koffi 2.16.0-beta.2 → 2.16.1

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

@@ -1,100 +0,0 @@
-#include <stdio.h>
-#include "napi.h"
-
-using namespace Napi;
-
-#if (NAPI_VERSION > 2)
-namespace {
-
-static void cleanup(void* arg) {
-  printf("static cleanup(%d)\n", *(int*)(arg));
-}
-static void cleanupInt(int* arg) {
-  printf("static cleanup(%d)\n", *(arg));
-}
-
-static void cleanupVoid() {
-  printf("static cleanup()\n");
-}
-
-static int secret1 = 42;
-static int secret2 = 43;
-
-class TestClass {
- public:
-  Env::CleanupHook<void (*)(void* arg), int> hook;
-
-  void removeHook(Env env) { hook.Remove(env); }
-};
-
-Value AddHooks(const CallbackInfo& info) {
-  auto env = info.Env();
-
-  bool shouldRemove = info[0].As<Boolean>().Value();
-
-  // hook: void (*)(void *arg), hint: int
-  auto hook1 = env.AddCleanupHook(cleanup, &secret1);
-  // test using same hook+arg pair
-  auto hook1b = env.AddCleanupHook(cleanup, &secret1);
-
-  // hook: void (*)(int *arg), hint: int
-  auto hook2 = env.AddCleanupHook(cleanupInt, &secret2);
-
-  // hook: void (*)(int *arg), hint: void (default)
-  auto hook3 = env.AddCleanupHook(cleanupVoid);
-  // test using the same hook
-  auto hook3b = env.AddCleanupHook(cleanupVoid);
-
-  // hook: lambda []void (int *arg)->void, hint: int
-  auto hook4 = env.AddCleanupHook(
-      [&](int* arg) { printf("lambda cleanup(%d)\n", *arg); }, &secret1);
-
-  // hook: lambda []void (void *)->void, hint: void
-  auto hook5 =
-      env.AddCleanupHook([&](void*) { printf("lambda cleanup(void)\n"); },
-                         static_cast<void*>(nullptr));
-
-  // hook: lambda []void ()->void, hint: void (default)
-  auto hook6 = env.AddCleanupHook([&]() { printf("lambda cleanup()\n"); });
-
-  if (shouldRemove) {
-    hook1.Remove(env);
-    hook1b.Remove(env);
-    hook2.Remove(env);
-    hook3.Remove(env);
-    hook3b.Remove(env);
-    hook4.Remove(env);
-    hook5.Remove(env);
-    hook6.Remove(env);
-  }
-
-  int added = 0;
-
-  added += !hook1.IsEmpty();
-  added += !hook1b.IsEmpty();
-  added += !hook2.IsEmpty();
-  added += !hook3.IsEmpty();
-  added += !hook3b.IsEmpty();
-  added += !hook4.IsEmpty();
-  added += !hook5.IsEmpty();
-  added += !hook6.IsEmpty();
-
-  // Test store a hook in a member class variable
-  auto myclass = TestClass();
-  myclass.hook = env.AddCleanupHook(cleanup, &secret1);
-  myclass.removeHook(env);
-
-  return Number::New(env, added);
-}
-
-}  // anonymous namespace
-
-Object InitEnvCleanup(Env env) {
-  Object exports = Object::New(env);
-
-  exports["addHooks"] = Function::New(env, AddHooks);
-
-  return exports;
-}
-
-#endif

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

