koffi 0.9.4 → 0.9.5

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

@@ -1,225 +1,225 @@
-#include "napi.h"
-#include <thread>
-#include <cstdlib>
-#include <condition_variable>
-#include <mutex>
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-namespace {
-
-struct TestData {
-
-  TestData(Promise::Deferred&& deferred) : deferred(std::move(deferred)) {};
-  
-  // Native Promise returned to JavaScript
-  Promise::Deferred deferred;
-
-  // List of threads created for test. This list only ever accessed via main
-  // thread.
-  std::vector<std::thread> threads = {};
-
-  ThreadSafeFunction tsfn = ThreadSafeFunction();
-
-  // These variables are only accessed from the main thread.
-  bool mainWantsRelease = false;
-  size_t expected_calls = 0;
-};
-
-void FinalizerCallback(Napi::Env env, TestData* finalizeData){
-  for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
-    finalizeData->threads[i].join();
-  }
-  finalizeData->deferred.Resolve(Boolean::New(env, true));
-  delete finalizeData;
-}
-
-/**
- * See threadsafe_function_sum.js for descriptions of the tests in this file
- */
-
-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.Release();
-}
-
-static Value TestWithTSFN(const CallbackInfo& info) {
-  int threadCount = info[0].As<Number>().Int32Value();
-  Function cb = info[1].As<Function>();
-
-  // 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()));
-
-  ThreadSafeFunction tsfn = ThreadSafeFunction::New(
-      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) );
-  }
-
-  return testData->deferred.Promise();
-}
-
-// Task instance created for each new std::thread
-class DelayedTSFNTask {
-public:
-  // Each instance has its own tsfn
-  ThreadSafeFunction tsfn;
-
-  // Thread-safety
-  std::mutex mtx;
-  std::condition_variable cv;
-
-  // Entry point for std::thread
-  void entryDelayedTSFN(int threadId) {
-    std::unique_lock<std::mutex> lk(mtx);
-    cv.wait(lk);
-    tsfn.BlockingCall([=](Napi::Env env, Function callback) {
-      callback.Call({Number::New(env, static_cast<double>(threadId))});
-    });
-    tsfn.Release();
-  };
-};
-
-struct TestDataDelayed {
-
-  TestDataDelayed(Promise::Deferred &&deferred)
-      : deferred(std::move(deferred)){};
-  ~TestDataDelayed() { taskInsts.clear(); };
-  // Native Promise returned to JavaScript
-  Promise::Deferred deferred;
-
-  // List of threads created for test. This list only ever accessed via main
-  // thread.
-  std::vector<std::thread> threads = {};
-
-  // List of DelayedTSFNThread instances
-  std::vector<std::unique_ptr<DelayedTSFNTask>> taskInsts = {};
-
-  ThreadSafeFunction tsfn = ThreadSafeFunction();
-};
-
-void FinalizerCallbackDelayed(Napi::Env env, TestDataDelayed *finalizeData) {
-  for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
-    finalizeData->threads[i].join();
-  }
-  finalizeData->deferred.Resolve(Boolean::New(env, true));
-  delete finalizeData;
-}
-
-static Value TestDelayedTSFN(const CallbackInfo &info) {
-  int threadCount = info[0].As<Number>().Int32Value();
-  Function cb = info[1].As<Function>();
-
-  TestDataDelayed *testData =
-      new TestDataDelayed(Promise::Deferred::New(info.Env()));
-
-  testData->tsfn =
-      ThreadSafeFunction::New(info.Env(), cb, "Test", 0, threadCount,
-                              std::function<decltype(FinalizerCallbackDelayed)>(
-                                  FinalizerCallbackDelayed),
-                              testData);
-
-  for (int i = 0; i < threadCount; ++i) {
-    testData->taskInsts.push_back(
-        std::unique_ptr<DelayedTSFNTask>(new DelayedTSFNTask()));
-    testData->threads.push_back(std::thread(&DelayedTSFNTask::entryDelayedTSFN,
-                                            testData->taskInsts.back().get(),
-                                            i));
-  }
-  std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 100 + 1));
-
-  for (auto &task : testData->taskInsts) {
-    std::lock_guard<std::mutex> lk(task->mtx);
-    task->tsfn = testData->tsfn;
-    task->cv.notify_all();
-  }
-
-  return testData->deferred.Promise();
-}
-
-void AcquireFinalizerCallback(Napi::Env env,
-                              TestData* finalizeData,
-                              TestData* context) {
-  (void) context;
-  for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
-    finalizeData->threads[i].join();
-  }
-  finalizeData->deferred.Resolve(Boolean::New(env, true));
-  delete finalizeData;
-}
-
-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) {
-    // 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))});
-  });
-  tsfn.Release();
-}
-
-static Value CreateThread(const CallbackInfo& info) {
-  TestData* testData = static_cast<TestData*>(info.Data());
-  // Counting expected calls like this only works because on the JS side this
-  // binding is called from a synchronous loop. This means the main loop has no
-  // chance to run the tsfn JS callback before we've counted how many threads
-  // the JS intends to create.
-  testData->expected_calls++;
-  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) );
-  return Number::New(info.Env(), threadId);
-}
-
-static Value StopThreads(const CallbackInfo& info) {
-  TestData* testData = static_cast<TestData*>(info.Data());
-  testData->mainWantsRelease = true;
-  return info.Env().Undefined();
-}
-
-static Value TestAcquire(const CallbackInfo& info) {
-  Function cb = info[0].As<Function>();
-  Napi::Env env = info.Env();
-
-  // 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->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["promise"] = testData->deferred.Promise();
-
-  return result;
-}
-}
-
-Object InitThreadSafeFunctionSum(Env env) {
-  Object exports = Object::New(env);
-  exports["testDelayedTSFN"] = Function::New(env, TestDelayedTSFN);
-  exports["testWithTSFN"] = Function::New(env, TestWithTSFN);
-  exports["testAcquire"] = Function::New(env, TestAcquire);
-  return exports;
-}
-
-#endif
+#include "napi.h"
+#include <thread>
+#include <cstdlib>
+#include <condition_variable>
+#include <mutex>
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+namespace {
+
+struct TestData {
+
+  TestData(Promise::Deferred&& deferred) : deferred(std::move(deferred)) {};
+  
+  // Native Promise returned to JavaScript
+  Promise::Deferred deferred;
+
+  // List of threads created for test. This list only ever accessed via main
+  // thread.
+  std::vector<std::thread> threads = {};
+
+  ThreadSafeFunction tsfn = ThreadSafeFunction();
+
+  // These variables are only accessed from the main thread.
+  bool mainWantsRelease = false;
+  size_t expected_calls = 0;
+};
+
+void FinalizerCallback(Napi::Env env, TestData* finalizeData){
+  for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
+    finalizeData->threads[i].join();
+  }
+  finalizeData->deferred.Resolve(Boolean::New(env, true));
+  delete finalizeData;
+}
+
+/**
+ * See threadsafe_function_sum.js for descriptions of the tests in this file
+ */
+
+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.Release();
+}
+
+static Value TestWithTSFN(const CallbackInfo& info) {
+  int threadCount = info[0].As<Number>().Int32Value();
+  Function cb = info[1].As<Function>();
+
+  // 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()));
+
+  ThreadSafeFunction tsfn = ThreadSafeFunction::New(
+      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) );
+  }
+
+  return testData->deferred.Promise();
+}
+
+// Task instance created for each new std::thread
+class DelayedTSFNTask {
+public:
+  // Each instance has its own tsfn
+  ThreadSafeFunction tsfn;
+
+  // Thread-safety
+  std::mutex mtx;
+  std::condition_variable cv;
+
+  // Entry point for std::thread
+  void entryDelayedTSFN(int threadId) {
+    std::unique_lock<std::mutex> lk(mtx);
+    cv.wait(lk);
+    tsfn.BlockingCall([=](Napi::Env env, Function callback) {
+      callback.Call({Number::New(env, static_cast<double>(threadId))});
+    });
+    tsfn.Release();
+  };
+};
+
+struct TestDataDelayed {
+
+  TestDataDelayed(Promise::Deferred &&deferred)
+      : deferred(std::move(deferred)){};
+  ~TestDataDelayed() { taskInsts.clear(); };
+  // Native Promise returned to JavaScript
+  Promise::Deferred deferred;
+
+  // List of threads created for test. This list only ever accessed via main
+  // thread.
+  std::vector<std::thread> threads = {};
+
+  // List of DelayedTSFNThread instances
+  std::vector<std::unique_ptr<DelayedTSFNTask>> taskInsts = {};
+
+  ThreadSafeFunction tsfn = ThreadSafeFunction();
+};
+
+void FinalizerCallbackDelayed(Napi::Env env, TestDataDelayed *finalizeData) {
+  for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
+    finalizeData->threads[i].join();
+  }
+  finalizeData->deferred.Resolve(Boolean::New(env, true));
+  delete finalizeData;
+}
+
+static Value TestDelayedTSFN(const CallbackInfo &info) {
+  int threadCount = info[0].As<Number>().Int32Value();
+  Function cb = info[1].As<Function>();
+
+  TestDataDelayed *testData =
+      new TestDataDelayed(Promise::Deferred::New(info.Env()));
+
+  testData->tsfn =
+      ThreadSafeFunction::New(info.Env(), cb, "Test", 0, threadCount,
+                              std::function<decltype(FinalizerCallbackDelayed)>(
+                                  FinalizerCallbackDelayed),
+                              testData);
+
+  for (int i = 0; i < threadCount; ++i) {
+    testData->taskInsts.push_back(
+        std::unique_ptr<DelayedTSFNTask>(new DelayedTSFNTask()));
+    testData->threads.push_back(std::thread(&DelayedTSFNTask::entryDelayedTSFN,
+                                            testData->taskInsts.back().get(),
+                                            i));
+  }
+  std::this_thread::sleep_for(std::chrono::milliseconds(std::rand() % 100 + 1));
+
+  for (auto &task : testData->taskInsts) {
+    std::lock_guard<std::mutex> lk(task->mtx);
+    task->tsfn = testData->tsfn;
+    task->cv.notify_all();
+  }
+
+  return testData->deferred.Promise();
+}
+
+void AcquireFinalizerCallback(Napi::Env env,
+                              TestData* finalizeData,
+                              TestData* context) {
+  (void) context;
+  for (size_t i = 0; i < finalizeData->threads.size(); ++i) {
+    finalizeData->threads[i].join();
+  }
+  finalizeData->deferred.Resolve(Boolean::New(env, true));
+  delete finalizeData;
+}
+
+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) {
+    // 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))});
+  });
+  tsfn.Release();
+}
+
+static Value CreateThread(const CallbackInfo& info) {
+  TestData* testData = static_cast<TestData*>(info.Data());
+  // Counting expected calls like this only works because on the JS side this
+  // binding is called from a synchronous loop. This means the main loop has no
+  // chance to run the tsfn JS callback before we've counted how many threads
+  // the JS intends to create.
+  testData->expected_calls++;
+  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) );
+  return Number::New(info.Env(), threadId);
+}
+
+static Value StopThreads(const CallbackInfo& info) {
+  TestData* testData = static_cast<TestData*>(info.Data());
+  testData->mainWantsRelease = true;
+  return info.Env().Undefined();
+}
+
+static Value TestAcquire(const CallbackInfo& info) {
+  Function cb = info[0].As<Function>();
+  Napi::Env env = info.Env();
+
+  // 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->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["promise"] = testData->deferred.Promise();
+
+  return result;
+}
+}
+
+Object InitThreadSafeFunctionSum(Env env) {
+  Object exports = Object::New(env);
+  exports["testDelayedTSFN"] = Function::New(env, TestDelayedTSFN);
+  exports["testWithTSFN"] = Function::New(env, TestWithTSFN);
+  exports["testAcquire"] = Function::New(env, TestAcquire);
+  return exports;
+}
+
+#endif

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

