koffi 2.16.0-beta.2 → 2.16.1

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

@@ -1,70 +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,
-          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,
-          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);
-}

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

@@ -1,248 +0,0 @@
-#include "napi.h"
-
-#include <chrono>
-#include <condition_variable>
-#include <mutex>
-#include <thread>
-
-#if (NAPI_VERSION > 3)
-
-using namespace Napi;
-
-namespace {
-
-struct ProgressData {
-  int32_t progress;
-};
-
-class TestWorkerWithNoCb : public AsyncProgressQueueWorker<ProgressData> {
- public:
-  static void DoWork(const CallbackInfo& info) {
-    switch (info.Length()) {
-      case 1: {
-        Function cb = info[0].As<Function>();
-        TestWorkerWithNoCb* worker = new TestWorkerWithNoCb(info.Env(), cb);
-        worker->Queue();
-      } break;
-
-      case 2: {
-        std::string resName = info[0].As<String>();
-        Function cb = info[1].As<Function>();
-        TestWorkerWithNoCb* worker =
-            new TestWorkerWithNoCb(info.Env(), resName.c_str(), cb);
-        worker->Queue();
-      } break;
-
-      case 3: {
-        std::string resName = info[0].As<String>();
-        Object resObject = info[1].As<Object>();
-        Function cb = info[2].As<Function>();
-        TestWorkerWithNoCb* worker =
-            new TestWorkerWithNoCb(info.Env(), resName.c_str(), resObject, cb);
-        worker->Queue();
-      } break;
-
-      default:
-
-        break;
-    }
-  }
-
- protected:
-  void Execute(const ExecutionProgress& progress) override {
-    ProgressData data{1};
-    progress.Send(&data, 1);
-  }
-
-  void OnProgress(const ProgressData*, size_t /* count */) override {
-    _cb.Call({});
-  }
-
- private:
-  TestWorkerWithNoCb(Napi::Env env, Function cb)
-      : AsyncProgressQueueWorker(env) {
-    _cb.Reset(cb, 1);
-  }
-  TestWorkerWithNoCb(Napi::Env env, const char* resourceName, Function cb)
-      : AsyncProgressQueueWorker(env, resourceName) {
-    _cb.Reset(cb, 1);
-  }
-  TestWorkerWithNoCb(Napi::Env env,
-                     const char* resourceName,
-                     const Object& resourceObject,
-                     Function cb)
-      : AsyncProgressQueueWorker(env, resourceName, resourceObject) {
-    _cb.Reset(cb, 1);
-  }
-  FunctionReference _cb;
-};
-
-class TestWorkerWithRecv : public AsyncProgressQueueWorker<ProgressData> {
- public:
-  static void DoWork(const CallbackInfo& info) {
-    switch (info.Length()) {
-      case 2: {
-        Object recv = info[0].As<Object>();
-        Function cb = info[1].As<Function>();
-        TestWorkerWithRecv* worker = new TestWorkerWithRecv(recv, cb);
-        worker->Queue();
-      } break;
-
-      case 3: {
-        Object recv = info[0].As<Object>();
-        Function cb = info[1].As<Function>();
-        std::string resName = info[2].As<String>();
-        TestWorkerWithRecv* worker =
-            new TestWorkerWithRecv(recv, cb, resName.c_str());
-        worker->Queue();
-      } break;
-
-      case 4: {
-        Object recv = info[0].As<Object>();
-        Function cb = info[1].As<Function>();
-        std::string resName = info[2].As<String>();
-        Object resObject = info[3].As<Object>();
-        TestWorkerWithRecv* worker =
-            new TestWorkerWithRecv(recv, cb, resName.c_str(), resObject);
-        worker->Queue();
-      } break;
-
-      default:
-
-        break;
-    }
-  }
-
- protected:
-  void Execute(const ExecutionProgress&) override {}
-
-  void OnProgress(const ProgressData*, size_t /* count */) override {}
-
- private:
-  TestWorkerWithRecv(const Object& recv, const Function& cb)
-      : AsyncProgressQueueWorker(recv, cb) {}
-  TestWorkerWithRecv(const Object& recv,
-                     const Function& cb,
-                     const char* resourceName)
-      : AsyncProgressQueueWorker(recv, cb, resourceName) {}
-  TestWorkerWithRecv(const Object& recv,
-                     const Function& cb,
-                     const char* resourceName,
-                     const Object& resourceObject)
-      : AsyncProgressQueueWorker(recv, cb, resourceName, resourceObject) {}
-};
-
-class TestWorkerWithCb : public AsyncProgressQueueWorker<ProgressData> {
- public:
-  static void DoWork(const CallbackInfo& info) {
-    switch (info.Length()) {
-      case 1: {
-        Function cb = info[0].As<Function>();
-        TestWorkerWithCb* worker = new TestWorkerWithCb(cb);
-        worker->Queue();
-      } break;
-
-      case 2: {
-        Function cb = info[0].As<Function>();
-        std::string asyncResName = info[1].As<String>();
-        TestWorkerWithCb* worker =
-            new TestWorkerWithCb(cb, asyncResName.c_str());
-        worker->Queue();
-      } break;
-
-      default:
-
-        break;
-    }
-  }
-
- protected:
-  void Execute(const ExecutionProgress&) override {}
-
-  void OnProgress(const ProgressData*, size_t /* count */) override {}
-
- private:
-  TestWorkerWithCb(Function cb) : AsyncProgressQueueWorker(cb) {}
-  TestWorkerWithCb(Function cb, const char* res_name)
-      : AsyncProgressQueueWorker(cb, res_name) {}
-};
-
-class TestWorker : public AsyncProgressQueueWorker<ProgressData> {
- public:
-  static Napi::Value CreateWork(const CallbackInfo& info) {
-    int32_t times = info[0].As<Number>().Int32Value();
-    Function cb = info[1].As<Function>();
-    Function progress = info[2].As<Function>();
-
-    TestWorker* worker = new TestWorker(
-        cb, progress, "TestResource", Object::New(info.Env()), times);
-
-    return Napi::External<TestWorker>::New(info.Env(), worker);
-  }
-
-  static void QueueWork(const CallbackInfo& info) {
-    auto wrap = info[0].As<Napi::External<TestWorker>>();
-    auto worker = wrap.Data();
-    worker->Queue();
-  }
-
- protected:
-  void Execute(const ExecutionProgress& progress) override {
-    using namespace std::chrono_literals;
-    std::this_thread::sleep_for(1s);
-
-    if (_times < 0) {
-      SetError("test error");
-    } else {
-      progress.Signal();
-    }
-    ProgressData data{0};
-    for (int32_t idx = 0; idx < _times; idx++) {
-      data.progress = idx;
-      progress.Send(&data, 1);
-    }
-  }
-
-  void OnProgress(const ProgressData* data, size_t count) override {
-    Napi::Env env = Env();
-    _test_case_count++;
-    if (!_js_progress_cb.IsEmpty()) {
-      if (_test_case_count == 1) {
-        if (count != 0) {
-          SetError("expect 0 count of data on 1st call");
-        }
-      } else {
-        Number progress = Number::New(env, data->progress);
-        _js_progress_cb.Call(Receiver().Value(), {progress});
-      }
-    }
-  }
-
- private:
-  TestWorker(Function cb,
-             Function progress,
-             const char* resource_name,
-             const Object& resource,
-             int32_t times)
-      : AsyncProgressQueueWorker(cb, resource_name, resource), _times(times) {
-    _js_progress_cb.Reset(progress, 1);
-  }
-
-  int32_t _times;
-  size_t _test_case_count = 0;
-  FunctionReference _js_progress_cb;
-};
-
-}  // namespace
-
-Object InitAsyncProgressQueueWorker(Env env) {
-  Object exports = Object::New(env);
-  exports["createWork"] = Function::New(env, TestWorker::CreateWork);
-  exports["queueWork"] = Function::New(env, TestWorker::QueueWork);
-  exports["runWorkerNoCb"] = Function::New(env, TestWorkerWithNoCb::DoWork);
-  exports["runWorkerWithRecv"] = Function::New(env, TestWorkerWithRecv::DoWork);
-  exports["runWorkerWithCb"] = Function::New(env, TestWorkerWithCb::DoWork);
-  return exports;
-}
-
-#endif

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

