From 153620d53c13b6900ca26218763784a6d566cb90 Mon Sep 17 00:00:00 2001
From: alexlamsl <alexlamsl@gmail.com>
Date: Tue, 20 Dec 2022 12:35:46 +0200
Subject: [PATCH] add tests for #1633 - `setImmediate(fn, ...args)` -
 `setInterval(fn, delay, ...args)` - `setTimeout(fn, delay, ...args)`

---
 test/bun.js/setImmediate.test.js | 47 ++++++++++++++++++++++++++++++++
 test/bun.js/setInterval.test.js  | 11 ++++++--
 test/bun.js/setTimeout.test.js   | 22 +++++++++------
 3 files changed, 69 insertions(+), 11 deletions(-)
 create mode 100644 test/bun.js/setImmediate.test.js

diff --git a/test/bun.js/setImmediate.test.js b/test/bun.js/setImmediate.test.js
new file mode 100644
index 0000000000000..9cd6fa1c99d01
--- /dev/null
+++ b/test/bun.js/setImmediate.test.js
@@ -0,0 +1,47 @@
+import { it, expect } from "bun:test";
+
+it("setImmediate", async () => {
+  var lastID = -1;
+  const result = await new Promise((resolve, reject) => {
+    var numbers = [];
+
+    for (let i = 0; i < 10; i++) {
+      const id = setImmediate((...args) => {
+        numbers.push(i);
+        if (i === 9) {
+          resolve(numbers);
+        }
+        try {
+          expect(args.length).toBe(1);
+          expect(args[0]).toBe(i);
+        } catch (err) {
+          reject(err);
+        }
+      }, i);
+      expect(id > lastID).toBe(true);
+      lastID = id;
+    }
+  });
+
+  for (let j = 0; j < result.length; j++) {
+    expect(result[j]).toBe(j);
+  }
+  expect(result.length).toBe(10);
+});
+
+it("clearImmediate", async () => {
+  var called = false;
+  const id = setImmediate(() => {
+    called = true;
+    expect(false).toBe(true);
+  });
+  clearImmediate(id);
+
+  // assert it doesn't crash if you call clearImmediate twice
+  clearImmediate(id);
+
+  await new Promise((resolve, reject) => {
+    setImmediate(resolve);
+  });
+  expect(called).toBe(false);
+});
diff --git a/test/bun.js/setInterval.test.js b/test/bun.js/setInterval.test.js
index de219b92f4e1e..57ee54aa0891a 100644
--- a/test/bun.js/setInterval.test.js
+++ b/test/bun.js/setInterval.test.js
@@ -6,13 +6,20 @@ it("setInterval", async () => {
   const result = await new Promise((resolve, reject) => {
     start = performance.now();
 
-    var id = setInterval(() => {
+    var id = setInterval((...args) => {
       counter++;
       if (counter === 10) {
         resolve(counter);
         clearInterval(id);
       }
-    }, 1);
+      try {
+        expect(args.length).toBe(1);
+        expect(args[0]).toBe("foo");
+      } catch (err) {
+        reject(err);
+        clearInterval(id);
+      }
+    }, 1, "foo");
   });
 
   expect(result).toBe(10);
diff --git a/test/bun.js/setTimeout.test.js b/test/bun.js/setTimeout.test.js
index a899867df7519..015bb1d7b896a 100644
--- a/test/bun.js/setTimeout.test.js
+++ b/test/bun.js/setTimeout.test.js
@@ -5,22 +5,28 @@ it("setTimeout", async () => {
   const result = await new Promise((resolve, reject) => {
     var numbers = [];
 
-    for (let i = 1; i < 100; i++) {
-      const id = setTimeout(() => {
+    for (let i = 0; i < 10; i++) {
+      const id = setTimeout((...args) => {
         numbers.push(i);
-        if (i === 99) {
+        if (i === 9) {
           resolve(numbers);
         }
-      }, i);
+        try {
+          expect(args.length).toBe(1);
+          expect(args[0]).toBe("foo");
+        } catch (err) {
+          reject(err);
+        }
+      }, i, "foo");
       expect(id > lastID).toBe(true);
       lastID = id;
     }
   });
 
   for (let j = 0; j < result.length; j++) {
-    expect(result[j]).toBe(j + 1);
+    expect(result[j]).toBe(j);
   }
-  expect(result.length).toBe(99);
+  expect(result.length).toBe(10);
 });
 
 it("clearTimeout", async () => {
@@ -35,9 +41,7 @@ it("clearTimeout", async () => {
   clearTimeout(id);
 
   await new Promise((resolve, reject) => {
-    setTimeout(() => {
-      resolve();
-    }, 10);
+    setTimeout(resolve, 10);
   });
   expect(called).toBe(false);
 });