The Tor Browser: testing/modules/Assert.jsm@7e26c7da4463 (annotated)

testing/modules/Assert.jsm@7e26c7da4463 (annotated)

testing/modules/Assert.jsm

Wed, 31 Dec 2014 06:55:50 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:55:50 +0100
changeset 2: 7e26c7da4463
permissions: -rw-r--r--

Added tag UPSTREAM_283F7C6 for changeset ca08bd8f51b2

 /* 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/. */
 // http://wiki.commonjs.org/wiki/Unit_Testing/1.0
 // When you see a javadoc comment that contains a number, it's a reference to a
 // specific section of the CommonJS spec.
 //
 // Originally from narwhal.js (http://narwhaljs.org)
 // Copyright (c) 2009 Thomas Robinson <280north.com>
 // MIT license: http://opensource.org/licenses/MIT
 "use strict";
 this.EXPORTED_SYMBOLS = [
   "Assert"
 ];
 /**
  * 1. The assert module provides functions that throw AssertionError's when
  * particular conditions are not met.
  *
  * To use the module you'll need to instantiate it first, which allows consumers
  * to override certain behavior on the newly obtained instance. For examples,
  * see the javadoc comments for the `report` member function.
  */
 let Assert = this.Assert = function(reporterFunc) {
   if (reporterFunc)
     this.setReporter(reporterFunc);
 };
 function instanceOf(object, type) {
   return Object.prototype.toString.call(object) == "[object " + type + "]";
 }
 function replacer(key, value) {
   if (value === undefined) {
     return "" + value;
   }
   if (typeof value === "number" && (isNaN(value) || !isFinite(value))) {
     return value.toString();
   }
   if (typeof value === "function" || instanceOf(value, "RegExp")) {
     return value.toString();
   }
   return value;
 }
 const kTruncateLength = 128;
 function truncate(text, newLength = kTruncateLength) {
   if (typeof text == "string") {
     return text.length < newLength ? text : text.slice(0, newLength);
   } else {
     return text;
   }
 }
 function getMessage(error, prefix = "") {
   let actual, expected;
   // Wrap calls to JSON.stringify in try...catch blocks, as they may throw. If
   // so, fall back to toString().
   try {
     actual = JSON.stringify(error.actual, replacer);
   } catch (ex) {
     actual = Object.prototype.toString.call(error.actual);
   }
   try {
     expected = JSON.stringify(error.expected, replacer);
   } catch (ex) {
     expected = Object.prototype.toString.call(error.expected);
   }
   let message = prefix;
   if (error.operator) {
     message += (prefix ? " - " : "") + truncate(actual) + " " + error.operator +
                " " + truncate(expected);
   }
   return message;
 }
 /**
  * 2. The AssertionError is defined in assert.
  *
  * Example:
  * new assert.AssertionError({
  *   message: message,
  *   actual: actual,
  *   expected: expected,
  *   operator: operator
  * });
  *
  * At present only the four keys mentioned above are used and
  * understood by the spec. Implementations or sub modules can pass
  * other keys to the AssertionError's constructor - they will be
  * ignored.
  */
 Assert.AssertionError = function(options) {
   this.name = "AssertionError";
   this.actual = options.actual;
   this.expected = options.expected;
   this.operator = options.operator;
   this.message = getMessage(this, options.message);
   // The part of the stack that comes from this module is not interesting.
   let stack = Components.stack;
   do {
     stack = stack.caller;
   } while(stack.filename && stack.filename.contains("Assert.jsm"))
   this.stack = stack;
 };
 // assert.AssertionError instanceof Error
 Assert.AssertionError.prototype = Object.create(Error.prototype, {
   constructor: {
     value: Assert.AssertionError,
     enumerable: false,
     writable: true,
     configurable: true
   }
 });
 let proto = Assert.prototype;
 proto._reporter = null;
 /**
  * Set a custom assertion report handler function. Arguments passed in to this
  * function are:
  * err (AssertionError|null) An error object when the assertion failed or null
  *                           when it passed
  * message (string) Message describing the assertion
  * stack (stack) Stack trace of the assertion function
  *
  * Example:
  * ```js
  * Assert.setReporter(function customReporter(err, message, stack) {
  *   if (err) {
  *     do_report_result(false, err.message, err.stack);
  *   } else {
  *     do_report_result(true, message, stack);
  *   }
  * });
  * ```
  *
  * @param reporterFunc
  *        (function) Report handler function
  */
 proto.setReporter = function(reporterFunc) {
   this._reporter = reporterFunc;
 };
 /**
  * 3. All of the following functions must throw an AssertionError when a
  * corresponding condition is not met, with a message that may be undefined if
  * not provided.  All assertion methods provide both the actual and expected
  * values to the assertion error for display purposes.
  *
  * This report method only throws errors on assertion failures, as per spec,
  * but consumers of this module (think: xpcshell-test, mochitest) may want to
  * override this default implementation.
  *
  * Example:
  * ```js
  * // The following will report an assertion failure.
  * this.report(1 != 2, 1, 2, "testing JS number math!", "==");
  * ```
  *
  * @param failed
  *        (boolean) Indicates if the assertion failed or not
  * @param actual
  *        (mixed) The result of evaluating the assertion
  * @param expected (optional)
  *        (mixed) Expected result from the test author
  * @param message (optional)
  *        (string) Short explanation of the expected result
  * @param operator (optional)
  *        (string) Operation qualifier used by the assertion method (ex: '==')
  */
 proto.report = function(failed, actual, expected, message, operator) {
   let err = new Assert.AssertionError({
     message: message,
     actual: actual,
     expected: expected,
     operator: operator
   });
   if (!this._reporter) {
     // If no custom reporter is set, throw the error.
     if (failed) {
       throw err;
     }
   } else {
     this._reporter(failed ? err : null, message, err.stack);
   }
 };
 /**
  * 4. Pure assertion tests whether a value is truthy, as determined by !!guard.
  * assert.ok(guard, message_opt);
  * This statement is equivalent to assert.equal(true, !!guard, message_opt);.
  * To test strictly for the value true, use assert.strictEqual(true, guard,
  * message_opt);.
  *
  * @param value
  *        (mixed) Test subject to be evaluated as truthy
  * @param message (optional)
  *        (string) Short explanation of the expected result
  */
 proto.ok = function(value, message) {
   this.report(!value, value, true, message, "==");
 };
 /**
  * 5. The equality assertion tests shallow, coercive equality with ==.
  * assert.equal(actual, expected, message_opt);
  *
  * @param actual
  *        (mixed) Test subject to be evaluated as equivalent to `expected`
  * @param expected
  *        (mixed) Test reference to evaluate against `actual`
  * @param message (optional)
  *        (string) Short explanation of the expected result
  */
 proto.equal = function equal(actual, expected, message) {
   this.report(actual != expected, actual, expected, message, "==");
 };
 /**
  * 6. The non-equality assertion tests for whether two objects are not equal
  * with != assert.notEqual(actual, expected, message_opt);
  *
  * @param actual
  *        (mixed) Test subject to be evaluated as NOT equivalent to `expected`
  * @param expected
  *        (mixed) Test reference to evaluate against `actual`
  * @param message (optional)
  *        (string) Short explanation of the expected result
  */
 proto.notEqual = function notEqual(actual, expected, message) {
   this.report(actual == expected, actual, expected, message, "!=");
 };
 /**
  * 7. The equivalence assertion tests a deep equality relation.
  * assert.deepEqual(actual, expected, message_opt);
  *
  * We check using the most exact approximation of equality between two objects
  * to keep the chance of false positives to a minimum.
  * `JSON.stringify` is not designed to be used for this purpose; objects may
  * have ambiguous `toJSON()` implementations that would influence the test.
  *
  * @param actual
  *        (mixed) Test subject to be evaluated as equivalent to `expected`, including nested properties
  * @param expected
  *        (mixed) Test reference to evaluate against `actual`
  * @param message (optional)
  *        (string) Short explanation of the expected result
  */
 proto.deepEqual = function deepEqual(actual, expected, message) {
   this.report(!_deepEqual(actual, expected), actual, expected, message, "deepEqual");
 };
 function _deepEqual(actual, expected) {
   // 7.1. All identical values are equivalent, as determined by ===.
   if (actual === expected) {
     return true;
   // 7.2. If the expected value is a Date object, the actual value is
   // equivalent if it is also a Date object that refers to the same time.
   } else if (instanceOf(actual, "Date") && instanceOf(expected, "Date")) {
     return actual.getTime() === expected.getTime();
   // 7.3 If the expected value is a RegExp object, the actual value is
   // equivalent if it is also a RegExp object with the same source and
   // properties (`global`, `multiline`, `lastIndex`, `ignoreCase`).
   } else if (instanceOf(actual, "RegExp") && instanceOf(expected, "RegExp")) {
     return actual.source === expected.source &&
            actual.global === expected.global &&
            actual.multiline === expected.multiline &&
            actual.lastIndex === expected.lastIndex &&
            actual.ignoreCase === expected.ignoreCase;
   // 7.4. Other pairs that do not both pass typeof value == "object",
   // equivalence is determined by ==.
   } else if (typeof actual != "object" && typeof expected != "object") {
     return actual == expected;
   // 7.5 For all other Object pairs, including Array objects, equivalence is
   // determined by having the same number of owned properties (as verified
   // with Object.prototype.hasOwnProperty.call), the same set of keys
   // (although not necessarily the same order), equivalent values for every
   // corresponding key, and an identical 'prototype' property. Note: this
   // accounts for both named and indexed properties on Arrays.
   } else {
     return objEquiv(actual, expected);
   }
 }
 function isUndefinedOrNull(value) {
   return value === null || value === undefined;
 }
 function isArguments(object) {
   return instanceOf(object, "Arguments");
 }
 function objEquiv(a, b) {
   if (isUndefinedOrNull(a) || isUndefinedOrNull(b)) {
     return false;
   }
   // An identical 'prototype' property.
   if (a.prototype !== b.prototype) {
     return false;
   }
   // Object.keys may be broken through screwy arguments passing. Converting to
   // an array solves the problem.
   if (isArguments(a)) {
     if (!isArguments(b)) {
       return false;
     }
     a = pSlice.call(a);
     b = pSlice.call(b);
     return _deepEqual(a, b);
   }
   let ka, kb, key, i;
   try {
     ka = Object.keys(a);
     kb = Object.keys(b);
   } catch (e) {
     // Happens when one is a string literal and the other isn't
     return false;
   }
   // Having the same number of owned properties (keys incorporates
   // hasOwnProperty)
   if (ka.length != kb.length)
     return false;
   // The same set of keys (although not necessarily the same order),
   ka.sort();
   kb.sort();
   // Equivalent values for every corresponding key, and possibly expensive deep
   // test
   for (i = ka.length - 1; i >= 0; i--) {
     key = ka[i];
     if (!_deepEqual(a[key], b[key])) {
       return false;
     }
   }
   return true;
 }
 /**
  * 8. The non-equivalence assertion tests for any deep inequality.
  * assert.notDeepEqual(actual, expected, message_opt);
  *
  * @param actual
  *        (mixed) Test subject to be evaluated as NOT equivalent to `expected`, including nested properties
  * @param expected
  *        (mixed) Test reference to evaluate against `actual`
  * @param message (optional)
  *        (string) Short explanation of the expected result
  */
 proto.notDeepEqual = function notDeepEqual(actual, expected, message) {
   this.report(_deepEqual(actual, expected), actual, expected, message, "notDeepEqual");
 };
 /**
  * 9. The strict equality assertion tests strict equality, as determined by ===.
  * assert.strictEqual(actual, expected, message_opt);
  *
  * @param actual
  *        (mixed) Test subject to be evaluated as strictly equivalent to `expected`
  * @param expected
  *        (mixed) Test reference to evaluate against `actual`
  * @param message (optional)
  *        (string) Short explanation of the expected result
  */
 proto.strictEqual = function strictEqual(actual, expected, message) {
   this.report(actual !== expected, actual, expected, message, "===");
 };
 /**
  * 10. The strict non-equality assertion tests for strict inequality, as
  * determined by !==.  assert.notStrictEqual(actual, expected, message_opt);
  *
  * @param actual
  *        (mixed) Test subject to be evaluated as NOT strictly equivalent to `expected`
  * @param expected
  *        (mixed) Test reference to evaluate against `actual`
  * @param message (optional)
  *        (string) Short explanation of the expected result
  */
 proto.notStrictEqual = function notStrictEqual(actual, expected, message) {
   this.report(actual === expected, actual, expected, message, "!==");
 };
 function expectedException(actual, expected) {
   if (!actual || !expected) {
     return false;
   }
   if (instanceOf(expected, "RegExp")) {
     return expected.test(actual);
   } else if (actual instanceof expected) {
     return true;
   } else if (expected.call({}, actual) === true) {
     return true;
   }
   return false;
 }
 /**
  * 11. Expected to throw an error:
  * assert.throws(block, Error_opt, message_opt);
  *
  * @param block
  *        (function) Function block to evaluate and catch eventual thrown errors
  * @param expected (optional)
  *        (mixed) Test reference to evaluate against the thrown result from `block`
  * @param message (optional)
  *        (string) Short explanation of the expected result
  */
 proto.throws = function(block, expected, message) {
   let actual;
   if (typeof expected === "string") {
     message = expected;
     expected = null;
   }
   try {
     block();
   } catch (e) {
     actual = e;
   }
   message = (expected && expected.name ? " (" + expected.name + ")." : ".") +
             (message ? " " + message : ".");
   if (!actual) {
     this.report(true, actual, expected, "Missing expected exception" + message);
   }
   if ((actual && expected && !expectedException(actual, expected))) {
     throw actual;
   }
   this.report(false, expected, expected, message);
 };

The Tor Browser / annotate

testing/modules/Assert.jsm@7e26c7da4463 (annotated)

testing/modules/Assert.jsm