bun:test: compare an expected Map and Set in toMatchObject and Bun.deepMatch

packages/bun-types/bun.d.ts

@@ -2937,6 +2937,11 @@ declare module "bun" {
    * Returns true if all properties in the subset exist in the
    * other and have equal values.
    *
+   * A `Date` in the subset matches a `Date` with the same time value.
+   * An `Error` in the subset matches an `Error` with the same message.
+   * A `Set` or a `Map` in the subset matches one of the same size whose
+   * members match.
+   *
    * This also powers expect().toMatchObject in `bun:test`
    */
   function deepMatch(subset: unknown, a: unknown): boolean;

src/jsc/bindings/headers-handwritten.h

@@ -470,6 +470,52 @@ struct DeepMatchState {
         recorded.append(patternOfValue);
         recordedNames.append(name);
     }
+
+    // False if this (value, pattern) pair already matched or is still being compared (a cycle). Both are in `gcBuffer` already.
+    bool markSeen(JSC::JSValue value, JSC::JSValue pattern)
+    {
+        std::pair<JSC::EncodedJSValue, JSC::EncodedJSValue> pair { JSC::JSValue::encode(value), JSC::JSValue::encode(pattern) };
+        if (!seen.insert(pair).second)
+            return false;
+        if (openTrials) [[unlikely]]
+            seenInTrials.append(pair);
+        return true;
+    }
+
+    // One try of a Set member or a Map entry against a candidate. A try that fails takes back what it put in `seen`, `gcBuffer` and the records.
+    unsigned openTrials { 0 };
+    WTF::Vector<std::pair<JSC::EncodedJSValue, JSC::EncodedJSValue>> seenInTrials;
+
+    struct Trial {
+        DeepMatchState& state;
+        size_t seenBegin;
+        size_t gcBegin;
+        size_t recordsBegin;
+        bool matched { false };
+
+        Trial(DeepMatchState& state)
+            : state(state)
+            , seenBegin(state.seenInTrials.size())
+            , gcBegin(state.gcBuffer.size())
+            , recordsBegin(state.recordedNames.size())
+        {
+            state.openTrials++;
+        }
+
+        ~Trial()
+        {
+            if (!matched) {
+                for (size_t i = state.seenInTrials.size(); i-- > seenBegin;)
+                    state.seen.erase(state.seenInTrials[i]);
+                state.seenInTrials.shrink(seenBegin);
+                state.gcBuffer.shrink(gcBegin);
+                state.recorded.shrink(recordsBegin * 4);
+                state.recordedNames.shrink(recordsBegin);
+            }
+            if (!--state.openTrials)
+                state.seenInTrials.shrink(0);
+        }
+    };
 };
 }
 

test/js/bun/bun-object/deep-match.spec.ts

@@ -77,6 +77,23 @@ describe("Bun.deepMatch", () => {
       new Set(["a", "b", "c"]),
       new Set(["a", "b", "c"]),
     ],
+    // a member or a value of `b` may be a superset of the one in `a`
+    [{ m: new Map([ ["foo", { a: 1 }] ]) }, { m: new Map([ ["foo", { a: 1, b: 2 }] ]) }],
+    [{ s: new Set([{ a: 1 }]) }, { s: new Set([{ a: 1, b: 2 }]) }],
+    [{ m: new Map([ ["foo", 1], ["bar", 2] ]) }, { m: new Map([ ["bar", 2], ["foo", 1] ]) }],
+
+    // Dates and Errors
+    [new Date(1), new Date(1)],
+    [{ d: new Date(1) }, { d: new Date(1), other: 1 }],
+    [{ d: [new Date(1)] }, { d: [new Date(1)] }],
+    [new Error("a"), new Error("a")],
+    [{ e: new Error("a") }, { e: new Error("a", { cause: 1 }) }],
+    [{ e: new Error("a") }, { e: Object.assign(new Error("a"), { code: 1 }) }],
+    // a plain object in the subset matches the properties of any object
+    [{ message: "a" }, new Error("a")],
+    [{ d: {} }, { d: new Date() }],
+    [{ m: {} }, { m: new Map([ ["foo", 1] ]) }],
+    [{ s: { size: 1 } }, { s: new Set([1]) }],
   ])("Bun.deepMatch(%p, %p) === true", (a, b) => {
     expect(Bun.deepMatch(a, b)).toBe(true);
   });
