mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-10-17 00:24:30 +00:00
393 lines
9.9 KiB
JavaScript
393 lines
9.9 KiB
JavaScript
/* Any copyright is dedicated to the Public Domain.
|
|
http://creativecommons.org/publicdomain/zero/1.0/ */
|
|
|
|
/**
|
|
* This file tests the DeferredTask.jsm module.
|
|
*/
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// Globals
|
|
|
|
var { classes: Cc, interfaces: Ci, utils: Cu, results: Cr } = Components;
|
|
|
|
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
|
|
|
|
XPCOMUtils.defineLazyModuleGetter(this, "DeferredTask",
|
|
"resource://gre/modules/DeferredTask.jsm");
|
|
XPCOMUtils.defineLazyModuleGetter(this, "Promise",
|
|
"resource://gre/modules/Promise.jsm");
|
|
|
|
/**
|
|
* Due to the nature of this module, most of the tests are time-dependent. All
|
|
* the timeouts are designed to occur at multiples of this granularity value,
|
|
* in milliseconds, that should be high enough to prevent intermittent failures,
|
|
* but low enough to prevent an excessive overall test execution time.
|
|
*/
|
|
const T = 100;
|
|
|
|
/**
|
|
* Waits for the specified timeout before resolving the returned promise.
|
|
*/
|
|
function promiseTimeout(aTimeoutMs)
|
|
{
|
|
let deferred = Promise.defer();
|
|
do_timeout(aTimeoutMs, deferred.resolve);
|
|
return deferred.promise;
|
|
}
|
|
|
|
function run_test()
|
|
{
|
|
run_next_test();
|
|
}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
//// Tests
|
|
|
|
/**
|
|
* Creates a simple DeferredTask and executes it once.
|
|
*/
|
|
add_test(function test_arm_simple()
|
|
{
|
|
new DeferredTask(run_next_test, 10).arm();
|
|
});
|
|
|
|
/**
|
|
* Checks that the delay set for the task is respected.
|
|
*/
|
|
add_test(function test_arm_delay_respected()
|
|
{
|
|
let executed1 = false;
|
|
let executed2 = false;
|
|
|
|
new DeferredTask(function () {
|
|
executed1 = true;
|
|
do_check_false(executed2);
|
|
}, 1*T).arm();
|
|
|
|
new DeferredTask(function () {
|
|
executed2 = true;
|
|
do_check_true(executed1);
|
|
run_next_test();
|
|
}, 2*T).arm();
|
|
});
|
|
|
|
/**
|
|
* Checks that calling "arm" again does not introduce further delay.
|
|
*/
|
|
add_test(function test_arm_delay_notrestarted()
|
|
{
|
|
let executed = false;
|
|
|
|
// Create a task that will run later.
|
|
let deferredTask = new DeferredTask(() => { executed = true; }, 4*T);
|
|
deferredTask.arm();
|
|
|
|
// Before the task starts, call "arm" again.
|
|
do_timeout(2*T, () => deferredTask.arm());
|
|
|
|
// The "arm" call should not have introduced further delays.
|
|
do_timeout(5*T, function () {
|
|
do_check_true(executed);
|
|
run_next_test();
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Checks that a task runs only once when armed multiple times synchronously.
|
|
*/
|
|
add_test(function test_arm_coalesced()
|
|
{
|
|
let executed = false;
|
|
|
|
let deferredTask = new DeferredTask(function () {
|
|
do_check_false(executed);
|
|
executed = true;
|
|
run_next_test();
|
|
}, 50);
|
|
|
|
deferredTask.arm();
|
|
deferredTask.arm();
|
|
});
|
|
|
|
/**
|
|
* Checks that a task runs only once when armed multiple times synchronously,
|
|
* even when it has been created with a delay of zero milliseconds.
|
|
*/
|
|
add_test(function test_arm_coalesced_nodelay()
|
|
{
|
|
let executed = false;
|
|
|
|
let deferredTask = new DeferredTask(function () {
|
|
do_check_false(executed);
|
|
executed = true;
|
|
run_next_test();
|
|
}, 0);
|
|
|
|
deferredTask.arm();
|
|
deferredTask.arm();
|
|
});
|
|
|
|
/**
|
|
* Checks that a task can be armed again while running.
|
|
*/
|
|
add_test(function test_arm_recursive()
|
|
{
|
|
let executed = false;
|
|
|
|
let deferredTask = new DeferredTask(function () {
|
|
if (!executed) {
|
|
executed = true;
|
|
deferredTask.arm();
|
|
} else {
|
|
run_next_test();
|
|
}
|
|
}, 50);
|
|
|
|
deferredTask.arm();
|
|
});
|
|
|
|
/**
|
|
* Checks that calling "arm" while an asynchronous task is running waits until
|
|
* the task is finished before restarting the delay.
|
|
*/
|
|
add_test(function test_arm_async()
|
|
{
|
|
let finishedExecution = false;
|
|
let finishedExecutionAgain = false;
|
|
|
|
// Create a task that will run later.
|
|
let deferredTask = new DeferredTask(function* () {
|
|
yield promiseTimeout(4*T);
|
|
if (!finishedExecution) {
|
|
finishedExecution = true;
|
|
} else if (!finishedExecutionAgain) {
|
|
finishedExecutionAgain = true;
|
|
}
|
|
}, 2*T);
|
|
deferredTask.arm();
|
|
|
|
// While the task is running, call "arm" again. This will result in a wait
|
|
// of 2*T until the task finishes, then another 2*T for the normal task delay
|
|
// specified on construction.
|
|
do_timeout(4*T, function () {
|
|
do_check_true(deferredTask.isRunning);
|
|
do_check_false(finishedExecution);
|
|
deferredTask.arm();
|
|
});
|
|
|
|
// This will fail in case the task was started without waiting 2*T after it
|
|
// has finished.
|
|
do_timeout(7*T, function () {
|
|
do_check_false(deferredTask.isRunning);
|
|
do_check_true(finishedExecution);
|
|
});
|
|
|
|
// This is in the middle of the second execution.
|
|
do_timeout(10*T, function () {
|
|
do_check_true(deferredTask.isRunning);
|
|
do_check_false(finishedExecutionAgain);
|
|
});
|
|
|
|
// Wait enough time to verify that the task was executed as expected.
|
|
do_timeout(13*T, function () {
|
|
do_check_false(deferredTask.isRunning);
|
|
do_check_true(finishedExecutionAgain);
|
|
run_next_test();
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Checks that an armed task can be disarmed.
|
|
*/
|
|
add_test(function test_disarm()
|
|
{
|
|
// Create a task that will run later.
|
|
let deferredTask = new DeferredTask(function () {
|
|
do_throw("This task should not run.");
|
|
}, 2*T);
|
|
deferredTask.arm();
|
|
|
|
// Disable execution later, but before the task starts.
|
|
do_timeout(1*T, () => deferredTask.disarm());
|
|
|
|
// Wait enough time to verify that the task did not run.
|
|
do_timeout(3*T, run_next_test);
|
|
});
|
|
|
|
/**
|
|
* Checks that calling "disarm" allows the delay to be restarted.
|
|
*/
|
|
add_test(function test_disarm_delay_restarted()
|
|
{
|
|
let executed = false;
|
|
|
|
let deferredTask = new DeferredTask(() => { executed = true; }, 4*T);
|
|
deferredTask.arm();
|
|
|
|
do_timeout(2*T, function () {
|
|
deferredTask.disarm();
|
|
deferredTask.arm();
|
|
});
|
|
|
|
do_timeout(5*T, function () {
|
|
do_check_false(executed);
|
|
});
|
|
|
|
do_timeout(7*T, function () {
|
|
do_check_true(executed);
|
|
run_next_test();
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Checks that calling "disarm" while an asynchronous task is running does not
|
|
* prevent the task to finish.
|
|
*/
|
|
add_test(function test_disarm_async()
|
|
{
|
|
let finishedExecution = false;
|
|
|
|
let deferredTask = new DeferredTask(function* () {
|
|
deferredTask.arm();
|
|
yield promiseTimeout(2*T);
|
|
finishedExecution = true;
|
|
}, 1*T);
|
|
deferredTask.arm();
|
|
|
|
do_timeout(2*T, function () {
|
|
do_check_true(deferredTask.isRunning);
|
|
do_check_true(deferredTask.isArmed);
|
|
do_check_false(finishedExecution);
|
|
deferredTask.disarm();
|
|
});
|
|
|
|
do_timeout(4*T, function () {
|
|
do_check_false(deferredTask.isRunning);
|
|
do_check_false(deferredTask.isArmed);
|
|
do_check_true(finishedExecution);
|
|
run_next_test();
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Checks that calling "arm" immediately followed by "disarm" while an
|
|
* asynchronous task is running does not cause it to run again.
|
|
*/
|
|
add_test(function test_disarm_immediate_async()
|
|
{
|
|
let executed = false;
|
|
|
|
let deferredTask = new DeferredTask(function* () {
|
|
do_check_false(executed);
|
|
executed = true;
|
|
yield promiseTimeout(2*T);
|
|
}, 1*T);
|
|
deferredTask.arm();
|
|
|
|
do_timeout(2*T, function () {
|
|
do_check_true(deferredTask.isRunning);
|
|
do_check_false(deferredTask.isArmed);
|
|
deferredTask.arm();
|
|
deferredTask.disarm();
|
|
});
|
|
|
|
do_timeout(4*T, function () {
|
|
do_check_true(executed);
|
|
do_check_false(deferredTask.isRunning);
|
|
do_check_false(deferredTask.isArmed);
|
|
run_next_test();
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Checks the isArmed and isRunning properties with a synchronous task.
|
|
*/
|
|
add_test(function test_isArmed_isRunning()
|
|
{
|
|
let deferredTask = new DeferredTask(function () {
|
|
do_check_true(deferredTask.isRunning);
|
|
do_check_false(deferredTask.isArmed);
|
|
deferredTask.arm();
|
|
do_check_true(deferredTask.isArmed);
|
|
deferredTask.disarm();
|
|
do_check_false(deferredTask.isArmed);
|
|
run_next_test();
|
|
}, 50);
|
|
|
|
do_check_false(deferredTask.isArmed);
|
|
deferredTask.arm();
|
|
do_check_true(deferredTask.isArmed);
|
|
do_check_false(deferredTask.isRunning);
|
|
});
|
|
|
|
/**
|
|
* Checks that the "finalize" method executes a synchronous task.
|
|
*/
|
|
add_test(function test_finalize()
|
|
{
|
|
let executed = false;
|
|
let timePassed = false;
|
|
|
|
let deferredTask = new DeferredTask(function () {
|
|
do_check_false(timePassed);
|
|
executed = true;
|
|
}, 2*T);
|
|
deferredTask.arm();
|
|
|
|
do_timeout(1*T, () => { timePassed = true; });
|
|
|
|
// This should trigger the immediate execution of the task.
|
|
deferredTask.finalize().then(function () {
|
|
do_check_true(executed);
|
|
run_next_test();
|
|
});
|
|
});
|
|
|
|
/**
|
|
* Checks that the "finalize" method executes the task again from start to
|
|
* finish in case it is already running.
|
|
*/
|
|
add_test(function test_finalize_executes_entirely()
|
|
{
|
|
let executed = false;
|
|
let executedAgain = false;
|
|
let timePassed = false;
|
|
|
|
let deferredTask = new DeferredTask(function* () {
|
|
// The first time, we arm the timer again and set up the finalization.
|
|
if (!executed) {
|
|
deferredTask.arm();
|
|
do_check_true(deferredTask.isArmed);
|
|
do_check_true(deferredTask.isRunning);
|
|
|
|
deferredTask.finalize().then(function () {
|
|
// When we reach this point, the task must be finished.
|
|
do_check_true(executedAgain);
|
|
do_check_false(timePassed);
|
|
do_check_false(deferredTask.isArmed);
|
|
do_check_false(deferredTask.isRunning);
|
|
run_next_test();
|
|
});
|
|
|
|
// The second execution triggered by the finalization waits 1*T for the
|
|
// current task to finish (see the timeout below), but then it must not
|
|
// wait for the 2*T specified on construction as normal task delay. The
|
|
// second execution will finish after the timeout below has passed again,
|
|
// for a total of 2*T of wait time.
|
|
do_timeout(3*T, () => { timePassed = true; });
|
|
}
|
|
|
|
yield promiseTimeout(1*T);
|
|
|
|
// Just before finishing, indicate if we completed the second execution.
|
|
if (executed) {
|
|
do_check_true(deferredTask.isRunning);
|
|
executedAgain = true;
|
|
} else {
|
|
executed = true;
|
|
}
|
|
}, 2*T);
|
|
|
|
deferredTask.arm();
|
|
});
|