The Tor Browser: addon-sdk/source/test/test-unit-test.js@6474c204b198 (annotated)

addon-sdk/source/test/test-unit-test.js@6474c204b198 (annotated)

addon-sdk/source/test/test-unit-test.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.

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 const timer = require("sdk/timers");
 const { Loader } = require("sdk/test/loader");
 var setupCalled = false, teardownCalled = false;
 exports.setup = function() {
     setupCalled = true;
 };
 exports.teardown = function() {
     teardownCalled = true;
     setupCalled = false;
 };
 // Important note - unit tests are run in alphabetical order.  The following
 // unit tests for setup/teardown are order dependent, sometimes the result of
 // one test is checked in the next test (testing for teardown does this).  When
 // tests are cohesively a single unit, they are named <test_name> - partN where
 // N is their order in the sequence.  Secondly, because these tests should be
 // run before all others, they start with an A.
 exports.testASetupTeardownSyncTestPart1 = function(test) {
     test.assertEqual(true, setupCalled, 'setup function was called before this');
     test.assertEqual(false, teardownCalled, 'teardown function was not called before this');
 };
 exports.testASetupTeardownSyncTestPart2 = function(test) {
     test.assertEqual(true, setupCalled, 'setup was re-called before this');
     test.assertEqual(true, teardownCalled, 'teardown was called after first function');
 };
 exports.testATeardownAsyncTestPart1 = function(test) {
     teardownCalled = false;
     timer.setTimeout(function() {
         test.assertEqual(false, teardownCalled, "teardown not called until done");
         test.done();
     }, 200);
     test.waitUntilDone();
 };
 exports.testATeardownAsyncTestPart2 = function(test) {
     test.assertEqual(true, teardownCalled, "teardown called after done");
 };
 exports.testWaitUntilInstant = function(test) {
   test.waitUntilDone();
   test.waitUntil(function () true, "waitUntil with instant true pass")
       .then(function () test.done());
 }
 exports.testWaitUntil = function(test) {
   test.waitUntilDone();
   let succeed = false;
   test.waitUntil(function () succeed, "waitUntil pass")
       .then(function () test.done());
   timer.setTimeout(function () {
     succeed = true;
   }, 200);
 }
 exports.testWaitUntilEqual = function(test) {
   test.waitUntilDone();
   let succeed = false;
   test.waitUntilEqual("foo", function () succeed ? "foo" : "bar",
                       "waitUntilEqual pass")
       .then(function () test.done());
   timer.setTimeout(function () {
     succeed = true;
   }, 200);
 }
 exports.testWaitUntilNotEqual = function(test) {
   test.waitUntilDone();
   let succeed = false;
   test.waitUntilNotEqual("foo", function () succeed ? "bar" : "foo",
                          "waitUntilNotEqual pass")
       .then(function () test.done());
   timer.setTimeout(function () {
     succeed = true;
   }, 200);
 }
 exports.testWaitUntilMatches = function(test) {
   test.waitUntilDone();
   let succeed = false;
   test.waitUntilMatches(function () succeed ? "foo" : "bar",
                         /foo/, "waitUntilEqual pass")
       .then(function () test.done());
   timer.setTimeout(function () {
     succeed = true;
   }, 200);
 }
 exports.testWaitUntilErrorInCallback = function(test) {
   test.waitUntilDone();
   test.expectFail(function() {
     test.waitUntil(function () {throw "oops"}, "waitUntil pass")
         .then(function () test.done());
   });
 }
 exports.testWaitUntilTimeoutInCallback = function(test) {
   test.waitUntilDone();
   let expected = [];
   let message = 0;
   if (require("@test/options").parseable) {
     expected.push(["print", "TEST-START | wait4ever\n"]);
     expected.push(["error", "fail:", "Timed out"]);
     expected.push(["error", "test assertion never became true:\n", "assertion failed, value is false\n"]);
     expected.push(["print", "TEST-END | wait4ever\n"]);
   }
   else {
     expected.push(["info",  "executing 'wait4ever'"]);
     expected.push(["error", "fail:", "Timed out"]);
     expected.push(["error", "test assertion never became true:\n", "assertion failed, value is false\n"]);
   }
   function checkExpected(name, args) {
     if (expected.length == 0 || expected[0][0] != name) {
       test.fail("Saw an unexpected console." + name + "() call " + args);
       return;
     }
     message++;
     let expectedArgs = expected.shift().slice(1);
     for (let i = 0; i < expectedArgs.length; i++)
       test.assertEqual(args[i], expectedArgs[i], "Should have seen the right message in argument " + i + " of message " + message);
     if (expected.length == 0)
       test.done();
   }
   let runner = new (require("sdk/deprecated/unit-test").TestRunner)({
     console: {
       error: function() {
         checkExpected("error", Array.slice(arguments));
       },
       info: function () {
         checkExpected("info", Array.slice(arguments));
       },
       trace: function () {},
       exception: function () {},
       print: function () {
         checkExpected("print", Array.slice(arguments));
       }
     }
   });
   runner.start({
     test: {
       name: "wait4ever",
       testFunction: function(test) {
         test.waitUntilDone(100);
         test.waitUntil(function() false);
       }
     },
     onDone: function() {}
   });
 };
 exports.testExpectFail = function(test) {
     test.expectFail(function() {
         test.fail('expectFail masking .fail');
     });
     test.expectFail(function() {
         test.assert(false, 'expectFail masking .assert');
     });
     test.assert(true, 'assert should pass with no expectFail');
 /*
     test.expectFail(function() {
         test.expectFail(function() {
             test.fail('this should blow up');
         });
     });
 */
 };
 exports.testAssertFunction = function(test) {
     test.assertFunction(function() {}, 'assertFunction with function');
     test.expectFail(function() {
         test.assertFunction(null, 'assertFunction with non-function');
     });
 };
 exports.testAssertUndefined = function(test) {
     test.assertUndefined(undefined, 'assertUndefined with undefined');
     test.expectFail(function() {
         test.assertUndefined(null, 'assertUndefined with null');
     });
     test.expectFail(function() {
         test.assertUndefined(false, 'assertUndefined with false');
     });
     test.expectFail(function() {
         test.assertUndefined(0, 'assertUndefined with 0');
     });
 };
 exports.testAssertNotUndefined = function(test) {
     test.expectFail(function() {
         test.assertNotUndefined(undefined, 'assertNotUndefined with undefined');
     });
     test.assertNotUndefined(null, 'assertNotUndefined with null');
     test.assertNotUndefined(false, 'assertNotUndefined with false');
     test.assertNotUndefined(0, 'assertNotUndefined with 0');
 };
 exports.testAssertNull = function(test) {
     test.assertNull(null, 'assertNull with null');
     test.expectFail(function() {
         test.assertNull(undefined, 'assertNull with undefined');
     });
     test.expectFail(function() {
         test.assertNull(false, 'assertNull with false');
     });
     test.expectFail(function() {
         test.assertNull(0, 'assertNull with 0');
     });
 };
 exports.testAssertNotNull = function(test) {
     test.assertNotNull(undefined, 'assertNotNull with undefined');
     test.assertNotNull(false, 'assertNotNull with false');
     test.assertNotNull(0, 'assertNotNull with 0');
     test.expectFail(function() {
         test.assertNotNull(null, 'testAssertNotNull with null');
     });
 };
 exports.testAssertObject = function(test) {
     test.assertObject({}, 'assertObject with {}' );
     test.assertObject(new Object(), 'assertObject with new Object');
     test.expectFail(function() {
         test.assertObject('fail', 'assertObject with string');
     });
 };
 exports.testAssertString = function(test) {
     test.assertString('', 'assertString with ""');
     test.assertString(new String(), 'assertString with new String');
 };
 exports.testAssertArray = function(test) {
     test.assertArray([], 'assertArray with []');
     test.assertArray(new Array(), 'assertArray with new Array');
 };
 exports.testNumber = function(test) {
     test.assertNumber(1, 'assertNumber with 1');
     test.assertNumber(new Number('2'), 'assertNumber with new Number("2")' );
 };