@@ -1,55 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-if (process.argv[2] === 'runInChildProcess') {
-  const bindingPath = process.argv[3];
-  const removeHooks = process.argv[4] === 'true';
-
-  const binding = require(bindingPath);
-  const actualAdded = binding.env_cleanup.addHooks(removeHooks);
-  const expectedAdded = removeHooks === true ? 0 : 8;
-  assert(actualAdded === expectedAdded, 'Incorrect number of hooks added');
-} else {
-  module.exports = require('./common').runTestWithBindingPath(test);
-}
-
-function test (bindingPath) {
-  for (const removeHooks of [false, true]) {
-    const { status, output } = require('./napi_child').spawnSync(
-      process.execPath,
-      [
-        __filename,
-        'runInChildProcess',
-        bindingPath,
-        removeHooks
-      ],
-      { encoding: 'utf8' }
-    );
-
-    const stdout = output[1].trim();
-    /**
-         * There is no need to sort the lines, as per Node-API documentation:
-         *  > The hooks will be called in reverse order, i.e. the most recently
-         *  > added one will be called first.
-        */
-    const lines = stdout.split(/[\r\n]+/);
-
-    assert(status === 0, `Process aborted with status ${status}`);
-
-    if (removeHooks) {
-      assert.deepStrictEqual(lines, [''], 'Child process had console output when none expected');
-    } else {
-      assert.deepStrictEqual(lines, [
-        'lambda cleanup()',
-        'lambda cleanup(void)',
-        'lambda cleanup(42)',
-        'static cleanup()',
-        'static cleanup()',
-        'static cleanup(43)',
-        'static cleanup(42)',
-        'static cleanup(42)'
-      ], 'Child process console output mismisatch');
-    }
-  }
-}

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

@@ -1,25 +0,0 @@
-#include "napi.h"
-#include "test_helper.h"
-
-#if (NAPI_VERSION > 8)
-
-using namespace Napi;
-
-namespace {
-
-Value GetModuleFileName(const CallbackInfo& info) {
-  Env env = info.Env();
-  return String::New(env, env.GetModuleFileName());
-}
-
-}  // end anonymous namespace
-
-Object InitEnvMiscellaneous(Env env) {
-  Object exports = Object::New(env);
-
-  exports["get_module_file_name"] = Function::New(env, GetModuleFileName);
-
-  return exports;
-}
-
-#endif

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

@@ -1,12 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const { pathToFileURL } = require('url');
-
-module.exports = require('./common').runTest(test);
-
-function test (binding, { bindingPath } = {}) {
-  const path = binding.env_misc.get_module_file_name();
-  const bindingFileUrl = pathToFileURL(bindingPath).toString();
-  assert(bindingFileUrl === path);
-}

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

