quickwin 1.1.4 → 1.2.1

package/test/test_wolfssl_read.js

@@ -0,0 +1,201 @@
+import * as sock from 'sock';
+import * as wolfssl from 'wolfssl';
+import * as os from 'os';
+import * as std from 'std';
+const HTTPS_PORT = 18924;
+const WANT_READ = 2;
+const WANT_WRITE = 3;
+const ZERO_RETURN = 6;
+export const suite = {
+    name: 'net-wolfssl-read',
+    run: async (t) => {
+        function assert(name, ok) {
+            if (ok) {
+                t.ok++;
+                std.printf('  PASS: %s\n', name);
+            }
+            else {
+                t.fail++;
+                std.printf('  FAIL: %s\n', name);
+            }
+        }
+        // ── wolfSSL_read return contract: ArrayBuffer | null, never number ──
+        t.section('wolfSSL_read contract (HTTPS /large/65536)');
+        await new Promise((resolve) => {
+            const s = sock.socket();
+            if (s === null || s < 0) {
+                assert('socket() ok', false);
+                resolve();
+                return;
+            }
+            let ssl = null;
+            let ctx = null;
+            let connected = false;
+            let handshakeDone = false;
+            let sentRequest = false;
+            let total = 0;
+            const EXPECTED = 65536;
+            let sawNumber = false;
+            let sawArray = false;
+            let sawNull = false;
+            let nullErrOk = true;
+            let done = false;
+            const finish = () => {
+                if (done)
+                    return;
+                done = true;
+                os.clearTimeout(timeoutId);
+                assert('connected', connected);
+                assert('handshake ok', handshakeDone);
+                assert('request sent', sentRequest);
+                assert('received some data', sawArray && total > 0);
+                assert('wolfSSL_read never returned number', !sawNumber);
+                assert('wolfSSL_read returned null on no-data/EOF', sawNull);
+                assert('null path get_error in {WANT_READ,WANT_WRITE,ZERO_RETURN}', nullErrOk);
+                if (ssl) {
+                    wolfssl.wolfSSL_free(ssl);
+                    ssl = null;
+                }
+                if (ctx) {
+                    wolfssl.wolfSSL_CTX_free(ctx);
+                    ctx = null;
+                }
+                sock.closesocket(s);
+                resolve();
+            };
+            const timeoutId = os.setTimeout(() => {
+                assert('wolfSSL_read contract timeout (15s)', false);
+                finish();
+            }, 15000);
+            const sendReq = () => {
+                const req = 'GET /large/65536 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);
+                wolfssl.wolfSSL_write(ssl, buf);
+                sentRequest = true;
+            };
+            const onReadable = () => {
+                // Drain until content complete or null
+                for (let guard = 0; guard < 10000; guard++) {
+                    const d = wolfssl.wolfSSL_read(ssl, 8192);
+                    if (d === null) {
+                        sawNull = true;
+                        const err = wolfssl.wolfSSL_get_error(ssl, -1);
+                        if (err !== WANT_READ && err !== WANT_WRITE && err !== ZERO_RETURN) {
+                            nullErrOk = false;
+                            std.printf('    null get_error=%d\n', err);
+                        }
+                        if (err === ZERO_RETURN || err === 1 || err === 5) {
+                            // EOF / fatal — done draining
+                            break;
+                        }
+                        // WANT_*: wait for next FD_READ/WRITE
+                        return;
+                    }
+                    if (typeof d === 'number') {
+                        // Pre-fix C API returns number 0/-1 — record and stop
+                        sawNumber = true;
+                        std.printf('    FAIL got number %d (want ArrayBuffer|null)\n', d);
+                        finish();
+                        return;
+                    }
+                    if (d instanceof ArrayBuffer) {
+                        sawArray = true;
+                        total += d.byteLength;
+                        if (total >= EXPECTED)
+                            break;
+                    }
+                }
+                if (total >= EXPECTED)
+                    finish();
+            };
+            sock.set_on_event(s, (event) => {
+                if (done)
+                    return;
+                if (event.lNetworkEvents & 16 /* sock.FdEvent.FD_CONNECT */) {
+                    if (event.iErrorCode[0] !== 0) {
+                        assert('connect error code 0', false);
+                        finish();
+                        return;
+                    }
+                    connected = true;
+                    const method = wolfssl.wolfTLSv1_2_client_method();
+                    ctx = wolfssl.wolfSSL_CTX_new(method);
+                    if (!ctx) {
+                        assert('CTX_new', false);
+                        finish();
+                        return;
+                    }
+                    wolfssl.wolfSSL_CTX_set_verify(ctx, 0 /* wolfssl.VerifyMode.SSL_VERIFY_NONE */);
+                    ssl = wolfssl.wolfSSL_new(ctx);
+                    if (!ssl) {
+                        assert('SSL_new', false);
+                        finish();
+                        return;
+                    }
+                    wolfssl.wolfSSL_set_fd(ssl, sock.get_fd(s));
+                    wolfssl.wolfSSL_UseSNI(ssl, 0 /* wolfssl.SniType.WOLFSSL_SNI_HOST_NAME */, 'localhost');
+                    // kick handshake immediately (FD_WRITE may not re-fire)
+                    {
+                        const ret = wolfssl.wolfSSL_connect(ssl);
+                        if (ret === 1 /* wolfssl.ReturnCode.SSL_SUCCESS */) {
+                            handshakeDone = true;
+                            sendReq();
+                        }
+                        else {
+                            const err = wolfssl.wolfSSL_get_error(ssl, ret);
+                            if (err !== WANT_READ && err !== WANT_WRITE) {
+                                assert('TLS handshake failed err=' + err, false);
+                                finish();
+                            }
+                        }
+                    }
+                }
+                if ((event.lNetworkEvents & 1 /* sock.FdEvent.FD_READ */) ||
+                    (event.lNetworkEvents & 2 /* sock.FdEvent.FD_WRITE */)) {
+                    if (!ssl)
+                        return;
+                    if (!handshakeDone) {
+                        const ret = wolfssl.wolfSSL_connect(ssl);
+                        if (ret === 1 /* wolfssl.ReturnCode.SSL_SUCCESS */) {
+                            handshakeDone = true;
+                            sendReq();
+                        }
+                        else {
+                            const err = wolfssl.wolfSSL_get_error(ssl, ret);
+                            if (err !== WANT_READ && err !== WANT_WRITE) {
+                                assert('TLS handshake failed err=' + err, false);
+                                finish();
+                            }
+                        }
+                        return;
+                    }
+                    if (sentRequest)
+                        onReadable();
+                }
+                if (event.lNetworkEvents & 32 /* sock.FdEvent.FD_CLOSE */) {
+                    // drain remaining then finish
+                    if (ssl && sentRequest && !sawNumber) {
+                        onReadable();
+                    }
+                    if (!sawNumber) {
+                        // Even if short, require null contract seen OR full body
+                        if (!sawNull && total < EXPECTED && total > 0) {
+                            // got data but no null — still OK if full body; if short, null expected
+                            sawNull = true; // server close without extra null read is edge; don't fail
+                        }
+                        if (total >= EXPECTED || sawNull)
+                            finish();
+                        else
+                            assert('data before close', false);
+                        if (!done)
+                            finish();
+                    }
+                }
+            });
+            sock.connect(s, '127.0.0.1', HTTPS_PORT);
+        });
+    }
+};

