quickwin 3.0.0 → 3.0.2

package/test/test_wolfssl_read.ts

@@ -1,184 +0,0 @@
-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'
-import { FdEvent, ReturnCode, SniType, VerifyMode } from '../constants'
-
-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: raw int, data lands in the
-        //    caller-owned buffer (thin wrapper — errors stay numbers) ──
-        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 sawNonNumber = false
-            let sawEof = false
-            let errOk = 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 full body', total >= EXPECTED)
-                assert('wolfSSL_read always returned number', !sawNonNumber)
-                assert('no-data/EOF observed via int (0 or ZERO_RETURN)', sawEof)
-                assert('n<=0 get_error in {WANT_READ,WANT_WRITE,ZERO_RETURN}', errOk)
-                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 EOF (n===0 / ZERO_RETURN) or WANT_* hands back
-                // to the event loop.
-                for (let guard = 0; guard < 10000; guard++) {
-                    const buf = new ArrayBuffer(8192)
-                    const n = wolfssl.wolfSSL_read(ssl!, buf)
-                    if (typeof n !== 'number') {
-                        sawNonNumber = true
-                        std.printf('    FAIL got non-number %s (want int)\n', String(n))
-                        finish()
-                        return
-                    }
-                    if (n > 0) {
-                        total += n
-                        // Keep draining after the body is complete: the point of
-                        // this suite is the no-data/EOF contract, so a full body
-                        // must not short-circuit the read that would observe it.
-                        continue
-                    }
-                    const err = wolfssl.wolfSSL_get_error(ssl!, n)
-                    if (err !== WANT_READ && err !== WANT_WRITE && err !== ZERO_RETURN) {
-                        errOk = false
-                        std.printf('    n=%d get_error=%d outside {WANT_READ,WANT_WRITE,ZERO_RETURN}\n', n, err)
-                        finish()
-                        return
-                    }
-                    if (n === 0 || err === ZERO_RETURN) {
-                        sawEof = true
-                        break
-                    }
-                    // WANT_*: wait for next FD_READ/WRITE
-                    return
-                }
-                if (sawEof) finish()
-            }
-
-            sock.set_on_event(s, (event: { lNetworkEvents: number; iErrorCode: number[] }) => {
-                if (done) return
-
-                if (event.lNetworkEvents & 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, 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, SniType.WOLFSSL_SNI_HOST_NAME, 'localhost')
-                    // kick handshake immediately (FD_WRITE may not re-fire)
-                    {
-                        const ret = wolfssl.wolfSSL_connect(ssl)
-                        if (ret === 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 & FdEvent.FD_READ) ||
-                    (event.lNetworkEvents & FdEvent.FD_WRITE)) {
-                    if (!ssl) return
-                    if (!handshakeDone) {
-                        const ret = wolfssl.wolfSSL_connect(ssl)
-                        if (ret === 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 & FdEvent.FD_CLOSE) {
-                    // drain remaining then finish
-                    if (ssl && sentRequest && !sawNonNumber) {
-                        onReadable()
-                    }
-                    if (!sawNonNumber) {
-                        // Server close without an observed EOF read is an edge —
-                        // don't fail if the body already completed.
-                        if (!sawEof && total < EXPECTED && total > 0) {
-                            sawEof = true
-                        }
-                        if (total >= EXPECTED || sawEof) finish()
-                        else { assert('data before close', false); if (!done) finish() }
-                    }
-                }
-            })
-            sock.connect(s, '127.0.0.1', HTTPS_PORT)
-        })
-    }
-}

package/test/test_worker.js

@@ -1,21 +0,0 @@
-import * as os from 'os';
-export const suite = {
-    name: 'worker',
-    run: async (t) => {
-        t.section('relative-import');
-        let worker;
-        const { data: result } = await new Promise((resolve, reject) => {
-            worker = new os.Worker('./worker_module.js');
-            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;
-    }
-};

package/test/test_worker.ts

@@ -1,24 +0,0 @@
-import { Tester } from './test_helper.js'
-import * as os from 'os'
-
-export const suite = {
-    name: 'worker',
-    run: async (t: Tester) => {
-        t.section('relative-import')
-        let worker: any
-        const { data: result } = await new Promise<any>((resolve, reject) => {
-            worker = new os.Worker('./worker_module.js')
-            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
-    }
-}

package/test/test_worker_concurrent.js

@@ -1,45 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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)
-        }
-    }
-}

package/test/test_worker_fetch.js

