koffi 2.16.0-beta.2 → 2.16.1

package/vendor/node-addon-api/test/README.md

@@ -1,91 +0,0 @@
-# Writing Tests
-
-There are multiple flavors of node-addon-api test builds that cover different
-build flags defined in `napi.h`:
-
-1. c++ exceptions enabled,
-2. c++ exceptions disabled,
-3. c++ exceptions disabled, and `NODE_ADDON_API_ENABLE_MAYBE` defined.
-
-Functions in node-addon-api that call into JavaScript can have different
-declared return types to reflect build flavor settings. For example,
-`Napi::Object::Set` returns `bool` when `NODE_ADDON_API_ENABLE_MAYBE`
-is not defined, and `Napi::Maybe<bool>` when `NODE_ADDON_API_ENABLE_MAYBE`
-is defined. In source code, return type variants are defined as
-`Napi::MaybeOrValue<>` to prevent the duplication of most of the code base.
-
-To properly test these build flavors, all values returned by a function defined
-to return `Napi::MaybeOrValue<>` should be tested by using one of the following
-test helpers to handle possible JavaScript exceptions.
-
-There are three test helper functions to conveniently convert
-`Napi::MaybeOrValue<>` values to raw values.
-
-## MaybeUnwrap
-
-```cpp
-template <typename T>
-T MaybeUnwrap(MaybeOrValue<T> maybe);
-```
-
-Converts `MaybeOrValue<T>` to `T` by checking that `MaybeOrValue` is NOT an
-empty `Maybe`.
-
-Returns the original value if `NODE_ADDON_API_ENABLE_MAYBE` is not defined.
-
-Example:
-
-```cpp
-Object obj = info[0].As<Object>();
-// we are sure the parameters should not throw
-Value value = MaybeUnwrap(obj->Get("foobar"));
-```
-
-## MaybeUnwrapOr
-
-```cpp
-template <typename T>
-T MaybeUnwrapOr(MaybeOrValue<T> maybe, const T& default_value = T());
-```
-
-Converts `MaybeOrValue<T>` to `T` by getting the value that wrapped by the
-`Maybe` or return the `default_value` if the `Maybe` is empty.
-
-Returns the original value if `NODE_ADDON_API_ENABLE_MAYBE` is not defined.
-
-Example:
-
-```cpp
-Value CallWithArgs(const CallbackInfo& info) {
-  Function func = info[0].As<Function>();
-  // We don't care if the operation is throwing or not, just return it back to node-addon-api
-  return MaybeUnwrapOr(
-      func.Call(std::initializer_list<napi_value>{info[1], info[2], info[3]}));
-}
-```
-
-## MaybeUnwrapTo
-
-```cpp
-template <typename T>
-bool MaybeUnwrapTo(MaybeOrValue<T> maybe, T* out);
-```
-
-Converts `MaybeOrValue<T>` to `T` by getting the value that wrapped by the
-e`Maybe` or return `false` if the Maybe is empty
-
-Copies the `value` to `out` when `NODE_ADDON_API_ENABLE_MAYBE` is not defined
-
-Example:
-
-```cpp
-Object opts = info[0].As<Object>();
-bool hasProperty = false;
-// The check may throw, but we are going to suppress that.
-if (MaybeUnwrapTo(opts.Has("blocking"), &hasProperty)) {
-  isBlocking = hasProperty &&
-                MaybeUnwrap(MaybeUnwrap(opts.Get("blocking")).ToBoolean());
-} else {
-  env.GetAndClearPendingException();
-}
-```

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

@@ -1,44 +0,0 @@
-#if (NAPI_VERSION > 5)
-#include <stdio.h>
-#include "napi.h"
-
-namespace {
-
-class TestAddon : public Napi::Addon<TestAddon> {
- public:
-  inline TestAddon(Napi::Env env, Napi::Object exports) {
-    DefineAddon(
-        exports,
-        {InstanceMethod("increment", &TestAddon::Increment),
-         InstanceValue(
-             "subObject",
-             DefineProperties(
-                 Napi::Object::New(env),
-                 {InstanceMethod("decrement", &TestAddon::Decrement)}))});
-  }
-
-  ~TestAddon() { fprintf(stderr, "TestAddon::~TestAddon\n"); }
-
- private:
-  Napi::Value Increment(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), ++value);
-  }
-
-  Napi::Value Decrement(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), --value);
-  }
-
-  uint32_t value = 42;
-};
-
-Napi::Value CreateAddon(const Napi::CallbackInfo& info) {
-  return TestAddon::Init(info.Env(), Napi::Object::New(info.Env()));
-}
-
-}  // end of anonymous namespace
-
-Napi::Object InitAddon(Napi::Env env) {
-  return Napi::Function::New<CreateAddon>(env, "CreateAddon");
-}
-
-#endif  // (NAPI_VERSION > 5)

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