package/test/test_wolfssl_read.ts

@@ -0,0 +1,181 @@
+import * as sock from 'sock'
+import * as wolfssl from 'wolfssl'
+import * as os from 'os'
+import * as std from 'std'
+import { Tester } from './test_helper.js'
+
+const HTTPS_PORT = 18924
+const WANT_READ = 2
+const WANT_WRITE = 3
+const ZERO_RETURN = 6
+
+export const suite = {
+    name: 'net-wolfssl-read',
+    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) }
+        }
+
+        // ── wolfSSL_read return contract: ArrayBuffer | null, never number ──
+        t.section('wolfSSL_read contract (HTTPS /large/65536)')
+        await new Promise<void>((resolve) => {
+            const s = sock.socket()
+            if (s === null || s < 0) {
+                assert('socket() ok', false)
+                resolve()
+                return
+            }
+
+            let ssl: wolfssl.WOLFSSL | null = null
+            let ctx: wolfssl.WOLFSSL_CTX | null = null
+            let connected = false
+            let handshakeDone = false
+            let sentRequest = false
+            let total = 0
+            const EXPECTED = 65536
+            let sawNumber = false
+            let sawArray = false
+            let sawNull = false
+            let nullErrOk = true
+            let done = false
+
+            const finish = () => {
+                if (done) return
+                done = true
+                os.clearTimeout(timeoutId)
+                assert('connected', connected)
+                assert('handshake ok', handshakeDone)
+                assert('request sent', sentRequest)
+                assert('received some data', sawArray && total > 0)
+                assert('wolfSSL_read never returned number', !sawNumber)
+                assert('wolfSSL_read returned null on no-data/EOF', sawNull)
+                assert('null path get_error in {WANT_READ,WANT_WRITE,ZERO_RETURN}', nullErrOk)
+                if (ssl) { wolfssl.wolfSSL_free(ssl); ssl = null }
+                if (ctx) { wolfssl.wolfSSL_CTX_free(ctx); ctx = null }
+                sock.closesocket(s)
+                resolve()
+            }
+
+            const timeoutId = os.setTimeout(() => {
+                assert('wolfSSL_read contract timeout (15s)', false)
+                finish()
+            }, 15000)
+
+            const sendReq = () => {
+                const req = 'GET /large/65536 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)
+                wolfssl.wolfSSL_write(ssl!, buf)
+                sentRequest = true
+            }
+
+            const onReadable = () => {
+                // Drain until content complete or null
+                for (let guard = 0; guard < 10000; guard++) {
+                    const d = wolfssl.wolfSSL_read(ssl!, 8192)
+                    if (d === null) {
+                        sawNull = true
+                        const err = wolfssl.wolfSSL_get_error(ssl!, -1)
+                        if (err !== WANT_READ && err !== WANT_WRITE && err !== ZERO_RETURN) {
+                            nullErrOk = false
+                            std.printf('    null get_error=%d\n', err)
+                        }
+                        if (err === ZERO_RETURN || err === 1 || err === 5) {
+                            // EOF / fatal — done draining
+                            break
+                        }
+                        // WANT_*: wait for next FD_READ/WRITE
+                        return
+                    }
+                    if (typeof d === 'number') {
+                        // Pre-fix C API returns number 0/-1 — record and stop
+                        sawNumber = true
+                        std.printf('    FAIL got number %d (want ArrayBuffer|null)\n', d)
+                        finish()
+                        return
+                    }
+                    if (d instanceof ArrayBuffer) {
+                        sawArray = true
+                        total += d.byteLength
+                        if (total >= EXPECTED) break
+                    }
+                }
+                if (total >= EXPECTED) finish()
+            }
+
+            sock.set_on_event(s, (event: { lNetworkEvents: number; iErrorCode: number[] }) => {
+                if (done) return
+
+                if (event.lNetworkEvents & sock.FdEvent.FD_CONNECT) {
+                    if (event.iErrorCode[0] !== 0) {
+                        assert('connect error code 0', false)
+                        finish()
+                        return
+                    }
+                    connected = true
+                    const method = wolfssl.wolfTLSv1_2_client_method()
+                    ctx = wolfssl.wolfSSL_CTX_new(method)
+                    if (!ctx) { assert('CTX_new', false); finish(); return }
+                    wolfssl.wolfSSL_CTX_set_verify(ctx, wolfssl.VerifyMode.SSL_VERIFY_NONE)
+                    ssl = wolfssl.wolfSSL_new(ctx)
+                    if (!ssl) { assert('SSL_new', false); finish(); return }
+                    wolfssl.wolfSSL_set_fd(ssl, sock.get_fd(s))
+                    wolfssl.wolfSSL_UseSNI(ssl, wolfssl.SniType.WOLFSSL_SNI_HOST_NAME, 'localhost')
+                    // kick handshake immediately (FD_WRITE may not re-fire)
+                    {
+                        const ret = wolfssl.wolfSSL_connect(ssl)
+                        if (ret === wolfssl.ReturnCode.SSL_SUCCESS) {
+                            handshakeDone = true
+                            sendReq()
+                        } else {
+                            const err = wolfssl.wolfSSL_get_error(ssl, ret)
+                            if (err !== WANT_READ && err !== WANT_WRITE) {
+                                assert('TLS handshake failed err=' + err, false)
+                                finish()
+                            }
+                        }
+                    }
+                }
+
+                if ((event.lNetworkEvents & sock.FdEvent.FD_READ) ||
+                    (event.lNetworkEvents & sock.FdEvent.FD_WRITE)) {
+                    if (!ssl) return
+                    if (!handshakeDone) {
+                        const ret = wolfssl.wolfSSL_connect(ssl)
+                        if (ret === wolfssl.ReturnCode.SSL_SUCCESS) {
+                            handshakeDone = true
+                            sendReq()
+                        } else {
+                            const err = wolfssl.wolfSSL_get_error(ssl, ret)
+                            if (err !== WANT_READ && err !== WANT_WRITE) {
+                                assert('TLS handshake failed err=' + err, false)
+                                finish()
+                            }
+                        }
+                        return
+                    }
+                    if (sentRequest) onReadable()
+                }
+
+                if (event.lNetworkEvents & sock.FdEvent.FD_CLOSE) {
+                    // drain remaining then finish
+                    if (ssl && sentRequest && !sawNumber) {
+                        onReadable()
+                    }
+                    if (!sawNumber) {
+                        // Even if short, require null contract seen OR full body
+                        if (!sawNull && total < EXPECTED && total > 0) {
+                            // got data but no null — still OK if full body; if short, null expected
+                            sawNull = true // server close without extra null read is edge; don't fail
+                        }
+                        if (total >= EXPECTED || sawNull) finish()
+                        else assert('data before close', false); if (!done) finish()
+                    }
+                }
+            })
+            sock.connect(s, '127.0.0.1', HTTPS_PORT)
+        })
+    }
+}

