koffi 0.9.1 → 0.9.4

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

@@ -0,0 +1,40 @@
+'use strict';
+
+if (process.argv[2] === 'child') {
+  // Create a single wrapped instance then exit.
+  return new (require(process.argv[3]).objectwrap.Test)();
+}
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const testUtil = require('./testUtil');
+
+module.exports = require('./common').runTestWithBindingPath(test);
+
+function test(bindingName) {
+  return testUtil.runGCTests([
+    'objectwrap removewrap test',
+    () => {
+      const binding = require(bindingName);
+      const Test = binding.objectwrap_removewrap.Test;
+      const getDtorCalled = binding.objectwrap_removewrap.getDtorCalled;
+
+      assert.strictEqual(getDtorCalled(), 0);
+      assert.throws(() => {
+        new Test();
+      });
+      assert.strictEqual(getDtorCalled(), 1);
+    },
+    // Test that gc does not crash.
+    () => {}
+  ]);
+
+  // Start a child process that creates a single wrapped instance to ensure that
+  // it is properly freed at its exit. It must not segfault.
+  // Re: https://github.com/nodejs/node-addon-api/issues/660
+  const child = spawnSync(process.execPath, [
+    __filename, 'child', bindingName
+  ]);
+  assert.strictEqual(child.signal, null);
+  assert.strictEqual(child.status, 0);
+}

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

@@ -0,0 +1,19 @@
+'use strict';
+const path = require('path');
+const { Worker, isMainThread, workerData } = require('worker_threads');
+
+module.exports = require('./common').runTestWithBuildType(test);
+
+async function test(buildType) {
+  if (isMainThread) {
+    const buildType = process.config.target_defaults.default_configuration;
+    const worker = new Worker(__filename, { workerData: buildType });
+    return new Promise((resolve, reject) => {
+      worker.on('exit', () => {
+        resolve();
+      });
+    }, () => {});
+  } else {
+    await require(path.join(__dirname, 'objectwrap.js'));
+  }
+}

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

@@ -0,0 +1,29 @@
+#include "napi.h"
+
+using namespace Napi;
+
+Value IsPromise(const CallbackInfo& info) {
+  return Boolean::New(info.Env(), info[0].IsPromise());
+}
+
+Value ResolvePromise(const CallbackInfo& info) {
+  auto deferred = Promise::Deferred::New(info.Env());
+  deferred.Resolve(info[0]);
+  return deferred.Promise();
+}
+
+Value RejectPromise(const CallbackInfo& info) {
+  auto deferred = Promise::Deferred::New(info.Env());
+  deferred.Reject(info[0]);
+  return deferred.Promise();
+}
+
+Object InitPromise(Env env) {
+  Object exports = Object::New(env);
+
+  exports["isPromise"] = Function::New(env, IsPromise);
+  exports["resolvePromise"] = Function::New(env, ResolvePromise);
+  exports["rejectPromise"] = Function::New(env, RejectPromise);
+
+  return exports;
+}

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

@@ -0,0 +1,18 @@
+'use strict';
+
+const assert = require('assert');
+const common = require('./common');
+
+module.exports = common.runTest(test);
+
+async function test(binding) {
+  assert.strictEqual(binding.promise.isPromise({}), false);
+
+  const resolving = binding.promise.resolvePromise('resolved');
+  await assert.strictEqual(binding.promise.isPromise(resolving), true);
+  resolving.then(common.mustCall()).catch(common.mustNotCall());
+
+  const rejecting = binding.promise.rejectPromise('error');
+  await assert.strictEqual(binding.promise.isPromise(rejecting), true);
+  rejecting.then(common.mustNotCall()).catch(common.mustCall());
+}

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

@@ -0,0 +1,24 @@
+#include "napi.h"
+
+using namespace Napi;
+
+static Reference<Buffer<uint8_t>> weak;
+
+void  CreateWeakArray(const CallbackInfo& info) {
+  weak = Weak(Buffer<uint8_t>::New(info.Env(), 1));
+  weak.SuppressDestruct();
+}
+
+napi_value AccessWeakArrayEmpty(const CallbackInfo& info) {
+  Buffer<uint8_t> value = weak.Value();
+  return Napi::Boolean::New(info.Env(), value.IsEmpty());
+}
+
+Object InitReference(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createWeakArray"] = Function::New(env, CreateWeakArray);
+  exports["accessWeakArrayEmpty"] = Function::New(env, AccessWeakArrayEmpty);
+
+  return exports;
+}

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

