koffi 2.7.1 → 2.7.3

package/vendor/node-addon-api/test/child_processes/objectwrap_function.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('../testUtil');
+
+module.exports = {
+  runTest: function (binding) {
+    return testUtil.runGCTests([
+      'objectwrap function',
+      () => {
+        const { FunctionTest } = binding.objectwrap_function();
+        const newConstructed = new FunctionTest();
+        const functionConstructed = FunctionTest();
+        assert(newConstructed instanceof FunctionTest);
+        assert(functionConstructed instanceof FunctionTest);
+        assert.throws(() => (FunctionTest(true)), /an exception/);
+      },
+      // Do one gc before returning.
+      () => {}
+    ]);
+  }
+};

package/vendor/node-addon-api/test/child_processes/threadsafe_function_exception.js

@@ -0,0 +1,33 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common');
+
+module.exports = {
+  testCall: async binding => {
+    const { testCall } = binding.threadsafe_function_exception;
+
+    await new Promise(resolve => {
+      process.once('uncaughtException', common.mustCall(err => {
+        assert.strictEqual(err.message, 'test');
+        resolve();
+      }, 1));
+
+      testCall(common.mustCall(() => {
+        throw new Error('test');
+      }, 1));
+    });
+  },
+  testCallWithNativeCallback: async binding => {
+    const { testCallWithNativeCallback } = binding.threadsafe_function_exception;
+
+    await new Promise(resolve => {
+      process.once('uncaughtException', common.mustCall(err => {
+        assert.strictEqual(err.message, 'test-from-native');
+        resolve();
+      }, 1));
+
+      testCallWithNativeCallback();
+    });
+  }
+};

package/vendor/node-addon-api/test/child_processes/typed_threadsafe_function_exception.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common');
+
+module.exports = {
+  testCall: async binding => {
+    const { testCall } = binding.typed_threadsafe_function_exception;
+
+    await new Promise(resolve => {
+      process.once('uncaughtException', common.mustCall(err => {
+        assert.strictEqual(err.message, 'test-from-native');
+        resolve();
+      }, 1));
+
+      testCall();
+    });
+  }
+};

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

@@ -3,6 +3,11 @@
 const assert = require('assert');
 const path = require('path');
 const { access } = require('node:fs/promises');
+const { spawn } = require('child_process');
+const { EOL } = require('os');
+const readline = require('readline');
+
+const escapeBackslashes = (pathString) => pathString.split('\\').join('\\\\');
 
 const noop = () => {};
 
@@ -26,7 +31,7 @@ function runCallChecks (exitCode) {
       context.name,
       context.messageSegment,
       context.actual);
-    console.log(context.stack.split('\n').slice(2).join('\n'));
+    console.log(context.stack.split(EOL).slice(2).join(EOL));
   });
 
   if (failed.length) process.exit(1);
@@ -143,7 +148,7 @@ async function whichBuildType () {
       if (await checkBuildType(envBuildType)) {
         buildType = envBuildType;
       } else {
-        throw new Error(`The ${envBuildType} build doesn't exists.`);
+        throw new Error(`The ${envBuildType} build doesn't exist.`);
       }
     } else {
       throw new Error('Invalid value for NODE_API_BUILD_CONFIG environment variable. It should be set to Release or Debug.');
@@ -164,7 +169,7 @@ exports.runTest = async function (test, buildType, buildPathRoot = process.env.B
   ].map(it => require.resolve(it));
 
   for (const item of bindings) {
-    await Promise.resolve(test(require(item)))
+    await Promise.resolve(test(require(item), { bindingPath: item }))
       .finally(exports.mustCall());
   }
 };
@@ -190,3 +195,52 @@ exports.runTestWithBuildType = async function (test, buildType) {
   await Promise.resolve(test(buildType))
     .finally(exports.mustCall());
 };