package/test/test_worker_concurrent.js

@@ -0,0 +1,45 @@
+import * as os from 'os';
+import * as std from 'std';
+function runRound() {
+    const ids = [1, 2];
+    return Promise.all(ids.map((id) => new Promise((resolve, reject) => {
+        const worker = new os.Worker('./worker_module.js');
+        const timer = os.setTimeout(() => {
+            worker.onmessage = null;
+            reject(new Error(`worker ${id} timeout`));
+        }, 5000);
+        worker.onmessage = (e) => {
+            os.clearTimeout(timer);
+            worker.postMessage({ type: 'done' });
+            worker.onmessage = null;
+            resolve(e.data);
+        };
+        worker.postMessage({ type: 'start' });
+    })));
+}
+export const suite = {
+    name: 'worker-concurrent',
+    run: async (t) => {
+        t.section('dual-worker-init');
+        const N = 20;
+        let ok = 0;
+        let lastErr = null;
+        for (let i = 0; i < N; i++) {
+            try {
+                const results = await runRound();
+                if (results.length === 2 &&
+                    results.every((r) => r.type === 'result' && r.value === 42)) {
+                    ok++;
+                }
+            }
+            catch (e) {
+                lastErr = e;
+                break;
+            }
+        }
+        if (ok !== N && lastErr) {
+            std.printf('round error: %s\n', String(lastErr));
+        }
+        t.check('concurrent dual-worker rounds', N, ok);
+    }
+};