@@ -0,0 +1,14 @@
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('./testUtil');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  return testUtil.runGCTests([
+    'test reference',
+    () => binding.reference.createWeakArray(),
+    () => assert.strictEqual(true, binding.reference.accessWeakArrayEmpty())
+  ]);
+};

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

@@ -0,0 +1,56 @@
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+namespace {
+
+Value RunPlainString(const CallbackInfo& info) {
+  Env env = info.Env();
+  return MaybeUnwrap(env.RunScript("1 + 2 + 3"));
+}
+
+Value RunStdString(const CallbackInfo& info) {
+  Env env = info.Env();
+  std::string str = "1 + 2 + 3";
+  return MaybeUnwrap(env.RunScript(str));
+}
+
+Value RunJsString(const CallbackInfo& info) {
+  Env env = info.Env();
+  return MaybeUnwrapOr(env.RunScript(info[0].As<String>()), Value());
+}
+
+Value RunWithContext(const CallbackInfo& info) {
+  Env env = info.Env();
+
+  Array keys = MaybeUnwrap(info[1].As<Object>().GetPropertyNames());
+  std::string code = "(";
+  for (unsigned int i = 0; i < keys.Length(); i++) {
+    if (i != 0) code += ",";
+    code += MaybeUnwrap(keys.Get(i)).As<String>().Utf8Value();
+  }
+  code += ") => " + info[0].As<String>().Utf8Value();
+
+  Value ret = MaybeUnwrap(env.RunScript(code));
+  Function fn = ret.As<Function>();
+  std::vector<napi_value> args;
+  for (unsigned int i = 0; i < keys.Length(); i++) {
+    Value key = MaybeUnwrap(keys.Get(i));
+    args.push_back(MaybeUnwrap(info[1].As<Object>().Get(key)));
+  }
+  return MaybeUnwrap(fn.Call(args));
+}
+
+} // end anonymous namespace
+
+Object InitRunScript(Env env) {
+  Object exports = Object::New(env);
+
+  exports["plainString"] = Function::New(env, RunPlainString);
+  exports["stdString"] = Function::New(env, RunStdString);
+  exports["jsString"] = Function::New(env, RunJsString);
+  exports["withContext"] = Function::New(env, RunWithContext);
+
+  return exports;
+}

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

@@ -0,0 +1,45 @@
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('./testUtil');
+
+module.exports = require('./common').runTest(test);
+
+function test (binding) {
+  return testUtil.runGCTests([
+    'Plain C string',
+    () => {
+      const sum = binding.run_script.plainString();
+      assert.strictEqual(sum, 1 + 2 + 3);
+    },
+
+    'std::string',
+    () => {
+      const sum = binding.run_script.stdString();
+      assert.strictEqual(sum, 1 + 2 + 3);
+    },
+
+    'JavaScript string',
+    () => {
+      const sum = binding.run_script.jsString('1 + 2 + 3');
+      assert.strictEqual(sum, 1 + 2 + 3);
+    },
+
+    'JavaScript, but not a string',
+    () => {
+      assert.throws(() => {
+        binding.run_script.jsString(true);
+      }, {
+        name: 'TypeError',
+        message: 'A string was expected'
+      });
+    },
+
+    'With context',
+    () => {
+      const a = 1; const b = 2; const c = 3;
+      const sum = binding.run_script.withContext('a + b + c', { a, b, c });
+      assert.strictEqual(sum, a + b + c);
+    }
+  ]);
+}

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

@@ -0,0 +1,79 @@
+#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

@@ -0,0 +1,73 @@
+'use strict';
+
+const buildType = process.config.target_defaults.default_configuration;
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+
+function test(binding)
+{
+    const majorNodeVersion = process.versions.node.split('.')[0];
+
+    let 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);
+
+    assert(binding.symbol.testNullSymbolCanBeCreated() === binding.symbol.testNullSymbolCanBeCreated());
+    assert(binding.symbol.testUndefinedSymbolCanBeCreated() === binding.symbol.testUndefinedSymbolCanBeCreated());
+    assert(binding.symbol.testUndefinedSymbolCanBeCreated() !== binding.symbol.testNullSymbolCanBeCreated());
+}

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

@@ -0,0 +1,54 @@
+// 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

@@ -0,0 +1,195 @@
+#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