koffi 0.9.34 → 0.9.37

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

@@ -0,0 +1,81 @@
+#include "napi.h"
+
+using namespace Napi;
+
+namespace {
+
+int testData = 1;
+int finalizeCount = 0;
+
+Value CreateExternal(const CallbackInfo& info) {
+  finalizeCount = 0;
+  return External<int>::New(info.Env(), &testData);
+}
+
+Value CreateExternalWithFinalize(const CallbackInfo& info) {
+  finalizeCount = 0;
+  return External<int>::New(info.Env(), new int(1),
+    [](Env /*env*/, int* data) {
+      delete data;
+      finalizeCount++;
+    });
+}
+
+Value CreateExternalWithFinalizeHint(const CallbackInfo& info) {
+  finalizeCount = 0;
+  char* hint = nullptr;
+  return External<int>::New(info.Env(), new int(1),
+    [](Env /*env*/, int* data, char* /*hint*/) {
+      delete data;
+      finalizeCount++;
+    },
+    hint);
+}
+
+void CheckExternal(const CallbackInfo& info) {
+   Value arg = info[0];
+   if (arg.Type() != napi_external) {
+      Error::New(info.Env(), "An external argument was expected.").ThrowAsJavaScriptException();
+      return;
+   }
+
+   External<int> external = arg.As<External<int>>();
+   int* externalData = external.Data();
+   if (externalData == nullptr || *externalData != 1) {
+      Error::New(info.Env(), "An external value of 1 was expected.").ThrowAsJavaScriptException();
+      return;
+   }
+}
+
+Value GetFinalizeCount(const CallbackInfo& info) {
+   return Number::New(info.Env(), finalizeCount);
+}
+
+Value CreateExternalWithFinalizeException(const CallbackInfo& info) {
+  return External<int>::New(info.Env(), new int(1),
+    [](Env env, int* data) {
+      Error error = Error::New(env, "Finalizer exception");
+      delete data;
+#ifdef NAPI_CPP_EXCEPTIONS
+      throw error;
+#else
+      error.ThrowAsJavaScriptException();
+#endif
+    });
+}
+
+} // end anonymous namespace
+
+Object InitExternal(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createExternal"] = Function::New(env, CreateExternal);
+  exports["createExternalWithFinalize"] = Function::New(env, CreateExternalWithFinalize);
+  exports["createExternalWithFinalizeException"] =
+      Function::New(env, CreateExternalWithFinalizeException);
+  exports["createExternalWithFinalizeHint"] = Function::New(env, CreateExternalWithFinalizeHint);
+  exports["checkExternal"] = Function::New(env, CheckExternal);
+  exports["getFinalizeCount"] = Function::New(env, GetFinalizeCount);
+
+  return exports;
+}

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

@@ -0,0 +1,88 @@
+'use strict';
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const testUtil = require('./testUtil');
+
+if (process.argv.length === 3) {
+  let interval;
+
+  // Running as the child process, hook up an `uncaughtException` handler to
+  // examine the error thrown by the finalizer.
+  process.on('uncaughtException', (error) => {
+    // TODO (gabrielschulhof): Use assert.matches() when we drop support for
+    // Node.js v10.x.
+    assert(!!error.message.match(/Finalizer exception/));
+    if (interval) {
+      clearInterval(interval);
+    }
+    process.exit(0);
+  });
+
+  // Create an external whose finalizer throws.
+  (() =>
+    require(process.argv[2]).external.createExternalWithFinalizeException())();
+
+  // gc until the external's finalizer throws or until we give up. Since the
+  // exception is thrown from a native `SetImmediate()` we cannot catch it
+  // anywhere except in the process' `uncaughtException` handler.
+  let maxGCTries = 10;
+  (function gcInterval() {
+    global.gc();
+    if (!interval) {
+      interval = setInterval(gcInterval, 100);
+    } else if (--maxGCTries === 0) {
+      throw new Error('Timed out waiting for the gc to throw');
+      process.exit(1);
+    }
+  })();
+
+  return;
+}
+
+module.exports = require('./common').runTestWithBindingPath(test);
+
+function test(bindingPath) {
+  const binding = require(bindingPath);
+
+  const child = spawnSync(process.execPath, [
+    '--expose-gc', __filename, bindingPath
+  ], { stdio: 'inherit' });
+  assert.strictEqual(child.status, 0);
+  assert.strictEqual(child.signal, null);
+
+  return testUtil.runGCTests([
+    'External without finalizer',
+    () => {
+      const test = binding.external.createExternal();
+      assert.strictEqual(typeof test, 'object');
+      binding.external.checkExternal(test);
+      assert.strictEqual(0, binding.external.getFinalizeCount());
+    },
+    () => {
+      assert.strictEqual(0, binding.external.getFinalizeCount());
+    },
+
+    'External with finalizer',
+    () => {
+      const test = binding.external.createExternalWithFinalize();
+      assert.strictEqual(typeof test, 'object');
+      binding.external.checkExternal(test);
+      assert.strictEqual(0, binding.external.getFinalizeCount());
+    },
+    () => {
+      assert.strictEqual(1, binding.external.getFinalizeCount());
+    },
+
+    'External with finalizer hint',
+    () => {
+      const test = binding.external.createExternalWithFinalizeHint();
+      assert.strictEqual(typeof test, 'object');
+      binding.external.checkExternal(test);
+      assert.strictEqual(0, binding.external.getFinalizeCount());
+    },
+    () => {
+      assert.strictEqual(1, binding.external.getFinalizeCount());
+    },
+  ]);
+}

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

