The Tor Browser: toolkit/modules/tests/xpcshell/test_AsyncShutdown.js@6474c204b198 (annotated)

toolkit/modules/tests/xpcshell/test_AsyncShutdown.js@6474c204b198 (annotated)

toolkit/modules/tests/xpcshell/test_AsyncShutdown.js

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 let Cu = Components.utils;
 Cu.import("resource://gre/modules/Services.jsm");
 Cu.import("resource://gre/modules/Promise.jsm");
 Cu.import("resource://gre/modules/AsyncShutdown.jsm");
 Services.prefs.setBoolPref("toolkit.asyncshutdown.testing", true);
 /**
  * An asynchronous task that takes several ticks to complete.
  *
  * @param {*=} resolution The value with which the resulting promise will be
  * resolved once the task is complete. This may be a rejected promise,
  * in which case the resulting promise will itself be rejected.
  * @param {object=} outResult An object modified by side-effect during the task.
  * Initially, its field |isFinished| is set to |false|. Once the task is
  * complete, its field |isFinished| is set to |true|.
  *
  * @return {promise} A promise fulfilled once the task is complete
  */
 function longRunningAsyncTask(resolution = undefined, outResult = {}) {
   outResult.isFinished = false;
   if (!("countFinished" in outResult)) {
     outResult.countFinished = 0;
   }
   let deferred = Promise.defer();
   do_timeout(100, function() {
     ++outResult.countFinished;
     outResult.isFinished = true;
     deferred.resolve(resolution);
   });
   return deferred.promise;
 }
 /**
  * Generate a unique notification topic.
  */
 function getUniqueTopic() {
   const PREFIX = "testing-phases-";
   return PREFIX + ++getUniqueTopic.counter;
 }
 getUniqueTopic.counter = 0;
 add_task(function test_no_condition() {
   do_print("Testing a phase with no condition");
   let topic = getUniqueTopic();
   AsyncShutdown._getPhase(topic);
   Services.obs.notifyObservers(null, topic, null);
   do_print("Phase with no condition didn't lock");
 });
 add_task(function test_simple_async() {
   do_print("Testing various combinations of a phase with a single condition");
   for (let arg of [undefined, null, "foo", 100, new Error("BOOM")]) {
     for (let resolution of [arg, Promise.reject(arg)]) {
       for (let success of [false, true]) {
         for (let state of [[null],
                            [],
                            [() => "some state"],
                            [function() {
                              throw new Error("State BOOM"); }],
                            [function() {
                              return {
                                toJSON: function() {
                                  throw new Error("State.toJSON BOOM");
                                }
                              };
                            }]]) {
           // Asynchronous phase
           do_print("Asynchronous test with " + arg + ", " + resolution);
           let topic = getUniqueTopic();
           let outParam = { isFinished: false };
           AsyncShutdown._getPhase(topic).addBlocker(
             "Async test",
               function() {
                 if (success) {
                   return longRunningAsyncTask(resolution, outParam);
                 } else {
                   throw resolution;
                 }
               },
               ...state
           );
           do_check_false(outParam.isFinished);
           Services.obs.notifyObservers(null, topic, null);
           do_check_eq(outParam.isFinished, success);
         }
       }
       // Synchronous phase - just test that we don't throw/freeze
       do_print("Synchronous test with " + arg + ", " + resolution);
       let topic = getUniqueTopic();
       AsyncShutdown._getPhase(topic).addBlocker(
         "Sync test",
         resolution
       );
       Services.obs.notifyObservers(null, topic, null);
     }
   }
 });
 add_task(function test_many() {
   do_print("Testing various combinations of a phase with many conditions");
   let topic = getUniqueTopic();
   let phase = AsyncShutdown._getPhase(topic);
   let outParams = [];
   for (let arg of [undefined, null, "foo", 100, new Error("BOOM")]) {
     for (let resolution of [arg, Promise.reject(arg)]) {
       let outParam = { isFinished: false };
       phase.addBlocker(
         "Test",
         () => longRunningAsyncTask(resolution, outParam)
       );
     }
   }
   do_check_true(outParams.every((x) => !x.isFinished));
   Services.obs.notifyObservers(null, topic, null);
   do_check_true(outParams.every((x) => x.isFinished));
 });
 function get_exn(f) {
   try {
     f();
     return null;
   } catch (ex) {
     return ex;
   }
 }
 add_task(function test_various_failures() {
   do_print("Ensure that we cannot add a condition for a phase that is already complete");
   let topic = getUniqueTopic();
   let phase = AsyncShutdown._getPhase(topic);
   Services.obs.notifyObservers(null, topic, null);
   let exn = get_exn(() => phase.addBlocker("Test", true));
   do_check_true(!!exn);
   do_print("Ensure that an incomplete blocker causes a TypeError");
   exn = get_exn(() => phase.addBlocker());
   do_check_eq(exn.name, "TypeError");
   exn = get_exn(() => phase.addBlocker(null, true));
   do_check_eq(exn.name, "TypeError");
   exn = get_exn(() => phase.addBlocker("Test 2", () => true, "not a function"));
   do_check_eq(exn.name, "TypeError");
 });
 add_task(function() {
   Services.prefs.clearUserPref("toolkit.asyncshutdown.testing");
 });
 function run_test() {
   run_next_test();
 }