@@ -1,7 +0,0 @@
-'use strict';
-
-module.exports = require('./common').runTestInChildProcess({
-  suite: 'addon',
-  testName: 'workingCode',
-  expectedStderr: ['TestAddon::~TestAddon']
-});

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

@@ -1,49 +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');
-
-const ADDONS_FOLDER = path.join(__dirname, 'addons');
-
-const addons = [
-  'echo addon',
-  'echo-addon'
-];
-
-async function beforeAll (addons) {
-  console.log('   >Preparing native addons to build');
-  for (const addon of addons) {
-    await remove(path.join(ADDONS_FOLDER, addon));
-    await copy(path.join(__dirname, 'tpl'), path.join(ADDONS_FOLDER, addon));
-  }
-}
-
-async function test (addon) {
-  console.log(`   >Building addon: '${addon}'`);
-  await exec('npm install', {
-    cwd: path.join(ADDONS_FOLDER, addon)
-  });
-  console.log(`   >Running test for: '${addon}'`);
-  // Disabled the checks on stderr and stdout because of this issue on npm:
-  // Stop using process.umask(): https://github.com/npm/cli/issues/1103
-  // We should enable the following checks again after the resolution of
-  // the reported issue.
-  // assert.strictEqual(stderr, '');
-  // assert.ok(stderr.length === 0);
-  // assert.ok(stdout.length > 0);
-  const binding = require(`${ADDONS_FOLDER}/${addon}`);
-  assert.strictEqual(binding.except.echo('except'), 'except');
-  assert.strictEqual(binding.except.echo(101), 101);
-  assert.strictEqual(binding.noexcept.echo('noexcept'), 'noexcept');
-  assert.strictEqual(binding.noexcept.echo(103), 103);
-}
-
-module.exports = (async function () {
-  await beforeAll(addons);
-  for (const addon of addons) {
-    await test(addon);
-  }
-})();

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

@@ -1,18 +0,0 @@
-#include <napi.h>
-
-Napi::Value Echo(const Napi::CallbackInfo& info) {
-  Napi::Env env = info.Env();
-  if (info.Length() != 1) {
-    Napi::TypeError::New(env,
-                         "Wrong number of arguments. One argument expected.")
-        .ThrowAsJavaScriptException();
-  }
-  return info[0].As<Napi::Value>();
-}
-
-Napi::Object Init(Napi::Env env, Napi::Object exports) {
-  exports.Set(Napi::String::New(env, "echo"), Napi::Function::New(env, Echo));
-  return exports;
-}
-
-NODE_API_MODULE(NODE_GYP_MODULE_NAME, Init)

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

@@ -1,63 +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\")",
-      'disable_deprecated': "<!(node -p \"process.env['npm_config_disable_deprecated']\")"
-    },
-    'conditions': [
-      ['NAPI_VERSION!=""', { 'defines': ['NAPI_VERSION=<@(NAPI_VERSION)'] } ],
-      ['NAPI_VERSION==2147483647', { 'defines': ['NAPI_EXPERIMENTAL'] } ],
-      ['disable_deprecated=="true"', {
-        'defines': ['NODE_ADDON_API_DISABLE_DEPRECATED']
-      }],
-      ['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',
-      },
-    },
-    {
-      'target_name': 'addon_noexcept',
-      'defines': [ 'NAPI_DISABLE_CPP_EXCEPTIONS' ],
-      'cflags': [ '-fno-exceptions' ],
-      'cflags_cc': [ '-fno-exceptions' ],
-      'msvs_settings': {
-        'VCCLCompilerTool': {
-          'ExceptionHandling': 0,
-          'EnablePREfast': 'true',
-        },
-      },
-      'xcode_settings': {
-        'CLANG_CXX_LIBRARY': 'libc++',
-        'MACOSX_DEPLOYMENT_TARGET': '10.7',
-        'GCC_ENABLE_CPP_EXCEPTIONS': 'NO',
-      },
-    },
-  ],
-}

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

