koffi 0.9.3 → 0.9.6

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

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