'use strict';
|
|
var objectAssign = require('object-assign');
|
|
// 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:
|
// NB: The URL to the CommonJS spec is kept just for tradition.
|
// node-assert has evolved a lot since then, both in API and behavior.
|
|
// 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; };
|
|
// Expose a strict only variant of assert
|
function strict(value, message) {
|
if (!value) fail(value, true, message, '==', strict);
|
}
|
assert.strict = objectAssign(strict, assert, {
|
equal: assert.strictEqual,
|
deepEqual: assert.deepStrictEqual,
|
notEqual: assert.notStrictEqual,
|
notDeepEqual: assert.notDeepStrictEqual
|
});
|
assert.strict.strict = assert.strict;
|
|
var objectKeys = Object.keys || function (obj) {
|
var keys = [];
|
for (var key in obj) {
|
if (hasOwn.call(obj, key)) keys.push(key);
|
}
|
return keys;
|
};
|
