koffi 0.9.0 → 0.9.3

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

@@ -0,0 +1,59 @@
+'use strict';
+const assert = require('assert');
+
+/**
+ *
+ * ThreadSafeFunction Tests: Thread Id Sums
+ *
+ * Every native C++ function that utilizes the TSFN will call the registered
+ * callback with the thread id. Passing Array.prototype.push with a bound array
+ * will push the thread id to the array. Therefore, starting `N` threads, we
+ * will expect the sum of all elements in the array to be `(N-1) * (N) / 2` (as
+ * thread IDs are 0-based)
+ *
+ * We check different methods of passing a ThreadSafeFunction around multiple
+ * threads:
+ *  - `testWithTSFN`: The main thread creates the TSFN. Then, it creates
+ *    threads, passing the TSFN at thread construction. The number of threads is
+ *    static (known at TSFN creation).
+ *  - `testDelayedTSFN`: The main thread creates threads, passing a promise to a
+ *    TSFN at construction. Then, it creates the TSFN, and resolves each
+ *    threads' promise. The number of threads is static.
+ *  - `testAcquire`: The native binding returns a function to start a new. A
+ *    call to this function will return `false` once `N` calls have been made.
+ *    Each thread will acquire its own use of the TSFN, call it, and then
+ *    release.
+ */
+
+const THREAD_COUNT = 5;
+const EXPECTED_SUM = (THREAD_COUNT - 1) * (THREAD_COUNT) / 2;
+
+module.exports = require('../common').runTest(test);
+
+/** @param {number[]} N */
+const sum = (N) => N.reduce((sum, n) => sum + n, 0);
+
+function test(binding) {
+  async function check(bindingFunction) {
+    const calls = [];
+    const result = await bindingFunction(THREAD_COUNT, Array.prototype.push.bind(calls));
+    assert.ok(result);
+    assert.equal(sum(calls), EXPECTED_SUM);
+  }
+
+  async function checkAcquire() {
+    const calls = [];
+    const { promise, createThread, stopThreads } = binding.threadsafe_function_sum.testAcquire(Array.prototype.push.bind(calls));
+    for (let i = 0; i < THREAD_COUNT; i++) {
+      createThread();
+    }
+    stopThreads();
+    const result = await promise;
+    assert.ok(result);
+    assert.equal(sum(calls), EXPECTED_SUM);
+  }
+
+  return check(binding.threadsafe_function_sum.testDelayedTSFN)
+    .then(() => check(binding.threadsafe_function_sum.testWithTSFN))
+    .then(() => checkAcquire());
+}

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

@@ -0,0 +1,42 @@
+#include "napi.h"
+#include "test_helper.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+namespace {
+
+static Value TestUnref(const CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Object global = env.Global();
+  Object resource = info[0].As<Object>();
+  Function cb = info[1].As<Function>();
+  Function setTimeout = MaybeUnwrap(global.Get("setTimeout")).As<Function>();
+  ThreadSafeFunction* tsfn = new ThreadSafeFunction;
+
+  *tsfn = ThreadSafeFunction::New(info.Env(), cb, resource, "Test", 1, 1, [tsfn](Napi::Env /* env */) {
+    delete tsfn;
+  });
+
+  tsfn->BlockingCall();
+
+  setTimeout.Call( global, {
+    Function::New(env, [tsfn](const CallbackInfo& info) {
+      tsfn->Unref(info.Env());
+    }),
+    Number::New(env, 100)
+  });
+
+  return info.Env().Undefined();
+}
+
+}
+
+Object InitThreadSafeFunctionUnref(Env env) {
+  Object exports = Object::New(env);
+  exports["testUnref"] = Function::New(env, TestUnref);
+  return exports;
+}
+
+#endif

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

@@ -0,0 +1,53 @@
+'use strict';
+
+const assert = require('assert');
+
+const isMainProcess = process.argv[1] != __filename;
+
+/**
+ * In order to test that the event loop exits even with an active TSFN, we need
+ * to spawn a new process for the test.
+ *   - Main process: spawns new node instance, executing this script
+ *   - Child process: creates TSFN. Native module Unref's via setTimeout after some time but does NOT call Release.
+ *
+ * Main process should expect child process to exit.
+ */
+
+if (isMainProcess) {
+  module.exports = require('../common').runTestWithBindingPath(test);
+} else {
+  test(process.argv[2]);
+}
+
+function test(bindingFile) {
+  if (isMainProcess) {
+    // Main process
+    return new Promise((resolve, reject) => {
+      const child = require('../napi_child').spawn(process.argv[0], [
+        '--expose-gc', __filename, bindingFile
+      ], { stdio: 'inherit' });
+
+      let timeout = setTimeout( function() {
+        child.kill();
+        timeout = 0;
+        reject(new Error("Expected child to die"));
+      }, 5000);
+
+      child.on("error", (err) => {
+        clearTimeout(timeout);
+        timeout = 0;
+        reject(new Error(err));
+      })
+
+      child.on("close", (code) => {
+        if (timeout) clearTimeout(timeout);
+        assert.strictEqual(code, 0, "Expected return value 0");
+        resolve();
+      });
+    });
+  } else {
+    // Child process
+    const binding = require(bindingFile);
+    binding.threadsafe_function_unref.testUnref({}, () => { });
+  }
+}

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

