The Tor Browser: comparison toolkit/mozapps/update/tests/unit_aus_update/head_update.js

comparison: toolkit/mozapps/update/tests/unit_aus_update/head_update.js

toolkit/mozapps/update/tests/unit_aus_update/head_update.js

branch: TOR_BUG_3246
changeset 7: 129ffea94266

equal deleted inserted replaced

--1:000000000000
+:1d546fbcc40d
+/* This Source Code Form is subject to the terms of the Mozilla Public
+* License, v. 2.0. If a copy of the MPL was not distributed with this
+* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+const INSTALL_LOCALE = "@AB_CD@";
+const MOZ_APP_NAME = "@MOZ_APP_NAME@";
+const BIN_SUFFIX = "@BIN_SUFFIX@";
+#ifdef XP_WIN
+// MOZ_APP_VENDOR is optional.
+// On Windows, if MOZ_APP_VENDOR is not defined the updates directory will be
+// located under %LOCALAPPDATA%\@MOZ_APP_BASENAME@\updates\TaskBarID
+#ifdef MOZ_APP_VENDOR
+const MOZ_APP_VENDOR = "@MOZ_APP_VENDOR@";
+#else
+const MOZ_APP_VENDOR = "";
+#endif
+// MOZ_APP_BASENAME is not optional for tests.
+const MOZ_APP_BASENAME = "@MOZ_APP_BASENAME@";
+#endif // XP_WIN
+const APP_INFO_NAME = "XPCShell";
+const APP_INFO_VENDOR = "Mozilla";
+#ifdef XP_UNIX
+const APP_BIN_SUFFIX = "-bin";
+#else
+const APP_BIN_SUFFIX = "@BIN_SUFFIX@";
+#endif
+#ifdef XP_WIN
+const IS_WIN = true;
+#else
+const IS_WIN = false;
+#endif
+#ifdef XP_MACOSX
+const IS_MACOSX = true;
+#ifdef MOZ_SHARK
+const IS_SHARK = true;
+#else
+const IS_SHARK = false;
+#endif
+#else
+const IS_MACOSX = false;
+#endif
+#ifdef XP_UNIX
+const IS_UNIX = true;
+#else
+const IS_UNIX = false;
+#endif
+#ifdef ANDROID
+const IS_ANDROID = true;
+#else
+const IS_ANDROID = false;
+#endif
+#ifdef MOZ_WIDGET_GONK
+const IS_TOOLKIT_GONK = true;
+#else
+const IS_TOOLKIT_GONK = false;
+#endif
+const USE_EXECV = IS_UNIX && !IS_MACOSX;
+#ifdef MOZ_VERIFY_MAR_SIGNATURE
+const IS_MAR_CHECKS_ENABLED = true;
+#else
+const IS_MAR_CHECKS_ENABLED = false;
+#endif
+const URL_HOST = "http://localhost";
+const FILE_APP_BIN = MOZ_APP_NAME + APP_BIN_SUFFIX;
+const FILE_COMPLETE_EXE = "complete.exe";
+const FILE_COMPLETE_MAR = "complete.mar";
+const FILE_HELPER_BIN = "TestAUSHelper" + BIN_SUFFIX;
+const FILE_MAINTENANCE_SERVICE_BIN = "maintenanceservice.exe";
+const FILE_MAINTENANCE_SERVICE_INSTALLER_BIN = "maintenanceservice_installer.exe";
+const FILE_OLD_VERSION_MAR = "old_version.mar";
+const FILE_PARTIAL_EXE = "partial.exe";
+const FILE_PARTIAL_MAR = "partial.mar";
+const FILE_UPDATER_BIN = "updater" + BIN_SUFFIX;
+const FILE_UPDATER_INI_BAK = "updater.ini.bak";
+const FILE_WRONG_CHANNEL_MAR = "wrong_product_channel.mar";
+const LOG_COMPLETE_SUCCESS = "complete_log_success";
+const LOG_PARTIAL_SUCCESS  = "partial_log_success";
+const LOG_PARTIAL_FAILURE  = "partial_log_failure";
+const LOG_SWITCH_SUCCESS = "rename_file: proceeding to rename the directory\n" +
+"rename_file: proceeding to rename the directory\n" +
+"Now, remove the tmpDir\n" +
+"succeeded\n" +
+"calling QuitProgressUI";
+const ERR_RENAME_FILE = "rename_file: failed to rename file";
+const ERR_UNABLE_OPEN_DEST = "unable to open destination file";
+const ERR_BACKUP_DISCARD = "backup_discard: unable to remove";
+const LOG_SVC_SUCCESSFUL_LAUNCH = "Process was started... waiting on result.";
+// All we care about is that the last modified time has changed so that Mac OS
+// X Launch Services invalidates its cache so the test allows up to one minute
+// difference in the last modified time.
+const MAC_MAX_TIME_DIFFERENCE = 60000;
+// Time to wait for the test helper process before continuing the test
+const TEST_HELPER_TIMEOUT = 100;
+// Time to wait for a check in the test before continuing the test
+const TEST_CHECK_TIMEOUT = 100;
+// How many of TEST_CHECK_TIMEOUT to wait before we abort the test.
+const MAX_TIMEOUT_RUNS = 2000;
+// Time in seconds the helper application should sleep.the helper's input and output files
+const HELPER_SLEEP_TIMEOUT = 180;
+// Maximum number of milliseconds the process that is launched can run before
+// the test will try to kill it.
+const APP_TIMER_TIMEOUT = 120000;
+#ifdef XP_WIN
+const PIPE_TO_NULL = ">nul";
+#else
+const PIPE_TO_NULL = "> /dev/null 2>&1";
+#endif
+// This default value will be overridden when using the http server.
+var gURLData = URL_HOST + "/";
+var gTestID;
+var gTestserver;
+var gRegisteredServiceCleanup;
+var gXHR;
+var gXHRCallback;
+var gUpdatePrompt;
+var gUpdatePromptCallback;
+var gCheckFunc;
+var gResponseBody;
+var gResponseStatusCode = 200;
+var gRequestURL;
+var gUpdateCount;
+var gUpdates;
+var gStatusCode;
+var gStatusText;
+var gStatusResult;
+var gProcess;
+var gAppTimer;
+var gHandle;
+var gGREDirOrig;
+var gAppDirOrig;
+var gServiceLaunchedCallbackLog = null;
+var gServiceLaunchedCallbackArgs = null;
+// Variables are used instead of contants so tests can override these values if
+// necessary.
+var gCallbackBinFile = "callback_app" + BIN_SUFFIX;
+var gCallbackArgs = ["./", "callback.log", "Test Arg 2", "Test Arg 3"];
+var gStageUpdate = false;
+var gSwitchApp = false;
+var gDisableReplaceFallback = false;
+var gUseTestAppDir = true;
+var gTimeoutRuns = 0;
+// Environment related globals
+var gShouldResetEnv = undefined;
+var gAddedEnvXRENoWindowsCrashDialog = false;
+var gEnvXPCOMDebugBreak;
+var gEnvXPCOMMemLeakLog;
+var gEnvDyldLibraryPath;
+var gEnvLdLibraryPath;
+// 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
+// run_test function.
+var DEBUG_AUS_TEST = true;
+// Never set DEBUG_TEST_LOG to true except when running tests locally or on the
+// try server since this will force a test that failed a parallel run to fail
+// when the same test runs non-parallel so the log from parallel test run can
+// be displayed in the log.
+var DEBUG_TEST_LOG = false;
+// Set to false to keep the log file from the failed parallel test run.
+var gDeleteLogFile = true;
+var gRealDump;
+var gTestLogText = "";
+var gPassed;
+#include ../shared.js
+var gTestFiles = [];
+var gTestDirs = [];
+// Common files for both successful and failed updates.
+var gTestFilesCommon = [
+{
+description      : "Should never change",
+fileName         : FILE_UPDATE_SETTINGS_INI,
+relPathDir       : "a/b/",
+originalContents : "ShouldNotBeReplaced\n",
+compareContents  : "ShouldNotBeReplaced\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : 0o767,
+comparePerms     : 0o767
+}, {
+description      : "Should never change",
+fileName         : "channel-prefs.js",
+relPathDir       : "a/b/defaults/pref/",
+originalContents : "ShouldNotBeReplaced\n",
+compareContents  : "ShouldNotBeReplaced\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : 0o767,
+comparePerms     : 0o767
+}];
+// Files for a complete successful update. This can be used for a complete
+// failed update by calling setTestFilesAndDirsForFailure.
+var gTestFilesCompleteSuccess = [
+{
+description      : "Added by update.manifest (add)",
+fileName         : "precomplete",
+relPathDir       : "",
+originalContents : null,
+compareContents  : null,
+originalFile     : "partial_precomplete",
+compareFile      : "complete_precomplete",
+originalPerms    : 0o666,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "searchpluginstext0",
+relPathDir       : "a/b/searchplugins/",
+originalContents : "ToBeReplacedWithFromComplete\n",
+compareContents  : "FromComplete\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : 0o775,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "searchpluginspng1.png",
+relPathDir       : "a/b/searchplugins/",
+originalContents : null,
+compareContents  : null,
+originalFile     : null,
+compareFile      : "complete.png",
+originalPerms    : null,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "searchpluginspng0.png",
+relPathDir       : "a/b/searchplugins/",
+originalContents : null,
+compareContents  : null,
+originalFile     : "partial.png",
+compareFile      : "complete.png",
+originalPerms    : 0o666,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "removed-files",
+relPathDir       : "a/b/",
+originalContents : null,
+compareContents  : null,
+originalFile     : "partial_removed-files",
+compareFile      : "complete_removed-files",
+originalPerms    : 0o666,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest if the parent directory " +
+"exists (add-if)",
+fileName         : "extensions1text0",
+relPathDir       : "a/b/distribution/extensions/extensions1/",
+originalContents : null,
+compareContents  : "FromComplete\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : null,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest if the parent directory " +
+"exists (add-if)",
+fileName         : "extensions1png1.png",
+relPathDir       : "a/b/distribution/extensions/extensions1/",
+originalContents : null,
+compareContents  : null,
+originalFile     : "partial.png",
+compareFile      : "complete.png",
+originalPerms    : 0o666,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest if the parent directory " +
+"exists (add-if)",
+fileName         : "extensions1png0.png",
+relPathDir       : "a/b/distribution/extensions/extensions1/",
+originalContents : null,
+compareContents  : null,
+originalFile     : null,
+compareFile      : "complete.png",
+originalPerms    : null,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest if the parent directory " +
+"exists (add-if)",
+fileName         : "extensions0text0",
+relPathDir       : "a/b/distribution/extensions/extensions0/",
+originalContents : "ToBeReplacedWithFromComplete\n",
+compareContents  : "FromComplete\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : null,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest if the parent directory " +
+"exists (add-if)",
+fileName         : "extensions0png1.png",
+relPathDir       : "a/b/distribution/extensions/extensions0/",
+originalContents : null,
+compareContents  : null,
+originalFile     : null,
+compareFile      : "complete.png",
+originalPerms    : null,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest if the parent directory " +
+"exists (add-if)",
+fileName         : "extensions0png0.png",
+relPathDir       : "a/b/distribution/extensions/extensions0/",
+originalContents : null,
+compareContents  : null,
+originalFile     : null,
+compareFile      : "complete.png",
+originalPerms    : null,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "exe0.exe",
+relPathDir       : "a/b/",
+originalContents : null,
+compareContents  : null,
+originalFile     : FILE_HELPER_BIN,
+compareFile      : FILE_COMPLETE_EXE,
+originalPerms    : 0o777,
+comparePerms     : 0o755
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "10text0",
+relPathDir       : "a/b/1/10/",
+originalContents : "ToBeReplacedWithFromComplete\n",
+compareContents  : "FromComplete\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : 0o767,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "0exe0.exe",
+relPathDir       : "a/b/0/",
+originalContents : null,
+compareContents  : null,
+originalFile     : FILE_HELPER_BIN,
+compareFile      : FILE_COMPLETE_EXE,
+originalPerms    : 0o777,
+comparePerms     : 0o755
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "00text1",
+relPathDir       : "a/b/0/00/",
+originalContents : "ToBeReplacedWithFromComplete\n",
+compareContents  : "FromComplete\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : 0o677,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "00text0",
+relPathDir       : "a/b/0/00/",
+originalContents : "ToBeReplacedWithFromComplete\n",
+compareContents  : "FromComplete\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : 0o775,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "00png0.png",
+relPathDir       : "a/b/0/00/",
+originalContents : null,
+compareContents  : null,
+originalFile     : null,
+compareFile      : "complete.png",
+originalPerms    : 0o776,
+comparePerms     : 0o644
+}, {
+description      : "Removed by precomplete (remove)",
+fileName         : "20text0",
+relPathDir       : "a/b/2/20/",
+originalContents : "ToBeDeleted\n",
+compareContents  : null,
+originalFile     : null,
+compareFile      : null,
+originalPerms    : null,
+comparePerms     : null
+}, {
+description      : "Removed by precomplete (remove)",
+fileName         : "20png0.png",
+relPathDir       : "a/b/2/20/",
+originalContents : "ToBeDeleted\n",
+compareContents  : null,
+originalFile     : null,
+compareFile      : null,
+originalPerms    : null,
+comparePerms     : null
+}];
+// Concatenate the common files to the end of the array.
+gTestFilesCompleteSuccess = gTestFilesCompleteSuccess.concat(gTestFilesCommon);
+// Files for a partial successful update. This can be used for a partial failed
+// update by calling setTestFilesAndDirsForFailure.
+var gTestFilesPartialSuccess = [
+{
+description      : "Added by update.manifest (add)",
+fileName         : "precomplete",
+relPathDir       : "",
+originalContents : null,
+compareContents  : null,
+originalFile     : "complete_precomplete",
+compareFile      : "partial_precomplete",
+originalPerms    : 0o666,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "searchpluginstext0",
+relPathDir       : "a/b/searchplugins/",
+originalContents : "ToBeReplacedWithFromPartial\n",
+compareContents  : "FromPartial\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : 0o775,
+comparePerms     : 0o644
+}, {
+description      : "Patched by update.manifest if the file exists " +
+"(patch-if)",
+fileName         : "searchpluginspng1.png",
+relPathDir       : "a/b/searchplugins/",
+originalContents : null,
+compareContents  : null,
+originalFile     : "complete.png",
+compareFile      : "partial.png",
+originalPerms    : 0o666,
+comparePerms     : 0o666
+}, {
+description      : "Patched by update.manifest if the file exists " +
+"(patch-if)",
+fileName         : "searchpluginspng0.png",
+relPathDir       : "a/b/searchplugins/",
+originalContents : null,
+compareContents  : null,
+originalFile     : "complete.png",
+compareFile      : "partial.png",
+originalPerms    : 0o666,
+comparePerms     : 0o666
+}, {
+description      : "Added by update.manifest if the parent directory " +
+"exists (add-if)",
+fileName         : "extensions1text0",
+relPathDir       : "a/b/distribution/extensions/extensions1/",
+originalContents : null,
+compareContents  : "FromPartial\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : null,
+comparePerms     : 0o644
+}, {
+description      : "Patched by update.manifest if the parent directory " +
+"exists (patch-if)",
+fileName         : "extensions1png1.png",
+relPathDir       : "a/b/distribution/extensions/extensions1/",
+originalContents : null,
+compareContents  : null,
+originalFile     : "complete.png",
+compareFile      : "partial.png",
+originalPerms    : 0o666,
+comparePerms     : 0o666
+}, {
+description      : "Patched by update.manifest if the parent directory " +
+"exists (patch-if)",
+fileName         : "extensions1png0.png",
+relPathDir       : "a/b/distribution/extensions/extensions1/",
+originalContents : null,
+compareContents  : null,
+originalFile     : "complete.png",
+compareFile      : "partial.png",
+originalPerms    : 0o666,
+comparePerms     : 0o666
+}, {
+description      : "Added by update.manifest if the parent directory " +
+"exists (add-if)",
+fileName         : "extensions0text0",
+relPathDir       : "a/b/distribution/extensions/extensions0/",
+originalContents : "ToBeReplacedWithFromPartial\n",
+compareContents  : "FromPartial\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : 0o644,
+comparePerms     : 0o644
+}, {
+description      : "Patched by update.manifest if the parent directory " +
+"exists (patch-if)",
+fileName         : "extensions0png1.png",
+relPathDir       : "a/b/distribution/extensions/extensions0/",
+originalContents : null,
+compareContents  : null,
+originalFile     : "complete.png",
+compareFile      : "partial.png",
+originalPerms    : 0o644,
+comparePerms     : 0o644
+}, {
+description      : "Patched by update.manifest if the parent directory " +
+"exists (patch-if)",
+fileName         : "extensions0png0.png",
+relPathDir       : "a/b/distribution/extensions/extensions0/",
+originalContents : null,
+compareContents  : null,
+originalFile     : "complete.png",
+compareFile      : "partial.png",
+originalPerms    : 0o644,
+comparePerms     : 0o644
+}, {
+description      : "Patched by update.manifest (patch)",
+fileName         : "exe0.exe",
+relPathDir       : "a/b/",
+originalContents : null,
+compareContents  : null,
+originalFile     : FILE_COMPLETE_EXE,
+compareFile      : FILE_PARTIAL_EXE,
+originalPerms    : 0o755,
+comparePerms     : 0o755
+}, {
+description      : "Patched by update.manifest (patch)",
+fileName         : "0exe0.exe",
+relPathDir       : "a/b/0/",
+originalContents : null,
+compareContents  : null,
+originalFile     : FILE_COMPLETE_EXE,
+compareFile      : FILE_PARTIAL_EXE,
+originalPerms    : 0o755,
+comparePerms     : 0o755
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "00text0",
+relPathDir       : "a/b/0/00/",
+originalContents : "ToBeReplacedWithFromPartial\n",
+compareContents  : "FromPartial\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : 0o644,
+comparePerms     : 0o644
+}, {
+description      : "Patched by update.manifest (patch)",
+fileName         : "00png0.png",
+relPathDir       : "a/b/0/00/",
+originalContents : null,
+compareContents  : null,
+originalFile     : "complete.png",
+compareFile      : "partial.png",
+originalPerms    : 0o666,
+comparePerms     : 0o666
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "20text0",
+relPathDir       : "a/b/2/20/",
+originalContents : null,
+compareContents  : "FromPartial\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : null,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "20png0.png",
+relPathDir       : "a/b/2/20/",
+originalContents : null,
+compareContents  : null,
+originalFile     : null,
+compareFile      : "partial.png",
+originalPerms    : null,
+comparePerms     : 0o644
+}, {
+description      : "Added by update.manifest (add)",
+fileName         : "00text2",
+relPathDir       : "a/b/0/00/",
+originalContents : null,
+compareContents  : "FromPartial\n",
+originalFile     : null,
+compareFile      : null,
+originalPerms    : null,
+comparePerms     : 0o644
+}, {
+description      : "Removed by update.manifest (remove)",
+fileName         : "10text0",
+relPathDir       : "a/b/1/10/",
+originalContents : "ToBeDeleted\n",
+compareContents  : null,
+originalFile     : null,
+compareFile      : null,
+originalPerms    : null,
+comparePerms     : null
+}, {
+description      : "Removed by update.manifest (remove)",
+fileName         : "00text1",
+relPathDir       : "a/b/0/00/",
+originalContents : "ToBeDeleted\n",
+compareContents  : null,
+originalFile     : null,
+compareFile      : null,
+originalPerms    : null,
+comparePerms     : null
+}];
+// Concatenate the common files to the end of the array.
+gTestFilesPartialSuccess = gTestFilesPartialSuccess.concat(gTestFilesCommon);
+/**
+* The mar files used for the updater tests contain the following remove
+* operations.
+*
+* partial and complete test mar remove operations
+* -----------------------------------------------
+* remove "text1"
+* remove "text0"
+* rmrfdir "9/99/"
+* rmdir "9/99/"
+* rmrfdir "9/98/"
+* rmrfdir "9/97/"
+* rmrfdir "9/96/"
+* rmrfdir "9/95/"
+* rmrfdir "9/95/"
+* rmrfdir "9/94/"
+* rmdir "9/94/"
+* rmdir "9/93/"
+* rmdir "9/92/"
+* rmdir "9/91/"
+* rmdir "9/90/"
+* rmdir "9/90/"
+* rmrfdir "8/89/"
+* rmdir "8/89/"
+* rmrfdir "8/88/"
+* rmrfdir "8/87/"
+* rmrfdir "8/86/"
+* rmrfdir "8/85/"
+* rmrfdir "8/85/"
+* rmrfdir "8/84/"
+* rmdir "8/84/"
+* rmdir "8/83/"
+* rmdir "8/82/"
+* rmdir "8/81/"
+* rmdir "8/80/"
+* rmdir "8/80/"
+* rmrfdir "7/"
+* rmdir "6/"
+* remove "5/text1"
+* remove "5/text0"
+* rmrfdir "5/"
+* remove "4/text1"
+* remove "4/text0"
+* remove "4/exe0.exe"
+* rmdir "4/"
+* remove "3/text1"
+* remove "3/text0"
+*
+* partial test mar additional remove operations
+* ---------------------------------------------
+* remove "0/00/00text1"
+* remove "1/10/10text0"
+* rmdir "1/10/"
+* rmdir "1/"
+*/
+var gTestDirsCommon = [
+{
+relPathDir   : "a/b/3/",
+dirRemoved   : false,
+files        : ["3text0", "3text1"],
+filesRemoved : true
+}, {
+relPathDir   : "a/b/4/",
+dirRemoved   : true,
+files        : ["4text0", "4text1"],
+filesRemoved : true
+}, {
+relPathDir   : "a/b/5/",
+dirRemoved   : true,
+files        : ["5test.exe", "5text0", "5text1"],
+filesRemoved : true
+}, {
+relPathDir   : "a/b/6/",
+dirRemoved   : true
+}, {
+relPathDir   : "a/b/7/",
+dirRemoved   : true,
+files        : ["7text0", "7text1"],
+subDirs      : ["70/", "71/"],
+subDirFiles  : ["7xtest.exe", "7xtext0", "7xtext1"]
+}, {
+relPathDir   : "a/b/8/",
+dirRemoved   : false
+}, {
+relPathDir   : "a/b/8/80/",
+dirRemoved   : true
+}, {
+relPathDir   : "a/b/8/81/",
+dirRemoved   : false,
+files        : ["81text0", "81text1"]
+}, {
+relPathDir   : "a/b/8/82/",
+dirRemoved   : false,
+subDirs      : ["820/", "821/"]
+}, {
+relPathDir   : "a/b/8/83/",
+dirRemoved   : true
+}, {
+relPathDir   : "a/b/8/84/",
+dirRemoved   : true
+}, {
+relPathDir   : "a/b/8/85/",
+dirRemoved   : true
+}, {
+relPathDir   : "a/b/8/86/",
+dirRemoved   : true,
+files        : ["86text0", "86text1"]
+}, {
+relPathDir   : "a/b/8/87/",
+dirRemoved   : true,
+subDirs      : ["870/", "871/"],
+subDirFiles  : ["87xtext0", "87xtext1"]
+}, {
+relPathDir   : "a/b/8/88/",
+dirRemoved   : true
+}, {
+relPathDir   : "a/b/8/89/",
+dirRemoved   : true
+}, {
+relPathDir   : "a/b/9/90/",
+dirRemoved   : true
+}, {
+relPathDir   : "a/b/9/91/",
+dirRemoved   : false,
+files        : ["91text0", "91text1"]
+}, {
+relPathDir   : "a/b/9/92/",
+dirRemoved   : false,
+subDirs      : ["920/", "921/"]
+}, {
+relPathDir   : "a/b/9/93/",
+dirRemoved   : true
+}, {
+relPathDir   : "a/b/9/94/",
+dirRemoved   : true
+}, {
+relPathDir   : "a/b/9/95/",
+dirRemoved   : true
+}, {
+relPathDir   : "a/b/9/96/",
+dirRemoved   : true,
+files        : ["96text0", "96text1"]
+}, {
+relPathDir   : "a/b/9/97/",
+dirRemoved   : true,
+subDirs      : ["970/", "971/"],
+subDirFiles  : ["97xtext0", "97xtext1"]
+}, {
+relPathDir   : "a/b/9/98/",
+dirRemoved   : true
+}, {
+relPathDir   : "a/b/9/99/",
+dirRemoved   : true
+}];
+// Directories for a complete successful update. This array can be used for a
+// complete failed update by calling setTestFilesAndDirsForFailure.
+var gTestDirsCompleteSuccess = [
+{
+description  : "Removed by precomplete (rmdir)",
+relPathDir   : "a/b/2/20/",
+dirRemoved   : true
+}, {
+description  : "Removed by precomplete (rmdir)",
+relPathDir   : "a/b/2/",
+dirRemoved   : true
+}];
+// Concatenate the common files to the beginning of the array.
+gTestDirsCompleteSuccess = gTestDirsCommon.concat(gTestDirsCompleteSuccess);
+// Directories for a partial successful update. This array can be used for a
+// partial failed update by calling setTestFilesAndDirsForFailure.
+var gTestDirsPartialSuccess = [
+{
+description  : "Removed by update.manifest (rmdir)",
+relPathDir   : "a/b/1/10/",
+dirRemoved   : true
+}, {
+description  : "Removed by update.manifest (rmdir)",
+relPathDir   : "a/b/1/",
+dirRemoved   : true
+}];
+// Concatenate the common files to the beginning of the array.
+gTestDirsPartialSuccess = gTestDirsCommon.concat(gTestDirsPartialSuccess);
+// Extra directories to check for existence for both complete and partial
+// updates. Whether they exist or not is set when calling setupUpdaterTest.
+var gTestExtraDirs = [
+{
+relPathDir   : DIR_UPDATED,
+dirExists    : false
+}, {
+relPathDir   : DIR_TOBEDELETED,
+dirExists    : false
+}];
+// This makes it possible to run most tests on xulrunner where the update
+// channel default preference is not set.
+if (MOZ_APP_NAME == "xulrunner") {
+try {
+gDefaultPrefBranch.getCharPref(PREF_APP_UPDATE_CHANNEL);
+} catch (e) {
+setUpdateChannel("test_channel");
+}
+}
+/**
+* Helper function for setting up the test environment.
+*/
+function setupTestCommon() {
+logTestInfo("start - general test setup");
+do_test_pending();
+if (gTestID) {
+do_throw("setupTestCommon should only be called once!");
+}
+let caller = Components.stack.caller;
+gTestID = caller.filename.toString().split("/").pop().split(".")[0];
+if (DEBUG_TEST_LOG) {
+let logFile = do_get_file(gTestID + ".log", true);
+if (logFile.exists()) {
+gPassed = false;
+logTestInfo("start - dumping previous test run log");
+logTestInfo("\n" + readFile(logFile) + "\n");
+logTestInfo("finish - dumping previous test run log");
+if (gDeleteLogFile) {
+logFile.remove(false);
+}
+do_throw("The parallel run of this test failed. Failing non-parallel " +
+"test so the log from the parallel run can be displayed in " +
+"non-parallel log.")
+} else {
+gRealDump = dump;
+dump = dumpOverride;
+}
+}
+// Don't attempt to show a prompt when an update finishes.
+Services.prefs.setBoolPref(PREF_APP_UPDATE_SILENT, true);
+gGREDirOrig = getGREDir();
+gAppDirOrig = getAppBaseDir();
+let applyDir = getApplyDirFile(null, true).parent;
+// Try to remove the directory used to apply updates and the updates directory
+// on platforms other than Windows. Since the test hasn't ran yet and the
+// directory shouldn't exist finished this is non-fatal for the test.
+if (applyDir.exists()) {
+logTestInfo("attempting to remove directory. Path: " + applyDir.path);
+try {
+removeDirRecursive(applyDir);
+} catch (e) {
+logTestInfo("non-fatal error removing directory. Path: " +
+applyDir.path + ", Exception: " + e);
+}
+}
+// adjustGeneralPaths registers a cleanup function that calls end_test when
+// it is defined as a function.
+adjustGeneralPaths();
+// Remove the updates directory on Windows which is located outside of the
+// application directory after the call to adjustGeneralPaths has set it up.
+// Since the test hasn't ran yet and the directory shouldn't exist finished
+// this is non-fatal for the test.
+if (IS_WIN) {
+let updatesDir = getMockUpdRootD();
+if (updatesDir.exists())  {
+logTestInfo("attempting to remove directory. Path: " + updatesDir.path);
+try {
+removeDirRecursive(updatesDir);
+} catch (e) {
+logTestInfo("non-fatal error removing directory. Path: " +
+updatesDir.path + ", Exception: " + e);
+}
+}
+}
+logTestInfo("finish - general test setup");
+}
+/**
+* Nulls out the most commonly used global vars used by tests to prevent leaks
+* as needed and attempts to restore the system to its original state.
+*/
+function cleanupTestCommon() {
+logTestInfo("start - general test cleanup");
+// Force the update manager to reload the update data to prevent it from
+// writing the old data to the files that have just been removed.
+reloadUpdateManagerData();
+if (gChannel) {
+gPrefRoot.removeObserver(PREF_APP_UPDATE_CHANNEL, observer);
+}
+// Call app update's observe method passing xpcom-shutdown to test that the
+// shutdown of app update runs without throwing or leaking. The observer
+// method is used directly instead of calling notifyObservers so components
+// outside of the scope of this test don't assert and thereby cause app update
+// tests to fail.
+gAUS.observe(null, "xpcom-shutdown", "");
+if (gXHR) {
+gXHRCallback     = null;
+gXHR.responseXML = null;
+// null out the event handlers to prevent a mFreeCount leak of 1
+gXHR.onerror     = null;
+gXHR.onload      = null;
+gXHR.onprogress  = null;
+gXHR             = null;
+}
+gTestserver = null;
+if (IS_UNIX) {
+// This will delete the launch script if it exists.
+getLaunchScript();
+}
+if (IS_WIN && MOZ_APP_BASENAME) {
+let appDir = getApplyDirFile(null, true);
+let vendor = MOZ_APP_VENDOR ? MOZ_APP_VENDOR : "Mozilla";
+const REG_PATH = "SOFTWARE\\" + vendor + "\\" + MOZ_APP_BASENAME +
+"\\TaskBarIDs";
+let key = AUS_Cc["@mozilla.org/windows-registry-key;1"].
+createInstance(AUS_Ci.nsIWindowsRegKey);
+try {
+key.open(AUS_Ci.nsIWindowsRegKey.ROOT_KEY_LOCAL_MACHINE, REG_PATH,
+AUS_Ci.nsIWindowsRegKey.ACCESS_ALL);
+if (key.hasValue(appDir.path)) {
+key.removeValue(appDir.path);
+}
+} catch (e) {
+}
+try {
+key.open(AUS_Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER, REG_PATH,
+AUS_Ci.nsIWindowsRegKey.ACCESS_ALL);
+if (key.hasValue(appDir.path)) {
+key.removeValue(appDir.path);
+}
+} catch (e) {
+}
+}
+// The updates directory is located outside of the application directory on
+// Windows so it also needs to be removed.
+if (IS_WIN) {
+let updatesDir = getMockUpdRootD();
+// Try to remove the directory used to apply updates. Since the test has
+// already finished this is non-fatal for the test.
+if (updatesDir.exists()) {
+logTestInfo("attempting to remove directory. Path: " + updatesDir.path);
+try {
+removeDirRecursive(updatesDir);
+} catch (e) {
+logTestInfo("non-fatal error removing directory. Path: " +
+updatesDir.path + ", Exception: " + e);
+}
+}
+}
+let applyDir = getApplyDirFile(null, true).parent;
+// Try to remove the directory used to apply updates. Since the test has
+// already finished this is non-fatal for the test.
+if (applyDir.exists()) {
+logTestInfo("attempting to remove directory. Path: " + applyDir.path);
+try {
+removeDirRecursive(applyDir);
+} catch (e) {
+logTestInfo("non-fatal error removing directory. Path: " +
+applyDir.path + ", Exception: " + e);
+}
+}
+resetEnvironment();
+logTestInfo("finish - general test cleanup");
+if (gRealDump) {
+dump = gRealDump;
+gRealDump = null;
+}
+if (DEBUG_TEST_LOG && !gPassed) {
+let fos = AUS_Cc["@mozilla.org/network/file-output-stream;1"].
+createInstance(AUS_Ci.nsIFileOutputStream);
+let logFile = do_get_file(gTestID + ".log", true);
+if (!logFile.exists()) {
+logFile.create(AUS_Ci.nsILocalFile.NORMAL_FILE_TYPE, PERMS_FILE);
+}
+fos.init(logFile, MODE_WRONLY | MODE_CREATE | MODE_APPEND, PERMS_FILE, 0);
+fos.write(gTestLogText, gTestLogText.length);
+fos.close();
+}
+if (DEBUG_TEST_LOG) {
+gTestLogText = null;
+} else {
+let logFile = do_get_file(gTestID + ".log", true);
+if (logFile.exists()) {
+logFile.remove(false);
+}
+}
+}
+/**
+* Helper function to store the log output of calls to dump in a variable so the
+* values can be written to a file for a parallel run of a test and printed to
+* the log file when the test runs synchronously.
+*/
+function dumpOverride(aText) {
+gTestLogText += aText;
+gRealDump(aText);
+}
+/**
+* Helper function that calls do_test_finished that tracks whether a parallel
+* run of a test passed when it runs synchronously so the log output can be
+* inspected.
+*/
+function doTestFinish() {
+if (gPassed === undefined) {
+gPassed = true;
+}
+do_test_finished();
+}
+/**
+* Sets the most commonly used preferences used by tests
+*/
+function setDefaultPrefs() {
+Services.prefs.setBoolPref(PREF_APP_UPDATE_ENABLED, true);
+Services.prefs.setBoolPref(PREF_APP_UPDATE_METRO_ENABLED, true);
+// Don't display UI for a successful installation. Some apps may not set this
+// pref to false like Firefox does.
+Services.prefs.setBoolPref(PREF_APP_UPDATE_SHOW_INSTALLED_UI, false);
+// Enable Update logging
+Services.prefs.setBoolPref(PREF_APP_UPDATE_LOG, true);
+}
+/**
+* Helper function for updater binary tests that sets the appropriate values
+* to check for update failures.
+*/
+function setTestFilesAndDirsForFailure() {
+gTestFiles.forEach(function STFADFF_Files(aTestFile) {
+aTestFile.compareContents = aTestFile.originalContents;
+aTestFile.compareFile = aTestFile.originalFile;
+aTestFile.comparePerms = aTestFile.originalPerms;
+});
+gTestDirs.forEach(function STFADFF_Dirs(aTestDir) {
+aTestDir.dirRemoved = false;
+if (aTestDir.filesRemoved) {
+aTestDir.filesRemoved = false;
+}
+});
+}
+/**
+* Initializes the most commonly used settings and creates an instance of the
+* update service stub.
+*/
+function standardInit() {
+createAppInfo("xpcshell@tests.mozilla.org", APP_INFO_NAME, "1.0", "2.0");
+setDefaultPrefs();
+// Initialize the update service stub component
+initUpdateServiceStub();
+}
+/**
+* Custom path handler for the http server
+*
+* @param   aMetadata
+*          The http metadata for the request.
+* @param   aResponse
+*          The http response for the request.
+*/
+function pathHandler(aMetadata, aResponse) {
+aResponse.setHeader("Content-Type", "text/xml", false);
+aResponse.setStatusLine(aMetadata.httpVersion, gResponseStatusCode, "OK");
+aResponse.bodyOutputStream.write(gResponseBody, gResponseBody.length);
+}
+/**
+* Helper function for getting the application version from the application.ini
+* file. This will look in both the GRE and the application directories for the
+* application.ini file.
+*
+* @return  The version string from the application.ini file.
+* @throws  If the application.ini file is not found.
+*/
+function getAppVersion() {
+// Read the application.ini and use its application version.
+let iniFile = gGREDirOrig.clone();
+iniFile.append("application.ini");
+if (!iniFile.exists()) {
+iniFile = gAppDirOrig.clone();
+iniFile.append("application.ini");
+}
+if (!iniFile.exists()) {
+do_throw("Unable to find application.ini!");
+}
+let iniParser = AUS_Cc["@mozilla.org/xpcom/ini-parser-factory;1"].
+getService(AUS_Ci.nsIINIParserFactory).
+createINIParser(iniFile);
+return iniParser.getString("App", "Version");
+}
+/**
+* Helper function for getting the relative path to the directory where the
+* application binary is located (e.g. <test_file_leafname>/dir.app/).
+*
+* Note: The dir.app subdirectory under <test_file_leafname> is needed for
+*       platforms other than Mac OS X so the tests can run in parallel due to
+*       update staging creating a lock file named moz_update_in_progress.lock in
+*       the parent directory of the installation directory.
+*
+* @return  The relative path to the directory where application binary is
+*          located.
+*/
+function getApplyDirPath() {
+return gTestID + "/dir.app/";
+}
+/**
+* Helper function for getting the nsIFile for a file in the directory where the
+* update will be applied.
+*
+* The files for the update are located two directories below the apply to
+* directory since Mac OS X sets the last modified time for the root directory
+* to the current time and if the update changes any files in the root directory
+* then it wouldn't be possible to test (bug 600098).
+*
+* @param   aRelPath (optional)
+*          The relative path to the file or directory to get from the root of
+*          the test's directory. If not specified the test's directory will be
+*          returned.
+* @param   aAllowNonexistent (optional)
+*          Whether the file must exist. If false or not specified the file must
+*          exist or the function will throw.
+* @return  The nsIFile for the file in the directory where the update will be
+*          applied.
+*/
+function getApplyDirFile(aRelPath, aAllowNonexistent) {
+let relpath = getApplyDirPath() + (aRelPath ? aRelPath : "");
+return do_get_file(relpath, aAllowNonexistent);
+}
+/**
+* Helper function for getting the relative path to the directory where the
+* test data files are located.
+*
+* @return  The relative path to the directory where the test data files are
+*          located.
+*/
+function getTestDirPath() {
+return "../data/";
+}
+/**
+* Helper function for getting the nsIFile for a file in the test data
+* directory.
+*
+* @param   aRelPath (optional)
+*          The relative path to the file or directory to get from the root of
+*          the test's data directory. If not specified the test's data
+*          directory will be returned.
+* @return  The nsIFile for the file in the test data directory.
+* @throws  If the file or directory does not exist.
+*/
+function getTestDirFile(aRelPath) {
+let relpath = getTestDirPath() + (aRelPath ? aRelPath : "");
+return do_get_file(relpath, false);
+}
+/**
+* Helper function for getting the directory that was updated. This can either
+* be the directory where the application binary is located or the directory
+* that contains the staged update.
+*/
+function getUpdatedDirPath() {
+return getApplyDirPath() + (gStageUpdate ? DIR_UPDATED +  "/" : "");
+}
+#ifdef XP_WIN
+XPCOMUtils.defineLazyGetter(this, "gInstallDirPathHash",
+function test_gInstallDirPathHash() {
+// Figure out where we should check for a cached hash value
+if (!MOZ_APP_BASENAME)
+return null;
+let vendor = MOZ_APP_VENDOR ? MOZ_APP_VENDOR : "Mozilla";
+let appDir = getApplyDirFile(null, true);
+const REG_PATH = "SOFTWARE\\" + vendor + "\\" + MOZ_APP_BASENAME +
+"\\TaskBarIDs";
+let regKey = AUS_Cc["@mozilla.org/windows-registry-key;1"].
+createInstance(AUS_Ci.nsIWindowsRegKey);
+try {
+regKey.open(AUS_Ci.nsIWindowsRegKey.ROOT_KEY_LOCAL_MACHINE, REG_PATH,
+AUS_Ci.nsIWindowsRegKey.ACCESS_ALL);
+regKey.writeStringValue(appDir.path, gTestID);
+return gTestID;
+} catch (e) {
+}
+try {
+regKey.create(AUS_Ci.nsIWindowsRegKey.ROOT_KEY_CURRENT_USER, REG_PATH,
+AUS_Ci.nsIWindowsRegKey.ACCESS_ALL);
+regKey.writeStringValue(appDir.path, gTestID);
+return gTestID;
+} catch (e) {
+logTestInfo("failed to create registry key. Registry Path: " + REG_PATH +
+", Key Name: " + appDir.path + ", Key Value: " + gTestID +
+", Exception " + e);
+}
+return null;
+});
+XPCOMUtils.defineLazyGetter(this, "gLocalAppDataDir",
+function test_gLocalAppDataDir() {
+const CSIDL_LOCAL_APPDATA = 0x1c;
+AUS_Cu.import("resource://gre/modules/ctypes.jsm");
+let lib = ctypes.open("shell32");
+let SHGetSpecialFolderPath = lib.declare("SHGetSpecialFolderPathW",
+ctypes.winapi_abi,
+ctypes.bool, /* bool(return) */
+ctypes.int32_t, /* HWND hwndOwner */
+ctypes.jschar.ptr, /* LPTSTR lpszPath */
+ctypes.int32_t, /* int csidl */
+ctypes.bool /* BOOL fCreate */);
+let aryPathLocalAppData = ctypes.jschar.array()(260);
+let rv = SHGetSpecialFolderPath(0, aryPathLocalAppData, CSIDL_LOCAL_APPDATA, false);
+lib.close();
+let pathLocalAppData = aryPathLocalAppData.readString(); // Convert the c-string to js-string
+let updatesDir = AUS_Cc["@mozilla.org/file/local;1"].
+createInstance(AUS_Ci.nsILocalFile);
+updatesDir.initWithPath(pathLocalAppData);
+return updatesDir;
+});
+XPCOMUtils.defineLazyGetter(this, "gProgFilesDir",
+function test_gProgFilesDir() {
+const CSIDL_PROGRAM_FILES = 0x26;
+AUS_Cu.import("resource://gre/modules/ctypes.jsm");
+let lib = ctypes.open("shell32");
+let SHGetSpecialFolderPath = lib.declare("SHGetSpecialFolderPathW",
+ctypes.winapi_abi,
+ctypes.bool, /* bool(return) */
+ctypes.int32_t, /* HWND hwndOwner */
+ctypes.jschar.ptr, /* LPTSTR lpszPath */
+ctypes.int32_t, /* int csidl */
+ctypes.bool /* BOOL fCreate */);
+let aryPathProgFiles = ctypes.jschar.array()(260);
+let rv = SHGetSpecialFolderPath(0, aryPathProgFiles, CSIDL_PROGRAM_FILES, false);
+lib.close();
+let pathProgFiles = aryPathProgFiles.readString(); // Convert the c-string to js-string
+let progFilesDir = AUS_Cc["@mozilla.org/file/local;1"].
+createInstance(AUS_Ci.nsILocalFile);
+progFilesDir.initWithPath(pathProgFiles);
+return progFilesDir;
+});
+/**
+* Helper function for getting the update root directory used by the tests. This
+* returns the same directory as returned by nsXREDirProvider::GetUpdateRootDir
+* in nsXREDirProvider.cpp so an application will be able to find the update
+* when running a test that launches the application.
+*/
+function getMockUpdRootD() {
+let localAppDataDir = gLocalAppDataDir.clone();
+let progFilesDir = gProgFilesDir.clone();
+let appDir = Services.dirsvc.get(XRE_EXECUTABLE_FILE, AUS_Ci.nsIFile).parent;
+let appDirPath = appDir.path;
+var relPathUpdates = "";
+if (gInstallDirPathHash && (MOZ_APP_VENDOR || MOZ_APP_BASENAME)) {
+relPathUpdates += (MOZ_APP_VENDOR ? MOZ_APP_VENDOR : MOZ_APP_BASENAME) +
+"\\" + DIR_UPDATES + "\\" + gInstallDirPathHash;
+}
+if (!relPathUpdates) {
+if (appDirPath.length > progFilesDir.path.length) {
+if (appDirPath.substr(0, progFilesDir.path.length) == progFilesDir.path) {
+if (MOZ_APP_VENDOR && MOZ_APP_BASENAME) {
+relPathUpdates += MOZ_APP_VENDOR + "\\" + MOZ_APP_BASENAME;
+} else {
+relPathUpdates += MOZ_APP_BASENAME;
+}
+relPathUpdates += appDirPath.substr(progFilesDir.path.length);
+}
+}
+}
+if (!relPathUpdates) {
+if (MOZ_APP_VENDOR && MOZ_APP_BASENAME) {
+relPathUpdates += MOZ_APP_VENDOR + "\\" + MOZ_APP_BASENAME;
+} else {
+relPathUpdates += MOZ_APP_BASENAME;
+}
+relPathUpdates += "\\" + MOZ_APP_NAME;
+}
+var updatesDir = AUS_Cc["@mozilla.org/file/local;1"].
+createInstance(AUS_Ci.nsILocalFile);
+updatesDir.initWithPath(localAppDataDir.path + "\\" + relPathUpdates);
+logTestInfo("returning UpdRootD Path: " + updatesDir.path);
+return updatesDir;
+}
+#else
+/**
+* Helper function for getting the update root directory used by the tests. This
+* returns the same directory as returned by nsXREDirProvider::GetUpdateRootDir
+* in nsXREDirProvider.cpp so an application will be able to find the update
+* when running a test that launches the application.
+*/
+function getMockUpdRootD() {
+return getApplyDirFile(DIR_BIN_REL_PATH, true);
+}
+#endif
+/**
+* Helper function for getting the nsIFile for the directory where the update
+* has been applied.
+*
+* This will be the same as getApplyDirFile for foreground updates, but will
+* point to a different file for the case of staged updates.
+*
+* Functions which attempt to access the files in the updated directory should
+* be using this instead of getApplyDirFile.
+*
+* @param   aRelPath (optional)
+*          The relative path to the file or directory to get from the root of
+*          the test's directory. If not specified the test's directory will be
+*          returned.
+* @param   aAllowNonexistent (optional)
+*          Whether the file must exist. If false or not specified the file must
+*          exist or the function will throw.
+* @return  The nsIFile for the directory where the update has been applied.
+*/
+function getTargetDirFile(aRelPath, aAllowNonexistent) {
+let relpath = getUpdatedDirPath() + (aRelPath ? aRelPath : "");
+return do_get_file(relpath, aAllowNonexistent);
+}
+if (IS_WIN) {
+const kLockFileName = "updated.update_in_progress.lock";
+/**
+* Helper function for locking a directory on Windows.
+*
+* @param   aDir
+*          The nsIFile for the directory to lock.
+*/
+function lockDirectory(aDir) {
+var file = aDir.clone();
+file.append(kLockFileName);
+file.create(file.NORMAL_FILE_TYPE, 0o444);
+file.QueryInterface(AUS_Ci.nsILocalFileWin);
+file.fileAttributesWin |= file.WFA_READONLY;
+file.fileAttributesWin &= ~file.WFA_READWRITE;
+logTestInfo("testing the successful creation of the lock file");
+do_check_true(file.exists());
+do_check_false(file.isWritable());
+}
+/**
+* Helper function for unlocking a directory on Windows.
+*
+* @param   aDir
+*          The nsIFile for the directory to unlock.
+*/
+function unlockDirectory(aDir) {
+var file = aDir.clone();
+file.append(kLockFileName);
+file.QueryInterface(AUS_Ci.nsILocalFileWin);
+file.fileAttributesWin |= file.WFA_READWRITE;
+file.fileAttributesWin &= ~file.WFA_READONLY;
+logTestInfo("removing and testing the successful removal of the lock file");
+file.remove(false);
+do_check_false(file.exists());
+}
+}
+/**
+* Helper function for updater tests for launching the updater binary to apply
+* a mar file.
+*
+* @param   aExpectedExitValue
+*          The expected exit value from the updater binary.
+* @param   aExpectedStatus
+*          The expected value of update.status when the test finishes.
+* @param   aCallback (optional)
+*          A callback function that will be called when this function finishes.
+*          If null no function will be called when this function finishes.
+*          If not specified the checkUpdateApplied function will be called when
+*          this function finishes.
+*/
+function runUpdate(aExpectedExitValue, aExpectedStatus, aCallback) {
+// Copy the updater binary to the updates directory.
+let binDir = gGREDirOrig.clone();
+let updater = binDir.clone();
+updater.append("updater.app");
+if (!updater.exists()) {
+updater = binDir.clone();
+updater.append(FILE_UPDATER_BIN);
+if (!updater.exists()) {
+do_throw("Unable to find updater binary!");
+}
+}
+let updatesDir = getUpdatesPatchDir();
+updater.copyToFollowingLinks(updatesDir, updater.leafName);
+let updateBin = updatesDir.clone();
+updateBin.append(updater.leafName);
+if (updateBin.leafName == "updater.app") {
+updateBin.append("Contents");
+updateBin.append("MacOS");
+updateBin.append("updater");
+if (!updateBin.exists()) {
+do_throw("Unable to find the updater executable!");
+}
+}
+let applyToDir = getApplyDirFile(null, true);
+let applyToDirPath = applyToDir.path;
+if (gStageUpdate || gSwitchApp) {
+applyToDirPath += "/" + DIR_UPDATED + "/";
+}
+if (IS_WIN) {
+// Convert to native path
+applyToDirPath = applyToDirPath.replace(/\//g, "\\");
+}
+let callbackApp = getApplyDirFile("a/b/" + gCallbackBinFile);
+callbackApp.permissions = PERMS_DIRECTORY;
+let args = [updatesDir.path, applyToDirPath, 0];
+if (gStageUpdate) {
+args[2] = -1;
+} else {
+if (gSwitchApp) {
+args[2] = "0/replace";
+}
+args = args.concat([callbackApp.parent.path, callbackApp.path]);
+args = args.concat(gCallbackArgs);
+}
+logTestInfo("running the updater: " + updateBin.path + " " + args.join(" "));
+let env = AUS_Cc["@mozilla.org/process/environment;1"].
+getService(AUS_Ci.nsIEnvironment);
+if (gDisableReplaceFallback) {
+env.set("MOZ_NO_REPLACE_FALLBACK", "1");
+}
+let process = AUS_Cc["@mozilla.org/process/util;1"].
+createInstance(AUS_Ci.nsIProcess);
+process.init(updateBin);
+process.run(true, args, args.length);
+if (gDisableReplaceFallback) {
+env.set("MOZ_NO_REPLACE_FALLBACK", "");
+}
+let status = readStatusFile();
+if (process.exitValue != aExpectedExitValue || status != aExpectedStatus) {
+if (process.exitValue != aExpectedExitValue) {
+logTestInfo("updater exited with unexpected value! Got: " +
+process.exitValue + ", Expected: " +  aExpectedExitValue);
+}
+if (status != aExpectedStatus) {
+logTestInfo("update status is not the expected status! Got: " + status +
+", Expected: " +  aExpectedStatus);
+}
+let updateLog = getUpdatesPatchDir();
+updateLog.append(FILE_UPDATE_LOG);
+logTestInfo("contents of " + updateLog.path + ":\n" +
+readFileBytes(updateLog).replace(/\r\n/g, "\n"));
+}
+logTestInfo("testing updater binary process exitValue against expected " +
+"exit value");
+do_check_eq(process.exitValue, aExpectedExitValue);
+logTestInfo("testing update status against expected status");
+do_check_eq(status, aExpectedStatus);
+if (aCallback !== null) {
+if (typeof(aCallback) == typeof(Function)) {
+aCallback();
+} else {
+checkUpdateApplied();
+}
+}
+}
+/**
+* Helper function for updater tests to stage an update.
+*/
+function stageUpdate() {
+logTestInfo("start - staging update");
+Services.obs.addObserver(gUpdateStagedObserver, "update-staged", false);
+setEnvironment();
+// Stage the update.
+AUS_Cc["@mozilla.org/updates/update-processor;1"].
+createInstance(AUS_Ci.nsIUpdateProcessor).
+processUpdate(gUpdateManager.activeUpdate);
+resetEnvironment();
+logTestInfo("finish - staging update");
+}
+/**
+* Helper function to check whether the maintenance service updater tests should
+* run. See bug 711660 for more details.
+*
+* @param  aFirstTest
+*         Whether this is the first test within the test.
+* @return true if the test should run and false if it shouldn't.
+*/
+function shouldRunServiceTest(aFirstTest) {
+// In case the machine is running an old maintenance service or if it
+// is not installed, and permissions exist to install it.  Then install
+// the newer bin that we have.
+attemptServiceInstall();
+let binDir = getGREDir();
+let updaterBin = binDir.clone();
+updaterBin.append(FILE_UPDATER_BIN);
+if (!updaterBin.exists()) {
+do_throw("Unable to find updater binary!");
+}
+let updaterBinPath = updaterBin.path;
+if (/ /.test(updaterBinPath)) {
+updaterBinPath = '"' + updaterBinPath + '"';
+}
+const REG_PATH = "SOFTWARE\\Mozilla\\MaintenanceService\\" +
+"3932ecacee736d366d6436db0f55bce4";
+let key = AUS_Cc["@mozilla.org/windows-registry-key;1"].
+createInstance(AUS_Ci.nsIWindowsRegKey);
+try {
+key.open(AUS_Ci.nsIWindowsRegKey.ROOT_KEY_LOCAL_MACHINE, REG_PATH,
+AUS_Ci.nsIWindowsRegKey.ACCESS_READ | key.WOW64_64);
+} catch (e) {
+#ifndef DISABLE_UPDATER_AUTHENTICODE_CHECK
+// The build system could sign the files and not have the test registry key
+// in which case we should fail the test by throwing so it can be fixed.
+if (isBinarySigned(updaterBinPath)) {
+do_throw("binary is signed but the test registry key does not exists!");
+}
+#endif
+logTestInfo("this test can only run on the buildbot build system at this " +
+"time.");
+return false;
+}
+// Check to make sure the service is installed
+let helperBin = getTestDirFile(FILE_HELPER_BIN);
+let args = ["wait-for-service-stop", "MozillaMaintenance", "10"];
+let process = AUS_Cc["@mozilla.org/process/util;1"].
+createInstance(AUS_Ci.nsIProcess);
+process.init(helperBin);
+logTestInfo("checking if the service exists on this machine.");
+process.run(true, args, args.length);
+if (process.exitValue == 0xEE) {
+do_throw("test registry key exists but this test can only run on systems " +
+"with the maintenance service installed.");
+} else {
+logTestInfo("service exists, return value: " + process.exitValue);
+}
+// If this is the first test in the series, then there is no reason the
+// service should be anything but stopped, so be strict here and throw
+// an error.
+if (aFirstTest && process.exitValue != 0) {
+do_throw("First test, check for service stopped state returned error " +
+process.exitValue);
+}
+#ifndef DISABLE_UPDATER_AUTHENTICODE_CHECK
+if (!isBinarySigned(updaterBinPath)) {
+logTestInfo("test registry key exists but this test can only run on " +
+"builds with signed binaries when " +
+"DISABLE_UPDATER_AUTHENTICODE_CHECK is not defined");
+do_throw("this test can only run on builds with signed binaries.");
+}
+#endif
+return true;
+}
+/**
+* Helper function to check whether the a binary is signed.
+*
+* @param  aBinPath The path to the file to check if it is signed.
+* @return true if the file is signed and false if it isn't.
+*/
+function isBinarySigned(aBinPath) {
+let helperBin = getTestDirFile(FILE_HELPER_BIN);
+let args = ["check-signature", aBinPath];
+let process = AUS_Cc["@mozilla.org/process/util;1"].
+createInstance(AUS_Ci.nsIProcess);
+process.init(helperBin);
+process.run(true, args, args.length);
+if (process.exitValue != 0) {
+logTestInfo("binary is not signed. " + FILE_HELPER_BIN + " returned " +
+process.exitValue + " for file " + aBinPath);
+return false;
+}
+return true;
+}
+/**
+* Helper function for asynchronously setting up the application files required
+* to launch the application for the updater tests by either copying or creating
+* symlinks for the files. This is needed for Windows debug builds which can
+* lock a file that is being copied so that the tests can run in parallel. After
+* the files have been copied the setupAppFilesFinished function will be called.
+*/
+function setupAppFilesAsync() {
+gTimeoutRuns++;
+try {
+setupAppFiles();
+} catch (e) {
+if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
+do_throw("Exceeded MAX_TIMEOUT_RUNS while trying to setup application " +
+"files. Exception: " + e);
+}
+do_timeout(TEST_CHECK_TIMEOUT, setupAppFilesAsync);
+return;
+}
+setupAppFilesFinished();
+}
+/**
+* Helper function for setting up the application files required to launch the
+* application for the updater tests by either copying or creating symlinks for
+* the files.
+*/
+function setupAppFiles() {
+logTestInfo("start - copying or creating symlinks for application files " +
+"for the test");
+let srcDir = getCurrentProcessDir();
+let destDir = getApplyDirFile(null, true);
+if (!destDir.exists()) {
+try {
+destDir.create(AUS_Ci.nsIFile.DIRECTORY_TYPE, PERMS_DIRECTORY);
+} catch (e) {
+logTestInfo("unable to create directory, Path: " + destDir.path +
+", Exception: " + e);
+do_throw(e);
+}
+}
+// Required files for the application or the test that aren't listed in the
+// dependentlibs.list file.
+let fileRelPaths = [FILE_APP_BIN, FILE_UPDATER_BIN,
+"application.ini", "dependentlibs.list"];
+// On Linux the updater.png must also be copied
+if (IS_UNIX && !IS_MACOSX) {
+fileRelPaths.push("icons/updater.png");
+}
+// Read the dependent libs file leafnames from the dependentlibs.list file
+// into the array.
+let deplibsFile = srcDir.clone();
+deplibsFile.append("dependentlibs.list");
+let istream = AUS_Cc["@mozilla.org/network/file-input-stream;1"].
+createInstance(AUS_Ci.nsIFileInputStream);
+istream.init(deplibsFile, 0x01, 0o444, 0);
+istream.QueryInterface(AUS_Ci.nsILineInputStream);
+let hasMore;
+let line = {};
+do {
+hasMore = istream.readLine(line);
+fileRelPaths.push(line.value);
+} while(hasMore);
+istream.close();
+fileRelPaths.forEach(function CMAF_FLN_FE(aFileRelPath) {
+copyFileToTestAppDir(aFileRelPath);
+});
+logTestInfo("finish - copying or creating symlinks for application files " +
+"for the test");
+}
+/**
+* Copies the specified files from the dist/bin directory into the test's
+* application directory.
+*
+* @param  aFileRelPath
+*         The relative path of the file to copy.
+*/
+function copyFileToTestAppDir(aFileRelPath) {
+let fileRelPath = aFileRelPath;
+let srcFile = gGREDirOrig.clone();
+let pathParts = fileRelPath.split("/");
+for (let i = 0; i < pathParts.length; i++) {
+if (pathParts[i]) {
+srcFile.append(pathParts[i]);
+}
+}
+if (IS_MACOSX && !srcFile.exists()) {
+logTestInfo("unable to copy file since it doesn't exist! Checking if " +
+fileRelPath + ".app exists. Path: " +
+srcFile.path);
+srcFile = gGREDirOrig.clone();
+for (let i = 0; i < pathParts.length; i++) {
+if (pathParts[i]) {
+srcFile.append(pathParts[i] + (pathParts.length - 1 == i ? ".app" : ""));
+}
+}
+fileRelPath = fileRelPath + ".app";
+}
+if (!srcFile.exists()) {
+do_throw("Unable to copy file since it doesn't exist! Path: " +
+srcFile.path);
+}
+// Symlink libraries. Note that the XUL library on Mac OS X doesn't have a
+// file extension and this will always be false on Windows.
+let shouldSymlink = (pathParts[pathParts.length - 1] == "XUL" ||
+fileRelPath.substr(fileRelPath.length - 3) == ".so" ||
+fileRelPath.substr(fileRelPath.length - 6) == ".dylib");
+let destFile = getApplyDirFile(DIR_BIN_REL_PATH + fileRelPath, true);
+if (!shouldSymlink) {
+if (!destFile.exists()) {
+try {
+srcFile.copyToFollowingLinks(destFile.parent, destFile.leafName);
+} catch (e) {
+// Just in case it is partially copied
+if (destFile.exists()) {
+try {
+destFile.remove(true);
+} catch (e) {
+logTestInfo("unable to remove file that failed to copy! Path: " +
+destFile.path);
+}
+}
+do_throw("Unable to copy file! Path: " + srcFile.path +
+", Exception: " + e);
+}
+}
+} else {
+try {
+if (destFile.exists()) {
+destFile.remove(false);
+}
+let ln = AUS_Cc["@mozilla.org/file/local;1"].createInstance(AUS_Ci.nsILocalFile);
+ln.initWithPath("/bin/ln");
+let process = AUS_Cc["@mozilla.org/process/util;1"].createInstance(AUS_Ci.nsIProcess);
+process.init(ln);
+let args = ["-s", srcFile.path, destFile.path];
+process.run(true, args, args.length);
+logTestInfo("verifying symlink. Path: " + destFile.path);
+do_check_true(destFile.isSymlink());
+} catch (e) {
+do_throw("Unable to create symlink for file! Path: " + srcFile.path +
+", Exception: " + e);
+}
+}
+}
+/**
+* Attempts to upgrade the maintenance service if permissions are allowed.
+* This is useful for XP where we have permission to upgrade in case an
+* older service installer exists.  Also if the user manually installed into
+* a unprivileged location.
+*/
+function attemptServiceInstall() {
+var version = AUS_Cc["@mozilla.org/system-info;1"]
+.getService(AUS_Ci.nsIPropertyBag2)
+.getProperty("version");
+var isVistaOrHigher = (parseFloat(version) >= 6.0);
+if (isVistaOrHigher) {
+return;
+}
+let binDir = getGREDir();
+let installerFile = binDir.clone();
+installerFile.append(FILE_MAINTENANCE_SERVICE_INSTALLER_BIN);
+if (!installerFile.exists()) {
+do_throw(FILE_MAINTENANCE_SERVICE_INSTALLER_BIN + " not found.");
+}
+let installerProcess = AUS_Cc["@mozilla.org/process/util;1"].
+createInstance(AUS_Ci.nsIProcess);
+installerProcess.init(installerFile);
+logTestInfo("starting installer process...");
+installerProcess.run(true, [], 0);
+}
+/**
+* Helper function for updater tests for launching the updater using the
+* maintenance service to apply a mar file.
+*
+* @param aInitialStatus
+*        The initial value of update.status.
+* @param aExpectedStatus
+*        The expected value of update.status when the test finishes.
+* @param aCheckSvcLog
+*        Whether the service log should be checked (optional).
+*/
+function runUpdateUsingService(aInitialStatus, aExpectedStatus, aCheckSvcLog) {
+// Check the service logs for a successful update
+function checkServiceLogs(aOriginalContents) {
+let contents = readServiceLogFile();
+logTestInfo("the contents of maintenanceservice.log:\n" + contents + "\n");
+do_check_neq(contents, aOriginalContents);
+do_check_neq(contents.indexOf(LOG_SVC_SUCCESSFUL_LAUNCH), -1);
+}
+function readServiceLogFile() {
+let file = AUS_Cc["@mozilla.org/file/directory_service;1"].
+getService(AUS_Ci.nsIProperties).
+get("CmAppData", AUS_Ci.nsIFile);
+file.append("Mozilla");
+file.append("logs");
+file.append("maintenanceservice.log");
+return readFile(file);
+}
+function waitServiceApps() {
+// maintenanceservice_installer.exe is started async during updates.
+waitForApplicationStop("maintenanceservice_installer.exe");
+// maintenanceservice_tmp.exe is started async from the service installer.
+waitForApplicationStop("maintenanceservice_tmp.exe");
+// In case the SCM thinks the service is stopped, but process still exists.
+waitForApplicationStop("maintenanceservice.exe");
+}
+function waitForServiceStop(aFailTest) {
+waitServiceApps();
+logTestInfo("waiting for service to stop if necessary...");
+// Use the helper bin to ensure the service is stopped. If not
+// stopped then wait for the service to be stopped (at most 120 seconds)
+let helperBin = getTestDirFile(FILE_HELPER_BIN);
+let helperBinArgs = ["wait-for-service-stop",
+"MozillaMaintenance",
+"120"];
+let helperBinProcess = AUS_Cc["@mozilla.org/process/util;1"].
+createInstance(AUS_Ci.nsIProcess);
+helperBinProcess.init(helperBin);
+logTestInfo("stopping service...");
+helperBinProcess.run(true, helperBinArgs, helperBinArgs.length);
+if (helperBinProcess.exitValue == 0xEE) {
+do_throw("The service does not exist on this machine.  Return value: " +
+helperBinProcess.exitValue);
+} else if (helperBinProcess.exitValue != 0) {
+if (aFailTest) {
+do_throw("maintenance service did not stop, last state: " +
+helperBinProcess.exitValue + ". Forcing test failure.");
+} else {
+logTestInfo("maintenance service did not stop, last state: " +
+helperBinProcess.exitValue + ".  May cause failures.");
+}
+} else {
+logTestInfo("service stopped.");
+}
+waitServiceApps();
+}
+function waitForApplicationStop(aApplication) {
+logTestInfo("waiting for " + aApplication + " to stop if " +
+"necessary...");
+// Use the helper bin to ensure the application is stopped.
+// If not, then wait for it to be stopped (at most 120 seconds)
+let helperBin = getTestDirFile(FILE_HELPER_BIN);
+let helperBinArgs = ["wait-for-application-exit",
+aApplication,
+"120"];
+let helperBinProcess = AUS_Cc["@mozilla.org/process/util;1"].
+createInstance(AUS_Ci.nsIProcess);
+helperBinProcess.init(helperBin);
+helperBinProcess.run(true, helperBinArgs, helperBinArgs.length);
+if (helperBinProcess.exitValue != 0) {
+do_throw(aApplication + " did not stop, last state: " +
+helperBinProcess.exitValue + ". Forcing test failure.");
+}
+}
+// Make sure the service from the previous test is already stopped.
+waitForServiceStop(true);
+// Prevent the cleanup function from begin run more than once
+if (gRegisteredServiceCleanup === undefined) {
+gRegisteredServiceCleanup = true;
+do_register_cleanup(function RUUS_cleanup() {
+resetEnvironment();
+// This will delete the app arguments log file if it exists.
+try {
+getAppArgsLogPath();
+} catch (e) {
+logTestInfo("unable to remove file during cleanup. Exception: " + e);
+}
+});
+}
+let svcOriginalLog;
+// Default to checking the service log if the parameter is not specified.
+if (aCheckSvcLog === undefined || aCheckSvcLog) {
+svcOriginalLog = readServiceLogFile();
+}
+let appArgsLogPath = getAppArgsLogPath();
+gServiceLaunchedCallbackLog = appArgsLogPath.replace(/^"|"$/g, "");
+let updatesDir = getUpdatesPatchDir();
+let file = updatesDir.clone();
+writeStatusFile(aInitialStatus);
+// sanity check
+do_check_eq(readStatusState(), aInitialStatus);
+writeVersionFile(DEFAULT_UPDATE_VERSION);
+gServiceLaunchedCallbackArgs = [
+"-no-remote",
+"-process-updates",
+"-dump-args",
+appArgsLogPath
+];
+if (gSwitchApp) {
+// We want to set the env vars again
+gShouldResetEnv = undefined;
+}
+setEnvironment();
+// There is a security check done by the service to make sure the updater
+// we are executing is the same as the one in the apply-to dir.
+// To make sure they match from tests we copy updater.exe to the apply-to dir.
+copyFileToTestAppDir(FILE_UPDATER_BIN);
+// The service will execute maintenanceservice_installer.exe and
+// will copy maintenanceservice.exe out of the same directory from
+// the installation directory.  So we need to make sure both of those
+// bins always exist in the installation directory.
+copyFileToTestAppDir(FILE_MAINTENANCE_SERVICE_BIN);
+copyFileToTestAppDir(FILE_MAINTENANCE_SERVICE_INSTALLER_BIN);
+let launchBin = getLaunchBin();
+let args = getProcessArgs(["-dump-args", appArgsLogPath]);
+let process = AUS_Cc["@mozilla.org/process/util;1"].
+createInstance(AUS_Ci.nsIProcess);
+process.init(launchBin);
+logTestInfo("launching " + launchBin.path + " " + args.join(" "));
+// Firefox does not wait for the service command to finish, but
+// we still launch the process sync to avoid intermittent failures with
+// the log file not being written out yet.
+// We will rely on watching the update.status file and waiting for the service
+// to stop to know the service command is done.
+process.run(true, args, args.length);
+resetEnvironment();
+function timerCallback(aTimer) {
+// Wait for the expected status
+let status = readStatusState();
+// status will probably always be equal to STATE_APPLYING but there is a
+// race condition where it would be possible on slower machines where status
+// could be equal to STATE_PENDING_SVC.
+if (status == STATE_APPLYING ||
+status == STATE_PENDING_SVC) {
+logTestInfo("still waiting to see the " + aExpectedStatus +
+" status, got " + status + " for now...");
+return;
+}
+// Make sure all of the logs are written out.
+waitForServiceStop(false);
+aTimer.cancel();
+aTimer = null;
+if (status != aExpectedStatus) {
+logTestInfo("update status is not the expected status! Got: " + status +
+", Expected: " +  aExpectedStatus);
+logTestInfo("update.status contents: " + readStatusFile());
+let updateLog = getUpdatesPatchDir();
+updateLog.append(FILE_UPDATE_LOG);
+logTestInfo("contents of " + updateLog.path + ":\n" +
+readFileBytes(updateLog).replace(/\r\n/g, "\n"));
+}
+logTestInfo("testing update status against expected status");
+do_check_eq(status, aExpectedStatus);
+if (aCheckSvcLog) {
+checkServiceLogs(svcOriginalLog);
+}
+checkUpdateFinished();
+}
+let timer = AUS_Cc["@mozilla.org/timer;1"].createInstance(AUS_Ci.nsITimer);
+timer.initWithCallback(timerCallback, 1000, timer.TYPE_REPEATING_SLACK);
+}
+/**
+* Gets the platform specific shell binary that is launched using nsIProcess and
+* in turn launches a binary used for the test (e.g. application, updater,
+* etc.). A shell is used so debug console output can be redirected to a file so
+* it doesn't end up in the test log.
+*
+* @return  nsIFile for the shell binary to launch using nsIProcess.
+* @throws  if the shell binary doesn't exist.
+*/
+function getLaunchBin() {
+let launchBin;
+if (IS_WIN) {
+launchBin = Services.dirsvc.get("WinD", AUS_Ci.nsIFile);
+launchBin.append("System32");
+launchBin.append("cmd.exe");
+} else {
+launchBin = AUS_Cc["@mozilla.org/file/local;1"].
+createInstance(AUS_Ci.nsILocalFile);
+launchBin.initWithPath("/bin/sh");
+}
+if (!launchBin.exists())
+do_throw(launchBin.path + " must exist to run this test!");
+return launchBin;
+}
+/**
+* Helper function that waits until the helper has completed its operations and
+* is in a sleep state before performing an update by calling doUpdate.
+*/
+function waitForHelperSleep() {
+gTimeoutRuns++;
+// Give the lock file process time to lock the file before updating otherwise
+// this test can fail intermittently on Windows debug builds.
+let output = getApplyDirFile("a/b/output", true);
+if (readFile(output) != "sleeping\n") {
+if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
+do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the helper to " +
+"finish its operation. Path: " + output.path);
+}
+do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+return;
+}
+try {
+output.remove(false);
+}
+catch (e) {
+if (gTimeoutRuns > MAX_TIMEOUT_RUNS) {
+do_throw("Exceeded MAX_TIMEOUT_RUNS while waiting for the helper " +
+"message file to no longer be in use. Path: " + output.path);
+}
+logTestInfo("failed to remove file. Path: " + output.path);
+do_timeout(TEST_HELPER_TIMEOUT, waitForHelperSleep);
+return;
+}
+doUpdate();
+}
+/**
+* Helper function that waits until the helper has finished its operations
+* before calling waitForHelperFinishFileUnlock to verify that the helper's
+* input and output directories are no longer in use.
+*/
+function waitForHelperFinished() {
+// Give the lock file process time to lock the file before updating otherwise
+// this test can fail intermittently on Windows debug builds.
+let output = getApplyDirFile("a/b/output", true);
+if (readFile(output) != "finished\n") {
+do_timeout(TEST_HELPER_TIMEOUT, waitForHelperFinished);
+return;
+}
+// Give the lock file process time to unlock the file before deleting the
+// input and output files.
+waitForHelperFinishFileUnlock();
+}
+/**
+* Helper function that waits until the helper's input and output files are no
+* longer in use before calling checkUpdate.
+*/
+function waitForHelperFinishFileUnlock() {
+try {
+let output = getApplyDirFile("a/b/output", true);
+if (output.exists()) {
+output.remove(false);
+}
+let input = getApplyDirFile("a/b/input", true);
+if (input.exists()) {
+input.remove(false);
+}
+} catch (e) {
+// Give the lock file process time to unlock the file before deleting the
+// input and output files.
+do_timeout(TEST_HELPER_TIMEOUT, waitForHelperFinishFileUnlock);
+return;
+}
+checkUpdate();
+}
+/**
+* Helper function to tell the helper to finish and exit its sleep state.
+*/
+function setupHelperFinish() {
+let input = getApplyDirFile("a/b/input", true);
+writeFile(input, "finish\n");
+waitForHelperFinished();
+}
+/**
+* Helper function for updater binary tests that creates the files and
+* directories used by the test.
+*
+* @param   aMarFile
+*          The mar file for the update test.
+*/
+function setupUpdaterTest(aMarFile, aUpdatedDirExists, aToBeDeletedDirExists) {
+let updatesPatchDir = getUpdatesPatchDir();
+if (!updatesPatchDir.exists()) {
+updatesPatchDir.create(AUS_Ci.nsIFile.DIRECTORY_TYPE, PERMS_DIRECTORY);
+}
+// Copy the mar that will be applied
+let mar = getTestDirFile(aMarFile);
+mar.copyToFollowingLinks(updatesPatchDir, FILE_UPDATE_ARCHIVE);
+createUpdateSettingsINI();
+let applyToDir = getApplyDirFile(null, true);
+gTestFiles.forEach(function SUT_TF_FE(aTestFile) {
+if (aTestFile.originalFile || aTestFile.originalContents) {
+let testDir = getApplyDirFile(aTestFile.relPathDir, true);
+if (!testDir.exists())
+testDir.create(AUS_Ci.nsIFile.DIRECTORY_TYPE, PERMS_DIRECTORY);
+let testFile;
+if (aTestFile.originalFile) {
+testFile = getTestDirFile(aTestFile.originalFile);
+testFile.copyToFollowingLinks(testDir, aTestFile.fileName);
+testFile = getApplyDirFile(aTestFile.relPathDir + aTestFile.fileName);
+} else {
+testFile = getApplyDirFile(aTestFile.relPathDir + aTestFile.fileName,
+true);
+writeFile(testFile, aTestFile.originalContents);
+}
+// Skip these tests on Windows and OS/2 since their
+// implementaions of chmod doesn't really set permissions.
+if (!IS_WIN && aTestFile.originalPerms) {
+testFile.permissions = aTestFile.originalPerms;
+// Store the actual permissions on the file for reference later after
+// setting the permissions.
+if (!aTestFile.comparePerms) {
+aTestFile.comparePerms = testFile.permissions;
+}
+}
+}
+});
+let helperBin = getTestDirFile(FILE_HELPER_BIN);
+let afterApplyBinDir = getApplyDirFile("a/b/", true);
+helperBin.copyToFollowingLinks(afterApplyBinDir, gCallbackBinFile);
+// Add the test directory that will be updated for a successful update or left
+// in the initial state for a failed update.
+gTestDirs.forEach(function SUT_TD_FE(aTestDir) {
+let testDir = getApplyDirFile(aTestDir.relPathDir, true);
+if (!testDir.exists()) {
+testDir.create(AUS_Ci.nsIFile.DIRECTORY_TYPE, PERMS_DIRECTORY);
+}
+if (aTestDir.files) {
+aTestDir.files.forEach(function SUT_TD_F_FE(aTestFile) {
+let testFile = getApplyDirFile(aTestDir.relPathDir + aTestFile, true);
+if (!testFile.exists()) {
+testFile.create(AUS_Ci.nsIFile.NORMAL_FILE_TYPE, PERMS_FILE);
+}
+});
+}
+if (aTestDir.subDirs) {
+aTestDir.subDirs.forEach(function SUT_TD_SD_FE(aSubDir) {
+let testSubDir = getApplyDirFile(aTestDir.relPathDir + aSubDir, true);
+if (!testSubDir.exists()) {
+testSubDir.create(AUS_Ci.nsIFile.DIRECTORY_TYPE, PERMS_DIRECTORY);
+}
+if (aTestDir.subDirFiles) {
+aTestDir.subDirFiles.forEach(function SUT_TD_SDF_FE(aTestFile) {
+let testFile = getApplyDirFile(aTestDir.relPathDir + aSubDir + aTestFile, true);
+if (!testFile.exists()) {
+testFile.create(AUS_Ci.nsIFile.NORMAL_FILE_TYPE, PERMS_FILE);
+}
+});
+}
+});
+}
+});
+gTestExtraDirs[0].dirExists = aUpdatedDirExists;
+gTestExtraDirs[1].dirExists = IS_WIN ? aToBeDeletedDirExists : false;
+}
+/**
+* Helper function for updater binary tests that creates the update-settings.ini
+* file.
+*/
+function createUpdateSettingsINI() {
+updateSettingsIni = getApplyDirFile(null, true);
+if (IS_MACOSX) {
+updateSettingsIni.append("Contents");
+updateSettingsIni.append("MacOS");
+}
+updateSettingsIni.append(FILE_UPDATE_SETTINGS_INI);
+writeFile(updateSettingsIni, UPDATE_SETTINGS_CONTENTS);
+}
+/**
+* Helper function for updater binary tests for verifying the contents of the
+* update log after a successful update.
+*
+* @param   aCompareLogFile
+*          The log file to compare the update log with.
+*/
+function checkUpdateLogContents(aCompareLogFile) {
+let updateLog = getUpdatesPatchDir();
+updateLog.append(FILE_UPDATE_LOG);
+let updateLogContents = readFileBytes(updateLog);
+// The channel-prefs.js is defined in gTestFilesCommon which will always be
+// located to the end of gTestFiles.
+if (gTestFiles.length > 1 &&
+	  gTestFiles[gTestFiles.length - 1].fileName == "channel-prefs.js" &&
+	  !gTestFiles[gTestFiles.length - 1].originalContents) {
+updateLogContents = updateLogContents.replace(/.* a\/b\/defaults\/.*/g, "");
+}
+if (gTestFiles.length > 2 &&
+	  gTestFiles[gTestFiles.length - 2].fileName == FILE_UPDATE_SETTINGS_INI &&
+	  !gTestFiles[gTestFiles.length - 2].originalContents) {
+updateLogContents = updateLogContents.replace(/.* a\/b\/update-settings.ini.*/g, "");
+}
+if (gStageUpdate) {
+// Skip the staged update messages
+updateLogContents = updateLogContents.replace(/Performing a staged update/, "");
+} else if (gSwitchApp) {
+// Skip the switch app request messages
+updateLogContents = updateLogContents.replace(/Performing a staged update/, "");
+updateLogContents = updateLogContents.replace(/Performing a replace request/, "");
+}
+// Skip the source/destination lines since they contain absolute paths.
+updateLogContents = updateLogContents.replace(/SOURCE DIRECTORY.*/g, "");
+updateLogContents = updateLogContents.replace(/DESTINATION DIRECTORY.*/g, "");
+// Skip lines that log failed attempts to open the callback executable.
+updateLogContents = updateLogContents.replace(/NS_main: callback app file .*/g, "");
+if (gSwitchApp) {
+// Remove the lines which contain absolute paths
+updateLogContents = updateLogContents.replace(/^Begin moving.*$/mg, "");
+if (IS_MACOSX) {
+// Remove the entire section about moving the precomplete file as it contains
+// absolute paths.
+updateLogContents = updateLogContents.replace(/\n/g, "%%%EOL%%%");
+updateLogContents = updateLogContents.replace(/Moving the precomplete file.*Finished moving the precomplete file/, "");
+updateLogContents = updateLogContents.replace(/%%%EOL%%%/g, "\n");
+}
+}
+updateLogContents = updateLogContents.replace(/\r/g, "");
+// Replace error codes since they are different on each platform.
+updateLogContents = updateLogContents.replace(/, err:.*\n/g, "\n");
+// Replace to make the log parsing happy.
+updateLogContents = updateLogContents.replace(/non-fatal error /g, "");
+// The FindFile results when enumerating the filesystem on Windows is not
+// determistic so the results matching the following need to be ignored.
+updateLogContents = updateLogContents.replace(/.* a\/b\/7\/7text.*\n/g, "");
+// Remove consecutive newlines
+updateLogContents = updateLogContents.replace(/\n+/g, "\n");
+// Remove leading and trailing newlines
+updateLogContents = updateLogContents.replace(/^\n|\n$/g, "");
+// The update log when running the service tests sometimes starts with data
+// from the previous launch of the updater.
+updateLogContents = updateLogContents.replace(/^calling QuitProgressUI\n[^\n]*\nUPDATE TYPE/g, "UPDATE TYPE");
+let compareLogContents = "";
+if (aCompareLogFile) {
+compareLogContents = readFileBytes(getTestDirFile(aCompareLogFile));
+}
+if (gSwitchApp) {
+compareLogContents += LOG_SWITCH_SUCCESS;
+}
+// The channel-prefs.js is defined in gTestFilesCommon which will always be
+// located to the end of gTestFiles.
+if (gTestFiles.length > 1 &&
+	  gTestFiles[gTestFiles.length - 1].fileName == "channel-prefs.js" &&
+	  !gTestFiles[gTestFiles.length - 1].originalContents) {
+compareLogContents = compareLogContents.replace(/.* a\/b\/defaults\/.*/g, "");
+}
+if (gTestFiles.length > 2 &&
+	  gTestFiles[gTestFiles.length - 2].fileName == FILE_UPDATE_SETTINGS_INI &&
+	  !gTestFiles[gTestFiles.length - 2].originalContents) {
+compareLogContents = compareLogContents.replace(/.* a\/b\/update-settings.ini.*/g, "");
+}
+// Remove leading and trailing newlines
+compareLogContents = compareLogContents.replace(/\n+/g, "\n");
+// Remove leading and trailing newlines
+compareLogContents = compareLogContents.replace(/^\n|\n$/g, "");
+// Don't write the contents of the file to the log to reduce log spam
+// unless there is a failure.
+if (compareLogContents == updateLogContents) {
+logTestInfo("log contents are correct");
+do_check_true(true);
+} else {
+logTestInfo("log contents are not correct");
+do_check_eq(compareLogContents, updateLogContents);
+}
+}
+/**
+* Helper function to check if the update log contains a string.
+*
+* @param   aCheckString
+*          The string to check if the update log contains.
+*/
+function checkUpdateLogContains(aCheckString) {
+let updateLog = getUpdatesPatchDir();
+updateLog.append(FILE_UPDATE_LOG);
+let updateLogContents = readFileBytes(updateLog);
+if (updateLogContents.indexOf(aCheckString) != -1) {
+logTestInfo("log file does contain: " + aCheckString);
+do_check_true(true);
+} else {
+logTestInfo("log file does not contain: " + aCheckString);
+logTestInfo("log file contents:\n" + updateLogContents);
+do_check_true(false);
+}
+}
+/**
+* Helper function for updater binary tests for verifying the state of files and
+* directories after a successful update.
+*/
+function checkFilesAfterUpdateSuccess() {
+logTestInfo("testing contents of files after a successful update");
+gTestFiles.forEach(function CFAUS_TF_FE(aTestFile) {
+let testFile = getTargetDirFile(aTestFile.relPathDir + aTestFile.fileName,
+true);
+logTestInfo("testing file: " + testFile.path);
+if (aTestFile.compareFile || aTestFile.compareContents) {
+do_check_true(testFile.exists());
+// Skip these tests on Windows and OS/2 since their
+// implementaions of chmod doesn't really set permissions.
+if (!IS_WIN && aTestFile.comparePerms) {
+// Check if the permssions as set in the complete mar file are correct.
+let logPerms = "testing file permissions - ";
+if (aTestFile.originalPerms) {
+logPerms += "original permissions: " +
+aTestFile.originalPerms.toString(8) + ", ";
+}
+logPerms += "compare permissions : " +
+aTestFile.comparePerms.toString(8) + ", ";
+logPerms += "updated permissions : " + testFile.permissions.toString(8);
+logTestInfo(logPerms);
+do_check_eq(testFile.permissions & 0xfff, aTestFile.comparePerms & 0xfff);
+}
+let fileContents1 = readFileBytes(testFile);
+let fileContents2 = aTestFile.compareFile ?
+readFileBytes(getTestDirFile(aTestFile.compareFile)) :
+aTestFile.compareContents;
+// Don't write the contents of the file to the log to reduce log spam
+// unless there is a failure.
+if (fileContents1 == fileContents2) {
+logTestInfo("file contents are correct");
+do_check_true(true);
+} else {
+logTestInfo("file contents are not correct");
+do_check_eq(fileContents1, fileContents2);
+}
+} else {
+do_check_false(testFile.exists());
+}
+});
+logTestInfo("testing operations specified in removed-files were performed " +
+"after a successful update");
+gTestDirs.forEach(function CFAUS_TD_FE(aTestDir) {
+let testDir = getTargetDirFile(aTestDir.relPathDir, true);
+logTestInfo("testing directory: " + testDir.path);
+if (aTestDir.dirRemoved) {
+do_check_false(testDir.exists());
+} else {
+do_check_true(testDir.exists());
+if (aTestDir.files) {
+aTestDir.files.forEach(function CFAUS_TD_F_FE(aTestFile) {
+let testFile = getTargetDirFile(aTestDir.relPathDir + aTestFile, true);
+logTestInfo("testing directory file: " + testFile.path);
+if (aTestDir.filesRemoved) {
+do_check_false(testFile.exists());
+} else {
+do_check_true(testFile.exists());
+}
+});
+}
+if (aTestDir.subDirs) {
+aTestDir.subDirs.forEach(function CFAUS_TD_SD_FE(aSubDir) {
+let testSubDir = getTargetDirFile(aTestDir.relPathDir + aSubDir, true);
+logTestInfo("testing sub-directory: " + testSubDir.path);
+do_check_true(testSubDir.exists());
+if (aTestDir.subDirFiles) {
+aTestDir.subDirFiles.forEach(function CFAUS_TD_SDF_FE(aTestFile) {
+let testFile = getTargetDirFile(aTestDir.relPathDir + aSubDir + aTestFile, true);
+logTestInfo("testing sub-directory file: " + testFile.path);
+do_check_true(testFile.exists());
+});
+}
+});
+}
+}
+});
+checkFilesAfterUpdateCommon();
+}
+/**
+* Helper function for updater binary tests for verifying the state of files and
+* directories after a failed update.
+*
+* @param aGetDirectory: the function used to get the files in the target directory.
+* Pass getApplyDirFile if you want to test the case of a failed switch request.
+*/
+function checkFilesAfterUpdateFailure(aGetDirectory) {
+let getdir = aGetDirectory || getTargetDirFile;
+logTestInfo("testing contents of files after a failed update");
+gTestFiles.forEach(function CFAUF_TF_FE(aTestFile) {
+let testFile = getdir(aTestFile.relPathDir + aTestFile.fileName, true);
+logTestInfo("testing file: " + testFile.path);
+if (aTestFile.compareFile || aTestFile.compareContents) {
+do_check_true(testFile.exists());
+// Skip these tests on Windows and OS/2 since their
+// implementaions of chmod doesn't really set permissions.
+if (!IS_WIN && aTestFile.comparePerms) {
+// Check the original permssions are retained on the file.
+let logPerms = "testing file permissions - ";
+if (aTestFile.originalPerms) {
+logPerms += "original permissions: " +
+aTestFile.originalPerms.toString(8) + ", ";
+}
+logPerms += "compare permissions : " +
+aTestFile.comparePerms.toString(8) + ", ";
+logPerms += "updated permissions : " + testFile.permissions.toString(8);
+logTestInfo(logPerms);
+do_check_eq(testFile.permissions & 0xfff, aTestFile.comparePerms & 0xfff);
+}
+let fileContents1 = readFileBytes(testFile);
+let fileContents2 = aTestFile.compareFile ?
+readFileBytes(getTestDirFile(aTestFile.compareFile)) :
+aTestFile.compareContents;
+// Don't write the contents of the file to the log to reduce log spam
+// unless there is a failure.
+if (fileContents1 == fileContents2) {
+logTestInfo("file contents are correct");
+do_check_true(true);
+} else {
+logTestInfo("file contents are not correct");
+do_check_eq(fileContents1, fileContents2);
+}
+} else {
+do_check_false(testFile.exists());
+}
+});
+logTestInfo("testing operations specified in removed-files were not " +
+"performed after a failed update");
+gTestDirs.forEach(function CFAUF_TD_FE(aTestDir) {
+let testDir = getdir(aTestDir.relPathDir, true);
+logTestInfo("testing directory: " + testDir.path);
+do_check_true(testDir.exists());
+if (aTestDir.files) {
+aTestDir.files.forEach(function CFAUS_TD_F_FE(aTestFile) {
+let testFile = getdir(aTestDir.relPathDir + aTestFile, true);
+logTestInfo("testing directory file: " + testFile.path);
+do_check_true(testFile.exists());
+});
+}
+if (aTestDir.subDirs) {
+aTestDir.subDirs.forEach(function CFAUS_TD_SD_FE(aSubDir) {
+let testSubDir = getdir(aTestDir.relPathDir + aSubDir, true);
+logTestInfo("testing sub-directory: " + testSubDir.path);
+do_check_true(testSubDir.exists());
+if (aTestDir.subDirFiles) {
+aTestDir.subDirFiles.forEach(function CFAUS_TD_SDF_FE(aTestFile) {
+let testFile = getdir(aTestDir.relPathDir + aSubDir + aTestFile,
+true);
+logTestInfo("testing sub-directory file: " + testFile.path);
+do_check_true(testFile.exists());
+});
+}
+});
+}
+});
+checkFilesAfterUpdateCommon();
+}
+/**
+* Helper function for updater binary tests for verifying the state of common
+* files and directories after a successful or failed update.
+*/
+function checkFilesAfterUpdateCommon() {
+logTestInfo("testing extra directories");
+gTestExtraDirs.forEach(function CFAUC_TED_FE(aTestExtraDir) {
+let testDir = getTargetDirFile(aTestExtraDir.relPathDir, true);
+logTestInfo("testing directory: " + testDir.path);
+if (aTestExtraDir.dirExists) {
+do_check_true(testDir.exists());
+} else {
+do_check_false(testDir.exists());
+}
+});
+logTestInfo("testing updating directory doesn't exist in the application " +
+	          "directory");
+let updatingDir = getTargetDirFile("updating", true);
+do_check_false(updatingDir.exists());
+if (gStageUpdate) {
+logTestInfo("testing updating directory doesn't exist in the updated " +
+		        "directory");
+updatingDir = getApplyDirFile("updating", true);
+do_check_false(updatingDir.exists());
+// This should never exist since the update was applied to the updated
+	// directory and the files should never be in use.
+logTestInfo("testing tobedeleted directory doesn't exist in the updated " +
+"directory");
+let toBeDeletedDir = getApplyDirFile(DIR_TOBEDELETED, true);
+do_check_false(toBeDeletedDir.exists());
+}
+logTestInfo("testing patch files should not be left behind");
+let updatesDir = getUpdatesPatchDir();
+let entries = updatesDir.QueryInterface(AUS_Ci.nsIFile).directoryEntries;
+while (entries.hasMoreElements()) {
+let entry = entries.getNext().QueryInterface(AUS_Ci.nsIFile);
+do_check_neq(getFileExtension(entry), "patch");
+}
+logTestInfo("testing backup files should not be left behind");
+let applyToDir = getTargetDirFile(null, true);
+checkFilesInDirRecursive(applyToDir, checkForBackupFiles);
+}
+/**
+* Helper function for updater binary tests for verifying the contents of the
+* updater callback application log which should contain the arguments passed to
+* the callback application.
+*/
+function checkCallbackAppLog() {
+let appLaunchLog = getApplyDirFile("a/b/" + gCallbackArgs[1], true);
+if (!appLaunchLog.exists()) {
+do_timeout(TEST_HELPER_TIMEOUT, checkCallbackAppLog);
+return;
+}
+let expectedLogContents = gCallbackArgs.join("\n") + "\n";
+let logContents = readFile(appLaunchLog);
+// It is possible for the log file contents check to occur before the log file
+// contents are completely written so wait until the contents are the expected
+// value. If the contents are never the expected value then the test will
+// fail by timing out.
+if (logContents != expectedLogContents) {
+do_timeout(TEST_HELPER_TIMEOUT, checkCallbackAppLog);
+return;
+}
+if (logContents == expectedLogContents) {
+logTestInfo("callback log file contents are correct");
+do_check_true(true);
+} else {
+logTestInfo("callback log file contents are not correct");
+do_check_eq(logContents, expectedLogContents);
+}
+waitForFilesInUse();
+}
+/**
+* Helper function for updater service tests for verifying the contents of the
+* updater callback application log which should contain the arguments passed to
+* the callback application.
+*/
+function checkCallbackServiceLog() {
+do_check_neq(gServiceLaunchedCallbackLog, null);
+let expectedLogContents = gServiceLaunchedCallbackArgs.join("\n") + "\n";
+let logFile = AUS_Cc["@mozilla.org/file/local;1"].createInstance(AUS_Ci.nsILocalFile);
+logFile.initWithPath(gServiceLaunchedCallbackLog);
+let logContents = readFile(logFile);
+// It is possible for the log file contents check to occur before the log file
+// contents are completely written so wait until the contents are the expected
+// value. If the contents are never the expected value then the test will
+// fail by timing out.
+if (logContents != expectedLogContents) {
+logTestInfo("callback service log not expected value, waiting longer");
+do_timeout(TEST_HELPER_TIMEOUT, checkCallbackServiceLog);
+return;
+}
+logTestInfo("testing that the callback application successfully launched " +
+"and the expected command line arguments were passed to it");
+do_check_eq(logContents, expectedLogContents);
+waitForFilesInUse();
+}
+// Waits until files that are in use that break tests are no longer in use and
+// then calls do_test_finished.
+function waitForFilesInUse() {
+if (IS_WIN) {
+let appBin = getApplyDirFile(FILE_APP_BIN, true);
+let maintSvcInstaller = getApplyDirFile(FILE_MAINTENANCE_SERVICE_INSTALLER_BIN, true);
+let helper = getApplyDirFile("uninstall/helper.exe", true);
+let updater = getUpdatesPatchDir();
+updater.append(FILE_UPDATER_BIN);
+let files = [appBin, updater, maintSvcInstaller, helper];
+for (var i = 0; i < files.length; ++i) {
+let file = files[i];
+let fileBak = file.parent.clone();
+if (file.exists()) {
+fileBak.append(file.leafName + ".bak");
+try {
+if (fileBak.exists()) {
+fileBak.remove(false);
+}
+file.copyTo(fileBak.parent, fileBak.leafName);
+file.remove(false);
+fileBak.moveTo(file.parent, file.leafName);
+logTestInfo("file is not in use. Path: " + file.path);
+} catch (e) {
+logTestInfo("file in use, will try again after " + TEST_CHECK_TIMEOUT +
+" ms, Path: " + file.path + ", Exception: " + e);
+try {
+if (fileBak.exists()) {
+fileBak.remove(false);
+}
+} catch (e) {
+logTestInfo("unable to remove file, this should never happen! " +
+"Path: " + fileBak.path + ", Exception: " + e);
+}
+do_timeout(TEST_CHECK_TIMEOUT, waitForFilesInUse);
+return;
+}
+}
+}
+}
+logTestInfo("calling doTestFinish");
+doTestFinish();
+}
+/**
+* Helper function for updater binary tests for verifying there are no update
+* backup files left behind after an update.
+*
+* @param   aFile
+*          An nsIFile to check if it has moz-backup for its extension.
+*/
+function checkForBackupFiles(aFile) {
+do_check_neq(getFileExtension(aFile), "moz-backup");
+}
+/**
+* Helper function for updater binary tests for recursively enumerating a
+* directory and calling a callback function with the file as a parameter for
+* each file found.
+*
+* @param   aDir
+*          A nsIFile for the directory to be deleted
+* @param   aCallback
+*          A callback function that will be called with the file as a
+*          parameter for each file found.
+*/
+function checkFilesInDirRecursive(aDir, aCallback) {
+if (!aDir.exists())
+do_throw("Directory must exist!");
+let dirEntries = aDir.directoryEntries;
+while (dirEntries.hasMoreElements()) {
+let entry = dirEntries.getNext().QueryInterface(AUS_Ci.nsIFile);
+if (entry.isDirectory()) {
+checkFilesInDirRecursive(entry, aCallback);
+} else {
+aCallback(entry);
+}
+}
+}
+/**
+* Sets up the bare bones XMLHttpRequest implementation below.
+*
+* @param   aCallback
+*          The callback function that will call the nsIDomEventListener's
+*          handleEvent method.
+*
+*          Example of the callback function
+*
+*            function callHandleEvent() {
+*              gXHR.status = gExpectedStatus;
+*              var e = { target: gXHR };
+*              gXHR.onload.handleEvent(e);
+*            }
+*/
+function overrideXHR(aCallback) {
+gXHRCallback = aCallback;
+gXHR = new xhr();
+var registrar = Components.manager.QueryInterface(AUS_Ci.nsIComponentRegistrar);
+registrar.registerFactory(gXHR.classID, gXHR.classDescription,
+gXHR.contractID, gXHR);
+}
+/**
+* Bare bones XMLHttpRequest implementation for testing onprogress, onerror,
+* and onload nsIDomEventListener handleEvent.
+*/
+function makeHandler(aVal) {
+if (typeof aVal == "function")
+return { handleEvent: aVal };
+return aVal;
+}
+function xhr() {
+}
+xhr.prototype = {
+overrideMimeType: function(aMimetype) { },
+setRequestHeader: function(aHeader, aValue) { },
+status: null,
+channel: { set notificationCallbacks(aVal) { } },
+_url: null,
+_method: null,
+open: function(aMethod, aUrl) {
+gXHR.channel.originalURI = Services.io.newURI(aUrl, null, null);
+gXHR._method = aMethod; gXHR._url = aUrl;
+},
+responseXML: null,
+responseText: null,
+send: function(aBody) {
+do_execute_soon(gXHRCallback); // Use a timeout so the XHR completes
+},
+_onprogress: null,
+set onprogress(aValue) { gXHR._onprogress = makeHandler(aValue); },
+get onprogress() { return gXHR._onprogress; },
+_onerror: null,
+set onerror(aValue) { gXHR._onerror = makeHandler(aValue); },
+get onerror() { return gXHR._onerror; },
+_onload: null,
+set onload(aValue) { gXHR._onload = makeHandler(aValue); },
+get onload() { return gXHR._onload; },
+addEventListener: function(aEvent, aValue, aCapturing) {
+eval("gXHR._on" + aEvent + " = aValue");
+},
+flags: AUS_Ci.nsIClassInfo.SINGLETON,
+implementationLanguage: AUS_Ci.nsIProgrammingLanguage.JAVASCRIPT,
+getHelperForLanguage: function(aLanguage) null,
+getInterfaces: function(aCount) {
+var interfaces = [AUS_Ci.nsISupports];
+aCount.value = interfaces.length;
+return interfaces;
+},
+classDescription: "XMLHttpRequest",
+contractID: "@mozilla.org/xmlextras/xmlhttprequest;1",
+classID: Components.ID("{c9b37f43-4278-4304-a5e0-600991ab08cb}"),
+createInstance: function(aOuter, aIID) {
+if (aOuter == null)
+return gXHR.QueryInterface(aIID);
+throw AUS_Cr.NS_ERROR_NO_AGGREGATION;
+},
+QueryInterface: function(aIID) {
+if (aIID.equals(AUS_Ci.nsIClassInfo) ||
+aIID.equals(AUS_Ci.nsISupports))
+return gXHR;
+throw AUS_Cr.NS_ERROR_NO_INTERFACE;
+},
+get wrappedJSObject() { return this; }
+};
+/**
+* Helper function to override the update prompt component to verify whether it
+* is called or not.
+*
+* @param   aCallback
+*          The callback to call if the update prompt component is called.
+*/
+function overrideUpdatePrompt(aCallback) {
+var registrar = Components.manager.QueryInterface(AUS_Ci.nsIComponentRegistrar);
+gUpdatePrompt = new UpdatePrompt();
+gUpdatePromptCallback = aCallback;
+registrar.registerFactory(gUpdatePrompt.classID, gUpdatePrompt.classDescription,
+gUpdatePrompt.contractID, gUpdatePrompt);
+}
+function UpdatePrompt() {
+var fns = ["checkForUpdates", "showUpdateAvailable", "showUpdateDownloaded",
+"showUpdateError", "showUpdateHistory", "showUpdateInstalled"];
+fns.forEach(function(aPromptFn) {
+UpdatePrompt.prototype[aPromptFn] = function() {
+if (!gUpdatePromptCallback) {
+return;
+}
+var callback = gUpdatePromptCallback[aPromptFn];
+if (!callback) {
+return;
+}
+callback.apply(gUpdatePromptCallback,
+Array.prototype.slice.call(arguments));
+}
+});
+}
+UpdatePrompt.prototype = {
+flags: AUS_Ci.nsIClassInfo.SINGLETON,
+implementationLanguage: AUS_Ci.nsIProgrammingLanguage.JAVASCRIPT,
+getHelperForLanguage: function(aLanguage) null,
+getInterfaces: function(aCount) {
+var interfaces = [AUS_Ci.nsISupports, AUS_Ci.nsIUpdatePrompt];
+aCount.value = interfaces.length;
+return interfaces;
+},
+classDescription: "UpdatePrompt",
+contractID: "@mozilla.org/updates/update-prompt;1",
+classID: Components.ID("{8c350a15-9b90-4622-93a1-4d320308664b}"),
+createInstance: function(aOuter, aIID) {
+if (aOuter == null)
+return gUpdatePrompt.QueryInterface(aIID);
+throw AUS_Cr.NS_ERROR_NO_AGGREGATION;
+},
+QueryInterface: function(aIID) {
+if (aIID.equals(AUS_Ci.nsIClassInfo) ||
+aIID.equals(AUS_Ci.nsISupports) ||
+aIID.equals(AUS_Ci.nsIUpdatePrompt))
+return gUpdatePrompt;
+throw AUS_Cr.NS_ERROR_NO_INTERFACE;
+},
+};
+/* Update check listener */
+const updateCheckListener = {
+onProgress: function UCL_onProgress(aRequest, aPosition, aTotalSize) {
+},
+onCheckComplete: function UCL_onCheckComplete(aRequest, aUpdates, aUpdateCount) {
+gRequestURL = aRequest.channel.originalURI.spec;
+gUpdateCount = aUpdateCount;
+gUpdates = aUpdates;
+logTestInfo("url = " + gRequestURL + ", " +
+"request.status = " + aRequest.status + ", " +
+"update.statusText = " + aRequest.statusText + ", " +
+"updateCount = " + aUpdateCount);
+// Use a timeout to allow the XHR to complete
+do_execute_soon(gCheckFunc);
+},
+onError: function UCL_onError(aRequest, aUpdate) {
+gRequestURL = aRequest.channel.originalURI.spec;
+gStatusCode = aRequest.status;
+gStatusText = aUpdate.statusText;
+logTestInfo("url = " + gRequestURL + ", " +
+"request.status = " + gStatusCode + ", " +
+"update.statusText = " + gStatusText);
+// Use a timeout to allow the XHR to complete
+do_execute_soon(gCheckFunc.bind(null, aRequest, aUpdate));
+},
+QueryInterface: function(aIID) {
+if (!aIID.equals(AUS_Ci.nsIUpdateCheckListener) &&
+!aIID.equals(AUS_Ci.nsISupports))
+throw AUS_Cr.NS_ERROR_NO_INTERFACE;
+return this;
+}
+};
+/* Update download listener - nsIRequestObserver */
+const downloadListener = {
+onStartRequest: function DL_onStartRequest(aRequest, aContext) {
+},
+onProgress: function DL_onProgress(aRequest, aContext, aProgress, aMaxProgress) {
+},
+onStatus: function DL_onStatus(aRequest, aContext, aStatus, aStatusText) {
+},
+onStopRequest: function DL_onStopRequest(aRequest, aContext, aStatus) {
+gStatusResult = aStatus;
+// Use a timeout to allow the request to complete
+do_execute_soon(gCheckFunc);
+},
+QueryInterface: function DL_QueryInterface(aIID) {
+if (!aIID.equals(AUS_Ci.nsIRequestObserver) &&
+!aIID.equals(AUS_Ci.nsIProgressEventSink) &&
+!aIID.equals(AUS_Ci.nsISupports))
+throw AUS_Cr.NS_ERROR_NO_INTERFACE;
+return this;
+}
+};
+/**
+* Helper for starting the http server used by the tests
+*/
+function start_httpserver() {
+let dir = getTestDirFile();
+logTestInfo("http server directory path: " + dir.path);
+if (!dir.isDirectory()) {
+do_throw("A file instead of a directory was specified for HttpServer " +
+"registerDirectory! Path: " + dir.path + "\n");
+}
+AUS_Cu.import("resource://testing-common/httpd.js");
+gTestserver = new HttpServer();
+gTestserver.registerDirectory("/", dir);
+gTestserver.start(-1);
+let testserverPort = gTestserver.identity.primaryPort;
+gURLData = URL_HOST + ":" + testserverPort + "/";
+logTestInfo("http server port = " + testserverPort);
+}
+/**
+* Helper for stopping the http server used by the tests
+*
+* @param   aCallback
+*          The callback to call after stopping the http server.
+*/
+function stop_httpserver(aCallback) {
+do_check_true(!!aCallback);
+gTestserver.stop(aCallback);
+}
+/**
+* Creates an nsIXULAppInfo
+*
+* @param   aID
+*          The ID of the test application
+* @param   aName
+*          A name for the test application
+* @param   aVersion
+*          The version of the application
+* @param   aPlatformVersion
+*          The gecko version of the application
+*/
+function createAppInfo(aID, aName, aVersion, aPlatformVersion) {
+const XULAPPINFO_CONTRACTID = "@mozilla.org/xre/app-info;1";
+const XULAPPINFO_CID = Components.ID("{c763b610-9d49-455a-bbd2-ede71682a1ac}");
+var XULAppInfo = {
+vendor: APP_INFO_VENDOR,
+name: aName,
+ID: aID,
+version: aVersion,
+appBuildID: "2007010101",
+platformVersion: aPlatformVersion,
+platformBuildID: "2007010101",
+inSafeMode: false,
+logConsoleErrors: true,
+OS: "XPCShell",
+XPCOMABI: "noarch-spidermonkey",
+QueryInterface: function QueryInterface(aIID) {
+if (aIID.equals(AUS_Ci.nsIXULAppInfo) ||
+aIID.equals(AUS_Ci.nsIXULRuntime) ||
+#ifdef XP_WIN
+aIID.equals(AUS_Ci.nsIWinAppHelper) ||
+#endif
+aIID.equals(AUS_Ci.nsISupports))
+return this;
+throw AUS_Cr.NS_ERROR_NO_INTERFACE;
+}
+};
+var XULAppInfoFactory = {
+createInstance: function (aOuter, aIID) {
+if (aOuter == null)
+return XULAppInfo.QueryInterface(aIID);
+throw AUS_Cr.NS_ERROR_NO_AGGREGATION;
+}
+};
+var registrar = Components.manager.QueryInterface(AUS_Ci.nsIComponentRegistrar);
+registrar.registerFactory(XULAPPINFO_CID, "XULAppInfo",
+XULAPPINFO_CONTRACTID, XULAppInfoFactory);
+}
+/**
+* Returns the platform specific arguments used by nsIProcess when launching
+* the application.
+*
+* @param   aExtraArgs (optional)
+*          An array of extra arguments to append to the default arguments.
+* @return  an array of arguments to be passed to nsIProcess.
+*
+* Note: a shell is necessary to pipe the application's console output which
+*       would otherwise pollute the xpcshell log.
+*
+* Command line arguments used when launching the application:
+* -no-remote prevents shell integration from being affected by an existing
+* application process.
+* -process-updates makes the application exits after being relaunched by the
+* updater.
+* the platform specific string defined by PIPE_TO_NULL to output both stdout
+* and stderr to null. This is needed to prevent output from the application
+* from ending up in the xpchsell log.
+*/
+function getProcessArgs(aExtraArgs) {
+if (!aExtraArgs) {
+aExtraArgs = [];
+}
+let appBinPath = getApplyDirFile(DIR_BIN_REL_PATH + FILE_APP_BIN, false).path;
+if (/ /.test(appBinPath)) {
+appBinPath = '"' + appBinPath + '"';
+}
+let args;
+if (IS_UNIX) {
+let launchScript = getLaunchScript();
+// Precreate the script with executable permissions
+launchScript.create(AUS_Ci.nsILocalFile.NORMAL_FILE_TYPE, PERMS_DIRECTORY);
+let scriptContents = "#! /bin/sh\n";
+scriptContents += appBinPath + " -no-remote -process-updates " +
+aExtraArgs.join(" ") + " " + PIPE_TO_NULL;
+writeFile(launchScript, scriptContents);
+logTestInfo("created " + launchScript.path + " containing:\n" +
+scriptContents);
+args = [launchScript.path];
+} else {
+args = ["/D", "/Q", "/C", appBinPath, "-no-remote", "-process-updates"].
+concat(aExtraArgs).concat([PIPE_TO_NULL]);
+}
+return args;
+}
+/**
+* Gets a file path for the application to dump its arguments into.  This is used
+* to verify that a callback application is launched.
+*
+* @return  the file for the application to dump its arguments into.
+*/
+function getAppArgsLogPath() {
+let appArgsLog = do_get_file("/", true);
+appArgsLog.append(gTestID + "_app_args_log");
+if (appArgsLog.exists()) {
+appArgsLog.remove(false);
+}
+let appArgsLogPath = appArgsLog.path;
+if (/ /.test(appArgsLogPath)) {
+appArgsLogPath = '"' + appArgsLogPath + '"';
+}
+return appArgsLogPath;
+}
+/**
+* Gets the nsIFile reference for the shell script to launch the application. If
+* the file exists it will be removed by this function.
+*
+* @return  the nsIFile for the shell script to launch the application.
+*/
+function getLaunchScript() {
+let launchScript = do_get_file("/", true);
+launchScript.append(gTestID + "_launch.sh");
+if (launchScript.exists()) {
+launchScript.remove(false);
+}
+return launchScript;
+}
+/**
+* Makes GreD, XREExeF, and UpdRootD point to unique file system locations so
+* xpcshell tests can run in parallel and to keep the environment clean.
+*/
+function adjustGeneralPaths() {
+let dirProvider = {
+getFile: function AGP_DP_getFile(aProp, aPersistent) {
+aPersistent.value = true;
+switch (aProp) {
+case NS_GRE_DIR:
+if (gUseTestAppDir) {
+return getApplyDirFile(DIR_BIN_REL_PATH, true);
+}
+break;
+case XRE_EXECUTABLE_FILE:
+if (gUseTestAppDir) {
+return getApplyDirFile(DIR_BIN_REL_PATH + FILE_APP_BIN, true);
+}
+break;
+case XRE_UPDATE_ROOT_DIR:
+return getMockUpdRootD();
+}
+return null;
+},
+QueryInterface: function(aIID) {
+if (aIID.equals(AUS_Ci.nsIDirectoryServiceProvider) ||
+aIID.equals(AUS_Ci.nsISupports))
+return this;
+throw AUS_Cr.NS_ERROR_NO_INTERFACE;
+}
+};
+let ds = Services.dirsvc.QueryInterface(AUS_Ci.nsIDirectoryService);
+ds.QueryInterface(AUS_Ci.nsIProperties).undefine(NS_GRE_DIR);
+ds.QueryInterface(AUS_Ci.nsIProperties).undefine(XRE_EXECUTABLE_FILE);
+ds.registerProvider(dirProvider);
+do_register_cleanup(function AGP_cleanup() {
+logTestInfo("start - unregistering directory provider");
+if (gAppTimer) {
+logTestInfo("start - cancel app timer");
+gAppTimer.cancel();
+gAppTimer = null;
+logTestInfo("finish - cancel app timer");
+}
+if (gProcess && gProcess.isRunning) {
+logTestInfo("start - kill process");
+try {
+gProcess.kill();
+} catch (e) {
+logTestInfo("kill process failed. Exception: " + e);
+}
+gProcess = null;
+logTestInfo("finish - kill process");
+}
+if (gHandle) {
+try {
+logTestInfo("start - closing handle");
+let kernel32 = ctypes.open("kernel32");
+let CloseHandle = kernel32.declare("CloseHandle", ctypes.default_abi,
+ctypes.bool, /*return*/
+ctypes.voidptr_t /*handle*/);
+if (!CloseHandle(gHandle)) {
+logTestInfo("call to CloseHandle failed");
+}
+kernel32.close();
+gHandle = null;
+logTestInfo("finish - closing handle");
+} catch (e) {
+logTestInfo("call to CloseHandle failed. Exception: " + e);
+}
+}
+// Call end_test first before the directory provider is unregistered
+if (typeof(end_test) == typeof(Function)) {
+logTestInfo("calling end_test");
+end_test();
+}
+ds.unregisterProvider(dirProvider);
+cleanupTestCommon();
+logTestInfo("finish - unregistering directory provider");
+});
+}
+/**
+* Helper function for launching the application to apply an update.
+*/
+function launchAppToApplyUpdate() {
+logTestInfo("start - launching application to apply update");
+let appBin = getApplyDirFile(DIR_BIN_REL_PATH + FILE_APP_BIN, false);
+if (typeof(customLaunchAppToApplyUpdate) == typeof(Function)) {
+customLaunchAppToApplyUpdate();
+}
+let launchBin = getLaunchBin();
+let args = getProcessArgs();
+logTestInfo("launching " + launchBin.path + " " + args.join(" "));
+gProcess = AUS_Cc["@mozilla.org/process/util;1"].
+createInstance(AUS_Ci.nsIProcess);
+gProcess.init(launchBin);
+gAppTimer = AUS_Cc["@mozilla.org/timer;1"].createInstance(AUS_Ci.nsITimer);
+gAppTimer.initWithCallback(gTimerCallback, APP_TIMER_TIMEOUT,
+AUS_Ci.nsITimer.TYPE_ONE_SHOT);
+setEnvironment();
+logTestInfo("launching application");
+gProcess.runAsync(args, args.length, gProcessObserver);
+resetEnvironment();
+logTestInfo("finish - launching application to apply update");
+}
+/**
+* The observer for the call to nsIProcess:runAsync.
+*/
+let gProcessObserver = {
+observe: function PO_observe(aSubject, aTopic, aData) {
+logTestInfo("topic: " + aTopic + ", process exitValue: " +
+gProcess.exitValue);
+if (gAppTimer) {
+gAppTimer.cancel();
+gAppTimer = null;
+}
+if (aTopic != "process-finished" || gProcess.exitValue != 0) {
+do_throw("Failed to launch application");
+}
+do_timeout(TEST_CHECK_TIMEOUT, checkUpdateFinished);
+},
+QueryInterface: XPCOMUtils.generateQI([AUS_Ci.nsIObserver])
+};
+/**
+* The timer callback to kill the process if it takes too long.
+*/
+let gTimerCallback = {
+notify: function TC_notify(aTimer) {
+gAppTimer = null;
+if (gProcess.isRunning) {
+logTestInfo("attempt to kill process");
+gProcess.kill();
+}
+do_throw("launch application timer expired");
+},
+QueryInterface: XPCOMUtils.generateQI([AUS_Ci.nsITimerCallback])
+};
+/**
+* The update-staged observer for the call to nsIUpdateProcessor:processUpdate.
+*/
+let gUpdateStagedObserver = {
+observe: function(aSubject, aTopic, aData) {
+if (aTopic == "update-staged") {
+Services.obs.removeObserver(gUpdateStagedObserver, "update-staged");
+checkUpdateApplied();
+}
+},
+QueryInterface: XPCOMUtils.generateQI([AUS_Ci.nsIObserver])
+};
+/**
+* Sets the environment that will be used by the application process when it is
+* launched.
+*/
+function setEnvironment() {
+// Prevent setting the environment more than once.
+if (gShouldResetEnv !== undefined)
+return;
+gShouldResetEnv = true;
+let env = AUS_Cc["@mozilla.org/process/environment;1"].
+getService(AUS_Ci.nsIEnvironment);
+if (IS_WIN && !env.exists("XRE_NO_WINDOWS_CRASH_DIALOG")) {
+gAddedEnvXRENoWindowsCrashDialog = true;
+logTestInfo("setting the XRE_NO_WINDOWS_CRASH_DIALOG environment " +
+"variable to 1... previously it didn't exist");
+env.set("XRE_NO_WINDOWS_CRASH_DIALOG", "1");
+}
+if (IS_UNIX) {
+let appGreDir = gGREDirOrig.clone();
+let envGreDir = AUS_Cc["@mozilla.org/file/local;1"].
+createInstance(AUS_Ci.nsILocalFile);
+let shouldSetEnv = true;
+if (IS_MACOSX) {
+if (env.exists("DYLD_LIBRARY_PATH")) {
+gEnvDyldLibraryPath = env.get("DYLD_LIBRARY_PATH");
+envGreDir.initWithPath(gEnvDyldLibraryPath);
+if (envGreDir.path == appGreDir.path) {
+gEnvDyldLibraryPath = null;
+shouldSetEnv = false;
+}
+}
+if (shouldSetEnv) {
+logTestInfo("setting DYLD_LIBRARY_PATH environment variable value to " +
+appGreDir.path);
+env.set("DYLD_LIBRARY_PATH", appGreDir.path);
+}
+} else {
+if (env.exists("LD_LIBRARY_PATH")) {
+gEnvLdLibraryPath = env.get("LD_LIBRARY_PATH");
+envGreDir.initWithPath(gEnvLdLibraryPath);
+if (envGreDir.path == appGreDir.path) {
+gEnvLdLibraryPath = null;
+shouldSetEnv = false;
+}
+}
+if (shouldSetEnv) {
+logTestInfo("setting LD_LIBRARY_PATH environment variable value to " +
+appGreDir.path);
+env.set("LD_LIBRARY_PATH", appGreDir.path);
+}
+}
+}
+if (env.exists("XPCOM_MEM_LEAK_LOG")) {
+gEnvXPCOMMemLeakLog = env.get("XPCOM_MEM_LEAK_LOG");
+logTestInfo("removing the XPCOM_MEM_LEAK_LOG environment variable... " +
+"previous value " + gEnvXPCOMMemLeakLog);
+env.set("XPCOM_MEM_LEAK_LOG", "");
+}
+if (env.exists("XPCOM_DEBUG_BREAK")) {
+gEnvXPCOMDebugBreak = env.get("XPCOM_DEBUG_BREAK");
+logTestInfo("setting the XPCOM_DEBUG_BREAK environment variable to " +
+"warn... previous value " + gEnvXPCOMDebugBreak);
+} else {
+logTestInfo("setting the XPCOM_DEBUG_BREAK environment variable to " +
+"warn... previously it didn't exist");
+}
+env.set("XPCOM_DEBUG_BREAK", "warn");
+if (gStageUpdate) {
+logTestInfo("setting the MOZ_UPDATE_STAGING environment variable to 1\n");
+env.set("MOZ_UPDATE_STAGING", "1");
+}
+logTestInfo("setting MOZ_NO_SERVICE_FALLBACK environment variable to 1");
+env.set("MOZ_NO_SERVICE_FALLBACK", "1");
+}
+/**
+* Sets the environment back to the original values after launching the
+* application.
+*/
+function resetEnvironment() {
+// Prevent resetting the environment more than once.
+if (gShouldResetEnv !== true)
+return;
+gShouldResetEnv = false;
+let env = AUS_Cc["@mozilla.org/process/environment;1"].
+getService(AUS_Ci.nsIEnvironment);
+if (gEnvXPCOMMemLeakLog) {
+logTestInfo("setting the XPCOM_MEM_LEAK_LOG environment variable back to " +
+gEnvXPCOMMemLeakLog);
+env.set("XPCOM_MEM_LEAK_LOG", gEnvXPCOMMemLeakLog);
+}
+if (gEnvXPCOMDebugBreak) {
+logTestInfo("setting the XPCOM_DEBUG_BREAK environment variable back to " +
+gEnvXPCOMDebugBreak);
+env.set("XPCOM_DEBUG_BREAK", gEnvXPCOMDebugBreak);
+} else {
+logTestInfo("clearing the XPCOM_DEBUG_BREAK environment variable");
+env.set("XPCOM_DEBUG_BREAK", "");
+}
+if (IS_UNIX) {
+if (IS_MACOSX) {
+if (gEnvDyldLibraryPath) {
+logTestInfo("setting DYLD_LIBRARY_PATH environment variable value " +
+"back to " + gEnvDyldLibraryPath);
+env.set("DYLD_LIBRARY_PATH", gEnvDyldLibraryPath);
+} else {
+logTestInfo("removing DYLD_LIBRARY_PATH environment variable");
+env.set("DYLD_LIBRARY_PATH", "");
+}
+} else {
+if (gEnvLdLibraryPath) {
+logTestInfo("setting LD_LIBRARY_PATH environment variable value back " +
+"to " + gEnvLdLibraryPath);
+env.set("LD_LIBRARY_PATH", gEnvLdLibraryPath);
+} else {
+logTestInfo("removing LD_LIBRARY_PATH environment variable");
+env.set("LD_LIBRARY_PATH", "");
+}
+}
+}
+if (IS_WIN && gAddedEnvXRENoWindowsCrashDialog) {
+logTestInfo("removing the XRE_NO_WINDOWS_CRASH_DIALOG environment " +
+"variable");
+env.set("XRE_NO_WINDOWS_CRASH_DIALOG", "");
+}
+if (gStageUpdate) {
+logTestInfo("removing the MOZ_UPDATE_STAGING environment variable\n");
+env.set("MOZ_UPDATE_STAGING", "");
+}
+logTestInfo("removing MOZ_NO_SERVICE_FALLBACK environment variable");
+env.set("MOZ_NO_SERVICE_FALLBACK", "");
+}