lib: move hasMatchingError as private method to Assert

Author: miguelmarcondesf

lib/assert.js

@@ -79,12 +79,35 @@ const assert = module.exports = ok;
 
 const NO_EXCEPTION_SENTINEL = {};
 
+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];
+        }
+      }
+    }
+  }
+}
+
 class Assert {
   constructor(options = {}) {
     this.options = options;
     this.AssertionError = AssertionError;
   }
 
+  // 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.
+
   #innerFail(obj) {
     if (obj.message instanceof Error) throw obj.message;
 
@@ -321,7 +344,7 @@ class Assert {
       error = undefined;
     }
 
-    if (!error || hasMatchingError(actual, error)) {
+    if (!error || this.#hasMatchingError(actual, error)) {
       const details = message ? `: ${message}` : '.';
       const fnType = stackStartFn === Assert.prototype.doesNotReject ?
         'rejection' : 'exception';
@@ -337,6 +360,26 @@ class Assert {
     throw actual;
   }
 
+  #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;
+  }
+
   async #waitForActual(promiseFn) {
     let resultPromise;
     if (typeof promiseFn === 'function') {