assert: improve partialDeepStrictEqual performance and add benchmark

Author: puskin

benchmark/assert/partial-deep-strict-equal.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const common = require('../common.js');
+const assert = require('assert');
+
+const bench = common.createBenchmark(main, {
+  n: [10, 50, 200],
+  size: [1e3],
+  datasetName: ['objects', 'simpleSets', 'complexSets', 'maps', 'arrayBuffers', 'dataViewArrayBuffers'],
+});
+
+function createObjects(length, depth = 0) {
+  return Array.from({ length }, () => ({
+    foo: 'yarp',
+    nope: {
+      bar: '123',
+      a: [1, 2, 3],
+      c: {},
+      b: !depth ? createObjects(2, depth + 1) : [],
+    },
+  }));
+}
+
+function createSimpleSets(length, depth = 0) {
+  return Array.from({ length }, () => new Set([
+    'yarp',
+    '123',
+    1,
+    2,
+    3,
+    null,
+  ]));
+}
+
+function createComplexSets(length, depth = 0) {
+  return Array.from({ length }, () => new Set([
+    'yarp',
+    {
+      bar: '123',
+      a: [1, 2, 3],
+      c: {},
+      b: !depth ? createComplexSets(2, depth + 1) : new Set(),
+    },
+  ]));
+}
+
+function createMaps(length, depth = 0) {
+  return Array.from({ length }, () => new Map([
+    ['foo', 'yarp'],
+    ['nope', new Map([
+      ['bar', '123'],
+      ['a', [1, 2, 3]],
+      ['c', {}],
+      ['b', !depth ? createMaps(2, depth + 1) : new Map()],
+    ])],
+  ]));
+}
+
+function createArrayBuffers(length) {
+  return Array.from({ length }, (_, n) => {
+    return new ArrayBuffer(n);
+  });
+}
+
+function createDataViewArrayBuffers(length) {
+  return Array.from({ length }, (_, n) => {
+    return new DataView(new ArrayBuffer(n));
+  });
+}
+
+const datasetMappings = {
+  objects: createObjects,
+  simpleSets: createSimpleSets,
+  complexSets: createComplexSets,
+  maps: createMaps,
+  arrayBuffers: createArrayBuffers,
+  dataViewArrayBuffers: createDataViewArrayBuffers,
+};
+
+function getDatasets(datasetName, size) {
+  return {
+    actual: datasetMappings[datasetName](size),
+    expected: datasetMappings[datasetName](size),
+  };
+}
+
+function main({ size, n, datasetName }) {
+  const { actual, expected } = getDatasets(datasetName, size);
+
+  bench.start();
+  for (let i = 0; i < n; ++i) {
+    assert.partialDeepStrictEqual(actual, expected);
+  }
+  bench.end(n);
+}

lib/assert.js

