diff --git a/doc/api/assert.md b/doc/api/assert.md
index fb33994df1586d..63365762aa8a0b 100644
--- a/doc/api/assert.md
+++ b/doc/api/assert.md
@@ -8,6 +8,9 @@ The `assert` module provides a set of assertion functions for verifying
 invariants. The module provides a recommended [`strict` mode][] and a more
 lenient legacy mode.
 
+To deactivate colors in output, use the `NODE_DISABLE_COLORS` environment
+variable. This will also deactivate the colors in the REPL.
+
 ## Class: assert.AssertionError
 
 A subclass of `Error` that indicates the failure of an assertion. All errors
@@ -78,8 +81,8 @@ changes:
 -->
 
 In `strict` mode, `assert` functions use the comparison in the corresponding
-strict functions. For example, [`assert.deepEqual()`][] will behave like
-[`assert.deepStrictEqual()`][].
+strict functions. For example, [`assert.equal()`][] will behave like
+[`assert.strictEqual()`][].
 
 In `strict` mode, error messages for objects display a diff. In legacy mode,
 error messages for objects display the objects, often truncated.
@@ -111,17 +114,15 @@ assert.deepEqual([[[1, 2, 3]], 4, 5], [[[1, 2, '3']], 4, 5]);
 //   ]
 ```
 
-To deactivate the colors, use the `NODE_DISABLE_COLORS` environment variable.
-This will also deactivate the colors in the REPL.
-
 ## Legacy mode
 
-Legacy mode uses the [Abstract Equality Comparison][] in:
+When accessing `assert` directly instead of using the `strict` property, the
+[Abstract Equality Comparison][] will be used for [`assert.equal()`][] and
+[`assert.notEqual()`][].
 
-* [`assert.deepEqual()`][]
-* [`assert.equal()`][]
-* [`assert.notDeepEqual()`][]
-* [`assert.notEqual()`][]
+In legacy mode, [`assert.deepEqual()`][] and [`assert.notDeepEqual()`][] work
+the same as in `strict` mode except that the prototypes of the objects are not
+compared.
 
 To use legacy mode:
 
@@ -130,14 +131,7 @@ const assert = require('assert');
 ```
 
 Whenever possible, use the [`strict` mode][] instead. Otherwise, the
-[Abstract Equality Comparison][] may cause surprising results. This is
-especially true for [`assert.deepEqual()`][], where the comparison rules are
-lax:
-
-```js
-// WARNING: This does not throw an AssertionError!
-assert.deepEqual(/a/gi, new Date());
-```
+[Abstract Equality Comparison][] may cause surprising results.
 
 ## assert(value[, message])
 <!-- YAML
@@ -152,6 +146,10 @@ An alias of [`assert.ok()`][].
 <!-- YAML
 added: v0.1.21
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/28011
+    description: Now identical to `deepStrictEqual()` except that it will not
+                 check the prototype.
   - version: v12.0.0
     pr-url: https://github.com/nodejs/node/pull/25008
     description: The type tags are now properly compared and there are a couple
@@ -182,84 +180,8 @@ An alias of [`assert.deepStrictEqual()`][].
 
 **Legacy mode**
 
-> Stability: 0 - Deprecated: Use [`assert.deepStrictEqual()`][] instead.
-
-Tests for deep equality between the `actual` and `expected` parameters. Consider
-using [`assert.deepStrictEqual()`][] instead. [`assert.deepEqual()`][] can have
-potentially surprising results.
-
-"Deep" equality means that the enumerable "own" properties of child objects
-are also recursively evaluated by the following rules.
-
-### Comparison details
-
-* Primitive values are compared with the [Abstract Equality Comparison][]
-  ( `==` ).
-* [Type tags][Object.prototype.toString()] of objects should be the same.
-* Only [enumerable "own" properties][] are considered.
-* [`Error`][] names and messages are always compared, even if these are not
-  enumerable properties.
-* [Object wrappers][] are compared both as objects and unwrapped values.
-* `Object` properties are compared unordered.
-* [`Map`][] keys and [`Set`][] items are compared unordered.
-* Recursion stops when both sides differ or both sides encounter a circular
-  reference.
-* Implementation does not test the [`[[Prototype]]`][prototype-spec] of
-  objects.
-* [`Symbol`][] properties are not compared.
-* [`WeakMap`][] and [`WeakSet`][] comparison does not rely on their values.
-
-The following example does not throw an `AssertionError` because the primitives
-are considered equal by the [Abstract Equality Comparison][] ( `==` ).
-
-```js
-// WARNING: This does not throw an AssertionError!
-assert.deepEqual('+00000000', false);
-```
-
-"Deep" equality means that the enumerable "own" properties of child objects
-are evaluated also:
-
-```js
-const assert = require('assert');
-
-const obj1 = {
-  a: {
-    b: 1
-  }
-};
-const obj2 = {
-  a: {
-    b: 2
-  }
-};
-const obj3 = {
-  a: {
-    b: 1
-  }
-};
-const obj4 = Object.create(obj1);
-
-assert.deepEqual(obj1, obj1);
-// OK
-
-// Values of b are different:
-assert.deepEqual(obj1, obj2);
-// AssertionError: { a: { b: 1 } } deepEqual { a: { b: 2 } }
-
-assert.deepEqual(obj1, obj3);
-// OK
-
-// Prototypes are ignored:
-assert.deepEqual(obj1, obj4);
-// AssertionError: { a: { b: 1 } } deepEqual {}
-```
-
-If the values are not equal, an `AssertionError` is thrown with a `message`
-property set equal to the value of the `message` parameter. If the `message`
-parameter is undefined, a default error message is assigned. If the `message`
-parameter is an instance of an [`Error`][] then it will be thrown instead of the
-`AssertionError`.
+Identical to [`assert.deepStrictEqual()`][] except that prototypes are not
+compared.
 
 ## assert.deepStrictEqual(actual, expected[, message])
 <!-- YAML
