koffi 2.16.0-beta.2 → 2.16.1

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

@@ -1,6 +0,0 @@
-'use strict';
-
-module.exports = require('./common').runTestInChildProcess({
-  suite: 'objectwrap_function',
-  testName: 'runTest'
-});

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

@@ -1,30 +0,0 @@
-#include <napi.h>
-
-class TestMIBase {
- public:
-  TestMIBase() : test(0) {}
-  virtual void dummy() {}
-  uint32_t test;
-};
-
-class TestMI : public TestMIBase, public Napi::ObjectWrap<TestMI> {
- public:
-  TestMI(const Napi::CallbackInfo& info) : Napi::ObjectWrap<TestMI>(info) {}
-
-  Napi::Value GetTest(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), test);
-  }
-
-  static void Initialize(Napi::Env env, Napi::Object exports) {
-    exports.Set(
-        "TestMI",
-        DefineClass(
-            env, "TestMI", {InstanceAccessor<&TestMI::GetTest>("test")}));
-  }
-};
-
-Napi::Object InitObjectWrapMultipleInheritance(Napi::Env env) {
-  Napi::Object exports = Napi::Object::New(env);
-  TestMI::Initialize(env, exports);
-  return exports;
-}

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

@@ -1,13 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-const test = bindingName => {
-  const binding = require(bindingName);
-  const TestMI = binding.objectwrap_multiple_inheritance.TestMI;
-  const testmi = new TestMI();
-
-  assert.strictEqual(testmi.test, 0);
-};
-
-module.exports = require('./common').runTestWithBindingPath(test);

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

@@ -1,45 +0,0 @@
-#include <assert.h>
-#include <napi.h>
-
-namespace {
-
-static int dtor_called = 0;
-
-class DtorCounter {
- public:
-  ~DtorCounter() {
-    assert(dtor_called == 0);
-    dtor_called++;
-  }
-};
-
-Napi::Value GetDtorCalled(const Napi::CallbackInfo& info) {
-  return Napi::Number::New(info.Env(), dtor_called);
-}
-
-class Test : public Napi::ObjectWrap<Test> {
- public:
-  Test(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Test>(info) {
-#ifdef NAPI_CPP_EXCEPTIONS
-    throw Napi::Error::New(Env(), "Some error");
-#else
-    Napi::Error::New(Env(), "Some error").ThrowAsJavaScriptException();
-#endif
-  }
-
-  static void Initialize(Napi::Env env, Napi::Object exports) {
-    exports.Set("Test", DefineClass(env, "Test", {}));
-    exports.Set("getDtorCalled", Napi::Function::New(env, GetDtorCalled));
-  }
-
- private:
-  DtorCounter dtor_counter_;
-};
-
-}  // anonymous namespace
-
-Napi::Object InitObjectWrapRemoveWrap(Napi::Env env) {
-  Napi::Object exports = Napi::Object::New(env);
-  Test::Initialize(env, exports);
-  return exports;
-}

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

@@ -1,32 +0,0 @@
-'use strict';
-
-if (process.argv[2] === 'child') {
-  // Create a single wrapped instance then exit.
-  // eslint-disable-next-line no-new
-  new (require(process.argv[3]).objectwrap.Test)();
-} else {
-  const assert = require('assert');
-  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(() => {
-          // eslint-disable-next-line no-new
-          new Test();
-        });
-        assert.strictEqual(getDtorCalled(), 1);
-      },
-      // Test that gc does not crash.
-      () => {}
-    ]);
-  }
-}

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

