koffi 2.16.0-beta.2 → 2.16.1

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

@@ -1,79 +0,0 @@
-#include <napi.h>
-#include "test_helper.h"
-using namespace Napi;
-
-Symbol CreateNewSymbolWithNoArgs(const Napi::CallbackInfo&) {
-  return Napi::Symbol();
-}
-
-Symbol CreateNewSymbolWithCppStrDesc(const Napi::CallbackInfo& info) {
-  String cppStrKey = info[0].As<String>();
-  return Napi::Symbol::New(info.Env(), cppStrKey.Utf8Value());
-}
-
-Symbol CreateNewSymbolWithCStrDesc(const Napi::CallbackInfo& info) {
-  String cStrKey = info[0].As<String>();
-  return Napi::Symbol::New(info.Env(), cStrKey.Utf8Value().c_str());
-}
-
-Symbol CreateNewSymbolWithNapiString(const Napi::CallbackInfo& info) {
-  String strKey = info[0].As<String>();
-  return Napi::Symbol::New(info.Env(), strKey);
-}
-
-Symbol GetWellknownSymbol(const Napi::CallbackInfo& info) {
-  String registrySymbol = info[0].As<String>();
-  return MaybeUnwrap(
-      Napi::Symbol::WellKnown(info.Env(), registrySymbol.Utf8Value().c_str()));
-}
-
-Symbol FetchSymbolFromGlobalRegistry(const Napi::CallbackInfo& info) {
-  String registrySymbol = info[0].As<String>();
-  return MaybeUnwrap(Napi::Symbol::For(info.Env(), registrySymbol));
-}
-
-Symbol FetchSymbolFromGlobalRegistryWithCppKey(const Napi::CallbackInfo& info) {
-  String cppStringKey = info[0].As<String>();
-  return MaybeUnwrap(Napi::Symbol::For(info.Env(), cppStringKey.Utf8Value()));
-}
-
-Symbol FetchSymbolFromGlobalRegistryWithCKey(const Napi::CallbackInfo& info) {
-  String cppStringKey = info[0].As<String>();
-  return MaybeUnwrap(
-      Napi::Symbol::For(info.Env(), cppStringKey.Utf8Value().c_str()));
-}
-
-Symbol TestUndefinedSymbolsCanBeCreated(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  return MaybeUnwrap(Napi::Symbol::For(env, env.Undefined()));
-}
-
-Symbol TestNullSymbolsCanBeCreated(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  return MaybeUnwrap(Napi::Symbol::For(env, env.Null()));
-}
-
-Object InitSymbol(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createNewSymbolWithNoArgs"] =
-      Function::New(env, CreateNewSymbolWithNoArgs);
-  exports["createNewSymbolWithCppStr"] =
-      Function::New(env, CreateNewSymbolWithCppStrDesc);
-  exports["createNewSymbolWithCStr"] =
-      Function::New(env, CreateNewSymbolWithCStrDesc);
-  exports["createNewSymbolWithNapi"] =
-      Function::New(env, CreateNewSymbolWithNapiString);
-  exports["getWellKnownSymbol"] = Function::New(env, GetWellknownSymbol);
-  exports["getSymbolFromGlobalRegistry"] =
-      Function::New(env, FetchSymbolFromGlobalRegistry);
-  exports["getSymbolFromGlobalRegistryWithCKey"] =
-      Function::New(env, FetchSymbolFromGlobalRegistryWithCKey);
-  exports["getSymbolFromGlobalRegistryWithCppKey"] =
-      Function::New(env, FetchSymbolFromGlobalRegistryWithCppKey);
-  exports["testUndefinedSymbolCanBeCreated"] =
-      Function::New(env, TestUndefinedSymbolsCanBeCreated);
-  exports["testNullSymbolCanBeCreated"] =
-      Function::New(env, TestNullSymbolsCanBeCreated);
-  return exports;
-}

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

