koffi 0.9.3 → 0.9.6

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

@@ -1,69 +1,69 @@
-'use strict';
-
-const assert = require('assert');
-const testUtil = require('./testUtil');
-const safeBuffer = require('safe-buffer');
-
-module.exports = require('./common').runTest(test);
-
-function test(binding) {
-  return testUtil.runGCTests([
-    'Internal Buffer',
-    () => {
-      const test = binding.buffer.createBuffer();
-      binding.buffer.checkBuffer(test);
-      assert.ok(test instanceof Buffer);
-
-      const test2 = safeBuffer.Buffer.alloc(test.length);
-      test.copy(test2);
-      binding.buffer.checkBuffer(test2);
-    },
-
-    'Buffer copy',
-    () => {
-      const test = binding.buffer.createBufferCopy();
-      binding.buffer.checkBuffer(test);
-      assert.ok(test instanceof Buffer);
-    },
-
-    'External Buffer',
-    () => {
-      const test = binding.buffer.createExternalBuffer();
-      binding.buffer.checkBuffer(test);
-      assert.ok(test instanceof Buffer);
-      assert.strictEqual(0, binding.buffer.getFinalizeCount());
-    },
-    () => {
-        global.gc();
-        assert.strictEqual(0, binding.buffer.getFinalizeCount());
-    },
-
-    'External Buffer with finalizer',
-    () => {
-      const test = binding.buffer.createExternalBufferWithFinalize();
-      binding.buffer.checkBuffer(test);
-      assert.ok(test instanceof Buffer);
-      assert.strictEqual(0, binding.buffer.getFinalizeCount());
-    },
-    () => {
-        global.gc();
-    },
-    () => {
-        assert.strictEqual(1, binding.buffer.getFinalizeCount());
-    },
-
-    'External Buffer with finalizer hint',
-    () => {
-        const test = binding.buffer.createExternalBufferWithFinalizeHint();
-        binding.buffer.checkBuffer(test);
-        assert.ok(test instanceof Buffer);
-        assert.strictEqual(0, binding.buffer.getFinalizeCount());
-    },
-    () => {
-        global.gc();
-    },
-    () => {
-        assert.strictEqual(1, binding.buffer.getFinalizeCount());
-    },
-  ]);
-}
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('./testUtil');
+const safeBuffer = require('safe-buffer');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  return testUtil.runGCTests([
+    'Internal Buffer',
+    () => {
+      const test = binding.buffer.createBuffer();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+
+      const test2 = safeBuffer.Buffer.alloc(test.length);
+      test.copy(test2);
+      binding.buffer.checkBuffer(test2);
+    },
+
+    'Buffer copy',
+    () => {
+      const test = binding.buffer.createBufferCopy();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+    },
+
+    'External Buffer',
+    () => {
+      const test = binding.buffer.createExternalBuffer();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+      assert.strictEqual(0, binding.buffer.getFinalizeCount());
+    },
+    () => {
+        global.gc();
+        assert.strictEqual(0, binding.buffer.getFinalizeCount());
+    },
+
+    'External Buffer with finalizer',
+    () => {
+      const test = binding.buffer.createExternalBufferWithFinalize();
+      binding.buffer.checkBuffer(test);
+      assert.ok(test instanceof Buffer);
+      assert.strictEqual(0, binding.buffer.getFinalizeCount());
+    },
+    () => {
+        global.gc();
+    },
+    () => {
+        assert.strictEqual(1, binding.buffer.getFinalizeCount());
+    },
+
+    'External Buffer with finalizer hint',
+    () => {
+        const test = binding.buffer.createExternalBufferWithFinalizeHint();
+        binding.buffer.checkBuffer(test);
+        assert.ok(test instanceof Buffer);
+        assert.strictEqual(0, binding.buffer.getFinalizeCount());
+    },
+    () => {
+        global.gc();
+    },
+    () => {
+        assert.strictEqual(1, binding.buffer.getFinalizeCount());
+    },
+  ]);
+}

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