@@ -1,20 +0,0 @@
-'use strict';
-const path = require('path');
-const { Worker, isMainThread } = require('worker_threads');
-const { runTestWithBuildType, whichBuildType } = require('./common');
-
-module.exports = runTestWithBuildType(test);
-
-async function test () {
-  if (isMainThread) {
-    const buildType = await whichBuildType();
-    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

@@ -1,111 +0,0 @@
-#include "napi.h"
-#include "test_helper.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();
-}
-
-Value PromiseReturnsCorrectEnv(const CallbackInfo& info) {
-  auto deferred = Promise::Deferred::New(info.Env());
-  return Boolean::New(info.Env(), deferred.Env() == info.Env());
-}
-
-Value ThenMethodOnFulfilled(const CallbackInfo& info) {
-  auto deferred = Promise::Deferred::New(info.Env());
-  Function onFulfilled = info[0].As<Function>();
-
-  Promise resultPromise = MaybeUnwrap(deferred.Promise().Then(onFulfilled));
-
-  bool isPromise = resultPromise.IsPromise();
-  deferred.Resolve(Number::New(info.Env(), 42));
-
-  Object result = Object::New(info.Env());
-  result["isPromise"] = Boolean::New(info.Env(), isPromise);
-  result["promise"] = resultPromise;
-
-  return result;
-}
-
-Value ThenMethodOnFulfilledOnRejectedResolve(const CallbackInfo& info) {
-  auto deferred = Promise::Deferred::New(info.Env());
-  Function onFulfilled = info[0].As<Function>();
-  Function onRejected = info[1].As<Function>();
-
-  Promise resultPromise =
-      MaybeUnwrap(deferred.Promise().Then(onFulfilled, onRejected));
-
-  bool isPromise = resultPromise.IsPromise();
-  deferred.Resolve(Number::New(info.Env(), 42));
-
-  Object result = Object::New(info.Env());
-  result["isPromise"] = Boolean::New(info.Env(), isPromise);
-  result["promise"] = resultPromise;
-
-  return result;
-}
-
-Value ThenMethodOnFulfilledOnRejectedReject(const CallbackInfo& info) {
-  auto deferred = Promise::Deferred::New(info.Env());
-  Function onFulfilled = info[0].As<Function>();
-  Function onRejected = info[1].As<Function>();
-
-  Promise resultPromise =
-      MaybeUnwrap(deferred.Promise().Then(onFulfilled, onRejected));
-
-  bool isPromise = resultPromise.IsPromise();
-  deferred.Reject(String::New(info.Env(), "Rejected"));
-
-  Object result = Object::New(info.Env());
-  result["isPromise"] = Boolean::New(info.Env(), isPromise);
-  result["promise"] = resultPromise;
-
-  return result;
-}
-
-Value CatchMethod(const CallbackInfo& info) {
-  auto deferred = Promise::Deferred::New(info.Env());
-  Function onRejected = info[0].As<Function>();
-
-  Promise resultPromise = MaybeUnwrap(deferred.Promise().Catch(onRejected));
-
-  bool isPromise = resultPromise.IsPromise();
-  deferred.Reject(String::New(info.Env(), "Rejected"));
-
-  Object result = Object::New(info.Env());
-  result["isPromise"] = Boolean::New(info.Env(), isPromise);
-  result["promise"] = resultPromise;
-
-  return result;
-}
-
-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);
-  exports["promiseReturnsCorrectEnv"] =
-      Function::New(env, PromiseReturnsCorrectEnv);
-  exports["thenMethodOnFulfilled"] = Function::New(env, ThenMethodOnFulfilled);
-  exports["thenMethodOnFulfilledOnRejectedResolve"] =
-      Function::New(env, ThenMethodOnFulfilledOnRejectedResolve);
-  exports["thenMethodOnFulfilledOnRejectedReject"] =
-      Function::New(env, ThenMethodOnFulfilledOnRejectedReject);
-  exports["catchMethod"] = Function::New(env, CatchMethod);
-
-  return exports;
-}

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

@@ -1,43 +0,0 @@
-'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());
-
-  assert(binding.promise.promiseReturnsCorrectEnv());
-
-  const onFulfilled = (value) => value * 2;
-  const onRejected = (reason) => reason + '!';
-
-  const thenOnFulfilled = binding.promise.thenMethodOnFulfilled(onFulfilled);
-  assert.strictEqual(thenOnFulfilled.isPromise, true);
-  const onFulfilledValue = await thenOnFulfilled.promise;
-  assert.strictEqual(onFulfilledValue, 84);
-
-  const thenResolve = binding.promise.thenMethodOnFulfilledOnRejectedResolve(onFulfilled, onRejected);
-  assert.strictEqual(thenResolve.isPromise, true);
-  const thenResolveValue = await thenResolve.promise;
-  assert.strictEqual(thenResolveValue, 84);
-
-  const thenRejected = binding.promise.thenMethodOnFulfilledOnRejectedReject(onFulfilled, onRejected);
-  assert.strictEqual(thenRejected.isPromise, true);
-  const rejectedValue = await thenRejected.promise;
-  assert.strictEqual(rejectedValue, 'Rejected!');
-
-  const catchMethod = binding.promise.catchMethod(onRejected);
-  assert.strictEqual(catchMethod.isPromise, true);
-  const catchValue = await catchMethod.promise;
-  assert.strictEqual(catchValue, 'Rejected!');
-}

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

