quickwin 2.0.0 → 2.1.1

package/test/test_sysinfo.ts

@@ -0,0 +1,141 @@
+import * as ffi from 'ffi'
+import * as os from 'os'
+import { WCHAR } from '../lib/ffi/bind.js'
+import { NULL, PtrArrayBuffer, type Ptr } from '../lib/ffi/ctype.js'
+import {
+    FormatMessage, GetCommandLineW, GetComputerName, GetEnvironmentVariable,
+    GetLocalTime, GetModuleFileName, GetSystemDirectory, GetSystemTimeAsFileTime,
+    GlobalAlloc, GlobalLock, GlobalUnlock, QueryPerformanceCounter,
+    QueryPerformanceFrequency, RtlMoveMemory, Sleep,
+} from '../lib/windows/kernel32.js'
+import {
+    CloseClipboard, EmptyClipboard, GetClipboardData, OpenClipboard,
+    RegisterClipboardFormat, SetClipboardData,
+} from '../lib/windows/user32.js'
+import {
+    GetFileVersionInfoSize, GetFileVersionInfo, VerQueryValue,
+} from '../lib/windows/version.js'
+import { SYSTEMTIME } from '../lib/windows/structs.js'
+import { Tester } from './test_helper.js'
+
+// 进程内存跟进读：ffi 只有 readByte（无 DataView/写通道），u32 小端拼值 / 指针随位宽
+// （| 是有符号 32 位运算，>>> 0 归一无符号——0xFEEF04BD 类高位值否则读成负数）
+function readU32At(addr: number): number {
+    return (ffi.readByte(addr) | (ffi.readByte(addr + 1) << 8) |
+        (ffi.readByte(addr + 2) << 16) | (ffi.readByte(addr + 3) << 24)) >>> 0
+}
+function readPtr(dv: DataView, offset: number): number {
+    if (os.arch === 'ia32') return dv.getUint32(offset, true)
+    return dv.getUint32(offset, true) + dv.getUint32(offset + 4, true) * 4294967296
+}
+
+export const suite = {
+    name: 'sysinfo',
+    run: (t: Tester) => {
+        t.section('QueryPerformanceCounter: frequency + monotonic')
+        const freqB = new PtrArrayBuffer(8)
+        t.checkTrue('QueryPerformanceFrequency ok', QueryPerformanceFrequency(freqB) !== 0)
+        const freq = new DataView(freqB).getBigInt64(0, true)
+        t.checkTrue(`frequency sane (${freq})`, freq > 0n)
+        const c1 = new PtrArrayBuffer(8)
+        const c2 = new PtrArrayBuffer(8)
+        QueryPerformanceCounter(c1)
+        QueryPerformanceCounter(c2)
+        const v1 = new DataView(c1).getBigInt64(0, true)
+        const v2 = new DataView(c2).getBigInt64(0, true)
+        t.checkTrue(`counter monotonic (${v1} <= ${v2})`, v1 <= v2)
+
+        t.section('Sleep: QPC-measured elapsed lands in interval')
+        QueryPerformanceCounter(c1)
+        Sleep(50)
+        QueryPerformanceCounter(c2)
+        const elapsedMs = Number((new DataView(c2).getBigInt64(0, true) -
+            new DataView(c1).getBigInt64(0, true)) * 1000n / freq)
+        t.checkTrue(`Sleep(50) -> ${elapsedMs}ms in [30, 3000)`, elapsedMs >= 30 && elapsedMs < 3000)
+
+        t.section('GetLocalTime / GetSystemTimeAsFileTime')
+        const st = SYSTEMTIME.alloc()
+        GetLocalTime(st.ptr)
+        const got = SYSTEMTIME.decode(st)
+        t.checkTrue(`year sane (${got.wYear})`, got.wYear >= 2024 && got.wYear <= 2100)
+        t.checkTrue(`month sane (${got.wMonth})`, got.wMonth >= 1 && got.wMonth <= 12)
+        const ftB = new PtrArrayBuffer(8)
+        GetSystemTimeAsFileTime(ftB)
+        const ft = new DataView(ftB).getBigUint64(0, true)
+        t.checkTrue(`FILETIME > 0 (${ft})`, ft > 0n)
+
+        t.section('env / computer name / module path')
+        const pathW = WCHAR.alloc(4096)
+        const pathLen = GetEnvironmentVariable('PATH', pathW, 4096)
+        t.checkTrue(`PATH non-empty (${pathLen} chars)`, pathLen > 0)
+        const nameW = WCHAR.alloc(260)
+        const nameLenB = new PtrArrayBuffer(4)
+        new Uint32Array(nameLenB)[0] = 260
+        t.checkTrue('GetComputerName ok', GetComputerName(nameW, nameLenB) !== 0)
+        const compName = WCHAR.decode(nameW)
+        t.checkTrue(`computer name non-empty (${compName})`, compName.length > 0)
+        const modW = WCHAR.alloc(520)
+        const modLen = GetModuleFileName(NULL, modW, 520)
+        const modPath = WCHAR.decode(modW)
+        t.checkTrue(`exe path has qwin (${modLen > 0})`, /qwin/i.test(modPath))
+        // 生产绑定的返回位 `<WCHAR>ptr!`：内建 WCHAR 自动解码 + `!` 非空担保（直接 string）
+        const cmdLine = GetCommandLineW()
+        t.checkTrue(`GetCommandLineW decodes to non-empty string (${cmdLine.length} chars)`,
+            typeof cmdLine === 'string' && cmdLine.length > 0)
+
+        t.section('FormatMessage: error 2 -> readable text')
+        const msgW = WCHAR.alloc(512)
+        const msgLen = FormatMessage(0x1200 /* FROM_SYSTEM | IGNORE_INSERTS */,
+            NULL, 2 /* ERROR_FILE_NOT_FOUND */, 0, msgW, 512, NULL)
+        // 语言无关断言（VM 中/英文系统都可过）：错误 2 的系统文字必然 > 4 字符
+        t.checkTrue(`error 2 message non-empty (${msgLen} chars)`, msgLen > 4)
+
+        t.section('clipboard roundtrip: CF_UNICODETEXT (GlobalAlloc/RtlMoveMemory)')
+        t.checkTrue('OpenClipboard', OpenClipboard(NULL) !== 0)
+        t.checkTrue('EmptyClipboard', EmptyClipboard() !== 0)
+        const clipText = 'QuickWin clip roundtrip 你好'
+        const clipSrc = WCHAR.encode(clipText)             // 自带 NUL 终止
+        const hMem = GlobalAlloc(0x2 /* GMEM_MOVEABLE */, clipSrc.byteLength)
+        t.checkTrue(`GlobalAlloc valid (${hMem})`, hMem !== 0)
+        const clipDst = GlobalLock(hMem)
+        t.checkTrue(`GlobalLock address (${clipDst})`, clipDst !== 0)
+        RtlMoveMemory(clipDst, clipSrc, clipSrc.byteLength)
+        GlobalUnlock(hMem)
+        const setR = SetClipboardData(13 /* CF_UNICODETEXT */, hMem)
+        t.checkTrue('SetClipboardData (ownership -> system)', setR !== 0)
+        CloseClipboard()
+        t.checkTrue('OpenClipboard (read back)', OpenClipboard(NULL) !== 0)
+        const hRead = GetClipboardData(13)
+        t.checkTrue('GetClipboardData handle', hRead !== 0)
+        const pRead = hRead ? GlobalLock(hRead) : 0
+        const back = pRead ? WCHAR.decode(pRead as Ptr<'WCHAR'>) : ''
+        if (pRead) GlobalUnlock(hRead)
+        CloseClipboard()
+        t.check('clip text roundtrip', clipText, back)
+        t.checkTrue('RegisterClipboardFormat', RegisterClipboardFormat('QuickWinClipFmt') !== 0)
+
+        t.section('version resource of kernel32.dll')
+        const sysW = WCHAR.alloc(300)
+        GetSystemDirectory(sysW, 300)                       // 尾不带反斜杠
+        const k32Path = `${WCHAR.decode(sysW)}\\kernel32.dll`
+        const hB = new PtrArrayBuffer(4)
+        const vSize = GetFileVersionInfoSize(k32Path, hB)
+        t.checkTrue(`version size > 0 (${vSize})`, vSize > 0)
+        if (vSize > 0) {
+            const vHandle = new Uint32Array(hB)[0]!
+            const vBuf = new PtrArrayBuffer(vSize)
+            t.checkTrue('GetFileVersionInfo', GetFileVersionInfo(k32Path, vHandle, vSize, vBuf) !== 0)
+            const pBuf = new PtrArrayBuffer(8)
+            const pLen = new PtrArrayBuffer(4)
+            t.checkTrue('VerQueryValue root block', VerQueryValue(vBuf, '\\', pBuf, pLen) !== 0)
+            const rootAddr = readPtr(new DataView(pBuf), 0)
+            const rootLen = new Uint32Array(pLen)[0]
+            t.checkTrue(`VS_FIXEDFILEINFO len >= 52 (${rootLen})`, rootLen! >= 52)
+            t.check('VS_FIXEDFILEINFO signature', 0xfeef04bd, readU32At(rootAddr))
+            const fms = readU32At(rootAddr + 8)
+            const fls = readU32At(rootAddr + 12)
+            const ver = `${fms >>> 16}.${fms & 0xffff}.${fls >>> 16}.${fls & 0xffff}`
+            t.checkTrue(`file version sane (${ver})`, fms !== 0 || fls !== 0)
+        }
+    },
+}

