quickwin 1.0.1 → 1.1.0

package/test/test_net_event.ts

@@ -1,55 +1,55 @@
-import * as sock from "sock"
-import * as os from "os"
-import { Tester } from './test_helper.js'
-
-interface WSAEvent {
-    lNetworkEvents: number;
-    iErrorCode: number[];
-}
-
-export const suite = {
-    name: 'net-event',
-    run: async (t: Tester): Promise<void> => {
-        await new Promise<void>((resolve, reject) => {
-            const s = sock.socket()
-            if (s === null || s < 0) { t.fail++; reject(new Error('socket() failed')); return }
-
-            var connected = false, gotData = false
-
-            const timeoutId = os.setTimeout(() => {
-                if (!connected) {
-                    sock.closesocket(s)
-                    reject(new Error('connect timeout'))
-                }
-            }, 5000)
-
-            sock.set_on_event(s, (event: WSAEvent) => {
-                if (event.lNetworkEvents & sock.FdEvent.FD_CONNECT) {
-                    if (event.iErrorCode[0] === 0) {
-                        connected = true; t.ok++
-                        os.clearTimeout(timeoutId)
-                        const req = "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n"
-                        const buf = new ArrayBuffer(req.length)
-                        const v = new Uint8Array(buf)
-                        for (let i = 0; i < req.length; i++) v[i] = req.charCodeAt(i)
-                        sock.send(s, buf)
-                    } else {
-                        sock.closesocket(s)
-                        reject(new Error('connect error: ' + event.iErrorCode[0]))
-                    }
-                }
-                if (event.lNetworkEvents & sock.FdEvent.FD_READ && connected && !gotData) {
-                    const data = sock.recv(s, 4096)
-                    if (data && data.byteLength > 0) { gotData = true; t.ok++ }
-                }
-                if (event.lNetworkEvents & sock.FdEvent.FD_CLOSE) {
-                    os.clearTimeout(timeoutId)
-                    sock.closesocket(s)
-                    if (gotData && connected) resolve()
-                    else reject(new Error('test incomplete'))
-                }
-            })
-            sock.connect(s, '127.0.0.1', 18923)
-        })
-    }
-}
+import * as sock from "sock"
+import * as os from "os"
+import { Tester } from './test_helper.js'
+
+interface WSAEvent {
+    lNetworkEvents: number;
+    iErrorCode: number[];
+}
+
+export const suite = {
+    name: 'net-event',
+    run: async (t: Tester): Promise<void> => {
+        await new Promise<void>((resolve, reject) => {
+            const s = sock.socket()
+            if (s === null || s < 0) { t.fail++; reject(new Error('socket() failed')); return }
+
+            var connected = false, gotData = false
+
+            const timeoutId = os.setTimeout(() => {
+                if (!connected) {
+                    sock.closesocket(s)
+                    reject(new Error('connect timeout'))
+                }
+            }, 5000)
+
+            sock.set_on_event(s, (event: WSAEvent) => {
+                if (event.lNetworkEvents & sock.FdEvent.FD_CONNECT) {
+                    if (event.iErrorCode[0] === 0) {
+                        connected = true; t.ok++
+                        os.clearTimeout(timeoutId)
+                        const req = "GET / HTTP/1.1\r\nHost: localhost\r\nConnection: close\r\n\r\n"
+                        const buf = new ArrayBuffer(req.length)
+                        const v = new Uint8Array(buf)
+                        for (let i = 0; i < req.length; i++) v[i] = req.charCodeAt(i)
+                        sock.send(s, buf)
+                    } else {
+                        sock.closesocket(s)
+                        reject(new Error('connect error: ' + event.iErrorCode[0]))
+                    }
+                }
+                if (event.lNetworkEvents & sock.FdEvent.FD_READ && connected && !gotData) {
+                    const data = sock.recv(s, 4096)
+                    if (data && data.byteLength > 0) { gotData = true; t.ok++ }
+                }
+                if (event.lNetworkEvents & sock.FdEvent.FD_CLOSE) {
+                    os.clearTimeout(timeoutId)
+                    sock.closesocket(s)
+                    if (gotData && connected) resolve()
+                    else reject(new Error('test incomplete'))
+                }
+            })
+            sock.connect(s, '127.0.0.1', 18923)
+        })
+    }
+}

package/test/test_net_fetch.ts

