koffi 2.16.0-beta.2 → 2.16.0

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

@@ -1,155 +0,0 @@
-#include <assert.h>
-#include "napi.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-namespace {
-
-class TSFNWrap : public ObjectWrap<TSFNWrap> {
- public:
-  static Function Init(Napi::Env env);
-  TSFNWrap(const CallbackInfo& info);
-
-  Napi::Value GetContext(const CallbackInfo& /*info*/) {
-    Reference<Napi::Value>* ctx = _tsfn.GetContext();
-    return ctx->Value();
-  };
-
-  Napi::Value Release(const CallbackInfo& info) {
-    Napi::Env env = info.Env();
-    _deferred = std::unique_ptr<Promise::Deferred>(new Promise::Deferred(env));
-    _tsfn.Release();
-    return _deferred->Promise();
-  };
-
- private:
-  ThreadSafeFunction _tsfn;
-  std::unique_ptr<Promise::Deferred> _deferred;
-};
-
-Function TSFNWrap::Init(Napi::Env env) {
-  Function func =
-      DefineClass(env,
-                  "TSFNWrap",
-                  {InstanceMethod("getContext", &TSFNWrap::GetContext),
-                   InstanceMethod("release", &TSFNWrap::Release)});
-  return func;
-}
-
-TSFNWrap::TSFNWrap(const CallbackInfo& info) : ObjectWrap<TSFNWrap>(info) {
-  Napi::Env env = info.Env();
-
-  Reference<Napi::Value>* _ctx = new Reference<Napi::Value>;
-  *_ctx = Persistent(info[0]);
-
-  _tsfn = ThreadSafeFunction::New(
-      info.Env(),
-      Function::New(env, [](const CallbackInfo& /*info*/) {}),
-      Object::New(env),
-      "Test",
-      1,
-      1,
-      _ctx,
-      [this](Napi::Env env, Reference<Napi::Value>* ctx) {
-        _deferred->Resolve(env.Undefined());
-        ctx->Reset();
-        delete ctx;
-      });
-}
-struct SimpleTestContext {
-  SimpleTestContext(int val) : _val(val) {}
-  int _val = -1;
-};
-
-void AssertGetContextFromVariousTSOverloads(const CallbackInfo& info) {
-  Env env = info.Env();
-  Function emptyFunc;
-
-  SimpleTestContext* ctx = new SimpleTestContext(42);
-  ThreadSafeFunction fn =
-      ThreadSafeFunction::New(env, emptyFunc, "testResource", 1, 1, ctx);
-
-  assert(fn.GetContext() == ctx);
-  delete ctx;
-  fn.Release();
-
-  fn = ThreadSafeFunction::New(env, emptyFunc, "testRes", 1, 1, [](Env) {});
-  fn.Release();
-
-  ctx = new SimpleTestContext(42);
-  fn = ThreadSafeFunction::New(env,
-                               emptyFunc,
-                               Object::New(env),
-                               "resStrObj",
-                               1,
-                               1,
-                               ctx,
-                               [](Env, SimpleTestContext*) {});
-  assert(fn.GetContext() == ctx);
-  delete ctx;
-  fn.Release();
-
-  fn = ThreadSafeFunction::New(
-      env, emptyFunc, Object::New(env), "resStrObj", 1, 1);
-  fn.Release();
-
-  ctx = new SimpleTestContext(42);
-  fn = ThreadSafeFunction::New(
-      env, emptyFunc, Object::New(env), "resStrObj", 1, 1, ctx);
-  assert(fn.GetContext() == ctx);
-  delete ctx;
-  fn.Release();
-
-  using FinalizerDataType = int;
-  FinalizerDataType* finalizerData = new int(42);
-  fn = ThreadSafeFunction::New(
-      env,
-      emptyFunc,
-      Object::New(env),
-      "resObject",
-      1,
-      1,
-      [](Env, FinalizerDataType* data) {
-        assert(*data == 42);
-        delete data;
-      },
-      finalizerData);
-  fn.Release();
-
-  ctx = new SimpleTestContext(42);
-  FinalizerDataType* finalizerDataB = new int(42);
-
-  fn = ThreadSafeFunction::New(
-      env,
-      emptyFunc,
-      Object::New(env),
-      "resObject",
-      1,
-      1,
-      ctx,
-      [](Env, FinalizerDataType* _data, SimpleTestContext* _ctx) {
-        assert(*_data == 42);
-        assert(_ctx->_val == 42);
-        delete _data;
-        delete _ctx;
-      },
-      finalizerDataB);
-  assert(fn.GetContext() == ctx);
-  fn.Release();
-}
-
-}  // namespace
-
-Object InitThreadSafeFunctionCtx(Env env) {
-  Object exports = Object::New(env);
-  Function tsfnWrap = TSFNWrap::Init(env);
-  exports.Set("TSFNWrap", tsfnWrap);
-  exports.Set("AssertFnReturnCorrectCxt",
-              Function::New(env, AssertGetContextFromVariousTSOverloads));
-
-  return exports;
-}
-
-#endif

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

