From 338abd73d850992bc94cc429748f6b2f2b7dadf7 Mon Sep 17 00:00:00 2001
From: Sosuke Suzuki <sosuke.suzuki@dr-ubie.com>
Date: Sun, 31 Dec 2023 02:41:25 +0900
Subject: [PATCH 1/8] Migrate all tests to use `node:test`

---
 test/node-test/abort-controller.js | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/test/node-test/abort-controller.js b/test/node-test/abort-controller.js
index d4d9a588df6..1b732b71604 100644
--- a/test/node-test/abort-controller.js
+++ b/test/node-test/abort-controller.js
@@ -169,6 +169,7 @@ for (const { AbortControllerImpl, controllerName } of controllers) {
       })
       t.after(server.close.bind(server))
 
+      const { promise, resolve } = promiseWithResolvers()
       server.listen(0, () => {
         const client = new Client(`http://localhost:${server.address().port}`)
         t.after(client.destroy.bind(client))
@@ -199,6 +200,7 @@ for (const { AbortControllerImpl, controllerName } of controllers) {
       })
       t.after(server.close.bind(server))
 
+      const { promise, resolve } = promiseWithResolvers()
       server.listen(0, () => {
         const client = new Client(`http://localhost:${server.address().port}`)
         t.after(client.destroy.bind(client))
@@ -227,6 +229,7 @@ for (const { AbortControllerImpl, controllerName } of controllers) {
       })
       t.after(server.close.bind(server))
 
+      const { promise, resolve } = promiseWithResolvers()
       server.listen(0, () => {
         const client = new Client(`http://localhost:${server.address().port}`)
         t.after(client.destroy.bind(client))

From 5fac49105351d0f2283de88218d83626cc363207 Mon Sep 17 00:00:00 2001
From: Sosuke Suzuki <sosuke.suzuki@dr-ubie.com>
Date: Sun, 31 Dec 2023 03:00:02 +0900
Subject: [PATCH 2/8] Move utils to `/test/utils`

---
 test/utils/node-test.js | 60 +++++++++++++++++++++++++++++++++++++++++
 test/utils/promise.js   | 16 +++++++++++
 2 files changed, 76 insertions(+)
 create mode 100644 test/utils/node-test.js
 create mode 100644 test/utils/promise.js

diff --git a/test/utils/node-test.js b/test/utils/node-test.js
new file mode 100644
index 00000000000..549fab32369
--- /dev/null
+++ b/test/utils/node-test.js
@@ -0,0 +1,60 @@
+/**
+ * A port of tap's `t.type` that can be used with `node:assert`
+ * https://github.com/tapjs/tapjs/blob/511019b2ac0fa014370154c3a341a0e632f50b19/src/asserts/src/index.ts#L199
+ */
+function ttype (plan, obj, klass) {
+  const name =
+        typeof klass === 'function'
+          ? klass.name || '(anonymous constructor)'
+          : klass
+
+  if (obj === klass) {
+    return plan.ok(1)
+  }
+
+  const tof = typeof obj
+  const type =
+        !obj && tof === 'object'
+          ? 'null'
+          // treat as object, but not Object
+          // t.type(() => {}, Function)
+          : tof === 'function' &&
+            typeof klass === 'function' &&
+            klass !== Object
+            ? 'object'
+            : tof
+
+  if (
+    (type === 'number' && klass === Number) ||
+      (type === 'string' && klass === String) ||
+      (type === 'bigint' && klass === BigInt) ||
+      (klass === 'array' && Array.isArray(obj)) ||
+      (type === 'symbol' && klass === Symbol)
+  ) {
+    return plan.ok(1)
+  }
+
+  // simplest case, it literally is the same thing
+  if (type === 'object' && klass !== 'object') {
+    if (typeof klass === 'function') {
+      return plan.ok(obj instanceof klass)
+    }
+
+    // check prototype chain for name
+    // at this point, we already know klass is not a function
+    // if the klass specified is an obj in the proto chain, pass
+    // if the name specified is the name of a ctor in the chain, pass
+    for (let p = obj; p; p = Object.getPrototypeOf(p)) {
+      const ctor = p.constructor && p.constructor.name
+      if (p === klass || ctor === name) {
+        return plan.ok(1)
+      }
+    }
+  }
+
+  return plan.strictEqual(type, name)
+}
+
+module.exports = {
+  ttype
+}
diff --git a/test/utils/promise.js b/test/utils/promise.js
new file mode 100644
index 00000000000..5e16a803630
--- /dev/null
+++ b/test/utils/promise.js
@@ -0,0 +1,16 @@
+/**
+ * The helper function to create a promise with resolvers.
+ * Please see https://github.com/tc39/proposal-promise-with-resolvers for more details.
+ */
+function promiseWithResolvers () {
+  let _resolve, _reject
+  const promise = new Promise((resolve, reject) => {
+    _resolve = resolve
+    _reject = reject
+  })
+  return { promise, resolve: _resolve, reject: _reject }
+}
+
+module.exports = {
+  promiseWithResolvers
+}

From 3437e9dc18dc9ffc1053616e50f4c64b4b16ac63 Mon Sep 17 00:00:00 2001
From: Sosuke Suzuki <sosuke.suzuki@dr-ubie.com>
Date: Sun, 31 Dec 2023 06:38:11 +0900
Subject: [PATCH 3/8] Use `p.completed`

---
 test/node-test/abort-controller.js |  3 ---
 test/utils/promise.js              | 16 ----------------
 2 files changed, 19 deletions(-)
 delete mode 100644 test/utils/promise.js

diff --git a/test/node-test/abort-controller.js b/test/node-test/abort-controller.js
index 1b732b71604..d4d9a588df6 100644
--- a/test/node-test/abort-controller.js
+++ b/test/node-test/abort-controller.js
@@ -169,7 +169,6 @@ for (const { AbortControllerImpl, controllerName } of controllers) {
       })
       t.after(server.close.bind(server))
 
-      const { promise, resolve } = promiseWithResolvers()
       server.listen(0, () => {
         const client = new Client(`http://localhost:${server.address().port}`)
         t.after(client.destroy.bind(client))
@@ -200,7 +199,6 @@ for (const { AbortControllerImpl, controllerName } of controllers) {
       })
       t.after(server.close.bind(server))
 
-      const { promise, resolve } = promiseWithResolvers()
       server.listen(0, () => {
         const client = new Client(`http://localhost:${server.address().port}`)
         t.after(client.destroy.bind(client))
@@ -229,7 +227,6 @@ for (const { AbortControllerImpl, controllerName } of controllers) {
       })
       t.after(server.close.bind(server))
 
-      const { promise, resolve } = promiseWithResolvers()
       server.listen(0, () => {
         const client = new Client(`http://localhost:${server.address().port}`)
         t.after(client.destroy.bind(client))
diff --git a/test/utils/promise.js b/test/utils/promise.js
deleted file mode 100644
index 5e16a803630..00000000000
--- a/test/utils/promise.js
+++ /dev/null
@@ -1,16 +0,0 @@
-/**
- * The helper function to create a promise with resolvers.
- * Please see https://github.com/tc39/proposal-promise-with-resolvers for more details.
- */
-function promiseWithResolvers () {
-  let _resolve, _reject
-  const promise = new Promise((resolve, reject) => {
-    _resolve = resolve
-    _reject = reject
-  })
-  return { promise, resolve: _resolve, reject: _reject }
-}
-
-module.exports = {
-  promiseWithResolvers
-}

From 0e37f523f2ad9164ffb05205bc29229136cc3bb8 Mon Sep 17 00:00:00 2001
From: Sosuke Suzuki <sosuke.suzuki@dr-ubie.com>
Date: Sun, 31 Dec 2023 19:32:34 +0900
Subject: [PATCH 4/8] Make `ttype` return `boolean`

---
 test/utils/node-test.js | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/test/utils/node-test.js b/test/utils/node-test.js
index 549fab32369..250fd0b19c2 100644
--- a/test/utils/node-test.js
+++ b/test/utils/node-test.js
@@ -2,14 +2,14 @@
  * A port of tap's `t.type` that can be used with `node:assert`
  * https://github.com/tapjs/tapjs/blob/511019b2ac0fa014370154c3a341a0e632f50b19/src/asserts/src/index.ts#L199
  */
-function ttype (plan, obj, klass) {
+function ttype (obj, klass) {
   const name =
         typeof klass === 'function'
           ? klass.name || '(anonymous constructor)'
           : klass
 
   if (obj === klass) {
-    return plan.ok(1)
+    return true
   }
 
   const tof = typeof obj
@@ -31,13 +31,13 @@ function ttype (plan, obj, klass) {
       (klass === 'array' && Array.isArray(obj)) ||
       (type === 'symbol' && klass === Symbol)
   ) {
-    return plan.ok(1)
+    return true
   }
 
   // simplest case, it literally is the same thing
   if (type === 'object' && klass !== 'object') {
     if (typeof klass === 'function') {
-      return plan.ok(obj instanceof klass)
+      return obj instanceof klass
     }
 
     // check prototype chain for name
@@ -47,12 +47,12 @@ function ttype (plan, obj, klass) {
     for (let p = obj; p; p = Object.getPrototypeOf(p)) {
       const ctor = p.constructor && p.constructor.name
       if (p === klass || ctor === name) {
-        return plan.ok(1)
+        return true
       }
     }
   }
 
-  return plan.strictEqual(type, name)
+  return type === name
 }
 
 module.exports = {

From 78c9f213e0b298714d7e70a1cf50d0e294dbfad3 Mon Sep 17 00:00:00 2001
From: Sosuke Suzuki <sosuke.suzuki@dr-ubie.com>
Date: Sun, 31 Dec 2023 03:31:47 +0900
Subject: [PATCH 5/8] Port `abort-event-emitter` to `node:test` runner

---
 test/{ => node-test}/abort-event-emitter.js | 136 ++++++++++++--------
 1 file changed, 85 insertions(+), 51 deletions(-)
 rename test/{ => node-test}/abort-event-emitter.js (64%)

diff --git a/test/abort-event-emitter.js b/test/node-test/abort-event-emitter.js
similarity index 64%
rename from test/abort-event-emitter.js
rename to test/node-test/abort-event-emitter.js
index a5397e4f03b..6c997e244cf 100644
--- a/test/abort-event-emitter.js
+++ b/test/node-test/abort-event-emitter.js
@@ -1,46 +1,52 @@
 'use strict'
 
-const { test } = require('tap')
+const { test } = require('node:test')
 const EventEmitter = require('events')
-const { Client, errors } = require('..')
+const { Client, errors } = require('../..')
 const { createServer } = require('http')
 const { createReadStream } = require('fs')
 const { Readable } = require('stream')
-const { wrapWithAsyncIterable } = require('./utils/async-iterators')
+const { tspl } = require('@matteo.collina/tspl')
+const { wrapWithAsyncIterable } = require('../utils/async-iterators')
+const { promiseWithResolvers } = require('../utils/promise')
+const { ttype } = require('../utils/node-test')
 
-test('Abort before sending request (no body)', (t) => {
-  t.plan(4)
+test('Abort before sending request (no body)', async (t) => {
+  const p = tspl(t, { plan: 4 })
 
   let count = 0
   const server = createServer((req, res) => {
     if (count === 1) {
-      t.fail('The second request should never be executed')
+      p.fail('The second request should never be executed')
     }
     count += 1
     res.end('hello')
   })
 
-  t.teardown(server.close.bind(server))
+  t.after(server.close.bind(server))
+
+  const { promise, resolve } = promiseWithResolvers()
 
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
     const ee = new EventEmitter()
-    t.teardown(client.destroy.bind(client))
+    t.after(client.destroy.bind(client))
 
     client.request({ path: '/', method: 'GET' }, (err, response) => {
-      t.error(err)
+      p.ifError(err)
       const bufs = []
       response.body.on('data', (buf) => {
         bufs.push(buf)
       })
       response.body.on('end', () => {
-        t.equal('hello', Buffer.concat(bufs).toString('utf8'))
+        p.strictEqual('hello', Buffer.concat(bufs).toString('utf8'))
+        resolve()
       })
     })
 
     const body = new Readable({ read () { } })
     body.on('error', (err) => {
-      t.type(err, errors.RequestAbortedError)
+      ttype(p, err, errors.RequestAbortedError)
     })
     client.request({
       path: '/',
@@ -48,15 +54,17 @@ test('Abort before sending request (no body)', (t) => {
       signal: ee,
       body
     }, (err, response) => {
-      t.type(err, errors.RequestAbortedError)
+      ttype(p, err, errors.RequestAbortedError)
     })
 
     ee.emit('abort')
   })
+
+  await promise
 })
 
-test('Abort before sending request (no body) async iterator', (t) => {
-  t.plan(3)
+test('Abort before sending request (no body) async iterator', async (t) => {
+  const p = tspl(t, { plan: 3 })
 
   let count = 0
   const server = createServer((req, res) => {
@@ -67,21 +75,24 @@ test('Abort before sending request (no body) async iterator', (t) => {
     res.end('hello')
   })
 
-  t.teardown(server.close.bind(server))
+  t.after(server.close.bind(server))
+
+  const { promise, resolve } = promiseWithResolvers()
 
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
     const ee = new EventEmitter()
-    t.teardown(client.destroy.bind(client))
+    t.after(client.destroy.bind(client))
 
     client.request({ path: '/', method: 'GET' }, (err, response) => {
-      t.error(err)
+      p.ifError(err)
       const bufs = []
       response.body.on('data', (buf) => {
         bufs.push(buf)
       })
       response.body.on('end', () => {
-        t.equal('hello', Buffer.concat(bufs).toString('utf8'))
+        p.strictEqual('hello', Buffer.concat(bufs).toString('utf8'))
+        resolve()
       })
     })
 
@@ -92,15 +103,17 @@ test('Abort before sending request (no body) async iterator', (t) => {
       signal: ee,
       body
     }, (err, response) => {
-      t.type(err, errors.RequestAbortedError)
+      ttype(p, err, errors.RequestAbortedError)
     })
 
     ee.emit('abort')
   })
+
+  await promise
 })
 
-test('Abort while waiting response (no body)', (t) => {
-  t.plan(1)
+test('Abort while waiting response (no body)', async (t) => {
+  const p = tspl(t, { plan: 1 })
 
   const ee = new EventEmitter()
   const server = createServer((req, res) => {
@@ -108,20 +121,25 @@ test('Abort while waiting response (no body)', (t) => {
     res.setHeader('content-type', 'text/plain')
     res.end('hello world')
   })
-  t.teardown(server.close.bind(server))
+  t.after(server.close.bind(server))
+
+  const { promise, resolve } = promiseWithResolvers()
 
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
-    t.teardown(client.destroy.bind(client))
+    t.after(client.destroy.bind(client))
 
     client.request({ path: '/', method: 'GET', signal: ee }, (err, response) => {
-      t.type(err, errors.RequestAbortedError)
+      ttype(p, err, errors.RequestAbortedError)
+      resolve()
     })
   })
+
+  await promise
 })
 
-test('Abort while waiting response (write headers started) (no body)', (t) => {
-  t.plan(1)
+test('Abort while waiting response (write headers started) (no body)', async (t) => {
+  const p = tspl(t, { plan: 1 })
 
   const ee = new EventEmitter()
   const server = createServer((req, res) => {
@@ -130,47 +148,54 @@ test('Abort while waiting response (write headers started) (no body)', (t) => {
     ee.emit('abort')
     res.end('hello world')
   })
-  t.teardown(server.close.bind(server))
+  t.after(server.close.bind(server))
 
+  const { promise, resolve } = promiseWithResolvers()
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
-    t.teardown(client.destroy.bind(client))
+    t.after(client.destroy.bind(client))
 
     client.request({ path: '/', method: 'GET', signal: ee }, (err, response) => {
-      t.type(err, errors.RequestAbortedError)
+      ttype(p, err, errors.RequestAbortedError)
+      resolve()
     })
   })
+
+  await promise
 })
 
-test('Abort while waiting response (write headers and write body started) (no body)', (t) => {
-  t.plan(2)
+test('Abort while waiting response (write headers and write body started) (no body)', async (t) => {
+  const p = tspl(t, { plan: 2 })
 
   const ee = new EventEmitter()
   const server = createServer((req, res) => {
     res.writeHead(200, { 'content-type': 'text/plain' })
     res.write('hello')
   })
-  t.teardown(server.close.bind(server))
+  t.after(server.close.bind(server))
 
+  const { promise, resolve } = promiseWithResolvers()
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
-    t.teardown(client.destroy.bind(client))
+    t.after(client.destroy.bind(client))
 
     client.request({ path: '/', method: 'GET', signal: ee }, (err, response) => {
-      t.error(err)
+      p.ifError(err)
       response.body.on('data', () => {
         ee.emit('abort')
       })
       response.body.on('error', err => {
-        t.type(err, errors.RequestAbortedError)
+        ttype(p, err, errors.RequestAbortedError)
+        resolve()
       })
     })
   })
+  await promise
 })
 
 function waitingWithBody (body, type) {
-  test(`Abort while waiting response (with body ${type})`, (t) => {
-    t.plan(1)
+  test(`Abort while waiting response (with body ${type})`, async (t) => {
+    const p = tspl(t, { plan: 1 })
 
     const ee = new EventEmitter()
     const server = createServer((req, res) => {
@@ -178,16 +203,19 @@ function waitingWithBody (body, type) {
       res.setHeader('content-type', 'text/plain')
       res.end('hello world')
     })
-    t.teardown(server.close.bind(server))
+    t.after(server.close.bind(server))
 
+    const { promise, resolve } = promiseWithResolvers()
     server.listen(0, () => {
       const client = new Client(`http://localhost:${server.address().port}`)
-      t.teardown(client.destroy.bind(client))
+      t.after(client.destroy.bind(client))
 
       client.request({ path: '/', method: 'POST', body, signal: ee }, (err, response) => {
-        t.type(err, errors.RequestAbortedError)
+        ttype(p, err, errors.RequestAbortedError)
+        resolve()
       })
     })
+    await promise
   })
 }
 
@@ -197,8 +225,8 @@ waitingWithBody(new Uint8Array([42]), 'Uint8Array')
 waitingWithBody(wrapWithAsyncIterable(createReadStream(__filename)), 'async-iterator')
 
 function writeHeadersStartedWithBody (body, type) {
-  test(`Abort while waiting response (write headers started) (with body ${type})`, (t) => {
-    t.plan(1)
+  test(`Abort while waiting response (write headers started) (with body ${type})`, async (t) => {
+    const p = tspl(t, { plan: 1 })
 
     const ee = new EventEmitter()
     const server = createServer((req, res) => {
@@ -207,16 +235,19 @@ function writeHeadersStartedWithBody (body, type) {
       ee.emit('abort')
       res.end('hello world')
     })
-    t.teardown(server.close.bind(server))
+    t.after(server.close.bind(server))
 
+    const { promise, resolve } = promiseWithResolvers()
     server.listen(0, () => {
       const client = new Client(`http://localhost:${server.address().port}`)
-      t.teardown(client.destroy.bind(client))
+      t.after(client.destroy.bind(client))
 
       client.request({ path: '/', method: 'POST', body, signal: ee }, (err, response) => {
-        t.type(err, errors.RequestAbortedError)
+        ttype(p, err, errors.RequestAbortedError)
+        resolve()
       })
     })
+    await promise
   })
 }
 
@@ -226,30 +257,33 @@ writeHeadersStartedWithBody(new Uint8Array([42]), 'Uint8Array')
 writeHeadersStartedWithBody(wrapWithAsyncIterable(createReadStream(__filename)), 'async-iterator')
 
 function writeBodyStartedWithBody (body, type) {
-  test(`Abort while waiting response (write headers and write body started) (with body ${type})`, (t) => {
-    t.plan(2)
+  test(`Abort while waiting response (write headers and write body started) (with body ${type})`, async (t) => {
+    const p = tspl(t, { plan: 2 })
 
     const ee = new EventEmitter()
     const server = createServer((req, res) => {
       res.writeHead(200, { 'content-type': 'text/plain' })
       res.write('hello')
     })
-    t.teardown(server.close.bind(server))
+    t.after(server.close.bind(server))
 
+    const { promise, resolve } = promiseWithResolvers()
     server.listen(0, () => {
       const client = new Client(`http://localhost:${server.address().port}`)
-      t.teardown(client.destroy.bind(client))
+      t.after(client.destroy.bind(client))
 
       client.request({ path: '/', method: 'POST', body, signal: ee }, (err, response) => {
-        t.error(err)
+        p.ifError(err)
         response.body.on('data', () => {
           ee.emit('abort')
         })
         response.body.on('error', err => {
-          t.type(err, errors.RequestAbortedError)
+          ttype(p, err, errors.RequestAbortedError)
+          resolve()
         })
       })
     })
+    await promise
   })
 }
 

From 4a8d06711821a08510b89ffef4130f5589cf62b1 Mon Sep 17 00:00:00 2001
From: Sosuke Suzuki <sosuke.suzuki@dr-ubie.com>
Date: Sun, 31 Dec 2023 06:42:29 +0900
Subject: [PATCH 6/8] Use `p.completed`

---
 test/node-test/abort-event-emitter.js | 36 ++++++---------------------
 1 file changed, 8 insertions(+), 28 deletions(-)

diff --git a/test/node-test/abort-event-emitter.js b/test/node-test/abort-event-emitter.js
index 6c997e244cf..da51d67323a 100644
--- a/test/node-test/abort-event-emitter.js
+++ b/test/node-test/abort-event-emitter.js
@@ -8,7 +8,6 @@ const { createReadStream } = require('fs')
 const { Readable } = require('stream')
 const { tspl } = require('@matteo.collina/tspl')
 const { wrapWithAsyncIterable } = require('../utils/async-iterators')
-const { promiseWithResolvers } = require('../utils/promise')
 const { ttype } = require('../utils/node-test')
 
 test('Abort before sending request (no body)', async (t) => {
@@ -25,8 +24,6 @@ test('Abort before sending request (no body)', async (t) => {
 
   t.after(server.close.bind(server))
 
-  const { promise, resolve } = promiseWithResolvers()
-
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
     const ee = new EventEmitter()
@@ -40,7 +37,6 @@ test('Abort before sending request (no body)', async (t) => {
       })
       response.body.on('end', () => {
         p.strictEqual('hello', Buffer.concat(bufs).toString('utf8'))
-        resolve()
       })
     })
 
@@ -60,7 +56,7 @@ test('Abort before sending request (no body)', async (t) => {
     ee.emit('abort')
   })
 
-  await promise
+  await p.completed
 })
 
 test('Abort before sending request (no body) async iterator', async (t) => {
@@ -77,8 +73,6 @@ test('Abort before sending request (no body) async iterator', async (t) => {
 
   t.after(server.close.bind(server))
 
-  const { promise, resolve } = promiseWithResolvers()
-
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
     const ee = new EventEmitter()
@@ -92,7 +86,6 @@ test('Abort before sending request (no body) async iterator', async (t) => {
       })
       response.body.on('end', () => {
         p.strictEqual('hello', Buffer.concat(bufs).toString('utf8'))
-        resolve()
       })
     })
 
@@ -109,7 +102,7 @@ test('Abort before sending request (no body) async iterator', async (t) => {
     ee.emit('abort')
   })
 
-  await promise
+  await p.completed
 })
 
 test('Abort while waiting response (no body)', async (t) => {
@@ -123,19 +116,16 @@ test('Abort while waiting response (no body)', async (t) => {
   })
   t.after(server.close.bind(server))
 
-  const { promise, resolve } = promiseWithResolvers()
-
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
     t.after(client.destroy.bind(client))
 
     client.request({ path: '/', method: 'GET', signal: ee }, (err, response) => {
       ttype(p, err, errors.RequestAbortedError)
-      resolve()
     })
   })
 
-  await promise
+  await p.completed
 })
 
 test('Abort while waiting response (write headers started) (no body)', async (t) => {
@@ -150,18 +140,16 @@ test('Abort while waiting response (write headers started) (no body)', async (t)
   })
   t.after(server.close.bind(server))
 
-  const { promise, resolve } = promiseWithResolvers()
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
     t.after(client.destroy.bind(client))
 
     client.request({ path: '/', method: 'GET', signal: ee }, (err, response) => {
       ttype(p, err, errors.RequestAbortedError)
-      resolve()
     })
   })
 
-  await promise
+  await p.completed
 })
 
 test('Abort while waiting response (write headers and write body started) (no body)', async (t) => {
@@ -174,7 +162,6 @@ test('Abort while waiting response (write headers and write body started) (no bo
   })
   t.after(server.close.bind(server))
 
-  const { promise, resolve } = promiseWithResolvers()
   server.listen(0, () => {
     const client = new Client(`http://localhost:${server.address().port}`)
     t.after(client.destroy.bind(client))
@@ -186,11 +173,10 @@ test('Abort while waiting response (write headers and write body started) (no bo
       })
       response.body.on('error', err => {
         ttype(p, err, errors.RequestAbortedError)
-        resolve()
       })
     })
   })
-  await promise
+  await p.completed
 })
 
 function waitingWithBody (body, type) {
@@ -205,17 +191,15 @@ function waitingWithBody (body, type) {
     })
     t.after(server.close.bind(server))
 
-    const { promise, resolve } = promiseWithResolvers()
     server.listen(0, () => {
       const client = new Client(`http://localhost:${server.address().port}`)
       t.after(client.destroy.bind(client))
 
       client.request({ path: '/', method: 'POST', body, signal: ee }, (err, response) => {
         ttype(p, err, errors.RequestAbortedError)
-        resolve()
       })
     })
-    await promise
+    await p.completed
   })
 }
 
@@ -237,17 +221,15 @@ function writeHeadersStartedWithBody (body, type) {
     })
     t.after(server.close.bind(server))
 
-    const { promise, resolve } = promiseWithResolvers()
     server.listen(0, () => {
       const client = new Client(`http://localhost:${server.address().port}`)
       t.after(client.destroy.bind(client))
 
       client.request({ path: '/', method: 'POST', body, signal: ee }, (err, response) => {
         ttype(p, err, errors.RequestAbortedError)
-        resolve()
       })
     })
-    await promise
+    await p.completed
   })
 }
 
@@ -267,7 +249,6 @@ function writeBodyStartedWithBody (body, type) {
     })
     t.after(server.close.bind(server))
 
-    const { promise, resolve } = promiseWithResolvers()
     server.listen(0, () => {
       const client = new Client(`http://localhost:${server.address().port}`)
       t.after(client.destroy.bind(client))
@@ -279,11 +260,10 @@ function writeBodyStartedWithBody (body, type) {
         })
         response.body.on('error', err => {
           ttype(p, err, errors.RequestAbortedError)
-          resolve()
         })
       })
     })
-    await promise
+    await p.completed
   })
 }
 

From 7feb96ade8732ab31c11cc133a736261088d8768 Mon Sep 17 00:00:00 2001
From: Sosuke Suzuki <sosuke.suzuki@dr-ubie.com>
Date: Mon, 1 Jan 2024 01:33:43 +0900
Subject: [PATCH 7/8] Update usage of `ttype`

---
 test/node-test/abort-event-emitter.js | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/test/node-test/abort-event-emitter.js b/test/node-test/abort-event-emitter.js
index da51d67323a..d795a73d341 100644
--- a/test/node-test/abort-event-emitter.js
+++ b/test/node-test/abort-event-emitter.js
@@ -42,7 +42,7 @@ test('Abort before sending request (no body)', async (t) => {
 
     const body = new Readable({ read () { } })
     body.on('error', (err) => {
-      ttype(p, err, errors.RequestAbortedError)
+      p.ok(ttype(err, errors.RequestAbortedError))
     })
     client.request({
       path: '/',
@@ -50,7 +50,7 @@ test('Abort before sending request (no body)', async (t) => {
       signal: ee,
       body
     }, (err, response) => {
-      ttype(p, err, errors.RequestAbortedError)
+      p.ok(ttype(err, errors.RequestAbortedError))
     })
 
     ee.emit('abort')
@@ -96,7 +96,7 @@ test('Abort before sending request (no body) async iterator', async (t) => {
       signal: ee,
       body
     }, (err, response) => {
-      ttype(p, err, errors.RequestAbortedError)
+      p.ok(ttype(err, errors.RequestAbortedError))
     })
 
     ee.emit('abort')
@@ -121,7 +121,7 @@ test('Abort while waiting response (no body)', async (t) => {
     t.after(client.destroy.bind(client))
 
     client.request({ path: '/', method: 'GET', signal: ee }, (err, response) => {
-      ttype(p, err, errors.RequestAbortedError)
+      p.ok(ttype(err, errors.RequestAbortedError))
     })
   })
 
@@ -145,7 +145,7 @@ test('Abort while waiting response (write headers started) (no body)', async (t)
     t.after(client.destroy.bind(client))
 
     client.request({ path: '/', method: 'GET', signal: ee }, (err, response) => {
-      ttype(p, err, errors.RequestAbortedError)
+      p.ok(ttype(err, errors.RequestAbortedError))
     })
   })
 
@@ -172,7 +172,7 @@ test('Abort while waiting response (write headers and write body started) (no bo
         ee.emit('abort')
       })
       response.body.on('error', err => {
-        ttype(p, err, errors.RequestAbortedError)
+        p.ok(ttype(err, errors.RequestAbortedError))
       })
     })
   })
@@ -196,7 +196,7 @@ function waitingWithBody (body, type) {
       t.after(client.destroy.bind(client))
 
       client.request({ path: '/', method: 'POST', body, signal: ee }, (err, response) => {
-        ttype(p, err, errors.RequestAbortedError)
+        p.ok(ttype(err, errors.RequestAbortedError))
       })
     })
     await p.completed