+
+// Some tests have to run in their own process, otherwise they would interfere
+// with each other. Such tests export a factory function rather than the test
+// itself so as to avoid automatic instantiation, and therefore interference,
+// in the main process. Two examples are addon and addon_data, both of which
+// use Napi::Env::SetInstanceData(). This helper function provides a common
+// approach for running such tests.
+exports.runTestInChildProcess = function ({ suite, testName, expectedStderr, execArgv }) {
+  return exports.runTestWithBindingPath((bindingName) => {
+    return new Promise((resolve) => {
+      bindingName = escapeBackslashes(bindingName);
+      // Test suites are assumed to be located here.
+      const suitePath = escapeBackslashes(path.join(__dirname, '..', 'child_processes', suite));
+      const child = spawn(process.execPath, [
+        '--expose-gc',
+        ...(execArgv ?? []),
+        '-e',
+        `require('${suitePath}').${testName}(require('${bindingName}'))`
+      ]);
+      const resultOfProcess = { stderr: [] };
+
+      // Capture the exit code and signal.
+      child.on('close', (code, signal) => resolve(Object.assign(resultOfProcess, { code, signal })));
+
+      // Capture the stderr as an array of lines.
+      readline
+        .createInterface({ input: child.stderr })
+        .on('line', (line) => {
+          resultOfProcess.stderr.push(line);
+        });
+    }).then(actual => {
+      // Back up the stderr in case the assertion fails.
+      const fullStderr = actual.stderr.map(item => `from child process: ${item}`);
+      const expected = { stderr: expectedStderr, code: 0, signal: null };
+
+      if (!expectedStderr) {
+        // If we don't care about stderr, delete it.
+        delete actual.stderr;
+        delete expected.stderr;
+      } else {
+        // Otherwise we only care about expected lines in the actual stderr, so
+        // filter out everything else.
+        actual.stderr = actual.stderr.filter(line => expectedStderr.includes(line));
+      }
+
+      assert.deepStrictEqual(actual, expected, `Assertion for child process test ${suite}.${testName} failed:${EOL}` + fullStderr.join(EOL));
+    });
+  });
+};

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

@@ -0,0 +1,25 @@
+#include "napi.h"
+#include "test_helper.h"
+
+#if (NAPI_VERSION > 8)
+
+using namespace Napi;
+
+namespace {
+
+Value GetModuleFileName(const CallbackInfo& info) {
+  Env env = info.Env();
+  return String::New(env, env.GetModuleFileName());
+}
+
+}  // end anonymous namespace
+
+Object InitEnvMiscellaneous(Env env) {
+  Object exports = Object::New(env);
+
+  exports["get_module_file_name"] = Function::New(env, GetModuleFileName);
+
+  return exports;
+}
+
+#endif

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

@@ -0,0 +1,12 @@
+'use strict';
+
+const assert = require('assert');
+const { pathToFileURL } = require('url');
+
+module.exports = require('./common').runTest(test);
+
+function test (binding, { bindingPath } = {}) {
+  const path = binding.env_misc.get_module_file_name();
+  const bindingFileUrl = pathToFileURL(bindingPath).toString();
+  assert(bindingFileUrl === path);
+}

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

@@ -153,6 +153,27 @@ void ThrowRangeError(const CallbackInfo& info) {
   throw RangeError::New(info.Env(), message);
 }
 
