koffi 2.3.4 → 2.3.6-beta.1

package/vendor/node-addon-api/test/callbackscope.js

@@ -3,12 +3,12 @@ const assert = require('assert');
 
 // we only check async hooks on 8.x an higher were
 // they are closer to working properly
-const nodeVersion = process.versions.node.split('.')[0]
-let async_hooks = undefined;
-function checkAsyncHooks() {
+const nodeVersion = process.versions.node.split('.')[0];
+let asyncHooks;
+function checkAsyncHooks () {
   if (nodeVersion >= 8) {
-    if (async_hooks == undefined) {
-      async_hooks = require('async_hooks');
+    if (asyncHooks === undefined) {
+      asyncHooks = require('async_hooks');
     }
     return true;
   }
@@ -17,33 +17,33 @@ function checkAsyncHooks() {
 
 module.exports = require('./common').runTest(test);
 
-function test(binding) {
-  if (!checkAsyncHooks())
-    return;
+function test (binding) {
+  if (!checkAsyncHooks()) { return; }
 
   let id;
   let insideHook = false;
-  const hook = async_hooks.createHook({
-    init(asyncId, type, triggerAsyncId, resource) {
-      if (id === undefined && type === 'callback_scope_test') {
+  const hook = asyncHooks.createHook({
+    init (asyncId, type, triggerAsyncId, resource) {
+      if (id === undefined && (type === 'callback_scope_test' || type === 'existing_callback_scope_test')) {
         id = asyncId;
       }
     },
-    before(asyncId) {
-      if (asyncId === id)
-        insideHook = true;
+    before (asyncId) {
+      if (asyncId === id) { insideHook = true; }
     },
-    after(asyncId) {
-      if (asyncId === id)
-        insideHook = false;
+    after (asyncId) {
+      if (asyncId === id) { insideHook = false; }
     }
   }).enable();
 
   return new Promise(resolve => {
-    binding.callbackscope.runInCallbackScope(function() {
+    binding.callbackscope.runInCallbackScope(function () {
       assert(insideHook);
-      hook.disable();
-      resolve();
+      binding.callbackscope.runInPreExistingCbScope(function () {
+        assert(insideHook);
+        hook.disable();
+        resolve();
+      });
     });
   });
 }

package/vendor/node-addon-api/test/common/index.js

@@ -2,6 +2,7 @@
 'use strict';
 const assert = require('assert');
 const path = require('path');
+const { access } = require('node:fs/promises');
 
 const noop = () => {};
 
@@ -75,9 +76,41 @@ exports.mustNotCall = function (msg) {
   };
 };
 
-exports.runTest = async function (test, buildType, buildPathRoot = process.env.BUILD_PATH || '') {
-  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
+const buildTypes = {
+  Release: 'Release',
+  Debug: 'Debug'
+};
+
+async function checkBuildType (buildType) {
+  try {
+    await access(path.join(path.resolve('./test/build'), buildType));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function whichBuildType () {
+  let buildType = 'Release';
+  const envBuildType = process.env.NODE_API_BUILD_CONFIG;
+  if (envBuildType) {
+    if (Object.values(buildTypes).includes(envBuildType)) {
+      if (await checkBuildType(envBuildType)) {
+        buildType = envBuildType;
+      } else {
+        throw new Error(`The ${envBuildType} build doesn't exists.`);
+      }
+    } else {
+      throw new Error('Invalid value for NODE_API_BUILD_CONFIG environment variable. It should be set to Release or Debug.');
+    }
+  }
+  return buildType;
+}
+
+exports.whichBuildType = whichBuildType;
 
+exports.runTest = async function (test, buildType, buildPathRoot = process.env.BUILD_PATH || '') {
+  buildType = buildType || await whichBuildType();
   const bindings = [
     path.join(buildPathRoot, `../build/${buildType}/binding.node`),
     path.join(buildPathRoot, `../build/${buildType}/binding_noexcept.node`),
@@ -92,7 +125,7 @@ exports.runTest = async function (test, buildType, buildPathRoot = process.env.B
 };
 
 exports.runTestWithBindingPath = async function (test, buildType, buildPathRoot = process.env.BUILD_PATH || '') {
-  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
+  buildType = buildType || await whichBuildType();
 
   const bindings = [
     path.join(buildPathRoot, `../build/${buildType}/binding.node`),
@@ -107,7 +140,7 @@ exports.runTestWithBindingPath = async function (test, buildType, buildPathRoot
 };
 
 exports.runTestWithBuildType = async function (test, buildType) {
-  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
+  buildType = buildType || await whichBuildType();
 
   await Promise.resolve(test(buildType))
     .finally(exports.mustCall());

package/vendor/node-addon-api/test/dataview/dataview.js

@@ -3,18 +3,18 @@
 const assert = require('assert');
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
-  function testDataViewCreation(factory, arrayBuffer, offset, length) {
+function test (binding) {
+  function testDataViewCreation (factory, arrayBuffer, offset, length) {
     const view = factory(arrayBuffer, offset, length);
-    offset = offset ? offset : 0;
+    offset = offset || 0;
     assert.ok(dataview.getArrayBuffer(view) instanceof ArrayBuffer);
     assert.strictEqual(dataview.getArrayBuffer(view), arrayBuffer);
     assert.strictEqual(dataview.getByteOffset(view), offset);
     assert.strictEqual(dataview.getByteLength(view),
-        length ? length : arrayBuffer.byteLength - offset);
+      length || arrayBuffer.byteLength - offset);
   }
 
-  function testInvalidRange(factory, arrayBuffer, offset, length) {
+  function testInvalidRange (factory, arrayBuffer, offset, length) {
     assert.throws(() => {
       factory(arrayBuffer, offset, length);
     }, RangeError);

package/vendor/node-addon-api/test/dataview/dataview_read_write.js

@@ -1,55 +1,57 @@
+/* eslint-disable no-eval */
 'use strict';
 
 const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
-  function expected(type, value) {
+function test (binding) {
+  function expected (type, value) {
     return eval(`(new ${type}Array([${value}]))[0]`);
   }
 
-  function nativeReadDataView(dataview, type, offset, value) {
+  function nativeReadDataView (dataview, type, offset, value) {
     return eval(`binding.dataview_read_write.get${type}(dataview, offset)`);
   }
 
-  function nativeWriteDataView(dataview, type, offset, value) {
+  function nativeWriteDataView (dataview, type, offset, value) {
     eval(`binding.dataview_read_write.set${type}(dataview, offset, value)`);
   }
 
-  function isLittleEndian() {
+  // eslint-disable-next-line no-unused-vars
+  function isLittleEndian () {
     const buffer = new ArrayBuffer(2);
     new DataView(buffer).setInt16(0, 256, true /* littleEndian */);
     return new Int16Array(buffer)[0] === 256;
   }
 
-  function jsReadDataView(dataview, type, offset, value) {
+  function jsReadDataView (dataview, type, offset, value) {
     return eval(`dataview.get${type}(offset, isLittleEndian())`);
   }
 
-  function jsWriteDataView(dataview, type, offset, value) {
+  function jsWriteDataView (dataview, type, offset, value) {
     eval(`dataview.set${type}(offset, value, isLittleEndian())`);
   }
 
-  function testReadData(dataview, type, offset, value) {
+  function testReadData (dataview, type, offset, value) {
     jsWriteDataView(dataview, type, offset, 0);
     assert.strictEqual(jsReadDataView(dataview, type, offset), 0);
 
     jsWriteDataView(dataview, type, offset, value);
     assert.strictEqual(
-        nativeReadDataView(dataview, type, offset), expected(type, value));
+      nativeReadDataView(dataview, type, offset), expected(type, value));
   }
 
-  function testWriteData(dataview, type, offset, value) {
+  function testWriteData (dataview, type, offset, value) {
     jsWriteDataView(dataview, type, offset, 0);
     assert.strictEqual(jsReadDataView(dataview, type, offset), 0);
 
     nativeWriteDataView(dataview, type, offset, value);
     assert.strictEqual(
-        jsReadDataView(dataview, type, offset), expected(type, value));
+      jsReadDataView(dataview, type, offset), expected(type, value));
   }
 
-  function testInvalidOffset(dataview, type, offset, value) {
+  function testInvalidOffset (dataview, type, offset, value) {
     assert.throws(() => {
       nativeReadDataView(dataview, type, offset);
     }, RangeError);

package/vendor/node-addon-api/test/date.cc

@@ -26,7 +26,8 @@ Value ValueOf(const CallbackInfo& info) {
 Value OperatorValue(const CallbackInfo& info) {
   Date input = info[0].As<Date>();
 
-  return Boolean::New(info.Env(), input.ValueOf() == static_cast<double>(input));
+  return Boolean::New(info.Env(),
+                      input.ValueOf() == static_cast<double>(input));
 }
 
 }  // anonymous namespace

package/vendor/node-addon-api/test/date.js

@@ -4,12 +4,12 @@ const assert = require('assert');
 
 module.exports = require('./common').runTest(test);
 
-function test(binding) {
+function test (binding) {
   const {
     CreateDate,
     IsDate,
     ValueOf,
-    OperatorValue,
+    OperatorValue
   } = binding.date;
   assert.deepStrictEqual(CreateDate(0), new Date(0));
   assert.strictEqual(IsDate(new Date(0)), true);

package/vendor/node-addon-api/test/env_cleanup.cc

@@ -20,6 +20,13 @@ static void cleanupVoid() {
 static int secret1 = 42;
 static int secret2 = 43;
 
+class TestClass {
+ public:
+  Env::CleanupHook<void (*)(void* arg), int> hook;
+
+  void removeHook(Env env) { hook.Remove(env); }
+};
+
 Value AddHooks(const CallbackInfo& info) {
   auto env = info.Env();
 
@@ -72,6 +79,11 @@ Value AddHooks(const CallbackInfo& info) {
   added += !hook5.IsEmpty();
   added += !hook6.IsEmpty();
 
+  // Test store a hook in a member class variable
+  auto myclass = TestClass();
+  myclass.hook = env.AddCleanupHook(cleanup, &secret1);
+  myclass.removeHook(env);
+
   return Number::New(env, added);
 }
 

package/vendor/node-addon-api/test/env_cleanup.js

@@ -3,54 +3,53 @@
 const assert = require('assert');
 
 if (process.argv[2] === 'runInChildProcess') {
-    const binding_path = process.argv[3];
-    const remove_hooks = process.argv[4] === 'true';
+  const bindingPath = process.argv[3];
+  const removeHooks = process.argv[4] === 'true';
 
-    const binding = require(binding_path);
-    const actualAdded = binding.env_cleanup.addHooks(remove_hooks);
-    const expectedAdded = remove_hooks === true ? 0 : 8;
-    assert(actualAdded === expectedAdded, 'Incorrect number of hooks added');
-}
-else {
-    module.exports = require('./common').runTestWithBindingPath(test);
+  const binding = require(bindingPath);
+  const actualAdded = binding.env_cleanup.addHooks(removeHooks);
+  const expectedAdded = removeHooks === true ? 0 : 8;
+  assert(actualAdded === expectedAdded, 'Incorrect number of hooks added');
+} else {
+  module.exports = require('./common').runTestWithBindingPath(test);
 }
 
-function test(bindingPath) {
-    for (const remove_hooks of [false, true]) {
-        const { status, output } = require('./napi_child').spawnSync(
-            process.execPath,
-            [
-                __filename,
-                'runInChildProcess',
-                bindingPath,
-                remove_hooks,
-            ],
-            { encoding: 'utf8' }
-        );
+function test (bindingPath) {
+  for (const removeHooks of [false, true]) {
+    const { status, output } = require('./napi_child').spawnSync(
+      process.execPath,
+      [
+        __filename,
+        'runInChildProcess',
+        bindingPath,
+        removeHooks
+      ],
+      { encoding: 'utf8' }
+    );
 
-        const stdout = output[1].trim();
-        /**
+    const stdout = output[1].trim();
+    /**
          * There is no need to sort the lines, as per Node-API documentation:
          *  > The hooks will be called in reverse order, i.e. the most recently
          *  > added one will be called first.
         */
-        const lines = stdout.split(/[\r\n]+/);
+    const lines = stdout.split(/[\r\n]+/);
 
-        assert(status === 0, `Process aborted with status ${status}`);
+    assert(status === 0, `Process aborted with status ${status}`);
 
-        if (remove_hooks) {
-            assert.deepStrictEqual(lines, [''], 'Child process had console output when none expected')
-        } else {
-            assert.deepStrictEqual(lines, [
-                'lambda cleanup()',
-                'lambda cleanup(void)',
-                'lambda cleanup(42)',
-                'static cleanup()',
-                'static cleanup()',
-                'static cleanup(43)',
-                'static cleanup(42)',
-                'static cleanup(42)'
-            ],  'Child process console output mismisatch')
-        }
+    if (removeHooks) {
+      assert.deepStrictEqual(lines, [''], 'Child process had console output when none expected');
+    } else {
+      assert.deepStrictEqual(lines, [
+        'lambda cleanup()',
+        'lambda cleanup(void)',
+        'lambda cleanup(42)',
+        'static cleanup()',
+        'static cleanup()',
+        'static cleanup(43)',
+        'static cleanup(42)',
+        'static cleanup(42)'
+      ], 'Child process console output mismisatch');
     }
+  }
 }

package/vendor/node-addon-api/test/error.cc

@@ -140,7 +140,7 @@ void CatchAndRethrowErrorThatEscapesScope(const CallbackInfo& info) {
   }
 }
 
-#else // NAPI_CPP_EXCEPTIONS
+#else  // NAPI_CPP_EXCEPTIONS
 
 void ThrowJSError(const CallbackInfo& info) {
   std::string message = info[0].As<String>().Utf8Value();
@@ -219,7 +219,7 @@ void CatchAndRethrowErrorThatEscapesScope(const CallbackInfo& info) {
   }
 }
 
-#endif // NAPI_CPP_EXCEPTIONS
+#endif  // NAPI_CPP_EXCEPTIONS
 
 void ThrowFatalError(const CallbackInfo& /*info*/) {
   Error::Fatal("Error::ThrowFatalError", "This is a fatal error");
@@ -261,7 +261,7 @@ void ThrowDefaultError(const CallbackInfo& info) {
   NAPI_THROW_IF_FAILED_VOID(env, status);
 }
 
-} // end anonymous namespace
+}  // end anonymous namespace
 
 Object InitError(Env env) {
   Object exports = Object::New(env);
@@ -275,9 +275,10 @@ Object InitError(Env env) {
   exports["catchErrorMessage"] = Function::New(env, CatchErrorMessage);
   exports["doNotCatch"] = Function::New(env, DoNotCatch);
   exports["catchAndRethrowError"] = Function::New(env, CatchAndRethrowError);
-  exports["throwErrorThatEscapesScope"] = Function::New(env, ThrowErrorThatEscapesScope);
+  exports["throwErrorThatEscapesScope"] =
+      Function::New(env, ThrowErrorThatEscapesScope);
   exports["catchAndRethrowErrorThatEscapesScope"] =
-    Function::New(env, CatchAndRethrowErrorThatEscapesScope);
+      Function::New(env, CatchAndRethrowErrorThatEscapesScope);
   exports["throwFatalError"] = Function::New(env, ThrowFatalError);
   exports["throwDefaultError"] = Function::New(env, ThrowDefaultError);
   exports["resetPromises"] = Function::New(env, ResetPromises);

package/vendor/node-addon-api/test/error_terminating_environment.js

@@ -1,20 +1,21 @@
 'use strict';
-const buildType = process.config.target_defaults.default_configuration;
+
 const assert = require('assert');
+const { whichBuildType } = require('./common');
 
 // These tests ensure that Error types can be used in a terminating
 // environment without triggering any fatal errors.
 
 if (process.argv[2] === 'runInChildProcess') {
-  const binding_path = process.argv[3];
-  const index_for_test_case = Number(process.argv[4]);
+  const bindingPath = process.argv[3];
+  const indexForTestCase = Number(process.argv[4]);
 
-  const binding = require(binding_path);
+  const binding = require(bindingPath);
 
   // Use C++ promises to ensure the worker thread is terminated right
   // before running the testable code in the binding.
 
-  binding.error.resetPromises()
+  binding.error.resetPromises();
 
   const { Worker } = require('worker_threads');
 
@@ -23,73 +24,76 @@ if (process.argv[2] === 'runInChildProcess') {
     {
       argv: [
         'runInWorkerThread',
-        binding_path,
-        index_for_test_case,
+        bindingPath,
+        indexForTestCase
       ]
     }
   );
 
-  binding.error.waitForWorkerThread()
+  binding.error.waitForWorkerThread();
 
   worker.terminate();
 
-  binding.error.releaseWorkerThread()
-
-  return;
-}
+  binding.error.releaseWorkerThread();
+} else {
+  if (process.argv[2] === 'runInWorkerThread') {
+    const bindingPath = process.argv[3];
+    const indexForTestCase = Number(process.argv[4]);
+
+    const binding = require(bindingPath);
+
+    switch (indexForTestCase) {
+      case 0:
+        binding.error.throwJSError('test', true);
+        break;
+      case 1:
+        binding.error.throwTypeError('test', true);
+        break;
+      case 2:
+        binding.error.throwRangeError('test', true);
+        break;
+      case 3:
+        binding.error.throwDefaultError(false, true);
+        break;
+      case 4:
+        binding.error.throwDefaultError(true, true);
+        break;
+      default: assert.fail('Invalid index');
+    }
 
-if (process.argv[2] === 'runInWorkerThread') {
-  const binding_path = process.argv[3];
-  const index_for_test_case = Number(process.argv[4]);
-
-  const binding = require(binding_path);
-
-  switch (index_for_test_case) {
-    case 0:
-      binding.error.throwJSError('test', true);
-      break;
-    case 1:
-      binding.error.throwTypeError('test', true);
-      break;
-    case 2:
-      binding.error.throwRangeError('test', true);
-      break;
-    case 3:
-      binding.error.throwDefaultError(false, true);
-      break;
-    case 4:
-      binding.error.throwDefaultError(true, true);
-      break;
-    default: assert.fail('Invalid index');
+    assert.fail('This should not be reachable');
   }
 
-  assert.fail('This should not be reachable');
-}
+  wrapTest();
 
-test(`./build/${buildType}/binding.node`, true);
-test(`./build/${buildType}/binding_noexcept.node`, true);
-test(`./build/${buildType}/binding_swallowexcept.node`, false);
-test(`./build/${buildType}/binding_swallowexcept_noexcept.node`, false);
-test(`./build/${buildType}/binding_custom_namespace.node`, true);
-
-function test(bindingPath, process_should_abort) {
-  const number_of_test_cases = 5;
-
-  for (let i = 0; i < number_of_test_cases; ++i) {
-    const child_process = require('./napi_child').spawnSync(
-      process.execPath,
-      [
-        __filename,
-        'runInChildProcess',
-        bindingPath,
-        i,
-      ]
-    );
+  async function wrapTest () {
+    const buildType = await whichBuildType();
+    test(`./build/${buildType}/binding.node`, true);
+    test(`./build/${buildType}/binding_noexcept.node`, true);
+    test(`./build/${buildType}/binding_swallowexcept.node`, false);
+    test(`./build/${buildType}/binding_swallowexcept_noexcept.node`, false);
+    test(`./build/${buildType}/binding_custom_namespace.node`, true);
+  }
 
-    if (process_should_abort) {
-      assert(child_process.status !== 0, `Test case ${bindingPath} ${i} failed: Process exited with status code 0.`);
-    } else {
-      assert(child_process.status === 0, `Test case ${bindingPath} ${i} failed: Process status ${child_process.status} is non-zero`);
+  function test (bindingPath, processShouldAbort) {
+    const numberOfTestCases = 5;
+
+    for (let i = 0; i < numberOfTestCases; ++i) {
+      const childProcess = require('./napi_child').spawnSync(
+        process.execPath,
+        [
+          __filename,
+          'runInChildProcess',
+          bindingPath,
+          i
+        ]
+      );
+
+      if (processShouldAbort) {
+        assert(childProcess.status !== 0, `Test case ${bindingPath} ${i} failed: Process exited with status code 0.`);
+      } else {
+        assert(childProcess.status === 0, `Test case ${bindingPath} ${i} failed: Process status ${childProcess.status} is non-zero`);
+      }
     }
   }
 }