koffi 0.9.0 → 0.9.3

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

@@ -0,0 +1,83 @@
+#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 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");
+    }
+    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();
+    if (!_js_progress_cb.IsEmpty()) {
+      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;
+  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);
+  return exports;
+}
+
+#endif

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

@@ -0,0 +1,46 @@
+'use strict';
+
+const common = require('./common')
+const assert = require('assert');
+
+module.exports = common.runTest(test);
+
+async function test({ asyncprogressqueueworker }) {
+  await success(asyncprogressqueueworker);
+  await fail(asyncprogressqueueworker);
+}
+
+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);
+  });
+}

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

@@ -0,0 +1,134 @@
+#include "napi.h"
+
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <thread>
+
+#if (NAPI_VERSION > 3)
+
+using namespace Napi;
+
+namespace {
+
+struct ProgressData {
+  size_t progress;
+};
+
+class TestWorker : public AsyncProgressWorker<ProgressData> {
+ public:
+  static void DoWork(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()));
+    worker->_times = times;
+    worker->Queue();
+  }
+
+ protected:
+  void Execute(const ExecutionProgress& progress) override {
+    if (_times < 0) {
+      SetError("test error");
+    }
+    ProgressData data{0};
+    std::unique_lock<std::mutex> lock(_cvm);
+    for (int32_t idx = 0; idx < _times; idx++) {
+      data.progress = idx;
+      progress.Send(&data, 1);
+      _cv.wait(lock);
+    }
+  }
+
+  void OnProgress(const ProgressData* data, size_t /* count */) override {
+    Napi::Env env = Env();
+    if (!_progress.IsEmpty()) {
+      Number progress = Number::New(env, data->progress);
+      _progress.MakeCallback(Receiver().Value(), {progress});
+    }
+    _cv.notify_one();
+  }
+
+ private:
+  TestWorker(Function cb,
+             Function progress,
+             const char* resource_name,
+             const Object& resource)
+      : AsyncProgressWorker(cb, resource_name, resource) {
+    _progress.Reset(progress, 1);
+  }
+  std::condition_variable _cv;
+  std::mutex _cvm;
+  int32_t _times;
+  FunctionReference _progress;
+};
+
+class MalignWorker : public AsyncProgressWorker<ProgressData> {
+ public:
+  static void DoWork(const CallbackInfo& info) {
+    Function cb = info[0].As<Function>();
+    Function progress = info[1].As<Function>();
+
+    MalignWorker* worker =
+        new MalignWorker(cb, progress, "TestResource", Object::New(info.Env()));
+    worker->Queue();
+  }
+
+ protected:
+  void Execute(const ExecutionProgress& progress) override {
+    std::unique_lock<std::mutex> lock(_cvm);
+    // Testing a nullptr send is acceptable.
+    progress.Send(nullptr, 0);
+    _cv.wait(lock);
+    // Testing busy looping on send doesn't trigger unexpected empty data
+    // OnProgress call.
+    for (size_t i = 0; i < 1000000; i++) {
+      ProgressData data{0};
+      progress.Send(&data, 1);
+    }
+  }
+
+  void OnProgress(const ProgressData* /* data */, size_t count) override {
+    Napi::Env env = Env();
+    _test_case_count++;
+    bool error = false;
+    Napi::String reason = Napi::String::New(env, "No error");
+    if (_test_case_count == 1 && count != 0) {
+      error = true;
+      reason = Napi::String::New(env, "expect 0 count of data on 1st call");
+    }
+    if (_test_case_count > 1 && count != 1) {
+      error = true;
+      reason = Napi::String::New(env, "expect 1 count of data on non-1st call");
+    }
+    _progress.MakeCallback(Receiver().Value(),
+                           {Napi::Boolean::New(env, error), reason});
+    _cv.notify_one();
+  }
+
+ private:
+  MalignWorker(Function cb,
+               Function progress,
+               const char* resource_name,
+               const Object& resource)
+      : AsyncProgressWorker(cb, resource_name, resource) {
+    _progress.Reset(progress, 1);
+  }
+
+  size_t _test_case_count = 0;
+  std::condition_variable _cv;
+  std::mutex _cvm;
+  FunctionReference _progress;
+};
+}  // namespace
+
+Object InitAsyncProgressWorker(Env env) {
+  Object exports = Object::New(env);
+  exports["doWork"] = Function::New(env, TestWorker::DoWork);
+  exports["doMalignTest"] = Function::New(env, MalignWorker::DoWork);
+  return exports;
+}
+
+#endif

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

