koffi 2.3.4 → 2.3.6-beta.1

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

@@ -1,9 +1,9 @@
 // Run each test function in sequence,
 // with an async delay and GC call between each.
 
-function tick(x) {
+function tick (x) {
   return new Promise((resolve) => {
-    setImmediate(function ontick() {
+    setImmediate(function ontick () {
       if (--x === 0) {
         resolve();
       } else {
@@ -11,9 +11,9 @@ function tick(x) {
       }
     });
   });
-};
+}
 
-async function runGCTests(tests) {
+async function runGCTests (tests) {
   // Break up test list into a list of lists of the form
   // [ [ 'test name', function() {}, ... ], ..., ].
   const testList = [];
@@ -27,7 +27,7 @@ async function runGCTests(tests) {
   }
 
   for (const test of testList) {
-    await (async function(test) {
+    await (async function (test) {
       let title;
       for (let i = 0; i < test.length; i++) {
         if (i === 0) {
@@ -50,5 +50,5 @@ async function runGCTests(tests) {
 }
 
 module.exports = {
-  runGCTests,
+  runGCTests
 };

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

@@ -12,13 +12,15 @@ constexpr size_t ARRAY_LENGTH = 10;
 constexpr size_t MAX_QUEUE_SIZE = 2;
 
 static std::thread threads[2];
-static ThreadSafeFunction tsfn;
+static ThreadSafeFunction s_tsfn;
 
 struct ThreadSafeFunctionInfo {
   enum CallType {
     DEFAULT,
     BLOCKING,
-    NON_BLOCKING
+    NON_BLOCKING,
+    NON_BLOCKING_DEFAULT,
+    NON_BLOCKING_SINGLE_ARG
   } type;
   bool abort;
   bool startSecondary;
@@ -33,44 +35,57 @@ struct ThreadSafeFunctionInfo {
 static int ints[ARRAY_LENGTH];
 
 static void SecondaryThread() {
-  if (tsfn.Release() != napi_ok) {
+  if (s_tsfn.Release() != napi_ok) {
     Error::Fatal("SecondaryThread", "ThreadSafeFunction.Release() failed");
   }
 }
 
 // Source thread producing the data
 static void DataSourceThread() {
-  ThreadSafeFunctionInfo* info = tsfn.GetContext();
+  ThreadSafeFunctionInfo* info = s_tsfn.GetContext();
 
   if (info->startSecondary) {
-    if (tsfn.Acquire() != napi_ok) {
+    if (s_tsfn.Acquire() != napi_ok) {
       Error::Fatal("DataSourceThread", "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;
+
     auto callback = [](Env env, Function jsCallback, int* data) {
-      jsCallback.Call({ Number::New(env, *data) });
+      jsCallback.Call({Number::New(env, *data)});
+    };
+
+    auto noArgCallback = [](Env env, Function jsCallback) {
+      jsCallback.Call({Number::New(env, 42)});
     };
 
     switch (info->type) {
       case ThreadSafeFunctionInfo::DEFAULT:
-        status = tsfn.BlockingCall();
+        status = s_tsfn.BlockingCall();
         break;
       case ThreadSafeFunctionInfo::BLOCKING:
-        status = tsfn.BlockingCall(&ints[index], callback);
+        status = s_tsfn.BlockingCall(&ints[index], callback);
         break;
       case ThreadSafeFunctionInfo::NON_BLOCKING:
-        status = tsfn.NonBlockingCall(&ints[index], callback);
+        status = s_tsfn.NonBlockingCall(&ints[index], callback);
+        break;
+      case ThreadSafeFunctionInfo::NON_BLOCKING_DEFAULT:
+        status = s_tsfn.NonBlockingCall();
+        break;
+
+      case ThreadSafeFunctionInfo::NON_BLOCKING_SINGLE_ARG:
+        status = s_tsfn.NonBlockingCall(noArgCallback);
         break;
     }
 
-    if (info->abort && info->type != ThreadSafeFunctionInfo::NON_BLOCKING) {
+    if (info->abort && (info->type == ThreadSafeFunctionInfo::BLOCKING ||
+                        info->type == ThreadSafeFunctionInfo::DEFAULT)) {
       // 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);
@@ -80,20 +95,20 @@ static void DataSourceThread() {
     }
 
     switch (status) {
-    case napi_queue_full:
-      queueWasFull = true;
-      index++;
-      // fall through
+      case napi_queue_full:
+        queueWasFull = true;
+        index++;
+        // fall through
 
-    case napi_ok:
-      continue;
+      case napi_ok:
+        continue;
 
-    case napi_closing:
-      queueWasClosing = true;
-      break;
+      case napi_closing:
+        queueWasClosing = true;
+        break;
 
-    default:
-      Error::Fatal("DataSourceThread", "ThreadSafeFunction.*Call() failed");
+      default:
+        Error::Fatal("DataSourceThread", "ThreadSafeFunction.*Call() failed");
     }
   }
 
@@ -105,7 +120,7 @@ static void DataSourceThread() {
     Error::Fatal("DataSourceThread", "Queue was never closing");
   }
 
-  if (!queueWasClosing && tsfn.Release() != napi_ok) {
+  if (!queueWasClosing && s_tsfn.Release() != napi_ok) {
     Error::Fatal("DataSourceThread", "ThreadSafeFunction.Release() failed");
   }
 }
@@ -114,9 +129,9 @@ static Value StopThread(const CallbackInfo& info) {
   tsfnInfo.jsFinalizeCallback = Napi::Persistent(info[0].As<Function>());
   bool abort = info[1].As<Boolean>();
   if (abort) {
-    tsfn.Abort();
+    s_tsfn.Abort();
   } else {
-    tsfn.Release();
+    s_tsfn.Release();
   }
   {
     std::lock_guard<std::mutex> _(tsfnInfo.protect);
@@ -140,15 +155,21 @@ static void JoinTheThreads(Env /* env */,
 }
 
 static Value StartThreadInternal(const CallbackInfo& info,
-    ThreadSafeFunctionInfo::CallType type) {
+                                 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 = ThreadSafeFunction::New(info.Env(), info[0].As<Function>(),
-      "Test", tsfnInfo.maxQueueSize, 2, &tsfnInfo, JoinTheThreads, threads);
+  s_tsfn = ThreadSafeFunction::New(info.Env(),
+                                   info[0].As<Function>(),
+                                   "Test",
+                                   tsfnInfo.maxQueueSize,
+                                   2,
+                                   &tsfnInfo,
+                                   JoinTheThreads,
+                                   threads);
 
   threads[0] = std::thread(DataSourceThread);
 
@@ -156,7 +177,7 @@ static Value StartThreadInternal(const CallbackInfo& info,
 }
 
 static Value Release(const CallbackInfo& /* info */) {
-  if (tsfn.Release() != napi_ok) {
+  if (s_tsfn.Release() != napi_ok) {
     Error::Fatal("Release", "ThreadSafeFunction.Release() failed");
   }
   return Value();
@@ -174,6 +195,16 @@ static Value StartThreadNoNative(const CallbackInfo& info) {
   return StartThreadInternal(info, ThreadSafeFunctionInfo::DEFAULT);
 }
 
+static Value StartThreadNonblockingNoNative(const CallbackInfo& info) {
+  return StartThreadInternal(info,
+                             ThreadSafeFunctionInfo::NON_BLOCKING_DEFAULT);
+}
+
+static Value StartThreadNonBlockingSingleArg(const CallbackInfo& info) {
+  return StartThreadInternal(info,
+                             ThreadSafeFunctionInfo::NON_BLOCKING_SINGLE_ARG);
+}
+
 Object InitThreadSafeFunction(Env env) {
   for (size_t index = 0; index < ARRAY_LENGTH; index++) {
     ints[index] = index;
@@ -184,8 +215,12 @@ Object InitThreadSafeFunction(Env env) {
   exports["MAX_QUEUE_SIZE"] = Number::New(env, MAX_QUEUE_SIZE);
   exports["startThread"] = Function::New(env, StartThread);
   exports["startThreadNoNative"] = Function::New(env, StartThreadNoNative);
+  exports["startThreadNonblockingNoNative"] =
+      Function::New(env, StartThreadNonblockingNoNative);
   exports["startThreadNonblocking"] =
       Function::New(env, StartThreadNonblocking);
+  exports["startThreadNonblockSingleArg"] =
+      Function::New(env, StartThreadNonBlockingSingleArg);
   exports["stopThread"] = Function::New(env, StopThread);
   exports["release"] = Function::New(env, Release);
 

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

@@ -5,8 +5,9 @@ const common = require('../common');
 
 module.exports = common.runTest(test);
 
-async function test(binding) {
-  const expectedArray = (function(arrayLength) {
+// Main test body
+async function test (binding) {
+  const expectedArray = (function (arrayLength) {
     const result = [];
     for (let index = 0; index < arrayLength; index++) {
       result.push(arrayLength - 1 - index);
@@ -14,15 +15,18 @@ async function test(binding) {
     return result;
   })(binding.threadsafe_function.ARRAY_LENGTH);
 
-  function testWithJSMarshaller({
+  const expectedDefaultArray = Array.from({ length: binding.threadsafe_function.ARRAY_LENGTH }, (_, i) => 42);
+
+  function testWithJSMarshaller ({
     threadStarter,
     quitAfter,
     abort,
     maxQueueSize,
-    launchSecondary }) {
+    launchSecondary
+  }) {
     return new Promise((resolve) => {
       const array = [];
-      binding.threadsafe_function[threadStarter](function testCallback(value) {
+      binding.threadsafe_function[threadStarter](function testCallback (value) {
         array.push(value);
         if (array.length === quitAfter) {
           binding.threadsafe_function.stopThread(common.mustCall(() => {
@@ -30,7 +34,7 @@ async function test(binding) {
           }), !!abort);
         }
       }, !!abort, !!launchSecondary, maxQueueSize);
-      if (threadStarter === 'startThreadNonblocking') {
+      if ((threadStarter === 'startThreadNonblocking' || threadStarter === 'startThreadNonblockSingleArg')) {
         // 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();
@@ -39,23 +43,28 @@ async function test(binding) {
     });
   }
 
-  await new Promise(function testWithoutJSMarshaller(resolve) {
-    let callCount = 0;
-    binding.threadsafe_function.startThreadNoNative(function testCallback() {
-      callCount++;
+  function testWithoutJSMarshallers (nativeFunction) {
+    return new Promise((resolve) => {
+      let callCount = 0;
+      nativeFunction(function testCallback () {
+        callCount++;
+
+        // The default call-into-JS implementation passes no arguments.
+        assert.strictEqual(arguments.length, 0);
+        if (callCount === binding.threadsafe_function.ARRAY_LENGTH) {
+          setImmediate(() => {
+            binding.threadsafe_function.stopThread(common.mustCall(() => {
+              resolve();
+            }), false);
+          });
+        }
+      }, false /* abort */, false /* launchSecondary */,
+      binding.threadsafe_function.MAX_QUEUE_SIZE);
+    });
+  }
 
-      // The default call-into-JS implementation passes no arguments.
-      assert.strictEqual(arguments.length, 0);
-      if (callCount === binding.threadsafe_function.ARRAY_LENGTH) {
-        setImmediate(() => {
-          binding.threadsafe_function.stopThread(common.mustCall(() => {
-            resolve();
-          }), false);
-        });
-      }
-    }, false /* abort */, false /* launchSecondary */,
-    binding.threadsafe_function.MAX_QUEUE_SIZE);
-  });
+  await testWithoutJSMarshallers(binding.threadsafe_function.startThreadNoNative);
+  await testWithoutJSMarshallers(binding.threadsafe_function.startThreadNonblockingNoNative);
 
   // Start the thread in blocking mode, and assert that all values are passed.
   // Quit after it's done.
@@ -65,7 +74,7 @@ async function test(binding) {
       maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
       quitAfter: binding.threadsafe_function.ARRAY_LENGTH
     }),
-    expectedArray,
+    expectedArray
   );
 
   // Start the thread in blocking mode with an infinite queue, and assert that
@@ -76,7 +85,7 @@ async function test(binding) {
       maxQueueSize: 0,
       quitAfter: binding.threadsafe_function.ARRAY_LENGTH
     }),
-    expectedArray,
+    expectedArray
   );
 
   // Start the thread in non-blocking mode, and assert that all values are
@@ -87,7 +96,7 @@ async function test(binding) {
       maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
       quitAfter: binding.threadsafe_function.ARRAY_LENGTH
     }),
-    expectedArray,
+    expectedArray
   );
 
   // Start the thread in blocking mode, and assert that all values are passed.
@@ -98,7 +107,7 @@ async function test(binding) {
       maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
       quitAfter: 1
     }),
-    expectedArray,
+    expectedArray
   );
 
   // Start the thread in blocking mode with an infinite queue, and assert that
@@ -109,10 +118,9 @@ async function test(binding) {
       maxQueueSize: 0,
       quitAfter: 1
     }),
-    expectedArray,
+    expectedArray
   );
 
-
   // Start the thread in non-blocking mode, and assert that all values are
   // passed. Quit early, but let the thread finish.
   assert.deepStrictEqual(
@@ -121,7 +129,16 @@ async function test(binding) {
       maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
       quitAfter: 1
     }),
-    expectedArray,
+    expectedArray
+  );
+
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblockSingleArg',
+      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: 1
+    }),
+    expectedDefaultArray
   );
 
   // Start the thread in blocking mode, and assert that all values are passed.
@@ -134,7 +151,7 @@ async function test(binding) {
       maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
       launchSecondary: true
     }),
-    expectedArray,
+    expectedArray
   );
 
   // Start the thread in non-blocking mode, and assert that all values are
@@ -147,7 +164,17 @@ async function test(binding) {
       maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
       launchSecondary: true
     }),
-    expectedArray,
+    expectedArray
+  );
+
+  assert.deepStrictEqual(
+    await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblockSingleArg',
+      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
+      quitAfter: 1,
+      launchSecondary: true
+    }),
+    expectedDefaultArray
   );
 
   // Start the thread in blocking mode, and assert that it could not finish.
@@ -159,7 +186,7 @@ async function test(binding) {
       maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
       abort: true
     })).indexOf(0),
-    -1,
+    -1
   );
 
   // Start the thread in blocking mode with an infinite queue, and assert that
@@ -171,7 +198,7 @@ async function test(binding) {
       maxQueueSize: 0,
       abort: true
     })).indexOf(0),
-    -1,
+    -1
   );
 
   // Start the thread in non-blocking mode, and assert that it could not finish.
@@ -183,6 +210,16 @@ async function test(binding) {
       maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
       abort: true
     })).indexOf(0),
-    -1,
+    -1
+  );
+
+  assert.strictEqual(
+    (await testWithJSMarshaller({
+      threadStarter: 'startThreadNonblockSingleArg',
+      quitAfter: 1,
+      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
+      abort: true
+    })).indexOf(0),
+    -1
   );
 }

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

@@ -1,3 +1,4 @@
+#include <assert.h>
 #include "napi.h"
 
 #if (NAPI_VERSION > 3)
@@ -7,57 +8,148 @@ using namespace Napi;
 namespace {
 
 class TSFNWrap : public ObjectWrap<TSFNWrap> {
-public:
-  static Object Init(Napi::Env env, Object exports);
-  TSFNWrap(const CallbackInfo &info);
+ public:
+  static Function Init(Napi::Env env);
+  TSFNWrap(const CallbackInfo& info);
 
-  Napi::Value GetContext(const CallbackInfo & /*info*/) {
-    Reference<Napi::Value> *ctx = _tsfn.GetContext();
+  Napi::Value GetContext(const CallbackInfo& /*info*/) {
+    Reference<Napi::Value>* ctx = _tsfn.GetContext();
     return ctx->Value();
   };
 
-  Napi::Value Release(const CallbackInfo &info) {
+  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:
+ private:
   ThreadSafeFunction _tsfn;
   std::unique_ptr<Promise::Deferred> _deferred;
 };
 
-Object TSFNWrap::Init(Napi::Env env, Object exports) {
+Function TSFNWrap::Init(Napi::Env env) {
   Function func =
-      DefineClass(env, "TSFNWrap",
+      DefineClass(env,
+                  "TSFNWrap",
                   {InstanceMethod("getContext", &TSFNWrap::GetContext),
                    InstanceMethod("release", &TSFNWrap::Release)});
-
-  exports.Set("TSFNWrap", func);
-  return exports;
+  return func;
 }
 
-TSFNWrap::TSFNWrap(const CallbackInfo &info) : ObjectWrap<TSFNWrap>(info) {
+TSFNWrap::TSFNWrap(const CallbackInfo& info) : ObjectWrap<TSFNWrap>(info) {
   Napi::Env env = info.Env();
 
-  Reference<Napi::Value> *_ctx = new Reference<Napi::Value>;
+  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) {
+      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
+}  // namespace
 
 Object InitThreadSafeFunctionCtx(Env env) {
-  return TSFNWrap::Init(env, Object::New(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

@@ -4,9 +4,10 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-async function test(binding) {
+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();
 }