koffi 2.3.4 → 2.3.6-beta.1

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

@@ -22,64 +22,59 @@ static Napi::Value TestGetter(const Napi::CallbackInfo& /*info*/) {
   return Napi::Value();
 }
 
-static void TestSetter(const Napi::CallbackInfo& /*info*/) {
-}
+static void TestSetter(const Napi::CallbackInfo& /*info*/) {}
 
 class TestClass : public Napi::ObjectWrap<TestClass> {
  public:
-  TestClass(const Napi::CallbackInfo& info):
-      ObjectWrap<TestClass>(info) {
-  }
+  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*/) {
-  }
+  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*/) {
-  }
+  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*/) {
-  }
+                               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)
-    });
+    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)});
   }
 };
 
@@ -91,42 +86,34 @@ static Napi::Value CreateTestObject(const Napi::CallbackInfo& info) {
   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)),
+      // 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;

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

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

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

@@ -40,23 +40,23 @@ static void TSFNCallJS(Env env,
 }
 
 using TSFN = TypedThreadSafeFunction<ThreadSafeFunctionInfo, int, TSFNCallJS>;
-static TSFN tsfn;
+static TSFN s_tsfn;
 
 // Thread data to transmit to JS
 static int ints[ARRAY_LENGTH];
 
 static void SecondaryThread() {
-  if (tsfn.Release() != napi_ok) {
+  if (s_tsfn.Release() != napi_ok) {
     Error::Fatal("TypedSecondaryThread", "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("TypedDataSourceThread",
                    "ThreadSafeFunction.Acquire() failed");
     }
@@ -71,13 +71,13 @@ static void DataSourceThread() {
 
     switch (info->type) {
       case ThreadSafeFunctionInfo::DEFAULT:
-        status = tsfn.BlockingCall();
+        status = s_tsfn.BlockingCall();
         break;
       case ThreadSafeFunctionInfo::BLOCKING:
-        status = tsfn.BlockingCall(&ints[index]);
+        status = s_tsfn.BlockingCall(&ints[index]);
         break;
       case ThreadSafeFunctionInfo::NON_BLOCKING:
-        status = tsfn.NonBlockingCall(&ints[index]);
+        status = s_tsfn.NonBlockingCall(&ints[index]);
         break;
     }
 
@@ -117,7 +117,7 @@ static void DataSourceThread() {
     Error::Fatal("TypedDataSourceThread", "Queue was never closing");
   }
 
-  if (!queueWasClosing && tsfn.Release() != napi_ok) {
+  if (!queueWasClosing && s_tsfn.Release() != napi_ok) {
     Error::Fatal("TypedDataSourceThread",
                  "ThreadSafeFunction.Release() failed");
   }
@@ -127,9 +127,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);
@@ -160,15 +160,15 @@ static Value StartThreadInternal(const CallbackInfo& info,
   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);
+  s_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);
 
@@ -176,7 +176,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", "TypedThreadSafeFunction.Release() failed");
   }
   return Value();

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

@@ -5,7 +5,7 @@ const common = require('../common');
 
 module.exports = common.runTest(test);
 
-async function test(binding) {
+async function test (binding) {
   const expectedArray = (function (arrayLength) {
     const result = [];
     for (let index = 0; index < arrayLength; index++) {
@@ -14,15 +14,16 @@ async function test(binding) {
     return result;
   })(binding.typed_threadsafe_function.ARRAY_LENGTH);
 
-  function testWithJSMarshaller({
+  function testWithJSMarshaller ({
     threadStarter,
     quitAfter,
     abort,
     maxQueueSize,
-    launchSecondary }) {
+    launchSecondary
+  }) {
     return new Promise((resolve) => {
       const array = [];
-      binding.typed_threadsafe_function[threadStarter](function testCallback(value) {
+      binding.typed_threadsafe_function[threadStarter](function testCallback (value) {
         array.push(value);
         if (array.length === quitAfter) {
           binding.typed_threadsafe_function.stopThread(common.mustCall(() => {
@@ -39,9 +40,9 @@ async function test(binding) {
     });
   }
 
-  await new Promise(function testWithoutJSMarshaller(resolve) {
+  await new Promise(function testWithoutJSMarshaller (resolve) {
     let callCount = 0;
-    binding.typed_threadsafe_function.startThreadNoNative(function testCallback() {
+    binding.typed_threadsafe_function.startThreadNoNative(function testCallback () {
       callCount++;
 
       // The default call-into-JS implementation passes no arguments.
@@ -54,7 +55,7 @@ async function test(binding) {
         });
       }
     }, false /* abort */, false /* launchSecondary */,
-      binding.typed_threadsafe_function.MAX_QUEUE_SIZE);
+    binding.typed_threadsafe_function.MAX_QUEUE_SIZE);
   });
 
   // Start the thread in blocking mode, and assert that all values are passed.
@@ -65,7 +66,7 @@ async function test(binding) {
       maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
       quitAfter: binding.typed_threadsafe_function.ARRAY_LENGTH
     }),
-    expectedArray,
+    expectedArray
   );
 
   // Start the thread in blocking mode with an infinite queue, and assert that
@@ -76,7 +77,7 @@ async function test(binding) {
       maxQueueSize: 0,
       quitAfter: binding.typed_threadsafe_function.ARRAY_LENGTH
     }),
-    expectedArray,
+    expectedArray
   );
 
   // Start the thread in non-blocking mode, and assert that all values are
@@ -87,7 +88,7 @@ async function test(binding) {
       maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
       quitAfter: binding.typed_threadsafe_function.ARRAY_LENGTH
     }),
-    expectedArray,
+    expectedArray
   );
 
   // Start the thread in blocking mode, and assert that all values are passed.
@@ -98,7 +99,7 @@ async function test(binding) {
       maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
       quitAfter: 1
     }),
-    expectedArray,
+    expectedArray
   );
 
   // Start the thread in blocking mode with an infinite queue, and assert that
@@ -109,10 +110,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 +121,7 @@ async function test(binding) {
       maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
       quitAfter: 1
     }),
-    expectedArray,
+    expectedArray
   );
 
   // Start the thread in blocking mode, and assert that all values are passed.
@@ -134,7 +134,7 @@ async function test(binding) {
       maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
       launchSecondary: true
     }),
-    expectedArray,
+    expectedArray
   );
 
   // Start the thread in non-blocking mode, and assert that all values are
@@ -147,7 +147,7 @@ async function test(binding) {
       maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
       launchSecondary: true
     }),
-    expectedArray,
+    expectedArray
   );
 
   // Start the thread in blocking mode, and assert that it could not finish.
@@ -159,7 +159,7 @@ async function test(binding) {
       maxQueueSize: binding.typed_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 +171,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 +183,6 @@ async function test(binding) {
       maxQueueSize: binding.typed_threadsafe_function.MAX_QUEUE_SIZE,
       abort: true
     })).indexOf(0),
-    -1,
+    -1
   );
 }

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

