koffi 2.3.4 → 2.3.6-beta.1

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

@@ -9,21 +9,20 @@ using namespace Napi;
 namespace {
 
 struct TestContext {
-  TestContext(Promise::Deferred &&deferred)
+  TestContext(Promise::Deferred&& deferred)
       : deferred(std::move(deferred)), callData(nullptr){};
 
   napi_threadsafe_function tsfn;
   Promise::Deferred deferred;
-  double *callData;
+  double* callData;
 
   ~TestContext() {
-    if (callData != nullptr)
-      delete callData;
+    if (callData != nullptr) delete callData;
   };
 };
 
-void FinalizeCB(napi_env env, void * /*finalizeData */, void *context) {
-  TestContext *testContext = static_cast<TestContext *>(context);
+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 {
@@ -32,10 +31,12 @@ void FinalizeCB(napi_env env, void * /*finalizeData */, void *context) {
   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);
+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);
@@ -43,9 +44,11 @@ void CallJSWithData(napi_env env, napi_value /* callback */, void *context,
   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);
+void CallJSNoData(napi_env env,
+                  napi_value /* callback */,
+                  void* context,
+                  void* /*data*/) {
+  TestContext* testContext = static_cast<TestContext*>(context);
   testContext->callData = nullptr;
 
   napi_status status =
@@ -54,7 +57,7 @@ void CallJSNoData(napi_env env, napi_value /* callback */, void *context,
   NAPI_THROW_IF_FAILED_VOID(env, status);
 }
 
-static Value TestCall(const CallbackInfo &info) {
+static Value TestCall(const CallbackInfo& info) {
   Napi::Env env = info.Env();
   bool isBlocking = false;
   bool hasData = false;
@@ -71,15 +74,22 @@ static Value TestCall(const CallbackInfo &info) {
   }
 
   // Allow optional callback passed from JS. Useful for testing.
-  Function cb = Function::New(env, [](const CallbackInfo & /*info*/) {});
+  Function cb = Function::New(env, [](const CallbackInfo& /*info*/) {});
 
-  TestContext *testContext = new TestContext(Napi::Promise::Deferred(env));
+  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_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());
 
@@ -88,22 +98,22 @@ static Value TestCall(const CallbackInfo &info) {
   // Test the four napi_threadsafe_function direct-accessing calls
   if (isBlocking) {
     if (hasData) {
-      wrapped.BlockingCall(static_cast<void *>(new double(std::rand())));
+      wrapped.BlockingCall(static_cast<void*>(new double(std::rand())));
     } else {
-      wrapped.BlockingCall(static_cast<void *>(nullptr));
+      wrapped.BlockingCall(static_cast<void*>(nullptr));
     }
   } else {
     if (hasData) {
-      wrapped.NonBlockingCall(static_cast<void *>(new double(std::rand())));
+      wrapped.NonBlockingCall(static_cast<void*>(new double(std::rand())));
     } else {
-      wrapped.NonBlockingCall(static_cast<void *>(nullptr));
+      wrapped.NonBlockingCall(static_cast<void*>(nullptr));
     }
   }
 
   return testContext->deferred.Promise();
 }
 
-} // namespace
+}  // namespace
 
 Object InitThreadSafeFunctionExistingTsfn(Env env) {
   Object exports = Object::New(env);

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

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

@@ -9,12 +9,13 @@ 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);
+  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);

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

@@ -2,6 +2,6 @@
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
+function test (binding) {
   binding.threadsafe_function_ptr.test({}, () => {});
 }

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

@@ -1,8 +1,8 @@
-#include "napi.h"
-#include <thread>
-#include <cstdlib>
 #include <condition_variable>
+#include <cstdlib>
 #include <mutex>
+#include <thread>
+#include "napi.h"
 
 #if (NAPI_VERSION > 3)
 
@@ -11,9 +11,8 @@ using namespace Napi;
 namespace {
 
 struct TestData {
+  TestData(Promise::Deferred&& deferred) : deferred(std::move(deferred)){};
 
-  TestData(Promise::Deferred&& deferred) : deferred(std::move(deferred)) {};
-  
   // Native Promise returned to JavaScript
   Promise::Deferred deferred;
 
@@ -28,7 +27,7 @@ struct TestData {
   size_t expected_calls = 0;
 };
 
-void FinalizerCallback(Napi::Env env, TestData* finalizeData){
+void FinalizerCallback(Napi::Env env, TestData* finalizeData) {
   for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
     finalizeData->threads[i].join();
   }
@@ -42,8 +41,8 @@ void FinalizerCallback(Napi::Env env, TestData* finalizeData){
 
 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.BlockingCall([=](Napi::Env env, Function callback) {
+    callback.Call({Number::New(env, static_cast<double>(threadId))});
   });
   tsfn.Release();
 }
@@ -54,15 +53,20 @@ static Value TestWithTSFN(const CallbackInfo& info) {
 
   // 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* testData = new TestData(Promise::Deferred::New(info.Env()));
 
   ThreadSafeFunction tsfn = ThreadSafeFunction::New(
-      info.Env(), cb, "Test", 0, threadCount,
-      std::function<decltype(FinalizerCallback)>(FinalizerCallback), testData);
+      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) );
+    testData->threads.push_back(std::thread(entryWithTSFN, tsfn, i));
   }
 
   return testData->deferred.Promise();
@@ -70,7 +74,7 @@ static Value TestWithTSFN(const CallbackInfo& info) {
 
 // Task instance created for each new std::thread
 class DelayedTSFNTask {
-public:
+ public:
   // Each instance has its own tsfn
   ThreadSafeFunction tsfn;
 
@@ -90,8 +94,7 @@ public:
 };
 
 struct TestDataDelayed {
-
-  TestDataDelayed(Promise::Deferred &&deferred)
+  TestDataDelayed(Promise::Deferred&& deferred)
       : deferred(std::move(deferred)){};
   ~TestDataDelayed() { taskInsts.clear(); };
   // Native Promise returned to JavaScript
@@ -107,7 +110,7 @@ struct TestDataDelayed {
   ThreadSafeFunction tsfn = ThreadSafeFunction();
 };
 
-void FinalizerCallbackDelayed(Napi::Env env, TestDataDelayed *finalizeData) {
+void FinalizerCallbackDelayed(Napi::Env env, TestDataDelayed* finalizeData) {
   for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
     finalizeData->threads[i].join();
   }
@@ -115,15 +118,19 @@ void FinalizerCallbackDelayed(Napi::Env env, TestDataDelayed *finalizeData) {
   delete finalizeData;
 }
 
-static Value TestDelayedTSFN(const CallbackInfo &info) {
+static Value TestDelayedTSFN(const CallbackInfo& info) {
   int threadCount = info[0].As<Number>().Int32Value();
   Function cb = info[1].As<Function>();
 
-  TestDataDelayed *testData =
+  TestDataDelayed* testData =
       new TestDataDelayed(Promise::Deferred::New(info.Env()));
 
   testData->tsfn =
-      ThreadSafeFunction::New(info.Env(), cb, "Test", 0, threadCount,
+      ThreadSafeFunction::New(info.Env(),
+                              cb,
+                              "Test",
+                              0,
+                              threadCount,
                               std::function<decltype(FinalizerCallbackDelayed)>(
                                   FinalizerCallbackDelayed),
                               testData);
@@ -137,7 +144,7 @@ static Value TestDelayedTSFN(const CallbackInfo &info) {
   }
   std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 100 + 1));
 
-  for (auto &task : testData->taskInsts) {
+  for (auto& task : testData->taskInsts) {
     std::lock_guard<std::mutex> lk(task->mtx);
     task->tsfn = testData->tsfn;
     task->cv.notify_all();
@@ -149,7 +156,7 @@ static Value TestDelayedTSFN(const CallbackInfo &info) {
 void AcquireFinalizerCallback(Napi::Env env,
                               TestData* finalizeData,
                               TestData* context) {
-  (void) context;
+  (void)context;
   for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
     finalizeData->threads[i].join();
   }
@@ -161,13 +168,13 @@ 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) {
+  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))});
+    callback.Call({Number::New(env, static_cast<double>(threadId))});
   });
   tsfn.Release();
 }
@@ -182,7 +189,7 @@ static Value CreateThread(const CallbackInfo& info) {
   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) );
+  testData->threads.push_back(std::thread(entryAcquire, tsfn, threadId));
   return Number::New(info.Env(), threadId);
 }
 