+#if NAPI_VERSION > 8
+void ThrowSyntaxErrorCStr(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+  ReleaseAndWaitForChildProcess(info, 1);
+  throw SyntaxError::New(info.Env(), message.c_str());
+}
+
+void ThrowSyntaxErrorCtor(const CallbackInfo& info) {
+  Napi::Value js_range_err = info[0];
+  ReleaseAndWaitForChildProcess(info, 1);
+  throw Napi::SyntaxError(info.Env(), js_range_err);
+}
+
+void ThrowSyntaxError(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+
+  ReleaseAndWaitForChildProcess(info, 1);
+  throw SyntaxError::New(info.Env(), message);
+}
+#endif  // NAPI_VERSION > 8
+
 Value CatchError(const CallbackInfo& info) {
   Function thrower = info[0].As<Function>();
   try {
@@ -255,6 +276,27 @@ void ThrowEmptyRangeError(const CallbackInfo& info) {
   RangeError().ThrowAsJavaScriptException();
 }
 
+#if NAPI_VERSION > 8
+void ThrowSyntaxError(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+
+  ReleaseAndWaitForChildProcess(info, 1);
+  SyntaxError::New(info.Env(), message).ThrowAsJavaScriptException();
+}
+
+void ThrowSyntaxErrorCtor(const CallbackInfo& info) {
+  Napi::Value js_range_err = info[0];
+  ReleaseAndWaitForChildProcess(info, 1);
+  SyntaxError(info.Env(), js_range_err).ThrowAsJavaScriptException();
+}
+
+void ThrowSyntaxErrorCStr(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+  ReleaseAndWaitForChildProcess(info, 1);
+  SyntaxError::New(info.Env(), message.c_str()).ThrowAsJavaScriptException();
+}
+#endif  // NAPI_VERSION > 8
+
 Value CatchError(const CallbackInfo& info) {
   Function thrower = info[0].As<Function>();
   thrower({});
@@ -372,6 +414,11 @@ Object InitError(Env env) {
   exports["throwRangeErrorCtor"] = Function::New(env, ThrowRangeErrorCtor);
   exports["throwRangeErrorCStr"] = Function::New(env, ThrowRangeErrorCStr);
   exports["throwEmptyRangeError"] = Function::New(env, ThrowEmptyRangeError);
+#if NAPI_VERSION > 8
+  exports["throwSyntaxError"] = Function::New(env, ThrowSyntaxError);
+  exports["throwSyntaxErrorCtor"] = Function::New(env, ThrowSyntaxErrorCtor);
+  exports["throwSyntaxErrorCStr"] = Function::New(env, ThrowSyntaxErrorCStr);
+#endif  // NAPI_VERSION > 8
   exports["catchError"] = Function::New(env, CatchError);
   exports["catchErrorMessage"] = Function::New(env, CatchErrorMessage);
   exports["doNotCatch"] = Function::New(env, DoNotCatch);

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

@@ -9,6 +9,8 @@ if (process.argv[2] === 'fatal') {
 
 module.exports = require('./common').runTestWithBindingPath(test);
 
+const napiVersion = Number(process.env.NAPI_VERSION ?? process.versions.napi);
+
 function test (bindingPath) {
   const binding = require(bindingPath);
   binding.error.testErrorCopySemantics();
@@ -46,6 +48,20 @@ function test (bindingPath) {
     return err instanceof RangeError && err.message === 'rangeTypeError';
   });
 
+  if (napiVersion > 8) {
+    assert.throws(() => binding.error.throwSyntaxErrorCStr('test'), function (err) {
+      return err instanceof SyntaxError && err.message === 'test';
+    });
+
+    assert.throws(() => binding.error.throwSyntaxError('test'), function (err) {
+      return err instanceof SyntaxError && err.message === 'test';
+    });
+
+    assert.throws(() => binding.error.throwSyntaxErrorCtor(new SyntaxError('syntaxTypeError')), function (err) {
+      return err instanceof SyntaxError && err.message === 'syntaxTypeError';
+    });
+  }
+
   assert.throws(
     () => binding.error.doNotCatch(
       () => {

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

@@ -60,6 +60,7 @@ function loadTestModules (currentDirectory = __dirname, pre = '') {
           file === 'binding.gyp' ||
           file === 'build' ||
           file === 'common' ||
+          file === 'child_processes' ||
           file === 'napi_child.js' ||
           file === 'testUtil.js' ||
           file === 'thunking_manual.cc' ||
@@ -137,6 +138,10 @@ if (napiVersion < 8 && !filterConditionsProvided) {
   testModules.splice(testModules.indexOf('type_taggable'), 1);
 }
 
+if (napiVersion < 9 && !filterConditionsProvided) {
+  testModules.splice(testModules.indexOf('env_misc'), 1);
+}
+
 (async function () {
   console.log(`Testing with Node-API Version '${napiVersion}'.`);
 

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

@@ -18,28 +18,26 @@ class FunctionTest : public Napi::ObjectWrap<FunctionTest> {
     return MaybeUnwrap(GetConstructor(info.Env()).New(args));
   }
 
-  // Constructor-per-env map in a static member because env.SetInstanceData()
-  // would interfere with Napi::Addon<T>
-  static std::unordered_map<napi_env, Napi::FunctionReference> constructors;
-
   static void Initialize(Napi::Env env, Napi::Object exports) {
     const char* name = "FunctionTest";
     Napi::Function func = DefineClass(env, name, {});
-    constructors[env] = Napi::Persistent(func);
-    env.AddCleanupHook([env] { constructors.erase(env); });
+    Napi::FunctionReference* ctor = new Napi::FunctionReference();
+    *ctor = Napi::Persistent(func);
+    env.SetInstanceData(ctor);
     exports.Set(name, func);
   }
 
   static Napi::Function GetConstructor(Napi::Env env) {
-    return constructors[env].Value();
+    return env.GetInstanceData<Napi::FunctionReference>()->Value();
   }
 };
 
-std::unordered_map<napi_env, Napi::FunctionReference>
-    FunctionTest::constructors;
+Napi::Value ObjectWrapFunctionFactory(const Napi::CallbackInfo& info) {
+  Napi::Object exports = Napi::Object::New(info.Env());
+  FunctionTest::Initialize(info.Env(), exports);
+  return exports;
+}
 
 Napi::Object InitObjectWrapFunction(Napi::Env env) {
-  Napi::Object exports = Napi::Object::New(env);
-  FunctionTest::Initialize(env, exports);
-  return exports;
+  return Napi::Function::New<ObjectWrapFunctionFactory>(env, "FunctionFactory");
 }

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

@@ -1,22 +1,6 @@
 'use strict';
 
-const assert = require('assert');
-const testUtil = require('./testUtil');
-
-function test (binding) {
-  return testUtil.runGCTests([
-    'objectwrap function',
-    () => {
-      const { FunctionTest } = binding.objectwrap_function;
-      const newConstructed = new FunctionTest();
-      const functionConstructed = FunctionTest();
-      assert(newConstructed instanceof FunctionTest);
-      assert(functionConstructed instanceof FunctionTest);
-      assert.throws(() => (FunctionTest(true)), /an exception/);
-    },
-    // Do on gc before returning.
-    () => {}
-  ]);
-}
-
-module.exports = require('./common').runTest(test);
+module.exports = require('./common').runTestInChildProcess({
+  suite: 'objectwrap_function',
+  testName: 'runTest'
+});

package/vendor/node-addon-api/test/threadsafe_function/threadsafe_function_exception.cc

@@ -0,0 +1,50 @@
+#include <cstdlib>
+#include "napi.h"
+#include "test_helper.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+namespace {
+
+void CallJS(napi_env env, napi_value /* callback */, void* /*data*/) {
+  Napi::Error error = Napi::Error::New(env, "test-from-native");
+  NAPI_THROW_VOID(error);
+}
+
+void TestCall(const CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  ThreadSafeFunction wrapped =
+      ThreadSafeFunction::New(env,
+                              info[0].As<Napi::Function>(),
+                              Object::New(env),
+                              String::New(env, "Test"),
+                              0,
+                              1);
+  wrapped.BlockingCall(static_cast<void*>(nullptr));
+  wrapped.Release();
+}
+
+void TestCallWithNativeCallback(const CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  ThreadSafeFunction wrapped = ThreadSafeFunction::New(
+      env, Napi::Function(), Object::New(env), String::New(env, "Test"), 0, 1);
+  wrapped.BlockingCall(static_cast<void*>(nullptr), CallJS);
+  wrapped.Release();
+}
+
+}  // namespace
+
+Object InitThreadSafeFunctionException(Env env) {
+  Object exports = Object::New(env);
+  exports["testCall"] = Function::New(env, TestCall);
+  exports["testCallWithNativeCallback"] =
+      Function::New(env, TestCallWithNativeCallback);
+
+  return exports;
+}
+
+#endif

package/vendor/node-addon-api/test/threadsafe_function/threadsafe_function_exception.js

@@ -0,0 +1,20 @@
+'use strict';
+
+const common = require('../common');
+
+module.exports = common.runTest(test);
+
+const execArgv = ['--force-node-api-uncaught-exceptions-policy=true'];
+async function test () {
+  await common.runTestInChildProcess({
+    suite: 'threadsafe_function_exception',
+    testName: 'testCall',
+    execArgv
+  });
+
+  await common.runTestInChildProcess({
+    suite: 'threadsafe_function_exception',
+    testName: 'testCallWithNativeCallback',
+    execArgv
+  });
+}

package/vendor/node-addon-api/test/typed_threadsafe_function/typed_threadsafe_function_exception.cc

@@ -0,0 +1,39 @@
+#include <cstdlib>
+#include "napi.h"
+#include "test_helper.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+namespace {
+
+void CallJS(Napi::Env env,
+            Napi::Function /* callback */,
+            std::nullptr_t* /* context */,
+            void* /*data*/) {
+  Napi::Error error = Napi::Error::New(env, "test-from-native");
+  NAPI_THROW_VOID(error);
+}
+
+using TSFN = TypedThreadSafeFunction<std::nullptr_t, void, CallJS>;
+
+void TestCall(const CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  TSFN wrapped = TSFN::New(
+      env, Napi::Function(), Object::New(env), String::New(env, "Test"), 0, 1);
+  wrapped.BlockingCall(static_cast<void*>(nullptr));
+  wrapped.Release();
+}
+
+}  // namespace
+
+Object InitTypedThreadSafeFunctionException(Env env) {
+  Object exports = Object::New(env);
+  exports["testCall"] = Function::New(env, TestCall);
+
+  return exports;
+}
+
+#endif

package/vendor/node-addon-api/test/typed_threadsafe_function/typed_threadsafe_function_exception.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const common = require('../common');
+
+module.exports = common.runTest(test);
+
+async function test () {
+  await common.runTestInChildProcess({
+    suite: 'typed_threadsafe_function_exception',
+    testName: 'testCall',
+    execArgv: ['--force-node-api-uncaught-exceptions-policy=true']
+  });
+}