koffi 1.1.0-beta.0 → 1.1.0-beta.3

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

@@ -0,0 +1,11 @@
+{
+  "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

@@ -0,0 +1,99 @@
+#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

@@ -0,0 +1,46 @@
+'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

@@ -0,0 +1,243 @@
+#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

@@ -0,0 +1,69 @@
+'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

@@ -0,0 +1,36 @@
+#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

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