koffi 1.0.5 → 1.1.0-beta.0

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

@@ -1,88 +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;
-
-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();
-
-  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,56 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-if (process.argv[2] === 'runInChildProcess') {
-    const binding_path = process.argv[3];
-    const remove_hooks = process.argv[4] === 'true';
-
-    const binding = require(binding_path);
-    const actualAdded = binding.env_cleanup.addHooks(remove_hooks);
-    const expectedAdded = remove_hooks === true ? 0 : 8;
-    assert(actualAdded === expectedAdded, 'Incorrect number of hooks added');
-}
-else {
-    module.exports = require('./common').runTestWithBindingPath(test);
-}
-
-function test(bindingPath) {
-    for (const remove_hooks of [false, true]) {
-        const { status, output } = require('./napi_child').spawnSync(
-            process.execPath,
-            [
-                __filename,
-                'runInChildProcess',
-                bindingPath,
-                remove_hooks,
-            ],
-            { 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 (remove_hooks) {
-            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/error.cc

@@ -1,287 +0,0 @@
-#include <future>
-#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));
-}
-
-#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 ThrowTypeError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw TypeError::New(info.Env(), message);
-}
-
-void ThrowRangeError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw RangeError::New(info.Env(), message);
-}
-
-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 ThrowRangeError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  RangeError::New(info.Env(), message).ThrowAsJavaScriptException();
-}
-
-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["lastExceptionErrorCode"] =
-      Function::New(env, LastExceptionErrorCode);
-  exports["throwJSError"] = Function::New(env, ThrowJSError);
-  exports["throwTypeError"] = Function::New(env, ThrowTypeError);
-  exports["throwRangeError"] = Function::New(env, ThrowRangeError);
-  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;
-}

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

@@ -1,81 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-if (process.argv[2] === 'fatal') {
-  const binding = require(process.argv[3]);
-  binding.error.throwFatalError();
-}
-
-module.exports = require('./common').runTestWithBindingPath(test);
-
-function test (bindingPath) {
-  const binding = require(bindingPath);
-
-  assert.throws(() => binding.error.throwApiError('test'), function (err) {
-    return err instanceof Error && err.message.includes('Invalid');
-  });
-
-  assert.throws(() => binding.error.lastExceptionErrorCode(), function (err) {
-    return err instanceof TypeError && err.message === 'A boolean was expected';
-  });
-
-  assert.throws(() => binding.error.throwJSError('test'), function (err) {
-    return err instanceof Error && err.message === 'test';
-  });
-
-  assert.throws(() => binding.error.throwTypeError('test'), function (err) {
-    return err instanceof TypeError && err.message === 'test';
-  });
-
-  assert.throws(() => binding.error.throwRangeError('test'), function (err) {
-    return err instanceof RangeError && err.message === 'test';
-  });
-
-  assert.throws(
-    () => binding.error.doNotCatch(
-      () => {
-        throw new TypeError('test');
-      }),
-    function (err) {
-      return err instanceof TypeError && err.message === 'test' && !err.caught;
-    });
-
-  assert.throws(
-    () => binding.error.catchAndRethrowError(
-      () => {
-        throw new TypeError('test');
-      }),
-    function (err) {
-      return err instanceof TypeError && err.message === 'test' && err.caught;
-    });
-
-  const err = binding.error.catchError(
-    () => { throw new TypeError('test'); });
-  assert(err instanceof TypeError);
-  assert.strictEqual(err.message, 'test');
-
-  const msg = binding.error.catchErrorMessage(
-    () => { throw new TypeError('test'); });
-  assert.strictEqual(msg, 'test');
-
-  assert.throws(() => binding.error.throwErrorThatEscapesScope('test'), function (err) {
-    return err instanceof Error && err.message === 'test';
-  });
-
-  assert.throws(() => binding.error.catchAndRethrowErrorThatEscapesScope('test'), function (err) {
-    return err instanceof Error && err.message === 'test' && err.caught;
-  });
-
-  const p = require('./napi_child').spawnSync(
-    process.execPath, [__filename, 'fatal', bindingPath]);
-  assert.ifError(p.error);
-  assert.ok(p.stderr.toString().includes(
-    'FATAL ERROR: Error::ThrowFatalError This is a fatal error'));
-
-  assert.throws(() => binding.error.throwDefaultError(false),
-    /Cannot convert undefined or null to object/);
-
-  assert.throws(() => binding.error.throwDefaultError(true),
-    /A number was expected/);
-}

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

