koffi 0.9.3 → 0.9.6

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

@@ -1,86 +1,86 @@
-'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 === 'async_context_test') {
-          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();
-  });
-}
-
-function test(binding) {
-  if (!checkAsyncHooks()) {
-    return;
-  }
-
-  const hooks = installAsyncHooksForTest();
-  const triggerAsyncId = async_hooks.executionAsyncId();
-  binding.asynccontext.makeCallback(common.mustCall(), { foo: 'foo' });
-  return 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());
-}
+'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 === 'async_context_test') {
+          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();
+  });
+}
+
+function test(binding) {
+  if (!checkAsyncHooks()) {
+    return;
+  }
+
+  const hooks = installAsyncHooksForTest();
+  const triggerAsyncId = async_hooks.executionAsyncId();
+  binding.asynccontext.makeCallback(common.mustCall(), { foo: 'foo' });
+  return 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());
+}

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

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