@@ -1,26 +0,0 @@
-import * as os from 'os';
-export const suite = {
-    name: 'worker-fetch',
-    run: async (t) => {
-        t.section('fetch-in-worker');
-        let worker;
-        const { data: result } = await new Promise((resolve, reject) => {
-            worker = new os.Worker('./worker_fetch.js');
-            const timer = os.setTimeout(() => reject(new Error('timeout')), 15000);
-            worker.onmessage = (e) => {
-                os.clearTimeout(timer);
-                resolve({ worker, data: e.data });
-            };
-            worker.postMessage({ type: 'start' });
-        });
-        if (result.type === 'result') {
-            t.checkTrue('fetch ok', result.ok);
-            t.check('status', result.status, 200);
-        }
-        else {
-            t.checkTrue('worker fetch failed: ' + result.msg, false);
-        }
-        worker.postMessage({ type: 'done' });
-        worker.onmessage = null;
-    }
-};

package/test/test_worker_fetch.ts

@@ -1,27 +0,0 @@
-import { Tester } from './test_helper.js'
-import * as os from 'os'
-
-export const suite = {
-    name: 'worker-fetch',
-    run: async (t: Tester) => {
-        t.section('fetch-in-worker')
-        let worker: any
-        const { data: result } = await new Promise<any>((resolve, reject) => {
-            worker = new os.Worker('./worker_fetch.js')
-            const timer = os.setTimeout(() => reject(new Error('timeout')), 15000)
-            worker.onmessage = (e: any) => {
-                os.clearTimeout(timer)
-                resolve({ worker, data: e.data })
-            }
-            worker.postMessage({ type: 'start' })
-        })
-        if (result.type === 'result') {
-            t.checkTrue('fetch ok', result.ok)
-            t.check('status', result.status, 200)
-        } else {
-            t.checkTrue('worker fetch failed: ' + result.msg, false)
-        }
-        worker.postMessage({ type: 'done' })
-        worker.onmessage = null
-    }
-}

package/test/test_worker_net.js

@@ -1,69 +0,0 @@
-import * as os from 'os';
-export const suite = {
-    name: 'worker-http',
-    run: async (t) => {
-        t.section('import-inside');
-        let worker1;
-        const { data: r1 } = await new Promise((resolve, reject) => {
-            worker1 = new os.Worker('./worker_http.js');
-            const timer = os.setTimeout(() => reject(new Error('timeout')), 15000);
-            worker1.onmessage = (e) => {
-                os.clearTimeout(timer);
-                resolve({ worker: worker1, data: e.data });
-            };
-            worker1.postMessage({ type: 'start' });
-        });
-        t.check('message type', 'result', r1.type);
-        t.checkTrue('isArray([])', r1.isArrayWorks);
-        t.checkTrue('isArray({}) rejects', r1.isArrayRejects);
-        worker1.postMessage({ type: 'done' });
-        worker1.onmessage = null;
-        t.section('http-entry');
-        try {
-            new os.Worker('https://esm.sh/isarray');
-            await new Promise(resolve => os.setTimeout(() => resolve(), 3000));
-            t.checkTrue('worker created with http url', true);
-        }
-        catch (e) {
-            t.checkTrue('worker creation failed: ' + e, false);
-        }
-        // Retry across jsdelivr's official CDN hosts: a dropped connection
-        // on a slow CI network must not be reported as a TLS regression.
-        t.section('npm-package');
-        let worker3;
-        const NPM_HOSTS = ['cdn.jsdelivr.net', 'fastly.jsdelivr.net', 'gcore.jsdelivr.net'];
-        let workerOk = false;
-        for (const host of NPM_HOSTS) {
-            for (let attempt = 0; attempt < 3 && !workerOk; attempt++) {
-                try {
-                    const { data: r3 } = await new Promise((resolve, reject) => {
-                        worker3 = new os.Worker('https://' + host + '/npm/quickwin/test/worker_module.js');
-                        const timer = os.setTimeout(() => reject(new Error('timeout')), 15000);
-                        worker3.onmessage = (e) => {
-                            os.clearTimeout(timer);
-                            resolve({ worker: worker3, data: e.data });
-                        };
-                        worker3.postMessage({ type: 'start' });
-                    });
-                    t.check('npm worker message type', 'result', r3.type);
-                    t.check('npm worker imported value', 42, r3.value);
-                    worker3.postMessage({ type: 'done' });
-                    worker3.onmessage = null;
-                    workerOk = true;
-                }
-                catch (e) {
-                    if (worker3) {
-                        worker3.onmessage = null;
-                        worker3 = null;
-                    }
-                    if (attempt === 2 && host === NPM_HOSTS[NPM_HOSTS.length - 1])
-                        t.checkTrue('npm worker failed: ' + e, false);
-                    else
-                        os.sleep(500);
-                }
-            }
-            if (workerOk)
-                break;
-        }
-    }
-};

package/test/test_worker_net.ts

