koffi 0.9.3 → 0.9.6

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

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

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

@@ -1,24 +1,24 @@
-'use strict';
-
-const assert = require('assert');
-
-function test(binding, succeed) {
-  return new Promise((resolve) =>
-    // Can't pass an arrow function to doWork because that results in an
-    // undefined context inside its body when the function gets called.
-    binding.doWork(succeed, function(e) {
-      setImmediate(() => {
-        // If the work is supposed to fail, make sure there's an error.
-        assert.strictEqual(succeed || e.message === 'test error', true);
-        assert.strictEqual(binding.workerGone, false);
-        binding.deleteWorker();
-        assert.strictEqual(binding.workerGone, true);
-        resolve();
-      });
-    }));
-}
-
-module.exports = require('./common').runTest(async binding => {
-  await test(binding.persistentasyncworker, false);
-  await test(binding.persistentasyncworker, true);
-});
+'use strict';
+
+const assert = require('assert');
+
+function test(binding, succeed) {
+  return new Promise((resolve) =>
+    // Can't pass an arrow function to doWork because that results in an
+    // undefined context inside its body when the function gets called.
+    binding.doWork(succeed, function(e) {
+      setImmediate(() => {
+        // If the work is supposed to fail, make sure there's an error.
+        assert.strictEqual(succeed || e.message === 'test error', true);
+        assert.strictEqual(binding.workerGone, false);
+        binding.deleteWorker();
+        assert.strictEqual(binding.workerGone, true);
+        resolve();
+      });
+    }));
+}
+
+module.exports = require('./common').runTest(async binding => {
+  await test(binding.persistentasyncworker, false);
+  await test(binding.persistentasyncworker, true);
+});

package/vendor/node-addon-api/test/basic_types/array.cc

@@ -1,40 +1,40 @@
-#include "napi.h"
-
-using namespace Napi;
-
-Value CreateArray(const CallbackInfo& info) {
-  if (info.Length() > 0) {
-    size_t length = info[0].As<Number>().Uint32Value();
-    return Array::New(info.Env(), length);
-  } else {
-    return Array::New(info.Env());
-  }
-}
-
-Value GetLength(const CallbackInfo& info) {
-  Array array = info[0].As<Array>();
-  return Number::New(info.Env(), static_cast<uint32_t>(array.Length()));
-}
-
-Value GetElement(const CallbackInfo& info) {
-  Array array = info[0].As<Array>();
-  size_t index = info[1].As<Number>().Uint32Value();
-  return array[index];
-}
-
-void SetElement(const CallbackInfo& info) {
-  Array array = info[0].As<Array>();
-  size_t index = info[1].As<Number>().Uint32Value();
-  array[index] = info[2].As<Value>();
-}
-
-Object InitBasicTypesArray(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createArray"] = Function::New(env, CreateArray);
-  exports["getLength"] = Function::New(env, GetLength);
-  exports["get"] = Function::New(env, GetElement);
-  exports["set"] = Function::New(env, SetElement);
-
-  return exports;
-}
+#include "napi.h"
+
+using namespace Napi;
+
+Value CreateArray(const CallbackInfo& info) {
+  if (info.Length() > 0) {
+    size_t length = info[0].As<Number>().Uint32Value();
+    return Array::New(info.Env(), length);
+  } else {
+    return Array::New(info.Env());
+  }
+}
+
+Value GetLength(const CallbackInfo& info) {
+  Array array = info[0].As<Array>();
+  return Number::New(info.Env(), static_cast<uint32_t>(array.Length()));
+}
+
+Value GetElement(const CallbackInfo& info) {
+  Array array = info[0].As<Array>();
+  size_t index = info[1].As<Number>().Uint32Value();
+  return array[index];
+}
+
+void SetElement(const CallbackInfo& info) {
+  Array array = info[0].As<Array>();
+  size_t index = info[1].As<Number>().Uint32Value();
+  array[index] = info[2].As<Value>();
+}
+
+Object InitBasicTypesArray(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createArray"] = Function::New(env, CreateArray);
+  exports["getLength"] = Function::New(env, GetLength);
+  exports["get"] = Function::New(env, GetElement);
+  exports["set"] = Function::New(env, SetElement);
+
+  return exports;
+}