package/test/test_wolfssl_read.js

@@ -19,7 +19,8 @@ export const suite = {
                 std.printf('  FAIL: %s\n', name);
             }
         }
-        // ── wolfSSL_read return contract: ArrayBuffer | null, never number ──
+        // ── 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((resolve) => {
             const s = sock.socket();
@@ -35,10 +36,9 @@ export const suite = {
             let sentRequest = false;
             let total = 0;
             const EXPECTED = 65536;
-            let sawNumber = false;
-            let sawArray = false;
-            let sawNull = false;
-            let nullErrOk = true;
+            let sawNonNumber = false;
+            let sawEof = false;
+            let errOk = true;
             let done = false;
             const finish = () => {
                 if (done)
@@ -48,10 +48,10 @@ export const suite = {
                 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);
+                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;
@@ -77,39 +77,39 @@ export const suite = {
                 sentRequest = true;
             };
             const onReadable = () => {
-                // Drain until content complete or null
+                // Drain until EOF (n===0 / ZERO_RETURN) or WANT_* hands back
+                // to the event loop.
                 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);
+                    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 (d instanceof ArrayBuffer) {
-                        sawArray = true;
-                        total += d.byteLength;
+                    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 null.
+                        // 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 (total >= EXPECTED)
+                if (sawEof)
                     finish();
             };
             sock.set_on_event(s, (event) => {
@@ -178,21 +178,22 @@ export const suite = {
                 }
                 if (event.lNetworkEvents & 32 /* sock.FdEvent.FD_CLOSE */) {
                     // drain remaining then finish
-                    if (ssl && sentRequest && !sawNumber) {
+                    if (ssl && sentRequest && !sawNonNumber) {
                         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 (!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 || sawNull)
+                        if (total >= EXPECTED || sawEof)
                             finish();
-                        else
+                        else {
                             assert('data before close', false);
-                        if (!done)
-                            finish();
+                            if (!done)
+                                finish();
+                        }
                     }
                 }
             });

package/test/test_wolfssl_read.ts

@@ -17,7 +17,8 @@ export const suite = {
             else { t.fail++; std.printf('  FAIL: %s\n', name) }
         }
 
-        // ── wolfSSL_read return contract: ArrayBuffer | null, never number ──
+        // ── 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()
@@ -34,10 +35,9 @@ export const suite = {
             let sentRequest = false
             let total = 0
             const EXPECTED = 65536
-            let sawNumber = false
-            let sawArray = false
-            let sawNull = false
-            let nullErrOk = true
+            let sawNonNumber = false
+            let sawEof = false
+            let errOk = true
             let done = false
 
             const finish = () => {
@@ -47,10 +47,10 @@ export const suite = {
                 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)
+                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)
@@ -72,39 +72,39 @@ export const suite = {
             }
 
             const onReadable = () => {
-                // Drain until content complete or null
+                // Drain until EOF (n===0 / ZERO_RETURN) or WANT_* hands back
+                // to the event loop.
                 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)
+                    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 (d instanceof ArrayBuffer) {
-                        sawArray = true
-                        total += d.byteLength
+                    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 null.
+                        // 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 (total >= EXPECTED) finish()
+                if (sawEof) finish()
             }
 
             sock.set_on_event(s, (event: { lNetworkEvents: number; iErrorCode: number[] }) => {
@@ -163,17 +163,17 @@ export const suite = {
 
                 if (event.lNetworkEvents & sock.FdEvent.FD_CLOSE) {
                     // drain remaining then finish
-                    if (ssl && sentRequest && !sawNumber) {
+                    if (ssl && sentRequest && !sawNonNumber) {
                         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 (!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 || sawNull) finish()
-                        else assert('data before close', false); if (!done) finish()
+                        if (total >= EXPECTED || sawEof) finish()
+                        else { assert('data before close', false); if (!done) finish() }
                     }
                 }
             })