@@ -1,9 +0,0 @@
-'use strict';
-
-const except = require('bindings')('addon');
-const noexcept = require('bindings')('addon_noexcept');
-
-module.exports = {
-  except,
-  noexcept
-};

package/vendor/node-addon-api/test/addon_build/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/addon_data.cc

@@ -1,98 +0,0 @@
-#if (NAPI_VERSION > 5)
-#include <stdio.h>
-#include "napi.h"
-#include "test_helper.h"
-
-// An overly elaborate way to get/set a boolean stored in the instance data:
-// 0. The constructor for JS `VerboseIndicator` instances, which have a private
-//    member named "verbose", is stored in the instance data.
-// 1. Add a property named "verbose" onto exports served by a getter/setter.
-// 2. The getter returns an object of type VerboseIndicator, which itself has a
-//    property named "verbose", also served by a getter/setter:
-//    * The getter returns a boolean, indicating whether "verbose" is set.
-//    * The setter sets "verbose" on the instance data.
-// 3. The setter sets "verbose" on the instance data.
-
-class Addon {
- public:
-  class VerboseIndicator : public Napi::ObjectWrap<VerboseIndicator> {
-   public:
-    VerboseIndicator(const Napi::CallbackInfo& info)
-        : Napi::ObjectWrap<VerboseIndicator>(info) {
-      info.This().As<Napi::Object>()["verbose"] = Napi::Boolean::New(
-          info.Env(), info.Env().GetInstanceData<Addon>()->verbose);
-    }
-
-    Napi::Value Getter(const Napi::CallbackInfo& info) {
-      return Napi::Boolean::New(info.Env(),
-                                info.Env().GetInstanceData<Addon>()->verbose);
-    }
-
-    void Setter(const Napi::CallbackInfo& info, const Napi::Value& val) {
-      info.Env().GetInstanceData<Addon>()->verbose = val.As<Napi::Boolean>();
-    }
-
-    static Napi::FunctionReference Init(Napi::Env env) {
-      return Napi::Persistent(DefineClass(
-          env,
-          "VerboseIndicator",
-          {InstanceAccessor<&VerboseIndicator::Getter,
-                            &VerboseIndicator::Setter>("verbose")}));
-    }
-  };
-
-  static Napi::Value Getter(const Napi::CallbackInfo& info) {
-    return MaybeUnwrap(
-        info.Env().GetInstanceData<Addon>()->VerboseIndicator.New({}));
-  }
-
-  static void Setter(const Napi::CallbackInfo& info) {
-    info.Env().GetInstanceData<Addon>()->verbose = info[0].As<Napi::Boolean>();
-  }
-
-  Addon(Napi::Env env) : VerboseIndicator(VerboseIndicator::Init(env)) {}
-  ~Addon() {
-    if (verbose) {
-      fprintf(stderr, "addon_data: Addon::~Addon\n");
-    }
-  }
-
-  static void DeleteAddon(Napi::Env, Addon* addon, uint32_t* hint) {
-    delete addon;
-    fprintf(stderr, "hint: %u\n", *hint);
-    delete hint;
-  }
-
-  static Napi::Object Init(Napi::Env env, Napi::Value jshint) {
-    if (!jshint.IsNumber()) {
-      NAPI_THROW(Napi::Error::New(env, "Expected number"), Napi::Object());
-    }
-    uint32_t hint = jshint.As<Napi::Number>();
-    if (hint == 0)
-      env.SetInstanceData(new Addon(env));
-    else
-      env.SetInstanceData<Addon, uint32_t, DeleteAddon>(new Addon(env),
-                                                        new uint32_t(hint));
-    Napi::Object result = Napi::Object::New(env);
-    result.DefineProperties({
-        Napi::PropertyDescriptor::Accessor<Getter, Setter>("verbose"),
-    });
-
-    return result;
-  }
-
- private:
-  bool verbose = false;
-  Napi::FunctionReference VerboseIndicator;
-};
-
-// We use an addon factory so we can cover both the case where there is an
-// instance data hint and the case where there isn't.
-static Napi::Value AddonFactory(const Napi::CallbackInfo& info) {
-  return Addon::Init(info.Env(), info[0]);
-}
-
-Napi::Object InitAddonData(Napi::Env env) {
-  return Napi::Function::New(env, AddonFactory);
-}
-#endif  // (NAPI_VERSION > 5)

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