@@ -1,13 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-async function test (binding) {
-  const ctx = { };
-  const tsfn = new binding.threadsafe_function_ctx.TSFNWrap(ctx);
-  assert(tsfn.getContext() === ctx);
-  await tsfn.release();
-  binding.threadsafe_function_ctx.AssertFnReturnCorrectCxt();
-}

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

@@ -1,50 +0,0 @@
-#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

@@ -1,20 +0,0 @@
-'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/threadsafe_function/threadsafe_function_existing_tsfn.cc

@@ -1,125 +0,0 @@
-#include <cstdlib>
-#include "napi.h"
-#include "test_helper.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-namespace {
-
-struct TestContext {
-  TestContext(Promise::Deferred&& deferred)
-      : deferred(std::move(deferred)), callData(nullptr){};
-
-  napi_threadsafe_function tsfn;
-  Promise::Deferred deferred;
-  double* callData;
-
-  ~TestContext() {
-    if (callData != nullptr) delete callData;
-  };
-};
-
-void FinalizeCB(napi_env env, void* /*finalizeData */, void* context) {
-  TestContext* testContext = static_cast<TestContext*>(context);
-  if (testContext->callData != nullptr) {
-    testContext->deferred.Resolve(Number::New(env, *testContext->callData));
-  } else {
-    testContext->deferred.Resolve(Napi::Env(env).Undefined());
-  }
-  delete testContext;
-}
-
-void CallJSWithData(napi_env env,
-                    napi_value /* callback */,
-                    void* context,
-                    void* data) {
-  TestContext* testContext = static_cast<TestContext*>(context);
-  testContext->callData = static_cast<double*>(data);
-
-  napi_status status =
-      napi_release_threadsafe_function(testContext->tsfn, napi_tsfn_release);
-
-  NAPI_THROW_IF_FAILED_VOID(env, status);
-}
-
-void CallJSNoData(napi_env env,
-                  napi_value /* callback */,
-                  void* context,
-                  void* /*data*/) {
-  TestContext* testContext = static_cast<TestContext*>(context);
-  testContext->callData = nullptr;
-
-  napi_status status =
-      napi_release_threadsafe_function(testContext->tsfn, napi_tsfn_release);
-
-  NAPI_THROW_IF_FAILED_VOID(env, status);
-}
-
-static Value TestCall(const CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  bool isBlocking = false;
-  bool hasData = false;
-  if (info.Length() > 0) {
-    Object opts = info[0].As<Object>();
-    bool hasProperty = MaybeUnwrap(opts.Has("blocking"));
-    if (hasProperty) {
-      isBlocking = MaybeUnwrap(MaybeUnwrap(opts.Get("blocking")).ToBoolean());
-    }
-    hasProperty = MaybeUnwrap(opts.Has("data"));
-    if (hasProperty) {
-      hasData = MaybeUnwrap(MaybeUnwrap(opts.Get("data")).ToBoolean());
-    }
-  }
-
-  // Allow optional callback passed from JS. Useful for testing.
-  Function cb = Function::New(env, [](const CallbackInfo& /*info*/) {});
-
-  TestContext* testContext = new TestContext(Napi::Promise::Deferred(env));
-
-  napi_status status =
-      napi_create_threadsafe_function(env,
-                                      cb,
-                                      Object::New(env),
-                                      String::New(env, "Test"),
-                                      0,
-                                      1,
-                                      nullptr, /*finalize data*/
-                                      FinalizeCB,
-                                      testContext,
-                                      hasData ? CallJSWithData : CallJSNoData,
-                                      &testContext->tsfn);
-
-  NAPI_THROW_IF_FAILED(env, status, Value());
-
-  ThreadSafeFunction wrapped = ThreadSafeFunction(testContext->tsfn);
-
-  // Test the four napi_threadsafe_function direct-accessing calls
-  if (isBlocking) {
-    if (hasData) {
-      wrapped.BlockingCall(static_cast<void*>(new double(std::rand())));
-    } else {
-      wrapped.BlockingCall(static_cast<void*>(nullptr));
-    }
-  } else {
-    if (hasData) {
-      wrapped.NonBlockingCall(static_cast<void*>(new double(std::rand())));
-    } else {
-      wrapped.NonBlockingCall(static_cast<void*>(nullptr));
-    }
-  }
-
-  return testContext->deferred.Promise();
-}
-
-}  // namespace
-
-Object InitThreadSafeFunctionExistingTsfn(Env env) {
-  Object exports = Object::New(env);
-  exports["testCall"] = Function::New(env, TestCall);
-
-  return exports;
-}
-
-#endif

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