@@ -0,0 +1,61 @@
+'use strict';
+
+const common = require('./common')
+const assert = require('assert');
+
+module.exports = common.runTest(test);
+
+async function test({ asyncprogressworker }) {
+  await success(asyncprogressworker);
+  await fail(asyncprogressworker);
+  await malignTest(asyncprogressworker);
+}
+
+function success(binding) {
+  return new Promise((resolve, reject) => {
+    const expected = [0, 1, 2, 3];
+    const actual = [];
+    binding.doWork(expected.length,
+      common.mustCall((err) => {
+        if (err) {
+          reject(err);
+        }
+      }),
+      common.mustCall((_progress) => {
+        actual.push(_progress);
+        if (actual.length === expected.length) {
+          assert.deepEqual(actual, expected);
+          resolve();
+        }
+      }, expected.length)
+    );
+  });
+}
+
+function fail(binding) {
+  return new Promise((resolve) => {
+    binding.doWork(-1,
+      common.mustCall((err) => {
+        assert.throws(() => { throw err }, /test error/)
+        resolve();
+      }),
+      common.mustNotCall()
+    );
+  });
+}
+
+function malignTest(binding) {
+  return new Promise((resolve, reject) => {
+    binding.doMalignTest(
+      common.mustCall((err) => {
+        if (err) {
+          return reject(err);
+        }
+        resolve();
+      }),
+      common.mustCallAtLeast((error, reason) => {
+        assert(!error, reason);
+      }, 1)
+    );
+  });
+}

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

@@ -0,0 +1,106 @@
+#include "napi.h"
+
+using namespace Napi;
+
+class TestWorker : public AsyncWorker {
+ public:
+  static void DoWork(const CallbackInfo& info) {
+    bool succeed = info[0].As<Boolean>();
+    Object resource = info[1].As<Object>();
+    Function cb = info[2].As<Function>();
+    Value data = info[3];
+
+    TestWorker* worker = new TestWorker(cb, "TestResource", resource);
+    worker->Receiver().Set("data", data);
+    worker->_succeed = succeed;
+    worker->Queue();
+  }
+
+ protected:
+  void Execute() override {
+    if (!_succeed) {
+      SetError("test error");
+    }
+  }
+
+ private:
+  TestWorker(Function cb, const char* resource_name, const Object& resource)
+      : AsyncWorker(cb, resource_name, resource) {}
+  bool _succeed;
+};
+
+class TestWorkerWithResult : public AsyncWorker {
+ public:
+  static void DoWork(const CallbackInfo& info) {
+    bool succeed = info[0].As<Boolean>();
+    Object resource = info[1].As<Object>();
+    Function cb = info[2].As<Function>();
+    Value data = info[3];
+
+    TestWorkerWithResult* worker =
+        new TestWorkerWithResult(cb, "TestResource", resource);
+    worker->Receiver().Set("data", data);
+    worker->_succeed = succeed;
+    worker->Queue();
+  }
+
+ protected:
+  void Execute() override {
+    if (!_succeed) {
+      SetError("test error");
+    }
+  }
+
+  std::vector<napi_value> GetResult(Napi::Env env) override {
+    return {Boolean::New(env, _succeed),
+            String::New(env, _succeed ? "ok" : "error")};
+  }
+
+ private:
+  TestWorkerWithResult(Function cb,
+                       const char* resource_name,
+                       const Object& resource)
+      : AsyncWorker(cb, resource_name, resource) {}
+  bool _succeed;
+};
+
+class TestWorkerNoCallback : public AsyncWorker {
+ public:
+  static Value DoWork(const CallbackInfo& info) {
+    napi_env env = info.Env();
+    bool succeed = info[0].As<Boolean>();
+    Object resource = info[1].As<Object>();
+
+    TestWorkerNoCallback* worker =
+        new TestWorkerNoCallback(env, "TestResource", resource);
+    worker->_succeed = succeed;
+    worker->Queue();
+    return worker->_deferred.Promise();
+  }
+
+ protected:
+  void Execute() override {}
+  virtual void OnOK() override { _deferred.Resolve(Env().Undefined()); }
+  virtual void OnError(const Napi::Error& /* e */) override {
+    _deferred.Reject(Env().Undefined());
+  }
+
+ private:
+  TestWorkerNoCallback(napi_env env,
+                       const char* resource_name,
+                       const Object& resource)
+      : AsyncWorker(env, resource_name, resource),
+        _deferred(Napi::Promise::Deferred::New(env)) {}
+  Promise::Deferred _deferred;
+  bool _succeed;
+};
+
+Object InitAsyncWorker(Env env) {
+  Object exports = Object::New(env);
+  exports["doWork"] = Function::New(env, TestWorker::DoWork);
+  exports["doWorkNoCallback"] =
+      Function::New(env, TestWorkerNoCallback::DoWork);
+  exports["doWorkWithResult"] =
+      Function::New(env, TestWorkerWithResult::DoWork);
+  return exports;
+}

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