@@ -226,7 +226,7 @@ function writeHeadersStartedWithBody (body, type) {
       t.after(client.destroy.bind(client))
 
       client.request({ path: '/', method: 'POST', body, signal: ee }, (err, response) => {
-        ttype(p, err, errors.RequestAbortedError)
+        p.ok(ttype(err, errors.RequestAbortedError))
       })
     })
     await p.completed
@@ -259,7 +259,7 @@ function writeBodyStartedWithBody (body, type) {
           ee.emit('abort')
         })
         response.body.on('error', err => {
-          ttype(p, err, errors.RequestAbortedError)
+          p.ok(ttype(err, errors.RequestAbortedError))
         })
       })
     })

From cb4915ba0d51c445e8d3eeda2bbba2a09c74d8a8 Mon Sep 17 00:00:00 2001
From: Sosuke Suzuki <sosuke.suzuki@dr-ubie.com>
Date: Wed, 3 Jan 2024 14:08:24 +0900
Subject: [PATCH 8/8] Remove `ttype`

---
 test/node-test/abort-event-emitter.js | 19 ++++-----
 test/utils/node-test.js               | 60 ---------------------------
 2 files changed, 9 insertions(+), 70 deletions(-)
 delete mode 100644 test/utils/node-test.js

diff --git a/test/node-test/abort-event-emitter.js b/test/node-test/abort-event-emitter.js
index d795a73d341..d97407ae27a 100644
--- a/test/node-test/abort-event-emitter.js
+++ b/test/node-test/abort-event-emitter.js
@@ -8,7 +8,6 @@ const { createReadStream } = require('fs')
 const { Readable } = require('stream')
 const { tspl } = require('@matteo.collina/tspl')
 const { wrapWithAsyncIterable } = require('../utils/async-iterators')