@@ -0,0 +1,140 @@
+#include <napi.h>
+
+// The formulaic comment below should accompany any code that results in an
+// internal piece of heap data getting created, because each such piece of heap
+// data must be attached to an object by way of a deleter which gets called when
+// the object gets garbage-collected.
+//
+// At the very least, you can add a fprintf(stderr, ...) to the deleter in
+// napi-inl.h and then count the number of times the deleter prints by running
+// node --expose-gc test/thunking_manual.js and counting the number of prints
+// between the two rows of dashes. That number should coincide with the number
+// of formulaic comments below.
+//
+// Note that currently this result can only be achieved with node-chakracore,
+// because V8 does not garbage-collect classes.
+
+static Napi::Value TestMethod(const Napi::CallbackInfo& /*info*/) {
+  return Napi::Value();
+}
+
+static Napi::Value TestGetter(const Napi::CallbackInfo& /*info*/) {
+  return Napi::Value();
+}
+
+static void TestSetter(const Napi::CallbackInfo& /*info*/) {
+}
+
+class TestClass : public Napi::ObjectWrap<TestClass> {
+ public:
+  TestClass(const Napi::CallbackInfo& info):
+      ObjectWrap<TestClass>(info) {
+  }
+  static Napi::Value TestClassStaticMethod(const Napi::CallbackInfo& info) {
+    return Napi::Number::New(info.Env(), 42);
+  }
+
+  static void TestClassStaticVoidMethod(const Napi::CallbackInfo& /*info*/) {
+  }
+
+  Napi::Value TestClassInstanceMethod(const Napi::CallbackInfo& info) {
+    return Napi::Number::New(info.Env(), 42);
+  }
+
+  void TestClassInstanceVoidMethod(const Napi::CallbackInfo& /*info*/) {
+  }
+
+  Napi::Value TestClassInstanceGetter(const Napi::CallbackInfo& info) {
+    return Napi::Number::New(info.Env(), 42);
+  }
+
+  void TestClassInstanceSetter(const Napi::CallbackInfo& /*info*/,
+                               const Napi::Value& /*new_value*/) {
+  }
+
+  static Napi::Function NewClass(Napi::Env env) {
+    return DefineClass(env, "TestClass", {
+      // Make sure to check that the deleter gets called.
+      StaticMethod("staticMethod", TestClassStaticMethod),
+      // Make sure to check that the deleter gets called.
+      StaticMethod("staticVoidMethod", TestClassStaticVoidMethod),
+      // Make sure to check that the deleter gets called.
+      StaticMethod(Napi::Symbol::New(env, "staticMethod"),
+                   TestClassStaticMethod),
+      // Make sure to check that the deleter gets called.
+      StaticMethod(Napi::Symbol::New(env, "staticVoidMethod"),
+                   TestClassStaticVoidMethod),
+      // Make sure to check that the deleter gets called.
+      InstanceMethod("instanceMethod", &TestClass::TestClassInstanceMethod),
+      // Make sure to check that the deleter gets called.
+      InstanceMethod("instanceVoidMethod",
+                     &TestClass::TestClassInstanceVoidMethod),
+      // Make sure to check that the deleter gets called.
+      InstanceMethod(Napi::Symbol::New(env, "instanceMethod"),
+                     &TestClass::TestClassInstanceMethod),
+      // Make sure to check that the deleter gets called.
+      InstanceMethod(Napi::Symbol::New(env, "instanceVoidMethod"),
+                     &TestClass::TestClassInstanceVoidMethod),
+      // Make sure to check that the deleter gets called.
+      InstanceAccessor("instanceAccessor",
+                       &TestClass::TestClassInstanceGetter,
+                       &TestClass::TestClassInstanceSetter)
+    });
+  }
+};
+
+static Napi::Value CreateTestObject(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Napi::Object item = Napi::Object::New(env);
+
+  // Make sure to check that the deleter gets called.
+  item["testMethod"] = Napi::Function::New(env, TestMethod, "testMethod");
+
+  item.DefineProperties({
+    // Make sure to check that the deleter gets called.
+    Napi::PropertyDescriptor::Accessor(env,
+                                       item,
+                                       "accessor_1",
+                                       TestGetter),
+    // Make sure to check that the deleter gets called.
+    Napi::PropertyDescriptor::Accessor(env,
+                                       item,
+                                       std::string("accessor_1_std_string"),
+                                       TestGetter),
+    // Make sure to check that the deleter gets called.
+    Napi::PropertyDescriptor::Accessor(env,
+                                       item,
+                                       Napi::String::New(info.Env(),
+                                                        "accessor_1_js_string"),
+                                       TestGetter),
+    // Make sure to check that the deleter gets called.
+    Napi::PropertyDescriptor::Accessor(env,
+                                       item,
+                                       "accessor_2",
+                                       TestGetter,
+                                       TestSetter),
+    // Make sure to check that the deleter gets called.
+    Napi::PropertyDescriptor::Accessor(env,
+                                       item,
+                                       std::string("accessor_2_std_string"),
+                                       TestGetter,
+                                       TestSetter),
+    // Make sure to check that the deleter gets called.
+    Napi::PropertyDescriptor::Accessor(env,
+                                       item,
+                                       Napi::String::New(env,
+                                                        "accessor_2_js_string"),
+                                       TestGetter,
+                                       TestSetter),
+    Napi::PropertyDescriptor::Value("TestClass", TestClass::NewClass(env)),
+  });
+
+  return item;
+}
+
+Napi::Object InitThunkingManual(Napi::Env env) {
+  Napi::Object exports = Napi::Object::New(env);
+  exports["createTestObject"] =
+      Napi::Function::New(env, CreateTestObject, "createTestObject");
+  return exports;
+}

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

