koffi 0.9.1 → 0.9.2

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

@@ -0,0 +1,188 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('../common');
+
+module.exports = common.runTest(test);
+
+async function test(binding) {
+  const expectedArray = (function (arrayLength) {
+    const result = [];
+    for (let index = 0; index < arrayLength; index++) {
+      result.push(arrayLength - 1 - index);
+    }
+    return result;
+  })(binding.typed_threadsafe_function.ARRAY_LENGTH);
+
+  function testWithJSMarshaller({
+    threadStarter,
+    quitAfter,
+    abort,
+    maxQueueSize,
+    launchSecondary }) {
+    return new Promise((resolve) => {
+      const array = [];
+      binding.typed_threadsafe_function[threadStarter](function testCallback(value) {
+        array.push(value);
+        if (array.length === quitAfter) {
+          binding.typed_threadsafe_function.stopThread(common.mustCall(() => {
+            resolve(array);
+          }), !!abort);
+        }
+      }, !!abort, !!launchSecondary, maxQueueSize);
+      if (threadStarter === 'startThreadNonblocking') {
+        // Let's make this thread really busy for a short while to ensure that
+        // the queue fills and the thread receives a napi_queue_full.
+        const start = Date.now();
+        while (Date.now() - start < 200);
+      }
+    });
+  }
+
+  await new Promise(function testWithoutJSMarshaller(resolve) {
+    let callCount = 0;
+    binding.typed_threadsafe_function.startThreadNoNative(function testCallback() {
+      callCount++;
+
+      // The default call-into-JS implementation passes no arguments.
+      assert.strictEqual(arguments.length, 0);
+      if (callCount === binding.typed_threadsafe_function.ARRAY_LENGTH) {
+        setImmediate(() => {
+          binding.typed_threadsafe_function.stopThread(common.mustCall(() => {
+            resolve();
+          }), false);
+        });
+      }
+    }, false /* abort */, false /* launchSecondary */,
+      binding.typed_threadsafe_function.MAX_QUEUE_SIZE);
+  });
+
+  // Start the thread in blocking mode, and assert that all values are passed.
+  // Quit after it's done.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: binding.typed_threadsafe_function.ARRAY_LENGTH
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode with an infinite queue, and assert that
+  // all values are passed. Quit after it's done.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      maxQueueSize: 0,
+      quitAfter: binding.typed_threadsafe_function.ARRAY_LENGTH
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in non-blocking mode, and assert that all values are
+  // passed. Quit after it's done.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblocking',
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: binding.typed_threadsafe_function.ARRAY_LENGTH
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode, and assert that all values are passed.
+  // Quit early, but let the thread finish.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: 1
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode with an infinite queue, and assert that
+  // all values are passed. Quit early, but let the thread finish.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      maxQueueSize: 0,
+      quitAfter: 1
+    }),
+    expectedArray,
+  );
+
+
+  // Start the thread in non-blocking mode, and assert that all values are
+  // passed. Quit early, but let the thread finish.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblocking',
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: 1
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode, and assert that all values are passed.
+  // Quit early, but let the thread finish. Launch a secondary thread to test
+  // the reference counter incrementing functionality.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      quitAfter: 1,
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      launchSecondary: true
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in non-blocking mode, and assert that all values are
+  // passed. Quit early, but let the thread finish. Launch a secondary thread
+  // to test the reference counter incrementing functionality.
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblocking',
+      quitAfter: 1,
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      launchSecondary: true
+    }),
+    expectedArray,
+  );
+
+  // Start the thread in blocking mode, and assert that it could not finish.
+  // Quit early by aborting.
+  assert.strictEqual(
+    (await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      quitAfter: 1,
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      abort: true
+    })).indexOf(0),
+    -1,
+  );
+
+  // Start the thread in blocking mode with an infinite queue, and assert that
+  // it could not finish. Quit early by aborting.
+  assert.strictEqual(
+    (await testWithJSMarshaller({
+      threadStarter: 'startThread',
+      quitAfter: 1,
+      maxQueueSize: 0,
+      abort: true
+    })).indexOf(0),
+    -1,
+  );
+
+  // Start the thread in non-blocking mode, and assert that it could not finish.
+  // Quit early and aborting.
+  assert.strictEqual(
+    (await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblocking',
+      quitAfter: 1,
+      maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
+      abort: true
+    })).indexOf(0),
+    -1,
+  );
+}

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

