lib: rebase Assert.fail method

Author: miguelmarcondesf

lib/assert.js

@@ -436,43 +436,21 @@ class Assert {
   }
 
   /**
-   * @param {any} actual
-   * @param {any} expected
-   * @param {string | Error} [message]
-   * @param {string} [operator]
-   * @param {Function} [stackStartFn]
+   * Throws an AssertionError with the given message.
+   * @param {any | Error} [message]
    */
-  fail(actual, expected, message, operator, stackStartFn) {
-    const argsLen = arguments.length;
+  fail(message) {
+    if (isError(message)) throw message;
 
     let internalMessage = false;
-    if (actual == null && argsLen <= 1) {
-      internalMessage = true;
+    if (message === undefined) {
       message = 'Failed';
-    } else if (argsLen === 1) {
-      message = actual;
-      actual = undefined;
-    } else {
-      if (warned === false) {
-        warned = true;
-        process.emitWarning(
-          'assert.fail() with more than one argument is deprecated. ' +
-            'Please use assert.strictEqual() instead or only pass a message.',
-          'DeprecationWarning',
-          'DEP0094',
-        );
-      }
-      if (argsLen === 2)
-        operator = '!=';
+      internalMessage = true;
     }
 
-    if (message instanceof Error) throw message;
-
     const errArgs = {
-      actual,
-      expected,
-      operator: operator === undefined ? 'fail' : operator,
-      stackStartFn: stackStartFn || this.fail,
+      operator: 'fail',
+      stackStartFn: this.fail,
       message,
     };
     const err = new AssertionError(errArgs);
@@ -837,292 +815,6 @@ function ok(...args) {
 ObjectAssign(assert, assertInstance);
 assert.ok = ok;
 
-// 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 innerFail(obj) {
-  if (obj.message instanceof Error) throw obj.message;
-
-  throw new AssertionError(obj);
-}
-
-/**
- * Throws an AssertionError with the given message.
- * @param {any | Error} [message]
- */
-function fail(message) {
-  if (isError(message)) throw message;
-
-  let internalMessage = false;
-  if (message === undefined) {
-    message = 'Failed';
-    internalMessage = true;
-  }
-
-  const errArgs = {
-    operator: 'fail',
-    stackStartFn: fail,
-    message,
-  };
-  const err = new AssertionError(errArgs);
-  if (internalMessage) {
-    err.generatedMessage = true;
-  }
-  throw err;
-}
-
-assert.fail = fail;
-
-// The AssertionError is defined in internal/error.
-assert.AssertionError = AssertionError;
-
-/**
- * Pure assertion tests whether a value is truthy, as determined
- * by !!value.
- * @param {...any} args
- * @returns {void}
- */
-function ok(...args) {
-  innerOk(ok, args.length, ...args);
-}
-assert.ok = ok;
-
-/**
- * The equality assertion tests shallow, coercive equality with ==.
- * @param {any} actual
- * @param {any} expected
- * @param {string | Error} [message]
- * @returns {void}
- */
-/* eslint-disable no-restricted-properties */
-assert.equal = function equal(actual, expected, message) {
-  if (arguments.length < 2) {
-    throw new ERR_MISSING_ARGS('actual', 'expected');
-  }
-  // eslint-disable-next-line eqeqeq
-  if (actual != expected && (!NumberIsNaN(actual) || !NumberIsNaN(expected))) {
-    innerFail({
-      actual,
-      expected,
-      message,
-      operator: '==',
-      stackStartFn: equal,
-    });
-  }
-};
-
-/**
- * The non-equality assertion tests for whether two objects are not
- * equal with !=.
- * @param {any} actual
- * @param {any} expected
- * @param {string | Error} [message]
- * @returns {void}
- */
-assert.notEqual = function notEqual(actual, expected, message) {
-  if (arguments.length < 2) {
-    throw new ERR_MISSING_ARGS('actual', 'expected');
-  }
-  // eslint-disable-next-line eqeqeq
-  if (actual == expected || (NumberIsNaN(actual) && NumberIsNaN(expected))) {
-    innerFail({
-      actual,
-      expected,
-      message,
-      operator: '!=',
-      stackStartFn: notEqual,
-    });
-  }
-};
-
-/**
- * The deep equivalence assertion tests a deep equality relation.
- * @param {any} actual
- * @param {any} expected
- * @param {string | Error} [message]
- * @returns {void}
- */
-assert.deepEqual = function deepEqual(actual, expected, message) {
-  if (arguments.length < 2) {
-    throw new ERR_MISSING_ARGS('actual', 'expected');
-  }
-  if (isDeepEqual === undefined) lazyLoadComparison();
-  if (!isDeepEqual(actual, expected)) {
-    innerFail({
-      actual,
-      expected,
-      message,
-      operator: 'deepEqual',
-      stackStartFn: deepEqual,
-    });
-  }
-};
-
-/**
- * The deep non-equivalence assertion tests for any deep inequality.
- * @param {any} actual
- * @param {any} expected
- * @param {string | Error} [message]
- * @returns {void}
- */
-assert.notDeepEqual = function notDeepEqual(actual, expected, message) {
-  if (arguments.length < 2) {
-    throw new ERR_MISSING_ARGS('actual', 'expected');
-  }
-  if (isDeepEqual === undefined) lazyLoadComparison();
-  if (isDeepEqual(actual, expected)) {
-    innerFail({
-      actual,
-      expected,
-      message,
-      operator: 'notDeepEqual',
-      stackStartFn: notDeepEqual,
-    });
-  }
-};
-/* eslint-enable */
-
-/**
- * The deep strict equivalence assertion tests a deep strict equality
- * relation.
- * @param {any} actual
- * @param {any} expected
- * @param {string | Error} [message]
- * @returns {void}
- */
-assert.deepStrictEqual = function deepStrictEqual(actual, expected, message) {
-  if (arguments.length < 2) {
-    throw new ERR_MISSING_ARGS('actual', 'expected');
-  }
-  if (isDeepEqual === undefined) lazyLoadComparison();
-  if (!isDeepStrictEqual(actual, expected)) {
-    innerFail({
-      actual,
-      expected,
-      message,
-      operator: 'deepStrictEqual',
-      stackStartFn: deepStrictEqual,
-    });
-  }
-};
-
-/**
- * The deep strict non-equivalence assertion tests for any deep strict
- * inequality.
- * @param {any} actual
- * @param {any} expected
- * @param {string | Error} [message]
- * @returns {void}
- */
-assert.notDeepStrictEqual = notDeepStrictEqual;
-function notDeepStrictEqual(actual, expected, message) {
-  if (arguments.length < 2) {
-    throw new ERR_MISSING_ARGS('actual', 'expected');
-  }
-  if (isDeepEqual === undefined) lazyLoadComparison();
-  if (isDeepStrictEqual(actual, expected)) {
-    innerFail({
-      actual,
-      expected,
-      message,
-      operator: 'notDeepStrictEqual',
-      stackStartFn: notDeepStrictEqual,
-    });
-  }
-}
-
-
-// assert.strictEqual = function strictEqual(actual, expected, message) {
-
-/**
- * The strict non-equivalence assertion tests for any strict inequality.
- * @param {any} actual
- * @param {any} expected
- * @param {string | Error} [message]
- * @returns {void}
- */
-assert.notStrictEqual = function notStrictEqual(actual, expected, message) {
-  if (arguments.length < 2) {
-    throw new ERR_MISSING_ARGS('actual', 'expected');
-  }
-  if (ObjectIs(actual, expected)) {
-    innerFail({
-      actual,
-      expected,
-      message,
-      operator: 'notStrictEqual',
-      stackStartFn: notStrictEqual,
-    });
-  }
-};
-
-/**
- * The strict equivalence assertion test between two objects
- * @param {any} actual
- * @param {any} expected
- * @param {string | Error} [message]
- * @returns {void}
- */
-assert.partialDeepStrictEqual = function partialDeepStrictEqual(
-  actual,
-  expected,
-  message,
-) {
-  if (arguments.length < 2) {
-    throw new ERR_MISSING_ARGS('actual', 'expected');
-  }
-  if (isDeepEqual === undefined) lazyLoadComparison();
-  if (!isPartialStrictEqual(actual, expected)) {
-    innerFail({
-      actual,
-      expected,
-      message,
-      operator: 'partialDeepStrictEqual',
-      stackStartFn: partialDeepStrictEqual,
-    });
-  }
-};
-
-class Comparison {
-  constructor(obj, keys, actual) {
-    for (const key of keys) {
-      if (key in obj) {
-        if (actual !== undefined &&
-            typeof actual[key] === 'string' &&
-            isRegExp(obj[key]) &&
-            RegExpPrototypeExec(obj[key], actual[key]) !== null) {
-          this[key] = actual[key];
-        } else {
-          this[key] = obj[key];
-        }
-      }
-    }
-  }
-}
-
-function hasMatchingError(actual, expected) {
-  if (typeof expected !== 'function') {
-    if (isRegExp(expected)) {
-      const str = String(actual);
-      return RegExpPrototypeExec(expected, str) !== null;
-    }
-    throw new ERR_INVALID_ARG_TYPE(
-      'expected', ['Function', 'RegExp'], expected,
-    );
-  }
-  // Guard instanceof against arrow functions as they don't have a prototype.
-  if (expected.prototype !== undefined && actual instanceof expected) {
-    return true;
-  }
-  if (ObjectPrototypeIsPrototypeOf(Error, expected)) {
-    return false;
-  }
-  return ReflectApply(expected, {}, [actual]) === true;
-}
-
 /**
  * Expose a strict only variant of assert.
  * @param {...any} args