@@ -1,180 +0,0 @@
-'use strict';
-
-const common = require('./common');
-const assert = require('assert');
-
-module.exports = common.runTest(test);
-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;
-}
-
-async function test ({ asyncprogressqueueworker }) {
-  await success(asyncprogressqueueworker);
-  await fail(asyncprogressqueueworker);
-
-  await asyncProgressWorkerCallbackOverloads(asyncprogressqueueworker.runWorkerWithCb);
-  await asyncProgressWorkerRecvOverloads(asyncprogressqueueworker.runWorkerWithRecv);
-  await asyncProgressWorkerNoCbOverloads(asyncprogressqueueworker.runWorkerNoCb);
-}
-
-async function asyncProgressWorkerCallbackOverloads (bindingFunction) {
-  bindingFunction(common.mustCall());
-  if (!checkAsyncHooks()) {
-    return;
-  }
-
-  const hooks = common.installAysncHooks('cbResources');
-
-  const triggerAsyncId = asyncHooks.executionAsyncId();
-  await new Promise((resolve, reject) => {
-    bindingFunction(common.mustCall(), 'cbResources');
-    hooks.then(actual => {
-      assert.deepStrictEqual(actual, [
-        {
-          eventName: 'init',
-          type: 'cbResources',
-          triggerAsyncId,
-          resource: {}
-        },
-        { eventName: 'before' },
-        { eventName: 'after' },
-        { eventName: 'destroy' }
-      ]);
-      resolve();
-    }).catch((err) => reject(err));
-  });
-}
-
-async function asyncProgressWorkerRecvOverloads (bindingFunction) {
-  const recvObject = {
-    a: 4
-  };
-
-  function cb () {
-    assert.strictEqual(this.a, recvObject.a);
-  }
-
-  bindingFunction(recvObject, common.mustCall(cb));
-  if (!checkAsyncHooks()) {
-    return;
-  }
-  const asyncResources = [
-    { resName: 'cbRecvResources', resObject: {} },
-    { resName: 'cbRecvResourcesObject', resObject: { foo: 'bar' } }
-  ];
-
-  for (const asyncResource of asyncResources) {
-    const asyncResName = asyncResource.resName;
-    const asyncResObject = asyncResource.resObject;
-
-    const hooks = common.installAysncHooks(asyncResource.resName);
-    const triggerAsyncId = asyncHooks.executionAsyncId();
-    await new Promise((resolve, reject) => {
-      if (Object.keys(asyncResObject).length === 0) {
-        bindingFunction(recvObject, common.mustCall(cb), asyncResName);
-      } else {
-        bindingFunction(recvObject, common.mustCall(cb), asyncResName, asyncResObject);
-      }
-
-      hooks.then(actual => {
-        assert.deepStrictEqual(actual, [
-          {
-            eventName: 'init',
-            type: asyncResName,
-            triggerAsyncId,
-            resource: asyncResObject
-          },
-          { eventName: 'before' },
-          { eventName: 'after' },
-          { eventName: 'destroy' }
-        ]);
-        resolve();
-      }).catch((err) => reject(err));
-    });
-  }
-}
-
-async function asyncProgressWorkerNoCbOverloads (bindingFunction) {
-  bindingFunction(common.mustCall());
-  if (!checkAsyncHooks()) {
-    return;
-  }
-  const asyncResources = [
-    { resName: 'noCbResources', resObject: {} },
-    { resName: 'noCbResourcesObject', resObject: { foo: 'bar' } }
-  ];
-
-  for (const asyncResource of asyncResources) {
-    const asyncResName = asyncResource.resName;
-    const asyncResObject = asyncResource.resObject;
-
-    const hooks = common.installAysncHooks(asyncResource.resName);
-    const triggerAsyncId = asyncHooks.executionAsyncId();
-    await new Promise((resolve, reject) => {
-      if (Object.keys(asyncResObject).length === 0) {
-        bindingFunction(asyncResName, common.mustCall(() => {}));
-      } else {
-        bindingFunction(asyncResName, asyncResObject, common.mustCall(() => {}));
-      }
-
-      hooks.then(actual => {
-        assert.deepStrictEqual(actual, [
-          {
-            eventName: 'init',
-            type: asyncResName,
-            triggerAsyncId,
-            resource: asyncResObject
-          },
-          { eventName: 'before' },
-          { eventName: 'after' },
-          { eventName: 'destroy' }
-        ]);
-        resolve();
-      }).catch((err) => reject(err));
-    });
-  }
-}
-
-function success (binding) {
-  return new Promise((resolve, reject) => {
-    const expected = [0, 1, 2, 3];
-    const actual = [];
-    const worker = binding.createWork(expected.length,
-      common.mustCall((err) => {
-        if (err) {
-          reject(err);
-        } else {
-          // All queued items shall be invoked before complete callback.
-          assert.deepEqual(actual, expected);
-          resolve();
-        }
-      }),
-      common.mustCall((_progress) => {
-        actual.push(_progress);
-      }, expected.length)
-    );
-    binding.queueWork(worker);
-  });
-}
-
-function fail (binding) {
-  return new Promise((resolve, reject) => {
-    const worker = binding.createWork(-1,
-      common.mustCall((err) => {
-        assert.throws(() => { throw err; }, /test error/);
-        resolve();
-      }),
-      common.mustNotCall()
-    );
-    binding.queueWork(worker);
-  });
-}