@@ -715,6 +637,10 @@ let err;
 <!-- YAML
 added: v0.1.21
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/28011
+    description: Now identical to `notDeepStrictEqual()` except that it will not
+                 check the prototype.
   - version: v9.0.0
     pr-url: https://github.com/nodejs/node/pull/15001
     description: The `Error` names and messages are now properly compared
@@ -741,48 +667,8 @@ An alias of [`assert.notDeepStrictEqual()`][].
 
 **Legacy mode**
 
-> Stability: 0 - Deprecated: Use [`assert.notDeepStrictEqual()`][] instead.
-
-Tests for any deep inequality. Opposite of [`assert.deepEqual()`][].
-
-```js
-const assert = require('assert');
-
-const obj1 = {
-  a: {
-    b: 1
-  }
-};
-const obj2 = {
-  a: {
-    b: 2
-  }
-};
-const obj3 = {
-  a: {
-    b: 1
-  }
-};
-const obj4 = Object.create(obj1);
-
-assert.notDeepEqual(obj1, obj1);
-// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
-
-assert.notDeepEqual(obj1, obj2);
-// OK
-
-assert.notDeepEqual(obj1, obj3);
-// AssertionError: { a: { b: 1 } } notDeepEqual { a: { b: 1 } }
-
-assert.notDeepEqual(obj1, obj4);
-// OK
-```
-
-If the values are deeply equal, an `AssertionError` is thrown with a `message`
-property set equal to the value of the `message` parameter. If the `message`
-parameter is undefined, a default error message is assigned. If the `message`
-parameter is an instance of an [`Error`][] then it will be thrown instead of the
-`AssertionError`.
+Identical to [`assert.notDeepStrictEqual()`][] except that prototypes are not
+compared.
 
 ## assert.notDeepStrictEqual(actual, expected[, message])
 <!-- YAML
