koffi 2.16.0-beta.2 → 2.16.0

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

@@ -1,98 +0,0 @@
-'use strict';
-
-/* eslint-disable no-unused-vars */
-
-const assert = require('assert');
-const common = require('./common');
-const testUtil = require('./testUtil');
-
-module.exports = require('./common').runTest(test);
-
-function test (binding) {
-  const { isExperimental } = binding;
-
-  let isCallbackCalled = false;
-
-  const tests = [
-    'Finalizer Order - ObjectWrap',
-    () => {
-      let test = new binding.finalizer_order.Test(() => { isCallbackCalled = true; });
-      test = null;
-
-      global.gc();
-
-      if (isExperimental) {
-        assert.strictEqual(binding.finalizer_order.Test.isBasicFinalizerCalled, true, 'Expected basic finalizer to be called [before ticking]');
-        assert.strictEqual(binding.finalizer_order.Test.isFinalizerCalled, false, 'Expected (extended) finalizer to not be called [before ticking]');
-        assert.strictEqual(isCallbackCalled, false, 'Expected callback to not be called [before ticking]');
-      } else {
-        assert.strictEqual(binding.finalizer_order.Test.isBasicFinalizerCalled, false, 'Expected basic finalizer to not be called [before ticking]');
-        assert.strictEqual(binding.finalizer_order.Test.isFinalizerCalled, false, 'Expected (extended) finalizer to not be called [before ticking]');
-        assert.strictEqual(isCallbackCalled, false, 'Expected callback to not be called [before ticking]');
-      }
-    },
-    () => {
-      assert.strictEqual(binding.finalizer_order.Test.isBasicFinalizerCalled, true, 'Expected basic finalizer to be called [after ticking]');
-      assert.strictEqual(binding.finalizer_order.Test.isFinalizerCalled, true, 'Expected (extended) finalizer to be called [after ticking]');
-      assert.strictEqual(isCallbackCalled, true, 'Expected callback to be called [after ticking]');
-    },
-
-    'Finalizer Order - External with Basic Finalizer',
-    () => {
-      let ext = binding.finalizer_order.createExternalBasicFinalizer();
-      ext = null;
-      global.gc();
-
-      if (isExperimental) {
-        assert.strictEqual(binding.finalizer_order.isExternalBasicFinalizerCalled(), true, 'Expected External basic finalizer to be called [before ticking]');
-      } else {
-        assert.strictEqual(binding.finalizer_order.isExternalBasicFinalizerCalled(), false, 'Expected External basic finalizer to not be called [before ticking]');
-      }
-    },
-    () => {
-      assert.strictEqual(binding.finalizer_order.isExternalBasicFinalizerCalled(), true, 'Expected External basic finalizer to be called [after ticking]');
-    },
-
-    'Finalizer Order - External with Finalizer',
-    () => {
-      let ext = binding.finalizer_order.createExternalFinalizer();
-      ext = null;
-      global.gc();
-      assert.strictEqual(binding.finalizer_order.isExternalFinalizerCalled(), false, 'Expected External extended finalizer to not be called [before ticking]');
-    },
-    () => {
-      assert.strictEqual(binding.finalizer_order.isExternalFinalizerCalled(), true, 'Expected External extended finalizer to be called [after ticking]');
-    }
-  ];
-
-  if (binding.isExperimental) {
-    tests.push(...[
-      'PostFinalizer',
-      () => {
-        binding.finalizer_order.PostFinalizer(common.mustCall());
-      },
-
-      'PostFinalizerWithData',
-      () => {
-        const data = {};
-        const callback = (callbackData) => {
-          assert.strictEqual(callbackData, data);
-        };
-        binding.finalizer_order.PostFinalizerWithData(common.mustCall(callback), data);
-      },
-
-      'PostFinalizerWithDataAndHint',
-      () => {
-        const data = {};
-        const hint = {};
-        const callback = (callbackData, callbackHint) => {
-          assert.strictEqual(callbackData, data);
-          assert.strictEqual(callbackHint, hint);
-        };
-        binding.finalizer_order.PostFinalizerWithDataAndHint(common.mustCall(callback), data, hint);
-      }
-    ]);
-  }
-
-  return testUtil.runGCTests(tests);
-}

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

@@ -1,338 +0,0 @@
-#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)});
-}
-
-Value NewTargetCallback(const CallbackInfo& info) {
-  return info.NewTarget();
-}
-
-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["newTargetCallback"] =
-      Function::New(env, NewTargetCallback, std::string("newTargetCallback"));
-  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["newTargetCallback"] =
-      Function::New<NewTargetCallback>(env, std::string("newTargetCallback"));
-  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

@@ -1,137 +0,0 @@
-'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' });
-
-  /* eslint-disable-next-line new-cap */
-  assert.strictEqual(new binding.newTargetCallback(), binding.newTargetCallback);
-  assert.strictEqual(binding.newTargetCallback(), undefined);
-
-  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());
-}