koffi 1.0.3 → 1.1.0-beta.0

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

@@ -1,195 +0,0 @@
-#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 ThreadSafeFunction tsfn;
-
-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;
-
-// Thread data to transmit to JS
-static int ints[ARRAY_LENGTH];
-
-static void SecondaryThread() {
-  if (tsfn.Release() != napi_ok) {
-    Error::Fatal("SecondaryThread", "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("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) });
-    };
-
-    switch (info->type) {
-      case ThreadSafeFunctionInfo::DEFAULT:
-        status = tsfn.BlockingCall();
-        break;
-      case ThreadSafeFunctionInfo::BLOCKING:
-        status = tsfn.BlockingCall(&ints[index], callback);
-        break;
-      case ThreadSafeFunctionInfo::NON_BLOCKING:
-        status = tsfn.NonBlockingCall(&ints[index], callback);
-        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("DataSourceThread", "ThreadSafeFunction.*Call() failed");
-    }
-  }
-
-  if (info->type == ThreadSafeFunctionInfo::NON_BLOCKING && !queueWasFull) {
-    Error::Fatal("DataSourceThread", "Queue was never full");
-  }
-
-  if (info->abort && !queueWasClosing) {
-    Error::Fatal("DataSourceThread", "Queue was never closing");
-  }
-
-  if (!queueWasClosing && tsfn.Release() != napi_ok) {
-    Error::Fatal("DataSourceThread", "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 = ThreadSafeFunction::New(info.Env(), info[0].As<Function>(),
-      "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", "ThreadSafeFunction.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 InitThreadSafeFunction(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

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

@@ -1,188 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const common = require('../common');
-
-module.exports = common.runTest(test);
-
-async function test(binding) {
-  const expectedArray = (function(arrayLength) {
-    const result = [];
-    for (let index = 0; index < arrayLength; index++) {
-      result.push(arrayLength - 1 - index);
-    }
-    return result;
-  })(binding.threadsafe_function.ARRAY_LENGTH);
-
-  function testWithJSMarshaller({
-    threadStarter,
-    quitAfter,
-    abort,
-    maxQueueSize,
-    launchSecondary }) {
-    return new Promise((resolve) => {
-      const array = [];
-      binding.threadsafe_function[threadStarter](function testCallback(value) {
-        array.push(value);
-        if (array.length === quitAfter) {
-          binding.threadsafe_function.stopThread(common.mustCall(() => {
-            resolve(array);
-          }), !!abort);
-        }
-      }, !!abort, !!launchSecondary, maxQueueSize);
-      if (threadStarter === 'startThreadNonblocking') {
-        // 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();
-        while (Date.now() - start < 200);
-      }
-    });
-  }
-
-  await new Promise(function testWithoutJSMarshaller(resolve) {
-    let callCount = 0;
-    binding.threadsafe_function.startThreadNoNative(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);
-  });
-
-  // Start the thread in blocking mode, and assert that all values are passed.
-  // Quit after it's done.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
-      quitAfter: binding.threadsafe_function.ARRAY_LENGTH
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in blocking mode with an infinite queue, and assert that
-  // all values are passed. Quit after it's done.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      maxQueueSize: 0,
-      quitAfter: binding.threadsafe_function.ARRAY_LENGTH
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in non-blocking mode, and assert that all values are
-  // passed. Quit after it's done.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThreadNonblocking',
-      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
-      quitAfter: binding.threadsafe_function.ARRAY_LENGTH
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in blocking mode, and assert that all values are passed.
-  // Quit early, but let the thread finish.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
-      quitAfter: 1
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in blocking mode with an infinite queue, and assert that
-  // all values are passed. Quit early, but let the thread finish.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      maxQueueSize: 0,
-      quitAfter: 1
-    }),
-    expectedArray,
-  );
-
-
-  // Start the thread in non-blocking mode, and assert that all values are
-  // passed. Quit early, but let the thread finish.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThreadNonblocking',
-      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
-      quitAfter: 1
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in blocking mode, and assert that all values are passed.
-  // Quit early, but let the thread finish. Launch a secondary thread to test
-  // the reference counter incrementing functionality.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      quitAfter: 1,
-      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
-      launchSecondary: true
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in non-blocking mode, and assert that all values are
-  // passed. Quit early, but let the thread finish. Launch a secondary thread
-  // to test the reference counter incrementing functionality.
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThreadNonblocking',
-      quitAfter: 1,
-      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
-      launchSecondary: true
-    }),
-    expectedArray,
-  );
-
-  // Start the thread in blocking mode, and assert that it could not finish.
-  // Quit early by aborting.
-  assert.strictEqual(
-    (await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      quitAfter: 1,
-      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
-      abort: true
-    })).indexOf(0),
-    -1,
-  );
-
-  // Start the thread in blocking mode with an infinite queue, and assert that
-  // it could not finish. Quit early by aborting.
-  assert.strictEqual(
-    (await testWithJSMarshaller({
-      threadStarter: 'startThread',
-      quitAfter: 1,
-      maxQueueSize: 0,
-      abort: true
-    })).indexOf(0),
-    -1,
-  );
-
-  // Start the thread in non-blocking mode, and assert that it could not finish.
-  // Quit early and aborting.
-  assert.strictEqual(
-    (await testWithJSMarshaller({
-      threadStarter: 'startThreadNonblocking',
-      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,63 +0,0 @@
-#include "napi.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-namespace {
-
-class TSFNWrap : public ObjectWrap<TSFNWrap> {
-public:
-  static Object Init(Napi::Env env, Object exports);
-  TSFNWrap(const CallbackInfo &info);
-
-  Napi::Value GetContext(const CallbackInfo & /*info*/) {
-    Reference<Napi::Value> *ctx = _tsfn.GetContext();
-    return ctx->Value();
-  };
-
-  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:
-  ThreadSafeFunction _tsfn;
-  std::unique_ptr<Promise::Deferred> _deferred;
-};
-
-Object TSFNWrap::Init(Napi::Env env, Object exports) {
-  Function func =
-      DefineClass(env, "TSFNWrap",
-                  {InstanceMethod("getContext", &TSFNWrap::GetContext),
-                   InstanceMethod("release", &TSFNWrap::Release)});
-
-  exports.Set("TSFNWrap", func);
-  return exports;
-}
-
-TSFNWrap::TSFNWrap(const CallbackInfo &info) : ObjectWrap<TSFNWrap>(info) {
-  Napi::Env env = info.Env();
-
-  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) {
-        _deferred->Resolve(env.Undefined());
-        ctx->Reset();
-        delete ctx;
-      });
-}
-
-} // namespace
-
-Object InitThreadSafeFunctionCtx(Env env) {
-  return TSFNWrap::Init(env, Object::New(env));
-}
-
-#endif

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

@@ -1,12 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-async function test(binding) {
-  const ctx = { };
-  const tsfn = new binding.threadsafe_function_ctx.TSFNWrap(ctx);
-  assert(tsfn.getContext() === ctx);
-  await tsfn.release();
-}

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

@@ -1,115 +0,0 @@
-#include <cstdlib>
-#include "napi.h"
-#include "test_helper.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-namespace {
-
-struct TestContext {
-  TestContext(Promise::Deferred &&deferred)
-      : deferred(std::move(deferred)), callData(nullptr){};
-
-  napi_threadsafe_function tsfn;
-  Promise::Deferred deferred;
-  double *callData;
-
-  ~TestContext() {
-    if (callData != nullptr)
-      delete callData;
-  };
-};
-
-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 {
-    testContext->deferred.Resolve(Napi::Env(env).Undefined());
-  }
-  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);
-
-  napi_status status =
-      napi_release_threadsafe_function(testContext->tsfn, napi_tsfn_release);
-
-  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);
-  testContext->callData = nullptr;
-
-  napi_status status =
-      napi_release_threadsafe_function(testContext->tsfn, napi_tsfn_release);
-
-  NAPI_THROW_IF_FAILED_VOID(env, status);
-}
-
-static Value TestCall(const CallbackInfo &info) {
-  Napi::Env env = info.Env();
-  bool isBlocking = false;
-  bool hasData = false;
-  if (info.Length() > 0) {
-    Object opts = info[0].As<Object>();
-    bool hasProperty = MaybeUnwrap(opts.Has("blocking"));
-    if (hasProperty) {
-      isBlocking = MaybeUnwrap(MaybeUnwrap(opts.Get("blocking")).ToBoolean());
-    }
-    hasProperty = MaybeUnwrap(opts.Has("data"));
-    if (hasProperty) {
-      hasData = MaybeUnwrap(MaybeUnwrap(opts.Get("data")).ToBoolean());
-    }
-  }
-
-  // Allow optional callback passed from JS. Useful for testing.
-  Function cb = Function::New(env, [](const CallbackInfo & /*info*/) {});
-
-  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_THROW_IF_FAILED(env, status, Value());
-
-  ThreadSafeFunction wrapped = ThreadSafeFunction(testContext->tsfn);
-
-  // Test the four napi_threadsafe_function direct-accessing calls
-  if (isBlocking) {
-    if (hasData) {
-      wrapped.BlockingCall(static_cast<void *>(new double(std::rand())));
-    } else {
-      wrapped.BlockingCall(static_cast<void *>(nullptr));
-    }
-  } else {
-    if (hasData) {
-      wrapped.NonBlockingCall(static_cast<void *>(new double(std::rand())));
-    } else {
-      wrapped.NonBlockingCall(static_cast<void *>(nullptr));
-    }
-  }
-
-  return testContext->deferred.Promise();
-}
-
-} // namespace
-
-Object InitThreadSafeFunctionExistingTsfn(Env env) {
-  Object exports = Object::New(env);
-  exports["testCall"] = Function::New(env, TestCall);
-
-  return exports;
-}
-
-#endif

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

@@ -1,14 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-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");
-}

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

@@ -1,26 +0,0 @@
-#include "napi.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-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);
-  tsfn.Release();
-  return info.Env().Undefined();
-}
-
-}
-
-Object InitThreadSafeFunctionPtr(Env env) {
-  Object exports = Object::New(env);
-  exports["test"] = Function::New(env, Test);
-
-  return exports;
-}
-
-#endif

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

@@ -1,7 +0,0 @@
-'use strict';
-
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  binding.threadsafe_function_ptr.test({}, () => {});
-}