@@ -0,0 +1,68 @@
+#include "napi.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+using ContextType = Reference<Napi::Value>;
+using TSFN = TypedThreadSafeFunction<ContextType>;
+
+namespace {
+
+class TSFNWrap : public ObjectWrap<TSFNWrap> {
+ public:
+  static Object Init(Napi::Env env, Object exports);
+  TSFNWrap(const CallbackInfo& info);
+
+  Napi::Value GetContext(const CallbackInfo& /*info*/) {
+    ContextType* 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:
+  TSFN _tsfn;
+  std::unique_ptr<Promise::Deferred> _deferred;
+};
+
+Object TSFNWrap::Init(Napi::Env env, Object exports) {
+  Function func =
+      DefineClass(env,
+                  "TSFNWrap",
+                  {InstanceMethod("getContext", &TSFNWrap::GetContext),
+                   InstanceMethod("release", &TSFNWrap::Release)});
+
+  exports.Set("TSFNWrap", func);
+  return exports;
+}
+
+TSFNWrap::TSFNWrap(const CallbackInfo& info) : ObjectWrap<TSFNWrap>(info) {
+  ContextType* _ctx = new ContextType;
+  *_ctx = Persistent(info[0]);
+
+  _tsfn = TSFN::New(info.Env(),
+                    this->Value(),
+                    "Test",
+                    1,
+                    1,
+                    _ctx,
+                    [this](Napi::Env env, void*, ContextType* ctx) {
+                      _deferred->Resolve(env.Undefined());
+                      ctx->Reset();
+                      delete ctx;
+                    });
+}
+
+}  // namespace
+
+Object InitTypedThreadSafeFunctionCtx(Env env) {
+  return TSFNWrap::Init(env, Object::New(env));
+}
+
+#endif

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

@@ -0,0 +1,12 @@
+'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();
+}

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

@@ -0,0 +1,127 @@
+#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;
+  };
+};
+
+using TSFN = TypedThreadSafeFunction<TestContext, double>;
+
+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());
+
+  TSFN wrapped = TSFN(testContext->tsfn);
+
+  // Test the four napi_threadsafe_function direct-accessing calls
+  if (isBlocking) {
+    if (hasData) {
+      wrapped.BlockingCall(new double(std::rand()));
+    } else {
+      wrapped.BlockingCall(nullptr);
+    }
+  } else {
+    if (hasData) {
+      wrapped.NonBlockingCall(new double(std::rand()));
+    } else {
+      wrapped.NonBlockingCall(nullptr);
+    }
+  }
+
+  return testContext->deferred.Promise();
+}
+
+}  // namespace
+
+Object InitTypedThreadSafeFunctionExistingTsfn(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_existing_tsfn.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+async function test(binding) {
+  const testCall = binding.typed_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/typed_threadsafe_function/typed_threadsafe_function_ptr.cc

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

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

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

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

@@ -0,0 +1,237 @@
+#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 = {};
+
+  // These variables are only accessed from the main thread.
+  bool mainWantsRelease = false;
+  size_t expected_calls = 0;
+
+  static void CallJs(Napi::Env env,
+                     Function callback,
+                     TestData* testData,
+                     double* data) {
+    // 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, *data)});
+    delete data;
+  }
+
+  TypedThreadSafeFunction<TestData, double, CallJs> tsfn;
+};
+
+using TSFN = TypedThreadSafeFunction<TestData, double, TestData::CallJs>;
+
+void FinalizerCallback(Napi::Env env, void*, 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(TSFN tsfn, int threadId) {
+  std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 100 + 1));
+  tsfn.BlockingCall(new 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()));
+
+  TSFN tsfn =
+      TSFN::New(info.Env(),
+                cb,
+                "Test",
+                0,
+                threadCount,
+                testData,
+                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
+  TSFN 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);
+    tsfn.BlockingCall(new double(threadId));
+    tsfn.Release();
+  };
+};
+
+struct TestDataDelayed : TestData {
+  TestDataDelayed(Promise::Deferred&& deferred)
+      : TestData(std::move(deferred)){};
+  ~TestDataDelayed() { taskInsts.clear(); };
+
+  // List of DelayedTSFNThread instances
+  std::vector<std::unique_ptr<DelayedTSFNTask>> taskInsts = {};
+};
+
+void FinalizerCallbackDelayed(Napi::Env env,
+                              TestDataDelayed* finalizeData,
+                              TestData*) {
+  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 = TSFN::New(info.Env(),
+                             cb,
+                             "Test",
+                             0,
+                             threadCount,
+                             testData,
+                             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(TSFN tsfn, int threadId) {
+  tsfn.Acquire();
+  std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 100 + 1));
+  tsfn.BlockingCall(new 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++;
+  TSFN 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 = TSFN::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 InitTypedThreadSafeFunctionSum(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