@@ -1,22 +1,22 @@
-#include "napi.h"
-
-using namespace Napi;
-
-#if (NAPI_VERSION > 2)
-namespace {
-
-static void RunInCallbackScope(const CallbackInfo& info) {
-  Function callback = info[0].As<Function>();
-  AsyncContext context(info.Env(), "callback_scope_test");
-  CallbackScope scope(info.Env(), context);
-  callback.Call({});
-}
-
-} // end anonymous namespace
-
-Object InitCallbackScope(Env env) {
-  Object exports = Object::New(env);
-  exports["runInCallbackScope"] = Function::New(env, RunInCallbackScope);
-  return exports;
-}
-#endif
+#include "napi.h"
+
+using namespace Napi;
+
+#if (NAPI_VERSION > 2)
+namespace {
+
+static void RunInCallbackScope(const CallbackInfo& info) {
+  Function callback = info[0].As<Function>();
+  AsyncContext context(info.Env(), "callback_scope_test");
+  CallbackScope scope(info.Env(), context);
+  callback.Call({});
+}
+
+} // end anonymous namespace
+
+Object InitCallbackScope(Env env) {
+  Object exports = Object::New(env);
+  exports["runInCallbackScope"] = Function::New(env, RunInCallbackScope);
+  return exports;
+}
+#endif

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

@@ -1,49 +1,49 @@
-'use strict';
-const assert = require('assert');
-
-// 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 = require('./common').runTest(test);
-
-function test(binding) {
-  if (!checkAsyncHooks())
-    return;
-
-  let id;
-  let insideHook = false;
-  const hook = async_hooks.createHook({
-    init(asyncId, type, triggerAsyncId, resource) {
-      if (id === undefined && type === 'callback_scope_test') {
-        id = asyncId;
-      }
-    },
-    before(asyncId) {
-      if (asyncId === id)
-        insideHook = true;
-    },
-    after(asyncId) {
-      if (asyncId === id)
-        insideHook = false;
-    }
-  }).enable();
-
-  return new Promise(resolve => {
-    binding.callbackscope.runInCallbackScope(function() {
-      assert(insideHook);
-      hook.disable();
-      resolve();
-    });
-  });
-}
+'use strict';
+const assert = require('assert');
+
+// 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 = require('./common').runTest(test);
+
+function test(binding) {
+  if (!checkAsyncHooks())
+    return;
+
+  let id;
+  let insideHook = false;
+  const hook = async_hooks.createHook({
+    init(asyncId, type, triggerAsyncId, resource) {
+      if (id === undefined && type === 'callback_scope_test') {
+        id = asyncId;
+      }
+    },
+    before(asyncId) {
+      if (asyncId === id)
+        insideHook = true;
+    },
+    after(asyncId) {
+      if (asyncId === id)
+        insideHook = false;
+    }
+  }).enable();
+
+  return new Promise(resolve => {
+    binding.callbackscope.runInCallbackScope(function() {
+      assert(insideHook);
+      hook.disable();
+      resolve();
+    });
+  });
+}

package/vendor/node-addon-api/test/common/index.js

