koffi 2.0.1 → 2.1.0-beta.3

package/test/sync.js

@@ -15,7 +15,6 @@
 
 const koffi = require('./build/koffi.node');
 const assert = require('assert');
-const path = require('path');
 
 const Pack1 = koffi.struct('Pack1', {
     a: 'int'
@@ -62,7 +61,7 @@ const IntFloat = koffi.struct('IntFloat', {
 
 const BFG = koffi.struct('BFG', {
     a: 'int8_t',
-    b: 'int64_t',
+    b: [16, 'int64_t'],
     c: 'char',
     d: 'const char *',
     e: 'short',
@@ -115,6 +114,21 @@ const StrStruct = koffi.struct('StrStruct', {
     str16: koffi.types.string16
 });
 
+const EndianInts = koffi.struct('EndianInts', {
+    i16le: 'int16_le_t',
+    i16be: 'int16_be_t',
+    u16le: 'uint16_le_t',
+    u16be: 'uint16_be_t',
+    i32le: 'int32_le_t',
+    i32be: 'int32_be_t',
+    u32le: 'uint32_le_t',
+    u32be: 'uint32_be_t',
+    i64le: 'int64_le_t',
+    i64be: 'int64_be_t',
+    u64le: 'uint64_le_t',
+    u64be: 'uint64_be_t'
+});
+
 main();
 
 async function main() {
@@ -128,7 +142,7 @@ async function main() {
 }
 
 async function test() {
-    let lib_filename = path.dirname(__filename) + '/build/misc' + koffi.extension;
+    let lib_filename = __dirname + '/build/misc' + koffi.extension;
     let lib = koffi.load(lib_filename);
 
     const GetMinusOne1 = lib.func('int8_t GetMinusOne1(void)');
@@ -160,6 +174,7 @@ async function test() {
     const ConcatenateToStr8 = lib.func('ConcatenateToStr8', 'str', [...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('AliasBFG __fastcall MakePackedBFG(int x, double y, _Out_ PackedBFG *p, const char *str)');
+    const MakePolymorphBFG = lib.func('void MakePolymorphBFG(int type, int x, double y, const char *str, _Out_ void *p)');
     const ReturnBigString = process.platform == 'win32' ?
                             lib.stdcall(1, koffi.disposable('str', koffi.free), ['str']) :
                             lib.func('const char * __stdcall ReturnBigString(const char *str)');
@@ -186,6 +201,24 @@ async function test() {
     const MultiplyIntegers = lib.func('void MultiplyIntegers(int multiplier, _Inout_ int *values, int len)');
     const ThroughStr = lib.func('str ThroughStr(StrStruct s)');
     const ThroughStr16 = lib.func('str16 ThroughStr16(StrStruct s)');
+    const ReverseBytes = lib.func('void ReverseBytes(_Inout_ void *array, int len)');
+    const CopyEndianInts1 = lib.func('void CopyEndianInts1(EndianInts ints, _Out_ uint8_t *buf)');
+    const CopyEndianInts2 = lib.func('void CopyEndianInts2(int16_le_t i16le, int16_be_t i16be, uint16_le_t u16le, uint16_be_t u16be, ' +
+                                                          'int32_le_t i32le, int32_be_t i32be, uint32_le_t u32le, uint32_be_t u32be, ' +
+                                                          'int64_le_t i64le, int64_be_t i64be, uint64_le_t u64le, uint64_be_t u64be, ' +
+                                                          '_Out_ void *out)');
+    const ReturnEndianInt2SL = lib.func('int16_le_t ReturnEndianInt2(int16_be_t v)');
+    const ReturnEndianInt2SB = lib.func('int16_be_t ReturnEndianInt2(int16_le_t v)');
+    const ReturnEndianInt2UL = lib.func('uint16_le_t ReturnEndianInt2(uint16_be_t v)');
+    const ReturnEndianInt2UB = lib.func('uint16_be_t ReturnEndianInt2(uint16_le_t v)');
+    const ReturnEndianInt4SL = lib.func('int32_le_t ReturnEndianInt4(int32_be_t v)');
+    const ReturnEndianInt4SB = lib.func('int32_be_t ReturnEndianInt4(int32_le_t v)');
+    const ReturnEndianInt4UL = lib.func('uint32_le_t ReturnEndianInt4(uint32_be_t v)');
+    const ReturnEndianInt4UB = lib.func('uint32_be_t ReturnEndianInt4(uint32_le_t v)');
+    const ReturnEndianInt8SL = lib.func('int64_le_t ReturnEndianInt8(int64_be_t v)');
+    const ReturnEndianInt8SB = lib.func('int64_be_t ReturnEndianInt8(int64_le_t v)');
+    const ReturnEndianInt8UL = lib.func('uint64_le_t ReturnEndianInt8(uint64_be_t v)');
+    const ReturnEndianInt8UB = lib.func('uint64_be_t ReturnEndianInt8(uint64_le_t v)');
 
     // Simple signed value returns
     assert.equal(GetMinusOne1(), -1);
@@ -295,6 +328,17 @@ async function test() {
         assert.deepEqual(out, bfg);
     }
 
+    // Polymorph pointer
+    {
+        let bfg = {};
+
+        MakePolymorphBFG(0, 2, 7, 'boo', koffi.as(bfg, 'BFG *'));
+        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/boo/X', e: 54, inner: { f: 14, g: 5 }});
+
+        MakePolymorphBFG(1, 2, 7, 'bies', koffi.as(bfg, 'PackedBFG *'));
+        assert.deepEqual(bfg, { a: 2, b: 4, c: -25, d: 'X/bies/X', e: 54, inner: { f: 14, g: 5 }});
+    }
+
     // Big string
     {
         let str = 'fooBAR!'.repeat(1024 * 1024);
@@ -394,4 +438,65 @@ async function test() {
         assert.equal(ThroughStr16({ str: null, str16: 'World!' }), 'World!');
         assert.equal(ThroughStr16({ str: 'World!', str16: null }), null);
     }
+
+    // Transparent typed arrays for void pointers
+    {
+        let arr8 = Uint8Array.from([1, 2, 3, 4, 5]);
+        let arr16 = Int16Array.from([1, 2, 3, 4, 5]);
+
+        ReverseBytes(arr8, arr8.byteLength);
+        assert.deepEqual(arr8, Uint8Array.from([5, 4, 3, 2, 1]));
+
+        ReverseBytes(arr16, arr16.byteLength);
+        assert.deepEqual(arr16, Int16Array.from([1280, 1024, 768, 512, 256]));
+    }
+
+    // Endian-sensitive integer types
+    {
+        let ints = {
+            i16le: 0x7BCD,
+            i16be: 0x7BCD,
+            u16le: 0x7BCD,
+            u16be: 0x7BCD,
+            i32le: 0x4EADBEEF,
+            i32be: 0x4EADBEEF,
+            u32le: 0x4EADBEEF,
+            u32be: 0x4EADBEEF,
+            i64le: 0x0123456789ABCDEFn,
+            i64be: 0x0123456789ABCDEFn,
+            u64le: 0x0123456789ABCDEFn,
+            u64be: 0x0123456789ABCDEFn
+        };
+
+        let out1 = new Uint8Array(56);
+        let out2 = new Uint8Array(56);
+
+        CopyEndianInts1(ints, out1);
+        CopyEndianInts2(ints.i16le, ints.i16be, ints.u16le, ints.u16be,
+                        ints.i32le, ints.i32be, ints.u32le, ints.u32be,
+                        ints.u64le, ints.u64be, ints.u64le, ints.u64be, out2);
+
+        assert.deepEqual(out1, Uint8Array.from([
+            0xCD, 0x7B, 0x7B, 0xCD,
+            0xCD, 0x7B, 0x7B, 0xCD,
+            0xEF, 0xBE, 0xAD, 0x4E, 0x4E, 0xAD, 0xBE, 0xEF,
+            0xEF, 0xBE, 0xAD, 0x4E, 0x4E, 0xAD, 0xBE, 0xEF,
+            0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF,
+            0xEF, 0xCD, 0xAB, 0x89, 0x67, 0x45, 0x23, 0x01, 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF
+        ]));
+        assert.deepEqual(out2, out1);
+
+        assert.equal(ReturnEndianInt2SL(0x7B6D), 0x6D7B);
+        assert.equal(ReturnEndianInt2SB(0x7B6D), 0x6D7B);
+        assert.equal(ReturnEndianInt2UL(0x7B6D), 0x6D7B);
+        assert.equal(ReturnEndianInt2UB(0x7B6D), 0x6D7B);
+        assert.equal(ReturnEndianInt4SL(0x4EADBE4F), 0x4FBEAD4E);
+        assert.equal(ReturnEndianInt4SB(0x4EADBE4F), 0x4FBEAD4E);
+        assert.equal(ReturnEndianInt4UL(0x4EADBE4F), 0x4FBEAD4E);
+        assert.equal(ReturnEndianInt4UB(0x4EADBE4F), 0x4FBEAD4E);
+        assert.equal(ReturnEndianInt8SL(0x0123456789ABCD3Fn), 0x3FCDAB8967452301n);
+        assert.equal(ReturnEndianInt8SB(0x0123456789ABCD3Fn), 0x3FCDAB8967452301n);
+        assert.equal(ReturnEndianInt8UL(0x0123456789ABCD3Fn), 0x3FCDAB8967452301n);
+        assert.equal(ReturnEndianInt8UB(0x0123456789ABCD3Fn), 0x3FCDAB8967452301n);
+    }
 }