@@ -198,21 +205,29 @@ static Value TestAcquire(const CallbackInfo& info) {
 
   // 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* testData = new TestData(Promise::Deferred::New(info.Env()));
 
-  testData->tsfn = ThreadSafeFunction::New(
-    env, cb, "Test", 0, 1, testData,
-    std::function<decltype(AcquireFinalizerCallback)>(AcquireFinalizerCallback),
-    testData);
+  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["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);

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

@@ -33,15 +33,15 @@ 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) {
+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() {
+  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++) {

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

@@ -15,27 +15,40 @@ static Value TestUnref(const CallbackInfo& info) {
   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 = 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)
-  });
+  setTimeout.Call(
+      global,
+      {Function::New(
+           env, [tsfn](const CallbackInfo& info) { tsfn->Unref(info.Env()); }),
+       Number::New(env, 100)});
 
   return info.Env().Undefined();
 }
 
+static Value TestRef(const CallbackInfo& info) {
+  Function cb = info[1].As<Function>();
+
+  auto tsfn = ThreadSafeFunction::New(info.Env(), cb, "testRes", 1, 1);
+
+  tsfn.BlockingCall();
+  tsfn.Unref(info.Env());
+  tsfn.Ref(info.Env());
+
+  return info.Env().Undefined();
 }
 