-const { ttype } = require('../utils/node-test')
 
 test('Abort before sending request (no body)', async (t) => {
   const p = tspl(t, { plan: 4 })
@@ -42,7 +41,7 @@ test('Abort before sending request (no body)', async (t) => {
 
     const body = new Readable({ read () { } })
     body.on('error', (err) => {
-      p.ok(ttype(err, errors.RequestAbortedError))
+      p.ok(err instanceof errors.RequestAbortedError)
     })
     client.request({
       path: '/',
@@ -50,7 +49,7 @@ test('Abort before sending request (no body)', async (t) => {
       signal: ee,
       body
     }, (err, response) => {
-      p.ok(ttype(err, errors.RequestAbortedError))
+      p.ok(err instanceof errors.RequestAbortedError)
     })
 
     ee.emit('abort')
@@ -96,7 +95,7 @@ test('Abort before sending request (no body) async iterator', async (t) => {
       signal: ee,
       body
     }, (err, response) => {
-      p.ok(ttype(err, errors.RequestAbortedError))
+      p.ok(err instanceof errors.RequestAbortedError)
     })
 
     ee.emit('abort')
@@ -121,7 +120,7 @@ test('Abort while waiting response (no body)', async (t) => {
     t.after(client.destroy.bind(client))
 
     client.request({ path: '/', method: 'GET', signal: ee }, (err, response) => {
-      p.ok(ttype(err, errors.RequestAbortedError))
+      p.ok(err instanceof errors.RequestAbortedError)
     })
   })
 
@@ -145,7 +144,7 @@ test('Abort while waiting response (write headers started) (no body)', async (t)
     t.after(client.destroy.bind(client))
 
     client.request({ path: '/', method: 'GET', signal: ee }, (err, response) => {
-      p.ok(ttype(err, errors.RequestAbortedError))
+      p.ok(err instanceof errors.RequestAbortedError)
     })
   })
 
@@ -172,7 +171,7 @@ test('Abort while waiting response (write headers and write body started) (no bo
         ee.emit('abort')
       })
       response.body.on('error', err => {
-        p.ok(ttype(err, errors.RequestAbortedError))
+        p.ok(err instanceof errors.RequestAbortedError)
       })
     })
   })