@@ -1,13 +0,0 @@
-#include <napi.h>
-
-namespace {
-void Test(const Napi::CallbackInfo& info) {
-  info[0].As<Napi::Function>().Call({});
-}
-
-}  // namespace
-Napi::Object InitErrorHandlingPrim(Napi::Env env) {
-  Napi::Object exports = Napi::Object::New(env);
-  exports.Set("errorHandlingPrim", Napi::Function::New<Test>(env));
-  return exports;
-}

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

@@ -1,29 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest((binding) => {
-  test(binding.errorHandlingPrim);
-});
-
-function canThrow (binding, errorMessage, errorType) {
-  try {
-    binding.errorHandlingPrim(() => {
-      throw errorMessage;
-    });
-  } catch (e) {
-    // eslint-disable-next-line valid-typeof
-    assert(typeof e === errorType);
-    assert(e === errorMessage);
-  }
-}
-
-function test (binding) {
-  canThrow(binding, '404 server not found!', 'string');
-  canThrow(binding, 42, 'number');
-  canThrow(binding, Symbol.for('newSym'), 'symbol');
-  canThrow(binding, false, 'boolean');
-  canThrow(binding, BigInt(123), 'bigint');
-  canThrow(binding, () => { console.log('Logger shutdown incorrectly'); }, 'function');
-  canThrow(binding, { status: 403, errorMsg: 'Not authenticated' }, 'object');
-}

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

@@ -1,95 +0,0 @@
-'use strict';
-const buildType = process.config.target_defaults.default_configuration;
-const assert = require('assert');
-
-// These tests ensure that Error types can be used in a terminating
-// environment without triggering any fatal errors.
-
-if (process.argv[2] === 'runInChildProcess') {
-  const binding_path = process.argv[3];
-  const index_for_test_case = Number(process.argv[4]);
-
-  const binding = require(binding_path);
-
-  // Use C++ promises to ensure the worker thread is terminated right
-  // before running the testable code in the binding.
-
-  binding.error.resetPromises()
-
-  const { Worker } = require('worker_threads');
-
-  const worker = new Worker(
-    __filename,
-    {
-      argv: [
-        'runInWorkerThread',
-        binding_path,
-        index_for_test_case,
-      ]
-    }
-  );
-
-  binding.error.waitForWorkerThread()
-
-  worker.terminate();
-
-  binding.error.releaseWorkerThread()
-
-  return;
-}
-
-if (process.argv[2] === 'runInWorkerThread') {
-  const binding_path = process.argv[3];
-  const index_for_test_case = Number(process.argv[4]);
-
-  const binding = require(binding_path);
-
-  switch (index_for_test_case) {
-    case 0:
-      binding.error.throwJSError('test', true);
-      break;
-    case 1:
-      binding.error.throwTypeError('test', true);
-      break;
-    case 2:
-      binding.error.throwRangeError('test', true);
-      break;
-    case 3:
-      binding.error.throwDefaultError(false, true);
-      break;
-    case 4:
-      binding.error.throwDefaultError(true, true);
-      break;
-    default: assert.fail('Invalid index');
-  }
-
-  assert.fail('This should not be reachable');
-}
-
-test(`./build/${buildType}/binding.node`, true);
-test(`./build/${buildType}/binding_noexcept.node`, true);
-test(`./build/${buildType}/binding_swallowexcept.node`, false);
-test(`./build/${buildType}/binding_swallowexcept_noexcept.node`, false);
-test(`./build/${buildType}/binding_custom_namespace.node`, true);
-
-function test(bindingPath, process_should_abort) {
-  const number_of_test_cases = 5;
-
-  for (let i = 0; i < number_of_test_cases; ++i) {
-    const child_process = require('./napi_child').spawnSync(
-      process.execPath,
-      [
-        __filename,
-        'runInChildProcess',
-        bindingPath,
-        i,
-      ]
-    );
-
-    if (process_should_abort) {
-      assert(child_process.status !== 0, `Test case ${bindingPath} ${i} failed: Process exited with status code 0.`);
-    } else {
-      assert(child_process.status === 0, `Test case ${bindingPath} ${i} failed: Process status ${child_process.status} is non-zero`);
-    }
-  }
-}