assert: make partialDeepStrictEqual throw when comparing [0] with [-0]

Fixes: nodejs#56230
puskin94 · Dec 12, 2024 · 0ce4a4a · 0ce4a4a
1 parent a1d980c
commit 0ce4a4a
Show file tree

Hide file tree

Showing 2 changed files with 60 additions and 14 deletions.
diff --git a/lib/assert.js b/lib/assert.js
@@ -507,31 +507,52 @@ function partiallyCompareArrays(actual, expected, comparedObjects) {
   // Create a map to count occurrences of each element in the expected array
   const expectedCounts = new SafeMap();
   for (const expectedItem of expected) {
-    let found = false;
-    for (const { 0: key, 1: count } of expectedCounts) {
-      if (isDeepStrictEqual(key, expectedItem)) {
-        expectedCounts.set(key, count + 1);
-        found = true;
-        break;
+    const expectedIsMinusZero = ObjectIs(expectedItem, -0);
+    if (ObjectIs(expectedItem, 0) || expectedIsMinusZero) {
+      // Handle 0 and -0 separately to avoid map key collisions
+      const zeroKey = expectedIsMinusZero ? '-0' : '0';
+      expectedCounts.set(zeroKey, (expectedCounts.get(zeroKey) || 0) + 1);
+    } else {
+      let found = false;
+      for (const { 0: key, 1: count } of expectedCounts) {
+        if (isDeepStrictEqual(key, expectedItem)) {
+          expectedCounts.set(key, count + 1);
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        expectedCounts.set(expectedItem, 1);
       }
-    }
-    if (!found) {
-      expectedCounts.set(expectedItem, 1);
     }
   }
 
   const safeActual = new SafeArrayIterator(actual);
 
   // Create a map to count occurrences of relevant elements in the actual array
   for (const actualItem of safeActual) {
-    for (const { 0: key, 1: count } of expectedCounts) {
-      if (isDeepStrictEqual(key, actualItem)) {
+    const actualIsMinusZero = ObjectIs(actualItem, -0);
+    const zeroKey = actualIsMinusZero ? '-0' : '0';
+
+    if (ObjectIs(actualItem, 0) || actualIsMinusZero) {
+      if (expectedCounts.has(zeroKey)) {
+        const count = expectedCounts.get(zeroKey);
         if (count === 1) {
-          expectedCounts.delete(key);
+          expectedCounts.delete(zeroKey);
         } else {
-          expectedCounts.set(key, count - 1);
+          expectedCounts.set(zeroKey, count - 1);
+        }
+      }
+    } else {
+      for (const { 0: expectedItem, 1: count } of expectedCounts) {
+        if (isDeepStrictEqual(expectedItem, actualItem)) {
+          if (count === 1) {
+            expectedCounts.delete(expectedItem);
+          } else {
+            expectedCounts.set(expectedItem, count - 1);
+          }
+          break;
         }
-        break;
       }
     }
   }

diff --git a/test/parallel/test-assert-objects.js b/test/parallel/test-assert-objects.js
@@ -97,6 +97,21 @@ describe('Object Comparison Tests', () => {
           actual: [1, 'two', true],
           expected: [1, 'two', false],
         },
+        {
+          description: 'throws when comparing [0] with [-0]',
+          actual: [0],
+          expected: [-0],
+        },
+        {
+          description: 'throws when comparing [0, 0, 0] with [0, -0]',
+          actual: [0, 0, 0],
+          expected: [0, -0],
+        },
+        {
+          description: 'throws when comparing [-0] with [0]',
+          actual: [0],
+          expected: [-0],
+        },
         {
           description:
             'throws when comparing two Date objects with different times',
@@ -385,6 +400,16 @@ describe('Object Comparison Tests', () => {
         actual: [1, 'two', true],
         expected: [1, 'two', true],
       },
+      {
+        description: 'compares [0] with [0]',
+        actual: [0],
+        expected: [0],
+      },
+      {
+        description: 'compares [-0] with [-0]',
+        actual: [-0],
+        expected: [-0],
+      },
       {
         description: 'compares two Date objects with the same time',
         actual: new Date(0),