koffi 1.0.0 → 1.0.3

package/test/misc.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+const koffi = require('./build/koffi.node');
+const assert = require('assert');
+const path = require('path');
+
+const Pack1 = koffi.struct('Pack1', {
+    a: 'int'
+});
+const Pack2 = koffi.struct('Pack2', {
+    a: 'int',
+    b: 'int'
+});
+const Pack3 = koffi.struct('Pack3', {
+    a: 'int',
+    b: 'int',
+    c: 'int'
+});
+
+const BFG = koffi.struct('BFG', {
+    a: 'int8_t',
+    b: 'int64_t',
+    c: 'char',
+    d: 'string',
+    e: 'short',
+    inner: koffi.struct({
+        f: 'float',
+        g: 'double'
+    })
+});
+const PackedBFG = koffi.pack('PackedBFG', {
+    a: 'int8_t',
+    b: 'int64_t',
+    c: 'char',
+    d: 'string',
+    e: 'short',
+    inner: koffi.pack({
+        f: 'float',
+        g: 'double'
+    })
+});
+
+main();
+
+async function main() {
+    try {
+        await test();
+        console.log('Success!');
+    } catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+}
+
+async function test() {
+    let lib_filename = path.dirname(__filename) + '/build/misc' + koffi.extension;
+    let lib = koffi.load(lib_filename);
+
+    const FillPack1 = lib.func('FillPack1', 'void', ['int', koffi.out(koffi.pointer(Pack1))]);
+    const RetPack1 = lib.func('RetPack1', Pack1, ['int']);
+    const AddPack1 = lib.fastcall('AddPack1', 'void', ['int', koffi.inout(koffi.pointer(Pack1))]);
+    const FillPack2 = lib.func('FillPack2', 'void', ['int', 'int', koffi.out(koffi.pointer(Pack2))]);
+    const RetPack2 = lib.func('RetPack2', Pack2, ['int', 'int']);
+    const AddPack2 = lib.fastcall('AddPack2', 'void', ['int', 'int', koffi.inout(koffi.pointer(Pack2))]);
+    const FillPack3 = lib.func('FillPack3', 'void', ['int', 'int', 'int', koffi.out(koffi.pointer(Pack3))]);
+    const RetPack3 = lib.func('RetPack3', Pack3, ['int', 'int', 'int']);
+    const AddPack3 = lib.fastcall('AddPack3', 'void', ['int', 'int', 'int', koffi.inout(koffi.pointer(Pack3))]);
+    const ConcatenateToInt1 = lib.func('ConcatenateToInt1', 'int64_t', Array(12).fill('int8_t'));
+    const ConcatenateToInt4 = lib.func('ConcatenateToInt4', 'int64_t', Array(12).fill('int32_t'));
+    const ConcatenateToInt8 = lib.func('ConcatenateToInt8', 'int64_t', Array(12).fill('int64_t'));
+    const ConcatenateToStr1 = lib.func('ConcatenateToStr1', 'string', [...Array(8).fill('int8_t'), koffi.struct('IJK1', {i: 'int8_t', j: 'int8_t', k: 'int8_t'}), 'int8_t']);
+    const ConcatenateToStr4 = lib.func('ConcatenateToStr4', 'string', [...Array(8).fill('int32_t'), koffi.pointer(koffi.struct('IJK4', {i: 'int32_t', j: 'int32_t', k: 'int32_t'})), 'int32_t']);
+    const ConcatenateToStr8 = lib.func('ConcatenateToStr8', 'string', [...Array(8).fill('int64_t'), koffi.struct('IJK8', {i: 'int64_t', j: 'int64_t', k: 'int64_t'}), 'int64_t']);
+    const MakeBFG = lib.func('BFG __stdcall MakeBFG(_Out_ BFG *p, int x, double y, const char *str)');
+    const MakePackedBFG = lib.func('PackedBFG __fastcall MakePackedBFG(int x, double y, _Out_ PackedBFG *p, const char *str)');
+    const ReturnBigString = process.platform == 'win32' ?
+                            lib.stdcall(1, 'string', ['string']) :
+                            lib.func('const char * __stdcall ReturnBigString(const char *str)');
+    const PrintFmt = lib.func('const char *PrintFmt(const char *fmt, ...)');
+    const Concat16 = lib.func('const char16_t *Concat16(const char16_t *str1, const char16_t *str2)')
+
+    // Simple tests with Pack1
+    {
+        let p = {};
+
+        FillPack1(777, p);
+        assert.deepEqual(p, { a: 777 });
+
+        let q = RetPack1(6);
+        assert.deepEqual(q, { a: 6 });
+
+        AddPack1(6, p);
+        assert.deepEqual(p, { a: 783 });
+    }
+
+    // Simple tests with Pack2
+    {
+        let p = {};
+
+        FillPack2(123, 456, p);
+        assert.deepEqual(p, { a: 123, b: 456 });
+
+        let q = RetPack2(6, 9);
+        assert.deepEqual(q, { a: 6, b: 9 });
+
+        AddPack2(6, 9, p);
+        assert.deepEqual(p, { a: 129, b: 465 });
+    }
+
+    // Simple tests with Pack3
+    {
+        let p = {};
+
+        FillPack3(1, 2, 3, p);
+        assert.deepEqual(p, { a: 1, b: 2, c: 3 });
+
+        let q = RetPack3(6, 9, -12);
+        assert.deepEqual(q, { a: 6, b: 9, c: -12 });
+
+        AddPack3(6, 9, -12, p);
+        assert.deepEqual(p, { a: 7, b: 11, c: -9 });
+    }
+
+    // Many parameters
+    {
+        assert.equal(ConcatenateToInt1(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
+        assert.equal(ConcatenateToInt4(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
+        assert.equal(ConcatenateToInt8(5, 6, 1, 2, 3, 9, 4, 4, 0, 6, 8, 7), 561239440687n);
+        assert.equal(ConcatenateToStr1(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
+        assert.equal(ConcatenateToStr4(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
+        assert.equal(ConcatenateToStr8(5, 6, 1, 2, 3, 9, 4, 4, {i: 0, j: 6, k: 8}, 7), '561239440687');
+    }
+
+    // Big struct
+    {
+        let out = {};
+        let bfg = MakeBFG(out, 2, 7, '__Hello123456789++++foobarFOOBAR!__');
+        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/__Hello123456789++++foobarFOOBAR!__/X', e: 54, inner: { f: 14, g: 5 } });
+        assert.deepEqual(out, bfg);
+    }
+
+    // Packed struct
+    {
+        let out = {};
+        let bfg = MakePackedBFG(2, 7, out, '__Hello123456789++++foobarFOOBAR!__');
+        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/__Hello123456789++++foobarFOOBAR!__/X', e: 54, inner: { f: 14, g: 5 } });
+        assert.deepEqual(out, bfg);
+    }
+
+    // Big string
+    {
+        let str = 'fooBAR!'.repeat(1024 * 1024);
+        assert.equal(ReturnBigString(str), str);
+    }
+
+    // Variadic
+    {
+        let str = PrintFmt('foo %d %g %s', 'int', 200, 'double', 1.5, 'string', 'BAR');
+        assert.equal(str, 'foo 200 1.5 BAR');
+    }
+
+    // UTF-16LE strings
+    {
+        let str = Concat16('Hello ', 'World!');
+        assert.equal(str, 'Hello World!');
+    }
+}

package/test/raylib.js

@@ -0,0 +1,165 @@
+#!/usr/bin/env node
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+const koffi = require('./build/koffi.node');
+const crypto = require('crypto');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const Color = koffi.struct('Color', {
+    r: 'uchar',
+    g: 'uchar',
+    b: 'uchar',
+    a: 'uchar'
+});
+
+const Image = koffi.struct('Image', {
+    data: koffi.pointer('void'),
+    width: 'int',
+    height: 'int',
+    mipmaps: 'int',
+    format: 'int'
+});
+
+const GlyphInfo = koffi.struct('GlyphInfo', {
+    value: 'int',
+    offsetX: 'int',
+    offsetY: 'int',
+    advanceX: 'int',
+    image: Image
+});
+
+const Vector2 = koffi.struct('Vector2', {
+    x: 'float',
+    y: 'float'
+});
+
+const Rectangle = koffi.struct('Rectangle', {
+    x: 'float',
+    y: 'float',
+    width: 'float',
+    height: 'float'
+});
+
+const Texture = koffi.struct('Texture', {
+    id: 'uint',
+    width: 'int',
+    height: 'int',
+    mipmaps: 'int',
+    format: 'int'
+});
+
+const Font = koffi.struct('Font', {
+    baseSize: 'int',
+    glyphCount: 'int',
+    glyphPadding: 'int',
+    texture: Texture,
+    recs: koffi.pointer(Rectangle),
+    glyphs: koffi.pointer(GlyphInfo)
+});
+
+main();
+
+async function main() {
+    try {
+        await test();
+    } catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+}
+
+async function test() {
+    let lib_filename = path.dirname(__filename) + '/build/raylib' + koffi.extension;
+    let lib = koffi.load(lib_filename);
+
+    const InitWindow = lib.func('InitWindow', 'void', ['int', 'int', 'string']);
+    const SetTraceLogLevel = lib.func('SetTraceLogLevel', 'void', ['int']);
+    const SetWindowState = lib.func('SetWindowState', 'void', ['uint']);
+    const GenImageColor = lib.func('GenImageColor', Image, ['int', 'int', Color]);
+    const GetFontDefault = lib.func('GetFontDefault', Font, []);
+    const MeasureTextEx = lib.func('MeasureTextEx', Vector2, [Font, 'string', 'float', 'float']);
+    const ImageDrawTextEx = lib.func('ImageDrawTextEx', 'void', [koffi.pointer(Image), Font, 'string', Vector2, 'float', 'float', Color]);
+    const ExportImage = lib.func('ExportImage', 'bool', [Image, 'string']);
+
+    // We need to call InitWindow before using anything else (such as fonts)
+    SetTraceLogLevel(4); // Warnings
+    SetWindowState(0x80); // Hidden
+    InitWindow(640, 480, "Raylib Test");
+
+    let img = GenImageColor(800, 600, { r: 0, g: 0, b: 0, a: 255 });
+    let font = GetFontDefault();
+
+    for (let i = 0; i < 3600; i++) {
+        let text = 'Hello World!';
+        let text_width = MeasureTextEx(font, text, 10, 1).x;
+
+        let angle = (i * 7) * Math.PI / 180;
+        let color = {
+            r: 127.5 + 127.5 * Math.sin(angle),
+            g: 127.5 + 127.5 * Math.sin(angle + Math.PI / 2),
+            b: 127.5 + 127.5 * Math.sin(angle + Math.PI),
+            a: 255
+        };
+        let pos = {
+            x: (img.width / 2 - text_width / 2) + i * 0.1 * Math.cos(angle - Math.PI / 2),
+            y: (img.height / 2 - 16) + i * 0.1 * Math.sin(angle - Math.PI / 2)
+        };
+
+        ImageDrawTextEx(img, font, text, pos, 10, 1, color);
+    }
+
+    // In theory we could directly checksum the image data, but we can't do it easily right now
+    // until koffi gives us something to transform a pointer to a buffer.
+    let tmp_dir = fs.mkdtempSync(path.join(os.tmpdir(), 'raylib'));
+
+    try {
+        ExportImage(img, tmp_dir + '/hello.png');
+
+        let sha256 = await new Promise((resolve, reject) => {
+            try {
+                let reader = fs.createReadStream(tmp_dir + '/hello.png');
+                let sha = crypto.createHash('sha256');
+
+                reader.on('error', reject);
+                reader.on('data', buf => sha.update(buf));
+                reader.on('end', () => {
+                    let hash = sha.digest('hex');
+                    resolve(hash);
+                });
+            } catch (err) {
+                reject(err);
+            }
+        });
+        let expected = '5ec23005377082582a14d261f5d07f51a6615b3bcdf5b91ada29aba65da22c5f';
+
+        console.log('Computed checksum: ' + sha256);
+        console.log('Expected: ' + expected);
+        console.log('');
+
+        if (sha256 == expected) {
+            console.log('Success!');
+        } else {
+            throw new Error('Image mismatch');
+        }
+    } finally {
+        if (fs.rmSync != null) {
+            fs.rmSync(tmp_dir, { recursive: true });
+        } else {
+            fs.rmdirSync(tmp_dir, { recursive: true });
+        }
+    }
+}

package/test/sqlite.js

@@ -0,0 +1,104 @@
+#!/usr/bin/env node
+
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see https://www.gnu.org/licenses/.
+
+const crypto = require('crypto');
+const koffi = require('./build/koffi.node');
+const assert = require('assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const sqlite3_db = koffi.handle('sqlite3_db');
+const sqlite3_stmt = koffi.handle('sqlite3_stmt');
+
+main();
+
+async function main() {
+    try {
+        await test();
+        console.log('Success!');
+    } catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+}
+
+async function test() {
+    let lib_filename = path.dirname(__filename) + '/build/sqlite3' + koffi.extension;
+    let lib = koffi.load(lib_filename);
+
+    const sqlite3_open_v2 = lib.func('sqlite3_open_v2', 'int', ['string', koffi.out(koffi.pointer(sqlite3_db)), 'int', 'string']);
+    const sqlite3_exec = lib.func('sqlite3_exec', 'int', [sqlite3_db, 'string', 'void *', 'void *', 'void *']);
+    const sqlite3_prepare_v2 = lib.func('sqlite3_prepare_v2', 'int', [sqlite3_db, 'string', 'int', koffi.out(koffi.pointer(sqlite3_stmt)), 'string']);
+    const sqlite3_reset = lib.func('sqlite3_reset', 'int', [sqlite3_stmt]);
+    const sqlite3_bind_text = lib.func('sqlite3_bind_text', 'int', [sqlite3_stmt, 'int', 'string', 'int', 'void *']);
+    const sqlite3_bind_int = lib.func('sqlite3_bind_int', 'int', [sqlite3_stmt, 'int', 'int']);
+    const sqlite3_step = lib.func('sqlite3_step', 'int', [sqlite3_stmt]);
+    const sqlite3_finalize = lib.func('sqlite3_finalize', 'int', [sqlite3_stmt]);
+    const sqlite3_close_v2 = lib.func('sqlite3_close_v2', 'int', [sqlite3_db]);
+
+    let filename = await create_temporary_file(path.join(os.tmpdir(), 'test_sqlite'));
+    let db = {};
+
+    try {
+        if (sqlite3_open_v2(filename, db, 0x2 | 0x4, null) != 0)
+            throw new Error('Failed to open database');
+        if (sqlite3_exec(db, 'CREATE TABLE foo (id INTEGER PRIMARY KEY, bar TEXT, value INT);', null, null, null) != 0)
+            throw new Error('Failed to create table');
+
+        let stmt = {};
+        if (sqlite3_prepare_v2(db, "INSERT INTO foo (bar, value) VALUES (?1, ?2)", -1, stmt, null) != 0)
+            throw new Error('Failed to prepare insert statement for table foo');
+        for (let i = 0; i < 200; i++) {
+            sqlite3_reset(stmt);
+
+            sqlite3_bind_text(stmt, 1, `TXT ${i}`, -1, null);
+            sqlite3_bind_int(stmt, 2, i * 2);
+
+            if (sqlite3_step(stmt) != 101)
+                throw new Erorr('Failed to insert new test row');
+        }
+        sqlite3_finalize(stmt);
+    } finally {
+        sqlite3_close_v2(db);
+        fs.unlinkSync(filename);
+    }
+}
+
+async function create_temporary_file(prefix) {
+    let buf = Buffer.allocUnsafe(4);
+
+    for (;;) {
+        try {
+            crypto.randomFillSync(buf);
+
+            let suffix = buf.toString('hex').padStart(8, '0');
+            let filename = `${prefix}.${suffix}`;
+
+            let file = await new Promise((resolve, reject) => {
+                let file = fs.createWriteStream(filename, { flags: 'wx', mode: 0o644 });
+
+                file.on('open', () => resolve(file));
+                file.on('error', reject);
+            });
+            file.close();
+
+            return filename;
+        } catch (err) {
+            if (err.code != 'EEXIST')
+                throw err;
+        }
+    }
+}