@@ -1,78 +0,0 @@
-#include "assert.h"
-#include "napi.h"
-#include "test_helper.h"
-using namespace Napi;
-
-static Reference<Buffer<uint8_t>> weak;
-
-static void RefMoveAssignTests(const Napi::CallbackInfo& info) {
-  Napi::Object obj = Napi::Object::New(info.Env());
-  obj.Set("tPro", "tTEST");
-  Napi::Reference<Napi::Object> ref = Napi::Reference<Napi::Object>::New(obj);
-  ref.SuppressDestruct();
-
-  napi_ref obj_ref = static_cast<napi_ref>(ref);
-  Napi::Reference<Napi::Object> existingRef =
-      Napi::Reference<Napi::Object>(info.Env(), obj_ref);
-  assert(ref == existingRef);
-  assert(!(ref != existingRef));
-
-  std::string val =
-      MaybeUnwrap(existingRef.Value().Get("tPro")).As<Napi::String>();
-  assert(val == "tTEST");
-  // ------------------------------------------------------------ //
-  Napi::Reference<Napi::Object> copyMoveRef = std::move(existingRef);
-  assert(copyMoveRef == ref);
-
-  Napi::Reference<Napi::Object> copyAssignRef;
-  copyAssignRef = std::move(copyMoveRef);
-  assert(copyAssignRef == ref);
-}
-
-static void ReferenceRefTests(const Napi::CallbackInfo& info) {
-  Napi::Object obj = Napi::Object::New(info.Env());
-  Napi::Reference<Napi::Object> ref = Napi::Reference<Napi::Object>::New(obj);
-
-  assert(ref.Ref() == 1);
-  assert(ref.Unref() == 0);
-}
-
-static void ReferenceResetTests(const Napi::CallbackInfo& info) {
-  Napi::Object obj = Napi::Object::New(info.Env());
-  Napi::Reference<Napi::Object> ref = Napi::Reference<Napi::Object>::New(obj);
-  assert(!ref.IsEmpty());
-
-  ref.Reset();
-  assert(ref.IsEmpty());
-
-  Napi::Object newObject = Napi::Object::New(info.Env());
-  newObject.Set("n-api", "node");
-
-  ref.Reset(newObject, 1);
-  assert(!ref.IsEmpty());
-
-  std::string val = MaybeUnwrap(ref.Value().Get("n-api")).As<Napi::String>();
-  assert(val == "node");
-}
-
-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);
-
-  exports["refMoveAssignTest"] = Function::New(env, RefMoveAssignTests);
-  exports["referenceRefTest"] = Function::New(env, ReferenceRefTests);
-  exports["refResetTest"] = Function::New(env, ReferenceResetTests);
-  return exports;
-}

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

@@ -1,20 +0,0 @@
-'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()),
-    'test reference move op',
-    () => binding.reference.refMoveAssignTest(),
-    'test reference ref',
-    () => binding.reference.referenceRefTest(),
-    'test reference reset',
-    () => binding.reference.refResetTest()
-  ]);
-}

package/vendor/node-addon-api/test/require_basic_finalizers/index.js