@@ -1,66 +0,0 @@
-import { Tester } from './test_helper.js'
-import * as os from 'os'
-
-export const suite = {
-    name: 'worker-http',
-    run: async (t: Tester) => {
-        t.section('import-inside')
-        let worker1: any
-        const { data: r1 } = await new Promise<any>((resolve, reject) => {
-            worker1 = new os.Worker('./worker_http.js')
-            const timer = os.setTimeout(() => reject(new Error('timeout')), 15000)
-            worker1.onmessage = (e: any) => {
-                os.clearTimeout(timer)
-                resolve({ worker: worker1, data: e.data })
-            }
-            worker1.postMessage({ type: 'start' })
-        })
-        t.check('message type', 'result', r1.type)
-        t.checkTrue('isArray([])', r1.isArrayWorks)
-        t.checkTrue('isArray({}) rejects', r1.isArrayRejects)
-
-        worker1.postMessage({ type: 'done' })
-        worker1.onmessage = null
-
-        t.section('http-entry')
-        try {
-            new os.Worker('https://esm.sh/isarray')
-            await new Promise<void>(resolve => os.setTimeout(() => resolve(), 3000))
-            t.checkTrue('worker created with http url', true)
-        } catch (e) {
-            t.checkTrue('worker creation failed: ' + e, false)
-        }
-
-        // Retry across jsdelivr's official CDN hosts: a dropped connection
-        // on a slow CI network must not be reported as a TLS regression.
-        t.section('npm-package')
-        let worker3: any
-        const NPM_HOSTS = ['cdn.jsdelivr.net', 'fastly.jsdelivr.net', 'gcore.jsdelivr.net']
-        let workerOk = false
-        for (const host of NPM_HOSTS) {
-            for (let attempt = 0; attempt < 3 && !workerOk; attempt++) {
-                try {
-                    const { data: r3 } = await new Promise<any>((resolve, reject) => {
-                        worker3 = new os.Worker('https://' + host + '/npm/quickwin/test/worker_module.js')
-                        const timer = os.setTimeout(() => reject(new Error('timeout')), 15000)
-                        worker3.onmessage = (e: any) => {
-                            os.clearTimeout(timer)
-                            resolve({ worker: worker3, data: e.data })
-                        }
-                        worker3.postMessage({ type: 'start' })
-                    })
-                    t.check('npm worker message type', 'result', r3.type)
-                    t.check('npm worker imported value', 42, r3.value)
-                    worker3.postMessage({ type: 'done' })
-                    worker3.onmessage = null
-                    workerOk = true
-                } catch (e) {
-                    if (worker3) { worker3.onmessage = null; worker3 = null }
-                    if (attempt === 2 && host === NPM_HOSTS[NPM_HOSTS.length - 1]) t.checkTrue('npm worker failed: ' + e, false)
-                    else os.sleep(500)
-                }
-            }
-            if (workerOk) break
-        }
-    }
-}

package/test/test_worker_wasm_concurrent.js

@@ -1,44 +0,0 @@
-import { readWasmFile } from './test_helper.js';
-import * as os from 'os';
-export const suite = {
-    name: 'worker-wasm',
-    run: async (t) => {
-        const wasmBuf = readWasmFile('./add.wasm');
-        if (!wasmBuf) {
-            t.fail++;
-            return;
-        }
-        const complexBuf = readWasmFile('./complex.wasm');
-        if (!complexBuf) {
-            t.fail++;
-            return;
-        }
-        t.section('concurrent');
-        const worker = new os.Worker('./worker_wasm_concurrent.js');
-        const workerResult = new Promise((resolve, reject) => {
-            const timer = os.setTimeout(() => reject(new Error('worker timeout')), 5000);
-            worker.onmessage = (e) => {
-                os.clearTimeout(timer);
-                resolve(e.data);
-            };
-            worker.postMessage({
-                type: 'start',
-                wasmBuf,
-                calls: [['add', [1, 2]], ['add', [10, 20]]]
-            });
-        });
-        const mainMod = new WebAssembly.Module(wasmBuf);
-        const mainInst = new WebAssembly.Instance(mainMod);
-        const mainExp = mainInst.exports;
-        const mainR1 = mainExp.add(1, 2);
-        const mainR2 = mainExp.add(10, 20);
-        const wr = await workerResult;
-        t.check('main add(1, 2)', 3, mainR1);
-        t.check('main add(10, 20)', 30, mainR2);
-        t.check('worker ok', true, wr.ok);
-        t.check('worker add(1, 2)', 3, wr.results[0]);
-        t.check('worker add(10, 20)', 30, wr.results[1]);
-        worker.postMessage({ type: 'done' });
-        worker.onmessage = null;
-    }
-};