testing all (u)intX_t types

Author: bengl

.eslintrc.js

@@ -7,6 +7,9 @@ module.exports = {
   extends: [
     'standard'
   ],
+  globals: {
+    BigInt: true
+  },
   parserOptions: {
     ecmaVersion: 11
   },

test/test.js

@@ -7,48 +7,47 @@ const { getNativeFunction, getBufferPointer } = require('../lib/index');
 
 const test = pitesti();
 
-let add;
-let addPtr;
-let addAsync;
-let addTwiceAsync;
+const add = {};
+const addPtr = {};
+const addAsync = {};
+const addTwiceAsync = {};
+
+const sizes = [8, 16, 32, 64];
 
 const libAdder = path.join(__dirname, 'adder', 'libadder.so');
 
 test`get functions`(() => {
-  add = getNativeFunction(
-    libAdder,
-    'test_add_uint32_t',
-    'uint32_t',
-    ['uint32_t', 'uint32_t']
-  );
-
-  addPtr = getNativeFunction(
-    libAdder,
-    'test_add_ptr_uint32_t',
-    'void',
-    ['uint32_t *', 'uint32_t *', 'uint32_t *']
-  );
-
-  addAsync = getNativeFunction(
-    libAdder,
-    'test_add_async_uint32_t',
-    'void',
-    ['uint32_t', 'uint32_t', ['void', ['uint32_t']]]
-  );
-
-  addTwiceAsync = getNativeFunction(
-    libAdder,
-    'test_add_async_twice_uint32_t',
-    'void',
-    ['uint32_t', 'uint32_t', ['void', ['uint32_t']]]
-  );
-});
+  for (const size of sizes) {
+    for (const typ of [`int${size}_t`, `uint${size}_t`]) {
+      add[typ] = getNativeFunction(
+        libAdder,
+        `test_add_${typ}`,
+        typ,
+        [typ, typ]
+      );
+
+      addPtr[typ] = getNativeFunction(
+        libAdder,
+        `test_add_ptr_${typ}`,
+        'void',
+        [typ + ' *', typ + ' *', typ + ' *']
+      );
+
+      addAsync[typ] = getNativeFunction(
+        libAdder,
+        `test_add_async_${typ}`,
+        'void',
+        [typ, typ, ['void', [typ]]]
+      );
 
-test`basic adding`(() => {
-  assert.strictEqual(add(0, 2), 2);
-  assert.strictEqual(add(4, 5), 9);
-  assert.strictEqual(add(11, 22), 33);
-  assert.strictEqual(add(Math.pow(2, 32) - 1, 5), 4);
+      addTwiceAsync[typ] = getNativeFunction(
+        libAdder,
+        `test_add_async_twice_${typ}`,
+        'void',
+        [typ, typ, ['void', [typ]]]
+      );
+    }
+  }
 });
 
 test`getBufferPointer`(() => {
@@ -58,35 +57,72 @@ test`getBufferPointer`(() => {
   assert(testBufPtr > 0n);
 });
 
-test`adding via pointers`(() => {
-  const addingBuf = Buffer.alloc(12);
-  addingBuf.writeUInt32LE(4);
-  addingBuf.writeUInt32LE(3, 4);
-  const addingBufPtr = getBufferPointer(addingBuf);
-  addPtr(addingBufPtr, addingBufPtr + 4n, addingBufPtr + 8n);
-  assert.strictEqual(addingBuf.readUInt32LE(8), 7);
-});
+function num (size, n) {
+  return size === 64 ? BigInt(n) : n;
+}
 
-test`async adding`((done) => {
-  addAsync(4, 5, (result) => {
-    assert.strictEqual(result, 9);
-    done();
-  });
-});
+function bufAccess (typ, size) {
+  const u = typ.startsWith('u') ? 'U' : '';
+  const big = size === 64 ? 'Big' : '';
+  const endian = size === 8 ? '' : 'LE';
+  return `${big}${u}Int${size}${endian}`;
+}
 
-test`promisified adding`(async () => {
-  const addPromise = (a, b) => new Promise(resolve => addAsync(a, b, resolve));
-  assert.strictEqual(await addPromise(5, 3), 8);
-});
+function read (typ, size, buf, n) {
+  return buf[`read${bufAccess(typ, size)}`](n);
+}
 
-test`calling callback more than once`((done) => {
-  let counter = 0;
-  addTwiceAsync(4, 5, (result) => {
-    assert.strictEqual(result, 9);
-    if (++counter === 2) {
-      done();
-    }
-  });
-});
+function write (typ, size, buf, n, i) {
+  return buf[`write${bufAccess(typ, size)}`](n, i);
+}
+
+for (const size of sizes) {
+  for (const typ of [`int${size}_t`, `uint${size}_t`]) {
+    test.context(typ, () => {
+      const n = num.bind(null, size);
+      test`basic adding`(() => {
+        assert.strictEqual(add[typ](n(0), n(2)), n(2));
+        assert.strictEqual(add[typ](n(4), n(5)), n(9));
+        assert.strictEqual(add[typ](n(11), n(22)), n(33));
+        if (typ.startsWith('u') && size !== 64) {
+          assert.strictEqual(add[typ](Math.pow(2, size) - 1, 5), 4);
+        }
+      });
+
+      const r = read.bind(null, typ, size);
+      const w = write.bind(null, typ, size);
+      test`adding via pointers`(() => {
+        const addingBuf = Buffer.alloc(size * 3);
+        w(addingBuf, n(4), 0);
+        w(addingBuf, n(3), size / 8);
+        const addingBufPtr = getBufferPointer(addingBuf);
+        addPtr[typ](addingBufPtr, addingBufPtr + BigInt(size / 8), addingBufPtr + BigInt((size / 8) * 2));
+        assert.strictEqual(r(addingBuf, (size / 8) * 2), n(7));
+      });
+
+      test`async adding`((done) => {
+        addAsync[typ](n(4), n(5), (result) => {
+          assert.strictEqual(result, n(9));
+          done();
+        });
+      });
+
+      test`promisified adding`(async () => {
+        const addPromise = (a, b) => new Promise(resolve => addAsync[typ](a, b, resolve));
+        assert.strictEqual(await addPromise(n(5), n(3)), n(8));
+      });
+
+      test`calling callback more than once`((done) => {
+        let counter = 0;
+        addTwiceAsync[typ](n(4), n(5), (result) => {
+          assert.strictEqual(result, n(9));
+          if (++counter === 2) {
+            done();
+          }
+        });
+      });
+    });
+  }
+}
 
 test();