@@ -1,59 +1,59 @@
-'use strict';
-const assert = require('assert');
-
-/**
- *
- * ThreadSafeFunction Tests: Thread Id Sums
- *
- * Every native C++ function that utilizes the TSFN will call the registered
- * callback with the thread id. Passing Array.prototype.push with a bound array
- * will push the thread id to the array. Therefore, starting `N` threads, we
- * will expect the sum of all elements in the array to be `(N-1) * (N) / 2` (as
- * thread IDs are 0-based)
- *
- * We check different methods of passing a ThreadSafeFunction around multiple
- * threads:
- *  - `testWithTSFN`: The main thread creates the TSFN. Then, it creates
- *    threads, passing the TSFN at thread construction. The number of threads is
- *    static (known at TSFN creation).
- *  - `testDelayedTSFN`: The main thread creates threads, passing a promise to a
- *    TSFN at construction. Then, it creates the TSFN, and resolves each
- *    threads' promise. The number of threads is static.
- *  - `testAcquire`: The native binding returns a function to start a new. A
- *    call to this function will return `false` once `N` calls have been made.
- *    Each thread will acquire its own use of the TSFN, call it, and then
- *    release.
- */
-
-const THREAD_COUNT = 5;
-const EXPECTED_SUM = (THREAD_COUNT - 1) * (THREAD_COUNT) / 2;
-
-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) {
-    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() {
-    const calls = [];
-    const { promise, createThread, stopThreads } = binding.threadsafe_function_sum.testAcquire(Array.prototype.push.bind(calls));
-    for (let i = 0; i < THREAD_COUNT; i++) {
-      createThread();
-    }
-    stopThreads();
-    const result = await promise;
-    assert.ok(result);
-    assert.equal(sum(calls), EXPECTED_SUM);
-  }
-
-  return check(binding.threadsafe_function_sum.testDelayedTSFN)
-    .then(() => check(binding.threadsafe_function_sum.testWithTSFN))
-    .then(() => checkAcquire());
-}
+'use strict';
+const assert = require('assert');
+
+/**
+ *
+ * ThreadSafeFunction Tests: Thread Id Sums
+ *
+ * Every native C++ function that utilizes the TSFN will call the registered
+ * callback with the thread id. Passing Array.prototype.push with a bound array
+ * will push the thread id to the array. Therefore, starting `N` threads, we
+ * will expect the sum of all elements in the array to be `(N-1) * (N) / 2` (as
+ * thread IDs are 0-based)
+ *
+ * We check different methods of passing a ThreadSafeFunction around multiple
+ * threads:
+ *  - `testWithTSFN`: The main thread creates the TSFN. Then, it creates
+ *    threads, passing the TSFN at thread construction. The number of threads is
+ *    static (known at TSFN creation).
+ *  - `testDelayedTSFN`: The main thread creates threads, passing a promise to a
+ *    TSFN at construction. Then, it creates the TSFN, and resolves each
+ *    threads' promise. The number of threads is static.
+ *  - `testAcquire`: The native binding returns a function to start a new. A
+ *    call to this function will return `false` once `N` calls have been made.
+ *    Each thread will acquire its own use of the TSFN, call it, and then
+ *    release.
+ */
+
+const THREAD_COUNT = 5;
+const EXPECTED_SUM = (THREAD_COUNT - 1) * (THREAD_COUNT) / 2;
+
+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) {
+    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() {
+    const calls = [];
+    const { promise, createThread, stopThreads } = binding.threadsafe_function_sum.testAcquire(Array.prototype.push.bind(calls));
+    for (let i = 0; i < THREAD_COUNT; i++) {
+      createThread();
+    }
+    stopThreads();
+    const result = await promise;
+    assert.ok(result);
+    assert.equal(sum(calls), EXPECTED_SUM);
+  }
+
+  return check(binding.threadsafe_function_sum.testDelayedTSFN)
+    .then(() => check(binding.threadsafe_function_sum.testWithTSFN))
+    .then(() => checkAcquire());
+}

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