@@ -0,0 +1,324 @@
+#include <memory>
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+namespace {
+
+int testData = 1;
+
+Boolean EmptyConstructor(const CallbackInfo& info) {
+  auto env = info.Env();
+  bool isEmpty = info[0].As<Boolean>();
+  Function function = isEmpty ? Function() : Function(env, Object::New(env));
+  return Boolean::New(env, function.IsEmpty());
+}
+
+void VoidCallback(const CallbackInfo& info) {
+  auto env = info.Env();
+  Object obj = info[0].As<Object>();
+
+  obj["foo"] = String::New(env, "bar");
+}
+
+Value ValueCallback(const CallbackInfo& info) {
+  auto env = info.Env();
+  Object obj = Object::New(env);
+
+  obj["foo"] = String::New(env, "bar");
+
+  return obj;
+}
+
+void VoidCallbackWithData(const CallbackInfo& info) {
+  auto env = info.Env();
+  Object obj = info[0].As<Object>();
+
+  obj["foo"] = String::New(env, "bar");
+
+  int* data = static_cast<int*>(info.Data());
+  obj["data"] = Number::New(env, *data);
+}
+
+Value ValueCallbackWithData(const CallbackInfo& info) {
+  auto env = info.Env();
+  Object obj = Object::New(env);
+
+  obj["foo"] = String::New(env, "bar");
+
+  int* data = static_cast<int*>(info.Data());
+  obj["data"] = Number::New(env, *data);
+
+  return obj;
+}
+
+Value CallWithArgs(const CallbackInfo& info) {
+  Function func = info[0].As<Function>();
+  return MaybeUnwrap(
+      func.Call(std::initializer_list<napi_value>{info[1], info[2], info[3]}));
+}
+
+Value CallWithVector(const CallbackInfo& info) {
+   Function func = info[0].As<Function>();
+   std::vector<napi_value> args;
+   args.reserve(3);
+   args.push_back(info[1]);
+   args.push_back(info[2]);
+   args.push_back(info[3]);
+   return MaybeUnwrap(func.Call(args));
+}
+
+Value CallWithVectorUsingCppWrapper(const CallbackInfo& info) {
+  Function func = info[0].As<Function>();
+  std::vector<Value> args;
+  args.reserve(3);
+  args.push_back(info[1]);
+  args.push_back(info[2]);
+  args.push_back(info[3]);
+  return MaybeUnwrap(func.Call(args));
+}
+
+Value CallWithCStyleArray(const CallbackInfo& info) {
+  Function func = info[0].As<Function>();
+  std::vector<napi_value> args;
+  args.reserve(3);
+  args.push_back(info[1]);
+  args.push_back(info[2]);
+  args.push_back(info[3]);
+  return MaybeUnwrap(func.Call(args.size(), args.data()));
+}
+
+Value CallWithReceiverAndCStyleArray(const CallbackInfo& info) {
+  Function func = info[0].As<Function>();
+  Value receiver = info[1];
+  std::vector<napi_value> args;
+  args.reserve(3);
+  args.push_back(info[2]);
+  args.push_back(info[3]);
+  args.push_back(info[4]);
+  return MaybeUnwrap(func.Call(receiver, args.size(), args.data()));
+}
+
+Value CallWithReceiverAndArgs(const CallbackInfo& info) {
+   Function func = info[0].As<Function>();
+   Value receiver = info[1];
+   return MaybeUnwrap(func.Call(
+       receiver, std::initializer_list<napi_value>{info[2], info[3], info[4]}));
+}
+
+Value CallWithReceiverAndVector(const CallbackInfo& info) {
+   Function func = info[0].As<Function>();
+   Value receiver = info[1];
+   std::vector<napi_value> args;
+   args.reserve(3);
+   args.push_back(info[2]);
+   args.push_back(info[3]);
+   args.push_back(info[4]);
+   return MaybeUnwrap(func.Call(receiver, args));
+}
+
+Value CallWithReceiverAndVectorUsingCppWrapper(const CallbackInfo& info) {
+  Function func = info[0].As<Function>();
+  Value receiver = info[1];
+  std::vector<Value> args;
+  args.reserve(3);
+  args.push_back(info[2]);
+  args.push_back(info[3]);
+  args.push_back(info[4]);
+  return MaybeUnwrap(func.Call(receiver, args));
+}
+
+Value CallWithInvalidReceiver(const CallbackInfo& info) {
+   Function func = info[0].As<Function>();
+   return MaybeUnwrapOr(func.Call(Value(), std::initializer_list<napi_value>{}),
+                        Value());
+}
+
+Value CallConstructorWithArgs(const CallbackInfo& info) {
+   Function func = info[0].As<Function>();
+   return MaybeUnwrap(
+       func.New(std::initializer_list<napi_value>{info[1], info[2], info[3]}));
+}
+
+Value CallConstructorWithVector(const CallbackInfo& info) {
+   Function func = info[0].As<Function>();
+   std::vector<napi_value> args;
+   args.reserve(3);
+   args.push_back(info[1]);
+   args.push_back(info[2]);
+   args.push_back(info[3]);
+   return MaybeUnwrap(func.New(args));
+}
+
+Value CallConstructorWithCStyleArray(const CallbackInfo& info) {
+  Function func = info[0].As<Function>();
+  std::vector<napi_value> args;
+  args.reserve(3);
+  args.push_back(info[1]);
+  args.push_back(info[2]);
+  args.push_back(info[3]);
+  return MaybeUnwrap(func.New(args.size(), args.data()));
+}
+
+void IsConstructCall(const CallbackInfo& info) {
+   Function callback = info[0].As<Function>();
+   bool isConstructCall = info.IsConstructCall();
+   callback({Napi::Boolean::New(info.Env(), isConstructCall)});
+}
+
+void MakeCallbackWithArgs(const CallbackInfo& info) {
+  Env env = info.Env();
+  Function callback = info[0].As<Function>();
+  Object resource = info[1].As<Object>();
+
+  AsyncContext context(env, "function_test_context", resource);
+
+  callback.MakeCallback(
+      resource,
+      std::initializer_list<napi_value>{info[2], info[3], info[4]},
+      context);
+}
+
+void MakeCallbackWithVector(const CallbackInfo& info) {
+  Env env = info.Env();
+  Function callback = info[0].As<Function>();
+  Object resource = info[1].As<Object>();
+
+  AsyncContext context(env, "function_test_context", resource);
+
+  std::vector<napi_value> args;
+  args.reserve(3);
+  args.push_back(info[2]);
+  args.push_back(info[3]);
+  args.push_back(info[4]);
+  callback.MakeCallback(resource, args, context);
+}
+
+void MakeCallbackWithCStyleArray(const CallbackInfo& info) {
+  Env env = info.Env();
+  Function callback = info[0].As<Function>();
+  Object resource = info[1].As<Object>();
+
+  AsyncContext context(env, "function_test_context", resource);
+
+  std::vector<napi_value> args;
+  args.reserve(3);
+  args.push_back(info[2]);
+  args.push_back(info[3]);
+  args.push_back(info[4]);
+  callback.MakeCallback(resource, args.size(), args.data(), context);
+}
+
+void MakeCallbackWithInvalidReceiver(const CallbackInfo& info) {
+  Function callback = info[0].As<Function>();
+  callback.MakeCallback(Value(), std::initializer_list<napi_value>{});
+}
+
+Value CallWithFunctionOperator(const CallbackInfo& info) {
+  Function func = info[0].As<Function>();
+  return MaybeUnwrap(func({info[1], info[2], info[3]}));
+}
+
+} // end anonymous namespace
+
+Object InitFunction(Env env) {
+  Object result = Object::New(env);
+  Object exports = Object::New(env);
+  exports["emptyConstructor"] = Function::New(env, EmptyConstructor);
+  exports["voidCallback"] = Function::New(env, VoidCallback, "voidCallback");
+  exports["valueCallback"] = Function::New(env, ValueCallback, std::string("valueCallback"));
+  exports["voidCallbackWithData"] =
+    Function::New(env, VoidCallbackWithData, nullptr, &testData);
+  exports["valueCallbackWithData"] =
+    Function::New(env, ValueCallbackWithData, nullptr, &testData);
+  exports["callWithArgs"] = Function::New(env, CallWithArgs);
+  exports["callWithVector"] = Function::New(env, CallWithVector);
+  exports["callWithVectorUsingCppWrapper"] =
+      Function::New(env, CallWithVectorUsingCppWrapper);
+  exports["callWithCStyleArray"] = Function::New(env, CallWithCStyleArray);
+  exports["callWithReceiverAndCStyleArray"] =
+      Function::New(env, CallWithReceiverAndCStyleArray);
+  exports["callWithReceiverAndArgs"] = Function::New(env, CallWithReceiverAndArgs);
+  exports["callWithReceiverAndVector"] = Function::New(env, CallWithReceiverAndVector);
+  exports["callWithReceiverAndVectorUsingCppWrapper"] =
+      Function::New(env, CallWithReceiverAndVectorUsingCppWrapper);
+  exports["callWithInvalidReceiver"] = Function::New(env, CallWithInvalidReceiver);
+  exports["callConstructorWithArgs"] = Function::New(env, CallConstructorWithArgs);
+  exports["callConstructorWithVector"] = Function::New(env, CallConstructorWithVector);
+  exports["callConstructorWithCStyleArray"] =
+      Function::New(env, CallConstructorWithCStyleArray);
+  exports["isConstructCall"] = Function::New(env, IsConstructCall);
+  exports["makeCallbackWithArgs"] = Function::New(env, MakeCallbackWithArgs);
+  exports["makeCallbackWithVector"] =
+      Function::New(env, MakeCallbackWithVector);
+  exports["makeCallbackWithCStyleArray"] =
+      Function::New(env, MakeCallbackWithCStyleArray);
+  exports["makeCallbackWithInvalidReceiver"] =
+      Function::New(env, MakeCallbackWithInvalidReceiver);
+  exports["callWithFunctionOperator"] =
+      Function::New(env, CallWithFunctionOperator);
+  result["plain"] = exports;
+
+  exports = Object::New(env);
+  exports["emptyConstructor"] = Function::New(env, EmptyConstructor);
+  exports["voidCallback"] = Function::New<VoidCallback>(env, "voidCallback");
+  exports["valueCallback"] =
+      Function::New<ValueCallback>(env, std::string("valueCallback"));
+  exports["voidCallbackWithData"] =
+      Function::New<VoidCallbackWithData>(env, nullptr, &testData);
+  exports["valueCallbackWithData"] =
+      Function::New<ValueCallbackWithData>(env, nullptr, &testData);
+  exports["callWithArgs"] = Function::New<CallWithArgs>(env);
+  exports["callWithVector"] = Function::New<CallWithVector>(env);
+  exports["callWithVectorUsingCppWrapper"] =
+      Function::New<CallWithVectorUsingCppWrapper>(env);
+  exports["callWithCStyleArray"] = Function::New<CallWithCStyleArray>(env);
+  exports["callWithReceiverAndCStyleArray"] =
+      Function::New<CallWithReceiverAndCStyleArray>(env);
+  exports["callWithReceiverAndArgs"] =
+      Function::New<CallWithReceiverAndArgs>(env);
+  exports["callWithReceiverAndVector"] =
+      Function::New<CallWithReceiverAndVector>(env);
+  exports["callWithReceiverAndVectorUsingCppWrapper"] =
+      Function::New<CallWithReceiverAndVectorUsingCppWrapper>(env);
+  exports["callWithInvalidReceiver"] =
+      Function::New<CallWithInvalidReceiver>(env);
+  exports["callConstructorWithArgs"] =
+      Function::New<CallConstructorWithArgs>(env);
+  exports["callConstructorWithVector"] =
+      Function::New<CallConstructorWithVector>(env);
+  exports["callConstructorWithCStyleArray"] =
+      Function::New<CallConstructorWithCStyleArray>(env);
+  exports["isConstructCall"] = Function::New<IsConstructCall>(env);
+  exports["makeCallbackWithArgs"] = Function::New<MakeCallbackWithArgs>(env);
+  exports["makeCallbackWithVector"] =
+      Function::New<MakeCallbackWithVector>(env);
+  exports["makeCallbackWithCStyleArray"] =
+      Function::New<MakeCallbackWithCStyleArray>(env);
+  exports["makeCallbackWithInvalidReceiver"] =
+      Function::New<MakeCallbackWithInvalidReceiver>(env);
+  exports["callWithFunctionOperator"] =
+      Function::New<CallWithFunctionOperator>(env);
+  result["templated"] = exports;
+
+  exports = Object::New(env);
+  exports["lambdaWithNoCapture"] =
+      Function::New(env, [](const CallbackInfo& info) {
+        auto env = info.Env();
+        return Boolean::New(env, true);
+      });
+  exports["lambdaWithCapture"] =
+      Function::New(env, [data = 42](const CallbackInfo& info) {
+        auto env = info.Env();
+        return Boolean::New(env, data == 42);
+      });
+  exports["lambdaWithMoveOnlyCapture"] = Function::New(
+      env, [data = std::make_unique<int>(42)](const CallbackInfo& info) {
+        auto env = info.Env();
+        return Boolean::New(env, *data == 42);
+      });
+  result["lambda"] = exports;
+
+  return result;
+}

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