@@ -1,38 +0,0 @@
-'use strict';
-
-const { promisify } = require('util');
-const exec = promisify(require('child_process').exec);
-const { copy, remove } = require('fs-extra');
-const path = require('path');
-const assert = require('assert');
-
-async function test () {
-  const addon = 'require-basic-finalizers';
-  const ADDON_FOLDER = path.join(__dirname, 'addons', addon);
-
-  await remove(ADDON_FOLDER);
-  await copy(path.join(__dirname, 'tpl'), ADDON_FOLDER);
-
-  console.log('   >Building addon');
-
-  // Fail when NODE_ADDON_API_REQUIRE_BASIC_FINALIZERS is enabled
-  await assert.rejects(exec('npm --require-basic-finalizers install', {
-    cwd: ADDON_FOLDER
-  }), 'Addon unexpectedly compiled successfully');
-
-  // Succeed when NODE_ADDON_API_REQUIRE_BASIC_FINALIZERS is not enabled
-  return assert.doesNotReject(exec('npm install', {
-    cwd: ADDON_FOLDER
-  }));
-}
-
-module.exports = (function () {
-  // This test will only run under an experimental version test.
-  const isExperimental = Number(process.env.NAPI_VERSION) === 2147483647;
-
-  if (isExperimental) {
-    return test();
-  } else {
-    console.log('   >Skipped (non-experimental test run)');
-  }
-})();

package/vendor/node-addon-api/test/require_basic_finalizers/tpl/addon.cc

@@ -1,12 +0,0 @@
-#include <napi.h>
-
-Napi::Object Init(Napi::Env env, Napi::Object exports) {
-  exports.Set(
-      "external",
-      Napi::External<int>::New(
-          env, new int(1), [](Napi::Env /*env*/, int* data) { delete data; }));
-
-  return exports;
-}
-
-NODE_API_MODULE(NODE_GYP_MODULE_NAME, Init)

package/vendor/node-addon-api/test/require_basic_finalizers/tpl/binding.gyp

@@ -1,48 +0,0 @@
-{
-  'target_defaults': {
-    'include_dirs': [
-        "<!(node -p \"require('node-addon-api').include_dir\")"
-    ],
-    'variables': {
-      'NAPI_VERSION%': "<!(node -p \"process.env.NAPI_VERSION || process.versions.napi\")",
-      'require_basic_finalizers': "<!(node -p \"process.env['npm_config_require_basic_finalizers']\")",
-    },
-    'conditions': [
-      ['NAPI_VERSION!=""', { 'defines': ['NAPI_VERSION=<@(NAPI_VERSION)'] } ],
-      ['NAPI_VERSION==2147483647', { 'defines': ['NAPI_EXPERIMENTAL'] } ],
-      ['require_basic_finalizers=="true"', {
-        'defines': ['NODE_ADDON_API_REQUIRE_BASIC_FINALIZERS'],
-      }],
-      ['OS=="mac"', {
-        'cflags+': ['-fvisibility=hidden'],
-        'xcode_settings': {
-          'OTHER_CFLAGS': ['-fvisibility=hidden']
-        }
-      }]
-    ],
-    'sources': [
-      'addon.cc',
-    ],
-  },
-  'targets': [
-    {
-      'target_name': 'addon',
-      'defines': [
-        'NAPI_CPP_EXCEPTIONS'
-      ],
-      'cflags!': [ '-fno-exceptions' ],
-      'cflags_cc!': [ '-fno-exceptions' ],
-      'msvs_settings': {
-        'VCCLCompilerTool': {
-          'ExceptionHandling': 1,
-          'EnablePREfast': 'true',
-        },
-      },
-      'xcode_settings': {
-        'CLANG_CXX_LIBRARY': 'libc++',
-        'MACOSX_DEPLOYMENT_TARGET': '10.7',
-        'GCC_ENABLE_CPP_EXCEPTIONS': 'YES',
-      },
-    }
-  ]
-}

package/vendor/node-addon-api/test/require_basic_finalizers/tpl/index.js

@@ -1,3 +0,0 @@
-'use strict';
-
-module.exports = require('bindings')('addon');

package/vendor/node-addon-api/test/require_basic_finalizers/tpl/package.json

@@ -1,11 +0,0 @@
-{
-  "name": "addon",
-  "version": "0.0.0",
-  "description": "Node.js addon",
-  "private": true,
-  "scripts": {},
-  "dependencies": {
-    "node-addon-api": "file:../../../../"
-  },
-  "gypfile": true
-}

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

@@ -1,56 +0,0 @@
-#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].UnsafeAs<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

@@ -1,45 +0,0 @@
-'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);
-    }
-  ]);
-}