diff options
Diffstat (limited to 'toolkit/modules/tests/xpcshell/test_DeferredTask.js')
| -rw-r--r-- | toolkit/modules/tests/xpcshell/test_DeferredTask.js | 390 |
1 files changed, 390 insertions, 0 deletions
diff --git a/toolkit/modules/tests/xpcshell/test_DeferredTask.js b/toolkit/modules/tests/xpcshell/test_DeferredTask.js new file mode 100644 index 000000000..441f9054c --- /dev/null +++ b/toolkit/modules/tests/xpcshell/test_DeferredTask.js @@ -0,0 +1,390 @@ +/* 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(); +}); |