refactor

Author: tsctx

benchmarks/websocket/server/echo.mjs …nchmarks/_util/websocket-echo-server.mjsbenchmarks/websocket/server/echo.mjs renamed to benchmarks/_util/websocket-echo-server.mjs benchmarks/websocket/server/echo.mjs renamed to benchmarks/_util/websocket-echo-server.mjs

@@ -2,18 +2,17 @@
 
 import { bench } from './_util/runner.js'
 import { WebSocket } from '../index.js'
+import { WebSocket as WsWebSocket } from 'ws'
 
 /**
  * @typedef {object} WebSocketImpl
  * @property {(buffer: Uint8Array | string) => void} send
- * @property {(name: string, listener: (...args: any) => void, options?: { once: boolean }) => void} addEventListener
- * @property {(name: string, listener: (...args: any) => void) => void} removeEventListener
  * @property {(code?: number, reason?: string) => void} close
  * @property {string} binaryType
  */
 
 /**
- * @type {Record<string, { fn: (ws: WebSocketImpl, binary: string | Uint8Array) => import('./_util/runner.js').BenchMarkHandler; connect: () => Promise<WebSocketImpl>; binaries: (string | Uint8Array)[] }>}
+ * @type {Record<string, { fn: (ws: WebSocketImpl, binary: string | Uint8Array) => import('./_util/runner.js').BenchMarkHandler; connect: (url: string) => Promise<WebSocketImpl>; binaries: (string | Uint8Array)[] }>}
  */
 const experiments = {}
 /**
@@ -27,38 +26,42 @@ const experimentsInfo = {}
 const connections = []
 
 const binary = Buffer.alloc(1024 * 256, '_')
+const binaries = [binary, binary.toString('utf-8')]
 
 experiments['undici'] = {
-  fn: (ws, binary) => async (ev) => {
-    await /** @type {Promise<void>} */(new Promise((resolve, _reject) => {
+  fn: (ws, binary) => {
+    if (!(ws instanceof WebSocket)) {
+      throw new Error("'undici' websocket are expected.")
+    }
+
+    return (ev) => {
       ws.addEventListener(
         'message',
         () => {
           ev.end()
-          resolve()
         },
         { once: true }
       )
 
       ev.start()
       ws.send(binary)
-    }))
+    }
   },
 
-  connect: async () => {
-    const ws = new WebSocket('ws://localhost:5001')
+  connect: async (url) => {
+    const ws = new WebSocket(url)
 
     await /** @type {Promise<void>} */ (
       new Promise((resolve, reject) => {
         function onOpen () {
           resolve()
-          this.removeEventListener('open', onOpen)
-          this.removeEventListener('error', onError)
+          ws.removeEventListener('open', onOpen)
+          ws.removeEventListener('error', onError)
         }
         function onError (err) {
           reject(err)
-          this.removeEventListener('open', onOpen)
-          this.removeEventListener('error', onError)
+          ws.removeEventListener('open', onOpen)
+          ws.removeEventListener('error', onError)
         }
         ws.addEventListener('open', onOpen)
         ws.addEventListener('error', onError)
@@ -71,7 +74,50 @@ experiments['undici'] = {
     return ws
   },
 
-  binaries: [binary, binary.toString('utf-8')]
+  binaries
+}
+
+experiments['ws'] = {
+  fn: (ws, binary) => {
+    if (!(ws instanceof WsWebSocket)) {
+      throw new Error("'ws' websocket are expected.")
+    }
+
+    return (ev) => {
+      ws.once('message', () => {
+        ev.end()
+      })
+      ev.start()
+      ws.send(binary)
+    }
+  },
+
+  connect: async (url) => {
+    const ws = new WsWebSocket(url)
+
+    await /** @type {Promise<void>} */ (
+      new Promise((resolve, reject) => {
+        function onOpen () {
+          resolve()
+          ws.off('open', onOpen)
+          ws.off('error', onError)
+        }
+        function onError (err) {
+          reject(err)
+          ws.off('open', onOpen)
+          ws.off('error', onError)
+        }
+        ws.on('open', onOpen)
+        ws.on('error', onError)
+      })
+    )
+
+    ws.binaryType = 'arraybuffer'
+
+    return ws
+  },
+
+  binaries
 }
 
 async function init () {
@@ -85,14 +131,14 @@ async function init () {
 
     const { fn, connect, binaries } = experiments[name]
 
-    const ws = await connect()
+    const ws = await connect('ws://localhost:5001')
 
     for (let i = 0; i < binaries.length; ++i) {
       const binary = binaries[i]
       const bytes = Buffer.byteLength(binary)
 
       const binaryType = typeof binary === 'string' ? 'string' : 'binary'
-      const roundName = `${name} [${(bytes / (1024)).toFixed(2)}Kib (${binaryType})]`
+      const roundName = `${name} [${Math.floor(bytes / (1024))}Kib (${binaryType})]`
       round[roundName] = fn(ws, binary)
       experimentsInfo[roundName] = { bytes, binaryType }
     }