diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-19 00:47:55 +0000 |
commit | 26a029d407be480d791972afb5975cf62c9360a6 (patch) | |
tree | f435a8308119effd964b339f76abb83a57c29483 /toolkit/components/startup/tests/unit/test_startup_crash.js | |
parent | Initial commit. (diff) | |
download | firefox-26a029d407be480d791972afb5975cf62c9360a6.tar.xz firefox-26a029d407be480d791972afb5975cf62c9360a6.zip |
Adding upstream version 124.0.1.upstream/124.0.1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'toolkit/components/startup/tests/unit/test_startup_crash.js')
-rw-r--r-- | toolkit/components/startup/tests/unit/test_startup_crash.js | 329 |
1 files changed, 329 insertions, 0 deletions
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 0000000000..7beb519a01 --- /dev/null +++ b/toolkit/components/startup/tests/unit/test_startup_crash.js @@ -0,0 +1,329 @@ +/* Any copyright is dedicated to the Public Domain. + http://creativecommons.org/publicdomain/zero/1.0/ */ + +createAppInfo("xpcshell@tests.mozilla.org", "XPCShell", "1", "10.0"); + +var prefService = Services.prefs; +var appStartup = Services.startup; + +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); + Assert.ok(!gAppInfo.inSafeMode); + + // first run with startup crash tracking - existing profile lock + let replacedLockTime = Date.now(); + resetTestEnv(replacedLockTime); + Assert.ok(!prefService.prefHasUserValue(pref_recent_crashes)); + Assert.ok(!prefService.prefHasUserValue(pref_last_success)); + Assert.equal(replacedLockTime, gAppInfo.replacedLockTime); + try { + Assert.ok(!appStartup.trackStartupCrashBegin()); + do_throw("Should have thrown since last_success is not set"); + } catch (x) {} + + Assert.ok(!prefService.prefHasUserValue(pref_last_success)); + Assert.ok(!prefService.prefHasUserValue(pref_recent_crashes)); + Assert.ok(!appStartup.automaticSafeModeNecessary); + + // first run with startup crash tracking - no existing profile lock + replacedLockTime = 0; + resetTestEnv(replacedLockTime); + Assert.ok(!prefService.prefHasUserValue(pref_recent_crashes)); + Assert.ok(!prefService.prefHasUserValue(pref_last_success)); + Assert.equal(replacedLockTime, gAppInfo.replacedLockTime); + try { + Assert.ok(!appStartup.trackStartupCrashBegin()); + do_throw("Should have thrown since last_success is not set"); + } catch (x) {} + + Assert.ok(!prefService.prefHasUserValue(pref_last_success)); + Assert.ok(!prefService.prefHasUserValue(pref_recent_crashes)); + Assert.ok(!appStartup.automaticSafeModeNecessary); + + // normal startup - last startup was success + replacedLockTime = Date.now(); + resetTestEnv(replacedLockTime); + Assert.ok(!prefService.prefHasUserValue(pref_recent_crashes)); + prefService.setIntPref(pref_last_success, ms_to_s(replacedLockTime)); + Assert.equal( + ms_to_s(replacedLockTime), + prefService.getIntPref(pref_last_success) + ); + Assert.ok(!appStartup.trackStartupCrashBegin()); + Assert.equal( + ms_to_s(replacedLockTime), + prefService.getIntPref(pref_last_success) + ); + Assert.ok(!prefService.prefHasUserValue(pref_recent_crashes)); + Assert.ok(!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)); + Assert.ok(!appStartup.trackStartupCrashBegin()); + Assert.equal( + ms_to_s(replacedLockTime), + prefService.getIntPref(pref_last_success) + ); + Assert.equal(1, prefService.getIntPref(pref_recent_crashes)); + Assert.ok(!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)); + Assert.ok(!appStartup.trackStartupCrashBegin()); + Assert.equal( + ms_to_s(replacedLockTime), + prefService.getIntPref(pref_last_success) + ); + Assert.equal(max_resumed, prefService.getIntPref(pref_recent_crashes)); + Assert.ok(!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)); + Assert.ok(appStartup.trackStartupCrashBegin()); + // should remain the same since the last startup was not a crash + Assert.equal(max_resumed + 1, prefService.getIntPref(pref_recent_crashes)); + Assert.ok(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)); + Assert.ok(!appStartup.trackStartupCrashBegin()); + // should remain the same since the last startup was not a crash + Assert.equal(max_resumed + 1, prefService.getIntPref(pref_recent_crashes)); + // returns false when disabled + Assert.ok(!appStartup.automaticSafeModeNecessary); + Assert.equal(-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 + ); + Assert.ok(!appStartup.trackStartupCrashBegin()); + // recent crash count pref should be unset since the last crash was not recent + Assert.ok(!prefService.prefHasUserValue(pref_recent_crashes)); + Assert.ok(!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 + Assert.ok(!appStartup.trackStartupCrashBegin()); + // recent crash count pref should be created with value 1 + Assert.equal(1, prefService.getIntPref(pref_recent_crashes)); + Assert.ok(!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; + Assert.ok(!appStartup.trackStartupCrashBegin()); + // recent crash count pref should be incremented by 1 + Assert.equal(2, prefService.getIntPref(pref_recent_crashes)); + Assert.ok(!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 + Assert.ok(appStartup.trackStartupCrashBegin()); + // recent crash count pref should be incremented by 1 + Assert.equal(3, prefService.getIntPref(pref_recent_crashes)); + Assert.ok(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 + Assert.ok(!appStartup.trackStartupCrashBegin()); + // recent crash count should be unset since the last crash was not recent + Assert.ok(!prefService.prefHasUserValue(pref_recent_crashes)); + Assert.ok(!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(); + Assert.ok(!prefService.prefHasUserValue(pref_recent_crashes)); + Assert.ok(!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 + Assert.ok(prefService.getIntPref(pref_last_success) <= now_seconds()); + Assert.ok( + prefService.getIntPref(pref_last_success) >= now_seconds() - 4 * 60 * 60 + ); + Assert.ok(!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 + Assert.ok(!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)); + + Assert.ok(!prefService.prefHasUserValue(pref_recent_crashes)); + Assert.ok(prefService.prefHasUserValue(pref_last_success)); + Assert.ok(!appStartup.automaticSafeModeNecessary); + Assert.ok(!appStartup.trackStartupCrashBegin()); + Assert.ok(!prefService.prefHasUserValue(pref_recent_crashes)); + Assert.ok(prefService.prefHasUserValue(pref_last_success)); + Assert.ok(!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); + + Assert.equal(max_resumed + 1, prefService.getIntPref(pref_recent_crashes)); + Assert.ok(prefService.prefHasUserValue(pref_last_success)); + Assert.ok(!appStartup.automaticSafeModeNecessary); + Assert.ok(appStartup.trackStartupCrashBegin()); + Assert.equal(max_resumed + 1, prefService.getIntPref(pref_recent_crashes)); + Assert.ok(prefService.prefHasUserValue(pref_last_success)); + Assert.ok(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); + Assert.equal(max_resumed + 1, prefService.getIntPref(pref_recent_crashes)); + Assert.ok(prefService.prefHasUserValue(pref_last_success)); + Assert.ok(appStartup.automaticSafeModeNecessary); + Assert.ok(appStartup.trackStartupCrashBegin()); + Assert.equal(max_resumed + 1, prefService.getIntPref(pref_recent_crashes)); + Assert.equal(last_success, prefService.getIntPref(pref_last_success)); + Assert.ok(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(); + Assert.equal(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(); + Assert.equal(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 + Assert.equal(max_resumed + 2, prefService.getIntPref(pref_recent_crashes)); + Assert.ok(!appStartup.automaticSafeModeNecessary); +} |