koffi 0.9.33 → 0.9.34

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

@@ -1,225 +0,0 @@
-#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, [this] { return this->tsfn != nullptr; });
-    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 +0,0 @@
-'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 +0,0 @@
-#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

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

@@ -1,53 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-const isMainProcess = process.argv[1] != __filename;
-
-/**
- * In order to test that the event loop exits even with an active TSFN, we need
- * to spawn a new process for the test.
- *   - Main process: spawns new node instance, executing this script
- *   - 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.
- */
-
-if (isMainProcess) {
-  module.exports = require('../common').runTestWithBindingPath(test);
-} else {
-  test(process.argv[2]);
-}
-
-function test(bindingFile) {
-  if (isMainProcess) {
-    // Main process
-    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();
-      });
-    });
-  } else {
-    // Child process
-    const binding = require(bindingFile);
-    binding.threadsafe_function_unref.testUnref({}, () => { });
-  }
-}

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

@@ -1,140 +0,0 @@
-#include <napi.h>
-
-// The formulaic comment below should accompany any code that results in an
-// internal piece of heap data getting created, because each such piece of heap
-// data must be attached to an object by way of a deleter which gets called when
-// the object gets garbage-collected.
-//
-// At the very least, you can add a fprintf(stderr, ...) to the deleter in
-// napi-inl.h and then count the number of times the deleter prints by running
-// node --expose-gc test/thunking_manual.js and counting the number of prints
-// between the two rows of dashes. That number should coincide with the number
-// of formulaic comments below.
-//
-// Note that currently this result can only be achieved with node-chakracore,
-// because V8 does not garbage-collect classes.
-
-static Napi::Value TestMethod(const Napi::CallbackInfo& /*info*/) {
-  return Napi::Value();
-}
-
-static Napi::Value TestGetter(const Napi::CallbackInfo& /*info*/) {
-  return Napi::Value();
-}
-
-static void TestSetter(const Napi::CallbackInfo& /*info*/) {
-}
-
-class TestClass : public Napi::ObjectWrap<TestClass> {
- public:
-  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*/) {
-  }
-
-  Napi::Value TestClassInstanceMethod(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), 42);
-  }
-
-  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*/) {
-  }
-
-  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)
-    });
-  }
-};
-
-static Napi::Value CreateTestObject(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  Napi::Object item = Napi::Object::New(env);
-
-  // Make sure to check that the deleter gets called.
-  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)),
-  });
-
-  return item;
-}
-
-Napi::Object InitThunkingManual(Napi::Env env) {
-  Napi::Object exports = Napi::Object::New(env);
-  exports["createTestObject"] =
-      Napi::Function::New(env, CreateTestObject, "createTestObject");
-  return exports;
-}

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

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