summaryrefslogtreecommitdiffstats
path: root/toolkit/components/startup/tests
diff options
context:
space:
mode:
Diffstat (limited to 'toolkit/components/startup/tests')
-rw-r--r--toolkit/components/startup/tests/browser/.eslintrc.js7
-rw-r--r--toolkit/components/startup/tests/browser/beforeunload.html10
-rw-r--r--toolkit/components/startup/tests/browser/browser.ini8
-rw-r--r--toolkit/components/startup/tests/browser/browser_bug511456.js47
-rw-r--r--toolkit/components/startup/tests/browser/browser_bug537449.js53
-rw-r--r--toolkit/components/startup/tests/browser/browser_crash_detection.js23
-rw-r--r--toolkit/components/startup/tests/browser/head.js29
-rw-r--r--toolkit/components/startup/tests/unit/.eslintrc.js7
-rw-r--r--toolkit/components/startup/tests/unit/head_startup.js30
-rw-r--r--toolkit/components/startup/tests/unit/test_startup_crash.js300
-rw-r--r--toolkit/components/startup/tests/unit/xpcshell.ini6
11 files changed, 520 insertions, 0 deletions
diff --git a/toolkit/components/startup/tests/browser/.eslintrc.js b/toolkit/components/startup/tests/browser/.eslintrc.js
new file mode 100644
index 000000000..7c8021192
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+ "extends": [
+ "../../../../../testing/mochitest/browser.eslintrc.js"
+ ]
+};
diff --git a/toolkit/components/startup/tests/browser/beforeunload.html b/toolkit/components/startup/tests/browser/beforeunload.html
new file mode 100644
index 000000000..93ddd5f14
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/beforeunload.html
@@ -0,0 +1,10 @@
+<html>
+ <script>
+ window.onbeforeunload = function(event) {
+ event.returnValue = 'Test beforeunload handler';
+ }
+ </script>
+ <body>
+ Test page
+ </body>
+</html>
diff --git a/toolkit/components/startup/tests/browser/browser.ini b/toolkit/components/startup/tests/browser/browser.ini
new file mode 100644
index 000000000..0c02f73b6
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/browser.ini
@@ -0,0 +1,8 @@
+[DEFAULT]
+support-files =
+ head.js
+ beforeunload.html
+
+[browser_bug511456.js]
+[browser_bug537449.js]
+[browser_crash_detection.js]
diff --git a/toolkit/components/startup/tests/browser/browser_bug511456.js b/toolkit/components/startup/tests/browser/browser_bug511456.js
new file mode 100644
index 000000000..652a34ea2
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/browser_bug511456.js
@@ -0,0 +1,47 @@
+/* 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/. */
+
+"use strict";
+
+const TEST_URL = "http://example.com/browser/toolkit/components/startup/tests/browser/beforeunload.html";
+
+SpecialPowers.pushPrefEnv({"set": [["dom.require_user_interaction_for_beforeunload", false]]});
+
+function test() {
+ waitForExplicitFinish();
+ ignoreAllUncaughtExceptions();
+
+ let win2 = window.openDialog(location, "", "chrome,all,dialog=no", "about:blank");
+ win2.addEventListener("load", function onLoad() {
+ win2.removeEventListener("load", onLoad);
+
+ gBrowser.selectedTab = gBrowser.addTab(TEST_URL);
+ let browser = gBrowser.selectedBrowser;
+
+ whenBrowserLoaded(browser, function () {
+ let seenDialog = false;
+
+ // Cancel the prompt the first time.
+ waitForOnBeforeUnloadDialog(browser, (btnLeave, btnStay) => {
+ seenDialog = true;
+ btnStay.click();
+ });
+
+ let appStartup = Cc['@mozilla.org/toolkit/app-startup;1'].
+ getService(Ci.nsIAppStartup);
+ appStartup.quit(Ci.nsIAppStartup.eAttemptQuit);
+ ok(seenDialog, "Should have seen a prompt dialog");
+ ok(!win2.closed, "Shouldn't have closed the additional window");
+ win2.close();
+
+ // Leave the page the second time.
+ waitForOnBeforeUnloadDialog(browser, (btnLeave, btnStay) => {
+ btnLeave.click();
+ });
+
+ gBrowser.removeTab(gBrowser.selectedTab);
+ executeSoon(finish);
+ });
+ });
+}
diff --git a/toolkit/components/startup/tests/browser/browser_bug537449.js b/toolkit/components/startup/tests/browser/browser_bug537449.js
new file mode 100644
index 000000000..ed3446f8d
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/browser_bug537449.js
@@ -0,0 +1,53 @@
+/* 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/. */
+
+"use strict";
+
+//
+// Whitelisting this test.
+// As part of bug 1077403, the leaking uncaught rejection should be fixed.
+//
+thisTestLeaksUncaughtRejectionsAndShouldBeFixed("TypeError: this.docShell is null");
+
+SpecialPowers.pushPrefEnv({"set": [["dom.require_user_interaction_for_beforeunload", false]]});
+
+const TEST_URL = "http://example.com/browser/toolkit/components/startup/tests/browser/beforeunload.html";
+
+function test() {
+ waitForExplicitFinish();
+
+ gBrowser.selectedTab = gBrowser.addTab(TEST_URL);
+ let browser = gBrowser.selectedBrowser;
+
+ whenBrowserLoaded(browser, function () {
+ let seenDialog = false;
+
+ // Cancel the prompt the first time.
+ waitForOnBeforeUnloadDialog(browser, (btnLeave, btnStay) => {
+ seenDialog = true;
+ btnStay.click();
+ });
+
+ let appStartup = Cc['@mozilla.org/toolkit/app-startup;1'].
+ getService(Ci.nsIAppStartup);
+ appStartup.quit(Ci.nsIAppStartup.eAttemptQuit);
+ ok(seenDialog, "Should have seen a prompt dialog");
+ ok(!window.closed, "Shouldn't have closed the window");
+
+ let win2 = window.openDialog(location, "", "chrome,all,dialog=no", "about:blank");
+ ok(win2 != null, "Should have been able to open a new window");
+ win2.addEventListener("load", function onLoad() {
+ win2.removeEventListener("load", onLoad);
+ win2.close();
+
+ // Leave the page the second time.
+ waitForOnBeforeUnloadDialog(browser, (btnLeave, btnStay) => {
+ btnLeave.click();
+ });
+
+ gBrowser.removeTab(gBrowser.selectedTab);
+ executeSoon(finish);
+ });
+ });
+}
diff --git a/toolkit/components/startup/tests/browser/browser_crash_detection.js b/toolkit/components/startup/tests/browser/browser_crash_detection.js
new file mode 100644
index 000000000..039f80dde
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/browser_crash_detection.js
@@ -0,0 +1,23 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/
+ */
+
+function test() {
+ function checkLastSuccess() {
+ let lastSuccess = Services.prefs.getIntPref("toolkit.startup.last_success");
+ let si = Services.startup.getStartupInfo();
+ is(lastSuccess, parseInt(si["main"].getTime() / 1000, 10),
+ "Startup tracking pref should be set after a delay at the end of startup");
+ finish();
+ }
+
+ if (Services.prefs.getPrefType("toolkit.startup.max_resumed_crashes") == Services.prefs.PREF_INVALID) {
+ info("Skipping this test since startup crash detection is disabled");
+ return;
+ }
+
+ const startupCrashEndDelay = 35 * 1000;
+ waitForExplicitFinish();
+ requestLongerTimeout(2);
+ setTimeout(checkLastSuccess, startupCrashEndDelay);
+}
diff --git a/toolkit/components/startup/tests/browser/head.js b/toolkit/components/startup/tests/browser/head.js
new file mode 100644
index 000000000..c17da2ff7
--- /dev/null
+++ b/toolkit/components/startup/tests/browser/head.js
@@ -0,0 +1,29 @@
+/* Any copyright is dedicated to the Public Domain.
+ * http://creativecommons.org/publicdomain/zero/1.0/ */
+
+"use strict";
+
+const XUL_NS = "http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul";
+
+function whenBrowserLoaded(browser, callback) {
+ return BrowserTestUtils.browserLoaded(browser).then(callback);
+}
+
+function waitForOnBeforeUnloadDialog(browser, callback) {
+ browser.addEventListener("DOMWillOpenModalDialog", function onModalDialog(event) {
+ if (Cu.isCrossProcessWrapper(event.target)) {
+ // This event fires in both the content and chrome processes. We
+ // want to ignore the one in the content process.
+ return;
+ }
+
+ browser.removeEventListener("DOMWillOpenModalDialog", onModalDialog, true);
+
+ executeSoon(() => {
+ let stack = browser.parentNode;
+ let dialogs = stack.getElementsByTagNameNS(XUL_NS, "tabmodalprompt");
+ let {button0, button1} = dialogs[0].ui;
+ callback(button0, button1);
+ });
+ }, true);
+}
diff --git a/toolkit/components/startup/tests/unit/.eslintrc.js b/toolkit/components/startup/tests/unit/.eslintrc.js
new file mode 100644
index 000000000..d35787cd2
--- /dev/null
+++ b/toolkit/components/startup/tests/unit/.eslintrc.js
@@ -0,0 +1,7 @@
+"use strict";
+
+module.exports = {
+ "extends": [
+ "../../../../../testing/xpcshell/xpcshell.eslintrc.js"
+ ]
+};
diff --git a/toolkit/components/startup/tests/unit/head_startup.js b/toolkit/components/startup/tests/unit/head_startup.js
new file mode 100644
index 000000000..2466f70ee
--- /dev/null
+++ b/toolkit/components/startup/tests/unit/head_startup.js
@@ -0,0 +1,30 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+const XULRUNTIME_CONTRACTID = "@mozilla.org/xre/runtime;1";
+const XULRUNTIME_CID = Components.ID("7685dac8-3637-4660-a544-928c5ec0e714}");
+
+Components.utils.import("resource://gre/modules/XPCOMUtils.jsm");
+
+var gAppInfo = null;
+
+function createAppInfo(ID, name, version, platformVersion="1.0") {
+ let tmp = {};
+ Components.utils.import("resource://testing-common/AppInfo.jsm", tmp);
+ gAppInfo = tmp.newAppInfo({
+ ID, name, version, platformVersion,
+ crashReporter: true,
+ replacedLockTime: 0,
+ });
+
+ let XULAppInfoFactory = {
+ createInstance: function (outer, iid) {
+ if (outer != null)
+ throw Components.results.NS_ERROR_NO_AGGREGATION;
+ return gAppInfo.QueryInterface(iid);
+ }
+ };
+ let registrar = Components.manager.QueryInterface(Ci.nsIComponentRegistrar);
+ registrar.registerFactory(XULRUNTIME_CID, "XULRuntime",
+ XULRUNTIME_CONTRACTID, XULAppInfoFactory);
+}
diff --git a/toolkit/components/startup/tests/unit/test_startup_crash.js b/toolkit/components/startup/tests/unit/test_startup_crash.js
new file mode 100644
index 000000000..283633086
--- /dev/null
+++ b/toolkit/components/startup/tests/unit/test_startup_crash.js
@@ -0,0 +1,300 @@
+/* Any copyright is dedicated to the Public Domain.
+ http://creativecommons.org/publicdomain/zero/1.0/ */
+
+Components.utils.import("resource://gre/modules/Services.jsm");
+
+var Cc = Components.classes;
+var Ci = Components.interfaces;
+
+createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "10.0");
+
+var prefService = Services.prefs;
+var appStartup = Cc["@mozilla.org/toolkit/app-startup;1"].
+ getService(Ci.nsIAppStartup);
+
+const pref_last_success = "toolkit.startup.last_success";
+const pref_recent_crashes = "toolkit.startup.recent_crashes";
+const pref_max_resumed_crashes = "toolkit.startup.max_resumed_crashes";
+const pref_always_use_safe_mode = "toolkit.startup.always_use_safe_mode";
+
+function run_test() {
+ prefService.setBoolPref(pref_always_use_safe_mode, true);
+
+ resetTestEnv(0);
+
+ test_trackStartupCrashBegin();
+ test_trackStartupCrashEnd();
+ test_trackStartupCrashBegin_safeMode();
+ test_trackStartupCrashEnd_safeMode();
+ test_maxResumed();
+ resetTestEnv(0);
+
+ prefService.clearUserPref(pref_always_use_safe_mode);
+}
+
+// reset prefs to default
+function resetTestEnv(replacedLockTime) {
+ try {
+ // call begin to reset mStartupCrashTrackingEnded
+ appStartup.trackStartupCrashBegin();
+ } catch (x) { }
+ prefService.setIntPref(pref_max_resumed_crashes, 2);
+ prefService.clearUserPref(pref_recent_crashes);
+ gAppInfo.replacedLockTime = replacedLockTime;
+ prefService.clearUserPref(pref_last_success);
+}
+
+function now_seconds() {
+ return ms_to_s(Date.now());
+}
+
+function ms_to_s(ms) {
+ return Math.floor(ms / 1000);
+}
+
+function test_trackStartupCrashBegin() {
+ let max_resumed = prefService.getIntPref(pref_max_resumed_crashes);
+ do_check_false(gAppInfo.inSafeMode);
+
+ // first run with startup crash tracking - existing profile lock
+ let replacedLockTime = Date.now();
+ resetTestEnv(replacedLockTime);
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(prefService.prefHasUserValue(pref_last_success));
+ do_check_eq(replacedLockTime, gAppInfo.replacedLockTime);
+ try {
+ do_check_false(appStartup.trackStartupCrashBegin());
+ do_throw("Should have thrown since last_success is not set");
+ } catch (x) { }
+
+ do_check_false(prefService.prefHasUserValue(pref_last_success));
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // first run with startup crash tracking - no existing profile lock
+ replacedLockTime = 0;
+ resetTestEnv(replacedLockTime);
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(prefService.prefHasUserValue(pref_last_success));
+ do_check_eq(replacedLockTime, gAppInfo.replacedLockTime);
+ try {
+ do_check_false(appStartup.trackStartupCrashBegin());
+ do_throw("Should have thrown since last_success is not set");
+ } catch (x) { }
+
+ do_check_false(prefService.prefHasUserValue(pref_last_success));
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup - last startup was success
+ replacedLockTime = Date.now();
+ resetTestEnv(replacedLockTime);
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ do_check_eq(ms_to_s(replacedLockTime), prefService.getIntPref(pref_last_success));
+ do_check_false(appStartup.trackStartupCrashBegin());
+ do_check_eq(ms_to_s(replacedLockTime), prefService.getIntPref(pref_last_success));
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup with 1 recent crash
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_recent_crashes, 1);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ do_check_false(appStartup.trackStartupCrashBegin());
+ do_check_eq(ms_to_s(replacedLockTime), prefService.getIntPref(pref_last_success));
+ do_check_eq(1, prefService.getIntPref(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup with max_resumed_crashes crash
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_recent_crashes, max_resumed);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ do_check_false(appStartup.trackStartupCrashBegin());
+ do_check_eq(ms_to_s(replacedLockTime), prefService.getIntPref(pref_last_success));
+ do_check_eq(max_resumed, prefService.getIntPref(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup with too many recent crashes
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ do_check_true(appStartup.trackStartupCrashBegin());
+ // should remain the same since the last startup was not a crash
+ do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+ do_check_true(appStartup.automaticSafeModeNecessary);
+
+ // normal startup with too many recent crashes and startup crash tracking disabled
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_max_resumed_crashes, -1);
+ prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ do_check_false(appStartup.trackStartupCrashBegin());
+ // should remain the same since the last startup was not a crash
+ do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+ // returns false when disabled
+ do_check_false(appStartup.automaticSafeModeNecessary);
+ do_check_eq(-1, prefService.getIntPref(pref_max_resumed_crashes));
+
+ // normal startup after 1 non-recent crash (1 year ago), no other recent
+ replacedLockTime = Date.now() - 365 * 24 * 60 * 60 * 1000;
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 365 * 24 * 60 * 60);
+ do_check_false(appStartup.trackStartupCrashBegin());
+ // recent crash count pref should be unset since the last crash was not recent
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup after 1 crash (1 minute ago), no other recent
+ replacedLockTime = Date.now() - 60 * 1000;
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 60 * 60); // last success - 1 hour ago
+ do_check_false(appStartup.trackStartupCrashBegin());
+ // recent crash count pref should be created with value 1
+ do_check_eq(1, prefService.getIntPref(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup after another crash (1 minute ago), 1 already
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 60 * 60); // last success - 1 hour ago
+ replacedLockTime = Date.now() - 60 * 1000;
+ gAppInfo.replacedLockTime = replacedLockTime;
+ do_check_false(appStartup.trackStartupCrashBegin());
+ // recent crash count pref should be incremented by 1
+ do_check_eq(2, prefService.getIntPref(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // normal startup after another crash (1 minute ago), 2 already
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 60 * 60); // last success - 1 hour ago
+ do_check_true(appStartup.trackStartupCrashBegin());
+ // recent crash count pref should be incremented by 1
+ do_check_eq(3, prefService.getIntPref(pref_recent_crashes));
+ do_check_true(appStartup.automaticSafeModeNecessary);
+
+ // normal startup after 1 non-recent crash (1 year ago), 3 crashes already
+ replacedLockTime = Date.now() - 365 * 24 * 60 * 60 * 1000;
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 60 * 60); // last success - 1 hour ago
+ do_check_false(appStartup.trackStartupCrashBegin());
+ // recent crash count should be unset since the last crash was not recent
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+}
+
+function test_trackStartupCrashEnd() {
+ // successful startup with no last_success (upgrade test)
+ let replacedLockTime = Date.now() - 10 * 1000; // 10s ago
+ resetTestEnv(replacedLockTime);
+ try {
+ appStartup.trackStartupCrashBegin(); // required to be called before end
+ do_throw("Should have thrown since last_success is not set");
+ } catch (x) { }
+ appStartup.trackStartupCrashEnd();
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_false(prefService.prefHasUserValue(pref_last_success));
+
+ // successful startup - should set last_success
+ replacedLockTime = Date.now() - 10 * 1000; // 10s ago
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ appStartup.trackStartupCrashBegin(); // required to be called before end
+ appStartup.trackStartupCrashEnd();
+ // ensure last_success was set since we have declared a succesful startup
+ // main timestamp doesn't get set in XPCShell so approximate with now
+ do_check_true(prefService.getIntPref(pref_last_success) <= now_seconds());
+ do_check_true(prefService.getIntPref(pref_last_success) >= now_seconds() - 4 * 60 * 60);
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+
+ // successful startup with 1 recent crash
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ prefService.setIntPref(pref_recent_crashes, 1);
+ appStartup.trackStartupCrashBegin(); // required to be called before end
+ appStartup.trackStartupCrashEnd();
+ // ensure recent_crashes was cleared since we have declared a succesful startup
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+}
+
+function test_trackStartupCrashBegin_safeMode() {
+ gAppInfo.inSafeMode = true;
+ resetTestEnv(0);
+ let max_resumed = prefService.getIntPref(pref_max_resumed_crashes);
+
+ // check manual safe mode doesn't change prefs without crash
+ let replacedLockTime = Date.now() - 10 * 1000; // 10s ago
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_true(prefService.prefHasUserValue(pref_last_success));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+ do_check_false(appStartup.trackStartupCrashBegin());
+ do_check_false(prefService.prefHasUserValue(pref_recent_crashes));
+ do_check_true(prefService.prefHasUserValue(pref_last_success));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+
+ // check forced safe mode doesn't change prefs without crash
+ replacedLockTime = Date.now() - 10 * 1000; // 10s ago
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime));
+ prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+
+ do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+ do_check_true(prefService.prefHasUserValue(pref_last_success));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+ do_check_true(appStartup.trackStartupCrashBegin());
+ do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+ do_check_true(prefService.prefHasUserValue(pref_last_success));
+ do_check_true(appStartup.automaticSafeModeNecessary);
+
+ // check forced safe mode after old crash
+ replacedLockTime = Date.now() - 365 * 24 * 60 * 60 * 1000;
+ resetTestEnv(replacedLockTime);
+ // one year ago
+ let last_success = ms_to_s(replacedLockTime) - 365 * 24 * 60 * 60;
+ prefService.setIntPref(pref_last_success, last_success);
+ prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+ do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+ do_check_true(prefService.prefHasUserValue(pref_last_success));
+ do_check_true(appStartup.automaticSafeModeNecessary);
+ do_check_true(appStartup.trackStartupCrashBegin());
+ do_check_eq(max_resumed + 1, prefService.getIntPref(pref_recent_crashes));
+ do_check_eq(last_success, prefService.getIntPref(pref_last_success));
+ do_check_true(appStartup.automaticSafeModeNecessary);
+}
+
+function test_trackStartupCrashEnd_safeMode() {
+ gAppInfo.inSafeMode = true;
+ let replacedLockTime = Date.now();
+ resetTestEnv(replacedLockTime);
+ let max_resumed = prefService.getIntPref(pref_max_resumed_crashes);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 24 * 60 * 60);
+
+ // ensure recent_crashes were not cleared in manual safe mode
+ prefService.setIntPref(pref_recent_crashes, 1);
+ appStartup.trackStartupCrashBegin(); // required to be called before end
+ appStartup.trackStartupCrashEnd();
+ do_check_eq(1, prefService.getIntPref(pref_recent_crashes));
+
+ // recent_crashes should be set to max_resumed in forced safe mode to allow the user
+ // to try and start in regular mode after making changes.
+ prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+ appStartup.trackStartupCrashBegin(); // required to be called before end
+ appStartup.trackStartupCrashEnd();
+ do_check_eq(max_resumed, prefService.getIntPref(pref_recent_crashes));
+}
+
+function test_maxResumed() {
+ resetTestEnv(0);
+ gAppInfo.inSafeMode = false;
+ let max_resumed = prefService.getIntPref(pref_max_resumed_crashes);
+ let replacedLockTime = Date.now();
+ resetTestEnv(replacedLockTime);
+ prefService.setIntPref(pref_max_resumed_crashes, -1);
+
+ prefService.setIntPref(pref_recent_crashes, max_resumed + 1);
+ prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime) - 24 * 60 * 60);
+ appStartup.trackStartupCrashBegin();
+ // should remain the same since the last startup was not a crash
+ do_check_eq(max_resumed + 2, prefService.getIntPref(pref_recent_crashes));
+ do_check_false(appStartup.automaticSafeModeNecessary);
+}
diff --git a/toolkit/components/startup/tests/unit/xpcshell.ini b/toolkit/components/startup/tests/unit/xpcshell.ini
new file mode 100644
index 000000000..294800ee3
--- /dev/null
+++ b/toolkit/components/startup/tests/unit/xpcshell.ini
@@ -0,0 +1,6 @@
+[DEFAULT]
+head = head_startup.js
+tail =
+skip-if = toolkit == 'android'
+
+[test_startup_crash.js]