Reorganize tests (#2332)

1 files changed, 0 insertions, 2099 deletions

diff --git a/test/bun.js/test-test.test.ts b/test/bun.js/test-test.test.ts
deleted file mode 100644
index c83ee07a5..000000000
--- a/test/bun.js/test-test.test.ts
+++ /dev/null
@@ -1,2099 +0,0 @@
-import { spawn, spawnSync } from "bun";
-import { describe, expect, it, test } from "bun:test";
-import { bunEnv } from "bunEnv";
-import { bunExe } from "bunExe";
-import { mkdirSync, realpathSync, rmSync, writeFileSync } from "fs";
-import { mkdtemp, rm, writeFile } from "fs/promises";
-import { tmpdir } from "os";
-import { join } from "path";
-
-test("toStrictEqual() vs toEqual()", () => {
-  expect([1, , 3]).toEqual([1, , 3]);
-  expect({}).toEqual({});
-  expect({}).toStrictEqual({});
-  expect({}).toEqual({ a: undefined });
-  expect({}).not.toStrictEqual({ a: undefined });
-
-  class C {
-    hi = 34;
-  }
-  class D {
-    hi = 34;
-  }
-  let c = new C();
-  let d = new D();
-
-  expect(d).toEqual(c);
-  expect(d).not.toStrictEqual(c);
-  expect({ a: 1, b: undefined }).toEqual({ a: 1 });
-  expect({ a: 1 }).toEqual({ a: 1, b: undefined });
-  expect({ a: 1, b: undefined }).toEqual({ a: 1, b: undefined });
-
-  expect({ a: 1, b: undefined }).not.toStrictEqual({ a: 1 });
-  expect({ a: 1 }).not.toStrictEqual({ a: 1, b: undefined });
-  expect({ a: 1, b: undefined }).toStrictEqual({ a: 1, b: undefined });
-
-  expect({ a: 1, b: null }).not.toEqual({ a: 1 });
-  expect({ a: 1 }).not.toEqual({ a: 1, b: null });
-  expect({ a: 1, b: null }).toEqual({ a: 1, b: null });
-
-  expect({ a: 1 }).not.toEqual({ a: true });
-  expect({ a: 1 }).not.toEqual({ a: "1" });
-  expect({ a: 1 }).not.toEqual({ a: 1, b: 2 });
-  expect({ a: 1, b: 2 }).not.toEqual({ a: 1 });
-  expect({ a: 1 }).not.toStrictEqual({ a: true });
-  expect({ a: 1 }).not.toStrictEqual({ a: "1" });
-  expect({ a: 1 }).not.toStrictEqual({ a: 1, b: 2 });
-  expect({ a: 1, b: 2 }).not.toStrictEqual({ a: 1 });
-  expect({ a: 1 }).toStrictEqual({ a: 1 });
-
-  expect([1, undefined, 3]).toEqual([1, undefined, 3]);
-  expect([1, undefined, 3]).toStrictEqual([1, undefined, 3]);
-  expect([1, undefined, 3]).not.toEqual([1, 2, 3]);
-  expect([1, undefined, 3]).not.toStrictEqual([1, 2, 3]);
-  expect([1, undefined, 3]).not.toEqual([1, 2]);
-  expect([1, undefined, 3]).not.toStrictEqual([1, 2]);
-  expect([1, undefined, 3]).not.toEqual([1]);
-  expect([1, undefined, 3]).not.toStrictEqual([1]);
-  expect([1, undefined, 3]).not.toEqual([]);
-  expect([1, undefined, 3]).not.toStrictEqual([]);
-  expect([1, undefined, 3]).not.toEqual([1, 3]);
-  expect([1, undefined, 3]).not.toStrictEqual([1, 3]);
-
-  expect([1, null, 3]).toEqual([1, null, 3]);
-  expect([1, null, 3]).toStrictEqual([1, null, 3]);
-  expect([1, null, 3]).not.toEqual([1, 2, 3]);
-  expect([1, null, 3]).not.toStrictEqual([1, 2, 3]);
-  expect([1, null, 3]).not.toEqual([1, 2]);
-  expect([1, null, 3]).not.toStrictEqual([1, 2]);
-  expect([1, null, 3]).not.toEqual([1]);
-  expect([1, null, 3]).not.toStrictEqual([1]);
-  expect([1, null, 3]).not.toEqual([]);
-  expect([1, null, 3]).not.toStrictEqual([]);
-  expect([1, null, 3]).not.toEqual([1, 3]);
-  expect([1, null, 3]).not.toStrictEqual([1, 3]);
-
-  expect([, 1]).toEqual([, 1]);
-  expect([, 1]).toStrictEqual([, 1]);
-  expect([, 1]).not.toEqual([1]);
-  expect([1]).not.toEqual([, 1]);
-  expect([, 1]).not.toStrictEqual([1]);
-  expect([1]).not.toStrictEqual([, 1]);
-  expect([, 1]).toEqual([undefined, 1]);
-  expect([, 1]).not.toStrictEqual([undefined, 1]);
-  expect([, 1]).not.toEqual([null, 1]);
-  expect([, 1]).not.toStrictEqual([null, 1]);
-  expect([undefined, 1]).toEqual([, 1]);
-  expect([undefined, 1]).not.toStrictEqual([, 1]);
-  expect([null, 1]).not.toEqual([, 1]);
-  expect([null, 1]).not.toStrictEqual([, 1]);
-  expect([undefined, 1]).toEqual([undefined, 1]);
-  expect([undefined, 1]).toStrictEqual([undefined, 1]);
-
-  expect([0, , 2]).toEqual([0, undefined, 2]);
-  expect([, "boo2"]).toEqual([undefined, "boo2"]);
-  expect([, "boo"]).toEqual([, "boo"]);
-  expect([, 1]).toEqual([undefined, 1]);
-
-  const s1 = Symbol("test1");
-  const s2 = Symbol("test2");
-
-  let a = { a: 1, b: 2 };
-  let b = { a: 1, b: 2 };
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = undefined;
-  b[s2] = null;
-  expect(a).not.toEqual(b);
-  class F extends String {
-    constructor() {
-      super();
-    }
-  }
-
-  let f = new F("hello");
-  let j = new String("hello");
-  expect(f).not.toEqual(j);
-  class LaCroix {
-    constructor(flavor) {
-      this.flavor = flavor;
-    }
-  }
-  expect(new LaCroix("pamplemousse")).not.toStrictEqual({
-    flavor: "pamplemousse",
-  });
-  expect(new LaCroix("pamplemousse")).toEqual({ flavor: "pamplemousse" });
-
-  expect([, 1]).not.toStrictEqual([undefined, 1]);
-
-  expect([0, , 2]).toEqual([0, undefined, 2]);
-  expect([, "boo2"]).toEqual([undefined, "boo2"]);
-  expect([, "boo"]).toEqual([, "boo"]);
-  expect([, 1]).toEqual([undefined, 1]);
-});
-
-function f1() {
-  return "hello!";
-}
-function f2() {
-  return "hey!";
-}
-test("deepEquals regex", () => {
-  expect(/a/imu).toEqual(/a/imu);
-  expect(/a/imu).not.toEqual(/ab/imu);
-
-  expect(new RegExp("s", "g")).toEqual(new RegExp("s", "g"));
-  expect(new RegExp("s", "g")).not.toEqual(new RegExp("s", "i"));
-});
-
-test("toThrow", () => {
-  expect(() => {
-    throw new Error("hello");
-  }).toThrow("hello");
-
-  var err = new Error("bad");
-  expect(() => {
-    throw err;
-  }).toThrow(err);
-
-  expect(() => {
-    throw new Error("good");
-  }).toThrow();
-
-  expect(() => {
-    throw new Error("foo");
-  }).toThrow(/oo/);
-
-  expect(() =>
-    expect(() => {
-      throw new Error("bar");
-    }).toThrow(/baz/),
-  ).toThrow("/baz/");
-
-  expect(() => {
-    return true;
-  }).not.toThrow();
-
-  expect(() => {
-    return true;
-  }).not.toThrow(err);
-});
-
-test("deepEquals derived strings and strings", () => {
-  let a = new String("hello");
-  let b = "hello";
-  expect(a).toEqual(a);
-  expect(b).toEqual(b);
-  expect(a).not.toEqual(b);
-  expect(b).not.toEqual(a);
-
-  class F extends String {
-    constructor() {
-      super();
-    }
-  }
-
-  let f = new F("hello");
-  expect(f).toEqual(f);
-  expect(f).not.toEqual(b);
-  expect(b).not.toEqual(f);
-
-  let j = new String("hello");
-  expect(f).not.toEqual(j);
-
-  class G extends String {
-    constructor() {
-      super();
-      this.x = 0;
-    }
-  }
-
-  let g = new G("hello");
-  expect(g).not.toEqual(f);
-  expect(f).not.toEqual(g);
-  expect(g).toEqual(g);
-  expect(g).not.toEqual(b);
-  expect(b).not.toEqual(g);
-  expect(g).not.toEqual(a);
-});
-
-test("deepEquals throw getters", () => {
-  let a = {
-    get x() {
-      throw new Error("a");
-    },
-  };
-
-  let b = {
-    get x() {
-      return 3;
-    },
-  };
-
-  try {
-    expect(a).not.toEqual(b);
-  } catch (e) {
-    expect(e.message).toContain("a");
-  }
-
-  class B {
-    get x() {
-      throw new Error("b");
-    }
-  }
-
-  class C {
-    get x() {
-      return 3;
-    }
-  }
-
-  expect(() => {
-    expect(new B()).not.toEqual(new C());
-  }).toThrow();
-
-  let o = [
-    {
-      get x() {
-        throw new Error("c");
-      },
-    },
-  ];
-
-  let p = [
-    {
-      get x() {
-        return 3;
-      },
-    },
-  ];
-
-  try {
-    expect(o).not.toEqual(p);
-  } catch (e) {
-    expect(e.message).toContain("c");
-  }
-
-  const s = Symbol("s");
-  let q = {
-    get x() {
-      throw new Error("d");
-    },
-  };
-  q[s] = 3;
-
-  let r = {
-    get x() {
-      return 3;
-    },
-  };
-  r[s] = 3;
-
-  try {
-    expect(q).not.toEqual(r);
-  } catch (e) {
-    expect(e.message).toContain("d");
-  }
-});
-
-test("deepEquals large object", () => {
-  let o = {};
-  for (let i = 0; i < 65; i++) {
-    o["bun" + i] = i;
-  }
-  expect(o).toEqual(o);
-  let b = {};
-  for (let i = 0; i < 63; i++) {
-    b["bun" + i] = i;
-  }
-  expect(b).toEqual(b);
-  expect(o).not.toEqual(b);
-  expect(b).not.toEqual(o);
-
-  let c = { d: [Array(o)] };
-  let d = { d: [Array(b)] };
-  expect(c).toEqual(c);
-  expect(d).toEqual(d);
-  expect(c).not.toEqual(d);
-  expect(d).not.toEqual(c);
-
-  let e = { d: [Array(o), Array(o)] };
-  let f = { d: [Array(b), Array(b)] };
-  expect(e).toEqual(e);
-  expect(f).toEqual(f);
-  expect(e).not.toEqual(f);
-  expect(f).not.toEqual(e);
-
-  let p = [];
-  p[0] = {};
-  for (let i = 0; i < 1000; i++) {
-    p[0]["bun" + i] = i;
-  }
-  let q = [];
-  q[0] = {};
-  for (let i = 0; i < 1000; i++) {
-    q[0]["bun" + i] = i;
-  }
-  expect(p).toEqual(p);
-  expect(q).toEqual(q);
-
-  q[0].bun789 = 788;
-  expect(p).not.toEqual(q);
-  expect(q).not.toEqual(p);
-
-  let r = { d: {} };
-  let s = { d: {} };
-  for (let i = 0; i < 1000; i++) {
-    r.d["bun" + i] = i;
-    s.d["bun" + i] = i;
-  }
-
-  expect(r).toEqual(r);
-  expect(s).toEqual(s);
-
-  r.d.bun790 = 791;
-  expect(r).not.toEqual(s);
-  expect(s).not.toEqual(r);
-
-  let t = [];
-  t[5] = {};
-  let u = [];
-  u[5] = {};
-  for (let i = 0; i < 1000; i++) {
-    t[5]["bun" + i] = i;
-  }
-  for (let i = 0; i < 30; i++) {
-    u[5]["bun" + i] = i;
-  }
-  expect(t).toEqual(t);
-  expect(u).toEqual(u);
-  expect(t).not.toEqual(u);
-  expect(u).not.toEqual(t);
-
-  let v = { j: {} };
-  let w = { j: {} };
-  for (let i = 0; i < 1000; i++) {
-    v.j["bun" + i] = i;
-    w.j["bun" + i] = i;
-  }
-
-  expect(v).toEqual(v);
-  expect(w).toEqual(w);
-
-  v.j.bun999 = 1000;
-  expect(v).not.toEqual(w);
-  expect(w).not.toEqual(v);
-  expect(v).toEqual(v);
-
-  v.j.bun999 = 999;
-  w.j.bun0 = 1;
-  expect(v).not.toEqual(w);
-  expect(w).not.toEqual(v);
-  expect(v).toEqual(v);
-  expect(w).toEqual(w);
-});
-
-test("deepEquals - Date", () => {
-  let d = new Date();
-  expect(d).toEqual(d);
-  let b = d;
-  expect(b).toEqual(d);
-  d.setFullYear(1998);
-  expect(b).toEqual(d);
-  expect(b).not.toEqual(new Date());
-
-  var date = new Date();
-  date.setFullYear(1995);
-  expect(new Date()).not.toEqual(date);
-});
-
-test("deepEquals toString and functions", () => {
-  expect({ toString: f1 }).toEqual({
-    toString: f1,
-  });
-  expect({ toString: f1 }).not.toEqual({
-    toString: f2,
-  });
-
-  expect(f1).toEqual(f1);
-  expect(f1).not.toEqual(f2);
-});
-
-test("deepEquals set and map", () => {
-  let e = new Map();
-  e.set("a", 1);
-  e.set("b", 2);
-  e.set("c", 3);
-  e.set(8, 6);
-
-  let d = new Map();
-  d.set("a", 1);
-  d.set("b", 2);
-  d.set("c", 3);
-  d.set(8, 6);
-
-  expect(e).toEqual(d);
-  expect(d).toEqual(e);
-
-  let f = new Map();
-  f.set("a", 1);
-  f.set("b", 2);
-  f.set("c", 3);
-  f.set(8, 7);
-  expect(e).not.toEqual(f);
-
-  let g = new Map();
-  g.set({ a: { b: { c: 89 } } }, 1);
-
-  let h = new Map();
-  h.set({ a: { b: { c: 89 } } }, 1);
-  expect(g).toEqual(h);
-
-  let i = new Map();
-  i.set({ a: { b: { c: 89 } } }, 1);
-  i.set({ a: { b: { c: 89 } } }, 1);
-  expect(g).not.toEqual(i);
-
-  let j = new Map();
-  j.set({ a: { b: { c: 89 } } }, 1);
-  j.set({ a: { b: { c: 89 } } }, 1);
-  expect(i).toEqual(j);
-
-  let p = new Map();
-  p.set({ a: { b: { c: 90 } } }, 1);
-  expect(p).not.toEqual(g);
-
-  let q = new Map();
-  q.set({ a: { b: { c: 90 } } }, { a: { b: 45 } });
-
-  let r = new Map();
-  r.set({ a: { b: { c: 90 } } }, { a: { b: 45 } });
-  expect(q).toEqual(r);
-
-  let s = new Map();
-  s.set({ a: { b: { c: 90 } } }, { a: { b: 49 } });
-  expect(q).not.toEqual(s);
-
-  const u = { a: 1, b: 2 };
-
-  let a = new Set();
-  a.add({ a: 1 });
-  a.add([1, 2, 3]);
-  a.add("hello");
-  a.add(89);
-
-  let b = new Set();
-  b.add({ a: 1 });
-  b.add("hello");
-  b.add([1, 2, 3]);
-  b.add(89);
-  expect(a).toEqual(b);
-  expect(b).toEqual(a);
-  let c = new Set();
-  c.add(89);
-  c.add("hello");
-  c.add({ a: 1 });
-  c.add([1, 2, 3, 4]);
-  expect(a).not.toEqual(c);
-});
-
-test("deepEquals - symbols", () => {
-  const x = [5, 6];
-  x[99] = 7;
-
-  const y = [5, 6];
-  y[99] = 7;
-
-  expect(x).toEqual(y);
-
-  const s1 = Symbol("test1");
-  const s2 = Symbol("test2");
-
-  const o = { a: 1 };
-  o[s1] = 45;
-  o[99] = 99;
-  o[s2] = 3;
-
-  const k = { a: 1 };
-  k[99] = 99;
-  k[s2] = 3;
-  k[s1] = 45;
-
-  expect(o).toEqual(k);
-});
-
-test("toEqual objects and arrays", () => {
-  expect("hello").toEqual("hello");
-  const s1 = Symbol("test1");
-  const s2 = Symbol("test2");
-
-  expect({ a: 1, b: 2 }).toEqual({ b: 2, a: 1 });
-  expect([1, 2, 3]).toEqual([1, 2, 3]);
-  expect({ a: 1, b: 2 }).not.toEqual({ b: 2, a: 1, c: 3 });
-  expect([1, 2, 3]).not.toEqual([1, 2, 3, 4]);
-  expect({ a: 1, b: 2, c: 3 }).not.toEqual({ a: 1, b: 2 });
-  expect([1, 2, 3, 4]).not.toEqual([1, 2, 3]);
-
-  let a = [{ a: 1 }, { b: 2, c: 3, d: 4 }, { e: 5, f: 6 }];
-  let b = [{ a: 1 }, { b: 2, c: 3, d: 4 }, { e: 5, f: 6 }];
-  expect(a).toEqual(b);
-  expect(b).toEqual(a);
-  a[0].a = 2;
-  expect(a).not.toEqual(b);
-  expect(b).not.toEqual(a);
-
-  let c = { [Symbol("test")]: 1 };
-  let d = { [Symbol("test")]: 1 };
-  expect(c).not.toEqual(d);
-  expect(d).not.toEqual(c);
-
-  a = { [s1]: 1 };
-  a[s1] = 1;
-  b = { [s2]: 1 };
-  b[s2] = 1;
-  expect(a).not.toEqual(b);
-  expect(b).not.toEqual(a);
-
-  a = {};
-  b = {};
-  a[s1] = 1;
-  b[s1] = 1;
-  expect(a).toEqual(b);
-
-  a = {};
-  b = {};
-  a[s1] = 1;
-  b[s1] = 2;
-  expect(a).not.toEqual(b);
-
-  a = {};
-  b = {};
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = 2;
-  b[s2] = 2;
-  expect(a).toEqual(b);
-
-  a = {};
-  b = {};
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = 2;
-  b[s2] = 3;
-  expect(a).not.toEqual(b);
-
-  a = { a: 1, b: 2 };
-  b = { a: 1, b: 2 };
-  a[s1] = 1;
-  b[s1] = 1;
-  expect(a).toEqual(b);
-
-  a = { a: 2, b: 2 };
-  b = { a: 1, b: 2 };
-  a[s1] = 1;
-  b[s1] = 1;
-  expect(a).not.toEqual(b);
-
-  // do the same tests for arrays
-  a = [{ a: 1 }, { b: 2, c: 3, d: 4 }, { e: 5, f: 6 }];
-  b = [{ a: 1 }, { b: 2, c: 3, d: 4 }, { e: 5, f: 6 }];
-  expect(a).toEqual(b);
-  expect(b).toEqual(a);
-  a[0].a = 2;
-  expect(a).not.toEqual(b);
-  expect(b).not.toEqual(a);
-
-  a = [1, 2, 3];
-  b = [1, 2, 3];
-  a[s1] = 1;
-  b[s1] = 1;
-  expect(a).toEqual(b);
-
-  a = [1, 2, 3];
-  b = [1, 2, 3];
-  a[s1] = 1;
-  b[s1] = 2;
-  expect(a).not.toEqual(b);
-
-  a = [1, 2, 3];
-  b = [1, 2, 3];
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = 2;
-  b[s2] = 2;
-  expect(a).toEqual(b);
-
-  a = [1, 2, 3];
-  b = [1, 2, 3];
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = 2;
-  b[s2] = 3;
-  expect(a).not.toEqual(b);
-
-  a = [1, 2, 3];
-  b = [1, 2, 3];
-  a[s1] = 1;
-  b[s1] = 1;
-  expect(a).toEqual(b);
-
-  a = [2, 2, 3];
-  b = [1, 2, 3];
-  a[s1] = 1;
-  b[s1] = 1;
-  expect(a).not.toEqual(b);
-
-  // do the same tests for objects and arrays with null and undefined
-  a = { a: 1, b: 2 };
-  b = { a: 1, b: 2 };
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = null;
-  b[s2] = undefined;
-  expect(a).not.toEqual(b);
-
-  a = { a: 1, b: 2 };
-  b = { a: 1, b: 2 };
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = undefined;
-  b[s2] = null;
-  expect(a).not.toEqual(b);
-
-  a = { a: 1, b: 2 };
-  b = { a: 1, b: 2 };
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = null;
-  b[s2] = null;
-  expect(a).toEqual(b);
-
-  a = { a: 1, b: 2 };
-  b = { a: 1, b: 2 };
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = undefined;
-  b[s2] = undefined;
-  expect(a).toEqual(b);
-
-  a = [1, 2, 3];
-  b = [1, 2, 3];
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = null;
-  b[s2] = undefined;
-  expect(a).not.toEqual(b);
-
-  a = [1, 2, 3];
-  b = [1, 2, 3];
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = undefined;
-  b[s2] = null;
-  expect(a).not.toEqual(b);
-
-  a = [1, 2, 3];
-  b = [1, 2, 3];
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = null;
-  b[s2] = null;
-  expect(a).toEqual(b);
-
-  a = [1, 2, 3];
-  b = [1, 2, 3];
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = undefined;
-  b[s2] = undefined;
-  expect(a).toEqual(b);
-
-  // similar tests for indexed objects
-  a = { 0: 1, 1: 2, 2: 3 };
-  b = { 0: 1, 1: 2, 2: 3 };
-  a[s1] = 1;
-  b[s1] = 1;
-  expect(a).toEqual(b);
-
-  a = { 0: 1, 1: 2, 2: 3 };
-  b = { 0: 1, 1: 2, 2: 3 };
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = 2;
-  b[s2] = 3;
-  expect(a).not.toEqual(b);
-
-  a = { 0: 1, 1: 3, 2: 3 };
-  b = { 0: 1, 1: 2, 2: 3 };
-  a[s1] = 1;
-  b[s1] = 1;
-  a[s2] = 2;
-  b[s2] = 2;
-  expect(a).not.toEqual(b);
-
-  a = [1, 2, 3];
-  b = [1, 2, 3, 4];
-  expect(a).not.toEqual(b);
-
-  a = [1, 2, 3, 4];
-  b = [1, 2, 3];
-  expect(a).not.toEqual(b);
-
-  a = { a: 1, b: 2 };
-  b = { a: 1, b: 2, c: 3 };
-  expect(a).not.toEqual(b);
-
-  a = { a: 1, b: 2, c: 3 };
-  b = { a: 1, b: 2 };
-  expect(a).not.toEqual(b);
-});
-
-test("symbol based keys in arrays are processed correctly", () => {
-  const mySymbol = Symbol("test");
-
-  const actual1 = [];
-  actual1[mySymbol] = 3;
-
-  const actual2 = [];
-  actual2[mySymbol] = 4;
-
-  const expected = [];
-  expected[mySymbol] = 3;
-
-  expect(actual2).not.toEqual(expected);
-  expect(actual1).toEqual(expected);
-});
-
-test("non-enumerable members should be skipped during equal", () => {
-  const actual = {
-    x: 3,
-  };
-  Object.defineProperty(actual, "test", {
-    enumerable: false,
-    value: 5,
-  });
-  expect(actual).toEqual({ x: 3 });
-});
-
-test("non-enumerable symbolic members should be skipped during equal", () => {
-  const actual = {
-    x: 3,
-  };
-  const mySymbol = Symbol("test");
-  Object.defineProperty(actual, mySymbol, {
-    enumerable: false,
-    value: 5,
-  });
-  expect(actual).toEqual({ x: 3 });
-});
-
-test("properties with the same circularity are equal", () => {
-  const a = {};
-  a.x = a;
-  const b = {};
-  b.x = b;
-  expect(a).toEqual(b);
-  expect(b).toEqual(a);
-
-  const c = {
-    x: a,
-  };
-  const d = {
-    x: b,
-  };
-
-  expect(d).toEqual(c);
-  expect(c).toEqual(d);
-});
-
-test("toEqual() - arrays", () => {
-  expect([1, 2, 3]).toEqual([1, 2, 3]);
-  expect([1, 2, 3, 4]).not.toEqual([1, 2, 3]);
-});
-
-test("properties with different circularity are not equal", () => {
-  const a = {};
-  a.x = { y: a };
-  const b = {};
-  const bx = {};
-  b.x = bx;
-  bx.y = bx;
-  expect(a).not.toEqual(b);
-  expect(b).not.toEqual(a);
-
-  const c = {};
-  c.x = a;
-  const d = {};
-  d.x = b;
-  expect(c).not.toEqual(d);
-  expect(d).not.toEqual(c);
-});
-
-test("are not equal if circularity is not on the same property", () => {
-  const a = {};
-  const b = {};
-  a.a1 = a;
-  b.a1 = {};
-  b.a1.a1 = a;
-
-  expect(a).not.toEqual(b);
-  expect(b).not.toEqual(a);
-
-  const c = {};
-  c.x = { x: c };
-  const d = {};
-  d.x = d;
-
-  expect(d).not.toEqual(c);
-  expect(c).not.toEqual(d);
-});
-
-test("random isEqual tests", () => {
-  expect(1).toEqual(1);
-  expect(1).not.toEqual(2);
-  expect(1).not.toEqual("1");
-  expect(1).not.toEqual(true);
-  expect(1).not.toEqual(false);
-  expect(1).not.toEqual(null);
-  expect(1).not.toEqual(undefined);
-  expect(1).not.toEqual({});
-  expect(1).not.toEqual([]);
-  expect(1).not.toEqual([1]);
-  expect(1).not.toEqual([1, 2]);
-  expect(1).not.toEqual([1, 2, 3]);
-  expect(1).not.toEqual([1, 2, 3, 4]);
-  expect(1).not.toEqual([1, 2, 3, 4, 5]);
-  expect(1).not.toEqual([1, 2, 3, 4, 5, 6]);
-  expect(1).not.toEqual([1, 2, 3, 4, 5, 6, 7]);
-  expect(1).not.toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
-  expect(1).not.toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9]);
-  expect(1).not.toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-  expect(1).not.toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]);
-  expect(1).not.toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]);
-  expect(1).not.toEqual([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]);
-  expect(1).not.toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
-
-  // test toEquals for objects with getters and setters
-
-  expect([]).toEqual([]);
-  expect([1]).toEqual([1]);
-  expect([1, 2]).toEqual([1, 2]);
-  expect([1, 2, 3]).toEqual([1, 2, 3]);
-  expect({}).toEqual({});
-  expect({}).not.toEqual([]);
-  expect([]).not.toEqual({});
-
-  const obj = {
-    get a() {
-      return 1;
-    },
-  };
-  expect(obj).toEqual({ a: 1 });
-  expect({ a: 1 }).toEqual(obj);
-  expect(obj).not.toEqual({ a: 2 });
-  expect({ a: 2 }).not.toEqual(obj);
-
-  let a = new Set();
-  a.add([1, 2, 3]);
-  a.add("hello");
-  a.add({ a: 1 });
-  a.add(89);
-  let b = new Set();
-  b.add(89);
-  b.add({ a: 1 });
-  b.add("hello");
-  b.add([1, 2, 3]);
-  expect(a).toEqual(b);
-  expect(b).toEqual(a);
-  let c = new Set();
-  c.add(89);
-  c.add("helo");
-  c.add({ a: 1 });
-  c.add([1, 2, 3]);
-  expect(a).not.toEqual(c);
-
-  a = new Map();
-  a.set(1, 89);
-  a.set("hello", 2);
-  a.set({ a: 1 }, 3);
-  a.set([1, 2, 3], 4);
-  b = new Map();
-  b.set(1, 89);
-  b.set("hello", 2);
-  b.set({ a: 1 }, 3);
-  b.set([1, 2, 3], 4);
-  expect(a).toEqual(b);
-  expect(b).toEqual(a);
-  c = new Map();
-  c.set({ a: 1 }, 3);
-  c.set(1, 80);
-  c.set([1, 2, 3], 4);
-  c.set("hello", 2);
-  expect(a).not.toEqual(c);
-
-  a = new Set();
-  a.add(89);
-  a.add("hello");
-  a.add({ a: 1 });
-  a.add([1, 2, 3]);
-  a.add(a);
-  b = new Set();
-  b.add(89);
-  b.add("hello");
-  b.add(b);
-  b.add({ a: 1 });
-  b.add([1, 2, 3]);
-  expect(a).toEqual(b);
-  expect(b).toEqual(a);
-});
-
-test("testing Bun.deepEquals() using isEqual()", () => {
-  const t = new Uint8Array([1, 2, 3, 4, 5]);
-  expect(t).toEqual(t.slice());
-
-  expect(t.subarray(1)).toEqual(t.slice(1));
-  expect(t.subarray(1, 9)).toEqual(t.slice().subarray(1, 9));
-
-  var a = { foo: 1, bar: 2, baz: null };
-  var b = { foo: 1, bar: 2, baz: null };
-  a.baz = a;
-  b.baz = b;
-  expect(a).toEqual(b);
-
-  var a = { car: 1, cdr: { car: 2, cdr: null } };
-  var b = { car: 1, cdr: { car: 2, cdr: null } };
-  a.cdr.cdr = a;
-  b.cdr.cdr = b.cdr;
-  expect(a).not.toEqual(b);
-
-  expect(1n).not.toEqual(1);
-  expect(1).not.toEqual(1n);
-  expect(1n).toEqual(1n);
-  expect(undefined).not.toEqual([]);
-
-  var a = [1, 2, 3, null];
-  var b = [1, 2, 3, null];
-  a[3] = b;
-  b[3] = a;
-  expect(a).toEqual(b);
-
-  var a = [1, 2, 3, null];
-  var b = [1, 2, 3, null];
-  a[3] = a;
-  b[3] = a;
-  expect(a).toEqual(b);
-
-  var a = [1, [2, [3, null]]];
-  var b = [1, [2, [3, null]]];
-  a[1][1][1] = a;
-  b[1][1][1] = b[1][1];
-  expect(a).not.toEqual(b);
-
-  const foo = [1];
-  foo[1] = foo;
-
-  expect(foo).toEqual([1, foo]);
-
-  expect(1).toEqual(1);
-  expect([1]).toEqual([1]);
-
-  // expect(a).toEqual(a);
-  expect([1, 2, 3]).toEqual([1, 2, 3]);
-
-  let o = { a: 1, b: 2 };
-  expect(o).toEqual(o);
-  expect(o).toEqual({ a: 1, b: 2 });
-  expect(o).toEqual({ b: 2, a: 1 });
-  expect({ a: 1, b: 2 }).toEqual(o);
-  expect({ b: 2, a: 1 }).toEqual(o);
-  expect(o).not.toEqual({ a: 1, b: 2, c: 3 });
-  expect({ a: 1, b: 2, c: 3, d: 4 }).not.toEqual(o);
-  expect({ a: 1, b: 2 }).toEqual({ a: 1, b: 2 });
-  expect({ a: 1, b: 2 }).not.toEqual({ a: 1 });
-
-  expect("a").toEqual("a");
-  expect("aaaa").toEqual("aaaa");
-  expect("aaaa").not.toEqual("aaaaa");
-  expect("aaaa").not.toEqual("aaba");
-  expect("a").not.toEqual("b");
-
-  expect(undefined).not.toEqual(null);
-  expect(null).not.toEqual(undefined);
-  expect(undefined).not.toEqual(0);
-  expect(0).not.toEqual(undefined);
-  expect(null).not.toEqual(0);
-  expect(0).not.toEqual(null);
-  expect(undefined).not.toEqual("");
-  expect("").not.toEqual(undefined);
-  expect(null).not.toEqual("");
-  expect("").not.toEqual(null);
-  expect(undefined).not.toEqual(false);
-  expect(false).not.toEqual(undefined);
-  expect(null).not.toEqual(false);
-  expect(false).not.toEqual(null);
-  expect(undefined).not.toEqual(true);
-  expect(true).not.toEqual(undefined);
-  expect(null).not.toEqual(true);
-  expect(true).not.toEqual(null);
-  expect([]).not.toEqual(undefined);
-  expect(null).not.toEqual([]);
-  expect([]).not.toEqual(null);
-
-  expect(0).toEqual(0);
-  expect(-0).toEqual(-0);
-  expect(0).not.toEqual(-0);
-  expect(-0).not.toEqual(0);
-
-  expect(NaN).toEqual(NaN);
-
-  expect(null).toEqual(null);
-  expect(undefined).toEqual(undefined);
-
-  expect(1).toEqual(1);
-  expect(1).not.toEqual(2);
-
-  expect(NaN).toEqual(NaN);
-  expect(NaN).toEqual(0 / 0);
-  expect(Infinity).toEqual(Infinity);
-  expect(Infinity).toEqual(1 / 0);
-  expect(-Infinity).toEqual(-Infinity);
-  expect(-Infinity).toEqual(-1 / 0);
-});
-
-test("toHaveProperty() - emojis", () => {
-  expect({ "👍": "thumbs up" }).toHaveProperty("👍", "thumbs up");
-  expect({ "👩‍👩‍👧‍👧": "family" }).toHaveProperty("👩‍👩‍👧‍👧", "family");
-  expect({ "😶‍🌫️": "fog" }).toHaveProperty("😶‍🌫️", "fog");
-  expect({ "👩‍❤️‍👨": "couple" }).toHaveProperty("👩‍❤️‍👨", "couple");
-  expect({ "👩‍❤️‍👨‍👨‍👧‍👧": "family" }).toHaveProperty("👩‍❤️‍👨‍👨‍👧‍👧", "family");
-  expect({ "👩‍❤️‍👨‍👨‍👧": "family" }).toHaveProperty("👩‍❤️‍👨‍👨‍👧", "family");
-  expect({ "👩‍❤️‍👨‍👨‍👧": "family" }).not.toHaveProperty("👩‍❤️‍👨‍👨‍👧‍👧", "family");
-
-  // emojis in array
-  expect(["👍", "👎"]).toHaveProperty("0", "👍");
-  expect(["👍", "👎"]).toHaveProperty("1", "👎");
-  expect(["👍", "👎"]).not.toHaveProperty("0", "👎");
-  expect(["👍", "👎"]).not.toHaveProperty("1", "👍");
-  expect(["👩‍❤️‍👨‍👨‍👧‍👧"]).toHaveProperty("0", "👩‍❤️‍👨‍👨‍👧‍👧");
-  expect(["👩‍❤️‍👨‍👨‍👧‍👧"]).toHaveProperty([0], "👩‍❤️‍👨‍👨‍👧‍👧");
-  expect(["😶‍🌫️"]).toHaveProperty([0], "😶‍🌫️");
-});
-
-test("toHaveProperty() - dot and bracket notation edge cases", () => {
-  expect({ a: 1 }).not.toHaveProperty(".");
-  expect({ a: 1 }).not.toHaveProperty("]");
-  expect({ a: 1 }).not.toHaveProperty("[");
-  expect({ a: 1 }).not.toHaveProperty("[]");
-  expect({ a: 1 }).not.toHaveProperty("[[]]");
-  expect({ a: 1 }).not.toHaveProperty("[[");
-  expect({ a: 1 }).not.toHaveProperty("]]");
-  expect({ a: 1 }).not.toHaveProperty("[]]");
-  expect({ a: 1 }).not.toHaveProperty("[[]");
-  expect({ a: 1 }).not.toHaveProperty(".]");
-  expect({ a: 1 }).not.toHaveProperty(".[");
-  expect({ "": 1 }).toHaveProperty("[.", 1);
-  expect({ a: 1 }).not.toHaveProperty("[.");
-  expect({ a: 1 }).not.toHaveProperty("].");
-  expect({ a: 1 }).not.toHaveProperty("].[");
-  expect({ a: 1 }).not.toHaveProperty("].]");
-  expect({ a: 1 }).not.toHaveProperty("[.]");
-  expect({ a: 1 }).not.toHaveProperty("[.[");
-
-  expect([1]).toHaveProperty("[0]", 1);
-  expect([1]).toHaveProperty("[0][", 1);
-  expect([1]).toHaveProperty("[0]]", 1);
-  expect([1]).toHaveProperty("[0][[", 1);
-  expect([1]).toHaveProperty("[][[[0]", 1);
-  expect([1]).toHaveProperty("[][[[]][[][][.0", 1);
-  expect([1]).toHaveProperty("[][[[]][[][][.[][[][[[][][0", 1);
-  expect([1]).not.toHaveProperty("......1.............", 1);
-  expect([1]).not.toHaveProperty("......0.............", 1);
-  expect([1]).not.toHaveProperty(".0", 1);
-  expect([1]).not.toHaveProperty("0.", 1);
-  expect([{ "": 1 }]).toHaveProperty("0.", 1);
-  expect({ "": { "": 1 } }).toHaveProperty(".", 1);
-  expect({ "": { "": { "": 1 } } }).toHaveProperty("..", 1);
-  expect({ "": { "": { "": 1 } } }).not.toHaveProperty(".", 1);
-  expect({ "": { "": { "": 1 } } }).not.toHaveProperty("...", 1);
-  expect({ "": { "": { "": 1 } } }).not.toHaveProperty("....", 1);
-  expect([1]).toHaveProperty("0.[[[][][]][[[][[]]]]", 1);
-  expect([1]).not.toHaveProperty("[0].", 1);
-  expect([1]).toHaveProperty("0", 1);
-  expect([1]).toHaveProperty("[].0", 1);
-  expect([1]).toHaveProperty("[.0", 1);
-  expect([1]).toHaveProperty("].0", 1);
-  expect([1]).toHaveProperty("0[]][[[]", 1);
-  expect([1]).toHaveProperty("[[]][[[][][0", 1);
-  expect([1]).toHaveProperty("0", 1);
-  expect([1]).toHaveProperty("0.[", 1);
-  expect([1]).not.toHaveProperty("0........[", 1);
-  expect([1]).not.toHaveProperty("0..[", 1);
-  expect([1]).not.toHaveProperty(".0", 1);
-  expect([1]).toHaveProperty("[].0", 1);
-  expect([1]).not.toHaveProperty("[]..0", 1);
-  expect([1]).toHaveProperty("[.][.[[.]]]]].[.[].].]]]]].].].0", 1);
-  expect([1]).not.toHaveProperty("[.][.[[.]]]]].[.[].].]]0]]].].].", 1);
-  expect([1]).toHaveProperty("[.][.[[.]]]]].[.[].].]]0]]].].]", 1);
-  expect([1]).not.toHaveProperty("[.][.[[..]]]]].[.[].].]]0]]].].]", 1);
-  expect([1]).toHaveProperty("[.][.[[.]]]]].[.[].].0.]]]]].].]", 1);
-  expect([1]).not.toHaveProperty("[.][.[[.]]]]].[.[].].0.]]] ]].].]", 1);
-  expect([1]).not.toHaveProperty("0      ", 1);
-  expect([1]).not.toHaveProperty("   0      ", 1);
-  expect([1]).not.toHaveProperty("   0[]      ", 1);
-  expect([1]).not.toHaveProperty("   0]      ", 1);
-  expect([1]).not.toHaveProperty(" .[0]", 1);
-
-  expect({ "": 1 }).not.toHaveProperty(".", 1);
-  expect({ "": 1 }).not.toHaveProperty("]", 1);
-  expect({ "": 1 }).not.toHaveProperty("[", 1);
-  expect({ "": 1 }).toHaveProperty("", 1);
-
-  expect({ "": 1 }).not.toHaveProperty("..", 1);
-  expect({ "": { "": 1 } }).not.toHaveProperty("..", 1);
-  expect([{ "": 1 }]).toHaveProperty("0.", 1);
-  expect([{ "": 1 }]).not.toHaveProperty(".0.", 1);
-  expect({ "": [1] }).toHaveProperty(".0", 1);
-  expect({ "": [1] }).not.toHaveProperty("..0", 1);
-  expect([{ "": 1 }]).not.toHaveProperty("0..", 1);
-  expect([{ "": { "": 1 } }]).toHaveProperty("0..", 1);
-
-  expect([1]).not.toHaveProperty("[0].", 1);
-  expect([1]).not.toHaveProperty("[0][0]", 1);
-  expect({ a: [1] }).toHaveProperty("a[[[[[[[[[0]]]", 1);
-  expect({ "[[[": 0 }).not.toHaveProperty("[[[", 0);
-});
-
-test("toHaveProperty() - with string or array", () => {
-  const a = new Array(["a", "b", "c"]);
-  expect(a).toHaveProperty("0.1", "b");
-  const b = new Array("a", "b", "c");
-  expect({ a: { b: { c: 1 } } }).toHaveProperty(b);
-  const c = {
-    a: { b: 1 },
-    "a.b": 2,
-  };
-  const d = new Array("a.b");
-  expect(c).toHaveProperty(d, 2);
-  const houseForSale = {
-    bath: true,
-    bedrooms: 4,
-    kitchen: {
-      amenities: ["oven", "stove", "washer"],
-      area: 20,
-      wallColor: "white",
-      "nice.oven": true,
-    },
-    livingroom: {
-      amenities: [
-        {
-          couch: [
-            ["large", { dimensions: [20, 20] }],
-            ["small", { dimensions: [10, 10] }],
-          ],
-        },
-      ],
-    },
-    sunroom: "yes",
-    "ceiling.height": 20,
-    "entrance.window": 3,
-    entrance: { window: 5 },
-  };
-  expect(houseForSale).toHaveProperty("entrance.window", 5);
-  expect(houseForSale).toHaveProperty(["entrance", "window"], 5);
-  expect(houseForSale).toHaveProperty(["entrance.window"], 3);
-  expect(houseForSale).toHaveProperty("bath");
-  expect(houseForSale).not.toHaveProperty("jacuzzi");
-  // expect(houseForSale).toHaveProperty("jacuzzi");
-  // expect(houseForSale).not.toHaveProperty("bath");
-  expect(houseForSale).toHaveProperty("bath", true);
-  expect(houseForSale).not.toHaveProperty("bath", false);
-  // expect(houseForSale).toHaveProperty("bath", false);
-  // expect(houseForSale).not.toHaveProperty("bath", true);
-  expect(houseForSale).toHaveProperty("bedrooms", 4);
-  expect(houseForSale).toHaveProperty(["sunroom"], "yes");
-  expect(houseForSale).toHaveProperty("kitchen.area", 20);
-  expect(houseForSale).toHaveProperty("kitchen.amenities", ["oven", "stove", "washer"]);
-  expect(houseForSale).not.toHaveProperty(["kitchen", "area"], 21);
-  expect(houseForSale).toHaveProperty(["kitchen", "area"], 20);
-  expect(houseForSale).not.toHaveProperty(["kitchen", "area"], 29);
-  expect(houseForSale).toHaveProperty(["kitchen", "amenities"], ["oven", "stove", "washer"]);
-  expect(houseForSale).toHaveProperty("kitchen.amenities[2]", "washer");
-  expect(houseForSale).toHaveProperty(["kitchen", "amenities", 1], "stove");
-  expect(houseForSale).toHaveProperty(["kitchen", "amenities", 0], "oven");
-  expect(houseForSale).toHaveProperty("livingroom.amenities[0].couch[0][1].dimensions[0]", 20);
-  expect(houseForSale).toHaveProperty(["kitchen", "nice.oven"]);
-  expect(houseForSale).not.toHaveProperty(["kitchen", "open"]);
-  expect(houseForSale).toHaveProperty(["ceiling.height"], 20);
-  expect({ a: { b: 1 } }).toHaveProperty("a.b");
-  expect({ a: [2, 3, 4] }).toHaveProperty("a.0");
-  expect({ a: [2, 3, 4] }).toHaveProperty("a.1");
-  expect({ a: [2, 3, 4] }).toHaveProperty("a.2");
-  expect({ a: [2, 3, 4] }).toHaveProperty("a[1]");
-  expect([2, 3, 4]).toHaveProperty("1");
-  expect([2, 3, 4]).toHaveProperty("[1]");
-  expect([2, [6, 9], 4]).toHaveProperty("1.1");
-  expect([2, [6, 9], 4]).toHaveProperty("1[1]");
-  expect([2, [6, 9], 4]).toHaveProperty("[1].1");
-  expect([2, [6, 9], 4]).toHaveProperty("[1][1]");
-  expect([2, [6, 9], 4]).toHaveProperty([0], 2);
-  expect({ a: { b: 1 } }).toHaveProperty("a.b");
-  expect({ a: [1, 2, [3, { b: 1 }]] }).toHaveProperty("a.2.1.b");
-  expect({ a: [1, 2, [3, { b: 1 }]] }).toHaveProperty("a");
-  expect({ a: [1, 2, [3, { b: 1 }]] }).toHaveProperty("a[2][1].b");
-  expect({ a: [1, 2, [3, { b: 1 }]] }).toHaveProperty("a[2][1]");
-  expect({ a: [1, 2, [3, { b: 1 }]] }).not.toHaveProperty("a[2][1].c");
-  expect("test").toHaveProperty("length");
-  expect({}).toHaveProperty("constructor");
-  expect({}).toHaveProperty("constructor.name");
-  expect({}).toHaveProperty("constructor.name", "Object");
-  expect(new Date()).toHaveProperty("getTime");
-});
-
-test("toHaveProperty() - all", () => {
-  expect({ a: 1 }).toHaveProperty("a");
-  expect({ a: 1 }).toHaveProperty("a", 1);
-  expect({ a: 1 }).not.toHaveProperty("b");
-  expect({ a: 1 }).not.toHaveProperty("a", 2);
-
-  // test with object with property "a" with all types of values (including undefined)
-  expect({ a: undefined }).toHaveProperty("a");
-  expect({ a: null }).toHaveProperty("a");
-  expect({ a: 0 }).toHaveProperty("a");
-  expect({ a: false }).toHaveProperty("a");
-  expect({ a: "" }).toHaveProperty("a");
-  expect({ a: {} }).toHaveProperty("a");
-  expect({ a: [] }).toHaveProperty("a");
-  expect({ a: () => {} }).toHaveProperty("a");
-
-  // test with object with property "a" with all types of values (including undefined)
-  expect({ a: undefined }).toHaveProperty("a", undefined);
-  expect({ a: null }).toHaveProperty("a", null);
-  expect({ a: 0 }).toHaveProperty("a", 0);
-  expect({ a: false }).toHaveProperty("a", false);
-  expect({ a: "" }).toHaveProperty("a", "");
-  expect({ a: {} }).toHaveProperty("a", {});
-  expect({ a: [] }).toHaveProperty("a", []);
-  expect({ a: () => {} }).not.toHaveProperty("a", () => {});
-
-  // test with object with property "a" with all types of values (including undefined)
-
-  expect({ a: undefined }).not.toHaveProperty("a", null);
-  expect({ a: null }).not.toHaveProperty("a", undefined);
-  expect({ a: 0 }).not.toHaveProperty("a", null);
-  expect({ a: false }).not.toHaveProperty("a", null);
-  expect({ a: "" }).not.toHaveProperty("a", null);
-  expect({ a: {} }).not.toHaveProperty("a", null);
-  expect({ a: [] }).not.toHaveProperty("a", null);
-  expect({ a: () => {} }).not.toHaveProperty("a", null);
-
-  expect({ a: undefined }).not.toHaveProperty("a", 0);
-  expect({ a: null }).not.toHaveProperty("a", 0);
-  expect({ a: 0 }).not.toHaveProperty("a", 1);
-  expect({ a: false }).not.toHaveProperty("a", 0);
-  expect({ a: "" }).not.toHaveProperty("a", 0);
-  expect({ a: {} }).not.toHaveProperty("a", 0);
-  expect({ a: [] }).not.toHaveProperty("a", 0);
-  expect({ a: () => {} }).not.toHaveProperty("a", 0);
-
-  expect({ a: undefined }).not.toHaveProperty("a", false);
-  expect({ a: null }).not.toHaveProperty("a", false);
-  expect({ a: 0 }).not.toHaveProperty("a", false);
-  expect({ a: false }).not.toHaveProperty("a", true);
-  expect({ a: "" }).not.toHaveProperty("a", false);
-  expect({ a: {} }).not.toHaveProperty("a", false);
-  expect({ a: [] }).not.toHaveProperty("a", false);
-  expect({ a: () => {} }).not.toHaveProperty("a", false);
-
-  expect({ a: undefined }).not.toHaveProperty("a", "");
-  expect({ a: null }).not.toHaveProperty("a", "");
-  expect({ a: 0 }).not.toHaveProperty("a", "");
-  expect({ a: false }).not.toHaveProperty("a", "");
-  expect({ a: "" }).not.toHaveProperty("a", "a");
-  expect({ a: {} }).not.toHaveProperty("a", "");
-  expect({ a: [] }).not.toHaveProperty("a", "");
-  expect({ a: () => {} }).not.toHaveProperty("a", "");
-
-  expect({ a: undefined }).not.toHaveProperty("a", {});
-  expect({ a: null }).not.toHaveProperty("a", {});
-  expect({ a: 0 }).not.toHaveProperty("a", {});
-  expect({ a: false }).not.toHaveProperty("a", {});
-  expect({ a: "" }).not.toHaveProperty("a", {});
-  expect({ a: {} }).not.toHaveProperty("a", { a: 1 });
-  expect({ a: [] }).not.toHaveProperty("a", {});
-  expect({ a: () => {} }).not.toHaveProperty("a", {});
-
-  // test object with property "a" with value set, map, string
-  expect({ a: new Set([1, 2, 3]) }).toHaveProperty("a", new Set([3, 2, 1]));
-  expect({ a: new Map([{ a: 1 }, { b: 2 }, { c: 3 }]) }).toHaveProperty("a", new Map([{ c: 3 }, { b: 2 }, { a: 1 }]));
-  expect({ a: new String("a") }).toHaveProperty("a", new String("a"));
-  expect({ a: new String("a") }).not.toHaveProperty("a", "a");
-  expect({ a: new String("a") }).not.toHaveProperty("a", "b");
-  expect({ a: new String("a") }).not.toHaveProperty("a", new String("b"));
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Number(1));
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Boolean(true));
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Boolean(false));
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Object());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Array());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Function());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Date());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new RegExp());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Error());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Promise(() => {}));
-  expect({ a: new String("a") }).not.toHaveProperty("a", new WeakSet());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new WeakMap());
-  expect({ a: new String("a") }).not.toHaveProperty("a", Symbol("a"));
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Int8Array());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Uint8Array());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Uint8ClampedArray());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Int16Array());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Uint16Array());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Int32Array());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Uint32Array());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Float32Array());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new Float64Array());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new BigInt64Array());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new BigUint64Array());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new ArrayBuffer());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new SharedArrayBuffer());
-  expect({ a: new String("a") }).not.toHaveProperty("a", new DataView(new ArrayBuffer(1)));
-
-  // test property equality with sets, maps, objects, arrays, and String
-  expect({ a: new Set([1, 2, 3]) }).toHaveProperty("a", new Set([1, 2, 3]));
-  expect({ a: new Map([{ a: 1 }, { b: 2 }, { c: 3 }]) }).toHaveProperty("a", new Map([{ a: 1 }, { b: 2 }, { c: 3 }]));
-  expect({ a: { a: 1, b: 2, c: 3 } }).toHaveProperty("a", { a: 1, b: 2, c: 3 });
-  expect({ a: [1, 2, 3] }).toHaveProperty("a", [1, 2, 3]);
-  expect({ a: "a" }).toHaveProperty("a", "a");
-  expect({ a: new String("a") }).toHaveProperty("a", new String("a"));
-  expect({ a: new String("a") }).not.toHaveProperty("a", "a");
-});
-
-test("toBe()", () => {
-  const a = 1;
-  const b = 1;
-  expect(a).toBe(a);
-  expect(a).toBe(b);
-  expect(a).toBe(1);
-  expect(1).toBe(a);
-  expect(b).toBe(a);
-
-  const c = { a: 1 };
-  const d = { a: 1 };
-  expect(c).toBe(c);
-  expect(c).not.toBe(d);
-  expect(c).not.toBe({ a: 1 });
-  expect({ a: 1 }).not.toBe(c);
-  expect(d).not.toBe(c);
-
-  expect(1).toBe(1);
-  // expect(1).not.toBe(1);
-
-  expect(1).not.toBe(2);
-  expect(1).not.toBe("1");
-  expect("hello test").toBe("hello test");
-  expect("hello test").not.toBe("hello test2");
-});
-
-test("toHaveLength()", () => {
-  expect({ length: Number.MAX_SAFE_INTEGER }).toHaveLength(Number.MAX_SAFE_INTEGER);
-  expect("123").toHaveLength(3);
-  expect([1, 2, 3]).toHaveLength(3);
-  expect([1, 2, 3]).not.toHaveLength(2);
-  expect("123").not.toHaveLength(2);
-  expect({ length: 3 }).toHaveLength(3);
-  expect({ length: 3 }).not.toHaveLength(2);
-  expect({ length: 3 }).not.toHaveLength(Number.MAX_SAFE_INTEGER);
-  expect({ length: Number.MAX_SAFE_INTEGER }).not.toHaveLength(Number.MAX_SAFE_INTEGER - 1);
-  expect({ length: 3.3 }).not.toHaveLength(3);
-  expect("123").not.toHaveLength(-0);
-});
-
-test("toContain()", () => {
-  const s1 = new String("123");
-  expect(s1).not.toContain("12");
-  const s2 = "123";
-  expect(s2).toContain("12");
-
-  expect("test").toContain("es");
-  expect("test").toContain("est");
-  // expect("test").not.toContain("test");
-  expect(["test", "es"]).toContain("es");
-  expect("").toContain("");
-  expect([""]).toContain("");
-
-  expect(["lemon", "lime"]).not.toContain("orange");
-  expect("citrus fruits").toContain("fruit");
-
-  const a = new Uint16Array([1, 2, 3]);
-  expect(a).toContain(2);
-  expect(a).not.toContain(4);
-  expect([2, "2335", 5, true, false, null, undefined]).toContain(5);
-  expect([2, "2335", 5, true, false, null, undefined]).toContain("2335");
-  expect([2, "2335", 5, true, false, null, undefined]).toContain(true);
-  expect([2, "2335", 5, true, false, null, undefined]).toContain(false);
-  expect([2, "2335", 5, true, false, null, undefined]).toContain(null);
-  expect([2, "2335", 5, true, false, null, undefined]).toContain(undefined);
-  expect([2, "2335", 5, true, false, null, undefined]).not.toContain(3);
-  expect([2, "2335", 5, true, false, null, undefined]).not.not.not.toContain(3);
-
-  // expect([4, 5, 6]).not.toContain(5);
-
-  expect([]).not.toContain([]);
-});
-
-test("toBeTruthy()", () => {
-  expect("test").toBeTruthy();
-  expect(true).toBeTruthy();
-  expect(1).toBeTruthy();
-  expect({}).toBeTruthy();
-  expect([]).toBeTruthy();
-  expect(() => {}).toBeTruthy();
-  // expect(() => {}).not.toBeTruthy();
-
-  expect("").not.toBeTruthy();
-  expect(0).not.toBeTruthy();
-  expect(-0).not.toBeTruthy();
-  expect(NaN).not.toBeTruthy();
-  expect(0n).not.toBeTruthy();
-  expect(false).not.toBeTruthy();
-  expect(null).not.toBeTruthy();
-  expect(undefined).not.toBeTruthy();
-});
-
-test("toBeUndefined()", () => {
-  expect(undefined).toBeUndefined();
-  // expect(undefined).not.toBeUndefined();
-
-  expect(null).not.toBeUndefined();
-  expect(null).not.not.not.toBeUndefined();
-  expect(0).not.toBeUndefined();
-  expect("hello defined").not.toBeUndefined();
-});
-
-test("toBeNaN()", () => {
-  expect(NaN).toBeNaN();
-  // expect(NaN).not.toBeNaN();
-
-  expect(0).not.toBeNaN();
-  expect("hello not NaN").not.toBeNaN();
-});
-
-test("toBeNull()", () => {
-  expect(null).toBeNull();
-  // expect(null).not.toBeNull();
-
-  expect(undefined).not.toBeNull();
-  expect(0).not.toBeNull();
-  expect("hello not null").not.toBeNull();
-});
-
-test("toBeDefined()", () => {
-  expect(0).toBeDefined();
-  expect("hello defined").toBeDefined();
-  expect(null).toBeDefined();
-  // expect(null).not.toBeDefined();
-
-  expect(undefined).not.toBeDefined();
-});
-
-test("toBeFalsy()", () => {
-  expect("").toBeFalsy();
-  expect(0).toBeFalsy();
-  expect(-0).toBeFalsy();
-  expect(NaN).toBeFalsy();
-  expect(0n).toBeFalsy();
-  expect(false).toBeFalsy();
-  expect(null).toBeFalsy();
-  expect(undefined).toBeFalsy();
-  // expect(undefined).not.toBeFalsy();
-
-  expect("hello not falsy").not.toBeFalsy();
-  expect("hello not falsy").not.not.not.toBeFalsy();
-  expect(1).not.toBeFalsy();
-  expect(true).not.toBeFalsy();
-  expect({}).not.toBeFalsy();
-  expect([]).not.toBeFalsy();
-  expect(() => {}).not.toBeFalsy();
-});
-
-test("toBeGreaterThan()", () => {
-  expect(3n).toBeGreaterThan(2);
-  expect(Number.MAX_VALUE).not.toBeGreaterThan(Number.MAX_VALUE);
-  expect(1).not.toBeGreaterThan(BigInt(Number.MAX_VALUE));
-  expect(1).not.toBeGreaterThan(Number.MAX_SAFE_INTEGER);
-  expect(1).not.toBeGreaterThan(BigInt(Number.MAX_SAFE_INTEGER));
-  expect(Number.MAX_SAFE_INTEGER).not.toBeGreaterThan(Number.MAX_SAFE_INTEGER);
-  expect(BigInt(Number.MAX_SAFE_INTEGER)).not.toBeGreaterThan(BigInt(Number.MAX_SAFE_INTEGER));
-
-  expect(Infinity).toBeGreaterThan(-Infinity);
-  expect(-Infinity).not.toBeGreaterThan(Infinity);
-
-  expect(NaN).not.toBeGreaterThan(NaN);
-  expect(NaN).not.toBeGreaterThan(-Infinity);
-
-  expect(10).toBeGreaterThan(9);
-  expect(10).not.toBeGreaterThan(10);
-  expect(10).not.toBeGreaterThan(11);
-  expect(10).not.toBeGreaterThan(Infinity);
-  expect(10).toBeGreaterThan(-Infinity);
-  expect(10).not.toBeGreaterThan(NaN);
-  expect(10).toBeGreaterThan(0);
-  expect(10).toBeGreaterThan(-0);
-  expect(10).toBeGreaterThan(0.1);
-  expect(10).toBeGreaterThan(-0.1);
-  expect(10).toBeGreaterThan(0.9);
-  expect(10).toBeGreaterThan(-0.9);
-  expect(10).toBeGreaterThan(1);
-  expect(10).toBeGreaterThan(-1);
-  // switch the order
-  expect(9).not.toBeGreaterThan(10);
-  expect(10).not.toBeGreaterThan(10);
-  expect(11).toBeGreaterThan(10);
-  expect(Infinity).toBeGreaterThan(10);
-  expect(-Infinity).not.toBeGreaterThan(10);
-  expect(NaN).not.toBeGreaterThan(10);
-  expect(0).not.toBeGreaterThan(10);
-  expect(-0).not.toBeGreaterThan(10);
-  expect(0.1).not.toBeGreaterThan(10);
-  expect(-0.1).not.toBeGreaterThan(10);
-  expect(0.9).not.toBeGreaterThan(10);
-  expect(-0.9).not.toBeGreaterThan(10);
-  expect(1).not.toBeGreaterThan(10);
-  expect(-1).not.toBeGreaterThan(10);
-
-  // same tests but use bigints
-  expect(10n).toBeGreaterThan(9n);
-  expect(10n).not.toBeGreaterThan(10n);
-  expect(10n).not.toBeGreaterThan(11n);
-  expect(10n).not.toBeGreaterThan(Infinity);
-  expect(10n).toBeGreaterThan(-Infinity);
-  expect(10n).not.toBeGreaterThan(NaN);
-  expect(10n).toBeGreaterThan(0n);
-  expect(10n).toBeGreaterThan(-0n);
-  expect(10n).toBeGreaterThan(1n);
-  expect(10n).toBeGreaterThan(-1n);
-  // switch the order
-  expect(9n).not.toBeGreaterThan(10n);
-  expect(10n).not.toBeGreaterThan(10n);
-  expect(11n).toBeGreaterThan(10n);
-  expect(Infinity).toBeGreaterThan(10n);
-  expect(-Infinity).not.toBeGreaterThan(10n);
-  expect(NaN).not.toBeGreaterThan(10n);
-  expect(0n).not.toBeGreaterThan(10n);
-  expect(-0n).not.toBeGreaterThan(10n);
-  expect(1n).not.toBeGreaterThan(10n);
-  expect(-1n).not.toBeGreaterThan(10n);
-
-  // use bigints and numbers
-  expect(10n).toBeGreaterThan(9);
-  expect(10n).not.toBeGreaterThan(10);
-  expect(10n).not.toBeGreaterThan(11);
-  expect(10n).not.toBeGreaterThan(Infinity);
-  expect(10n).toBeGreaterThan(-Infinity);
-  expect(10n).not.toBeGreaterThan(NaN);
-  expect(10n).toBeGreaterThan(0);
-  expect(10n).toBeGreaterThan(-0);
-  expect(10n).toBeGreaterThan(0.1);
-  expect(10n).toBeGreaterThan(-0.1);
-  expect(10n).toBeGreaterThan(0.9);
-  expect(10n).toBeGreaterThan(-0.9);
-  expect(10n).toBeGreaterThan(1);
-  expect(10n).toBeGreaterThan(-1);
-  // switch the order
-  expect(9n).not.toBeGreaterThan(10);
-  expect(10n).not.toBeGreaterThan(10);
-  expect(11n).toBeGreaterThan(10);
-  expect(Infinity).toBeGreaterThan(10n);
-  expect(-Infinity).not.toBeGreaterThan(10n);
-  expect(NaN).not.toBeGreaterThan(10n);
-  expect(0n).not.toBeGreaterThan(10);
-  expect(-0n).not.toBeGreaterThan(10);
-  expect(1n).not.toBeGreaterThan(10);
-  expect(-1n).not.toBeGreaterThan(10);
-
-  expect(1n).not.toBeGreaterThan(1);
-  expect(1n).not.toBeGreaterThan(Number.MAX_SAFE_INTEGER);
-  expect(1n).not.toBeGreaterThan(Number.MAX_VALUE);
-  expect(1).not.toBeGreaterThan(1n);
-  expect(Number.MAX_SAFE_INTEGER).toBeGreaterThan(1n);
-  expect(Number.MAX_VALUE).toBeGreaterThan(1n);
-
-  expect(BigInt(Number.MAX_SAFE_INTEGER)).toBeGreaterThan(1n);
-  expect(BigInt(Number.MAX_VALUE)).toBeGreaterThan(1n);
-  expect(1n).not.toBeGreaterThan(BigInt(Number.MAX_SAFE_INTEGER));
-  expect(1n).not.toBeGreaterThan(BigInt(Number.MAX_VALUE));
-
-  expect(BigInt(Number.MAX_SAFE_INTEGER)).toBeGreaterThan(1);
-  expect(BigInt(Number.MAX_VALUE)).toBeGreaterThan(1);
-  expect(1).not.toBeGreaterThan(BigInt(Number.MAX_SAFE_INTEGER));
-});
-
-test("toBeGreaterThanOrEqual()", () => {
-  expect(Number.MAX_VALUE).toBeGreaterThanOrEqual(Number.MAX_VALUE);
-  expect(1).not.toBeGreaterThanOrEqual(Number.MAX_SAFE_INTEGER);
-  expect(1).not.toBeGreaterThanOrEqual(BigInt(Number.MAX_SAFE_INTEGER));
-  expect(1).not.toBeGreaterThanOrEqual(BigInt(Number.MAX_VALUE));
-  expect(Number.MAX_SAFE_INTEGER).toBeGreaterThanOrEqual(Number.MAX_SAFE_INTEGER);
-  expect(BigInt(Number.MAX_SAFE_INTEGER)).toBeGreaterThanOrEqual(BigInt(Number.MAX_SAFE_INTEGER));
-
-  expect(Infinity).toBeGreaterThanOrEqual(-Infinity);
-  expect(-Infinity).not.toBeGreaterThanOrEqual(Infinity);
-
-  expect(NaN).not.toBeGreaterThanOrEqual(NaN);
-  expect(NaN).not.toBeGreaterThanOrEqual(-Infinity);
-
-  expect(10).toBeGreaterThanOrEqual(9);
-  expect(10).toBeGreaterThanOrEqual(10);
-  expect(10).not.toBeGreaterThanOrEqual(11);
-  expect(10).not.toBeGreaterThanOrEqual(Infinity);
-  expect(10).toBeGreaterThanOrEqual(-Infinity);
-  expect(10).not.toBeGreaterThanOrEqual(NaN);
-  expect(10).toBeGreaterThanOrEqual(0);
-  expect(10).toBeGreaterThanOrEqual(-0);
-  expect(10).toBeGreaterThanOrEqual(0.1);
-  expect(10).toBeGreaterThanOrEqual(-0.1);
-  expect(10).toBeGreaterThanOrEqual(0.9);
-  expect(10).toBeGreaterThanOrEqual(-0.9);
-  expect(10).toBeGreaterThanOrEqual(1);
-  expect(10).toBeGreaterThanOrEqual(-1);
-  // switch the order
-  expect(9).not.toBeGreaterThanOrEqual(10);
-  expect(10).toBeGreaterThanOrEqual(10);
-  expect(11).toBeGreaterThanOrEqual(10);
-  expect(Infinity).toBeGreaterThanOrEqual(10);
-  expect(-Infinity).not.toBeGreaterThanOrEqual(10);
-  expect(NaN).not.toBeGreaterThanOrEqual(10);
-  expect(0).not.toBeGreaterThanOrEqual(10);
-  expect(-0).not.toBeGreaterThanOrEqual(10);
-  expect(0.1).not.toBeGreaterThanOrEqual(10);
-  expect(-0.1).not.toBeGreaterThanOrEqual(10);
-  expect(0.9).not.toBeGreaterThanOrEqual(10);
-  expect(-0.9).not.toBeGreaterThanOrEqual(10);
-  expect(1).not.toBeGreaterThanOrEqual(10);
-  expect(-1).not.toBeGreaterThanOrEqual(10);
-
-  // same tests but use bigints
-  expect(10n).toBeGreaterThanOrEqual(9n);
-  expect(10n).toBeGreaterThanOrEqual(10n);
-  expect(10n).not.toBeGreaterThanOrEqual(11n);
-  expect(10n).not.toBeGreaterThanOrEqual(Infinity);
-  expect(10n).toBeGreaterThanOrEqual(-Infinity);
-  expect(10n).not.toBeGreaterThanOrEqual(NaN);
-  expect(10n).toBeGreaterThanOrEqual(0n);
-  expect(10n).toBeGreaterThanOrEqual(-0n);
-  expect(10n).toBeGreaterThanOrEqual(1n);
-  expect(10n).toBeGreaterThanOrEqual(-1n);
-  // switch the order
-  expect(9n).not.toBeGreaterThanOrEqual(10n);
-  expect(10n).toBeGreaterThanOrEqual(10n);
-  expect(11n).toBeGreaterThanOrEqual(10n);
-  expect(Infinity).toBeGreaterThanOrEqual(10n);
-  expect(-Infinity).not.toBeGreaterThanOrEqual(10n);
-  expect(NaN).not.toBeGreaterThanOrEqual(10n);
-  expect(0n).not.toBeGreaterThanOrEqual(10n);
-  expect(-0n).not.toBeGreaterThanOrEqual(10n);
-  expect(1n).not.toBeGreaterThanOrEqual(10n);
-  expect(-1n).not.toBeGreaterThanOrEqual(10n);
-
-  // use bigints and numbers
-  expect(10n).toBeGreaterThanOrEqual(9);
-  expect(10n).toBeGreaterThanOrEqual(10);
-  expect(10n).not.toBeGreaterThanOrEqual(11);
-  expect(10n).not.toBeGreaterThanOrEqual(Infinity);
-  expect(10n).toBeGreaterThanOrEqual(-Infinity);
-  expect(10n).not.toBeGreaterThanOrEqual(NaN);
-  expect(10n).toBeGreaterThanOrEqual(0);
-  expect(10n).toBeGreaterThanOrEqual(-0);
-  expect(10n).toBeGreaterThanOrEqual(0.1);
-  expect(10n).toBeGreaterThanOrEqual(-0.1);
-  expect(10n).toBeGreaterThanOrEqual(0.9);
-  expect(10n).toBeGreaterThanOrEqual(-0.9);
-  expect(10n).toBeGreaterThanOrEqual(1);
-  expect(10n).toBeGreaterThanOrEqual(-1);
-  // switch the order
-  expect(9n).not.toBeGreaterThanOrEqual(10);
-  expect(10n).toBeGreaterThanOrEqual(10);
-  expect(11n).toBeGreaterThanOrEqual(10);
-  expect(Infinity).toBeGreaterThanOrEqual(10n);
-  expect(-Infinity).not.toBeGreaterThanOrEqual(10n);
-  expect(NaN).not.toBeGreaterThanOrEqual(10n);
-  expect(0n).not.toBeGreaterThanOrEqual(10);
-  expect(-0n).not.toBeGreaterThanOrEqual(10);
-  expect(1n).not.toBeGreaterThanOrEqual(10);
-  expect(-1n).not.toBeGreaterThanOrEqual(10);
-
-  expect(1n).toBeGreaterThanOrEqual(1);
-  expect(1n).not.toBeGreaterThanOrEqual(Number.MAX_SAFE_INTEGER);
-  expect(1n).not.toBeGreaterThanOrEqual(Number.MAX_VALUE);
-  expect(1).toBeGreaterThanOrEqual(1n);
-  expect(Number.MAX_SAFE_INTEGER).toBeGreaterThanOrEqual(1n);
-  expect(Number.MAX_VALUE).toBeGreaterThanOrEqual(1n);
-
-  expect(1).not.toBeGreaterThanOrEqual(BigInt(Number.MAX_VALUE));
-});
-
-test("toBeLessThan()", () => {
-  expect(3n).not.toBeLessThan(2);
-  expect(Number.MAX_VALUE).not.toBeLessThan(Number.MAX_VALUE);
-  expect(1).toBeLessThan(BigInt(Number.MAX_VALUE));
-  expect(1).toBeLessThan(Number.MAX_SAFE_INTEGER);
-  expect(1).toBeLessThan(BigInt(Number.MAX_SAFE_INTEGER));
-  expect(Number.MAX_SAFE_INTEGER).not.toBeLessThan(Number.MAX_SAFE_INTEGER);
-  expect(BigInt(Number.MAX_SAFE_INTEGER)).not.toBeLessThan(BigInt(Number.MAX_SAFE_INTEGER));
-
-  expect(Number.MAX_VALUE).not.toBeLessThan(BigInt(Number.MAX_VALUE));
-
-  expect(NaN).not.toBeLessThan(NaN);
-  expect(NaN).not.toBeLessThan(-Infinity);
-
-  expect(10).not.toBeLessThan(9);
-  expect(10).not.toBeLessThan(10);
-  expect(10).toBeLessThan(11);
-  expect(10).toBeLessThan(Infinity);
-  expect(10).not.toBeLessThan(-Infinity);
-  expect(10).not.toBeLessThan(NaN);
-  expect(10).not.toBeLessThan(0);
-  expect(10).not.toBeLessThan(-0);
-  expect(10).not.toBeLessThan(0.1);
-  expect(10).not.toBeLessThan(-0.1);
-  expect(10).not.toBeLessThan(0.9);
-  expect(10).not.toBeLessThan(-0.9);
-  expect(10).not.toBeLessThan(1);
-  expect(10).not.toBeLessThan(-1);
-  // switch the order
-  expect(9).toBeLessThan(10);
-  expect(10).not.toBeLessThan(10);
-  expect(11).not.toBeLessThan(10);
-  expect(Infinity).not.toBeLessThan(10);
-  expect(-Infinity).toBeLessThan(10);
-  expect(NaN).not.toBeLessThan(10);
-  expect(0).toBeLessThan(10);
-  expect(-0).toBeLessThan(10);
-  expect(0.1).toBeLessThan(10);
-  expect(-0.1).toBeLessThan(10);
-  expect(0.9).toBeLessThan(10);
-  expect(-0.9).toBeLessThan(10);
-  expect(1).toBeLessThan(10);
-  expect(-1).toBeLessThan(10);
-
-  // same tests but use bigints
-  expect(10n).not.toBeLessThan(9n);
-  expect(10n).not.toBeLessThan(10n);
-  expect(10n).toBeLessThan(11n);
-  expect(10n).toBeLessThan(Infinity);
-  expect(10n).not.toBeLessThan(-Infinity);
-  expect(10n).not.toBeLessThan(NaN);
-  expect(10n).not.toBeLessThan(0n);
-  expect(10n).not.toBeLessThan(-0n);
-  expect(10n).not.toBeLessThan(1n);
-  expect(10n).not.toBeLessThan(-1n);
-  // switch the order
-  expect(9n).toBeLessThan(10n);
-  expect(10n).not.toBeLessThan(10n);
-  expect(11n).not.toBeLessThan(10n);
-  expect(Infinity).not.toBeLessThan(10n);
-  expect(-Infinity).toBeLessThan(10n);
-  expect(NaN).not.toBeLessThan(10n);
-  expect(0n).toBeLessThan(10n);
-  expect(-0n).toBeLessThan(10n);
-  expect(1n).toBeLessThan(10n);
-  expect(-1n).toBeLessThan(10n);
-
-  // use bigints and numbers
-  expect(10n).not.toBeLessThan(9);
-  expect(10n).not.toBeLessThan(10);
-  expect(10n).toBeLessThan(11);
-  expect(10n).toBeLessThan(Infinity);
-  expect(10n).not.toBeLessThan(-Infinity);
-  expect(10n).not.toBeLessThan(NaN);
-  expect(10n).not.toBeLessThan(0);
-  expect(10n).not.toBeLessThan(-0);
-  expect(10n).not.toBeLessThan(0.1);
-  expect(10n).not.toBeLessThan(-0.1);
-  expect(10n).not.toBeLessThan(0.9);
-  expect(10n).not.toBeLessThan(-0.9);
-  expect(10n).not.toBeLessThan(1);
-  expect(10n).not.toBeLessThan(-1);
-  // switch the order
-  expect(9n).toBeLessThan(10);
-  expect(10n).not.toBeLessThan(10);
-  expect(11n).not.toBeLessThan(10);
-  expect(Infinity).not.toBeLessThan(10n);
-  expect(-Infinity).toBeLessThan(10n);
-  expect(NaN).not.toBeLessThan(10n);
-  expect(0n).toBeLessThan(10);
-  expect(-0n).toBeLessThan(10);
-  expect(1n).toBeLessThan(10);
-  expect(-1n).toBeLessThan(10);
-
-  expect(1n).not.toBeLessThan(1);
-  expect(1n).toBeLessThan(Number.MAX_SAFE_INTEGER);
-  expect(1n).toBeLessThan(Number.MAX_VALUE);
-  expect(1).not.toBeLessThan(1n);
-  expect(Number.MAX_SAFE_INTEGER).not.toBeLessThan(1n);
-  expect(Number.MAX_VALUE).not.toBeLessThan(1n);
-
-  expect(BigInt(Number.MAX_SAFE_INTEGER)).not.toBeLessThan(1n);
-  expect(BigInt(Number.MAX_VALUE)).not.toBeLessThan(1n);
-  expect(1n).toBeLessThan(BigInt(Number.MAX_SAFE_INTEGER));
-  expect(1n).toBeLessThan(BigInt(Number.MAX_VALUE));
-
-  expect(BigInt(Number.MAX_SAFE_INTEGER)).not.toBeLessThan(1);
-  expect(BigInt(Number.MAX_VALUE)).not.toBeLessThan(1);
-  expect(1).toBeLessThan(BigInt(Number.MAX_SAFE_INTEGER));
-});
-
-test("toBeLessThanOrEqual()", () => {
-  expect(3n).not.toBeLessThanOrEqual(2);
-  expect(Number.MAX_VALUE).toBeLessThanOrEqual(Number.MAX_VALUE);
-  expect(1).toBeLessThanOrEqual(BigInt(Number.MAX_VALUE));
-  expect(1).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
-  expect(1).toBeLessThanOrEqual(BigInt(Number.MAX_SAFE_INTEGER));
-  expect(Number.MAX_SAFE_INTEGER).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
-  expect(BigInt(Number.MAX_SAFE_INTEGER)).toBeLessThanOrEqual(BigInt(Number.MAX_SAFE_INTEGER));
-
-  expect(Number.MAX_VALUE).toBeLessThanOrEqual(BigInt(Number.MAX_VALUE));
-  expect(BigInt(Number.MAX_VALUE)).toBeLessThanOrEqual(Number.MAX_VALUE);
-
-  expect(NaN).not.toBeLessThanOrEqual(NaN);
-  expect(NaN).not.toBeLessThanOrEqual(-Infinity);
-
-  expect(10).not.toBeLessThanOrEqual(9);
-  expect(10).toBeLessThanOrEqual(10);
-  expect(10).toBeLessThanOrEqual(11);
-  expect(10).toBeLessThanOrEqual(Infinity);
-  expect(10).not.toBeLessThanOrEqual(-Infinity);
-  expect(10).not.toBeLessThanOrEqual(NaN);
-  expect(10).not.toBeLessThanOrEqual(0);
-  expect(10).not.toBeLessThanOrEqual(-0);
-  expect(10).not.toBeLessThanOrEqual(0.1);
-  expect(10).not.toBeLessThanOrEqual(-0.1);
-  expect(10).not.toBeLessThanOrEqual(0.9);
-  expect(10).not.toBeLessThanOrEqual(-0.9);
-  expect(10).not.toBeLessThanOrEqual(1);
-  expect(10).not.toBeLessThanOrEqual(-1);
-  // switch the order
-  expect(9).toBeLessThanOrEqual(10);
-  expect(10).toBeLessThanOrEqual(10);
-  expect(11).not.toBeLessThanOrEqual(10);
-  expect(Infinity).not.toBeLessThanOrEqual(10);
-  expect(-Infinity).toBeLessThanOrEqual(10);
-  expect(NaN).not.toBeLessThanOrEqual(10);
-  expect(0).toBeLessThanOrEqual(10);
-  expect(-0).toBeLessThanOrEqual(10);
-  expect(0.1).toBeLessThanOrEqual(10);
-  expect(-0.1).toBeLessThanOrEqual(10);
-  expect(0.9).toBeLessThanOrEqual(10);
-  expect(-0.9).toBeLessThanOrEqual(10);
-  expect(1).toBeLessThanOrEqual(10);
-  expect(-1).toBeLessThanOrEqual(10);
-
-  // same tests but use bigints
-  expect(10n).not.toBeLessThanOrEqual(9n);
-  expect(10n).toBeLessThanOrEqual(10n);
-  expect(10n).toBeLessThanOrEqual(11n);
-  expect(10n).toBeLessThanOrEqual(Infinity);
-  expect(10n).not.toBeLessThanOrEqual(-Infinity);
-  expect(10n).not.toBeLessThanOrEqual(NaN);
-  expect(10n).not.toBeLessThanOrEqual(0n);
-  expect(10n).not.toBeLessThanOrEqual(-0n);
-  expect(10n).not.toBeLessThanOrEqual(1n);
-  expect(10n).not.toBeLessThanOrEqual(-1n);
-  // switch the order
-  expect(9n).toBeLessThanOrEqual(10n);
-  expect(10n).toBeLessThanOrEqual(10n);
-  expect(11n).not.toBeLessThanOrEqual(10n);
-  expect(Infinity).not.toBeLessThanOrEqual(10n);
-  expect(-Infinity).toBeLessThanOrEqual(10n);
-  expect(NaN).not.toBeLessThanOrEqual(10n);
-  expect(0n).toBeLessThanOrEqual(10n);
-  expect(-0n).toBeLessThanOrEqual(10n);
-  expect(1n).toBeLessThanOrEqual(10n);
-  expect(-1n).toBeLessThanOrEqual(10n);
-
-  // use bigints and numbers
-  expect(10n).not.toBeLessThanOrEqual(9);
-  expect(10n).toBeLessThanOrEqual(10);
-  expect(10n).toBeLessThanOrEqual(11);
-  expect(10n).toBeLessThanOrEqual(Infinity);
-  expect(10n).not.toBeLessThanOrEqual(-Infinity);
-  expect(10n).not.toBeLessThanOrEqual(NaN);
-  expect(10n).not.toBeLessThanOrEqual(0);
-  expect(10n).not.toBeLessThanOrEqual(-0);
-  expect(10n).not.toBeLessThanOrEqual(0.1);
-  expect(10n).not.toBeLessThanOrEqual(-0.1);
-  expect(10n).not.toBeLessThanOrEqual(0.9);
-  expect(10n).not.toBeLessThanOrEqual(-0.9);
-  expect(10n).not.toBeLessThanOrEqual(1);
-  expect(10n).not.toBeLessThanOrEqual(-1);
-  // switch the order
-  expect(9n).toBeLessThanOrEqual(10);
-  expect(10n).toBeLessThanOrEqual(10);
-  expect(11n).not.toBeLessThanOrEqual(10);
-  expect(Infinity).not.toBeLessThanOrEqual(10n);
-  expect(-Infinity).toBeLessThanOrEqual(10n);
-  expect(NaN).not.toBeLessThanOrEqual(10n);
-  expect(0n).toBeLessThanOrEqual(10);
-  expect(-0n).toBeLessThanOrEqual(10);
-  expect(1n).toBeLessThanOrEqual(10);
-  expect(-1n).toBeLessThanOrEqual(10);
-
-  expect(1n).toBeLessThanOrEqual(1);
-  expect(1n).toBeLessThanOrEqual(Number.MAX_SAFE_INTEGER);
-  expect(1n).toBeLessThanOrEqual(Number.MAX_VALUE);
-  expect(1).toBeLessThanOrEqual(1n);
-  expect(Number.MAX_SAFE_INTEGER).not.toBeLessThanOrEqual(1n);
-  expect(Number.MAX_VALUE).not.toBeLessThanOrEqual(1n);
-
-  expect(BigInt(Number.MAX_SAFE_INTEGER)).not.toBeLessThanOrEqual(1n);
-  expect(BigInt(Number.MAX_VALUE)).not.toBeLessThanOrEqual(1n);
-  expect(1n).toBeLessThanOrEqual(BigInt(Number.MAX_SAFE_INTEGER));
-  expect(1n).toBeLessThanOrEqual(BigInt(Number.MAX_VALUE));
-
-  expect(BigInt(Number.MAX_SAFE_INTEGER)).not.toBeLessThanOrEqual(1);
-  expect(BigInt(Number.MAX_VALUE)).not.toBeLessThanOrEqual(1);
-  expect(1).toBeLessThanOrEqual(BigInt(Number.MAX_SAFE_INTEGER));
-});
-
-try {
-  test("test this doesnt crash");
-} catch (e) {}
-
-try {
-  test();
-} catch (e) {}
-
-describe("throw in describe scope doesn't enqueue tests after thrown", () => {
-  it("test enqueued before a describe scope throws is never run", () => {
-    throw new Error("This test failed");
-  });
-
-  class TestPass extends Error {
-    constructor(message) {
-      super(message);
-      this.name = "TestPass";
-    }
-  }
-
-  throw new TestPass("This test passed. Ignore the error message");
-
-  it("test enqueued after a describe scope throws is never run", () => {
-    throw new Error("This test failed");
-  });
-});
-
-it("a describe scope throwing doesn't cause all other tests in the file to fail", () => {
-  expect(true).toBe(true);
-});
-
-test("test async exceptions fail tests", () => {
-  const code = `
-  import {test, expect} from 'bun:test';
-  import {EventEmitter} from 'events';
-  test('test throwing inside an EventEmitter fails the test', () => {
-    const emitter = new EventEmitter();
-    emitter.on('event', () => {
-      throw new Error('test throwing inside an EventEmitter #FAIL001');
-    });
-    emitter.emit('event');
-  });
-
-  test('test throwing inside a queueMicrotask callback fails', async () => {
-
-    queueMicrotask(() => {
-      throw new Error('test throwing inside an EventEmitter #FAIL002');
-    });
-
-    await 1;
-  });
-
-  test('test throwing inside a process.nextTick callback fails', async () => {
-
-    process.nextTick(() => {
-      throw new Error('test throwing inside an EventEmitter #FAIL003');
-    });
-
-    await 1;
-  });
-
-  test('test throwing inside a setTimeout', async () => {
-    await new Promise((resolve, reject) => {
-      setTimeout(() => {
-        resolve();
-        throw new Error('test throwing inside an EventEmitter #FAIL004');
-      }, 0);
-    });
-  });
-
-  test('test throwing inside an async setTimeout', async () => {
-    await new Promise((resolve, reject) => {
-      setTimeout(async () => {
-        await 1;
-        resolve();
-        throw new Error('test throwing inside an EventEmitter #FAIL005');
-      }, 0);
-    });
-  });
-
-
-  test('test throwing inside an async setTimeout no await' , async () => {
-    await new Promise((resolve, reject) => {
-      setTimeout(async () => {
-        resolve();
-        throw new Error('test throwing inside an EventEmitter #FAIL006');
-      }, 0);
-    });
-  });
-
-  `;
-
-  rmSync("/tmp/test-throwing-bun/test-throwing-eventemitter.test.js", {
-    force: true,
-  });
-
-  try {
-    mkdirSync("/tmp/test-throwing-bun", { recursive: true });
-  } catch (e) {}
-  writeFileSync("/tmp/test-throwing-bun/test-throwing-eventemitter.test.js", code);
-
-  const { stderr, exitCode } = spawnSync([bunExe(), "wiptest", "test-throwing-eventemitter"], {
-    cwd: realpathSync("/tmp/test-throwing-bun"),
-    env: bunEnv,
-  });
-
-  const str = stderr!.toString();
-  expect(str).toContain("#FAIL001");
-  expect(str).toContain("#FAIL002");
-  expect(str).toContain("#FAIL003");
-  expect(str).toContain("#FAIL004");
-  expect(str).toContain("#FAIL005");
-  expect(str).toContain("#FAIL006");
-  expect(str).toContain("6 fail");
-  expect(str).toContain("0 pass");
-
-  expect(exitCode).toBe(1);
-});
-
-it("should return non-zero exit code for invalid syntax", async () => {
-  const test_dir = realpathSync(await mkdtemp(join(tmpdir(), "test")));
-  try {
-    await writeFile(join(test_dir, "bad.test.js"), "!!!");
-    const { stdout, stderr, exited } = spawn({
-      cmd: [bunExe(), "test", "bad.test.js"],
-      cwd: test_dir,
-      stdout: null,
-      stdin: "pipe",
-      stderr: "pipe",
-      env: bunEnv,
-    });
-    const err = await new Response(stderr).text();
-    expect(err).toContain("error: Unexpected end of file");
-    expect(err).toContain(" 0 pass");
-    expect(err).toContain(" 1 fail");
-    expect(err).toContain("Ran 1 tests across 1 files");
-    expect(stdout).toBeDefined();
-    expect(await new Response(stdout).text()).toBe("");
-    expect(await exited).toBe(1);
-  } finally {
-    await rm(test_dir, { force: true, recursive: true });
-  }
-});