@@ -1277,10 +1163,11 @@ second argument. This might lead to difficult-to-spot errors.
 [`TypeError`]: errors.html#errors_class_typeerror
 [`WeakMap`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakMap
 [`WeakSet`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/WeakSet
-[`assert.deepEqual()`]: #assert_assert_deepequal_actual_expected_message
 [`assert.deepStrictEqual()`]: #assert_assert_deepstrictequal_actual_expected_message
 [`assert.doesNotThrow()`]: #assert_assert_doesnotthrow_fn_error_message
+[`assert.equal()`]: #assert_assert_equal_actual_expected_message
 [`assert.notDeepStrictEqual()`]: #assert_assert_notdeepstrictequal_actual_expected_message
+[`assert.notEqual()`]: #assert_assert_notequal_actual_expected_message
 [`assert.notStrictEqual()`]: #assert_assert_notstrictequal_actual_expected_message
 [`assert.ok()`]: #assert_assert_ok_value_message
 [`assert.strictEqual()`]: #assert_assert_strictequal_actual_expected_message
diff --git a/lib/internal/assert/assertion_error.js b/lib/internal/assert/assertion_error.js
index 3734796e2d2a2d..4d97e5c5f3f711 100644
--- a/lib/internal/assert/assertion_error.js
+++ b/lib/internal/assert/assertion_error.js
@@ -16,14 +16,13 @@ const kReadableOperator = {
   deepStrictEqual: 'Expected values to be strictly deep-equal:',
   strictEqual: 'Expected values to be strictly equal:',
   strictEqualObject: 'Expected "actual" to be reference-equal to "expected":',
-  deepEqual: 'Expected values to be loosely deep-equal:',
+  deepEqual: 'Expected values to be deep-equal:',
   notDeepStrictEqual: 'Expected "actual" not to be strictly deep-equal to:',
   notStrictEqual: 'Expected "actual" to be strictly unequal to:',
   notStrictEqualObject:
     'Expected "actual" not to be reference-equal to "expected":',
-  notDeepEqual: 'Expected "actual" not to be loosely deep-equal to:',
+  notDeepEqual: 'Expected "actual" not to be deep-equal to:',
   notIdentical: 'Values have same structure but are not reference-equal:',
-  notDeepEqualUnequal: 'Expected values not to be loosely deep-equal:'
 };
 
 // Comparing short primitives should just show === / !== instead of using the
@@ -337,10 +336,9 @@ class AssertionError extends Error {
         expected = copyError(expected);
       }
 
-      if (operator === 'deepStrictEqual' || operator === 'strictEqual') {
+      if (/^(deep|strict|deepStrict)Equal$/.test(operator)) {
         super(createErrDiff(actual, expected, operator));
-      } else if (operator === 'notDeepStrictEqual' ||
-        operator === 'notStrictEqual') {
+      } else if (/^not(Deep|Strict|DeepStrict)Equal$/.test(operator)) {
         // In case the objects are equal but the operator requires unequal, show
         // the first object and say A equals B
         let base = kReadableOperator[operator];
@@ -372,32 +370,19 @@ class AssertionError extends Error {
       } else {
         let res = inspectValue(actual);
         let other = inspectValue(expected);
-        const knownOperator = kReadableOperator[operator];
-        if (operator === 'notDeepEqual' && res === other) {
-          res = `${knownOperator}\n\n${res}`;
-          if (res.length > 1024) {
-            res = `${res.slice(0, 1021)}...`;
-          }
-          super(res);
+        if (res.length > 512) {
+          res = `${res.slice(0, 509)}...`;
+        }
+        if (other.length > 512) {
+          other = `${other.slice(0, 509)}...`;
+        }
+        const newOp = kReadableOperator[`${operator}Unequal`];
+        if (newOp) {
+          res = `${newOp}\n\n${res}\n\nshould not deep-equal\n\n`;
         } else {
-          if (res.length > 512) {
-            res = `${res.slice(0, 509)}...`;
-          }
-          if (other.length > 512) {
-            other = `${other.slice(0, 509)}...`;
-          }
-          if (operator === 'deepEqual') {
-            res = `${knownOperator}\n\n${res}\n\nshould loosely deep-equal\n\n`;
-          } else {
-            const newOp = kReadableOperator[`${operator}Unequal`];
-            if (newOp) {
-              res = `${newOp}\n\n${res}\n\nshould not loosely deep-equal\n\n`;
-            } else {
-              other = ` ${operator} ${other}`;
-            }
-          }
-          super(`${res}${other}`);
+          other = ` ${operator} ${other}`;
         }
+        super(`${res}${other}`);
       }
     }
 
diff --git a/lib/internal/util/comparisons.js b/lib/internal/util/comparisons.js
index a895da2ad12945..1b1a29a4ac16dd 100644
--- a/lib/internal/util/comparisons.js
+++ b/lib/internal/util/comparisons.js
@@ -31,14 +31,11 @@ const {
   isBooleanObject,
   isBigIntObject,
   isSymbolObject,
-  isFloat32Array,
-  isFloat64Array
 } = require('internal/util/types');
 const {
   getOwnNonIndexProperties,
   propertyFilter: {
     ONLY_ENUMERABLE,
-    SKIP_SYMBOLS
   }
 } = internalBinding('util');
 
@@ -55,18 +52,6 @@ function areSimilarRegExps(a, b) {
   return a.source === b.source && a.flags === b.flags;
 }
 
-function areSimilarFloatArrays(a, b) {
-  if (a.byteLength !== b.byteLength) {
-    return false;
-  }
-  for (var offset = 0; offset < a.byteLength; offset++) {
-    if (a[offset] !== b[offset]) {
-      return false;
-    }
-  }
-  return true;
-}
-
 function areSimilarTypedArrays(a, b) {
   if (a.byteLength !== b.byteLength) {
     return false;
@@ -120,7 +105,7 @@ function isEqualBoxedPrimitive(val1, val2) {
 // (e.g. a Uint8Array and a Uint16Array with the same memory content
 // could still be different because they will be interpreted differently).
 //
-// For strict comparison, objects should have
+// To be treated as deep equal, objects should have:
 // a) The same built-in type tags
 // b) The same prototypes.
 
@@ -129,33 +114,22 @@ function innerDeepEqual(val1, val2, strict, memos) {
   if (val1 === val2) {
     if (val1 !== 0)
       return true;
-    return strict ? Object.is(val1, val2) : true;
+    return Object.is(val1, val2);
   }
 
   // Check more closely if val1 and val2 are equal.
-  if (strict) {
-    if (typeof val1 !== 'object') {
-      return typeof val1 === 'number' && Number.isNaN(val1) &&
-        Number.isNaN(val2);
-    }
-    if (typeof val2 !== 'object' || val1 === null || val2 === null) {
-      return false;
-    }
-    if (Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
-      return false;
-    }
-  } else {
-    if (val1 === null || typeof val1 !== 'object') {
-      if (val2 === null || typeof val2 !== 'object') {
-        // eslint-disable-next-line eqeqeq
-        return val1 == val2;
-      }
-      return false;
-    }
-    if (val2 === null || typeof val2 !== 'object') {
-      return false;
-    }
+  if (typeof val1 !== 'object') {
+    return typeof val1 === 'number' && Number.isNaN(val1) &&
+      Number.isNaN(val2);
+  }
+  if (typeof val2 !== 'object' || val1 === null || val2 === null) {
+    return false;
   }
+
+  if (strict && Object.getPrototypeOf(val1) !== Object.getPrototypeOf(val2)) {
+    return false;
+  }
+
   const val1Tag = objectToString(val1);
   const val2Tag = objectToString(val2);
 
@@ -167,9 +141,8 @@ function innerDeepEqual(val1, val2, strict, memos) {
     if (val1.length !== val2.length) {
       return false;
     }
-    const filter = strict ? ONLY_ENUMERABLE : ONLY_ENUMERABLE | SKIP_SYMBOLS;
-    const keys1 = getOwnNonIndexProperties(val1, filter);
-    const keys2 = getOwnNonIndexProperties(val2, filter);
+    const keys1 = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
+    const keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
     if (keys1.length !== keys2.length) {
       return false;
     }
@@ -193,19 +166,14 @@ function innerDeepEqual(val1, val2, strict, memos) {
       return false;
     }
   } else if (isArrayBufferView(val1)) {
-    if (!strict && (isFloat32Array(val1) || isFloat64Array(val1))) {
-      if (!areSimilarFloatArrays(val1, val2)) {
-        return false;
-      }
-    } else if (!areSimilarTypedArrays(val1, val2)) {
+    if (!areSimilarTypedArrays(val1, val2)) {
       return false;
     }
     // Buffer.compare returns true, so val1.length === val2.length. If they both
     // only contain numeric keys, we don't need to exam further than checking
     // the symbols.
-    const filter = strict ? ONLY_ENUMERABLE : ONLY_ENUMERABLE | SKIP_SYMBOLS;
-    const keys1 = getOwnNonIndexProperties(val1, filter);
-    const keys2 = getOwnNonIndexProperties(val2, filter);
+    const keys1 = getOwnNonIndexProperties(val1, ONLY_ENUMERABLE);
+    const keys2 = getOwnNonIndexProperties(val2, ONLY_ENUMERABLE);
     if (keys1.length !== keys2.length) {
       return false;
     }
@@ -262,7 +230,7 @@ function keyCheck(val1, val2, strict, memos, iterationType, aKeys) {
     }
   }
 
-  if (strict && arguments.length === 5) {
+  if (arguments.length === 5) {
     const symbolKeysA = Object.getOwnPropertySymbols(val1);
     if (symbolKeysA.length !== 0) {
       let count = 0;
@@ -344,52 +312,6 @@ function setHasEqualElement(set, val1, strict, memo) {
   return false;
 }
 
-// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#Loose_equality_using
-// Sadly it is not possible to detect corresponding values properly in case the
-// type is a string, number, bigint or boolean. The reason is that those values
-// can match lots of different string values (e.g., 1n == '+00001').
-function findLooseMatchingPrimitives(prim) {
-  switch (typeof prim) {
-    case 'undefined':
-      return null;
-    case 'object': // Only pass in null as object!
-      return undefined;
-    case 'symbol':
-      return false;
-    case 'string':
-      prim = +prim;
-      // Loose equal entries exist only if the string is possible to convert to
-      // a regular number and not NaN.
-      // Fall through
-    case 'number':
-      if (Number.isNaN(prim)) {
-        return false;
-      }
-  }
-  return true;
-}
-
-function setMightHaveLoosePrim(a, b, prim) {
-  const altValue = findLooseMatchingPrimitives(prim);
-  if (altValue != null)
-    return altValue;
-
-  return b.has(altValue) && !a.has(altValue);
-}
-
-function mapMightHaveLoosePrim(a, b, prim, item, memo) {
-  const altValue = findLooseMatchingPrimitives(prim);
-  if (altValue != null) {
-    return altValue;
-  }
-  const curB = b.get(altValue);
-  if (curB === undefined && !b.has(altValue) ||
-      !innerDeepEqual(item, curB, false, memo)) {
-    return false;
-  }
-  return !a.has(altValue) && innerDeepEqual(item, curB, false, memo);
-}
-
 function setEquiv(a, b, strict, memo) {
   // This is a lazily initiated Set of entries which have to be compared
   // pairwise.
@@ -402,24 +324,13 @@ function setEquiv(a, b, strict, memo) {
       if (set === null) {
         set = new Set();
       }
-      // If the specified value doesn't exist in the second set its an not null
-      // object (or non strict only: a not matching primitive) we'll need to go
-      // hunting for something thats deep-(strict-)equal to it. To make this
-      // O(n log n) complexity we have to copy these values in a new set first.
+      // If the specified value doesn't exist in the second set and it's a
+      // not-null object, we'll need to go hunting for something thats
+      // deep-equal to it. To make this O(n log n) complexity, we have to copy
+      // these values in a new set first.
       set.add(val);
     } else if (!b.has(val)) {
-      if (strict)
-        return false;
-
-      // Fast path to detect missing string, symbol, undefined and null values.
-      if (!setMightHaveLoosePrim(a, b, val)) {
-        return false;
-      }
-
-      if (set === null) {
-        set = new Set();
-      }
-      set.add(val);
+      return false;
     }
   }
 
@@ -430,10 +341,6 @@ function setEquiv(a, b, strict, memo) {
       if (typeof val === 'object' && val !== null) {
         if (!setHasEqualElement(set, val, strict, memo))
           return false;
-      } else if (!strict &&
-                 !a.has(val) &&
-                 !setHasEqualElement(set, val, strict, memo)) {
-        return false;
       }
     }
     return set.size === 0;
@@ -472,16 +379,7 @@ function mapEquiv(a, b, strict, memo) {
       const item2 = b.get(key);
       if ((item2 === undefined && !b.has(key) ||
           !innerDeepEqual(item1, item2, strict, memo))) {
-        if (strict)
-          return false;
-        // Fast path to detect missing string, symbol, undefined and null
-        // keys.
-        if (!mapMightHaveLoosePrim(a, b, key, item1, memo))
-          return false;
-        if (set === null) {
-          set = new Set();
-        }
-        set.add(key);
+        return false;
       }
     }
   }
@@ -491,11 +389,6 @@ function mapEquiv(a, b, strict, memo) {
       if (typeof key === 'object' && key !== null) {
         if (!mapHasEqualEntry(set, a, key, item, strict, memo))
           return false;
-      } else if (!strict &&
-                 (!a.has(key) ||
-                   !innerDeepEqual(a.get(key), item, false, memo)) &&
-                 !mapHasEqualEntry(set, a, key, item, false, memo)) {
-        return false;
       }
     }
     return set.size === 0;
@@ -565,5 +458,5 @@ function isDeepStrictEqual(val1, val2) {
 
 module.exports = {
   isDeepEqual,
-  isDeepStrictEqual
+  isDeepStrictEqual,
 };
diff --git a/test/parallel/test-assert-deep.js b/test/parallel/test-assert-deep.js
index 87f2a5f44f7d64..44dbde68188caf 100644
--- a/test/parallel/test-assert-deep.js
+++ b/test/parallel/test-assert-deep.js
@@ -13,29 +13,6 @@ const defaultMsgStartFull = `${defaultMsgStart}+ actual - expected`;
 if (process.stdout.isTTY)
   process.env.NODE_DISABLE_COLORS = '1';
 
-// Template tag function turning an error message into a RegExp
-// for assert.throws()
-function re(literals, ...values) {
-  let result = 'Expected values to be loosely deep-equal:\n\n';
-  for (const [i, value] of values.entries()) {
-    const str = util.inspect(value, {
-      compact: false,
-      depth: 1000,
-      customInspect: false,
-      maxArrayLength: Infinity,
-      breakLength: Infinity,
-      sorted: true,
-      getters: true
-    });
-    // Need to escape special characters.
-    result += `${str}${literals[i + 1]}`;
-  }
-  return {
-    code: 'ERR_ASSERTION',
-    message: result
-  };
-}
-
 // The following deepEqual tests might seem very weird.
 // They just describe what it is now.
 // That is why we discourage using deepEqual in our own tests.
@@ -196,7 +173,7 @@ function assertDeepAndStrictEqual(a, b) {
 function assertNotDeepOrStrict(a, b, err) {
   assert.throws(
     () => assert.deepEqual(a, b),
-    err || re`${a}\n\nshould loosely deep-equal\n\n${b}`
+    err || { code: 'ERR_ASSERTION' }
   );
   assert.throws(
     () => assert.deepStrictEqual(a, b),
@@ -205,22 +182,8 @@ function assertNotDeepOrStrict(a, b, err) {
 
   assert.throws(
     () => assert.deepEqual(b, a),
-    err || re`${b}\n\nshould loosely deep-equal\n\n${a}`
-  );
-  assert.throws(
-    () => assert.deepStrictEqual(b, a),
     err || { code: 'ERR_ASSERTION' }
   );
-}
-
-function assertOnlyDeepEqual(a, b, err) {
-  assert.deepEqual(a, b);
-  assert.throws(
-    () => assert.deepStrictEqual(a, b),
-    err || { code: 'ERR_ASSERTION' }
-  );
-
-  assert.deepEqual(b, a);
   assert.throws(
     () => assert.deepStrictEqual(b, a),
     err || { code: 'ERR_ASSERTION' }
@@ -267,10 +230,10 @@ assertNotDeepOrStrict(new Map([['a', 1]]), { a: 1 });
 assertNotDeepOrStrict(new Map(), []);
 assertNotDeepOrStrict(new Map(), {});
 
-assertOnlyDeepEqual(new Set(['1']), new Set([1]));
+assertNotDeepOrStrict(new Set(['1']), new Set([1]));
 
-assertOnlyDeepEqual(new Map([['1', 'a']]), new Map([[1, 'a']]));
-assertOnlyDeepEqual(new Map([['a', '1']]), new Map([['a', 1]]));
+assertNotDeepOrStrict(new Map([['1', 'a']]), new Map([[1, 'a']]));
+assertNotDeepOrStrict(new Map([['a', '1']]), new Map([['a', 1]]));
 assertNotDeepOrStrict(new Map([['a', '1']]), new Map([['a', 2]]));
 
 assertDeepAndStrictEqual(new Set([{}]), new Set([{}]));
@@ -308,7 +271,7 @@ assertDeepAndStrictEqual(
 );
 
 // This is an awful case, where a map contains multiple equivalent keys:
-assertOnlyDeepEqual(
+assertNotDeepOrStrict(
   new Map([[1, 'a'], ['1', 'b']]),
   new Map([['1', 'a'], [true, 'b']])
 );
@@ -320,7 +283,7 @@ assertDeepAndStrictEqual(
   new Map([[{}, 'a'], [{}, 'b']]),
   new Map([[{}, 'b'], [{}, 'a']])
 );
-assertOnlyDeepEqual(
+assertNotDeepOrStrict(
   new Map([[true, 'a'], ['1', 'b'], [1, 'a']]),
   new Map([['1', 'a'], [1, 'b'], [true, 'a']])
 );
@@ -342,7 +305,7 @@ assertNotDeepOrStrict(
   new Map([[{}, 1], [{}, 1]]),
   new Map([[{}, 1], [1, 1]])
 );
-assertOnlyDeepEqual(
+assertNotDeepOrStrict(
   new Map([[{}, 1], [true, 1]]),
   new Map([[{}, 1], [1, 1]])
 );
@@ -362,7 +325,7 @@ assertDeepAndStrictEqual(
   new Map([[1, undefined]]),
   new Map([[1, undefined]])
 );
-assertOnlyDeepEqual(
+assertNotDeepOrStrict(
   new Map([[1, null], ['', '0']]),
   new Map([['1', undefined], [false, 0]])
 );
@@ -376,12 +339,12 @@ assertDeepAndStrictEqual(
   new Map([[null, 3]]),
   new Map([[null, 3]])
 );
-assertOnlyDeepEqual(
+assertNotDeepOrStrict(
   new Map([[undefined, null], ['+000', 2n]]),
   new Map([[null, undefined], [false, '2']]),
 );
 
-assertOnlyDeepEqual(
+assertNotDeepOrStrict(
   new Set([null, '', 1n, 5, 2n, false]),
   new Set([undefined, 0, 5n, true, '2', '-000'])
 );
@@ -389,11 +352,11 @@ assertNotDeepOrStrict(
   new Set(['']),
   new Set(['0'])
 );
-assertOnlyDeepEqual(
+assertNotDeepOrStrict(
   new Map([[1, {}]]),
   new Map([[true, {}]])
 );
-assertOnlyDeepEqual(
+assertNotDeepOrStrict(
   new Map([[undefined, true]]),
   new Map([[null, true]])
 );
@@ -523,7 +486,15 @@ assertNotDeepOrStrict(
 {
   const map1 = new Map([[1, 1]]);
   const map2 = new Map([[1, '1']]);
-  assert.deepEqual(map1, map2);
+  assert.throws(
+    () => assert.deepEqual(map1, map2),
+    {
+      code: 'ERR_ASSERTION',
+      message: 'Expected values to be deep-equal:\n+' +
+               ' actual - expected\n\n' +
+               "  Map {\n+   1 => 1\n-   1 => '1'\n  }"
+    }
+  );
   assert.throws(
     () => assert.deepStrictEqual(map1, map2),
     {
@@ -595,7 +566,7 @@ assertNotDeepOrStrict(
 }
 
 // Handle NaN
-assert.notDeepEqual(NaN, NaN);
+assert.deepEqual(NaN, NaN);
 assert.deepStrictEqual(NaN, NaN);
 assert.deepStrictEqual({ a: NaN }, { a: NaN });
 assert.deepStrictEqual([ 1, 2, NaN, 4 ], [ 1, 2, NaN, 4 ]);
@@ -631,7 +602,7 @@ assert.deepStrictEqual([ 1, 2, NaN, 4 ], [ 1, 2, NaN, 4 ]);
 }
 
 // Minus zero
-assertOnlyDeepEqual(0, -0);
+assertNotDeepOrStrict(0, -0);
 assertDeepAndStrictEqual(-0, -0);
 
 // Handle symbols (enumerable only)
@@ -642,45 +613,40 @@ assertDeepAndStrictEqual(-0, -0);
   const obj3 = { [Symbol()]: 1 };
   // Add a non enumerable symbol as well. It is going to be ignored!
   Object.defineProperty(obj2, Symbol(), { value: 1 });
-  assertOnlyDeepEqual(obj1, obj3);
+  assertNotDeepOrStrict(obj1, obj3);
   assertDeepAndStrictEqual(obj1, obj2);
   obj2[Symbol()] = true;
-  assertOnlyDeepEqual(obj1, obj2);
+  assertNotDeepOrStrict(obj1, obj2);
   // TypedArrays have a fast path. Test for this as well.
   const a = new Uint8Array(4);
   const b = new Uint8Array(4);
   a[symbol1] = true;
   b[symbol1] = false;
-  assertOnlyDeepEqual(a, b);
+  assertNotDeepOrStrict(a, b);
   b[symbol1] = true;
   assertDeepAndStrictEqual(a, b);
   // The same as TypedArrays is valid for boxed primitives
   const boxedStringA = new String('test');
   const boxedStringB = new String('test');
   boxedStringA[symbol1] = true;
-  assertOnlyDeepEqual(boxedStringA, boxedStringB);
+  assertNotDeepOrStrict(boxedStringA, boxedStringB);
   boxedStringA[symbol1] = true;
   assertDeepAndStrictEqual(a, b);
   // Loose equal arrays should not compare symbols.
   const arr = [1];
   const arr2 = [1];
   arr[symbol1] = true;
-  assertOnlyDeepEqual(arr, arr2);
+  assertNotDeepOrStrict(arr, arr2);
   arr2[symbol1] = false;
-  assertOnlyDeepEqual(arr, arr2);
+  assertNotDeepOrStrict(arr, arr2);
 }
 
-assert.throws(
-  () => assert.notDeepEqual(1, true),
-  {
-    message: /1\n\nshould not loosely deep-equal\n\ntrue/
-  }
-);
+assert.notDeepEqual(1, true);
 
 assert.throws(
   () => assert.notDeepEqual(1, 1),
   {
-    message: /Expected "actual" not to be loosely deep-equal to:\n\n1/
+    message: /Expected "actual" not to be deep-equal to: 1/
   }
 );
 
@@ -721,8 +687,8 @@ assertNotDeepOrStrict(/a/igm, /a/im);
   assert.deepEqual(re1, /a/g);
 }
 
-assert.deepEqual(4, '4');
-assert.deepEqual(true, 1);
+assertNotDeepOrStrict(4, '4');
+assertNotDeepOrStrict(true, 1);
 assert.throws(() => assert.deepEqual(4, '5'),
               AssertionError,
               'deepEqual( 4, \'5\')');
@@ -730,7 +696,7 @@ assert.throws(() => assert.deepEqual(4, '5'),
 // Having the same number of owned properties && the same set of keys.
 assert.deepEqual({ a: 4 }, { a: 4 });
 assert.deepEqual({ a: 4, b: '2' }, { a: 4, b: '2' });
-assert.deepEqual([4], ['4']);
+assertNotDeepOrStrict([4], ['4']);
 assert.throws(
   () => assert.deepEqual({ a: 4 }, { a: 4, b: true }), AssertionError);
 assert.notDeepEqual(['a'], { 0: 'a' });
@@ -783,8 +749,8 @@ assertNotDeepOrStrict(true, {});
 assertNotDeepOrStrict(Symbol(), {});
 assertNotDeepOrStrict(Symbol(), Symbol());
 
-assertOnlyDeepEqual(4, '4');
-assertOnlyDeepEqual(true, 1);
+assertNotDeepOrStrict(4, '4');
+assertNotDeepOrStrict(true, 1);
 
 {
   const s = Symbol();
@@ -897,6 +863,21 @@ assert.throws(
              "+ [\n+   'a'\n+ ]\n- {\n-   '0': 'a'\n- }"
   });
 
+// Nested null prototype vs. Object prototype should assert in strict only.
+{
+  const a = { fhqwhgads: { greeting: 'come on' } };
+  const b = Object.create(null);
+  b.fhqwhgads = Object.create(null);
+  b.fhqwhgads.greeting = 'come on';
+  assert.deepEqual(a, b);
+  assert.throws(
+    () => { assert.deepStrictEqual(a, b); },
+    {
+      code: 'ERR_ASSERTION',
+      name: 'AssertionError',
+    }
+  );
+}
 /* eslint-enable */
 
 assert.deepStrictEqual({ a: 4, b: '1' }, { b: '1', a: 4 });
diff --git a/test/parallel/test-assert-typedarray-deepequal.js b/test/parallel/test-assert-typedarray-deepequal.js
index 6be4c10595ab45..c285bb921ccd17 100644
--- a/test/parallel/test-assert-typedarray-deepequal.js
+++ b/test/parallel/test-assert-typedarray-deepequal.js
@@ -64,14 +64,10 @@ const notEqualArrayPairs = [
 ];
 
 equalArrayPairs.forEach((arrayPair) => {
-  // eslint-disable-next-line no-restricted-properties
-  assert.deepEqual(arrayPair[0], arrayPair[1]);
   assert.deepStrictEqual(arrayPair[0], arrayPair[1]);
 });
 
 looseEqualArrayPairs.forEach((arrayPair) => {
-  // eslint-disable-next-line no-restricted-properties
-  assert.deepEqual(arrayPair[0], arrayPair[1]);
   assert.throws(
     makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]),
     assert.AssertionError
@@ -79,11 +75,6 @@ looseEqualArrayPairs.forEach((arrayPair) => {
 });
 
 notEqualArrayPairs.forEach((arrayPair) => {
-  assert.throws(
-    // eslint-disable-next-line no-restricted-properties
-    makeBlock(assert.deepEqual, arrayPair[0], arrayPair[1]),
-    assert.AssertionError
-  );
   assert.throws(
     makeBlock(assert.deepStrictEqual, arrayPair[0], arrayPair[1]),
     assert.AssertionError
diff --git a/test/parallel/test-vm-global-property-interceptors.js b/test/parallel/test-vm-global-property-interceptors.js
index 01ae72446047f9..8e4f90d5c23554 100644
--- a/test/parallel/test-vm-global-property-interceptors.js
+++ b/test/parallel/test-vm-global-property-interceptors.js
@@ -44,8 +44,7 @@ const result = {
 result;
 `, ctx);
 
-// eslint-disable-next-line no-restricted-properties
-assert.deepEqual(result, {
+assert.strictEqual(JSON.stringify(result), JSON.stringify({
   a: { value: 'a', writable: true, enumerable: true, configurable: true },
   b: { value: 'b', writable: false, enumerable: false, configurable: false },
   c: { value: 'c', writable: true, enumerable: true, configurable: false },
@@ -58,7 +57,7 @@ assert.deepEqual(result, {
     configurable: false
   },
   g: undefined
-});
+}));
 
 // Define new properties
 vm.runInContext(`