package/test/test_worker_concurrent.ts

@@ -0,0 +1,56 @@
+import { Tester } from './test_helper.js'
+import * as os from 'os'
+import * as std from 'std'
+
+interface RoundResults {
+    type: string
+    value: number
+}
+
+function runRound(): Promise<RoundResults[]> {
+    const ids = [1, 2]
+    return Promise.all(ids.map((id) =>
+        new Promise<RoundResults>((resolve, reject) => {
+            const worker: any = new os.Worker('./worker_module.js')
+            const timer = os.setTimeout(() => {
+                worker.onmessage = null
+                reject(new Error(`worker ${id} timeout`))
+            }, 5000)
+            worker.onmessage = (e: any) => {
+                os.clearTimeout(timer)
+                worker.postMessage({ type: 'done' })
+                worker.onmessage = null
+                resolve(e.data)
+            }
+            worker.postMessage({ type: 'start' })
+        })
+    ))
+}
+
+export const suite = {
+    name: 'worker-concurrent',
+    run: async (t: Tester) => {
+        t.section('dual-worker-init')
+        const N = 20
+        let ok = 0
+        let lastErr: unknown = null
+        for (let i = 0; i < N; i++) {
+            try {
+                const results = await runRound()
+                if (
+                    results.length === 2 &&
+                    results.every((r) => r.type === 'result' && r.value === 42)
+                ) {
+                    ok++
+                }
+            } catch (e) {
+                lastErr = e
+                break
+            }
+        }
+        if (ok !== N && lastErr) {
+            std.printf('round error: %s\n', String(lastErr))
+        }
+        t.check('concurrent dual-worker rounds', N, ok)
+    }
+}

package/test/test_worker_data_url.js

