test: split FFI call and callback coverage

test/ffi/ffi-callback-test-common.js

@@ -0,0 +1,45 @@
+'use strict';
+const common = require('../common');
+const assert = require('node:assert');
+const { spawnSync } = require('node:child_process');
+
+function spawnAbortingChild(source) {
+  const args = ['-e', source];
+  if (common.isWindows) {
+    return spawnSync(process.execPath, args, { encoding: 'utf8' });
+  }
+
+  // Avoid writing core files for these intentional aborts.
+  return spawnSync('/bin/sh', [
+    '-c', 'ulimit -c 0 && exec "$@"',
+    'sh', process.execPath, ...args,
+  ], { encoding: 'utf8' });
+}
+
+function assertAborts(source, message) {
+  const { stderr, status, signal } = spawnAbortingChild(source);
+  assert.ok(common.nodeProcessAborted(status, signal),
+            `status: ${status}, signal: ${signal}
+stderr: ${stderr}`);
+  assert.match(stderr, message);
+}
+
+function assertCallbackAborts(callbackBody, message) {
+  assertAborts(
+    `'use strict';
+const ffi = require('node:ffi');
+const { fixtureSymbols, libraryPath } = require(${JSON.stringify(require.resolve('./ffi-test-common'))});
+const { lib, functions } = ffi.dlopen(libraryPath, fixtureSymbols);
+const callback = lib.registerCallback(
+  { arguments: ['i32'], return: 'i32' },
+  () => { ${callbackBody} },
+);
+functions.call_int_callback(callback, 21);`,
+    message,
+  );
+}
+
+module.exports = {
+  assertAborts,
+  assertCallbackAborts,
+};

test/ffi/ffi.status

@@ -4,6 +4,6 @@ prefix ffi
 
 [$system==solaris] # Also applies to SmartOS
 # Bundled libffi callbacks crash on SmartOS.
-test-ffi-calls: SKIP
+test-ffi-callback*: SKIP
 test-ffi-shared-buffer: SKIP
 test-ffi-weakref-calls: SKIP

test/ffi/test-ffi-callback-abort-cross-thread.js

@@ -0,0 +1,28 @@
+'use strict';
+const common = require('../common');
+common.skipIfFFIMissing();
+const { test } = require('node:test');
+const { assertAborts } = require('./ffi-callback-test-common');
+
+test('ffi aborts on cross-thread callback invocation', () => {
+  const workerSource = `
+const { workerData } = require('node:worker_threads');
+const ffi = require('node:ffi');
+const { fixtureSymbols, libraryPath } = require(${JSON.stringify(require.resolve('./ffi-test-common'))});
+const { functions } = ffi.dlopen(libraryPath, fixtureSymbols);
+functions.call_int_callback(workerData, 21);
+`;
+  assertAborts(
+    `'use strict';
+const { Worker } = require('node:worker_threads');
+const ffi = require('node:ffi');
+const { fixtureSymbols, libraryPath } = require(${JSON.stringify(require.resolve('./ffi-test-common'))});
+const { lib } = ffi.dlopen(libraryPath, fixtureSymbols);
+const callback = lib.registerCallback(
+  { arguments: ['i32'], return: 'i32' },
+  (value) => value * 2,
+);
+new Worker(${JSON.stringify(workerSource)}, { eval: true, workerData: callback });`,
+    /Callbacks can only be invoked on the system thread they were created on/,
+  );
+});

test/ffi/test-ffi-callback-abort-fractional-return.js

@@ -0,0 +1,9 @@
+'use strict';
+const common = require('../common');
+common.skipIfFFIMissing();
+const { test } = require('node:test');
+const { assertCallbackAborts } = require('./ffi-callback-test-common');
+
+test('ffi aborts on fractional callback return values', () => {
+  assertCallbackAborts('return 1.5;', /Callback returned invalid value for declared FFI type/);
+});

test/ffi/test-ffi-callback-abort-out-of-range-return.js

@@ -0,0 +1,9 @@
+'use strict';
+const common = require('../common');
+common.skipIfFFIMissing();
+const { test } = require('node:test');
+const { assertCallbackAborts } = require('./ffi-callback-test-common');
+
+test('ffi aborts on out-of-range callback return values', () => {
+  assertCallbackAborts('return 2 ** 40;', /Callback returned invalid value for declared FFI type/);
+});