@@ -0,0 +1,133 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(binding => {
+  test(binding.function.plain);
+  test(binding.function.templated);
+  testLambda(binding.function.lambda);
+});
+
+function test (binding) {
+  assert.strictEqual(binding.emptyConstructor(true), true);
+  assert.strictEqual(binding.emptyConstructor(false), false);
+
+  let obj = {};
+  assert.deepStrictEqual(binding.voidCallback(obj), undefined);
+  assert.deepStrictEqual(obj, { foo: 'bar' });
+
+  assert.deepStrictEqual(binding.valueCallback(), { foo: 'bar' });
+
+  let args = null;
+  let ret = null;
+  let receiver = null;
+  function testFunction () {
+    receiver = this;
+    args = [].slice.call(arguments);
+    return ret;
+  }
+  function testConstructor () {
+    args = [].slice.call(arguments);
+  }
+
+  function makeCallbackTestFunction (receiver, expectedOne, expectedTwo, expectedThree) {
+    return function callback (one, two, three) {
+      assert.strictEqual(this, receiver);
+      assert.strictEqual(one, expectedOne);
+      assert.strictEqual(two, expectedTwo);
+      assert.strictEqual(three, expectedThree);
+    };
+  }
+
+  ret = 4;
+  assert.strictEqual(binding.callWithArgs(testFunction, 1, 2, 3), 4);
+  assert.strictEqual(receiver, undefined);
+  assert.deepStrictEqual(args, [1, 2, 3]);
+
+  ret = 5;
+  assert.strictEqual(binding.callWithVector(testFunction, 2, 3, 4), 5);
+  assert.strictEqual(receiver, undefined);
+  assert.deepStrictEqual(args, [2, 3, 4]);
+
+  ret = 5;
+  assert.strictEqual(binding.callWithVectorUsingCppWrapper(testFunction, 2, 3, 4), 5);
+  assert.strictEqual(receiver, undefined);
+  assert.deepStrictEqual(args, [2, 3, 4]);
+
+  ret = 6;
+  assert.strictEqual(binding.callWithReceiverAndArgs(testFunction, obj, 3, 4, 5), 6);
+  assert.deepStrictEqual(receiver, obj);
+  assert.deepStrictEqual(args, [3, 4, 5]);
+
+  ret = 7;
+  assert.strictEqual(binding.callWithReceiverAndVector(testFunction, obj, 4, 5, 6), 7);
+  assert.deepStrictEqual(receiver, obj);
+  assert.deepStrictEqual(args, [4, 5, 6]);
+
+  ret = 7;
+  assert.strictEqual(binding.callWithReceiverAndVectorUsingCppWrapper(testFunction, obj, 4, 5, 6), 7);
+  assert.deepStrictEqual(receiver, obj);
+  assert.deepStrictEqual(args, [4, 5, 6]);
+
+  ret = 8;
+  assert.strictEqual(binding.callWithCStyleArray(testFunction, 5, 6, 7), ret);
+  assert.deepStrictEqual(receiver, undefined);
+  assert.deepStrictEqual(args, [5, 6, 7]);
+
+  ret = 9;
+  assert.strictEqual(binding.callWithReceiverAndCStyleArray(testFunction, obj, 6, 7, 8), ret);
+  assert.deepStrictEqual(receiver, obj);
+  assert.deepStrictEqual(args, [6, 7, 8]);
+
+  ret = 10;
+  assert.strictEqual(binding.callWithFunctionOperator(testFunction, 7, 8, 9), ret);
+  assert.strictEqual(receiver, undefined);
+  assert.deepStrictEqual(args, [7, 8, 9]);
+
+  assert.throws(() => {
+    binding.callWithInvalidReceiver();
+  }, /Invalid (pointer passed as )?argument/);
+
+  obj = binding.callConstructorWithArgs(testConstructor, 5, 6, 7);
+  assert(obj instanceof testConstructor);
+  assert.deepStrictEqual(args, [5, 6, 7]);
+
+  obj = binding.callConstructorWithVector(testConstructor, 6, 7, 8);
+  assert(obj instanceof testConstructor);
+  assert.deepStrictEqual(args, [6, 7, 8]);
+
+  obj = binding.callConstructorWithCStyleArray(testConstructor, 7, 8, 9);
+  assert(obj instanceof testConstructor);
+  assert.deepStrictEqual(args, [7, 8, 9]);
+
+  obj = {};
+  assert.deepStrictEqual(binding.voidCallbackWithData(obj), undefined);
+  assert.deepStrictEqual(obj, { foo: 'bar', data: 1 });
+
+  assert.deepStrictEqual(binding.valueCallbackWithData(), { foo: 'bar', data: 1 });
+
+  assert.strictEqual(binding.voidCallback.name, 'voidCallback');
+  assert.strictEqual(binding.valueCallback.name, 'valueCallback');
+
+  let testConstructCall;
+  binding.isConstructCall((result) => { testConstructCall = result; });
+  assert.ok(!testConstructCall);
+  /* eslint-disable no-new, new-cap */
+  new binding.isConstructCall((result) => { testConstructCall = result; });
+  /* eslint-enable no-new, new-cap */
+  assert.ok(testConstructCall);
+
+  obj = {};
+  binding.makeCallbackWithArgs(makeCallbackTestFunction(obj, '1', '2', '3'), obj, '1', '2', '3');
+  binding.makeCallbackWithVector(makeCallbackTestFunction(obj, 4, 5, 6), obj, 4, 5, 6);
+  binding.makeCallbackWithCStyleArray(makeCallbackTestFunction(obj, 7, 8, 9), obj, 7, 8, 9);
+  assert.throws(() => {
+    binding.makeCallbackWithInvalidReceiver(() => {});
+  });
+}
+
+function testLambda (binding) {
+  assert.ok(binding.lambdaWithNoCapture());
+  assert.ok(binding.lambdaWithCapture());
+  assert.ok(binding.lambdaWithMoveOnlyCapture());
+}