summaryrefslogtreecommitdiff
path: root/cli/tests/unit_node
diff options
context:
space:
mode:
Diffstat (limited to 'cli/tests/unit_node')
-rw-r--r--cli/tests/unit_node/_fs/_fs_read_test.ts21
-rw-r--r--cli/tests/unit_node/async_hooks_test.ts13
-rw-r--r--cli/tests/unit_node/child_process_test.ts147
-rw-r--r--cli/tests/unit_node/events_test.ts5
-rw-r--r--cli/tests/unit_node/http2_test.ts25
-rw-r--r--cli/tests/unit_node/http_test.ts163
-rw-r--r--cli/tests/unit_node/internal/_randomFill_test.ts5
-rw-r--r--cli/tests/unit_node/internal/scrypt_test.ts9
-rw-r--r--cli/tests/unit_node/net_test.ts43
-rw-r--r--cli/tests/unit_node/process_test.ts5
-rw-r--r--cli/tests/unit_node/tls_test.ts7
-rw-r--r--cli/tests/unit_node/zlib_test.ts9
12 files changed, 221 insertions, 231 deletions
diff --git a/cli/tests/unit_node/_fs/_fs_read_test.ts b/cli/tests/unit_node/_fs/_fs_read_test.ts
index 34b029d9f..3ca303037 100644
--- a/cli/tests/unit_node/_fs/_fs_read_test.ts
+++ b/cli/tests/unit_node/_fs/_fs_read_test.ts
@@ -10,7 +10,6 @@ import { open, openSync } from "node:fs";
import { Buffer } from "node:buffer";
import * as path from "../../../../test_util/std/path/mod.ts";
import { closeSync } from "node:fs";
-import { deferred } from "../../../../test_util/std/async/deferred.ts";
async function readTest(
testData: string,
@@ -132,7 +131,7 @@ Deno.test({
Deno.test({
name: "[std/node/fs] Read fs.read(fd, options, cb) signature",
async fn() {
- const promise = deferred();
+ const { promise, reject, resolve } = Promise.withResolvers<void>();
const file = Deno.makeTempFileSync();
Deno.writeTextFileSync(file, "hi there");
const fd = openSync(file, "r+");
@@ -154,10 +153,10 @@ Deno.test({
Buffer.from([104, 105, 32, 116, 104, 101, 114, 101, 0, 0, 0]),
);
} catch (e) {
- promise.reject(e);
+ reject(e);
return;
}
- promise.resolve();
+ resolve();
},
);
closeSync(fd);
@@ -168,7 +167,7 @@ Deno.test({
Deno.test({
name: "[std/node/fs] Read fs.read(fd, cb) signature",
async fn() {
- const promise = deferred();
+ const { promise, resolve, reject } = Promise.withResolvers<void>();
const file = Deno.makeTempFileSync();
Deno.writeTextFileSync(file, "hi deno");
const fd = openSync(file, "r+");
@@ -178,10 +177,10 @@ Deno.test({
assertStrictEquals(bytesRead, 7);
assertStrictEquals(data?.byteLength, 16384);
} catch (e) {
- promise.reject(e);
+ reject(e);
return;
}
- promise.resolve();
+ resolve();
});
closeSync(fd);
await promise;
@@ -277,27 +276,27 @@ Deno.test({
await Deno.writeTextFile(file, "abc");
await t.step("without position option", async () => {
- const promise = deferred<void>();
+ const { promise, resolve } = Promise.withResolvers<void>();
let called = false;
const fd = openSync(file, "r");
read(fd, () => {
called = true;
closeSync(fd);
- promise.resolve();
+ resolve();
});
assertFalse(called);
await promise;
});
await t.step("with position option", async () => {
- const promise = deferred<void>();
+ const { promise, resolve } = Promise.withResolvers<void>();
let called = false;
const buffer = Buffer.alloc(2);
const fd = openSync(file, "r");
read(fd, { position: 1, buffer, offset: 0, length: 2 }, () => {
called = true;
closeSync(fd);
- promise.resolve();
+ resolve();
});
assertFalse(called);
await promise;
diff --git a/cli/tests/unit_node/async_hooks_test.ts b/cli/tests/unit_node/async_hooks_test.ts
index 871ad85f9..035e970d4 100644
--- a/cli/tests/unit_node/async_hooks_test.ts
+++ b/cli/tests/unit_node/async_hooks_test.ts
@@ -4,7 +4,6 @@ import {
assert,
assertEquals,
} from "../../../test_util/std/testing/asserts.ts";
-import { deferred } from "../../../test_util/std/async/deferred.ts";
Deno.test(async function foo() {
const asyncLocalStorage = new AsyncLocalStorage();
@@ -68,16 +67,16 @@ Deno.test(async function bar() {
Deno.test(async function nested() {
const als = new AsyncLocalStorage();
- const promise = deferred();
- const promise1 = deferred();
+ const deferred = Promise.withResolvers();
+ const deferred1 = Promise.withResolvers();
als.run(null, () => {
als.run({ x: 1 }, () => {
- promise.resolve(als.getStore());
+ deferred.resolve(als.getStore());
});
- promise1.resolve(als.getStore());
+ deferred1.resolve(als.getStore());
});
- assertEquals(await promise, { x: 1 });
- assertEquals(await promise1, null);
+ assertEquals(await deferred.promise, { x: 1 });
+ assertEquals(await deferred1.promise, null);
});
diff --git a/cli/tests/unit_node/child_process_test.ts b/cli/tests/unit_node/child_process_test.ts
index 47e87096e..d226319e6 100644
--- a/cli/tests/unit_node/child_process_test.ts
+++ b/cli/tests/unit_node/child_process_test.ts
@@ -10,45 +10,46 @@ import {
assertStrictEquals,
assertStringIncludes,
} from "../../../test_util/std/testing/asserts.ts";
-import { Deferred, deferred } from "../../../test_util/std/async/deferred.ts";
import * as path from "../../../test_util/std/path/mod.ts";
const { spawn, spawnSync, execFile, execFileSync, ChildProcess } = CP;
-function withTimeout<T>(timeoutInMS = 10_000): Deferred<T> {
- const promise = deferred<T>();
+function withTimeout<T>(
+ timeoutInMS = 10_000,
+): ReturnType<typeof Promise.withResolvers<T>> {
+ const deferred = Promise.withResolvers<T>();
const timer = setTimeout(() => {
- promise.reject("Timeout");
+ deferred.reject("Timeout");
}, timeoutInMS);
- promise.then(() => {
+ deferred.promise.then(() => {
clearTimeout(timer);
});
- return promise;
+ return deferred;
}
// TODO(uki00a): Once Node.js's `parallel/test-child-process-spawn-error.js` works, this test case should be removed.
Deno.test("[node/child_process spawn] The 'error' event is emitted when no binary is found", async () => {
- const promise = withTimeout();
+ const deferred = withTimeout<void>();
const childProcess = spawn("no-such-cmd");
childProcess.on("error", (_err: Error) => {
// TODO(@bartlomieju) Assert an error message.
- promise.resolve();
+ deferred.resolve();
});
- await promise;
+ await deferred.promise;
});
Deno.test("[node/child_process spawn] The 'exit' event is emitted with an exit code after the child process ends", async () => {
- const promise = withTimeout();
+ const deferred = withTimeout<void>();
const childProcess = spawn(Deno.execPath(), ["--help"], {
env: { NO_COLOR: "true" },
});
try {
let exitCode = null;
childProcess.on("exit", (code: number) => {
- promise.resolve();
+ deferred.resolve();
exitCode = code;
});
- await promise;
+ await deferred.promise;
assertStrictEquals(exitCode, 0);
assertStrictEquals(childProcess.exitCode, exitCode);
} finally {
@@ -59,16 +60,16 @@ Deno.test("[node/child_process spawn] The 'exit' event is emitted with an exit c
});
Deno.test("[node/child_process disconnect] the method exists", async () => {
- const promise = withTimeout();
+ const deferred = withTimeout<void>();
const childProcess = spawn(Deno.execPath(), ["--help"], {
env: { NO_COLOR: "true" },
});
try {
childProcess.disconnect();
childProcess.on("exit", () => {
- promise.resolve();
+ deferred.resolve();
});
- await promise;
+ await deferred.promise;
} finally {
childProcess.kill();
childProcess.stdout?.destroy();
@@ -79,7 +80,7 @@ Deno.test("[node/child_process disconnect] the method exists", async () => {
Deno.test({
name: "[node/child_process spawn] Verify that stdin and stdout work",
fn: async () => {
- const promise = withTimeout();
+ const deferred = withTimeout<void>();
const childProcess = spawn(Deno.execPath(), ["fmt", "-"], {
env: { NO_COLOR: "true" },
stdio: ["pipe", "pipe"],
@@ -94,9 +95,9 @@ Deno.test({
childProcess.stdin.write(" console.log('hello')", "utf-8");
childProcess.stdin.end();
childProcess.on("close", () => {
- promise.resolve();
+ deferred.resolve();
});
- await promise;
+ await deferred.promise;
assertStrictEquals(data, `console.log("hello");\n`);
} finally {
childProcess.kill();
@@ -107,7 +108,7 @@ Deno.test({
Deno.test({
name: "[node/child_process spawn] stdin and stdout with binary data",
fn: async () => {
- const promise = withTimeout();
+ const deferred = withTimeout<void>();
const p = path.join(
path.dirname(path.fromFileUrl(import.meta.url)),
"./testdata/binary_stdio.js",
@@ -127,9 +128,9 @@ Deno.test({
childProcess.stdin.write(buffer);
childProcess.stdin.end();
childProcess.on("close", () => {
- promise.resolve();
+ deferred.resolve();
});
- await promise;
+ await deferred.promise;
assertEquals(new Uint8Array(data!), buffer);
} finally {
childProcess.kill();
@@ -140,7 +141,7 @@ Deno.test({
async function spawnAndGetEnvValue(
inputValue: string | number | boolean,
): Promise<string> {
- const promise = withTimeout<string>();
+ const deferred = withTimeout<string>();
const env = spawn(
`"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`,
{
@@ -152,14 +153,14 @@ async function spawnAndGetEnvValue(
let envOutput = "";
assert(env.stdout);
- env.on("error", (err: Error) => promise.reject(err));
+ env.on("error", (err: Error) => deferred.reject(err));
env.stdout.on("data", (data) => {
envOutput += data;
});
env.on("close", () => {
- promise.resolve(envOutput.trim());
+ deferred.resolve(envOutput.trim());
});
- return await promise;
+ return await deferred.promise;
} finally {
env.kill();
}
@@ -191,7 +192,7 @@ Deno.test({
// TODO(uki00a): Remove this case once Node's `parallel/test-child-process-spawn-event.js` works.
Deno.test("[child_process spawn] 'spawn' event", async () => {
- const timeout = withTimeout();
+ const timeout = withTimeout<void>();
const subprocess = spawn(Deno.execPath(), ["eval", "console.log('ok')"]);
let didSpawn = false;
@@ -205,13 +206,13 @@ Deno.test("[child_process spawn] 'spawn' event", async () => {
const promises = [] as Promise<void>[];
function mustBeCalledAfterSpawn() {
- const promise = deferred<void>();
- promises.push(promise);
+ const deferred = Promise.withResolvers<void>();
+ promises.push(deferred.promise);
return () => {
if (didSpawn) {
- promise.resolve();
+ deferred.resolve();
} else {
- promise.reject(
+ deferred.reject(
new Error("function should be called after the 'spawn' event"),
);
}
@@ -229,7 +230,7 @@ Deno.test("[child_process spawn] 'spawn' event", async () => {
subprocess.on("close", mustBeCalledAfterSpawn());
try {
- await Promise.race([Promise.all(promises), timeout]);
+ await Promise.race([Promise.all(promises), timeout.promise]);
timeout.resolve();
} finally {
subprocess.kill();
@@ -238,12 +239,12 @@ Deno.test("[child_process spawn] 'spawn' event", async () => {
// TODO(uki00a): Remove this case once Node's `parallel/test-child-process-spawn-shell.js` works.
Deno.test("[child_process spawn] Verify that a shell is executed", async () => {
- const promise = withTimeout();
+ const deferred = withTimeout<void>();
const doesNotExist = spawn("does-not-exist", { shell: true });
try {
assertNotStrictEquals(doesNotExist.spawnfile, "does-not-exist");
doesNotExist.on("error", () => {
- promise.reject("The 'error' event must not be emitted.");
+ deferred.reject("The 'error' event must not be emitted.");
});
doesNotExist.on("exit", (code: number, signal: null) => {
assertStrictEquals(signal, null);
@@ -254,9 +255,9 @@ Deno.test("[child_process spawn] Verify that a shell is executed", async () => {
assertStrictEquals(code, 127); // Exit code of /bin/sh });
}
- promise.resolve();
+ deferred.resolve();
});
- await promise;
+ await deferred.promise;
} finally {
doesNotExist.kill();
doesNotExist.stdout?.destroy();
@@ -269,7 +270,7 @@ Deno.test({
ignore: Deno.build.os === "windows",
name: "[node/child_process spawn] Verify that passing arguments works",
async fn() {
- const promise = withTimeout();
+ const deferred = withTimeout<void>();
const echo = spawn("echo", ["foo"], {
shell: true,
});
@@ -286,9 +287,9 @@ Deno.test({
});
echo.on("close", () => {
assertStrictEquals(echoOutput.trim(), "foo");
- promise.resolve();
+ deferred.resolve();
});
- await promise;
+ await deferred.promise;
} finally {
echo.kill();
}
@@ -300,7 +301,7 @@ Deno.test({
ignore: Deno.build.os === "windows",
name: "[node/child_process spawn] Verity that shell features can be used",
async fn() {
- const promise = withTimeout();
+ const deferred = withTimeout<void>();
const cmd = "echo bar | cat";
const command = spawn(cmd, {
shell: true,
@@ -315,10 +316,10 @@ Deno.test({
command.on("close", () => {
assertStrictEquals(commandOutput.trim(), "bar");
- promise.resolve();
+ deferred.resolve();
});
- await promise;
+ await deferred.promise;
} finally {
command.kill();
}
@@ -331,7 +332,7 @@ Deno.test({
name:
"[node/child_process spawn] Verity that environment is properly inherited",
async fn() {
- const promise = withTimeout();
+ const deferred = withTimeout<void>();
const env = spawn(
`"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`,
{
@@ -343,15 +344,15 @@ Deno.test({
let envOutput = "";
assert(env.stdout);
- env.on("error", (err: Error) => promise.reject(err));
+ env.on("error", (err: Error) => deferred.reject(err));
env.stdout.on("data", (data) => {
envOutput += data;
});
env.on("close", () => {
assertStrictEquals(envOutput.trim(), "buzz");
- promise.resolve();
+ deferred.resolve();
});
- await promise;
+ await deferred.promise;
} finally {
env.kill();
}
@@ -496,16 +497,16 @@ Deno.test({
"./testdata/infinite_loop.js",
);
const childProcess = spawn(Deno.execPath(), ["run", script]);
- const p = withTimeout();
- const pStdout = withTimeout();
- const pStderr = withTimeout();
+ const p = withTimeout<void>();
+ const pStdout = withTimeout<void>();
+ const pStderr = withTimeout<void>();
childProcess.on("exit", () => p.resolve());
childProcess.stdout.on("close", () => pStdout.resolve());
childProcess.stderr.on("close", () => pStderr.resolve());
childProcess.kill("SIGKILL");
- await p;
- await pStdout;
- await pStderr;
+ await p.promise;
+ await pStdout.promise;
+ await pStderr.promise;
assert(childProcess.killed);
assertEquals(childProcess.signalCode, "SIGKILL");
assertExists(childProcess.exitCode);
@@ -527,9 +528,9 @@ Deno.test({
"--unstable",
script,
]);
- const p = deferred();
- childProcess.on("exit", () => p.resolve());
- await p;
+ const deferred = Promise.withResolvers<void>();
+ childProcess.on("exit", () => deferred.resolve());
+ await deferred.promise;
},
});
@@ -547,14 +548,14 @@ Deno.test({
"foo",
"index.js",
);
- const p = deferred();
+ const p = Promise.withResolvers<void>();
const cp = CP.fork(script, [], { cwd: testdataDir, stdio: "pipe" });
let output = "";
cp.on("close", () => p.resolve());
cp.stdout?.on("data", (data) => {
output += data;
});
- await p;
+ await p.promise;
assertEquals(output, "foo\ntrue\ntrue\ntrue\n");
},
});
@@ -567,7 +568,7 @@ Deno.test(
"[node/child_process spawn] supports windowsVerbatimArguments option",
{ ignore: Deno.build.os !== "windows" },
async () => {
- const cmdFinished = deferred();
+ const cmdFinished = Promise.withResolvers<void>();
let output = "";
const cp = spawn("cmd", ["/d", "/s", "/c", '"deno ^"--version^""'], {
stdio: "pipe",
@@ -577,7 +578,7 @@ Deno.test(
cp.stdout?.on("data", (data) => {
output += data;
});
- await cmdFinished;
+ await cmdFinished.promise;
assertStringIncludes(output, "deno");
assertStringIncludes(output, "v8");
assertStringIncludes(output, "typescript");
@@ -587,7 +588,7 @@ Deno.test(
Deno.test(
"[node/child_process spawn] supports stdio array option",
async () => {
- const cmdFinished = deferred();
+ const cmdFinished = Promise.withResolvers<void>();
let output = "";
const script = path.join(
path.dirname(path.fromFileUrl(import.meta.url)),
@@ -599,7 +600,7 @@ Deno.test(
output += data;
});
cp.on("close", () => cmdFinished.resolve());
- await cmdFinished;
+ await cmdFinished.promise;
assertStringIncludes(output, "foo");
assertStringIncludes(output, "close");
@@ -609,7 +610,7 @@ Deno.test(
Deno.test(
"[node/child_process spawn] supports stdio [0, 1, 2] option",
async () => {
- const cmdFinished = deferred();
+ const cmdFinished = Promise.withResolvers<void>();
let output = "";
const script = path.join(
path.dirname(path.fromFileUrl(import.meta.url)),
@@ -621,7 +622,7 @@ Deno.test(
output += data;
});
cp.on("close", () => cmdFinished.resolve());
- await cmdFinished;
+ await cmdFinished.promise;
assertStringIncludes(output, "foo");
assertStringIncludes(output, "close");
@@ -638,16 +639,16 @@ Deno.test({
// Spawn an infinite cat
const cp = spawn("cat", ["-"]);
- const p = withTimeout();
- const pStdout = withTimeout();
- const pStderr = withTimeout();
+ const p = withTimeout<void>();
+ const pStdout = withTimeout<void>();
+ const pStderr = withTimeout<void>();
cp.on("exit", () => p.resolve());
cp.stdout.on("close", () => pStdout.resolve());
cp.stderr.on("close", () => pStderr.resolve());
cp.kill("SIGIOT");
- await p;
- await pStdout;
- await pStderr;
+ await p.promise;
+ await pStdout.promise;
+ await pStderr.promise;
assert(cp.killed);
assertEquals(cp.signalCode, "SIGIOT");
},
@@ -655,7 +656,7 @@ Deno.test({
// Regression test for https://github.com/denoland/deno/issues/20373
Deno.test(async function undefinedValueInEnvVar() {
- const promise = withTimeout<string>();
+ const deferred = withTimeout<string>();
const env = spawn(
`"${Deno.execPath()}" eval -p "Deno.env.toObject().BAZ"`,
{
@@ -673,18 +674,18 @@ Deno.test(async function undefinedValueInEnvVar() {
let envOutput = "";
assert(env.stdout);
- env.on("error", (err: Error) => promise.reject(err));
+ env.on("error", (err: Error) => deferred.reject(err));
env.stdout.on("data", (data) => {
envOutput += data;
});
env.on("close", () => {
- promise.resolve(envOutput.trim());
+ deferred.resolve(envOutput.trim());
});
- await promise;
+ await deferred.promise;
} finally {
env.kill();
}
- const value = await promise;
+ const value = await deferred.promise;
assertEquals(value, "BAZ");
});
diff --git a/cli/tests/unit_node/events_test.ts b/cli/tests/unit_node/events_test.ts
index e341a17cb..6c447f05d 100644
--- a/cli/tests/unit_node/events_test.ts
+++ b/cli/tests/unit_node/events_test.ts
@@ -1,12 +1,11 @@
// Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
-import { deferred } from "../../../test_util/std/async/deferred.ts";
import { EventEmitter } from "node:events";
EventEmitter.captureRejections = true;
Deno.test("regression #20441", async () => {
- const promise = deferred();
+ const { promise, resolve } = Promise.withResolvers<void>();
const ee = new EventEmitter();
@@ -20,7 +19,7 @@ Deno.test("regression #20441", async () => {
});
ee.on("error", function (_) {
- promise.resolve();
+ resolve();
});
ee.emit("foo");
diff --git a/cli/tests/unit_node/http2_test.ts b/cli/tests/unit_node/http2_test.ts
index d0e0de43f..87ad6c748 100644
--- a/cli/tests/unit_node/http2_test.ts
+++ b/cli/tests/unit_node/http2_test.ts
@@ -2,7 +2,6 @@
import * as http2 from "node:http2";
import * as net from "node:net";
-import { deferred } from "../../../test_util/std/async/deferred.ts";
import { assertEquals } from "../../../test_util/std/testing/asserts.ts";
for (const url of ["http://127.0.0.1:4246", "https://127.0.0.1:4247"]) {
@@ -41,17 +40,17 @@ for (const url of ["http://127.0.0.1:4246", "https://127.0.0.1:4247"]) {
});
req.end();
- const endPromise = deferred();
+ const { promise, resolve } = Promise.withResolvers<void>();
setTimeout(() => {
try {
client.close();
} catch (_) {
// pass
}
- endPromise.resolve();
+ resolve();
}, 2000);
- await endPromise;
+ await promise;
assertEquals(receivedHeaders, { ":status": 200 });
assertEquals(receivedData, "hello world\n");
@@ -67,14 +66,14 @@ Deno.test(`[node/http2 client createConnection]`, {
ignore: Deno.build.os === "windows",
}, async () => {
const url = "http://127.0.0.1:4246";
- const createConnPromise = deferred();
+ const createConnDeferred = Promise.withResolvers<void>();
// Create a server to respond to the HTTP2 requests
const client = http2.connect(url, {
createConnection() {
const socket = net.connect({ host: "127.0.0.1", port: 4246 });
socket.on("connect", () => {
- createConnPromise.resolve();
+ createConnDeferred.resolve();
});
return socket;
@@ -94,7 +93,7 @@ Deno.test(`[node/http2 client createConnection]`, {
});
req.end();
- const endPromise = deferred();
+ const endPromise = Promise.withResolvers<void>();
setTimeout(() => {
try {
client.close();
@@ -104,8 +103,8 @@ Deno.test(`[node/http2 client createConnection]`, {
endPromise.resolve();
}, 2000);
- await createConnPromise;
- await endPromise;
+ await createConnDeferred.promise;
+ await endPromise.promise;
assertEquals(receivedData, "hello world\n");
});
@@ -127,11 +126,9 @@ Deno.test("[node/http2 server]", { sanitizeOps: false }, async () => {
const stream = await new Promise<http2.ServerHttp2Stream>((resolve) =>
session.on("stream", resolve)
);
- const _headers = await new Promise((resolve) =>
- stream.on("headers", resolve)
- );
- const _data = await new Promise((resolve) => stream.on("data", resolve));
- const _end = await new Promise((resolve) => stream.on("end", resolve));
+ await new Promise((resolve) => stream.on("headers", resolve));
+ await new Promise((resolve) => stream.on("data", resolve));
+ await new Promise((resolve) => stream.on("end", resolve));
stream.respond();
stream.end();
const resp = await responsePromise;
diff --git a/cli/tests/unit_node/http_test.ts b/cli/tests/unit_node/http_test.ts
index 84d25e42c..ef78432cb 100644
--- a/cli/tests/unit_node/http_test.ts
+++ b/cli/tests/unit_node/http_test.ts
@@ -9,7 +9,6 @@ import {
fail,
} from "../../../test_util/std/testing/asserts.ts";
import { assertSpyCalls, spy } from "../../../test_util/std/testing/mock.ts";
-import { deferred } from "../../../test_util/std/async/deferred.ts";
import { gzip } from "node:zlib";
import { Buffer } from "node:buffer";
@@ -28,42 +27,42 @@ Deno.test("[node/http listen]", async () => {
}
{
- const promise = deferred<void>();
+ const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer();
server.listen(() => {
server.close();
});
server.on("close", () => {
- promise.resolve();
+ resolve();
});
await promise;
}
{
- const promise = deferred<void>();
+ const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer();
server.listen().on("listening", () => {
server.close();
});
server.on("close", () => {
- promise.resolve();
+ resolve();
});
await promise;
}
for (const port of [0, -0, 0.0, "0", null, undefined]) {
- const promise = deferred<void>();
+ const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer();
server.listen(port, () => {
server.close();
});
server.on("close", () => {
- promise.resolve();
+ resolve();
});
await promise;
@@ -72,43 +71,43 @@ Deno.test("[node/http listen]", async () => {
Deno.test("[node/http close]", async () => {
{
- const promise1 = deferred<void>();
- const promise2 = deferred<void>();
+ const deferred1 = Promise.withResolvers<void>();
+ const deferred2 = Promise.withResolvers<void>();
// Node quirk: callback gets exception object, event listener does not.
// deno-lint-ignore no-explicit-any
const server = http.createServer().close((err: any) => {
assertEquals(err.code, "ERR_SERVER_NOT_RUNNING");
- promise1.resolve();
+ deferred1.resolve();
});
// deno-lint-ignore no-explicit-any
server.on("close", (err: any) => {
assertEquals(err, undefined);
- promise2.resolve();
+ deferred2.resolve();
});
server.on("listening", () => {
throw Error("unreachable");
});
- await promise1;
- await promise2;
+ await deferred1.promise;
+ await deferred2.promise;
}
{
- const promise1 = deferred<void>();
- const promise2 = deferred<void>();
+ const deferred1 = Promise.withResolvers<void>();
+ const deferred2 = Promise.withResolvers<void>();
const server = http.createServer().listen().close((err) => {
assertEquals(err, undefined);
- promise1.resolve();
+ deferred1.resolve();
});
// deno-lint-ignore no-explicit-any
server.on("close", (err: any) => {
assertEquals(err, undefined);
- promise2.resolve();
+ deferred2.resolve();
});
server.on("listening", () => {
throw Error("unreachable");
});
- await promise1;
- await promise2;
+ await deferred1.promise;
+ await deferred2.promise;
}
});
@@ -117,7 +116,7 @@ Deno.test("[node/http] chunked response", async () => {
const body of [undefined, "", "ok"]
) {
const expected = body ?? "";
- const promise = deferred<void>();
+ const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((_req, res) => {
res.writeHead(200, { "transfer-encoding": "chunked" });
@@ -134,7 +133,7 @@ Deno.test("[node/http] chunked response", async () => {
const actual = await res.text();
assertEquals(actual, expected);
- server.close(() => promise.resolve());
+ server.close(() => resolve());
});
await promise;
@@ -143,7 +142,7 @@ Deno.test("[node/http] chunked response", async () => {
// Test empty chunks: https://github.com/denoland/deno/issues/17194
Deno.test("[node/http] empty chunk in the middle of response", async () => {
- const promise = deferred<void>();
+ const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((_req, res) => {
res.write("a");
@@ -159,7 +158,7 @@ Deno.test("[node/http] empty chunk in the middle of response", async () => {
);
const actual = await res.text();
assertEquals(actual, "ab");
- server.close(() => promise.resolve());
+ server.close(() => resolve());
});
await promise;
@@ -167,7 +166,7 @@ Deno.test("[node/http] empty chunk in the middle of response", async () => {
Deno.test("[node/http] server can respond with 101, 204, 205, 304 status", async () => {
for (const status of [101, 204, 205, 304]) {
- const promise = deferred<void>();
+ const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((_req, res) => {
res.statusCode = status;
res.end("");
@@ -179,15 +178,15 @@ Deno.test("[node/http] server can respond with 101, 204, 205, 304 status", async
);
await res.arrayBuffer();
assertEquals(res.status, status);
- server.close(() => promise.resolve());
+ server.close(() => resolve());
});
await promise;
}
});
Deno.test("[node/http] request default protocol", async () => {
- const promise = deferred<void>();
- const promise2 = deferred<void>();
+ const deferred1 = Promise.withResolvers<void>();
+ const deferred2 = Promise.withResolvers<void>();
const server = http.createServer((_, res) => {
res.end("ok");
});
@@ -210,22 +209,22 @@ Deno.test("[node/http] request default protocol", async () => {
});
clientRes = res;
assertEquals(res.statusCode, 200);
- promise2.resolve();
+ deferred2.resolve();
},
);
clientReq.end();
});
server.on("close", () => {
- promise.resolve();
+ deferred1.resolve();
});
- await promise;
- await promise2;
+ await deferred1.promise;
+ await deferred2.promise;
assert(clientReq.socket instanceof EventEmitter);
assertEquals(clientRes!.complete, true);
});
Deno.test("[node/http] request with headers", async () => {
- const promise = deferred<void>();
+ const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((req, res) => {
assertEquals(req.headers["x-foo"], "bar");
res.end("ok");
@@ -249,7 +248,7 @@ Deno.test("[node/http] request with headers", async () => {
req.end();
});
server.on("close", () => {
- promise.resolve();
+ resolve();
});
await promise;
});
@@ -258,7 +257,7 @@ Deno.test("[node/http] non-string buffer response", {
// TODO(kt3k): Enable sanitizer. A "zlib" resource is leaked in this test case.
sanitizeResources: false,
}, async () => {
- const promise = deferred<void>();
+ const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((_, res) => {
res.socket!.end();
gzip(
@@ -281,7 +280,7 @@ Deno.test("[node/http] non-string buffer response", {
} catch (e) {
server.emit("error", e);
} finally {
- server.close(() => promise.resolve());
+ server.close(() => resolve());
}
});
await promise;
@@ -461,7 +460,7 @@ Deno.test("[node/http] send request with chunked body as default", async () => {
});
Deno.test("[node/http] ServerResponse _implicitHeader", async () => {
- const d = deferred<void>();
+ const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((_req, res) => {
const writeHeadSpy = spy(res, "writeHead");
// deno-lint-ignore no-explicit-any
@@ -476,11 +475,11 @@ Deno.test("[node/http] ServerResponse _implicitHeader", async () => {
const res = await fetch(`http://localhost:${port}`);
assertEquals(await res.text(), "Hello World");
server.close(() => {
- d.resolve();
+ resolve();
});
});
- await d;
+ await promise;
});
Deno.test("[node/http] server unref", async () => {
@@ -504,7 +503,7 @@ Deno.test("[node/http] server unref", async () => {
Deno.test("[node/http] ClientRequest handle non-string headers", async () => {
// deno-lint-ignore no-explicit-any
let headers: any;
- const def = deferred();
+ const { promise, resolve, reject } = Promise.withResolvers<void>();
const req = http.request("http://localhost:4545/echo_server", {
method: "POST",
headers: { 1: 2 },
@@ -514,18 +513,18 @@ Deno.test("[node/http] ClientRequest handle non-string headers", async () => {
resp.on("data", () => {});
resp.on("end", () => {
- def.resolve();
+ resolve();
});
});
- req.once("error", (e) => def.reject(e));
+ req.once("error", (e) => reject(e));
req.end();
- await def;
+ await promise;
assertEquals(headers!["1"], "2");
});
Deno.test("[node/http] ClientRequest uses HTTP/1.1", async () => {
let body = "";
- const def = deferred();
+ const { promise, resolve, reject } = Promise.withResolvers<void>();
const req = https.request("https://localhost:5545/http_version", {
method: "POST",
headers: { 1: 2 },
@@ -535,39 +534,39 @@ Deno.test("[node/http] ClientRequest uses HTTP/1.1", async () => {
});
resp.on("end", () => {
- def.resolve();
+ resolve();
});
});
- req.once("error", (e) => def.reject(e));
+ req.once("error", (e) => reject(e));
req.end();
- await def;
+ await promise;
assertEquals(body, "HTTP/1.1");
});
Deno.test("[node/http] ClientRequest setTimeout", async () => {
let body = "";
- const def = deferred();
- const timer = setTimeout(() => def.reject("timed out"), 50000);
+ const { promise, resolve, reject } = Promise.withResolvers<void>();
+ const timer = setTimeout(() => reject("timed out"), 50000);
const req = http.request("http://localhost:4545/http_version", (resp) => {
resp.on("data", (chunk) => {
body += chunk;
});
resp.on("end", () => {
- def.resolve();
+ resolve();
});
});
req.setTimeout(120000);
- req.once("error", (e) => def.reject(e));
+ req.once("error", (e) => reject(e));
req.end();
- await def;
+ await promise;
clearTimeout(timer);
assertEquals(body, "HTTP/1.1");
});
Deno.test("[node/http] ClientRequest PATCH", async () => {
let body = "";
- const def = deferred();
+ const { promise, resolve, reject } = Promise.withResolvers<void>();
const req = http.request("http://localhost:4545/echo_server", {
method: "PATCH",
}, (resp) => {
@@ -576,20 +575,20 @@ Deno.test("[node/http] ClientRequest PATCH", async () => {
});
resp.on("end", () => {
- def.resolve();
+ resolve();
});
});
req.write("hello ");
req.write("world");
- req.once("error", (e) => def.reject(e));
+ req.once("error", (e) => reject(e));
req.end();
- await def;
+ await promise;
assertEquals(body, "hello world");
});
Deno.test("[node/http] ClientRequest PUT", async () => {
let body = "";
- const def = deferred();
+ const { promise, resolve, reject } = Promise.withResolvers<void>();
const req = http.request("http://localhost:4545/echo_server", {
method: "PUT",
}, (resp) => {
@@ -598,20 +597,20 @@ Deno.test("[node/http] ClientRequest PUT", async () => {
});
resp.on("end", () => {
- def.resolve();
+ resolve();
});
});
req.write("hello ");
req.write("world");
- req.once("error", (e) => def.reject(e));
+ req.once("error", (e) => reject(e));
req.end();
- await def;
+ await promise;
assertEquals(body, "hello world");
});
Deno.test("[node/http] ClientRequest search params", async () => {
let body = "";
- const def = deferred();
+ const { promise, resolve, reject } = Promise.withResolvers<void>();
const req = http.request({
host: "localhost:4545",
path: "search_params?foo=bar",
@@ -621,18 +620,18 @@ Deno.test("[node/http] ClientRequest search params", async () => {
});
resp.on("end", () => {
- def.resolve();
+ resolve();
});
});
- req.once("error", (e) => def.reject(e));
+ req.once("error", (e) => reject(e));
req.end();
- await def;
+ await promise;
assertEquals(body, "foo=bar");
});
Deno.test("[node/http] HTTPS server", async () => {
- const promise = deferred<void>();
- const promise2 = deferred<void>();
+ const deferred = Promise.withResolvers<void>();
+ const deferred2 = Promise.withResolvers<void>();
const client = Deno.createHttpClient({
caCerts: [Deno.readTextFileSync("cli/tests/testdata/tls/RootCA.pem")],
});
@@ -652,14 +651,14 @@ Deno.test("[node/http] HTTPS server", async () => {
assertEquals(res.status, 200);
assertEquals(await res.text(), "success!");
server.close();
- promise2.resolve();
+ deferred2.resolve();
});
})
.on("error", () => fail());
server.on("close", () => {
- promise.resolve();
+ deferred.resolve();
});
- await Promise.all([promise, promise2]);
+ await Promise.all([deferred.promise, deferred2.promise]);
client.close();
});
@@ -667,7 +666,7 @@ Deno.test(
"[node/http] client upgrade",
{ permissions: { net: true } },
async () => {
- const promise = deferred();
+ const { promise, resolve } = Promise.withResolvers<void>();
const server = http.createServer((req, res) => {
// @ts-ignore: It exists on TLSSocket
assert(!req.socket.encrypted);
@@ -706,7 +705,7 @@ Deno.test(
// @ts-ignore it's a socket for real
serverSocket!.end();
server.close(() => {
- promise.resolve();
+ resolve();
});
});
});
@@ -725,7 +724,7 @@ Deno.test(
received = true;
return new Response("hello");
});
- const promise = deferred();
+ const { promise, resolve, reject } = Promise.withResolvers<void>();
let body = "";
const request = http.request(
@@ -736,11 +735,11 @@ Deno.test(
});
resp.on("end", () => {
- promise.resolve();
+ resolve();
});
},
);
- request.on("error", promise.reject);
+ request.on("error", reject);
request.end(() => {
assert(received);
});
@@ -754,22 +753,22 @@ Deno.test(
);
Deno.test("[node/http] server emits error if addr in use", async () => {
- const promise = deferred<void>();
- const promise2 = deferred<Error>();
+ const deferred1 = Promise.withResolvers<void>();
+ const deferred2 = Promise.withResolvers<Error>();
const server = http.createServer();
server.listen(9001);
const server2 = http.createServer();
server2.on("error", (e) => {
- promise2.resolve(e);
+ deferred2.resolve(e);
});
server2.listen(9001);
- const err = await promise2;
- server.close(() => promise.resolve());
+ const err = await deferred2.promise;
+ server.close(() => deferred1.resolve());
server2.close();
- await promise;
+ await deferred1.promise;
const expectedMsg = Deno.build.os === "windows"
? "Only one usage of each socket address"
: "Address already in use";
@@ -795,15 +794,15 @@ Deno.test(
return new Response("hello");
},
);
- const promise = deferred();
+ const { promise, resolve, reject } = Promise.withResolvers<void>();
const request = http.request("http://localhost:5929/");
- request.on("error", promise.reject);
+ request.on("error", reject);
request.on("close", () => {});
request.end();
setTimeout(() => {
request.destroy(new Error());
- promise.resolve();
+ resolve();
}, 100);
await promise;
diff --git a/cli/tests/unit_node/internal/_randomFill_test.ts b/cli/tests/unit_node/internal/_randomFill_test.ts
index 5e2e154c8..5d56ca65a 100644
--- a/cli/tests/unit_node/internal/_randomFill_test.ts
+++ b/cli/tests/unit_node/internal/_randomFill_test.ts
@@ -6,7 +6,6 @@ import {
assertNotEquals,
assertThrows,
} from "../../../../test_util/std/testing/asserts.ts";
-import { deferred } from "../../../../test_util/std/async/deferred.ts";
const validateNonZero = (buf: Buffer) => {
if (!buf.some((ch) => ch > 0)) throw new Error("Error");
@@ -17,14 +16,14 @@ const validateZero = (buf: Buffer) => {
};
Deno.test("[node/crypto.randomFill]", async () => {
- const promise = deferred();
+ const { promise, resolve } = Promise.withResolvers<boolean>();
const buf = Buffer.alloc(10);
const before = buf.toString("hex");
randomFill(buf, 5, 5, (_err, bufTwo) => {
const after = bufTwo?.toString("hex");
assertEquals(before.slice(0, 10), after?.slice(0, 10));
- promise.resolve(true);
+ resolve(true);
});
await promise;
diff --git a/cli/tests/unit_node/internal/scrypt_test.ts b/cli/tests/unit_node/internal/scrypt_test.ts
index d65cd27ff..83830f8e4 100644
--- a/cli/tests/unit_node/internal/scrypt_test.ts
+++ b/cli/tests/unit_node/internal/scrypt_test.ts
@@ -2,10 +2,9 @@
import { scrypt, scryptSync } from "node:crypto";
import { Buffer } from "node:buffer";
import { assertEquals } from "../../../../test_util/std/testing/asserts.ts";
-import { deferred } from "../../../../test_util/std/async/deferred.ts";
Deno.test("scrypt works correctly", async () => {
- const promise = deferred();
+ const { promise, resolve } = Promise.withResolvers<boolean>();
scrypt("password", "salt", 32, (err, key) => {
if (err) throw err;
@@ -46,14 +45,14 @@ Deno.test("scrypt works correctly", async () => {
115,
]),
);
- promise.resolve(true);
+ resolve(true);
});
await promise;
});
Deno.test("scrypt works with options", async () => {
- const promise = deferred();
+ const { promise, resolve } = Promise.withResolvers<boolean>();
scrypt(
"password",
@@ -101,7 +100,7 @@ Deno.test("scrypt works with options", async () => {
71,
]),
);
- promise.resolve(true);
+ resolve(true);
},
);
diff --git a/cli/tests/unit_node/net_test.ts b/cli/tests/unit_node/net_test.ts
index ca9d214e1..e55adafcb 100644
--- a/cli/tests/unit_node/net_test.ts
+++ b/cli/tests/unit_node/net_test.ts
@@ -5,15 +5,14 @@ import {
assert,
assertEquals,
} from "../../../test_util/std/testing/asserts.ts";
-import { Deferred, deferred } from "../../../test_util/std/async/deferred.ts";
import * as path from "../../../test_util/std/path/mod.ts";
import * as http from "node:http";
Deno.test("[node/net] close event emits after error event", async () => {
const socket = net.createConnection(27009, "doesnotexist");
const events: ("error" | "close")[] = [];
- const errorEmitted = deferred();
- const closeEmitted = deferred();
+ const errorEmitted = Promise.withResolvers<void>();
+ const closeEmitted = Promise.withResolvers<void>();
socket.once("error", () => {
events.push("error");
errorEmitted.resolve();
@@ -22,14 +21,14 @@ Deno.test("[node/net] close event emits after error event", async () => {
events.push("close");
closeEmitted.resolve();
});
- await Promise.all([errorEmitted, closeEmitted]);
+ await Promise.all([errorEmitted.promise, closeEmitted.promise]);
// `error` happens before `close`
assertEquals(events, ["error", "close"]);
});
Deno.test("[node/net] the port is available immediately after close callback", async () => {
- const p = deferred();
+ const deferred = Promise.withResolvers<void>();
// This simulates what get-port@5.1.1 does.
const getAvailablePort = (port: number) =>
@@ -48,11 +47,11 @@ Deno.test("[node/net] the port is available immediately after close callback", a
const port = await getAvailablePort(5555);
const httpServer = http.createServer();
- httpServer.on("error", (e) => p.reject(e));
+ httpServer.on("error", (e) => deferred.reject(e));
httpServer.listen(port, () => {
- httpServer.close(() => p.resolve());
+ httpServer.close(() => deferred.resolve());
});
- await p;
+ await deferred.promise;
});
Deno.test("[node/net] net.connect().unref() works", async () => {
@@ -100,16 +99,16 @@ Deno.test({
});
Deno.test("[node/net] connection event has socket value", async () => {
- const p = deferred();
- const p2 = deferred();
+ const deferred = Promise.withResolvers<void>();
+ const deferred2 = Promise.withResolvers<void>();
const server = net.createServer();
- server.on("error", p.reject);
+ server.on("error", deferred.reject);
server.on("connection", (socket) => {
assert(socket !== undefined);
socket.end();
server.close(() => {
- p.resolve();
+ deferred.resolve();
});
});
server.listen(async () => {
@@ -125,10 +124,10 @@ Deno.test("[node/net] connection event has socket value", async () => {
//
}
- p2.resolve();
+ deferred2.resolve();
});
- await Promise.all([p, p2]);
+ await Promise.all([deferred.promise, deferred2.promise]);
});
/// We need to make sure that any shared buffers are never used concurrently by two reads.
@@ -137,17 +136,19 @@ Deno.test("[node/net] multiple Sockets should get correct server data", async ()
const socketCount = 9;
class TestSocket {
- dataReceived: Deferred<undefined> = deferred();
+ dataReceived: ReturnType<typeof Promise.withResolvers<void>> = Promise
+ .withResolvers<void>();
events: string[] = [];
socket: net.Socket | undefined;
}
- const finished = deferred();
- const serverSocketsClosed: Deferred<undefined>[] = [];
+ const finished = Promise.withResolvers<void>();
+ const serverSocketsClosed: ReturnType<typeof Promise.withResolvers<void>>[] =
+ [];
const server = net.createServer();
server.on("connection", (socket) => {
assert(socket !== undefined);
- const i = serverSocketsClosed.push(deferred());
+ const i = serverSocketsClosed.push(Promise.withResolvers<void>());
socket.on("data", (data) => {
socket.write(new TextDecoder().decode(data));
});
@@ -183,7 +184,7 @@ Deno.test("[node/net] multiple Sockets should get correct server data", async ()
sockets[i].socket?.write(`${i}`.repeat(3));
}
- await Promise.all(sockets.map((socket) => socket.dataReceived));
+ await Promise.all(sockets.map((socket) => socket.dataReceived.promise));
for (let i = 0; i < socketCount; i++) {
sockets[i].socket?.end();
@@ -194,8 +195,8 @@ Deno.test("[node/net] multiple Sockets should get correct server data", async ()
});
});
- await finished;
- await Promise.all(serverSocketsClosed);
+ await finished.promise;
+ await Promise.all(serverSocketsClosed.map(({ promise }) => promise));
for (let i = 0; i < socketCount; i++) {
assertEquals(sockets[i].events, [`${i}`.repeat(3), `${i}`.repeat(3)]);
diff --git a/cli/tests/unit_node/process_test.ts b/cli/tests/unit_node/process_test.ts
index a572f11b2..ffb95413a 100644
--- a/cli/tests/unit_node/process_test.ts
+++ b/cli/tests/unit_node/process_test.ts
@@ -13,7 +13,6 @@ import {
assertThrows,
} from "../../../test_util/std/testing/asserts.ts";
import { stripColor } from "../../../test_util/std/fmt/colors.ts";
-import { deferred } from "../../../test_util/std/async/deferred.ts";
import * as path from "../../../test_util/std/path/mod.ts";
import { delay } from "../../../test_util/std/async/delay.ts";
@@ -368,7 +367,7 @@ Deno.test({
// stdin resource is present before the test starts.
sanitizeResources: false,
async fn() {
- const promise = deferred();
+ const { promise, resolve } = Promise.withResolvers<void>();
const expected = ["foo", "bar", null, "end"];
const data: (string | null)[] = [];
@@ -385,7 +384,7 @@ Deno.test({
process.stdin.push("bar");
process.nextTick(() => {
process.stdin.push(null);
- promise.resolve();
+ resolve();
});
});
diff --git a/cli/tests/unit_node/tls_test.ts b/cli/tests/unit_node/tls_test.ts
index 7a270c60b..0a3a91144 100644
--- a/cli/tests/unit_node/tls_test.ts
+++ b/cli/tests/unit_node/tls_test.ts
@@ -5,7 +5,6 @@ import {
assertInstanceOf,
} from "../../../test_util/std/testing/asserts.ts";
import { delay } from "../../../test_util/std/async/delay.ts";
-import { deferred } from "../../../test_util/std/async/deferred.ts";
import { fromFileUrl, join } from "../../../test_util/std/path/mod.ts";
import { serveTls } from "../../../test_util/std/http/server.ts";
import * as tls from "node:tls";
@@ -89,7 +88,7 @@ Deno.test("tls.connect mid-read tcp->tls upgrade", async () => {
});
Deno.test("tls.createServer creates a TLS server", async () => {
- const p = deferred();
+ const deferred = Promise.withResolvers<void>();
const server = tls.createServer(
// deno-lint-ignore no-explicit-any
{ host: "0.0.0.0", key, cert } as any,
@@ -131,9 +130,9 @@ Deno.test("tls.createServer creates a TLS server", async () => {
conn.close();
server.close();
- p.resolve();
+ deferred.resolve();
});
- await p;
+ await deferred.promise;
});
Deno.test("TLSSocket can construct without options", () => {
diff --git a/cli/tests/unit_node/zlib_test.ts b/cli/tests/unit_node/zlib_test.ts
index b878b7cc3..c025849da 100644
--- a/cli/tests/unit_node/zlib_test.ts
+++ b/cli/tests/unit_node/zlib_test.ts
@@ -4,7 +4,6 @@ import {
assert,
assertEquals,
} from "../../../test_util/std/testing/asserts.ts";
-import { deferred } from "../../../test_util/std/async/deferred.ts";
import { fromFileUrl, relative } from "../../../test_util/std/path/mod.ts";
import {
brotliCompressSync,
@@ -24,7 +23,7 @@ Deno.test("brotli compression sync", () => {
});
Deno.test("brotli compression", async () => {
- const promise = deferred();
+ const { promise, resolve } = Promise.withResolvers<void>();
const compress = createBrotliCompress();
const filePath = relative(
Deno.cwd(),
@@ -43,7 +42,7 @@ Deno.test("brotli compression", async () => {
const stream2 = input2.pipe(decompress).pipe(output2);
stream2.on("finish", () => {
- promise.resolve();
+ resolve();
});
});
@@ -73,12 +72,12 @@ Deno.test(
"zlib create deflate with dictionary",
{ sanitizeResources: false },
async () => {
- const promise = deferred();
+ const { promise, resolve } = Promise.withResolvers<void>();
const handle = createDeflate({
dictionary: Buffer.alloc(0),
});
- handle.on("close", () => promise.resolve());
+ handle.on("close", () => resolve());
handle.end();
handle.destroy();
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-27 08:41:06 +0000