@@ -1,3 +1,4 @@
+#include <assert.h>
 #include "napi.h"
 
 #if (NAPI_VERSION > 3)
@@ -11,7 +12,7 @@ namespace {
 
 class TSFNWrap : public ObjectWrap<TSFNWrap> {
  public:
-  static Object Init(Napi::Env env, Object exports);
+  static Function Init(Napi::Env env);
   TSFNWrap(const CallbackInfo& info);
 
   Napi::Value GetContext(const CallbackInfo& /*info*/) {
@@ -31,15 +32,14 @@ class TSFNWrap : public ObjectWrap<TSFNWrap> {
   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",
                   {InstanceMethod("getContext", &TSFNWrap::GetContext),
                    InstanceMethod("release", &TSFNWrap::Release)});
 
-  exports.Set("TSFNWrap", func);
-  return exports;
+  return func;
 }
 
 TSFNWrap::TSFNWrap(const CallbackInfo& info) : ObjectWrap<TSFNWrap>(info) {
@@ -61,8 +61,60 @@ TSFNWrap::TSFNWrap(const CallbackInfo& info) : ObjectWrap<TSFNWrap>(info) {
 
 }  // namespace
 
+struct SimpleTestContext {
+  SimpleTestContext(int val) : _val(val) {}
+  int _val = -1;
+};
+
+// A simple test to check that the context has been set successfully
+void AssertGetContextFromTSFNNoFinalizerIsCorrect(const CallbackInfo& info) {
+  // Test the overload where we provide a resource name but no finalizer
+  using TSFN = TypedThreadSafeFunction<SimpleTestContext>;
+  SimpleTestContext* ctx = new SimpleTestContext(42);
+  TSFN tsfn = TSFN::New(info.Env(), "testRes", 1, 1, ctx);
+
+  assert(tsfn.GetContext() == ctx);
+  delete ctx;
+  tsfn.Release();
+
+  // Test the other overload where we provide a async resource object, res name
+  // but no finalizer
+  ctx = new SimpleTestContext(52);
+  tsfn = TSFN::New(
+      info.Env(), Object::New(info.Env()), "testResourceObject", 1, 1, ctx);
+
+  assert(tsfn.GetContext() == ctx);
+  delete ctx;
+  tsfn.Release();
+
+  ctx = new SimpleTestContext(52);
+  tsfn = TSFN::New(info.Env(),
+                   "resStrings",
+                   1,
+                   1,
+                   ctx,
+                   [](Napi::Env, void*, SimpleTestContext*) {});
+
+  assert(tsfn.GetContext() == ctx);
+  delete ctx;
+  tsfn.Release();
+
+  ctx = new SimpleTestContext(52);
+  Function emptyFunc;
+  tsfn = TSFN::New(info.Env(), emptyFunc, "resString", 1, 1, ctx);
+  assert(tsfn.GetContext() == ctx);
+  delete ctx;
+  tsfn.Release();
+}
+
 Object InitTypedThreadSafeFunctionCtx(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("AssertTSFNReturnCorrectCxt",
+              Function::New(env, AssertGetContextFromTSFNNoFinalizerIsCorrect));
+  return exports;
 }
 
 #endif

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

@@ -9,4 +9,6 @@ async function test (binding) {
   const tsfn = new binding.typed_threadsafe_function_ctx.TSFNWrap(ctx);
   assert(tsfn.getContext() === ctx);
   await tsfn.release();
+
+  binding.typed_threadsafe_function_ctx.AssertTSFNReturnCorrectCxt();
 }

package/vendor/node-addon-api/test/typed_threadsafe_function/typed_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.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");
+  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

@@ -16,12 +16,16 @@ static Value Test(const CallbackInfo& info) {
   return info.Env().Undefined();
 }
 
+static Value ExtractEnvNullValue(const CallbackInfo& info) {
+  return info.Env().Null();
+}
+
 }  // namespace
 
 Object InitTypedThreadSafeFunctionPtr(Env env) {
   Object exports = Object::New(env);
   exports["test"] = Function::New(env, Test);
-
+  exports["null"] = Function::New(env, ExtractEnvNullValue);
   return exports;
 }
 

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

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

package/vendor/node-addon-api/test/typed_threadsafe_function/typed_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.typed_threadsafe_function_sum.testAcquire(Array.prototype.push.bind(calls));
     for (let i = 0; i < THREAD_COUNT; i++) {

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

@@ -32,6 +32,7 @@ static Value TestUnref(const CallbackInfo& info) {
       static_cast<FinalizerDataType*>(nullptr));
 
   tsfn->BlockingCall();
+  tsfn->Ref(info.Env());
 
   setTimeout.Call(
       global,
@@ -42,11 +43,24 @@ static Value TestUnref(const CallbackInfo& info) {
   return info.Env().Undefined();
 }
 
+static Value TestRef(const CallbackInfo& info) {
+  Function cb = info[1].As<Function>();
+
+  auto tsfn = TSFN::New(info.Env(), cb, "testRes", 1, 1, nullptr);
+
+  tsfn.BlockingCall();
+  tsfn.Unref(info.Env());
+  tsfn.Ref(info.Env());
+
+  return info.Env().Undefined();
+}
+
 }  // namespace
 
 Object InitTypedThreadSafeFunctionUnref(Env env) {
   Object exports = Object::New(env);
   exports["testUnref"] = Function::New(env, TestUnref);
+  exports["testRef"] = Function::New(env, TestRef);
   return exports;
 }