The Tor Browser / file revision

 /* 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 {