Reorganize tests (#2332)

1 files changed, 111 insertions, 0 deletions

diff --git a/test/js/node/stream/node-stream-uint8array.test.ts b/test/js/node/stream/node-stream-uint8array.test.ts
new file mode 100644
index 000000000..ec2e95d34
--- /dev/null
+++ b/test/js/node/stream/node-stream-uint8array.test.ts
@@ -0,0 +1,111 @@
+import { beforeEach, describe, expect, it } from "bun:test";
+import { Readable, Writable } from "stream";
+
+const ABC = new Uint8Array([0x41, 0x42, 0x43]);
+const DEF = new Uint8Array([0x44, 0x45, 0x46]);
+const GHI = new Uint8Array([0x47, 0x48, 0x49]);
+
+describe("Writable", () => {
+  let called;
+
+  function logCall(fn, id) {
+    return function () {
+      called[id] = (called[id] || 0) + 1;
+      return fn.apply(this, arguments);
+    };
+  }
+
+  beforeEach(() => {
+    called = [];
+  });
+
+  it("should perform simple operations", () => {
+    let n = 0;
+    const writable = new Writable({
+      write: logCall((chunk, encoding, cb) => {
+        expect(chunk instanceof Buffer).toBe(true);
+        if (n++ === 0) {
+          expect(String(chunk)).toBe("ABC");
+        } else {
+          expect(String(chunk)).toBe("DEF");
+        }
+
+        cb();
+      }, 0),
+    });
+
+    writable.write(ABC);
+    writable.end(DEF);
+    expect(called).toEqual([2]);
+  });
+
+  it("should pass in Uint8Array in object mode", () => {
+    const writable = new Writable({
+      objectMode: true,
+      write: logCall((chunk, encoding, cb) => {
+        expect(chunk instanceof Buffer).toBe(false);
+        expect(chunk instanceof Uint8Array).toBe(true);
+        expect(chunk).toStrictEqual(ABC);
+        expect(encoding).toBe("utf8");
+        cb();
+      }, 0),
+    });
+
+    writable.end(ABC);
+    expect(called).toEqual([1]);
+  });
+
+  it("should handle multiple writes carried out via writev()", () => {
+    let callback;
+
+    const writable = new Writable({
+      write: logCall((chunk, encoding, cb) => {
+        expect(chunk instanceof Buffer).toBe(true);
+        expect(encoding).toBe("buffer");
+        expect(String(chunk)).toBe("ABC");
+        callback = cb;
+      }, 0),
+      writev: logCall((chunks, cb) => {
+        expect(chunks.length).toBe(2);
+        expect(chunks[0].encoding).toBe("buffer");
+        expect(chunks[1].encoding).toBe("buffer");
+        expect(chunks[0].chunk + chunks[1].chunk).toBe("DEFGHI");
+      }, 1),
+    });
+
+    writable.write(ABC);
+    writable.write(DEF);
+    writable.end(GHI);
+    callback();
+    expect(called).toEqual([1, 1]);
+  });
+});
+
+describe("Readable", () => {
+  it("should perform simple operations", () => {
+    const readable = new Readable({
+      read() {},
+    });
+
+    readable.push(DEF);
+    readable.unshift(ABC);
+
+    const buf = readable.read();
+    expect(buf instanceof Buffer).toBe(true);
+    expect([...buf]).toEqual([...ABC, ...DEF]);
+  });
+
+  it("should work with setEncoding()", () => {
+    const readable = new Readable({
+      read() {},
+    });
+
+    readable.setEncoding("utf8");
+
+    readable.push(DEF);
+    readable.unshift(ABC);
+
+    const out = readable.read();
+    expect(out).toBe("ABCDEF");
+  });
+});