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;
     }
@@ -475,24 +473,59 @@ function partiallyCompareArrayBuffersOrViews(actual, expected) {
 }
 
 function partiallyCompareSets(actual, expected, comparedObjects) {
-  if (SetPrototypeGetSize(expected) > SetPrototypeGetSize(actual)) {
-    return false; // `expected` can't be a subset if it has more elements
+  if (actual === expected) return true;
+
+  const expectedSize = SetPrototypeGetSize(expected);
+  if (expectedSize === 0) return true;
+
+  const actualSize = SetPrototypeGetSize(actual);
+  if (expectedSize > actualSize) {
+    return false;
   }
 
   if (isDeepEqual === undefined) lazyLoadComparison();
 
-  const actualArray = ArrayFrom(FunctionPrototypeCall(SafeSet.prototype[SymbolIterator], actual));
+  // Separate expected items into direct matches and those needing deep comparison
+  const expectedItemsToCompare = []; // Items that need deep comparison
   const expectedIterator = FunctionPrototypeCall(SafeSet.prototype[SymbolIterator], expected);
-  const usedIndices = new SafeSet();
 
-  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;
+  for (const expectedItem of expectedIterator) {
+    if (actual.has(expectedItem)) {
+      continue;
+    } else if (isPrimitive(expectedItem)) {
+      return false;
+    } else {
+      expectedItemsToCompare.push(expectedItem);
+    }
+  }
+
+  if (expectedItemsToCompare.length === 0) {
+    return true;
+  }
+
+  // Only collect non-primitive items from actual for deep comparison
+  const actualSet = new SafeSet();
+  for (const item of FunctionPrototypeCall(SafeSet.prototype[SymbolIterator], actual)) {
+    if (!isPrimitive(item)) {
+      actualSet.add(item);
+    }
+  }
+
+  // Now do deep comparison for the remaining expected items
+  for (const expectedItem of expectedItemsToCompare) {
+    let foundMatch = false;
+
+    for (const actualItem of actualSet) {
+      if (isDeepStrictEqual(actualItem, expectedItem)) {
+        actualSet.delete(actualItem);
+        foundMatch = true;
+        break;
       }
     }
-    return false;
+
+    if (!foundMatch) {
+      return false;
+    }
   }
 
   return true;
@@ -510,21 +543,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 +578,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 +603,10 @@ function partiallyCompareArrays(actual, expected, comparedObjects) {
         }
       }
     }
+
+    if (expectedCounts.size === 0) {
+      return true;
+    }
   }
 
   return expectedCounts.size === 0;
@@ -723,6 +763,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 +785,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,