@@ -1,66 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test (binding) {
-  const majorNodeVersion = process.versions.node.split('.')[0];
-
-  const wellKnownSymbolFunctions = ['asyncIterator', 'hasInstance', 'isConcatSpreadable', 'iterator', 'match', 'replace', 'search', 'split', 'species', 'toPrimitive', 'toStringTag', 'unscopables'];
-  if (majorNodeVersion >= 12) {
-    wellKnownSymbolFunctions.push('matchAll');
-  }
-
-  function assertCanCreateSymbol (symbol) {
-    assert(binding.symbol.createNewSymbolWithCppStr(symbol) !== null);
-    assert(binding.symbol.createNewSymbolWithCStr(symbol) !== null);
-    assert(binding.symbol.createNewSymbolWithNapi(symbol) !== null);
-  }
-
-  function assertSymbolAreUnique (symbol) {
-    const symbolOne = binding.symbol.createNewSymbolWithCppStr(symbol);
-    const symbolTwo = binding.symbol.createNewSymbolWithCppStr(symbol);
-
-    assert(symbolOne !== symbolTwo);
-  }
-
-  function assertSymbolIsWellknown (symbol) {
-    const symbOne = binding.symbol.getWellKnownSymbol(symbol);
-    const symbTwo = binding.symbol.getWellKnownSymbol(symbol);
-    assert(symbOne && symbTwo);
-    assert(symbOne === symbTwo);
-  }
-
-  function assertSymbolIsNotWellknown (symbol) {
-    const symbolTest = binding.symbol.getWellKnownSymbol(symbol);
-    assert(symbolTest === undefined);
-  }
-
-  function assertCanCreateOrFetchGlobalSymbols (symbol, fetchFunction) {
-    const symbOne = fetchFunction(symbol);
-    const symbTwo = fetchFunction(symbol);
-    assert(symbOne && symbTwo);
-    assert(symbOne === symbTwo);
-  }
-
-  assertCanCreateSymbol('testing');
-  assertSymbolAreUnique('symbol');
-  assertSymbolIsNotWellknown('testing');
-
-  for (const wellknownProperty of wellKnownSymbolFunctions) {
-    assertSymbolIsWellknown(wellknownProperty);
-  }
-
-  assertCanCreateOrFetchGlobalSymbols('data', binding.symbol.getSymbolFromGlobalRegistry);
-  assertCanCreateOrFetchGlobalSymbols('CppKey', binding.symbol.getSymbolFromGlobalRegistryWithCppKey);
-  assertCanCreateOrFetchGlobalSymbols('CKey', binding.symbol.getSymbolFromGlobalRegistryWithCKey);
-
-  assert(binding.symbol.createNewSymbolWithNoArgs() === undefined);
-
-  // eslint-disable-next-line no-self-compare
-  assert(binding.symbol.testNullSymbolCanBeCreated() === binding.symbol.testNullSymbolCanBeCreated());
-  // eslint-disable-next-line no-self-compare
-  assert(binding.symbol.testUndefinedSymbolCanBeCreated() === binding.symbol.testUndefinedSymbolCanBeCreated());
-  assert(binding.symbol.testUndefinedSymbolCanBeCreated() !== binding.symbol.testNullSymbolCanBeCreated());
-}

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

@@ -1,54 +0,0 @@
-// Run each test function in sequence,
-// with an async delay and GC call between each.
-
-function tick (x) {
-  return new Promise((resolve) => {
-    setImmediate(function ontick () {
-      if (--x === 0) {
-        resolve();
-      } else {
-        setImmediate(ontick);
-      }
-    });
-  });
-}
-
-async function runGCTests (tests) {
-  // Break up test list into a list of lists of the form
-  // [ [ 'test name', function() {}, ... ], ..., ].
-  const testList = [];
-  let currentTest;
-  for (const item of tests) {
-    if (typeof item === 'string') {
-      currentTest = [];
-      testList.push(currentTest);
-    }
-    currentTest.push(item);
-  }
-
-  for (const test of testList) {
-    await (async function (test) {
-      let title;
-      for (let i = 0; i < test.length; i++) {
-        if (i === 0) {
-          title = test[i];
-        } else {
-          try {
-            test[i]();
-          } catch (e) {
-            console.error('Test failed: ' + title);
-            throw e;
-          }
-          if (i < tests.length - 1) {
-            global.gc();
-            await tick(10);
-          }
-        }
-      }
-    })(test);
-  }
-}
-
-module.exports = {
-  runGCTests
-};

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