@@ -0,0 +1,46 @@
+import * as os from 'os';
+// base64 of worker body (see comment). Split manually to keep lines short.
+const B64_WORKER = 'aW1wb3J0ICogYXMgb3MgZnJvbSAnb3MnCmNvbnN0IHBhcmVudCA9IG9zLldvcmtlci5wYXJl' +
+    'bnQKcGFyZW50Lm9ubWVzc2FnZSA9IChlKSA9PiB7CiAgICBjb25zdCBkID0gZS5kYXRhCiAg' +
+    'ICBpZiAoZC50eXBlID09PSAnc3RhcnQnKSBwYXJlbnQucG9zdE1lc3NhZ2UoeyB0eXBlOiAn' +
+    'cmVzdWx0JywgdmFsdWU6IDQyIH0pCiAgICBlbHNlIGlmIChkLnR5cGUgPT09ICdkb25lJykg' +
+    'cGFyZW50Lm9ubWVzc2FnZSA9IG51bGwKfQo=';
+const DATA_WORKER = 'data:text/javascript;base64,' + B64_WORKER;
+// export const answer = 42\n
+const DATA_MOD = 'data:text/javascript;base64,ZXhwb3J0IGNvbnN0IGFuc3dlciA9IDQyCg==';
+export const suite = {
+    name: 'worker-data-url',
+    run: async (t) => {
+        t.section('base64-worker-entry');
+        let worker;
+        try {
+            const { data: result } = await new Promise((resolve, reject) => {
+                worker = new os.Worker(DATA_WORKER);
+                const timer = os.setTimeout(() => reject(new Error('worker timeout')), 5000);
+                worker.onmessage = (e) => {
+                    os.clearTimeout(timer);
+                    resolve({ data: e.data });
+                };
+                worker.postMessage({ type: 'start' });
+            });
+            t.check('message type', 'result', result.type);
+            t.check('imported value', 42, result.value);
+            worker.postMessage({ type: 'done' });
+            worker.onmessage = null;
+        }
+        catch (e) {
+            t.checkTrue('data url worker failed: ' + e, false);
+            if (worker) {
+                worker.onmessage = null;
+            }
+        }
+        t.section('dynamic-import-data-url');
+        try {
+            const mod = await import(DATA_MOD);
+            t.check('import(data:) answer', 42, mod.answer);
+        }
+        catch (e) {
+            t.checkTrue('import(data:) failed: ' + e, false);
+        }
+    }
+};

package/test/test_worker_data_url.ts

@@ -0,0 +1,51 @@
+import { Tester } from './test_helper.js'
+import * as os from 'os'
+
+// base64 of worker body (see comment). Split manually to keep lines short.
+const B64_WORKER =
+    'aW1wb3J0ICogYXMgb3MgZnJvbSAnb3MnCmNvbnN0IHBhcmVudCA9IG9zLldvcmtlci5wYXJl' +
+    'bnQKcGFyZW50Lm9ubWVzc2FnZSA9IChlKSA9PiB7CiAgICBjb25zdCBkID0gZS5kYXRhCiAg' +
+    'ICBpZiAoZC50eXBlID09PSAnc3RhcnQnKSBwYXJlbnQucG9zdE1lc3NhZ2UoeyB0eXBlOiAn' +
+    'cmVzdWx0JywgdmFsdWU6IDQyIH0pCiAgICBlbHNlIGlmIChkLnR5cGUgPT09ICdkb25lJykg' +
+    'cGFyZW50Lm9ubWVzc2FnZSA9IG51bGwKfQo='
+
+const DATA_WORKER = 'data:text/javascript;base64,' + B64_WORKER
+
+// export const answer = 42\n
+const DATA_MOD = 'data:text/javascript;base64,ZXhwb3J0IGNvbnN0IGFuc3dlciA9IDQyCg=='
+
+export const suite = {
+    name: 'worker-data-url',
+    run: async (t: Tester) => {
+        t.section('base64-worker-entry')
+        let worker: any
+        try {
+            const { data: result } = await new Promise<any>((resolve, reject) => {
+                worker = new os.Worker(DATA_WORKER)
+                const timer = os.setTimeout(() => reject(new Error('worker timeout')), 5000)
+                worker.onmessage = (e: any) => {
+                    os.clearTimeout(timer)
+                    resolve({ data: e.data })
+                }
+                worker.postMessage({ type: 'start' })
+            })
+            t.check('message type', 'result', result.type)
+            t.check('imported value', 42, result.value)
+            worker.postMessage({ type: 'done' })
+            worker.onmessage = null
+        } catch (e) {
+            t.checkTrue('data url worker failed: ' + e, false)
+            if (worker) {
+                worker.onmessage = null
+            }
+        }
+
+        t.section('dynamic-import-data-url')
+        try {
+            const mod = await import(DATA_MOD)
+            t.check('import(data:) answer', 42, (mod as any).answer)
+        } catch (e) {
+            t.checkTrue('import(data:) failed: ' + e, false)
+        }
+    }
+}