@@ -1,113 +1,113 @@
-/* Test helpers ported from test/common/index.js in Node.js project. */
-'use strict';
-const assert = require('assert');
-const path = require('path');
-
-const noop = () => {};
-
-const mustCallChecks = [];
-
-function runCallChecks(exitCode) {
-  if (exitCode !== 0) return;
-
-  const failed = mustCallChecks.filter(function(context) {
-    if ('minimum' in context) {
-      context.messageSegment = `at least ${context.minimum}`;
-      return context.actual < context.minimum;
-    } else {
-      context.messageSegment = `exactly ${context.exact}`;
-      return context.actual !== context.exact;
-    }
-  });
-
-  failed.forEach(function(context) {
-    console.log('Mismatched %s function calls. Expected %s, actual %d.',
-                context.name,
-                context.messageSegment,
-                context.actual);
-    console.log(context.stack.split('\n').slice(2).join('\n'));
-  });
-
-  if (failed.length) process.exit(1);
-}
-
-exports.mustCall = function(fn, exact) {
-  return _mustCallInner(fn, exact, 'exact');
-};
-exports.mustCallAtLeast = function(fn, minimum) {
-  return _mustCallInner(fn, minimum, 'minimum');
-};
-
-function _mustCallInner(fn, criteria, field) {
-  if (typeof fn === 'number') {
-    criteria = fn;
-    fn = noop;
-  } else if (fn === undefined) {
-    fn = noop;
-  }
-  if (criteria === undefined) {
-    criteria = 1;
-  }
-
-  if (typeof criteria !== 'number')
-    throw new TypeError(`Invalid ${field} value: ${criteria}`);
-
-  const context = {
-    [field]: criteria,
-    actual: 0,
-    stack: (new Error()).stack,
-    name: fn.name || '<anonymous>'
-  };
-
-  // add the exit listener only once to avoid listener leak warnings
-  if (mustCallChecks.length === 0) process.on('exit', runCallChecks);
-
-  mustCallChecks.push(context);
-
-  return function() {
-    context.actual++;
-    return fn.apply(this, arguments);
-  };
-}
-
-exports.mustNotCall = function(msg) {
-  return function mustNotCall() {
-    assert.fail(msg || 'function should not have been called');
-  };
-};
-
-exports.runTest = async function(test, buildType, buildPathRoot = process.env.REL_BUILD_PATH || '') {
-  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
-
-  const bindings = [
-    path.join(buildPathRoot, `../build/${buildType}/binding.node`),
-    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept.node`),
-    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept_maybe.node`),
-  ].map(it => require.resolve(it));
-
-  for (const item of bindings) {
-    await Promise.resolve(test(require(item)))
-      .finally(exports.mustCall());
-  }
-}
-
-exports.runTestWithBindingPath = async function(test, buildType, buildPathRoot = process.env.REL_BUILD_PATH || '') {
-  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
-
-  const bindings = [
-    path.join(buildPathRoot, `../build/${buildType}/binding.node`),
-    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept.node`),
-    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept_maybe.node`),
-  ].map(it => require.resolve(it));
-
-  for (const item of bindings) {
-    await test(item);
-  }
-}
-
-exports.runTestWithBuildType = async function(test, buildType) {
-  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
-
-   await Promise.resolve(test(buildType))
-     .finally(exports.mustCall());
-}
+/* Test helpers ported from test/common/index.js in Node.js project. */
+'use strict';
+const assert = require('assert');
+const path = require('path');
+
+const noop = () => {};
+
+const mustCallChecks = [];
+
+function runCallChecks(exitCode) {
+  if (exitCode !== 0) return;
+
+  const failed = mustCallChecks.filter(function(context) {
+    if ('minimum' in context) {
+      context.messageSegment = `at least ${context.minimum}`;
+      return context.actual < context.minimum;
+    } else {
+      context.messageSegment = `exactly ${context.exact}`;
+      return context.actual !== context.exact;
+    }
+  });
+
+  failed.forEach(function(context) {
+    console.log('Mismatched %s function calls. Expected %s, actual %d.',
+                context.name,
+                context.messageSegment,
+                context.actual);
+    console.log(context.stack.split('\n').slice(2).join('\n'));
+  });
+
+  if (failed.length) process.exit(1);
+}
+
+exports.mustCall = function(fn, exact) {
+  return _mustCallInner(fn, exact, 'exact');
+};
+exports.mustCallAtLeast = function(fn, minimum) {
+  return _mustCallInner(fn, minimum, 'minimum');
+};
+
+function _mustCallInner(fn, criteria, field) {
+  if (typeof fn === 'number') {
+    criteria = fn;
+    fn = noop;
+  } else if (fn === undefined) {
+    fn = noop;
+  }
+  if (criteria === undefined) {
+    criteria = 1;
+  }
+
+  if (typeof criteria !== 'number')
+    throw new TypeError(`Invalid ${field} value: ${criteria}`);
+
+  const context = {
+    [field]: criteria,
+    actual: 0,
+    stack: (new Error()).stack,
+    name: fn.name || '<anonymous>'
+  };
+
+  // add the exit listener only once to avoid listener leak warnings
+  if (mustCallChecks.length === 0) process.on('exit', runCallChecks);
+
+  mustCallChecks.push(context);
+
+  return function() {
+    context.actual++;
+    return fn.apply(this, arguments);
+  };
+}
+
+exports.mustNotCall = function(msg) {
+  return function mustNotCall() {
+    assert.fail(msg || 'function should not have been called');
+  };
+};
+
+exports.runTest = async function(test, buildType, buildPathRoot = process.env.REL_BUILD_PATH || '') {
+  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
+
+  const bindings = [
+    path.join(buildPathRoot, `../build/${buildType}/binding.node`),
+    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept.node`),
+    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept_maybe.node`),
+  ].map(it => require.resolve(it));
+
+  for (const item of bindings) {
+    await Promise.resolve(test(require(item)))
+      .finally(exports.mustCall());
+  }
+}
+
+exports.runTestWithBindingPath = async function(test, buildType, buildPathRoot = process.env.REL_BUILD_PATH || '') {
+  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
+
+  const bindings = [
+    path.join(buildPathRoot, `../build/${buildType}/binding.node`),
+    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept.node`),
+    path.join(buildPathRoot, `../build/${buildType}/binding_noexcept_maybe.node`),
+  ].map(it => require.resolve(it));
+
+  for (const item of bindings) {
+    await test(item);
+  }
+}
+
+exports.runTestWithBuildType = async function(test, buildType) {
+  buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
+
+   await Promise.resolve(test(buildType))
+     .finally(exports.mustCall());
+}

package/vendor/node-addon-api/test/common/test_helper.h

@@ -1,61 +1,61 @@
-#pragma once
-#include "napi.h"
-
-namespace Napi {
-
-// Use this when a variable or parameter is unused in order to explicitly
-// silence a compiler warning about that.
-template <typename T>
-inline void USE(T&&) {}
-
-/**
- * A test helper that converts MaybeOrValue<T> to T by checking that
- * MaybeOrValue is NOT an empty Maybe when NODE_ADDON_API_ENABLE_MAYBE is
- * defined.
- *
- * Do nothing when NODE_ADDON_API_ENABLE_MAYBE is not defined.
- */
-template <typename T>
-inline T MaybeUnwrap(MaybeOrValue<T> maybe) {
-#if defined(NODE_ADDON_API_ENABLE_MAYBE)
-  return maybe.Unwrap();
-#else
-  return maybe;
-#endif
-}
-
-/**
- * A test helper that converts MaybeOrValue<T> to T by getting the value that
- * wrapped by the Maybe or return the default_value if the Maybe is empty when
- * NODE_ADDON_API_ENABLE_MAYBE is defined.
- *
- * Do nothing when NODE_ADDON_API_ENABLE_MAYBE is not defined.
- */
-template <typename T>
-inline T MaybeUnwrapOr(MaybeOrValue<T> maybe, const T& default_value) {
-#if defined(NODE_ADDON_API_ENABLE_MAYBE)
-  return maybe.UnwrapOr(default_value);
-#else
-  USE(default_value);
-  return maybe;
-#endif
-}
-
-/**
- * A test helper that converts MaybeOrValue<T> to T by getting the value that
- * wrapped by the Maybe or return false if the Maybe is empty when
- * NODE_ADDON_API_ENABLE_MAYBE is defined.
- *
- * Copying the value to out when NODE_ADDON_API_ENABLE_MAYBE is not defined.
- */
-template <typename T>
-inline bool MaybeUnwrapTo(MaybeOrValue<T> maybe, T* out) {
-#if defined(NODE_ADDON_API_ENABLE_MAYBE)
-  return maybe.UnwrapTo(out);
-#else
-  *out = maybe;
-  return true;
-#endif
-}
-
-}  // namespace Napi
+#pragma once
+#include "napi.h"
+
+namespace Napi {
+
+// Use this when a variable or parameter is unused in order to explicitly
+// silence a compiler warning about that.
+template <typename T>
+inline void USE(T&&) {}
+
+/**
+ * A test helper that converts MaybeOrValue<T> to T by checking that
+ * MaybeOrValue is NOT an empty Maybe when NODE_ADDON_API_ENABLE_MAYBE is
+ * defined.
+ *
+ * Do nothing when NODE_ADDON_API_ENABLE_MAYBE is not defined.
+ */
+template <typename T>
+inline T MaybeUnwrap(MaybeOrValue<T> maybe) {
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+  return maybe.Unwrap();
+#else
+  return maybe;
+#endif
+}
+
+/**
+ * A test helper that converts MaybeOrValue<T> to T by getting the value that
+ * wrapped by the Maybe or return the default_value if the Maybe is empty when
+ * NODE_ADDON_API_ENABLE_MAYBE is defined.
+ *
+ * Do nothing when NODE_ADDON_API_ENABLE_MAYBE is not defined.
+ */
+template <typename T>
+inline T MaybeUnwrapOr(MaybeOrValue<T> maybe, const T& default_value) {
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+  return maybe.UnwrapOr(default_value);
+#else
+  USE(default_value);
+  return maybe;
+#endif
+}
+
+/**
+ * A test helper that converts MaybeOrValue<T> to T by getting the value that
+ * wrapped by the Maybe or return false if the Maybe is empty when
+ * NODE_ADDON_API_ENABLE_MAYBE is defined.
+ *
+ * Copying the value to out when NODE_ADDON_API_ENABLE_MAYBE is not defined.
+ */
+template <typename T>
+inline bool MaybeUnwrapTo(MaybeOrValue<T> maybe, T* out) {
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+  return maybe.UnwrapTo(out);
+#else
+  *out = maybe;
+  return true;
+#endif
+}
+
+}  // namespace Napi