@@ -1,238 +1,238 @@
-import '../lib/fetch.js'
-import * as std from 'std'
-import { Tester } from './test_helper.js'
-
-export const suite = {
-    name: 'net-fetch',
-    run: async (t: Tester) => {
-        function assert(name: string, ok: boolean): void {
-            if (ok) { t.ok++; std.printf('  PASS: %s\n', name) }
-            else { t.fail++; std.printf('  FAIL: %s\n', name) }
-        }
-
-        async function safeFetch(url: any, init?: RequestInit) {
-            try {
-                return await fetch(url, init);
-            } catch {
-                return null;
-            }
-        }
-        const BASE = 'http://localhost:18923'
-
-        // ── Plain HTTP GET (regression: slot 0 + !s bug) ──
-        t.section('plain HTTP')
-        const r0 = await safeFetch(BASE + '/', { timeout: 5000 })
-        if (r0) {
-            assert('plain HTTP status 200', r0.status === 200)
-            const body = await r0.text()
-            assert('plain HTTP body non-empty', body.length > 0)
-            assert('plain HTTP body matches', body === 'hello from test server')
-        } else {
-            assert('plain HTTP endpoint reachable', false)
-        }
-
-        // ── Basic HTTP GET ──
-        t.section('HTTP GET')
-        const r1 = await safeFetch(BASE + '/any')
-        if (r1) {
-            assert('status received', r1.status > 0)
-            const body = await r1.text()
-            assert('body received', body.length > 0)
-        } else {
-            assert('local server reachable', false)
-        }
-
-        // ── Query string ──
-        t.section('query string')
-        const rq = await safeFetch(BASE + '/any?foo=bar&baz=42')
-        if (rq) {
-            const body = JSON.parse(await rq.text())
-            assert('query args received', body.args !== undefined)
-            assert('?foo=bar preserved', body.args.foo === 'bar')
-            assert('?baz=42 preserved', body.args.baz === '42')
-        } else {
-            assert('query string endpoint reachable', false)
-        }
-
-        // ── Request constructor ──
-        t.section('Request constructor')
-        {
-            const r = new Request('https://httpbun.com/any?x=1&y=2', { method: 'POST', headers: { 'X-Test': 'val' }, body: 'hello' })
-            assert('Request.url', r.url === 'https://httpbun.com/any?x=1&y=2')
-            assert('Request.method', r.method === 'POST')
-            assert('Request.headers get', r.headers.get('x-test') === 'val')
-            assert('Request.body is ReadableStream', r.body !== null && typeof r.body.getReader === 'function')
-        }
-        {
-            const r1 = new Request('https://example.com/path')
-            assert('Request default method GET', r1.method === 'GET')
-            assert('Request default redirect follow', r1.redirect === 'follow')
-        }
-        {
-            const r2 = new Request('https://httpbun.com/any')
-            const r3 = new Request(r2, { method: 'PUT' })
-            assert('Request clone same url', r3.url === r2.url)
-            assert('Request clone override method', r3.method === 'PUT')
-        }
-        {
-            const r = await safeFetch(new Request(BASE + '/any', { method: 'POST', headers: { 'Content-Type': 'text/plain' }, body: 'req-class' }))
-            if (r) {
-                const body = JSON.parse(await r.text())
-                assert('fetch(Request) status', r.status > 0)
-                assert('fetch(Request) method POST', body.method === 'POST')
-                assert('fetch(Request) body received', body.data === 'req-class')
-                assert('fetch(Request) content-type', body.headers['content-type'] === 'text/plain')
-            } else {
-                assert('fetch(Request) endpoint reachable', false)
-            }
-        }
-
-        // ── body / bodyUsed / stream ──
-        t.section('body / bodyUsed / stream')
-        const r2 = await safeFetch(BASE + '/any')
-        if (r2) {
-            assert('r.body exists', typeof r2.body === 'object' && r2.body !== null)
-            assert('bodyUsed false before read', r2.bodyUsed === false)
-
-            const reader = r2.body!.getReader()
-            let total = 0
-            while (true) {
-                const { done, value } = await reader.read()
-                if (done) break
-                total += value.length
-            }
-            assert('reader streams all bytes', total > 0)
-            assert('bodyUsed true after stream', r2.bodyUsed === true)
-        } else {
-            assert('body test endpoint reachable', false)
-        }
-
-        // ── text/json/arrayBuffer ──
-        t.section('text / json / arrayBuffer')
-        const r3 = await safeFetch(BASE + '/any')
-        if (r3) {
-            const text = await r3.text()
-            assert('text() returns string', typeof text === 'string' && text.length > 0)
-            assert('bodyUsed true after text()', r3.bodyUsed === true)
-
-            const r4 = await safeFetch(BASE + '/any')
-            if (r4) {
-                const buf = await r4.arrayBuffer()
-                assert('arrayBuffer() returns bytes', buf.byteLength > 0)
-            }
-        } else {
-            assert('text/json/ab endpoint reachable', false)
-        }
-
-        // double text() throws
-        t.section('bodyUsed throws')
-        const r5 = await safeFetch(BASE + '/any')
-        if (r5) {
-            await r5.text()
-            try { await r5.text(); assert('double text() throws', false) }
-            catch (e: unknown) { assert('double text() throws TypeError', (e as Error).message === 'Body already used') }
-        }
-
-        // ── POST ──
-        t.section('POST')
-        const r6 = await safeFetch(BASE + '/any', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({ msg: 'hello' })
-        })
-        if (r6) {
-            const body = await r6.text()
-            assert('POST body received', body.length > 0)
-        } else {
-            assert('POST endpoint reachable', false)
-        }
-
-        // ── Headers (local, no network) ──
-        t.section('Headers (local)')
-        const h = new Headers({ 'Content-Type': 'text/html', 'X-Custom': 'hello', 'Accept': '*/*' })
-        let c = 0
-        for (const [k, v] of h) { c++; if (typeof k !== 'string' || typeof v !== 'string') assert('for...of type', false) }
-        assert('for...of yields entries', c === 3)
-        assert('get()', h.get('content-type') === 'text/html')
-        assert('get() case-insensitive', h.get('Content-Type') === 'text/html')
-        assert('has()', h.has('x-custom'))
-        assert('set() overwrites', (h.set('accept', 'application/json'), h.get('accept') === 'application/json'))
-        assert('append() adds', (h.append('accept', 'text/plain'), h.get('accept') === 'application/json, text/plain'))
-        assert('delete()', (h.delete('accept'), h.has('accept') === false))
-
-        const h2 = new Headers({ 'a': '1', 'b': '2' })
-        let ec = 0; for (const _ of h2.entries()) { ec++ }
-        assert('entries()', ec === 2)
-        let kc = 0; for (const _ of h2.keys()) { kc++ }
-        assert('keys()', kc === 2)
-        let vc = 0; for (const _ of h2.values()) { vc++ }
-        assert('values()', vc === 2)
-
-        // ── Chunked Transfer-Encoding ──
-        t.section('chunked transfer encoding')
-        const r8 = await safeFetch(BASE + '/anything')
-        if (r8) {
-            assert('chunked status 200', r8.status === 200)
-            const body = await r8.json<{ url: string }>()
-            assert('chunked json has url', typeof body.url === 'string' && body.url.length > 0)
-        } else {
-            assert('local server reachable', false)
-        }
-
-        // ── stream cancel ──
-        t.section('stream cancel')
-        const r7 = await safeFetch(BASE + '/any')
-        if (r7) {
-            r7.body!.cancel()
-            assert('cancel() succeeds', true)
-            // After cancel: buffered chunks still readable, then done
-            const reader = r7.body!.getReader()
-            let finalDone = false
-            while (true) {
-                const { done } = await reader.read()
-                if (done) { finalDone = true; break }
-            }
-            assert('reader done after cancel', finalDone === true)
-        } else {
-            assert('cancel test endpoint reachable', false)
-        }
-
-        // ── UTF-8 Chinese text body ──
-        t.section('utf-8 chinese text')
-        const r9 = await safeFetch(BASE + '/base64/5Lit5paH')
-        if (r9) {
-            assert('chinese status 200', r9.status === 200)
-            const body = await r9.text()
-            assert('chinese body is 中文', body === '\u4e2d\u6587')
-            assert('chinese body length=2', body.length === 2)
-        } else {
-            assert('local server reachable', false)
-        }
-
-        // ── POST with Chinese body ──
-        t.section('post with chinese body')
-        const r10 = await safeFetch(BASE + '/post', {
-            method: 'POST',
-            body: '\u4e2d\u6587',
-            headers: { 'Content-Type': 'text/plain; charset=utf-8' }
-        })
-        if (r10) {
-            assert('post status 200', r10.status === 200)
-            const body = await r10.text()
-            assert('post body contains 中文', body.includes('\u4e2d\u6587'))
-        } else {
-            assert('local server reachable', false)
-        }
-
-        // ── HTTPS fetch ──
-        t.section('HTTPS fetch')
-        const r11 = await safeFetch('https://localhost:18924/', { timeout: 5000 })
-        if (r11) {
-            assert('https status 200', r11.status === 200)
-            const body = await r11.text()
-            assert('https body matches', body === 'hello from test server')
-        } else {
-            assert('https endpoint reachable', false)
-        }
-    }
-}
+import '../lib/fetch.js'
+import * as std from 'std'
+import { Tester } from './test_helper.js'
+
+export const suite = {
+    name: 'net-fetch',
+    run: async (t: Tester) => {
+        function assert(name: string, ok: boolean): void {
+            if (ok) { t.ok++; std.printf('  PASS: %s\n', name) }
+            else { t.fail++; std.printf('  FAIL: %s\n', name) }
+        }
+
+        async function safeFetch(url: any, init?: RequestInit) {
+            try {
+                return await fetch(url, init);
+            } catch {
+                return null;
+            }
+        }
+        const BASE = 'http://localhost:18923'
+
+        // ── Plain HTTP GET (regression: slot 0 + !s bug) ──
+        t.section('plain HTTP')
+        const r0 = await safeFetch(BASE + '/', { timeout: 5000 })
+        if (r0) {
+            assert('plain HTTP status 200', r0.status === 200)
+            const body = await r0.text()
+            assert('plain HTTP body non-empty', body.length > 0)
+            assert('plain HTTP body matches', body === 'hello from test server')
+        } else {
+            assert('plain HTTP endpoint reachable', false)
+        }
+
+        // ── Basic HTTP GET ──
+        t.section('HTTP GET')
+        const r1 = await safeFetch(BASE + '/any')
+        if (r1) {
+            assert('status received', r1.status > 0)
+            const body = await r1.text()
+            assert('body received', body.length > 0)
+        } else {
+            assert('local server reachable', false)
+        }
+
+        // ── Query string ──
+        t.section('query string')
+        const rq = await safeFetch(BASE + '/any?foo=bar&baz=42')
+        if (rq) {
+            const body = JSON.parse(await rq.text())
+            assert('query args received', body.args !== undefined)
+            assert('?foo=bar preserved', body.args.foo === 'bar')
+            assert('?baz=42 preserved', body.args.baz === '42')
+        } else {
+            assert('query string endpoint reachable', false)
+        }
+
+        // ── Request constructor ──
+        t.section('Request constructor')
+        {
+            const r = new Request('https://httpbun.com/any?x=1&y=2', { method: 'POST', headers: { 'X-Test': 'val' }, body: 'hello' })
+            assert('Request.url', r.url === 'https://httpbun.com/any?x=1&y=2')
+            assert('Request.method', r.method === 'POST')
+            assert('Request.headers get', r.headers.get('x-test') === 'val')
+            assert('Request.body is ReadableStream', r.body !== null && typeof r.body.getReader === 'function')
+        }
+        {
+            const r1 = new Request('https://example.com/path')
+            assert('Request default method GET', r1.method === 'GET')
+            assert('Request default redirect follow', r1.redirect === 'follow')
+        }
+        {
+            const r2 = new Request('https://httpbun.com/any')
+            const r3 = new Request(r2, { method: 'PUT' })
+            assert('Request clone same url', r3.url === r2.url)
+            assert('Request clone override method', r3.method === 'PUT')
+        }
+        {
+            const r = await safeFetch(new Request(BASE + '/any', { method: 'POST', headers: { 'Content-Type': 'text/plain' }, body: 'req-class' }))
+            if (r) {
+                const body = JSON.parse(await r.text())
+                assert('fetch(Request) status', r.status > 0)
+                assert('fetch(Request) method POST', body.method === 'POST')
+                assert('fetch(Request) body received', body.data === 'req-class')
+                assert('fetch(Request) content-type', body.headers['content-type'] === 'text/plain')
+            } else {
+                assert('fetch(Request) endpoint reachable', false)
+            }
+        }
+
+        // ── body / bodyUsed / stream ──
+        t.section('body / bodyUsed / stream')
+        const r2 = await safeFetch(BASE + '/any')
+        if (r2) {
+            assert('r.body exists', typeof r2.body === 'object' && r2.body !== null)
+            assert('bodyUsed false before read', r2.bodyUsed === false)
+
+            const reader = r2.body!.getReader()
+            let total = 0
+            while (true) {
+                const { done, value } = await reader.read()
+                if (done) break
+                total += value.length
+            }
+            assert('reader streams all bytes', total > 0)
+            assert('bodyUsed true after stream', r2.bodyUsed === true)
+        } else {
+            assert('body test endpoint reachable', false)
+        }
+
+        // ── text/json/arrayBuffer ──
+        t.section('text / json / arrayBuffer')
+        const r3 = await safeFetch(BASE + '/any')
+        if (r3) {
+            const text = await r3.text()
+            assert('text() returns string', typeof text === 'string' && text.length > 0)
+            assert('bodyUsed true after text()', r3.bodyUsed === true)
+
+            const r4 = await safeFetch(BASE + '/any')
+            if (r4) {
+                const buf = await r4.arrayBuffer()
+                assert('arrayBuffer() returns bytes', buf.byteLength > 0)
+            }
+        } else {
+            assert('text/json/ab endpoint reachable', false)
+        }
+
+        // double text() throws
+        t.section('bodyUsed throws')
+        const r5 = await safeFetch(BASE + '/any')
+        if (r5) {
+            await r5.text()
+            try { await r5.text(); assert('double text() throws', false) }
+            catch (e: unknown) { assert('double text() throws TypeError', (e as Error).message === 'Body already used') }
+        }
+
+        // ── POST ──
+        t.section('POST')
+        const r6 = await safeFetch(BASE + '/any', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ msg: 'hello' })
+        })
+        if (r6) {
+            const body = await r6.text()
+            assert('POST body received', body.length > 0)
+        } else {
+            assert('POST endpoint reachable', false)
+        }
+
+        // ── Headers (local, no network) ──
+        t.section('Headers (local)')
+        const h = new Headers({ 'Content-Type': 'text/html', 'X-Custom': 'hello', 'Accept': '*/*' })
+        let c = 0
+        for (const [k, v] of h) { c++; if (typeof k !== 'string' || typeof v !== 'string') assert('for...of type', false) }
+        assert('for...of yields entries', c === 3)
+        assert('get()', h.get('content-type') === 'text/html')
+        assert('get() case-insensitive', h.get('Content-Type') === 'text/html')
+        assert('has()', h.has('x-custom'))
+        assert('set() overwrites', (h.set('accept', 'application/json'), h.get('accept') === 'application/json'))
+        assert('append() adds', (h.append('accept', 'text/plain'), h.get('accept') === 'application/json, text/plain'))
+        assert('delete()', (h.delete('accept'), h.has('accept') === false))
+
+        const h2 = new Headers({ 'a': '1', 'b': '2' })
+        let ec = 0; for (const _ of h2.entries()) { ec++ }
+        assert('entries()', ec === 2)
+        let kc = 0; for (const _ of h2.keys()) { kc++ }
+        assert('keys()', kc === 2)
+        let vc = 0; for (const _ of h2.values()) { vc++ }
+        assert('values()', vc === 2)
+
+        // ── Chunked Transfer-Encoding ──
+        t.section('chunked transfer encoding')
+        const r8 = await safeFetch(BASE + '/anything')
+        if (r8) {
+            assert('chunked status 200', r8.status === 200)
+            const body = await r8.json<{ url: string }>()
+            assert('chunked json has url', typeof body.url === 'string' && body.url.length > 0)
+        } else {
+            assert('local server reachable', false)
+        }
+
+        // ── stream cancel ──
+        t.section('stream cancel')
+        const r7 = await safeFetch(BASE + '/any')
+        if (r7) {
+            r7.body!.cancel()
+            assert('cancel() succeeds', true)
+            // After cancel: buffered chunks still readable, then done
+            const reader = r7.body!.getReader()
+            let finalDone = false
+            while (true) {
+                const { done } = await reader.read()
+                if (done) { finalDone = true; break }
+            }
+            assert('reader done after cancel', finalDone === true)
+        } else {
+            assert('cancel test endpoint reachable', false)
+        }
+
+        // ── UTF-8 Chinese text body ──
+        t.section('utf-8 chinese text')
+        const r9 = await safeFetch(BASE + '/base64/5Lit5paH')
+        if (r9) {
+            assert('chinese status 200', r9.status === 200)
+            const body = await r9.text()
+            assert('chinese body is 中文', body === '\u4e2d\u6587')
+            assert('chinese body length=2', body.length === 2)
+        } else {
+            assert('local server reachable', false)
+        }
+
+        // ── POST with Chinese body ──
+        t.section('post with chinese body')
+        const r10 = await safeFetch(BASE + '/post', {
+            method: 'POST',
+            body: '\u4e2d\u6587',
+            headers: { 'Content-Type': 'text/plain; charset=utf-8' }
+        })
+        if (r10) {
+            assert('post status 200', r10.status === 200)
+            const body = await r10.text()
+            assert('post body contains 中文', body.includes('\u4e2d\u6587'))
+        } else {
+            assert('local server reachable', false)
+        }
+
+        // ── HTTPS fetch ──
+        t.section('HTTPS fetch')
+        const r11 = await safeFetch('https://localhost:18924/', { timeout: 5000 })
+        if (r11) {
+            assert('https status 200', r11.status === 200)
+            const body = await r11.text()
+            assert('https body matches', body === 'hello from test server')
+        } else {
+            assert('https endpoint reachable', false)
+        }
+    }
+}