The Tor Browser: comparison toolkit/modules/tests/xpcshell/test_DeferredTask.js

comparison: toolkit/modules/tests/xpcshell/test_DeferredTask.js

toolkit/modules/tests/xpcshell/test_DeferredTask.js

changeset 0: 6474c204b198

equal deleted inserted replaced

--1:000000000000
+:b1d6d31a81cf
+/* Any copyright is dedicated to the Public Domain.
+http://creativecommons.org/publicdomain/zero/1.0/ */
+/**
+* This file tests the DeferredTask.jsm module.
+*/
+////////////////////////////////////////////////////////////////////////////////
+/// Globals
+const { 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();
+});