@@ -23,7 +23,6 @@
 const {
   ArrayBufferIsView,
   ArrayBufferPrototypeGetByteLength,
-  ArrayFrom,
   ArrayIsArray,
   ArrayPrototypeIndexOf,
   ArrayPrototypeJoin,
@@ -395,12 +394,11 @@ function partiallyCompareMaps(actual, expected, comparedObjects) {
   const expectedIterator = FunctionPrototypeCall(SafeMap.prototype[SymbolIterator], expected);
 
   for (const { 0: key, 1: expectedValue } of expectedIterator) {
-    if (!MapPrototypeHas(actual, key)) {
+    const actualValue = MapPrototypeGet(actual, key);
+    if (actualValue === undefined && !MapPrototypeHas(actual, key)) {
       return false;
     }
 
-    const actualValue = MapPrototypeGet(actual, key);
-
     if (!compareBranch(actualValue, expectedValue, comparedObjects)) {
       return false;
     }
@@ -474,28 +472,74 @@ function partiallyCompareArrayBuffersOrViews(actual, expected) {
   return true;
 }
 
+// Adapted version of the "setEquiv" function in lib/internal/util/comparisons.js
 function partiallyCompareSets(actual, expected, comparedObjects) {
   if (SetPrototypeGetSize(expected) > SetPrototypeGetSize(actual)) {
-    return false; // `expected` can't be a subset if it has more elements
+    return false;
   }
 
   if (isDeepEqual === undefined) lazyLoadComparison();
+  let set = null;
 
-  const actualArray = ArrayFrom(FunctionPrototypeCall(SafeSet.prototype[SymbolIterator], actual));
+  // First, check if elements from expected exist in actual
   const expectedIterator = FunctionPrototypeCall(SafeSet.prototype[SymbolIterator], expected);
-  const usedIndices = new SafeSet();
+  for (const val of expectedIterator) {
+    // Fast path: direct inclusion check for both primitives and reference equality
+    if (actual.has(val)) {
+      continue;
+    }
+
+    // For primitives, if not found directly, return false immediately
+    if (isPrimitive(val)) {
+      return false;
+    }
 
-  expectedIteration: for (const expectedItem of expectedIterator) {
-    for (let actualIdx = 0; actualIdx < actualArray.length; actualIdx++) {
-      if (!usedIndices.has(actualIdx) && isDeepStrictEqual(actualArray[actualIdx], expectedItem)) {
-        usedIndices.add(actualIdx);
-        continue expectedIteration;
+    if (set === null) {
+      // Special case to avoid set creation for single-element comparison
+      if (SetPrototypeGetSize(expected) === 1) {
+        // Try to find any deep-equal object in actual
+        const actualIterator = FunctionPrototypeCall(SafeSet.prototype[SymbolIterator], actual);
+        for (const actualItem of actualIterator) {
+          if (!isPrimitive(actualItem) && isDeepStrictEqual(actualItem, val)) {
+            return true;
+          }
+        }
+        return false;
       }
+      set = new SafeSet();
     }
-    return false;
+
+    // Add this object for later deep comparison
+    set.add(val);
   }
 
-  return true;
+  // If all items were found directly, we're done
+  if (set === null) {
+    return true;
+  }
+
+  // For remaining objects that need deep comparison
+  const actualIterator = FunctionPrototypeCall(SafeSet.prototype[SymbolIterator], actual);
+  for (const actualItem of actualIterator) {
+    // Only consider non-primitive values for deep comparison
+    if (!isPrimitive(actualItem)) {
+      // Check if this actual item deep-equals any remaining expected item
+      for (const expectedItem of set) {
+        if (isDeepStrictEqual(actualItem, expectedItem)) {
+          // Remove the matched item so we don't match it again
+          set.delete(expectedItem);
+          // If all items are matched, we can return early
+          if (set.size === 0) {
+            return true;
+          }
+          break;
+        }
+      }
+    }
+  }
+
+  // If all objects in expected found matches, set will be empty
+  return set.size === 0;
 }
 
 const minusZeroSymbol = Symbol('-0');
@@ -510,21 +554,26 @@ function getZeroKey(item) {
 }
 
 function partiallyCompareArrays(actual, expected, comparedObjects) {
+  if (actual === expected) return true;
+
   if (expected.length > actual.length) {
     return false;
   }
 
+  if (expected.length === 0) {
+    return true;
+  }
+
   if (isDeepEqual === undefined) lazyLoadComparison();
 
   // Create a map to count occurrences of each element in the expected array
   const expectedCounts = new SafeMap();
-  const safeExpected = new SafeArrayIterator(expected);
 
-  for (const expectedItem of safeExpected) {
-    // Check if the item is a zero or a -0, as these need to be handled separately
+  const expectedIterator = new SafeArrayIterator(expected);
+  for (const expectedItem of expectedIterator) {
     if (expectedItem === 0) {
       const zeroKey = getZeroKey(expectedItem);
-      expectedCounts.set(zeroKey, (expectedCounts.get(zeroKey)?.count || 0) + 1);
+      expectedCounts.set(zeroKey, (expectedCounts.get(zeroKey) ?? 0) + 1);
     } else {
       let found = false;
       for (const { 0: key, 1: count } of expectedCounts) {
@@ -540,10 +589,8 @@ function partiallyCompareArrays(actual, expected, comparedObjects) {
     }
   }
 
-  const safeActual = new SafeArrayIterator(actual);
-
-  for (const actualItem of safeActual) {
-    // Check if the item is a zero or a -0, as these need to be handled separately
+  const actualIterator = new SafeArrayIterator(actual);
+  for (const actualItem of actualIterator) {
     if (actualItem === 0) {
       const zeroKey = getZeroKey(actualItem);
 
@@ -567,6 +614,10 @@ function partiallyCompareArrays(actual, expected, comparedObjects) {
         }
       }
     }
+
+    if (expectedCounts.size === 0) {
+      return true;
+    }
   }
 
   return expectedCounts.size === 0;
@@ -723,6 +774,10 @@ function compareExceptionKey(actual, expected, key, message, keys, fn) {
   }
 }
 
+function isPrimitive(value) {
+  return typeof value !== 'object' || value === null;
+}
+
 function expectedException(actual, expected, message, fn) {
   let generatedMessage = false;
   let throwError = false;
@@ -741,7 +796,7 @@ function expectedException(actual, expected, message, fn) {
       }
       throwError = true;
       // Handle primitives properly.
-    } else if (typeof actual !== 'object' || actual === null) {
+    } else if (isPrimitive(actual)) {
       const err = new AssertionError({
         actual,
         expected,