@@ -0,0 +1,179 @@
+'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 async_hooks = undefined;
+function checkAsyncHooks() {
+  if (nodeVersion >=8) {
+    if (async_hooks == undefined) {
+      async_hooks = require('async_hooks');
+    }
+    return true;
+  }
+  return false;
+}
+
+module.exports = common.runTest(test);
+
+function installAsyncHooksForTest() {
+  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 hook;
+     let destroyed = false;
+     const interval = setInterval(() => {
+       if (destroyed) {
+         hook.disable();
+         clearInterval(interval);
+         resolve(events);
+       }
+     }, 10);
+
+    hook = async_hooks.createHook({
+      init(asyncId, type, triggerAsyncId, resource) {
+        if (id === undefined && type === 'TestResource') {
+          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();
+  });
+}
+
+async function test(binding) {
+  if (!checkAsyncHooks()) {
+    await new Promise((resolve) => {
+      binding.asyncworker.doWork(true, {}, function (e) {
+        assert.strictEqual(typeof e, 'undefined');
+        assert.strictEqual(typeof this, 'object');
+        assert.strictEqual(this.data, 'test data');
+        resolve();
+      }, 'test data');
+    });
+
+    await new Promise((resolve) => {
+      binding.asyncworker.doWork(false, {}, function (e) {
+        assert.ok(e instanceof Error);
+        assert.strictEqual(e.message, 'test error');
+        assert.strictEqual(typeof this, 'object');
+        assert.strictEqual(this.data, 'test data');
+        resolve();
+      }, 'test data');
+    });
+
+    await new Promise((resolve) => {
+      binding.asyncworker.doWorkWithResult(true, {}, function (succeed, succeedString) {
+        assert(arguments.length == 2);
+        assert(succeed);
+        assert(succeedString == "ok");
+        assert.strictEqual(typeof this, 'object');
+        assert.strictEqual(this.data, 'test data');
+        resolve();
+      }, 'test data');
+    });
+
+    return;
+  }
+
+  {
+    const hooks = installAsyncHooksForTest();
+    const triggerAsyncId = async_hooks.executionAsyncId();
+    await new Promise((resolve) => {
+      binding.asyncworker.doWork(true, { foo: 'foo' }, function (e) {
+        assert.strictEqual(typeof e, 'undefined');
+        assert.strictEqual(typeof this, 'object');
+        assert.strictEqual(this.data, 'test data');
+        resolve();
+      }, 'test data');
+    });
+
+    await hooks.then(actual => {
+      assert.deepStrictEqual(actual, [
+        { eventName: 'init',
+          type: 'TestResource',
+          triggerAsyncId: triggerAsyncId,
+          resource: { foo: 'foo' } },
+        { eventName: 'before' },
+        { eventName: 'after' },
+        { eventName: 'destroy' }
+      ]);
+    }).catch(common.mustNotCall());
+  }
+
+  {
+    const hooks = installAsyncHooksForTest();
+    const triggerAsyncId = async_hooks.executionAsyncId();
+    await new Promise((resolve) => {
+      binding.asyncworker.doWorkWithResult(true, { foo: 'foo' },
+        function (succeed, succeedString) {
+          assert(arguments.length == 2);
+          assert(succeed);
+          assert(succeedString == "ok");
+          assert.strictEqual(typeof this, 'object');
+          assert.strictEqual(this.data, 'test data');
+          resolve();
+        }, 'test data');
+    });
+
+    await hooks.then(actual => {
+      assert.deepStrictEqual(actual, [
+        { eventName: 'init',
+          type: 'TestResource',
+          triggerAsyncId: triggerAsyncId,
+          resource: { foo: 'foo' } },
+        { eventName: 'before' },
+        { eventName: 'after' },
+        { eventName: 'destroy' }
+      ]);
+    }).catch(common.mustNotCall());
+  }
+
+  {
+    const hooks = installAsyncHooksForTest();
+    const triggerAsyncId = async_hooks.executionAsyncId();
+    await new Promise((resolve) => {
+      binding.asyncworker.doWork(false, { foo: 'foo' }, function (e) {
+        assert.ok(e instanceof Error);
+        assert.strictEqual(e.message, 'test error');
+        assert.strictEqual(typeof this, 'object');
+        assert.strictEqual(this.data, 'test data');
+        resolve();
+      }, 'test data');
+    });
+
+    await hooks.then(actual => {
+      assert.deepStrictEqual(actual, [
+        { eventName: 'init',
+          type: 'TestResource',
+          triggerAsyncId: triggerAsyncId,
+          resource: { foo: 'foo' } },
+        { eventName: 'before' },
+        { eventName: 'after' },
+        { eventName: 'destroy' }
+      ]);
+    }).catch(common.mustNotCall());
+  }
+}

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

@@ -0,0 +1,13 @@
+'use strict';
+
+const common = require('./common');
+
+module.exports = common.runTest(test);
+
+async function test(binding) {
+  await binding.asyncworker.doWorkNoCallback(true, {})
+    .then(common.mustCall()).catch(common.mustNotCall());
+
+  await binding.asyncworker.doWorkNoCallback(false, {})
+    .then(common.mustNotCall()).catch(common.mustCall());
+}

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

@@ -0,0 +1,63 @@
+#include "napi.h"
+
+// A variant of TestWorker wherein destruction is suppressed. That is, instances
+// are not destroyed during the `OnOK` callback. They must be explicitly
+// destroyed.
+
+using namespace Napi;
+
+namespace {
+
+class PersistentTestWorker : public AsyncWorker {
+ public:
+  static PersistentTestWorker* current_worker;
+  static void DoWork(const CallbackInfo& info) {
+    bool succeed = info[0].As<Boolean>();
+    Function cb = info[1].As<Function>();
+
+    PersistentTestWorker* worker = new PersistentTestWorker(cb, "TestResource");
+    current_worker = worker;
+
+    worker->SuppressDestruct();
+    worker->_succeed = succeed;
+    worker->Queue();
+  }
+
+  static Value GetWorkerGone(const CallbackInfo& info) {
+    return Boolean::New(info.Env(), current_worker == nullptr);
+  }
+
+  static void DeleteWorker(const CallbackInfo& info) {
+    (void)info;
+    delete current_worker;
+  }
+
+  ~PersistentTestWorker() { current_worker = nullptr; }
+
+ protected:
+  void Execute() override {
+    if (!_succeed) {
+      SetError("test error");
+    }
+  }
+
+ private:
+  PersistentTestWorker(Function cb, const char* resource_name)
+      : AsyncWorker(cb, resource_name) {}
+
+  bool _succeed;
+};
+
+PersistentTestWorker* PersistentTestWorker::current_worker = nullptr;
+
+}  // end of anonymous namespace
+
+Object InitPersistentAsyncWorker(Env env) {
+  Object exports = Object::New(env);
+  exports["doWork"] = Function::New(env, PersistentTestWorker::DoWork);
+  exports.DefineProperty(PropertyDescriptor::Accessor(
+      env, exports, "workerGone", PersistentTestWorker::GetWorkerGone));
+  exports["deleteWorker"] =
+      Function::New(env, PersistentTestWorker::DeleteWorker);
+  return exports;
+}