@@ -1,24 +0,0 @@
-'use strict';
-
-const common = require('./common');
-
-module.exports = common.runTest(test);
-
-async function test () {
-  await common.runTestInChildProcess({
-    suite: 'addon_data',
-    testName: 'workingCode'
-  });
-
-  await common.runTestInChildProcess({
-    suite: 'addon_data',
-    testName: 'cleanupWithoutHint',
-    expectedStderr: ['addon_data: Addon::~Addon']
-  });
-
-  await common.runTestInChildProcess({
-    suite: 'addon_data',
-    testName: 'cleanupWithHint',
-    expectedStderr: ['addon_data: Addon::~Addon', 'hint: 42']
-  });
-}

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

@@ -1,243 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-namespace {
-
-const size_t testLength = 4;
-uint8_t testData[testLength];
-int finalizeCount = 0;
-
-void InitData(uint8_t* data, size_t length) {
-  for (size_t i = 0; i < length; i++) {
-    data[i] = static_cast<uint8_t>(i);
-  }
-}
-
-bool VerifyData(uint8_t* data, size_t length) {
-  for (size_t i = 0; i < length; i++) {
-    if (data[i] != static_cast<uint8_t>(i)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-Value CreateBuffer(const CallbackInfo& info) {
-  ArrayBuffer buffer = ArrayBuffer::New(info.Env(), testLength);
-
-  if (buffer.ByteLength() != testLength) {
-    Error::New(info.Env(), "Incorrect buffer length.")
-        .ThrowAsJavaScriptException();
-    return Value();
-  }
-
-  InitData(static_cast<uint8_t*>(buffer.Data()), testLength);
-  return buffer;
-}
-
-Value CreateExternalBuffer(const CallbackInfo& info) {
-  finalizeCount = 0;
-
-  ArrayBuffer buffer = ArrayBuffer::New(info.Env(), testData, testLength);
-
-  if (buffer.ByteLength() != testLength) {
-    Error::New(info.Env(), "Incorrect buffer length.")
-        .ThrowAsJavaScriptException();
-    return Value();
-  }
-
-  if (buffer.Data() != testData) {
-    Error::New(info.Env(), "Incorrect buffer data.")
-        .ThrowAsJavaScriptException();
-    return Value();
-  }
-
-  InitData(testData, testLength);
-  return buffer;
-}
-
-Value CreateExternalBufferWithFinalize(const CallbackInfo& info) {
-  finalizeCount = 0;
-
-  uint8_t* data = new uint8_t[testLength];
-
-  ArrayBuffer buffer = ArrayBuffer::New(
-      info.Env(), data, testLength, [](Env /*env*/, void* finalizeData) {
-        delete[] static_cast<uint8_t*>(finalizeData);
-        finalizeCount++;
-      });
-
-  if (buffer.ByteLength() != testLength) {
-    Error::New(info.Env(), "Incorrect buffer length.")
-        .ThrowAsJavaScriptException();
-    return Value();
-  }
-
-  if (buffer.Data() != data) {
-    Error::New(info.Env(), "Incorrect buffer data.")
-        .ThrowAsJavaScriptException();
-    return Value();
-  }
-
-  InitData(data, testLength);
-  return buffer;
-}
-
-Value CreateExternalBufferWithFinalizeHint(const CallbackInfo& info) {
-  finalizeCount = 0;
-
-  uint8_t* data = new uint8_t[testLength];
-
-  char* hint = nullptr;
-  ArrayBuffer buffer = ArrayBuffer::New(
-      info.Env(),
-      data,
-      testLength,
-      [](Env /*env*/, void* finalizeData, char* /*finalizeHint*/) {
-        delete[] static_cast<uint8_t*>(finalizeData);
-        finalizeCount++;
-      },
-      hint);
-
-  if (buffer.ByteLength() != testLength) {
-    Error::New(info.Env(), "Incorrect buffer length.")
-        .ThrowAsJavaScriptException();
-    return Value();
-  }
-
-  if (buffer.Data() != data) {
-    Error::New(info.Env(), "Incorrect buffer data.")
-        .ThrowAsJavaScriptException();
-    return Value();
-  }
-
-  InitData(data, testLength);
-  return buffer;
-}
-
-void CheckBuffer(const CallbackInfo& info) {
-  if (!info[0].IsArrayBuffer()) {
-    Error::New(info.Env(), "A buffer was expected.")
-        .ThrowAsJavaScriptException();
-    return;
-  }
-
-  ArrayBuffer buffer = info[0].As<ArrayBuffer>();
-
-  if (buffer.ByteLength() != testLength) {
-    Error::New(info.Env(), "Incorrect buffer length.")
-        .ThrowAsJavaScriptException();
-    return;
-  }
-
-  if (!VerifyData(static_cast<uint8_t*>(buffer.Data()), testLength)) {
-    Error::New(info.Env(), "Incorrect buffer data.")
-        .ThrowAsJavaScriptException();
-    return;
-  }
-}
-
-Value GetFinalizeCount(const CallbackInfo& info) {
-  return Number::New(info.Env(), finalizeCount);
-}
-
-Value CreateBufferWithConstructor(const CallbackInfo& info) {
-  ArrayBuffer buffer = ArrayBuffer::New(info.Env(), testLength);
-  if (buffer.ByteLength() != testLength) {
-    Error::New(info.Env(), "Incorrect buffer length.")
-        .ThrowAsJavaScriptException();
-    return Value();
-  }
-  InitData(static_cast<uint8_t*>(buffer.Data()), testLength);
-  ArrayBuffer buffer2(info.Env(), buffer);
-  return buffer2;
-}
-
-Value CheckEmptyBuffer(const CallbackInfo& info) {
-  ArrayBuffer buffer;
-  return Boolean::New(info.Env(), buffer.IsEmpty());
-}
-
-void CheckDetachUpdatesData(const CallbackInfo& info) {
-  if (!info[0].IsArrayBuffer()) {
-    Error::New(info.Env(), "A buffer was expected.")
-        .ThrowAsJavaScriptException();
-    return;
-  }
-
-  ArrayBuffer buffer = info[0].As<ArrayBuffer>();
-
-  // This potentially causes the buffer to cache its data pointer and length.
-  buffer.Data();
-  buffer.ByteLength();
-
-#if NAPI_VERSION >= 7
-  if (buffer.IsDetached()) {
-    Error::New(info.Env(), "Buffer should not be detached.")
-        .ThrowAsJavaScriptException();
-    return;
-  }
-#endif
-
-  if (info.Length() == 2) {
-    // Detach externally (in JavaScript).
-    if (!info[1].IsFunction()) {
-      Error::New(info.Env(), "A function was expected.")
-          .ThrowAsJavaScriptException();
-      return;
-    }
-
-    Function detach = info[1].As<Function>();
-    detach.Call({});
-  } else {
-#if NAPI_VERSION >= 7
-    // Detach directly.
-    buffer.Detach();
-#else
-    return;
-#endif
-  }
-
-#if NAPI_VERSION >= 7
-  if (!buffer.IsDetached()) {
-    Error::New(info.Env(), "Buffer should be detached.")
-        .ThrowAsJavaScriptException();
-    return;
-  }
-#endif
-
-  if (buffer.Data() != nullptr) {
-    Error::New(info.Env(), "Incorrect data pointer.")
-        .ThrowAsJavaScriptException();
-    return;
-  }
-
-  if (buffer.ByteLength() != 0) {
-    Error::New(info.Env(), "Incorrect buffer length.")
-        .ThrowAsJavaScriptException();
-    return;
-  }
-}
-
-}  // end anonymous namespace
-
-Object InitArrayBuffer(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createBuffer"] = Function::New(env, CreateBuffer);
-  exports["createExternalBuffer"] = Function::New(env, CreateExternalBuffer);
-  exports["createExternalBufferWithFinalize"] =
-      Function::New(env, CreateExternalBufferWithFinalize);
-  exports["createExternalBufferWithFinalizeHint"] =
-      Function::New(env, CreateExternalBufferWithFinalizeHint);
-  exports["checkBuffer"] = Function::New(env, CheckBuffer);
-  exports["getFinalizeCount"] = Function::New(env, GetFinalizeCount);
-  exports["createBufferWithConstructor"] =
-      Function::New(env, CreateBufferWithConstructor);
-  exports["checkEmptyBuffer"] = Function::New(env, CheckEmptyBuffer);
-  exports["checkDetachUpdatesData"] =
-      Function::New(env, CheckDetachUpdatesData);
-
-  return exports;
-}