koffi 0.9.33 → 0.9.34

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

@@ -1,83 +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 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

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

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

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

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

@@ -1,179 +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 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

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

@@ -1,63 +0,0 @@
-#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;
-}