@@ -1,436 +0,0 @@
-#include <string.h>
-#include <future>
-#include "assert.h"
-#include "napi.h"
-
-using namespace Napi;
-
-namespace {
-
-std::promise<void> promise_for_child_process_;
-std::promise<void> promise_for_worker_thread_;
-
-void ResetPromises(const CallbackInfo&) {
-  promise_for_child_process_ = std::promise<void>();
-  promise_for_worker_thread_ = std::promise<void>();
-}
-
-void WaitForWorkerThread(const CallbackInfo&) {
-  std::future<void> future = promise_for_worker_thread_.get_future();
-
-  std::future_status status = future.wait_for(std::chrono::seconds(5));
-
-  if (status != std::future_status::ready) {
-    Error::Fatal("WaitForWorkerThread", "status != std::future_status::ready");
-  }
-}
-
-void ReleaseAndWaitForChildProcess(const CallbackInfo& info,
-                                   const uint32_t index) {
-  if (info.Length() < index + 1) {
-    return;
-  }
-
-  if (!info[index].As<Boolean>().Value()) {
-    return;
-  }
-
-  promise_for_worker_thread_.set_value();
-
-  std::future<void> future = promise_for_child_process_.get_future();
-
-  std::future_status status = future.wait_for(std::chrono::seconds(5));
-
-  if (status != std::future_status::ready) {
-    Error::Fatal("ReleaseAndWaitForChildProcess",
-                 "status != std::future_status::ready");
-  }
-}
-
-void ReleaseWorkerThread(const CallbackInfo&) {
-  promise_for_child_process_.set_value();
-}
-
-void DoNotCatch(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  thrower({});
-}
-
-void ThrowApiError(const CallbackInfo& info) {
-  // Attempting to call an empty function value will throw an API error.
-  Function(info.Env(), nullptr).Call(std::initializer_list<napi_value>{});
-}
-
-void LastExceptionErrorCode(const CallbackInfo& info) {
-  // Previously, `napi_extended_error_info.error_code` got reset to `napi_ok` in
-  // subsequent Node-API function calls, so this would have previously thrown an
-  // `Error` object instead of a `TypeError` object.
-  Env env = info.Env();
-  bool res;
-  napi_get_value_bool(env, Value::From(env, "asd"), &res);
-  NAPI_THROW_VOID(Error::New(env));
-}
-
-void TestErrorCopySemantics(const Napi::CallbackInfo& info) {
-  Napi::Error newError = Napi::Error::New(info.Env(), "errorCopyCtor");
-  Napi::Error existingErr;
-
-#ifdef NAPI_CPP_EXCEPTIONS
-  std::string msg = "errorCopyCtor";
-  assert(strcmp(newError.what(), msg.c_str()) == 0);
-#endif
-
-  Napi::Error errCopyCtor = newError;
-  assert(errCopyCtor.Message() == "errorCopyCtor");
-
-  existingErr = newError;
-  assert(existingErr.Message() == "errorCopyCtor");
-}
-
-void TestErrorMoveSemantics(const Napi::CallbackInfo& info) {
-  std::string errorMsg = "errorMoveCtor";
-  Napi::Error newError = Napi::Error::New(info.Env(), errorMsg.c_str());
-  Napi::Error errFromMove = std::move(newError);
-  assert(errFromMove.Message() == "errorMoveCtor");
-
-  newError = Napi::Error::New(info.Env(), "errorMoveAssign");
-  Napi::Error existingErr = std::move(newError);
-
-  assert(existingErr.Message() == "errorMoveAssign");
-}
-
-#ifdef NAPI_CPP_EXCEPTIONS
-
-void ThrowJSError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw Error::New(info.Env(), message);
-}
-
-void ThrowTypeErrorCtor(const CallbackInfo& info) {
-  Napi::Value js_type_error = info[0];
-  ReleaseAndWaitForChildProcess(info, 1);
-
-  throw Napi::TypeError(info.Env(), js_type_error);
-}
-
-void ThrowTypeError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw TypeError::New(info.Env(), message);
-}
-
-void ThrowTypeErrorCStr(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw TypeError::New(info.Env(), message.c_str());
-}
-
-void ThrowRangeErrorCStr(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw RangeError::New(info.Env(), message.c_str());
-}
-
-void ThrowRangeErrorCtor(const CallbackInfo& info) {
-  Napi::Value js_range_err = info[0];
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw Napi::RangeError(info.Env(), js_range_err);
-}
-
-void ThrowEmptyRangeError(const CallbackInfo& info) {
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw RangeError();
-}
-
-void ThrowRangeError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw RangeError::New(info.Env(), message);
-}
-
-#if NAPI_VERSION > 8
-void ThrowSyntaxErrorCStr(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw SyntaxError::New(info.Env(), message.c_str());
-}
-
-void ThrowSyntaxErrorCtor(const CallbackInfo& info) {
-  Napi::Value js_range_err = info[0];
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw Napi::SyntaxError(info.Env(), js_range_err);
-}
-
-void ThrowSyntaxError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw SyntaxError::New(info.Env(), message);
-}
-#endif  // NAPI_VERSION > 8
-
-Value CatchError(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  try {
-    thrower({});
-  } catch (const Error& e) {
-    return e.Value();
-  }
-  return info.Env().Null();
-}
-
-Value CatchErrorMessage(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  try {
-    thrower({});
-  } catch (const Error& e) {
-    std::string message = e.Message();
-    return String::New(info.Env(), message);
-  }
-  return info.Env().Null();
-}
-
-void CatchAndRethrowError(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  try {
-    thrower({});
-  } catch (Error& e) {
-    e.Set("caught", Boolean::New(info.Env(), true));
-    throw;
-  }
-}
-
-void ThrowErrorThatEscapesScope(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-
-  std::string message = info[0].As<String>().Utf8Value();
-  throw Error::New(info.Env(), message);
-}
-
-void CatchAndRethrowErrorThatEscapesScope(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-  try {
-    ThrowErrorThatEscapesScope(info);
-  } catch (Error& e) {
-    e.Set("caught", Boolean::New(info.Env(), true));
-    throw;
-  }
-}
-
-#else  // NAPI_CPP_EXCEPTIONS
-
-void ThrowJSError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  Error::New(info.Env(), message).ThrowAsJavaScriptException();
-}
-
-void ThrowTypeError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  TypeError::New(info.Env(), message).ThrowAsJavaScriptException();
-}
-
-void ThrowTypeErrorCtor(const CallbackInfo& info) {
-  Napi::Value js_type_error = info[0];
-  ReleaseAndWaitForChildProcess(info, 1);
-  TypeError(info.Env(), js_type_error).ThrowAsJavaScriptException();
-}
-
-void ThrowTypeErrorCStr(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  TypeError::New(info.Env(), message.c_str()).ThrowAsJavaScriptException();
-}
-
-void ThrowRangeError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  RangeError::New(info.Env(), message).ThrowAsJavaScriptException();
-}
-
-void ThrowRangeErrorCtor(const CallbackInfo& info) {
-  Napi::Value js_range_err = info[0];
-  ReleaseAndWaitForChildProcess(info, 1);
-  RangeError(info.Env(), js_range_err).ThrowAsJavaScriptException();
-}
-
-void ThrowRangeErrorCStr(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-  ReleaseAndWaitForChildProcess(info, 1);
-  RangeError::New(info.Env(), message.c_str()).ThrowAsJavaScriptException();
-}
-
-// TODO: Figure out the correct api for this
-void ThrowEmptyRangeError(const CallbackInfo& info) {
-  ReleaseAndWaitForChildProcess(info, 1);
-  RangeError().ThrowAsJavaScriptException();
-}
-
-#if NAPI_VERSION > 8
-void ThrowSyntaxError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  SyntaxError::New(info.Env(), message).ThrowAsJavaScriptException();
-}
-
-void ThrowSyntaxErrorCtor(const CallbackInfo& info) {
-  Napi::Value js_range_err = info[0];
-  ReleaseAndWaitForChildProcess(info, 1);
-  SyntaxError(info.Env(), js_range_err).ThrowAsJavaScriptException();
-}
-
-void ThrowSyntaxErrorCStr(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-  ReleaseAndWaitForChildProcess(info, 1);
-  SyntaxError::New(info.Env(), message.c_str()).ThrowAsJavaScriptException();
-}
-#endif  // NAPI_VERSION > 8
-
-Value CatchError(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  thrower({});
-
-  Env env = info.Env();
-  if (env.IsExceptionPending()) {
-    Error e = env.GetAndClearPendingException();
-    return e.Value();
-  }
-  return info.Env().Null();
-}
-
-Value CatchErrorMessage(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  thrower({});
-
-  Env env = info.Env();
-  if (env.IsExceptionPending()) {
-    Error e = env.GetAndClearPendingException();
-    std::string message = e.Message();
-    return String::New(env, message);
-  }
-  return info.Env().Null();
-}
-
-void CatchAndRethrowError(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  thrower({});
-
-  Env env = info.Env();
-  if (env.IsExceptionPending()) {
-    Error e = env.GetAndClearPendingException();
-    e.Set("caught", Boolean::New(info.Env(), true));
-    e.ThrowAsJavaScriptException();
-  }
-}
-
-void ThrowErrorThatEscapesScope(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-
-  std::string message = info[0].As<String>().Utf8Value();
-  Error::New(info.Env(), message).ThrowAsJavaScriptException();
-}
-
-void CatchAndRethrowErrorThatEscapesScope(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-  ThrowErrorThatEscapesScope(info);
-
-  Env env = info.Env();
-  if (env.IsExceptionPending()) {
-    Error e = env.GetAndClearPendingException();
-    e.Set("caught", Boolean::New(info.Env(), true));
-    e.ThrowAsJavaScriptException();
-  }
-}
-
-#endif  // NAPI_CPP_EXCEPTIONS
-
-void ThrowFatalError(const CallbackInfo& /*info*/) {
-  Error::Fatal("Error::ThrowFatalError", "This is a fatal error");
-}
-
-void ThrowDefaultError(const CallbackInfo& info) {
-  napi_value dummy;
-  napi_env env = info.Env();
-  napi_status status = napi_get_undefined(env, &dummy);
-  NAPI_FATAL_IF_FAILED(status, "ThrowDefaultError", "napi_get_undefined");
-
-  if (info[0].As<Boolean>().Value()) {
-    // Provoke Node-API into setting an error, then use the `Napi::Error::New`
-    // factory with only the `env` parameter to throw an exception generated
-    // from the last error.
-    uint32_t dummy_uint32;
-    status = napi_get_value_uint32(env, dummy, &dummy_uint32);
-    if (status == napi_ok) {
-      Error::Fatal("ThrowDefaultError", "napi_get_value_uint32");
-    }
-    // We cannot use `NAPI_THROW_IF_FAILED()` here because we do not wish
-    // control to pass back to the engine if we throw an exception here and C++
-    // exceptions are turned on.
-    Napi::Error::New(env).ThrowAsJavaScriptException();
-  }
-
-  // Produce and throw a second error that has different content than the one
-  // above. If the one above was thrown, then throwing the one below should
-  // have the effect of re-throwing the one above.
-  status = napi_get_named_property(env, dummy, "xyzzy", &dummy);
-  if (status == napi_ok) {
-    Error::Fatal("ThrowDefaultError", "napi_get_named_property");
-  }
-
-  ReleaseAndWaitForChildProcess(info, 1);
-
-  // The macro creates a `Napi::Error` using the factory that takes only the
-  // env, however, it heeds the exception mechanism to be used.
-  NAPI_THROW_IF_FAILED_VOID(env, status);
-}
-
-}  // end anonymous namespace
-
-Object InitError(Env env) {
-  Object exports = Object::New(env);
-  exports["throwApiError"] = Function::New(env, ThrowApiError);
-  exports["testErrorCopySemantics"] =
-      Function::New(env, TestErrorCopySemantics);
-  exports["testErrorMoveSemantics"] =
-      Function::New(env, TestErrorMoveSemantics);
-  exports["lastExceptionErrorCode"] =
-      Function::New(env, LastExceptionErrorCode);
-  exports["throwJSError"] = Function::New(env, ThrowJSError);
-  exports["throwTypeError"] = Function::New(env, ThrowTypeError);
-  exports["throwTypeErrorCtor"] = Function::New(env, ThrowTypeErrorCtor);
-  exports["throwTypeErrorCStr"] = Function::New(env, ThrowTypeErrorCStr);
-  exports["throwRangeError"] = Function::New(env, ThrowRangeError);
-  exports["throwRangeErrorCtor"] = Function::New(env, ThrowRangeErrorCtor);
-  exports["throwRangeErrorCStr"] = Function::New(env, ThrowRangeErrorCStr);
-  exports["throwEmptyRangeError"] = Function::New(env, ThrowEmptyRangeError);
-#if NAPI_VERSION > 8
-  exports["throwSyntaxError"] = Function::New(env, ThrowSyntaxError);
-  exports["throwSyntaxErrorCtor"] = Function::New(env, ThrowSyntaxErrorCtor);
-  exports["throwSyntaxErrorCStr"] = Function::New(env, ThrowSyntaxErrorCStr);
-#endif  // NAPI_VERSION > 8
-  exports["catchError"] = Function::New(env, CatchError);
-  exports["catchErrorMessage"] = Function::New(env, CatchErrorMessage);
-  exports["doNotCatch"] = Function::New(env, DoNotCatch);
-  exports["catchAndRethrowError"] = Function::New(env, CatchAndRethrowError);
-  exports["throwErrorThatEscapesScope"] =
-      Function::New(env, ThrowErrorThatEscapesScope);
-  exports["catchAndRethrowErrorThatEscapesScope"] =
-      Function::New(env, CatchAndRethrowErrorThatEscapesScope);
-  exports["throwFatalError"] = Function::New(env, ThrowFatalError);
-  exports["throwDefaultError"] = Function::New(env, ThrowDefaultError);
-  exports["resetPromises"] = Function::New(env, ResetPromises);
-  exports["waitForWorkerThread"] = Function::New(env, WaitForWorkerThread);
-  exports["releaseWorkerThread"] = Function::New(env, ReleaseWorkerThread);
-  return exports;
-}