add tsfn test with tsfn cb function call

Author: KevinEady

test/binding.cc

@@ -48,6 +48,7 @@ Object InitThreadSafeFunctionPtr(Env env);
 Object InitThreadSafeFunctionSum(Env env);
 Object InitThreadSafeFunctionUnref(Env env);
 Object InitThreadSafeFunction(Env env);
+Object InitThreadSafeFunctionExCall(Env env);
 Object InitThreadSafeFunctionExContext(Env env);
 Object InitThreadSafeFunctionExSimple(Env env);
 #endif
@@ -107,6 +108,7 @@ Object Init(Env env, Object exports) {
   exports.Set("threadsafe_function_sum", InitThreadSafeFunctionSum(env));
   exports.Set("threadsafe_function_unref", InitThreadSafeFunctionUnref(env));
   exports.Set("threadsafe_function", InitThreadSafeFunction(env));
+  exports.Set("threadsafe_function_ex_call", InitThreadSafeFunctionExCall(env));
   exports.Set("threadsafe_function_ex_context", InitThreadSafeFunctionExContext(env));
   exports.Set("threadsafe_function_ex_simple", InitThreadSafeFunctionExSimple(env));
 #endif

test/binding.gyp

@@ -34,6 +34,7 @@
         'object/set_property.cc',
         'promise.cc',
         'run_script.cc',
+        'threadsafe_function_ex/call.cc',
         'threadsafe_function_ex/context.cc',
         'threadsafe_function_ex/simple.cc',
         'threadsafe_function/threadsafe_function_ctx.cc',

test/index.js

@@ -41,6 +41,7 @@ let testModules = [
   'object/set_property',
   'promise',
   'run_script',
+  'threadsafe_function_ex/call',
   'threadsafe_function_ex/context',
   'threadsafe_function_ex/simple',
   'threadsafe_function/threadsafe_function_ctx',
@@ -83,6 +84,7 @@ if (napiVersion < 4) {
   testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_sum'), 1);
   testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_unref'), 1);
   testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function'), 1);
+  testModules.splice(testModules.indexOf('threadsafe_function_ex/call'), 1);
   testModules.splice(testModules.indexOf('threadsafe_function_ex/context'), 1);
   testModules.splice(testModules.indexOf('threadsafe_function_ex/simple'), 1);
 }

test/threadsafe_function_ex/call.cc

@@ -0,0 +1,83 @@
+#include "napi.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+namespace {
+
+// Context of our TSFN.
+using TSFNContext = void;
+
+// Data passed (as pointer) to ThreadSafeFunctionEx::[Non]BlockingCall
+struct TSFNData {
+  Reference<Napi::Value> data;
+  Promise::Deferred deferred;
+};
+
+// CallJs callback function
+static void CallJs(Napi::Env env, Napi::Function jsCallback,
+                   TSFNContext * /*context*/, TSFNData *data) {
+  jsCallback.Call(env.Undefined(), {data->data.Value()});
+  data->deferred.Resolve(data->data.Value());
+  delete data;
+}
+
+// Full type of our ThreadSafeFunctionEx
+using TSFN = ThreadSafeFunctionEx<TSFNContext, TSFNData, CallJs>;
+
+// A JS-accessible wrap that holds a TSFN.
+class TSFNWrap : public ObjectWrap<TSFNWrap> {
+public:
+  static Object Init(Napi::Env env, Object exports);
+  TSFNWrap(const CallbackInfo &info);
+
+  Napi::Value DoCall(const CallbackInfo &info) {
+    Napi::Env env = info.Env();
+    TSFNData *data =
+        new TSFNData{Napi::Reference<Napi::Value>(Persistent(info[0])),
+                     Promise::Deferred::New(env)};
+    _tsfn.NonBlockingCall(data);
+    return data->deferred.Promise();
+  };
+
+  Napi::Value Release(const CallbackInfo &) {
+    _tsfn.Release();
+    return _deferred.Promise();
+  };
+
+private:
+  TSFN _tsfn;
+  Promise::Deferred _deferred;
+};
+
+Object TSFNWrap::Init(Napi::Env env, Object exports) {
+  Function func = DefineClass(env, "TSFNWrap",
+                              {InstanceMethod("doCall", &TSFNWrap::DoCall),
+                               InstanceMethod("release", &TSFNWrap::Release)});
+
+  exports.Set("TSFNWrap", func);
+  return exports;
+}
+
+TSFNWrap::TSFNWrap(const CallbackInfo &info)
+    : ObjectWrap<TSFNWrap>(info),
+      _deferred(Promise::Deferred::New(info.Env())) {
+  Napi::Env env = info.Env();
+  Function callback = info[0].As<Function>();
+
+  _tsfn = TSFN::New(env,      // napi_env env,
+                    callback, // const Function& callback,
+                    Value(),  // const Object& resource,
+                    "Test",   // ResourceString resourceName,
+                    0,        // size_t maxQueueSize,
+                    1         // size_t initialThreadCount,
+  );
+}
+} // namespace
+
+Object InitThreadSafeFunctionExCall(Env env) {
+  return TSFNWrap::Init(env, Object::New(env));
+}
+
+#endif

test/threadsafe_function_ex/call.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const assert = require('assert');
+const buildType = process.config.target_defaults.default_configuration;
+
+module.exports = Promise.all([
+  test(require(`../build/${buildType}/binding.node`)),
+  test(require(`../build/${buildType}/binding_noexcept.node`))
+]);
+
+async function test(binding) {
+  const data = {};
+  const tsfn = new binding.threadsafe_function_ex_call.TSFNWrap(tsfnData => {
+    assert(data === tsfnData, "Data in and out of tsfn call do not equal");
+  });
+  await tsfn.doCall(data);
+  await tsfn.release();
+}