koffi 1.0.4 → 1.1.0-beta.1

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,99 +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. A boolean named "verbose" is stored in the instance data. The constructor
-//    for JS `VerboseIndicator` instances is also stored in the instance data.
-// 1. Add a property named "verbose" onto exports served by a getter/setter.
-// 2. The getter returns a 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: %d\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,46 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const { spawn } = require('child_process');
-const readline = require('readline');
-
-module.exports = require('./common').runTestWithBindingPath(test);
-
-// Make sure the instance data finalizer is called at process exit. If the hint
-// is non-zero, it will be printed out by the child process.
-function testFinalizer (bindingName, hint, expected) {
-  return new Promise((resolve) => {
-    bindingName = bindingName.split('\\').join('\\\\');
-    const child = spawn(process.execPath, [
-      '-e',
-      `require('${bindingName}').addon_data(${hint}).verbose = true;`
-    ]);
-    const actual = [];
-    readline
-      .createInterface({ input: child.stderr })
-      .on('line', (line) => {
-        if (expected.indexOf(line) >= 0) {
-          actual.push(line);
-        }
-      })
-      .on('close', () => {
-        assert.deepStrictEqual(expected, actual);
-        resolve();
-      });
-  });
-}
-
-async function test (bindingName) {
-  const binding = require(bindingName).addon_data(0);
-
-  // Make sure it is possible to get/set instance data.
-  assert.strictEqual(binding.verbose.verbose, false);
-  binding.verbose = true;
-  assert.strictEqual(binding.verbose.verbose, true);
-  binding.verbose = false;
-  assert.strictEqual(binding.verbose.verbose, false);
-
-  await testFinalizer(bindingName, 0, ['addon_data: Addon::~Addon']);
-  await testFinalizer(bindingName, 42,
-    ['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;
-}

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

@@ -1,69 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const testUtil = require('./testUtil');
-
-module.exports = require('./common').runTest(test);
-
-function test(binding) {
-  return testUtil.runGCTests([
-    'Internal ArrayBuffer',
-    () => {
-      const test = binding.arraybuffer.createBuffer();
-      binding.arraybuffer.checkBuffer(test);
-      assert.ok(test instanceof ArrayBuffer);
-
-      const test2 = test.slice(0);
-      binding.arraybuffer.checkBuffer(test2);
-    },
-
-    'External ArrayBuffer',
-    () => {
-      const test = binding.arraybuffer.createExternalBuffer();
-      binding.arraybuffer.checkBuffer(test);
-      assert.ok(test instanceof ArrayBuffer);
-      assert.strictEqual(0, binding.arraybuffer.getFinalizeCount());
-    },
-
-    () => assert.strictEqual(0, binding.arraybuffer.getFinalizeCount()),
-
-    'External ArrayBuffer with finalizer',
-    () => {
-      const test = binding.arraybuffer.createExternalBufferWithFinalize();
-      binding.arraybuffer.checkBuffer(test);
-      assert.ok(test instanceof ArrayBuffer);
-      assert.strictEqual(0, binding.arraybuffer.getFinalizeCount());
-    },
-
-    () => assert.strictEqual(1, binding.arraybuffer.getFinalizeCount()),
-
-    'External ArrayBuffer with finalizer hint',
-    () => {
-      const test = binding.arraybuffer.createExternalBufferWithFinalizeHint();
-      binding.arraybuffer.checkBuffer(test);
-      assert.ok(test instanceof ArrayBuffer);
-      assert.strictEqual(0, binding.arraybuffer.getFinalizeCount());
-    },
-
-    () => assert.strictEqual(1, binding.arraybuffer.getFinalizeCount()),
-
-    'ArrayBuffer with constructor',
-    () => {
-      assert.strictEqual(true, binding.arraybuffer.checkEmptyBuffer());
-      const test = binding.arraybuffer.createBufferWithConstructor();
-      binding.arraybuffer.checkBuffer(test);
-      assert.ok(test instanceof ArrayBuffer);
-    },
-
-    'ArrayBuffer updates data pointer and length when detached',
-    () => {
-      // Detach the ArrayBuffer in JavaScript.
-      const mem = new WebAssembly.Memory({ initial: 1 });
-      binding.arraybuffer.checkDetachUpdatesData(mem.buffer, () => mem.grow(1));
-
-      // Let C++ detach the ArrayBuffer.
-      const extBuffer = binding.arraybuffer.createExternalBuffer();
-      binding.arraybuffer.checkDetachUpdatesData(extBuffer);
-    },
-  ]);
-}

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

@@ -1,36 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-namespace {
-
-static void MakeCallback(const CallbackInfo& info) {
-  Function callback = info[0].As<Function>();
-  Object resource = info[1].As<Object>();
-  AsyncContext context(info.Env(), "async_context_test", resource);
-  callback.MakeCallback(
-      Object::New(info.Env()), std::initializer_list<napi_value>{}, context);
-}
-
-static void MakeCallbackNoResource(const CallbackInfo& info) {
-  Function callback = info[0].As<Function>();
-  AsyncContext context(info.Env(), "async_context_no_res_test");
-  callback.MakeCallback(
-      Object::New(info.Env()), std::initializer_list<napi_value>{}, context);
-}
-
-static Boolean AssertAsyncContextReturnCorrectEnv(const CallbackInfo& info) {
-  AsyncContext context(info.Env(), "empty_context_test");
-  return Boolean::New(info.Env(), context.Env() == info.Env());
-}
-}  // end anonymous namespace
-
-Object InitAsyncContext(Env env) {
-  Object exports = Object::New(env);
-  exports["makeCallback"] = Function::New(env, MakeCallback);
-  exports["makeCallbackNoResource"] =
-      Function::New(env, MakeCallbackNoResource);
-  exports["asyncCxtReturnCorrectEnv"] =
-      Function::New(env, AssertAsyncContextReturnCorrectEnv);
-  return exports;
-}

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

@@ -1,122 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const common = require('./common');
-
-// we only check async hooks on 8.x an higher were
-// they are closer to working properly
-const nodeVersion = process.versions.node.split('.')[0];
-let asyncHooks;
-function checkAsyncHooks () {
-  if (nodeVersion >= 8) {
-    if (asyncHooks === undefined) {
-      asyncHooks = require('async_hooks');
-    }
-    return true;
-  }
-  return false;
-}
-
-module.exports = common.runTest(test);
-
-function installAsyncHooksForTest (resName) {
-  return new Promise((resolve, reject) => {
-    let id;
-    const events = [];
-    /**
-     * TODO(legendecas): investigate why resolving & disabling hooks in
-     * destroy callback causing crash with case 'callbackscope.js'.
-     */
-    let destroyed = false;
-    const hook = asyncHooks.createHook({
-      init (asyncId, type, triggerAsyncId, resource) {
-        if (id === undefined && type === resName) {
-          id = asyncId;
-          events.push({ eventName: 'init', type, triggerAsyncId, resource });
-        }
-      },
-      before (asyncId) {
-        if (asyncId === id) {
-          events.push({ eventName: 'before' });
-        }
-      },
-      after (asyncId) {
-        if (asyncId === id) {
-          events.push({ eventName: 'after' });
-        }
-      },
-      destroy (asyncId) {
-        if (asyncId === id) {
-          events.push({ eventName: 'destroy' });
-          destroyed = true;
-        }
-      }
-    }).enable();
-
-    const interval = setInterval(() => {
-      if (destroyed) {
-        hook.disable();
-        clearInterval(interval);
-        resolve(events);
-      }
-    }, 10);
-  });
-}
-
-async function makeCallbackWithResource (binding) {
-  const hooks = installAsyncHooksForTest('async_context_test');
-  const triggerAsyncId = asyncHooks.executionAsyncId();
-  await new Promise((resolve, reject) => {
-    binding.asynccontext.makeCallback(common.mustCall(), { foo: 'foo' });
-    hooks.then(actual => {
-      assert.deepStrictEqual(actual, [
-        {
-          eventName: 'init',
-          type: 'async_context_test',
-          triggerAsyncId: triggerAsyncId,
-          resource: { foo: 'foo' }
-        },
-        { eventName: 'before' },
-        { eventName: 'after' },
-        { eventName: 'destroy' }
-      ]);
-    }).catch(common.mustNotCall());
-    resolve();
-  });
-}
-
-async function makeCallbackWithoutResource (binding) {
-  const hooks = installAsyncHooksForTest('async_context_no_res_test');
-  const triggerAsyncId = asyncHooks.executionAsyncId();
-  await new Promise((resolve, reject) => {
-    binding.asynccontext.makeCallbackNoResource(common.mustCall());
-    hooks.then(actual => {
-      assert.deepStrictEqual(actual, [
-        {
-          eventName: 'init',
-          type: 'async_context_no_res_test',
-          triggerAsyncId: triggerAsyncId,
-          resource: { }
-        },
-        { eventName: 'before' },
-        { eventName: 'after' },
-        { eventName: 'destroy' }
-      ]);
-    }).catch(common.mustNotCall());
-    resolve();
-  });
-}
-
-function assertAsyncContextReturnsCorrectEnv (binding) {
-  assert.strictEqual(binding.asynccontext.asyncCxtReturnCorrectEnv(), true);
-}
-
-async function test (binding) {
-  if (!checkAsyncHooks()) {
-    return;
-  }
-
-  await makeCallbackWithResource(binding);
-  await makeCallbackWithoutResource(binding);
-  assertAsyncContextReturnsCorrectEnv(binding);
-}