1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
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");
});
});
|