@@ -1,42 +1,42 @@
-#include "napi.h"
-#include "test_helper.h"
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-namespace {
-
-static Value TestUnref(const CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Object global = env.Global();
-  Object resource = info[0].As<Object>();
-  Function cb = info[1].As<Function>();
-  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->BlockingCall();
-
-  setTimeout.Call( global, {
-    Function::New(env, [tsfn](const CallbackInfo& info) {
-      tsfn->Unref(info.Env());
-    }),
-    Number::New(env, 100)
-  });
-
-  return info.Env().Undefined();
-}
-
-}
-
-Object InitThreadSafeFunctionUnref(Env env) {
-  Object exports = Object::New(env);
-  exports["testUnref"] = Function::New(env, TestUnref);
-  return exports;
-}
-
-#endif
+#include "napi.h"
+#include "test_helper.h"
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+namespace {
+
+static Value TestUnref(const CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  Object global = env.Global();
+  Object resource = info[0].As<Object>();
+  Function cb = info[1].As<Function>();
+  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->BlockingCall();
+
+  setTimeout.Call( global, {
+    Function::New(env, [tsfn](const CallbackInfo& info) {
+      tsfn->Unref(info.Env());
+    }),
+    Number::New(env, 100)
+  });
+
+  return info.Env().Undefined();
+}
+
+}
+
+Object InitThreadSafeFunctionUnref(Env env) {
+  Object exports = Object::New(env);
+  exports["testUnref"] = Function::New(env, TestUnref);
+  return exports;
+}
+
+#endif