@@ -0,0 +1,17 @@
+// Flags: --expose-gc
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  console.log("Thunking: Performing initial GC");
+  global.gc();
+  console.log("Thunking: Creating test object");
+  let object = binding.thunking_manual.createTestObject();
+  object = null;
+  console.log("Thunking: About to GC\n--------");
+  global.gc();
+  console.log("--------\nThunking: GC complete");
+}

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

@@ -0,0 +1,215 @@
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+#include "napi.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+constexpr size_t ARRAY_LENGTH = 10;
+constexpr size_t MAX_QUEUE_SIZE = 2;
+
+static std::thread threads[2];
+
+static struct ThreadSafeFunctionInfo {
+  enum CallType { DEFAULT, BLOCKING, NON_BLOCKING } type;
+  bool abort;
+  bool startSecondary;
+  FunctionReference jsFinalizeCallback;
+  uint32_t maxQueueSize;
+  bool closeCalledFromJs;
+  std::mutex protect;
+  std::condition_variable signal;
+} tsfnInfo;
+
+static void TSFNCallJS(Env env,
+                       Function jsCallback,
+                       ThreadSafeFunctionInfo* /* context */,
+                       int* data) {
+  // A null environment signifies the threadsafe function has been finalized.
+  if (!(env == nullptr || jsCallback == nullptr)) {
+    // If called with no data
+    if (data == nullptr) {
+      jsCallback.Call({});
+    } else {
+      jsCallback.Call({Number::New(env, *data)});
+    }
+  }
+}
+
+using TSFN = TypedThreadSafeFunction<ThreadSafeFunctionInfo, int, TSFNCallJS>;
+static TSFN tsfn;
+
+// Thread data to transmit to JS
+static int ints[ARRAY_LENGTH];
+
+static void SecondaryThread() {
+  if (tsfn.Release() != napi_ok) {
+    Error::Fatal("TypedSecondaryThread", "ThreadSafeFunction.Release() failed");
+  }
+}
+
+// Source thread producing the data
+static void DataSourceThread() {
+  ThreadSafeFunctionInfo* info = tsfn.GetContext();
+
+  if (info->startSecondary) {
+    if (tsfn.Acquire() != napi_ok) {
+      Error::Fatal("TypedDataSourceThread",
+                   "ThreadSafeFunction.Acquire() failed");
+    }
+
+    threads[1] = std::thread(SecondaryThread);
+  }
+
+  bool queueWasFull = false;
+  bool queueWasClosing = false;
+  for (int index = ARRAY_LENGTH - 1; index > -1 && !queueWasClosing; index--) {
+    napi_status status = napi_generic_failure;
+
+    switch (info->type) {
+      case ThreadSafeFunctionInfo::DEFAULT:
+        status = tsfn.BlockingCall();
+        break;
+      case ThreadSafeFunctionInfo::BLOCKING:
+        status = tsfn.BlockingCall(&ints[index]);
+        break;
+      case ThreadSafeFunctionInfo::NON_BLOCKING:
+        status = tsfn.NonBlockingCall(&ints[index]);
+        break;
+    }
+
+    if (info->abort && info->type != ThreadSafeFunctionInfo::NON_BLOCKING) {
+      // Let's make this thread really busy to give the main thread a chance to
+      // abort / close.
+      std::unique_lock<std::mutex> lk(info->protect);
+      while (!info->closeCalledFromJs) {
+        info->signal.wait(lk);
+      }
+    }
+
+    switch (status) {
+      case napi_queue_full:
+        queueWasFull = true;
+        index++;
+        // fall through
+
+      case napi_ok:
+        continue;
+
+      case napi_closing:
+        queueWasClosing = true;
+        break;
+
+      default:
+        Error::Fatal("TypedDataSourceThread",
+                     "ThreadSafeFunction.*Call() failed");
+    }
+  }
+
+  if (info->type == ThreadSafeFunctionInfo::NON_BLOCKING && !queueWasFull) {
+    Error::Fatal("TypedDataSourceThread", "Queue was never full");
+  }
+
+  if (info->abort && !queueWasClosing) {
+    Error::Fatal("TypedDataSourceThread", "Queue was never closing");
+  }
+
+  if (!queueWasClosing && tsfn.Release() != napi_ok) {
+    Error::Fatal("TypedDataSourceThread",
+                 "ThreadSafeFunction.Release() failed");
+  }
+}
+
+static Value StopThread(const CallbackInfo& info) {
+  tsfnInfo.jsFinalizeCallback = Napi::Persistent(info[0].As<Function>());
+  bool abort = info[1].As<Boolean>();
+  if (abort) {
+    tsfn.Abort();
+  } else {
+    tsfn.Release();
+  }
+  {
+    std::lock_guard<std::mutex> _(tsfnInfo.protect);
+    tsfnInfo.closeCalledFromJs = true;
+    tsfnInfo.signal.notify_one();
+  }
+  return Value();
+}
+
+// Join the thread and inform JS that we're done.
+static void JoinTheThreads(Env /* env */,
+                           std::thread* theThreads,
+                           ThreadSafeFunctionInfo* info) {
+  theThreads[0].join();
+  if (info->startSecondary) {
+    theThreads[1].join();
+  }
+
+  info->jsFinalizeCallback.Call({});
+  info->jsFinalizeCallback.Reset();
+}
+
+static Value StartThreadInternal(const CallbackInfo& info,
+                                 ThreadSafeFunctionInfo::CallType type) {
+  tsfnInfo.type = type;
+  tsfnInfo.abort = info[1].As<Boolean>();
+  tsfnInfo.startSecondary = info[2].As<Boolean>();
+  tsfnInfo.maxQueueSize = info[3].As<Number>().Uint32Value();
+  tsfnInfo.closeCalledFromJs = false;
+
+  tsfn = TSFN::New(info.Env(),
+                   info[0].As<Function>(),
+                   Object::New(info.Env()),
+                   "Test",
+                   tsfnInfo.maxQueueSize,
+                   2,
+                   &tsfnInfo,
+                   JoinTheThreads,
+                   threads);
+
+  threads[0] = std::thread(DataSourceThread);
+
+  return Value();
+}
+
+static Value Release(const CallbackInfo& /* info */) {
+  if (tsfn.Release() != napi_ok) {
+    Error::Fatal("Release", "TypedThreadSafeFunction.Release() failed");
+  }
+  return Value();
+}
+
+static Value StartThread(const CallbackInfo& info) {
+  return StartThreadInternal(info, ThreadSafeFunctionInfo::BLOCKING);
+}
+
+static Value StartThreadNonblocking(const CallbackInfo& info) {
+  return StartThreadInternal(info, ThreadSafeFunctionInfo::NON_BLOCKING);
+}
+
+static Value StartThreadNoNative(const CallbackInfo& info) {
+  return StartThreadInternal(info, ThreadSafeFunctionInfo::DEFAULT);
+}
+
+Object InitTypedThreadSafeFunction(Env env) {
+  for (size_t index = 0; index < ARRAY_LENGTH; index++) {
+    ints[index] = index;
+  }
+
+  Object exports = Object::New(env);
+  exports["ARRAY_LENGTH"] = Number::New(env, ARRAY_LENGTH);
+  exports["MAX_QUEUE_SIZE"] = Number::New(env, MAX_QUEUE_SIZE);
+  exports["startThread"] = Function::New(env, StartThread);
+  exports["startThreadNoNative"] = Function::New(env, StartThreadNoNative);
+  exports["startThreadNonblocking"] =
+      Function::New(env, StartThreadNonblocking);
+  exports["stopThread"] = Function::New(env, StopThread);
+  exports["release"] = Function::New(env, Release);
+
+  return exports;
+}
+
+#endif