@@ -1,14 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-async function test (binding) {
-  const testCall = binding.threadsafe_function_existing_tsfn.testCall;
-
-  assert.strictEqual(typeof await testCall({ blocking: true, data: true }), 'number');
-  assert.strictEqual(typeof await testCall({ blocking: true, data: false }), 'undefined');
-  assert.strictEqual(typeof await testCall({ blocking: false, data: true }), 'number');
-  assert.strictEqual(typeof await testCall({ blocking: false, data: false }), 'undefined');
-}

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

@@ -1,27 +0,0 @@
-#include "napi.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-namespace {
-
-static Value Test(const CallbackInfo& info) {
-  Object resource = info[0].As<Object>();
-  Function cb = info[1].As<Function>();
-  ThreadSafeFunction tsfn =
-      ThreadSafeFunction::New(info.Env(), cb, resource, "Test", 1, 1);
-  tsfn.Release();
-  return info.Env().Undefined();
-}
-
-}  // namespace
-
-Object InitThreadSafeFunctionPtr(Env env) {
-  Object exports = Object::New(env);
-  exports["test"] = Function::New(env, Test);
-
-  return exports;
-}
-
-#endif

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

@@ -1,7 +0,0 @@
-'use strict';
-
-module.exports = require('../common').runTest(test);
-
-function test (binding) {
-  binding.threadsafe_function_ptr.test({}, () => {});
-}

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

