koffi 2.16.0-beta.2 → 2.16.0

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

@@ -1,111 +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);
-
-const napiVersion = Number(process.env.NAPI_VERSION ?? process.versions.napi);
-
-function test (bindingPath) {
-  const binding = require(bindingPath);
-  binding.error.testErrorCopySemantics();
-  binding.error.testErrorMoveSemantics();
-
-  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.throwTypeErrorCStr('test'), function (err) {
-    return err instanceof TypeError && err.message === 'test';
-  });
-
-  assert.throws(() => binding.error.throwRangeErrorCStr('test'), function (err) {
-    return err instanceof RangeError && err.message === 'test';
-  });
-
-  assert.throws(() => binding.error.throwRangeError('test'), function (err) {
-    return err instanceof RangeError && err.message === 'test';
-  });
-
-  assert.throws(() => binding.error.throwTypeErrorCtor(new TypeError('jsTypeError')), function (err) {
-    return err instanceof TypeError && err.message === 'jsTypeError';
-  });
-
-  assert.throws(() => binding.error.throwRangeErrorCtor(new RangeError('rangeTypeError')), function (err) {
-    return err instanceof RangeError && err.message === 'rangeTypeError';
-  });
-
-  if (napiVersion > 8) {
-    assert.throws(() => binding.error.throwSyntaxErrorCStr('test'), function (err) {
-      return err instanceof SyntaxError && err.message === 'test';
-    });
-
-    assert.throws(() => binding.error.throwSyntaxError('test'), function (err) {
-      return err instanceof SyntaxError && err.message === 'test';
-    });
-
-    assert.throws(() => binding.error.throwSyntaxErrorCtor(new SyntaxError('syntaxTypeError')), function (err) {
-      return err instanceof SyntaxError && err.message === 'syntaxTypeError';
-    });
-  }
-
-  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,99 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const { whichBuildType } = require('./common');
-
-// These tests ensure that Error types can be used in a terminating
-// environment without triggering any fatal errors.
-
-if (process.argv[2] === 'runInChildProcess') {
-  const bindingPath = process.argv[3];
-  const indexForTestCase = Number(process.argv[4]);
-
-  const binding = require(bindingPath);
-
-  // 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',
-        bindingPath,
-        indexForTestCase
-      ]
-    }
-  );
-
-  binding.error.waitForWorkerThread();
-
-  worker.terminate();
-
-  binding.error.releaseWorkerThread();
-} else {
-  if (process.argv[2] === 'runInWorkerThread') {
-    const bindingPath = process.argv[3];
-    const indexForTestCase = Number(process.argv[4]);
-
-    const binding = require(bindingPath);
-
-    switch (indexForTestCase) {
-      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');
-  }
-
-  wrapTest();
-
-  async function wrapTest () {
-    const buildType = await whichBuildType();
-    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, processShouldAbort) {
-    const numberOfTestCases = 5;
-
-    for (let i = 0; i < numberOfTestCases; ++i) {
-      const childProcess = require('./napi_child').spawnSync(
-        process.execPath,
-        [
-          __filename,
-          'runInChildProcess',
-          bindingPath,
-          i
-        ]
-      );
-
-      if (processShouldAbort) {
-        assert(childProcess.status !== 0, `Test case ${bindingPath} ${i} failed: Process exited with status code 0.`);
-      } else {
-        assert(childProcess.status === 0, `Test case ${bindingPath} ${i} failed: Process status ${childProcess.status} is non-zero`);
-      }
-    }
-  }
-}

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

@@ -1,22 +0,0 @@
-#include <stdexcept>
-#include "napi.h"
-
-using namespace Napi;
-
-void ThrowStdException(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-  throw std::runtime_error(message);
-}
-
-void ThrowPrimitiveException(const CallbackInfo&) {
-  throw 0;
-}
-
-Object Init(Env env, Object exports) {
-  exports.Set("throwStdException", Napi::Function::New(env, ThrowStdException));
-  exports.Set("throwPrimitiveException",
-              Napi::Function::New(env, ThrowPrimitiveException));
-  return exports;
-}
-
-NODE_API_MODULE(addon, Init)

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

@@ -1,14 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTestWithBuildType(test);
-
-function test (buildType) {
-  const binding = require(`./build/${buildType}/binding_except_all.node`);
-
-  const message = 'error message';
-  assert.throws(binding.throwStdException.bind(undefined, message), { message });
-
-  assert.throws(binding.throwPrimitiveException.bind(undefined), { message: 'A native exception was thrown' });
-}

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

@@ -1,19 +0,0 @@
-'use strict';
-
-const { strictEqual } = require('assert');
-const { valid } = require('semver');
-
-const nodeAddonApi = require('../');
-
-module.exports = function test () {
-  strictEqual(nodeAddonApi.include.startsWith('"'), true);
-  strictEqual(nodeAddonApi.include.endsWith('"'), true);
-  strictEqual(nodeAddonApi.include.includes('node-addon-api'), true);
-  strictEqual(nodeAddonApi.include_dir, '');
-  strictEqual(nodeAddonApi.gyp, 'node_api.gyp:nothing');
-  strictEqual(nodeAddonApi.targets, 'node_addon_api.gyp');
-  strictEqual(valid(nodeAddonApi.version), true);
-  strictEqual(nodeAddonApi.version, require('../package.json').version);
-  strictEqual(nodeAddonApi.isNodeApiBuiltin, true);
-  strictEqual(nodeAddonApi.needsFlag, false);
-};

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

@@ -1,85 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-namespace {
-
-int testData = 1;
-int finalizeCount = 0;
-
-Value CreateExternal(const CallbackInfo& info) {
-  finalizeCount = 0;
-  return External<int>::New(info.Env(), &testData);
-}
-
-Value CreateExternalWithFinalize(const CallbackInfo& info) {
-  finalizeCount = 0;
-  return External<int>::New(info.Env(), new int(1), [](Env /*env*/, int* data) {
-    delete data;
-    finalizeCount++;
-  });
-}
-
-Value CreateExternalWithFinalizeHint(const CallbackInfo& info) {
-  finalizeCount = 0;
-  char* hint = nullptr;
-  return External<int>::New(
-      info.Env(),
-      new int(1),
-      [](Env /*env*/, int* data, char* /*hint*/) {
-        delete data;
-        finalizeCount++;
-      },
-      hint);
-}
-
-void CheckExternal(const CallbackInfo& info) {
-  Value arg = info[0];
-  if (arg.Type() != napi_external) {
-    Error::New(info.Env(), "An external argument was expected.")
-        .ThrowAsJavaScriptException();
-    return;
-  }
-
-  External<int> external = arg.As<External<int>>();
-  int* externalData = external.Data();
-  if (externalData == nullptr || *externalData != 1) {
-    Error::New(info.Env(), "An external value of 1 was expected.")
-        .ThrowAsJavaScriptException();
-    return;
-  }
-}
-
-Value GetFinalizeCount(const CallbackInfo& info) {
-  return Number::New(info.Env(), finalizeCount);
-}
-
-Value CreateExternalWithFinalizeException(const CallbackInfo& info) {
-  return External<int>::New(info.Env(), new int(1), [](Env env, int* data) {
-    Error error = Error::New(env, "Finalizer exception");
-    delete data;
-#ifdef NAPI_CPP_EXCEPTIONS
-    throw error;
-#else
-      error.ThrowAsJavaScriptException();
-#endif
-  });
-}
-
-}  // end anonymous namespace
-
-Object InitExternal(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createExternal"] = Function::New(env, CreateExternal);
-  exports["createExternalWithFinalize"] =
-      Function::New(env, CreateExternalWithFinalize);
-  exports["createExternalWithFinalizeException"] =
-      Function::New(env, CreateExternalWithFinalizeException);
-  exports["createExternalWithFinalizeHint"] =
-      Function::New(env, CreateExternalWithFinalizeHint);
-  exports["checkExternal"] = Function::New(env, CheckExternal);
-  exports["getFinalizeCount"] = Function::New(env, GetFinalizeCount);
-
-  return exports;
-}

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

@@ -1,85 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const { spawnSync } = require('child_process');
-const testUtil = require('./testUtil');
-
-if (process.argv.length === 3) {
-  let interval;
-
-  // Running as the child process, hook up an `uncaughtException` handler to
-  // examine the error thrown by the finalizer.
-  process.on('uncaughtException', (error) => {
-    // TODO (gabrielschulhof): Use assert.matches() when we drop support for
-    // Node.js v10.x.
-    assert(!!error.message.match(/Finalizer exception/));
-    if (interval) {
-      clearInterval(interval);
-    }
-    process.exit(0);
-  });
-
-  // Create an external whose finalizer throws.
-  (() =>
-    require(process.argv[2]).external.createExternalWithFinalizeException())();
-
-  // gc until the external's finalizer throws or until we give up. Since the
-  // exception is thrown from a native `SetImmediate()` we cannot catch it
-  // anywhere except in the process' `uncaughtException` handler.
-  let maxGCTries = 10;
-  (function gcInterval () {
-    global.gc();
-    if (!interval) {
-      interval = setInterval(gcInterval, 100);
-    } else if (--maxGCTries === 0) {
-      throw new Error('Timed out waiting for the gc to throw');
-    }
-  })();
-} else {
-  module.exports = require('./common').runTestWithBindingPath(test);
-
-  function test (bindingPath) {
-    const binding = require(bindingPath);
-
-    const child = spawnSync(process.execPath, [
-      '--expose-gc', __filename, bindingPath
-    ], { stdio: 'inherit' });
-    assert.strictEqual(child.status, 0);
-    assert.strictEqual(child.signal, null);
-
-    return testUtil.runGCTests([
-      'External without finalizer',
-      () => {
-        const test = binding.external.createExternal();
-        assert.strictEqual(typeof test, 'object');
-        binding.external.checkExternal(test);
-        assert.strictEqual(0, binding.external.getFinalizeCount());
-      },
-      () => {
-        assert.strictEqual(0, binding.external.getFinalizeCount());
-      },
-
-      'External with finalizer',
-      () => {
-        const test = binding.external.createExternalWithFinalize();
-        assert.strictEqual(typeof test, 'object');
-        binding.external.checkExternal(test);
-        assert.strictEqual(0, binding.external.getFinalizeCount());
-      },
-      () => {
-        assert.strictEqual(1, binding.external.getFinalizeCount());
-      },
-
-      'External with finalizer hint',
-      () => {
-        const test = binding.external.createExternalWithFinalizeHint();
-        assert.strictEqual(typeof test, 'object');
-        binding.external.checkExternal(test);
-        assert.strictEqual(0, binding.external.getFinalizeCount());
-      },
-      () => {
-        assert.strictEqual(1, binding.external.getFinalizeCount());
-      }
-    ]);
-  }
-}

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

@@ -1,152 +0,0 @@
-#include <napi.h>
-
-namespace {
-class Test : public Napi::ObjectWrap<Test> {
- public:
-  Test(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Test>(info) {
-    basicFinalizerCalled = false;
-    finalizerCalled = false;
-
-    if (info.Length() > 0) {
-      finalizeCb_ = Napi::Persistent(info[0].As<Napi::Function>());
-    }
-  }
-
-  static void Initialize(Napi::Env env, Napi::Object exports) {
-    exports.Set("Test",
-                DefineClass(env,
-                            "Test",
-                            {
-                                StaticAccessor("isBasicFinalizerCalled",
-                                               &IsBasicFinalizerCalled,
-                                               nullptr,
-                                               napi_default),
-                                StaticAccessor("isFinalizerCalled",
-                                               &IsFinalizerCalled,
-                                               nullptr,
-                                               napi_default),
-                            }));
-  }
-
-  void Finalize(Napi::BasicEnv /*env*/) { basicFinalizerCalled = true; }
-
-  void Finalize(Napi::Env /*env*/) {
-    finalizerCalled = true;
-    if (!finalizeCb_.IsEmpty()) {
-      finalizeCb_.Call({});
-    }
-  }
-
-  static Napi::Value IsBasicFinalizerCalled(const Napi::CallbackInfo& info) {
-    return Napi::Boolean::New(info.Env(), basicFinalizerCalled);
-  }
-
-  static Napi::Value IsFinalizerCalled(const Napi::CallbackInfo& info) {
-    return Napi::Boolean::New(info.Env(), finalizerCalled);
-  }
-
- private:
-  Napi::FunctionReference finalizeCb_;
-
-  static bool basicFinalizerCalled;
-  static bool finalizerCalled;
-};
-
-bool Test::basicFinalizerCalled = false;
-bool Test::finalizerCalled = false;
-
-bool externalBasicFinalizerCalled = false;
-bool externalFinalizerCalled = false;
-
-Napi::Value CreateExternalBasicFinalizer(const Napi::CallbackInfo& info) {
-  externalBasicFinalizerCalled = false;
-  return Napi::External<int>::New(
-      info.Env(), new int(1), [](Napi::BasicEnv /*env*/, int* data) {
-        externalBasicFinalizerCalled = true;
-        delete data;
-      });
-}
-
-Napi::Value CreateExternalFinalizer(const Napi::CallbackInfo& info) {
-  externalFinalizerCalled = false;
-  return Napi::External<int>::New(
-      info.Env(), new int(1), [](Napi::Env /*env*/, int* data) {
-        externalFinalizerCalled = true;
-        delete data;
-      });
-}
-
-Napi::Value isExternalBasicFinalizerCalled(const Napi::CallbackInfo& info) {
-  return Napi::Boolean::New(info.Env(), externalBasicFinalizerCalled);
-}
-
-Napi::Value IsExternalFinalizerCalled(const Napi::CallbackInfo& info) {
-  return Napi::Boolean::New(info.Env(), externalFinalizerCalled);
-}
-
-#ifdef NODE_API_EXPERIMENTAL_HAS_POST_FINALIZER
-Napi::Value PostFinalizer(const Napi::CallbackInfo& info) {
-  auto env = info.Env();
-
-  env.PostFinalizer([callback = Napi::Persistent(info[0].As<Napi::Function>())](
-                        Napi::Env /*env*/) { callback.Call({}); });
-
-  return env.Undefined();
-}
-
-Napi::Value PostFinalizerWithData(const Napi::CallbackInfo& info) {
-  auto env = info.Env();
-
-  env.PostFinalizer(
-      [callback = Napi::Persistent(info[0].As<Napi::Function>())](
-          Napi::Env /*env*/, Napi::Reference<Napi::Value>* data) {
-        callback.Call({data->Value()});
-        delete data;
-      },
-      new Napi::Reference<Napi::Value>(Napi::Persistent(info[1])));
-
-  return env.Undefined();
-}
-
-Napi::Value PostFinalizerWithDataAndHint(const Napi::CallbackInfo& info) {
-  auto env = info.Env();
-
-  env.PostFinalizer(
-      [callback = Napi::Persistent(info[0].As<Napi::Function>())](
-          Napi::Env /*env*/,
-          Napi::Reference<Napi::Value>* data,
-          Napi::Reference<Napi::Value>* hint) {
-        callback.Call({data->Value(), hint->Value()});
-        delete data;
-        delete hint;
-      },
-      new Napi::Reference<Napi::Value>(Napi::Persistent(info[1])),
-      new Napi::Reference<Napi::Value>(Napi::Persistent(info[2])));
-
-  return env.Undefined();
-}
-#endif
-
-}  // namespace
-
-Napi::Object InitFinalizerOrder(Napi::Env env) {
-  Napi::Object exports = Napi::Object::New(env);
-  Test::Initialize(env, exports);
-  exports["createExternalBasicFinalizer"] =
-      Napi::Function::New(env, CreateExternalBasicFinalizer);
-  exports["createExternalFinalizer"] =
-      Napi::Function::New(env, CreateExternalFinalizer);
-  exports["isExternalBasicFinalizerCalled"] =
-      Napi::Function::New(env, isExternalBasicFinalizerCalled);
-  exports["isExternalFinalizerCalled"] =
-      Napi::Function::New(env, IsExternalFinalizerCalled);
-
-#ifdef NODE_API_EXPERIMENTAL_HAS_POST_FINALIZER
-  exports["PostFinalizer"] = Napi::Function::New(env, PostFinalizer);
-  exports["PostFinalizerWithData"] =
-      Napi::Function::New(env, PostFinalizerWithData);
-  exports["PostFinalizerWithDataAndHint"] =
-      Napi::Function::New(env, PostFinalizerWithDataAndHint);
-#endif
-  return exports;
-}