make the test run faster

2 files changed, 91 insertions, 87 deletions

diff --git a/test/bun.js/third-party/napi_create_external/napi-create-external.test.ts b/test/bun.js/third-party/napi_create_external/napi-create-external.test.ts
index 055b488f9..9084b5256 100644
--- a/test/bun.js/third-party/napi_create_external/napi-create-external.test.ts
+++ b/test/bun.js/third-party/napi_create_external/napi-create-external.test.ts
@@ -1,4 +1,5 @@
 import { test, it, describe, expect } from "bun:test";
+import { withoutAggressiveGC } from "gc";
 import * as _ from "lodash";
 
 function rebase(str, inBase, outBase) {
@@ -19,7 +20,7 @@ function rebase(str, inBase, outBase) {
 }
 
 function expectDeepEqual(a, b) {
-  expect(JSON.stringify(a)).toBe(JSON.stringify(b));
+  expect(a).toEqual(b);
 }
 class HashMaker {
   constructor(length) {
@@ -117,83 +118,86 @@ class HashMaker {
 
 const treeClass = require("bktree-fast/native");
 
-for (let keyLen = 64; keyLen <= 512; keyLen += 64) {
-  const hm = new HashMaker(keyLen);
-  describe(`Key length: ${keyLen}`, () => {
-    it("should compute distance", () => {
-      const tree = new treeClass(keyLen);
-      for (const a of hm.data)
-        for (const b of hm.data)
-          expect(tree.distance(a, b)).toBe(hm.distance(a, b));
-    });
-
-    it("should know which keys it has", () => {
-      const tree = new treeClass(keyLen).add(hm.data);
-      expectDeepEqual(
-        hm.data.map((hash) => tree.has(hash)),
-        hm.data.map(() => true),
-      );
-      // Not interested in the hash
-      for (const hash of hm.data) expect(tree.has(hm.randomKey())).toBe(false);
+withoutAggressiveGC(() => {
+  // this test is too slow
+  for (let keyLen = 64; keyLen <= 64; keyLen += 64) {
+    // for (let keyLen = 64; keyLen <= 512; keyLen += 64) {
+    const hm = new HashMaker(keyLen);
+    describe(`Key length: ${keyLen}`, () => {
+      it("should compute distance", () => {
+        const tree = new treeClass(keyLen);
+        for (const a of hm.data)
+          for (const b of hm.data)
+            expect(tree.distance(a, b)).toBe(hm.distance(a, b));
+      });
+
+      it("should know which keys it has", () => {
+        const tree = new treeClass(keyLen).add(hm.data);
+        expectDeepEqual(
+          hm.data.map((hash) => tree.has(hash)),
+          hm.data.map(() => true),
+        );
+        // Not interested in the hash
+        for (const hash of hm.data)
+          expect(tree.has(hm.randomKey())).toBe(false);
+      });
+
+      it("should know the tree size", () => {
+        const tree = new treeClass(keyLen, { foo: 1 });
+        expect(tree.size).toBe(0);
+        tree.add(hm.data);
+        expect(tree.size).toBe(hm.data.length);
+        tree.add(hm.data);
+        expect(tree.size).toBe(hm.data.length);
+      });
+
+      it("should walk the tree", () => {
+        const tree = new treeClass(keyLen).add(hm.data);
+        const got = [];
+        tree.walk((hash, depth) => got.push(hash));
+        expectDeepEqual(got.sort(), hm.data.slice(0).sort());
+      });
+
+      it("should query", () => {
+        ((treeClass, expectDeepEqual) => {
+          const tree = new treeClass(keyLen).add(hm.data);
+
+          for (let dist = 0; dist <= hm.length; dist++) {
+            for (const baseKey of [hm.random, hm.data[0]]) {
+              const baseKey = hm.random;
+              const got = [];
+              tree.query(baseKey, dist, (key, distance) =>
+                got.push({ key, distance }),
+              );
+              const want = hm.query(baseKey, dist);
+              expectDeepEqual(
+                got.sort((a, b) => a.distance - b.distance),
+                want,
+              );
+              expectDeepEqual(tree.find(baseKey, dist), want);
+            }
+          }
+        })(treeClass, expectDeepEqual);
+      });
     });
+  }
 
-    it("should know the tree size", () => {
-      const tree = new treeClass(keyLen, { foo: 1 });
-      expect(tree.size).toBe(0);
-      tree.add(hm.data);
-      expect(tree.size).toBe(hm.data.length);
-      tree.add(hm.data);
-      expect(tree.size).toBe(hm.data.length);
-    });
+  describe("Misc functions", () => {
+    it("should pad keys", () => {
+      const tree = new treeClass(64);
+      expect(tree.padKey("1")).toBe("0000000000000001");
+      tree.add(["1", "2", "3"]);
 
-    it("should walk the tree", () => {
-      const tree = new treeClass(keyLen).add(hm.data);
       const got = [];
-      tree.walk((hash, depth) => got.push(hash));
-      expectDeepEqual(got.sort(), hm.data.slice(0).sort());
+      tree.query("2", 3, (hash, distance) => got.push({ hash, distance }));
+      const res = got.sort((a, b) => a.distance - b.distance);
+      const want = [
+        { hash: "0000000000000002", distance: 0 },
+        { hash: "0000000000000003", distance: 1 },
+        { hash: "0000000000000001", distance: 2 },
+      ];
+
+      expectDeepEqual(res, want);
     });
-
-    it("should query", () => {
-      Bun.gc(true);
-      ((treeClass, expectDeepEqual) => {
-        const tree = new treeClass(keyLen).add(hm.data);
-
-        for (let dist = 0; dist <= hm.length; dist++) {
-          for (const baseKey of [hm.random, hm.data[0]]) {
-            const baseKey = hm.random;
-            const got = [];
-            tree.query(baseKey, dist, (key, distance) =>
-              got.push({ key, distance }),
-            );
-            const want = hm.query(baseKey, dist);
-            expectDeepEqual(
-              got.sort((a, b) => a.distance - b.distance),
-              want,
-            );
-            expectDeepEqual(tree.find(baseKey, dist), want);
-          }
-        }
-      })(treeClass, expectDeepEqual);
-      Bun.gc(true);
-    });
-  });
-}
-
-describe("Misc functions", () => {
-  it("should pad keys", () => {
-    const tree = new treeClass(64);
-    expect(tree.padKey("1")).toBe("0000000000000001");
-    tree.add(["1", "2", "3"]);
-
-    const got = [];
-    tree.query("2", 3, (hash, distance) => got.push({ hash, distance }));
-    const res = got.sort((a, b) => a.distance - b.distance);
-    const want = [
-      { hash: "0000000000000002", distance: 0 },
-      { hash: "0000000000000003", distance: 1 },
-      { hash: "0000000000000001", distance: 2 },
-    ];
-
-    expectDeepEqual(res, want);
   });
 });
diff --git a/test/bun.js/websocket-server.test.ts b/test/bun.js/websocket-server.test.ts
index f7ef016ca..e25429b05 100644
--- a/test/bun.js/websocket-server.test.ts
+++ b/test/bun.js/websocket-server.test.ts
@@ -524,6 +524,7 @@ describe("websocket server", () => {
 
   it("publishText()", async () => {
     await new Promise<void>((resolve, reject) => {
+      var websocket;
       var server = serve({
         port: getPort(),
         websocket: {
@@ -531,6 +532,7 @@ describe("websocket server", () => {
             // we don't care about the data
             // we just want to make sure the DOMJIT call doesn't crash
             for (let i = 0; i < 40_000; i++) ws.publishText("hello", "world");
+            websocket.close();
             resolve();
           },
           message(ws, msg) {},
@@ -543,15 +545,15 @@ describe("websocket server", () => {
         },
       });
 
-      const websocket = new WebSocket(`ws://${server.hostname}:${server.port}`);
-      websocket.onmessage = () => {};
-      websocket.onerror = () => {};
+      websocket = new WebSocket(`ws://${server.hostname}:${server.port}`);
     });
   });
 
   it("publishBinary()", async () => {
     const bytes = Buffer.from("hello");
+
     await new Promise<void>((resolve, reject) => {
+      var websocket;
       var server = serve({
         port: getPort(),
         websocket: {
@@ -560,6 +562,7 @@ describe("websocket server", () => {
             // we just want to make sure the DOMJIT call doesn't crash
             for (let i = 0; i < 40_000; i++) ws.publishBinary("hello", bytes);
             resolve();
+            websocket.close();
           },
           message(ws, msg) {},
         },
@@ -571,14 +574,13 @@ describe("websocket server", () => {
         },
       });
 
-      const websocket = new WebSocket(`ws://${server.hostname}:${server.port}`);
-      websocket.onmessage = () => {};
-      websocket.onerror = () => {};
+      websocket = new WebSocket(`ws://${server.hostname}:${server.port}`);
     });
   });
 
   it("sendText()", async () => {
     await new Promise<void>((resolve, reject) => {
+      var websocket;
       var server = serve({
         port: getPort(),
         websocket: {
@@ -587,6 +589,7 @@ describe("websocket server", () => {
             // we just want to make sure the DOMJIT call doesn't crash
             for (let i = 0; i < 40_000; i++) ws.sendText("hello world", true);
             resolve();
+            websocket.close();
           },
           message(ws, msg) {},
         },
@@ -597,16 +600,14 @@ describe("websocket server", () => {
           return new Response("noooooo hello world");
         },
       });
-
-      const websocket = new WebSocket(`ws://${server.hostname}:${server.port}`);
-      websocket.onmessage = () => {};
-      websocket.onerror = () => {};
+      websocket = new WebSocket(`ws://${server.hostname}:${server.port}`);
     });
   });
 
   it("sendBinary()", async () => {
     const bytes = Buffer.from("hello");
     await new Promise<void>((resolve, reject) => {
+      var websocket;
       var server = serve({
         port: getPort(),
         websocket: {
@@ -614,6 +615,7 @@ describe("websocket server", () => {
             // we don't care about the data
             // we just want to make sure the DOMJIT call doesn't crash
             for (let i = 0; i < 40_000; i++) ws.sendBinary(bytes, true);
+            websocket.close();
             resolve();
           },
           message(ws, msg) {},
@@ -626,9 +628,7 @@ describe("websocket server", () => {
         },
       });
 
-      const websocket = new WebSocket(`ws://${server.hostname}:${server.port}`);
-      websocket.onmessage = () => {};
-      websocket.onerror = () => {};
+      websocket = new WebSocket(`ws://${server.hostname}:${server.port}`);
     });
   });