@@ -196,7 +195,7 @@ function waitingWithBody (body, type) {
       t.after(client.destroy.bind(client))
 
       client.request({ path: '/', method: 'POST', body, signal: ee }, (err, response) => {
-        p.ok(ttype(err, errors.RequestAbortedError))
+        p.ok(err instanceof errors.RequestAbortedError)
       })
     })
     await p.completed
@@ -226,7 +225,7 @@ function writeHeadersStartedWithBody (body, type) {
       t.after(client.destroy.bind(client))
 
       client.request({ path: '/', method: 'POST', body, signal: ee }, (err, response) => {
-        p.ok(ttype(err, errors.RequestAbortedError))
+        p.ok(err instanceof errors.RequestAbortedError)
       })
     })
     await p.completed
@@ -259,7 +258,7 @@ function writeBodyStartedWithBody (body, type) {
           ee.emit('abort')
         })
         response.body.on('error', err => {
-          p.ok(ttype(err, errors.RequestAbortedError))
+          p.ok(err instanceof errors.RequestAbortedError)
         })
       })
     })
diff --git a/test/utils/node-test.js b/test/utils/node-test.js
deleted file mode 100644
index 250fd0b19c2..00000000000
--- a/test/utils/node-test.js
+++ /dev/null
@@ -1,60 +0,0 @@
-/**
- * A port of tap's `t.type` that can be used with `node:assert`
- * https://github.com/tapjs/tapjs/blob/511019b2ac0fa014370154c3a341a0e632f50b19/src/asserts/src/index.ts#L199
- */
-function ttype (obj, klass) {
-  const name =
-        typeof klass === 'function'
-          ? klass.name || '(anonymous constructor)'
-          : klass
-
-  if (obj === klass) {
-    return true
-  }
-
-  const tof = typeof obj
-  const type =
-        !obj && tof === 'object'
-          ? 'null'
-          // treat as object, but not Object
-          // t.type(() => {}, Function)
-          : tof === 'function' &&
-            typeof klass === 'function' &&
-            klass !== Object
-            ? 'object'
-            : tof
-
-  if (
-    (type === 'number' && klass === Number) ||
-      (type === 'string' && klass === String) ||
-      (type === 'bigint' && klass === BigInt) ||
-      (klass === 'array' && Array.isArray(obj)) ||
-      (type === 'symbol' && klass === Symbol)
-  ) {
-    return true
-  }
-
-  // simplest case, it literally is the same thing
-  if (type === 'object' && klass !== 'object') {
-    if (typeof klass === 'function') {
-      return obj instanceof klass
-    }
-
-    // check prototype chain for name
-    // at this point, we already know klass is not a function
-    // if the klass specified is an obj in the proto chain, pass
-    // if the name specified is the name of a ctor in the chain, pass
-    for (let p = obj; p; p = Object.getPrototypeOf(p)) {
-      const ctor = p.constructor && p.constructor.name
-      if (p === klass || ctor === name) {
-        return true
-      }
-    }
-  }
-
-  return type === name
-}
-
-module.exports = {
-  ttype
-}