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

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

toolkit/modules/tests/xpcshell/test_task.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.

 /* Any copyright is dedicated to the Public Domain.
    http://creativecommons.org/publicdomain/zero/1.0/ */
 /**
  * This file tests the Task.jsm module.
  */
 ////////////////////////////////////////////////////////////////////////////////
 /// Globals
 const Cc = Components.classes;
 const Ci = Components.interfaces;
 const Cu = Components.utils;
 const Cr = Components.results;
 Cu.import("resource://gre/modules/XPCOMUtils.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "Promise",
                                   "resource://gre/modules/Promise.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "Services",
                                   "resource://gre/modules/Services.jsm");
 XPCOMUtils.defineLazyModuleGetter(this, "Task",
                                   "resource://gre/modules/Task.jsm");
 /**
  * Returns a promise that will be resolved with the given value, when an event
  * posted on the event loop of the main thread is processed.
  */
 function promiseResolvedLater(aValue) {
   let deferred = Promise.defer();
   Services.tm.mainThread.dispatch(function () deferred.resolve(aValue),
                                   Ci.nsIThread.DISPATCH_NORMAL);
   return deferred.promise;
 }
 ////////////////////////////////////////////////////////////////////////////////
 /// Tests
 function run_test()
 {
   run_next_test();
 }
 add_test(function test_normal()
 {
   Task.spawn(function () {
     let result = yield Promise.resolve("Value");
     for (let i = 0; i < 3; i++) {
       result += yield promiseResolvedLater("!");
     }
     throw new Task.Result("Task result: " + result);
   }).then(function (result) {
     do_check_eq("Task result: Value!!!", result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_exceptions()
 {
   Task.spawn(function () {
     try {
       yield Promise.reject("Rejection result by promise.");
       do_throw("Exception expected because the promise was rejected.");
     } catch (ex) {
       // We catch this exception now, we will throw a different one later.
       do_check_eq("Rejection result by promise.", ex);
     }
     throw new Error("Exception uncaught by task.");
   }).then(function (result) {
     do_throw("Unexpected success!");
   }, function (ex) {
     do_check_eq("Exception uncaught by task.", ex.message);
     run_next_test();
   });
 });
 add_test(function test_recursion()
 {
   function task_fibonacci(n) {
     throw new Task.Result(n < 2 ? n : (yield task_fibonacci(n - 1)) +
                                       (yield task_fibonacci(n - 2)));
   };
   Task.spawn(task_fibonacci(6)).then(function (result) {
     do_check_eq(8, result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_spawn_primitive()
 {
   function fibonacci(n) {
     return n < 2 ? n : fibonacci(n - 1) + fibonacci(n - 2);
   };
   // Polymorphism between task and non-task functions (see "test_recursion").
   Task.spawn(fibonacci(6)).then(function (result) {
     do_check_eq(8, result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_spawn_function()
 {
   Task.spawn(function () {
     return "This is not a generator.";
   }).then(function (result) {
     do_check_eq("This is not a generator.", result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_spawn_function_this()
 {
   Task.spawn(function () {
     return this;
   }).then(function (result) {
     // Since the task function wasn't defined in strict mode, its "this" object
     // should be the same as the "this" object in this function, i.e. the global
     // object.
     do_check_eq(result, this);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_spawn_function_this_strict()
 {
   "use strict";
   Task.spawn(function () {
     return this;
   }).then(function (result) {
     // Since the task function was defined in strict mode, its "this" object
     // should be undefined.
     do_check_eq(typeof(result), "undefined");
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_spawn_function_returning_promise()
 {
   Task.spawn(function () {
     return promiseResolvedLater("Resolution value.");
   }).then(function (result) {
     do_check_eq("Resolution value.", result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_spawn_function_exceptions()
 {
   Task.spawn(function () {
     throw new Error("Exception uncaught by task.");
   }).then(function (result) {
     do_throw("Unexpected success!");
   }, function (ex) {
     do_check_eq("Exception uncaught by task.", ex.message);
     run_next_test();
   });
 });
 add_test(function test_spawn_function_taskresult()
 {
   Task.spawn(function () {
     throw new Task.Result("Task result");
   }).then(function (result) {
     do_check_eq("Task result", result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_yielded_undefined()
 {
   Task.spawn(function () {
     yield;
     throw new Task.Result("We continued correctly.");
   }).then(function (result) {
     do_check_eq("We continued correctly.", result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_yielded_primitive()
 {
   Task.spawn(function () {
     throw new Task.Result("Primitive " + (yield "value."));
   }).then(function (result) {
     do_check_eq("Primitive value.", result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_star_normal()
 {
   Task.spawn(function* () {
     let result = yield Promise.resolve("Value");
     for (let i = 0; i < 3; i++) {
       result += yield promiseResolvedLater("!");
     }
     return "Task result: " + result;
   }).then(function (result) {
     do_check_eq("Task result: Value!!!", result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_star_exceptions()
 {
   Task.spawn(function* () {
     try {
       yield Promise.reject("Rejection result by promise.");
       do_throw("Exception expected because the promise was rejected.");
     } catch (ex) {
       // We catch this exception now, we will throw a different one later.
       do_check_eq("Rejection result by promise.", ex);
     }
     throw new Error("Exception uncaught by task.");
   }).then(function (result) {
     do_throw("Unexpected success!");
   }, function (ex) {
     do_check_eq("Exception uncaught by task.", ex.message);
     run_next_test();
   });
 });
 add_test(function test_star_recursion()
 {
   function* task_fibonacci(n) {
     return n < 2 ? n : (yield task_fibonacci(n - 1)) +
                        (yield task_fibonacci(n - 2));
   };
   Task.spawn(task_fibonacci(6)).then(function (result) {
     do_check_eq(8, result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_mixed_legacy_and_star()
 {
   Task.spawn(function* () {
     return yield (function() {
       throw new Task.Result(yield 5);
     })();
   }).then(function (result) {
     do_check_eq(5, result);
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_async_function_from_generator()
 {
   Task.spawn(function* () {
     let object = {
       asyncFunction: Task.async(function* (param) {
         do_check_eq(this, object);
         return param;
       })
     };
     // Ensure the async function returns a promise that resolves as expected.
     do_check_eq((yield object.asyncFunction(1)), 1);
     // Ensure a second call to the async function also returns such a promise.
     do_check_eq((yield object.asyncFunction(3)), 3);
   }).then(function () {
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_async_function_from_function()
 {
   Task.spawn(function* () {
     return Task.spawn(function* () {
       let object = {
         asyncFunction: Task.async(function (param) {
           do_check_eq(this, object);
           return param;
         })
       };
       // Ensure the async function returns a promise that resolves as expected.
       do_check_eq((yield object.asyncFunction(5)), 5);
       // Ensure a second call to the async function also returns such a promise.
       do_check_eq((yield object.asyncFunction(7)), 7);
     });
   }).then(function () {
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_async_function_that_throws_rejects_promise()
 {
   Task.spawn(function* () {
     let object = {
       asyncFunction: Task.async(function* () {
         throw "Rejected!";
       })
     };
     yield object.asyncFunction();
   }).then(function () {
     do_throw("unexpected success calling async function that throws error");
   }, function (ex) {
     do_check_eq(ex, "Rejected!");
     run_next_test();
   });
 });
 add_test(function test_async_return_function()
 {
   Task.spawn(function* () {
     // Ensure an async function that returns a function resolves to the function
     // itself instead of calling the function and resolving to its return value.
     return Task.spawn(function* () {
       let returnValue = function () {
         return "These aren't the droids you're looking for.";
       };
       let asyncFunction = Task.async(function () {
         return returnValue;
       });
       do_check_eq((yield asyncFunction()), returnValue);
     });
   }).then(function () {
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_async_throw_argument_not_function()
 {
   Task.spawn(function* () {
     // Ensure Task.async throws if its aTask argument is not a function.
     Assert.throws(() => Task.async("not a function"),
                   /aTask argument must be a function/);
   }).then(function () {
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });
 add_test(function test_async_throw_on_function_in_place_of_promise()
 {
   Task.spawn(function* () {
     // Ensure Task.spawn throws if passed an async function.
     Assert.throws(() => Task.spawn(Task.async(function* () {})),
                   /Cannot use an async function in place of a promise/);
   }).then(function () {
     run_next_test();
   }, function (ex) {
     do_throw("Unexpected error: " + ex);
   });
 });