@@ -1,230 +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 s_tsfn;
-
-struct ThreadSafeFunctionInfo {
-  enum CallType {
-    DEFAULT,
-    BLOCKING,
-    NON_BLOCKING,
-    NON_BLOCKING_DEFAULT,
-    NON_BLOCKING_SINGLE_ARG
-  } 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 (s_tsfn.Release() != napi_ok) {
-    Error::Fatal("SecondaryThread", "ThreadSafeFunction.Release() failed");
-  }
-}
-
-// Source thread producing the data
-static void DataSourceThread() {
-  ThreadSafeFunctionInfo* info = s_tsfn.GetContext();
-
-  if (info->startSecondary) {
-    if (s_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)});
-    };
-
-    auto noArgCallback = [](Env env, Function jsCallback) {
-      jsCallback.Call({Number::New(env, 42)});
-    };
-
-    switch (info->type) {
-      case ThreadSafeFunctionInfo::DEFAULT:
-        status = s_tsfn.BlockingCall();
-        break;
-      case ThreadSafeFunctionInfo::BLOCKING:
-        status = s_tsfn.BlockingCall(&ints[index], callback);
-        break;
-      case ThreadSafeFunctionInfo::NON_BLOCKING:
-        status = s_tsfn.NonBlockingCall(&ints[index], callback);
-        break;
-      case ThreadSafeFunctionInfo::NON_BLOCKING_DEFAULT:
-        status = s_tsfn.NonBlockingCall();
-        break;
-
-      case ThreadSafeFunctionInfo::NON_BLOCKING_SINGLE_ARG:
-        status = s_tsfn.NonBlockingCall(noArgCallback);
-        break;
-    }
-
-    if (info->abort && (info->type == ThreadSafeFunctionInfo::BLOCKING ||
-                        info->type == ThreadSafeFunctionInfo::DEFAULT)) {
-      // 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 && s_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) {
-    s_tsfn.Abort();
-  } else {
-    s_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;
-
-  s_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 (s_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);
-}
-
-static Value StartThreadNonblockingNoNative(const CallbackInfo& info) {
-  return StartThreadInternal(info,
-                             ThreadSafeFunctionInfo::NON_BLOCKING_DEFAULT);
-}
-
-static Value StartThreadNonBlockingSingleArg(const CallbackInfo& info) {
-  return StartThreadInternal(info,
-                             ThreadSafeFunctionInfo::NON_BLOCKING_SINGLE_ARG);
-}
-
-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["startThreadNonblockingNoNative"] =
-      Function::New(env, StartThreadNonblockingNoNative);
-  exports["startThreadNonblocking"] =
-      Function::New(env, StartThreadNonblocking);
-  exports["startThreadNonblockSingleArg"] =
-      Function::New(env, StartThreadNonBlockingSingleArg);
-  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,225 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const common = require('../common');
-
-module.exports = common.runTest(test);
-
-// Main test body
-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);
-
-  const expectedDefaultArray = Array.from({ length: binding.threadsafe_function.ARRAY_LENGTH }, (_, i) => 42);
-
-  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' || threadStarter === 'startThreadNonblockSingleArg')) {
-        // 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);
-      }
-    });
-  }
-
-  function testWithoutJSMarshallers (nativeFunction) {
-    return new Promise((resolve) => {
-      let callCount = 0;
-      nativeFunction(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);
-    });
-  }
-
-  await testWithoutJSMarshallers(binding.threadsafe_function.startThreadNoNative);
-  await testWithoutJSMarshallers(binding.threadsafe_function.startThreadNonblockingNoNative);
-
-  // 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
-  );
-
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThreadNonblockSingleArg',
-      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
-      quitAfter: 1
-    }),
-    expectedDefaultArray
-  );
-
-  // 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
-  );
-
-  assert.deepStrictEqual(
-    await testWithJSMarshaller({
-      threadStarter: 'startThreadNonblockSingleArg',
-      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
-      quitAfter: 1,
-      launchSecondary: true
-    }),
-    expectedDefaultArray
-  );
-
-  // 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
-  );
-
-  assert.strictEqual(
-    (await testWithJSMarshaller({
-      threadStarter: 'startThreadNonblockSingleArg',
-      quitAfter: 1,
-      maxQueueSize: binding.threadsafe_function.MAX_QUEUE_SIZE,
-      abort: true
-    })).indexOf(0),
-    -1
-  );
-}