test/ffi/test-ffi-callback-abort-promise.js

@@ -0,0 +1,9 @@
+'use strict';
+const common = require('../common');
+common.skipIfFFIMissing();
+const { test } = require('node:test');
+const { assertCallbackAborts } = require('./ffi-callback-test-common');
+
+test('ffi aborts when a callback returns a promise', () => {
+  assertCallbackAborts('return Promise.resolve(1);', /Callbacks cannot return promises/);
+});

test/ffi/test-ffi-callback-abort-throw.js

@@ -0,0 +1,9 @@
+'use strict';
+const common = require('../common');
+common.skipIfFFIMissing();
+const { test } = require('node:test');
+const { assertCallbackAborts } = require('./ffi-callback-test-common');
+
+test('ffi aborts when a callback throws', () => {
+  assertCallbackAborts('throw new Error("boom");', /Callbacks cannot throw an exception/);
+});

test/ffi/test-ffi-callbacks.js

@@ -0,0 +1,84 @@
+'use strict';
+const common = require('../common');
+common.skipIfFFIMissing();
+const assert = require('node:assert');
+const { test } = require('node:test');
+const ffi = require('node:ffi');
+const { cString, fixtureSymbols, libraryPath } = require('./ffi-test-common');
+
+function getLibrary() {
+  return ffi.dlopen(libraryPath, fixtureSymbols);
+}
+
+test('ffi callbacks can be registered and invoked', () => {
+  const { lib, functions: symbols } = getLibrary();
+  const seen = [];
+  const intCallback = lib.registerCallback(
+    { arguments: ['i32'], return: 'i32' },
+    (value) => value * 2,
+  );
+  const stringCallback = lib.registerCallback(
+    { arguments: ['pointer'], return: 'void' },
+    (ptr) => seen.push(ffi.toString(ptr)),
+  );
+  const binaryCallback = lib.registerCallback(
+    { arguments: ['i32', 'i32'], return: 'i32' },
+    (a, b) => a + b,
+  );
+
+  try {
+    assert.strictEqual(symbols.call_int_callback(intCallback, 21), 42);
+    symbols.call_string_callback(stringCallback, cString('hello callback'));
+    assert.deepStrictEqual(seen, ['hello callback']);
+    assert.strictEqual(symbols.call_binary_int_callback(binaryCallback, 19, 23), 42);
+
+    const nullPointerCallback = lib.registerCallback({ return: 'pointer' }, () => null);
+    const undefinedPointerCallback = lib.registerCallback({ return: 'pointer' }, () => undefined);
+    try {
+      assert.strictEqual(symbols.call_pointer_callback_is_null(nullPointerCallback), 1);
+      assert.strictEqual(symbols.call_pointer_callback_is_null(undefinedPointerCallback), 1);
+    } finally {
+      lib.unregisterCallback(nullPointerCallback);
+      lib.unregisterCallback(undefinedPointerCallback);
+    }
+  } finally {
+    lib.unregisterCallback(intCallback);
+    lib.unregisterCallback(stringCallback);
+    lib.unregisterCallback(binaryCallback);
+    lib.close();
+  }
+});
+
+test('ffi callback ref and unref APIs work', () => {
+  const { lib, functions: symbols } = getLibrary();
+  let called = false;
+  const values = [];
+  const voidCallback = lib.registerCallback(() => {
+    called = true;
+  });
+  const countingCallback = lib.registerCallback(
+    { arguments: ['i32'], return: 'i32' },
+    (value) => {
+      values.push(value);
+      return 0;
+    },
+  );
+
+  try {
+    lib.unrefCallback(voidCallback);
+    lib.refCallback(voidCallback);
+    symbols.call_void_callback(voidCallback);
+    symbols.call_callback_multiple_times(countingCallback, 5);
+
+    assert.strictEqual(called, true);
+    assert.deepStrictEqual(values, [0, 1, 2, 3, 4]);
+
+    lib.unregisterCallback(voidCallback);
+    lib.unregisterCallback(countingCallback);
+
+    assert.throws(() => lib.refCallback(voidCallback), /Callback not found/);
+    assert.throws(() => lib.unregisterCallback(-1n), /The first argument must be a non-negative bigint/);
+  } finally {
+    lib.close();
+  }
+});