@@ -100,39 +117,56 @@ describe("Bun.deepMatch", () => {
     [[], [undefined]],
     [["a", "b", "c"], ["a", "b", "d"]],
 
-    // Maps
-    // FIXME: I assume this is incorrect but I need confirmation on expected behavior.
-    // [
-    //   new Map<number, number>([ [1, 2], [2, 3], [3, 4] ]),
-    //   new Map<number, number>([ [1, 2], [2, 3] ]),
-    // ],
-    // [
-    //   new Map<number, number>([ [1, 2], [2, 3], [3, 4] ]),
-    //   new Map<number, number>([ [1, 2], [2, 3], [3, 4], [4, 5] ]),
-    // ],
-    // [
-    //   new Map<number, number>([ [1, 2], [2, 3], [3, 4], [4, 5] ]),
-    //   new Map<number, number>([ [1, 2], [2, 3], [3, 4] ]),
-    // ],
+    // Maps: the same size, and each entry of `b` matches an entry of `a`
+    [
+      new Map<number, number>([ [1, 2], [2, 3], [3, 4] ]),
+      new Map<number, number>([ [1, 2], [2, 3] ]),
+    ],
+    [
+      new Map<number, number>([ [1, 2], [2, 3], [3, 4] ]),
+      new Map<number, number>([ [1, 2], [2, 3], [3, 4], [4, 5] ]),
+    ],
+    [
+      new Map<number, number>([ [1, 2], [2, 3], [3, 4], [4, 5] ]),
+      new Map<number, number>([ [1, 2], [2, 3], [3, 4] ]),
+    ],
+    [new Map([ ["foo", 1] ]), new Map([ ["foo", 2] ])],
+    [new Map([ ["foo", 1] ]), new Map([ ["bar", 1] ])],
+    [{ m: new Map([ ["foo", { a: 1, b: 2 }] ]) }, { m: new Map([ ["foo", { a: 1 }] ]) }],
+    [{ m: new Map() }, { m: {} }],
+    [{ m: new Map() }, { m: new Set() }],
 
-    // Sets
-    // FIXME: I assume this is incorrect but I need confirmation on expected behavior.
-    // [
-    //   new Set([1, 2, 3]),
-    //   new Set([4, 5, 6]),
-    // ],
-    // [
-    //   new Set([1, 2, 3]),
-    //   new Set([1, 2]),
-    // ],
-    // [
-    //   new Set([1, 2]),
-    //   new Set([1, 2, 3]),
-    // ],
-    // [
-    //   new Set(["a", "b", "c"]),
-    //   new Set(["a", "b", "d"]),
-    // ],
+    // Sets: the same size, and each member of `b` matches a member of `a`
+    [
+      new Set([1, 2, 3]),
+      new Set([4, 5, 6]),
+    ],
+    [
+      new Set([1, 2, 3]),
+      new Set([1, 2]),
+    ],
+    [
+      new Set([1, 2]),
+      new Set([1, 2, 3]),
+    ],
+    [
+      new Set(["a", "b", "c"]),
+      new Set(["a", "b", "d"]),
+    ],
+    [{ s: new Set([{ a: 1, b: 2 }]) }, { s: new Set([{ a: 1 }]) }],
+    [{ s: new Set() }, { s: {} }],
+    [{ s: new Set([1]) }, { s: [1] }],
+
+    // A Date is compared by its time value, an Error by its message
+    [new Date(1), new Date(2)],
+    [{ d: new Date(1) }, { d: new Date(2) }],
+    [{ d: new Date() }, { d: {} }],
+    [{ d: new Date(1) }, { d: [new Date(1)] }],
+    [new Error("a"), new Error("b")],
+    [{ e: new Error("a") }, { e: new Error("b") }],
+    [{ e: new Error("a") }, { e: { message: "a" } }],
+    [{ e: new Error("a") }, { e: {} }],
+    [{ e: Object.assign(new Error("a"), { code: 1 }) }, { e: new Error("a") }],
   ])("Bun.deepMatch(%p, %p) === false", (a, b) => {
     expect(Bun.deepMatch(a, b)).toBe(false);
   });