| 'use strict'; |
| |
| // compare and isBuffer taken from https://github.com/feross/buffer/blob/680e9e5e488f22aac27599a57dc844a6315928dd/index.js |
| // original notice: |
| |
| /*! |
| * The buffer module from node.js, for the browser. |
| * |
| * @author Feross Aboukhadijeh <feross@feross.org> <http://feross.org> |
| * @license MIT |
| */ |
| function compare(a, b) { |
| if (a === b) { |
| return 0; |
| } |
| |
| var x = a.length; |
| var y = b.length; |
| |
| for (var i = 0, len = Math.min(x, y); i < len; ++i) { |
| if (a[i] !== b[i]) { |
| x = a[i]; |
| y = b[i]; |
| break; |
| } |
| } |
| |
| if (x < y) { |
| return -1; |
| } |
| if (y < x) { |
| return 1; |
| } |
| return 0; |
| } |
| function isBuffer(b) { |
| if (global.Buffer && typeof global.Buffer.isBuffer === 'function') { |
| return global.Buffer.isBuffer(b); |
| } |
| return !!(b != null && b._isBuffer); |
| } |
| |
| // based on node assert, original notice: |
| |
| // http://wiki.commonjs.org/wiki/Unit_Testing/1.0 |
| // |
| // THIS IS NOT TESTED NOR LIKELY TO WORK OUTSIDE V8! |
| // |
| // Originally from narwhal.js (http://narwhaljs.org) |
| // Copyright (c) 2009 Thomas Robinson <280north.com> |
| // |
| // Permission is hereby granted, free of charge, to any person obtaining a copy |
| // of this software and associated documentation files (the 'Software'), to |
| // deal in the Software without restriction, including without limitation the |
| // rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| // sell copies of the Software, and to permit persons to whom the Software is |
| // furnished to do so, subject to the following conditions: |
| // |
| // The above copyright notice and this permission notice shall be included in |
| // all copies or substantial portions of the Software. |
| // |
| // THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| // AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
| // ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION |
| // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. |
| |
| var util = require('util/'); |
| var hasOwn = Object.prototype.hasOwnProperty; |
| var pSlice = Array.prototype.slice; |
| var functionsHaveNames = (function () { |
| return function foo() {}.name === 'foo'; |
| }()); |
| function pToString (obj) { |
| return Object.prototype.toString.call(obj); |
| } |
| function isView(arrbuf) { |
| if (isBuffer(arrbuf)) { |
| return false; |
| } |
| if (typeof global.ArrayBuffer !== 'function') { |
| return false; |
| } |
| if (typeof ArrayBuffer.isView === 'function') { |
| return ArrayBuffer.isView(arrbuf); |
| } |
| if (!arrbuf) { |
| return false; |
| } |
| if (arrbuf instanceof DataView) { |
| return true; |
| } |
| if (arrbuf.buffer && arrbuf.buffer instanceof ArrayBuffer) { |
| return true; |
| } |
| return false; |
| } |
| // 1. The assert module provides functions that throw |
| // AssertionError's when particular conditions are not met. The |
| // assert module must conform to the following interface. |
| |
| var assert = module.exports = ok; |
| |
| // 2. The AssertionError is defined in assert. |
| // new assert.AssertionError({ message: message, |
| // actual: actual, |
| // expected: expected }) |
| |
| var regex = /\s*function\s+([^\(\s]*)\s*/; |
| // based on https://github.com/ljharb/function.prototype.name/blob/adeeeec8bfcc6068b187d7d9fb3d5bb1d3a30899/implementation.js |
| function getName(func) { |
| if (!util.isFunction(func)) { |
| return; |
| } |
| if (functionsHaveNames) { |
| return func.name; |
| } |
| var str = func.toString(); |
| var match = str.match(regex); |
| return match && match[1]; |
| } |
| assert.AssertionError = function AssertionError(options) { |
| this.name = 'AssertionError'; |
| this.actual = options.actual; |
| this.expected = options.expected; |
| this.operator = options.operator; |
| if (options.message) { |
| this.message = options.message; |
| this.generatedMessage = false; |
| } else { |
| this.message = getMessage(this); |
| this.generatedMessage = true; |
| } |
| var stackStartFunction = options.stackStartFunction || fail; |
| if (Error.captureStackTrace) { |
| Error.captureStackTrace(this, stackStartFunction); |
| } else { |
| // non v8 browsers so we can have a stacktrace |
| var err = new Error(); |
| if (err.stack) { |
| var out = err.stack; |
| |
| // try to strip useless frames |
| var fn_name = getName(stackStartFunction); |
| var idx = out.indexOf('\n' + fn_name); |
| if (idx >= 0) { |
| // once we have located the function frame |
| // we need to strip out everything before it (and its line) |
| var next_line = out.indexOf('\n', idx + 1); |
| out = out.substring(next_line + 1); |
| } |
| |
| this.stack = out; |
| } |
| } |
| }; |
| |
| // assert.AssertionError instanceof Error |
| util.inherits(assert.AssertionError, Error); |
| |
| function truncate(s, n) { |
| if (typeof s === 'string') { |
| return s.length < n ? s : s.slice(0, n); |
| } else { |
| return s; |
| } |
| } |
| function inspect(something) { |
| if (functionsHaveNames || !util.isFunction(something)) { |
| return util.inspect(something); |
| } |
| var rawname = getName(something); |
| var name = rawname ? ': ' + rawname : ''; |
| return '[Function' + name + ']'; |
| } |
| function getMessage(self) { |
| return truncate(inspect(self.actual), 128) + ' ' + |
| self.operator + ' ' + |
| truncate(inspect(self.expected), 128); |
| } |
| |
| // At present only the three 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. |
| |
| // 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. |
| |
| function fail(actual, expected, message, operator, stackStartFunction) { |
| throw new assert.AssertionError({ |
| message: message, |
| actual: actual, |
| expected: expected, |
| operator: operator, |
| stackStartFunction: stackStartFunction |
| }); |
| } |
| |
| // EXTENSION! allows for well behaved errors defined elsewhere. |
| assert.fail = fail; |
| |
| // 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);. |
| |
| function ok(value, message) { |
| if (!value) fail(value, true, message, '==', assert.ok); |
| } |
| assert.ok = ok; |
| |
| // 5. The equality assertion tests shallow, coercive equality with |
| // ==. |
| // assert.equal(actual, expected, message_opt); |
| |
| assert.equal = function equal(actual, expected, message) { |
| if (actual != expected) fail(actual, expected, message, '==', assert.equal); |
| }; |
| |
| // 6. The non-equality assertion tests for whether two objects are not equal |
| // with != assert.notEqual(actual, expected, message_opt); |
| |
| assert.notEqual = function notEqual(actual, expected, message) { |
| if (actual == expected) { |
| fail(actual, expected, message, '!=', assert.notEqual); |
| } |
| }; |
| |
| // 7. The equivalence assertion tests a deep equality relation. |
| // assert.deepEqual(actual, expected, message_opt); |
| |
| assert.deepEqual = function deepEqual(actual, expected, message) { |
| if (!_deepEqual(actual, expected, false)) { |
| fail(actual, expected, message, 'deepEqual', assert.deepEqual); |
| } |
| }; |
| |
| assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) { |
| if (!_deepEqual(actual, expected, true)) { |
| fail(actual, expected, message, 'deepStrictEqual', assert.deepStrictEqual); |
| } |
| }; |
| |
| function _deepEqual(actual, expected, strict, memos) { |
| // 7.1. All identical values are equivalent, as determined by ===. |
| if (actual === expected) { |
| return true; |
| } else if (isBuffer(actual) && isBuffer(expected)) { |
| return compare(actual, expected) === 0; |
| |
| // 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 (util.isDate(actual) && util.isDate(expected)) { |
| 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 (util.isRegExp(actual) && util.isRegExp(expected)) { |
| 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 ((actual === null || typeof actual !== 'object') && |
| (expected === null || typeof expected !== 'object')) { |
| return strict ? actual === expected : actual == expected; |
| |
| // If both values are instances of typed arrays, wrap their underlying |
| // ArrayBuffers in a Buffer each to increase performance |
| // This optimization requires the arrays to have the same type as checked by |
| // Object.prototype.toString (aka pToString). Never perform binary |
| // comparisons for Float*Arrays, though, since e.g. +0 === -0 but their |
| // bit patterns are not identical. |
| } else if (isView(actual) && isView(expected) && |
| pToString(actual) === pToString(expected) && |
| !(actual instanceof Float32Array || |
| actual instanceof Float64Array)) { |
| return compare(new Uint8Array(actual.buffer), |
| new Uint8Array(expected.buffer)) === 0; |
| |
| // 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 if (isBuffer(actual) !== isBuffer(expected)) { |
| return false; |
| } else { |
| memos = memos || {actual: [], expected: []}; |
| |
| var actualIndex = memos.actual.indexOf(actual); |
| if (actualIndex !== -1) { |
| if (actualIndex === memos.expected.indexOf(expected)) { |
| return true; |
| } |
| } |
| |
| memos.actual.push(actual); |
| memos.expected.push(expected); |
| |
| return objEquiv(actual, expected, strict, memos); |
| } |
| } |
| |
| function isArguments(object) { |
| return Object.prototype.toString.call(object) == '[object Arguments]'; |
| } |
| |
| function objEquiv(a, b, strict, actualVisitedObjects) { |
| if (a === null || a === undefined || b === null || b === undefined) |
| return false; |
| // if one is a primitive, the other must be same |
| if (util.isPrimitive(a) || util.isPrimitive(b)) |
| return a === b; |
| if (strict && Object.getPrototypeOf(a) !== Object.getPrototypeOf(b)) |
| return false; |
| var aIsArgs = isArguments(a); |
| var bIsArgs = isArguments(b); |
| if ((aIsArgs && !bIsArgs) || (!aIsArgs && bIsArgs)) |
| return false; |
| if (aIsArgs) { |
| a = pSlice.call(a); |
| b = pSlice.call(b); |
| return _deepEqual(a, b, strict); |
| } |
| var ka = objectKeys(a); |
| var kb = objectKeys(b); |
| var key, i; |
| // 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(); |
| //~~~cheap key test |
| for (i = ka.length - 1; i >= 0; i--) { |
| if (ka[i] !== kb[i]) |
| return false; |
| } |
| //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], strict, actualVisitedObjects)) |
| return false; |
| } |
| return true; |
| } |
| |
| // 8. The non-equivalence assertion tests for any deep inequality. |
| // assert.notDeepEqual(actual, expected, message_opt); |
| |
| assert.notDeepEqual = function notDeepEqual(actual, expected, message) { |
| if (_deepEqual(actual, expected, false)) { |
| fail(actual, expected, message, 'notDeepEqual', assert.notDeepEqual); |
| } |
| }; |
| |
| assert.notDeepStrictEqual = notDeepStrictEqual; |
| function notDeepStrictEqual(actual, expected, message) { |
| if (_deepEqual(actual, expected, true)) { |
| fail(actual, expected, message, 'notDeepStrictEqual', notDeepStrictEqual); |
| } |
| } |
| |
| |
| // 9. The strict equality assertion tests strict equality, as determined by ===. |
| // assert.strictEqual(actual, expected, message_opt); |
| |
| assert.strictEqual = function strictEqual(actual, expected, message) { |
| if (actual !== expected) { |
| fail(actual, expected, message, '===', assert.strictEqual); |
| } |
| }; |
| |
| // 10. The strict non-equality assertion tests for strict inequality, as |
| // determined by !==. assert.notStrictEqual(actual, expected, message_opt); |
| |
| assert.notStrictEqual = function notStrictEqual(actual, expected, message) { |
| if (actual === expected) { |
| fail(actual, expected, message, '!==', assert.notStrictEqual); |
| } |
| }; |
| |
| function expectedException(actual, expected) { |
| if (!actual || !expected) { |
| return false; |
| } |
| |
| if (Object.prototype.toString.call(expected) == '[object RegExp]') { |
| return expected.test(actual); |
| } |
| |
| try { |
| if (actual instanceof expected) { |
| return true; |
| } |
| } catch (e) { |
| // Ignore. The instanceof check doesn't work for arrow functions. |
| } |
| |
| if (Error.isPrototypeOf(expected)) { |
| return false; |
| } |
| |
| return expected.call({}, actual) === true; |
| } |
| |
| function _tryBlock(block) { |
| var error; |
| try { |
| block(); |
| } catch (e) { |
| error = e; |
| } |
| return error; |
| } |
| |
| function _throws(shouldThrow, block, expected, message) { |
| var actual; |
| |
| if (typeof block !== 'function') { |
| throw new TypeError('"block" argument must be a function'); |
| } |
| |
| if (typeof expected === 'string') { |
| message = expected; |
| expected = null; |
| } |
| |
| actual = _tryBlock(block); |
| |
| message = (expected && expected.name ? ' (' + expected.name + ').' : '.') + |
| (message ? ' ' + message : '.'); |
| |
| if (shouldThrow && !actual) { |
| fail(actual, expected, 'Missing expected exception' + message); |
| } |
| |
| var userProvidedMessage = typeof message === 'string'; |
| var isUnwantedException = !shouldThrow && util.isError(actual); |
| var isUnexpectedException = !shouldThrow && actual && !expected; |
| |
| if ((isUnwantedException && |
| userProvidedMessage && |
| expectedException(actual, expected)) || |
| isUnexpectedException) { |
| fail(actual, expected, 'Got unwanted exception' + message); |
| } |
| |
| if ((shouldThrow && actual && expected && |
| !expectedException(actual, expected)) || (!shouldThrow && actual)) { |
| throw actual; |
| } |
| } |
| |
| // 11. Expected to throw an error: |
| // assert.throws(block, Error_opt, message_opt); |
| |
| assert.throws = function(block, /*optional*/error, /*optional*/message) { |
| _throws(true, block, error, message); |
| }; |
| |
| // EXTENSION! This is annoying to write outside this module. |
| assert.doesNotThrow = function(block, /*optional*/error, /*optional*/message) { |
| _throws(false, block, error, message); |
| }; |
| |
| assert.ifError = function(err) { if (err) throw err; }; |
| |
| var objectKeys = Object.keys || function (obj) { |
| var keys = []; |
| for (var key in obj) { |
| if (hasOwn.call(obj, key)) keys.push(key); |
| } |
| return keys; |
| }; |