+}  // namespace
+
 Object InitThreadSafeFunctionUnref(Env env) {
   Object exports = Object::New(env);
   exports["testUnref"] = Function::New(env, TestUnref);
+  exports["testRef"] = Function::New(env, TestRef);
   return exports;
 }
 

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

@@ -2,7 +2,7 @@
 
 const assert = require('assert');
 
-const isMainProcess = process.argv[1] != __filename;
+const isMainProcess = process.argv[1] !== __filename;
 
 /**
  * In order to test that the event loop exits even with an active TSFN, we need
@@ -11,43 +11,88 @@ const isMainProcess = process.argv[1] != __filename;
  *   - 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.
+ *
+ * We also added a new test case for `Ref`. The idea being, if a TSFN is active, the event loop that it belongs to should not exit
+ * Our setup is similar to the test for the `Unref` case, with the difference being now we are expecting the child process to hang
  */
 
 if (isMainProcess) {
   module.exports = require('../common').runTestWithBindingPath(test);
 } else {
-  test(process.argv[2]);
+  const isTestingRef = (process.argv[3] === 'true');
+
+  if (isTestingRef) {
+    execTSFNRefTest(process.argv[2]);
+  } else {
+    execTSFNUnrefTest(process.argv[2]);
+  }
 }
 
-function test(bindingFile) {
-  if (isMainProcess) {
-    // Main process
+function testUnRefCallback (resolve, reject, bindingFile) {
+  const child = require('../napi_child').spawn(process.argv[0], [
+    '--expose-gc', __filename, bindingFile, false
+  ], { 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();
+  });
+}
+
+function testRefCallback (resolve, reject, bindingFile) {
+  const child = require('../napi_child').spawn(process.argv[0], [
+    '--expose-gc', __filename, bindingFile, true
+  ], { stdio: 'inherit' });
+
+  let timeout = setTimeout(function () {
+    child.kill();
+    timeout = 0;
+    resolve();
+  }, 1000);
+
+  child.on('error', (err) => {
+    clearTimeout(timeout);
+    timeout = 0;
+    reject(new Error(err));
+  });
+
+  child.on('close', (code) => {
+    if (timeout) clearTimeout(timeout);
+
+    reject(new Error('We expected Child to hang'));
+  });
+}
+
+function test (bindingFile) {
+  // Main process
+  return new Promise((resolve, reject) => {
+    testUnRefCallback(resolve, reject, bindingFile);
+  }).then(() => {
     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();
-      });
+      testRefCallback(resolve, reject, bindingFile);
     });
-  } else {
-    // Child process
-    const binding = require(bindingFile);
-    binding.threadsafe_function_unref.testUnref({}, () => { });
-  }
+  });
+}
+
+function execTSFNUnrefTest (bindingFile) {
+  const binding = require(bindingFile);
+  binding.threadsafe_function_unref.testUnref({}, () => { });
+}
+
+function execTSFNRefTest (bindingFile) {
+  const binding = require(bindingFile);
+  binding.threadsafe_function_unref.testRef({}, () => { });
 }