@@ -1,240 +0,0 @@
-#include <condition_variable>
-#include <cstdlib>
-#include <mutex>
-#include <thread>
-#include "napi.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-namespace {
-
-struct TestData {
-  TestData(Promise::Deferred&& deferred) : deferred(std::move(deferred)){};
-
-  // Native Promise returned to JavaScript
-  Promise::Deferred deferred;
-
-  // List of threads created for test. This list only ever accessed via main
-  // thread.
-  std::vector<std::thread> threads = {};
-
-  ThreadSafeFunction tsfn = ThreadSafeFunction();
-
-  // These variables are only accessed from the main thread.
-  bool mainWantsRelease = false;
-  size_t expected_calls = 0;
-};
-
-void FinalizerCallback(Napi::Env env, TestData* finalizeData) {
-  for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
-    finalizeData->threads[i].join();
-  }
-  finalizeData->deferred.Resolve(Boolean::New(env, true));
-  delete finalizeData;
-}
-
-/**
- * See threadsafe_function_sum.js for descriptions of the tests in this file
- */
-
-void entryWithTSFN(ThreadSafeFunction tsfn, int threadId) {
-  std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 100 + 1));
-  tsfn.BlockingCall([=](Napi::Env env, Function callback) {
-    callback.Call({Number::New(env, static_cast<double>(threadId))});
-  });
-  tsfn.Release();
-}
-
-static Value TestWithTSFN(const CallbackInfo& info) {
-  int threadCount = info[0].As<Number>().Int32Value();
-  Function cb = info[1].As<Function>();
-
-  // We pass the test data to the Finalizer for cleanup. The finalizer is
-  // responsible for deleting this data as well.
-  TestData* testData = new TestData(Promise::Deferred::New(info.Env()));
-
-  ThreadSafeFunction tsfn = ThreadSafeFunction::New(
-      info.Env(),
-      cb,
-      "Test",
-      0,
-      threadCount,
-      std::function<decltype(FinalizerCallback)>(FinalizerCallback),
-      testData);
-
-  for (int i = 0; i < threadCount; ++i) {
-    // A copy of the ThreadSafeFunction will go to the thread entry point
-    testData->threads.push_back(std::thread(entryWithTSFN, tsfn, i));
-  }
-
-  return testData->deferred.Promise();
-}
-
-// Task instance created for each new std::thread
-class DelayedTSFNTask {
- public:
-  // Each instance has its own tsfn
-  ThreadSafeFunction tsfn;
-
-  // Thread-safety
-  std::mutex mtx;
-  std::condition_variable cv;
-
-  // Entry point for std::thread
-  void entryDelayedTSFN(int threadId) {
-    std::unique_lock<std::mutex> lk(mtx);
-    cv.wait(lk, [this] { return this->tsfn != nullptr; });
-    tsfn.BlockingCall([=](Napi::Env env, Function callback) {
-      callback.Call({Number::New(env, static_cast<double>(threadId))});
-    });
-    tsfn.Release();
-  };
-};
-
-struct TestDataDelayed {
-  TestDataDelayed(Promise::Deferred&& deferred)
-      : deferred(std::move(deferred)){};
-  ~TestDataDelayed() { taskInsts.clear(); };
-  // Native Promise returned to JavaScript
-  Promise::Deferred deferred;
-
-  // List of threads created for test. This list only ever accessed via main
-  // thread.
-  std::vector<std::thread> threads = {};
-
-  // List of DelayedTSFNThread instances
-  std::vector<std::unique_ptr<DelayedTSFNTask>> taskInsts = {};
-
-  ThreadSafeFunction tsfn = ThreadSafeFunction();
-};
-
-void FinalizerCallbackDelayed(Napi::Env env, TestDataDelayed* finalizeData) {
-  for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
-    finalizeData->threads[i].join();
-  }
-  finalizeData->deferred.Resolve(Boolean::New(env, true));
-  delete finalizeData;
-}
-
-static Value TestDelayedTSFN(const CallbackInfo& info) {
-  int threadCount = info[0].As<Number>().Int32Value();
-  Function cb = info[1].As<Function>();
-
-  TestDataDelayed* testData =
-      new TestDataDelayed(Promise::Deferred::New(info.Env()));
-
-  testData->tsfn =
-      ThreadSafeFunction::New(info.Env(),
-                              cb,
-                              "Test",
-                              0,
-                              threadCount,
-                              std::function<decltype(FinalizerCallbackDelayed)>(
-                                  FinalizerCallbackDelayed),
-                              testData);
-
-  for (int i = 0; i < threadCount; ++i) {
-    testData->taskInsts.push_back(
-        std::unique_ptr<DelayedTSFNTask>(new DelayedTSFNTask()));
-    testData->threads.push_back(std::thread(&DelayedTSFNTask::entryDelayedTSFN,
-                                            testData->taskInsts.back().get(),
-                                            i));
-  }
-  std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 100 + 1));
-
-  for (auto& task : testData->taskInsts) {
-    std::lock_guard<std::mutex> lk(task->mtx);
-    task->tsfn = testData->tsfn;
-    task->cv.notify_all();
-  }
-
-  return testData->deferred.Promise();
-}
-
-void AcquireFinalizerCallback(Napi::Env env,
-                              TestData* finalizeData,
-                              TestData* context) {
-  (void)context;
-  for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
-    finalizeData->threads[i].join();
-  }
-  finalizeData->deferred.Resolve(Boolean::New(env, true));
-  delete finalizeData;
-}
-
-void entryAcquire(ThreadSafeFunction tsfn, int threadId) {
-  tsfn.Acquire();
-  TestData* testData = tsfn.GetContext();
-  std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 100 + 1));
-  tsfn.BlockingCall([=](Napi::Env env, Function callback) {
-    // This lambda runs on the main thread so it's OK to access the variables
-    // `expected_calls` and `mainWantsRelease`.
-    testData->expected_calls--;
-    if (testData->expected_calls == 0 && testData->mainWantsRelease)
-      testData->tsfn.Release();
-    callback.Call({Number::New(env, static_cast<double>(threadId))});
-  });
-  tsfn.Release();
-}
-
-static Value CreateThread(const CallbackInfo& info) {
-  TestData* testData = static_cast<TestData*>(info.Data());
-  // Counting expected calls like this only works because on the JS side this
-  // binding is called from a synchronous loop. This means the main loop has no
-  // chance to run the tsfn JS callback before we've counted how many threads
-  // the JS intends to create.
-  testData->expected_calls++;
-  ThreadSafeFunction tsfn = testData->tsfn;
-  int threadId = testData->threads.size();
-  // A copy of the ThreadSafeFunction will go to the thread entry point
-  testData->threads.push_back(std::thread(entryAcquire, tsfn, threadId));
-  return Number::New(info.Env(), threadId);
-}
-
-static Value StopThreads(const CallbackInfo& info) {
-  TestData* testData = static_cast<TestData*>(info.Data());
-  testData->mainWantsRelease = true;
-  return info.Env().Undefined();
-}
-
-static Value TestAcquire(const CallbackInfo& info) {
-  Function cb = info[0].As<Function>();
-  Napi::Env env = info.Env();
-
-  // We pass the test data to the Finalizer for cleanup. The finalizer is
-  // responsible for deleting this data as well.
-  TestData* testData = new TestData(Promise::Deferred::New(info.Env()));
-
-  testData->tsfn =
-      ThreadSafeFunction::New(env,
-                              cb,
-                              "Test",
-                              0,
-                              1,
-                              testData,
-                              std::function<decltype(AcquireFinalizerCallback)>(
-                                  AcquireFinalizerCallback),
-                              testData);
-
-  Object result = Object::New(env);
-  result["createThread"] =
-      Function::New(env, CreateThread, "createThread", testData);
-  result["stopThreads"] =
-      Function::New(env, StopThreads, "stopThreads", testData);
-  result["promise"] = testData->deferred.Promise();
-
-  return result;
-}
-}  // namespace
-
-Object InitThreadSafeFunctionSum(Env env) {
-  Object exports = Object::New(env);
-  exports["testDelayedTSFN"] = Function::New(env, TestDelayedTSFN);
-  exports["testWithTSFN"] = Function::New(env, TestWithTSFN);
-  exports["testAcquire"] = Function::New(env, TestAcquire);
-  return exports;
-}
-
-#endif