koffi 0.9.2 → 0.9.5

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

@@ -1,30 +1,30 @@
-#include <napi.h>
-
-class TestMIBase {
-public:
-  TestMIBase() : test(0) {}
-  virtual void dummy() {}
-  uint32_t test;
-};
-
-class TestMI : public TestMIBase, public Napi::ObjectWrap<TestMI> {
-public:
-  TestMI(const Napi::CallbackInfo& info) :
-    Napi::ObjectWrap<TestMI>(info) {}
-
-  Napi::Value GetTest(const Napi::CallbackInfo& info) {
-    return Napi::Number::New(info.Env(), test);
-  }
-
-  static void Initialize(Napi::Env env, Napi::Object exports) {
-    exports.Set("TestMI", DefineClass(env, "TestMI", {
-      InstanceAccessor<&TestMI::GetTest>("test")
-    }));
-  }
-};
-
-Napi::Object InitObjectWrapMultipleInheritance(Napi::Env env) {
-  Napi::Object exports = Napi::Object::New(env);
-  TestMI::Initialize(env, exports);
-  return exports;
-}
+#include <napi.h>
+
+class TestMIBase {
+public:
+  TestMIBase() : test(0) {}
+  virtual void dummy() {}
+  uint32_t test;
+};
+
+class TestMI : public TestMIBase, public Napi::ObjectWrap<TestMI> {
+public:
+  TestMI(const Napi::CallbackInfo& info) :
+    Napi::ObjectWrap<TestMI>(info) {}
+
+  Napi::Value GetTest(const Napi::CallbackInfo& info) {
+    return Napi::Number::New(info.Env(), test);
+  }
+
+  static void Initialize(Napi::Env env, Napi::Object exports) {
+    exports.Set("TestMI", DefineClass(env, "TestMI", {
+      InstanceAccessor<&TestMI::GetTest>("test")
+    }));
+  }
+};
+
+Napi::Object InitObjectWrapMultipleInheritance(Napi::Env env) {
+  Napi::Object exports = Napi::Object::New(env);
+  TestMI::Initialize(env, exports);
+  return exports;
+}

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

@@ -1,13 +1,13 @@
-'use strict';
-
-const assert = require('assert');
-
-const test = bindingName => {
-  const binding = require(bindingName);
-  const TestMI = binding.objectwrap_multiple_inheritance.TestMI;
-  const testmi = new TestMI();
-
-  assert.strictEqual(testmi.test, 0);
-}
-
-module.exports = require('./common').runTestWithBindingPath(test);
+'use strict';
+
+const assert = require('assert');
+
+const test = bindingName => {
+  const binding = require(bindingName);
+  const TestMI = binding.objectwrap_multiple_inheritance.TestMI;
+  const testmi = new TestMI();
+
+  assert.strictEqual(testmi.test, 0);
+}
+
+module.exports = require('./common').runTestWithBindingPath(test);

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

@@ -1,45 +1,45 @@
-#include <assert.h>
-#include <napi.h>
-
-namespace {
-
-static int dtor_called = 0;
-
-class DtorCounter {
- public:
-  ~DtorCounter() {
-    assert(dtor_called == 0);
-    dtor_called++;
-  }
-};
-
-Napi::Value GetDtorCalled(const Napi::CallbackInfo& info) {
-  return Napi::Number::New(info.Env(), dtor_called);
-}
-
-class Test : public Napi::ObjectWrap<Test> {
- public:
-  Test(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Test>(info) {
-#ifdef NAPI_CPP_EXCEPTIONS
-    throw Napi::Error::New(Env(), "Some error");
-#else
-    Napi::Error::New(Env(), "Some error").ThrowAsJavaScriptException();
-#endif
-  }
-
-  static void Initialize(Napi::Env env, Napi::Object exports) {
-    exports.Set("Test", DefineClass(env, "Test", {}));
-    exports.Set("getDtorCalled", Napi::Function::New(env, GetDtorCalled));
-  }
-
- private:
-  DtorCounter dtor_counter_;
-};
-
-}  // anonymous namespace
-
-Napi::Object InitObjectWrapRemoveWrap(Napi::Env env) {
-  Napi::Object exports = Napi::Object::New(env);
-  Test::Initialize(env, exports);
-  return exports;
-}
+#include <assert.h>
+#include <napi.h>
+
+namespace {
+
+static int dtor_called = 0;
+
+class DtorCounter {
+ public:
+  ~DtorCounter() {
+    assert(dtor_called == 0);
+    dtor_called++;
+  }
+};
+
+Napi::Value GetDtorCalled(const Napi::CallbackInfo& info) {
+  return Napi::Number::New(info.Env(), dtor_called);
+}
+
+class Test : public Napi::ObjectWrap<Test> {
+ public:
+  Test(const Napi::CallbackInfo& info) : Napi::ObjectWrap<Test>(info) {
+#ifdef NAPI_CPP_EXCEPTIONS
+    throw Napi::Error::New(Env(), "Some error");
+#else
+    Napi::Error::New(Env(), "Some error").ThrowAsJavaScriptException();
+#endif
+  }
+
+  static void Initialize(Napi::Env env, Napi::Object exports) {
+    exports.Set("Test", DefineClass(env, "Test", {}));
+    exports.Set("getDtorCalled", Napi::Function::New(env, GetDtorCalled));
+  }
+
+ private:
+  DtorCounter dtor_counter_;
+};
+
+}  // anonymous namespace
+
+Napi::Object InitObjectWrapRemoveWrap(Napi::Env env) {
+  Napi::Object exports = Napi::Object::New(env);
+  Test::Initialize(env, exports);
+  return exports;
+}

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

@@ -1,40 +1,40 @@
-'use strict';
-
-if (process.argv[2] === 'child') {
-  // Create a single wrapped instance then exit.
-  return new (require(process.argv[3]).objectwrap.Test)();
-}
-
-const assert = require('assert');
-const { spawnSync } = require('child_process');
-const testUtil = require('./testUtil');
-
-module.exports = require('./common').runTestWithBindingPath(test);
-
-function test(bindingName) {
-  return testUtil.runGCTests([
-    'objectwrap removewrap test',
-    () => {
-      const binding = require(bindingName);
-      const Test = binding.objectwrap_removewrap.Test;
-      const getDtorCalled = binding.objectwrap_removewrap.getDtorCalled;
-
-      assert.strictEqual(getDtorCalled(), 0);
-      assert.throws(() => {
-        new Test();
-      });
-      assert.strictEqual(getDtorCalled(), 1);
-    },
-    // Test that gc does not crash.
-    () => {}
-  ]);
-
-  // Start a child process that creates a single wrapped instance to ensure that
-  // it is properly freed at its exit. It must not segfault.
-  // Re: https://github.com/nodejs/node-addon-api/issues/660
-  const child = spawnSync(process.execPath, [
-    __filename, 'child', bindingName
-  ]);
-  assert.strictEqual(child.signal, null);
-  assert.strictEqual(child.status, 0);
-}
+'use strict';
+
+if (process.argv[2] === 'child') {
+  // Create a single wrapped instance then exit.
+  return new (require(process.argv[3]).objectwrap.Test)();
+}
+
+const assert = require('assert');
+const { spawnSync } = require('child_process');
+const testUtil = require('./testUtil');
+
+module.exports = require('./common').runTestWithBindingPath(test);
+
+function test(bindingName) {
+  return testUtil.runGCTests([
+    'objectwrap removewrap test',
+    () => {
+      const binding = require(bindingName);
+      const Test = binding.objectwrap_removewrap.Test;
+      const getDtorCalled = binding.objectwrap_removewrap.getDtorCalled;
+
+      assert.strictEqual(getDtorCalled(), 0);
+      assert.throws(() => {
+        new Test();
+      });
+      assert.strictEqual(getDtorCalled(), 1);
+    },
+    // Test that gc does not crash.
+    () => {}
+  ]);
+
+  // Start a child process that creates a single wrapped instance to ensure that
+  // it is properly freed at its exit. It must not segfault.
+  // Re: https://github.com/nodejs/node-addon-api/issues/660
+  const child = spawnSync(process.execPath, [
+    __filename, 'child', bindingName
+  ]);
+  assert.strictEqual(child.signal, null);
+  assert.strictEqual(child.status, 0);
+}

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

@@ -1,19 +1,19 @@
-'use strict';
-const path = require('path');
-const { Worker, isMainThread, workerData } = require('worker_threads');
-
-module.exports = require('./common').runTestWithBuildType(test);
-
-async function test(buildType) {
-  if (isMainThread) {
-    const buildType = process.config.target_defaults.default_configuration;
-    const worker = new Worker(__filename, { workerData: buildType });
-    return new Promise((resolve, reject) => {
-      worker.on('exit', () => {
-        resolve();
-      });
-    }, () => {});
-  } else {
-    await require(path.join(__dirname, 'objectwrap.js'));
-  }
-}
+'use strict';
+const path = require('path');
+const { Worker, isMainThread, workerData } = require('worker_threads');
+
+module.exports = require('./common').runTestWithBuildType(test);
+
+async function test(buildType) {
+  if (isMainThread) {
+    const buildType = process.config.target_defaults.default_configuration;
+    const worker = new Worker(__filename, { workerData: buildType });
+    return new Promise((resolve, reject) => {
+      worker.on('exit', () => {
+        resolve();
+      });
+    }, () => {});
+  } else {
+    await require(path.join(__dirname, 'objectwrap.js'));
+  }
+}

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

@@ -1,29 +1,29 @@
-#include "napi.h"
-
-using namespace Napi;
-
-Value IsPromise(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].IsPromise());
-}
-
-Value ResolvePromise(const CallbackInfo& info) {
-  auto deferred = Promise::Deferred::New(info.Env());
-  deferred.Resolve(info[0]);
-  return deferred.Promise();
-}
-
-Value RejectPromise(const CallbackInfo& info) {
-  auto deferred = Promise::Deferred::New(info.Env());
-  deferred.Reject(info[0]);
-  return deferred.Promise();
-}
-
-Object InitPromise(Env env) {
-  Object exports = Object::New(env);
-
-  exports["isPromise"] = Function::New(env, IsPromise);
-  exports["resolvePromise"] = Function::New(env, ResolvePromise);
-  exports["rejectPromise"] = Function::New(env, RejectPromise);
-
-  return exports;
-}
+#include "napi.h"
+
+using namespace Napi;
+
+Value IsPromise(const CallbackInfo& info) {
+  return Boolean::New(info.Env(), info[0].IsPromise());
+}
+
+Value ResolvePromise(const CallbackInfo& info) {
+  auto deferred = Promise::Deferred::New(info.Env());
+  deferred.Resolve(info[0]);
+  return deferred.Promise();
+}
+
+Value RejectPromise(const CallbackInfo& info) {
+  auto deferred = Promise::Deferred::New(info.Env());
+  deferred.Reject(info[0]);
+  return deferred.Promise();
+}
+
+Object InitPromise(Env env) {
+  Object exports = Object::New(env);
+
+  exports["isPromise"] = Function::New(env, IsPromise);
+  exports["resolvePromise"] = Function::New(env, ResolvePromise);
+  exports["rejectPromise"] = Function::New(env, RejectPromise);
+
+  return exports;
+}

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

@@ -1,18 +1,18 @@
-'use strict';
-
-const assert = require('assert');
-const common = require('./common');
-
-module.exports = common.runTest(test);
-
-async function test(binding) {
-  assert.strictEqual(binding.promise.isPromise({}), false);
-
-  const resolving = binding.promise.resolvePromise('resolved');
-  await assert.strictEqual(binding.promise.isPromise(resolving), true);
-  resolving.then(common.mustCall()).catch(common.mustNotCall());
-
-  const rejecting = binding.promise.rejectPromise('error');
-  await assert.strictEqual(binding.promise.isPromise(rejecting), true);
-  rejecting.then(common.mustNotCall()).catch(common.mustCall());
-}
+'use strict';
+
+const assert = require('assert');
+const common = require('./common');
+
+module.exports = common.runTest(test);
+
+async function test(binding) {
+  assert.strictEqual(binding.promise.isPromise({}), false);
+
+  const resolving = binding.promise.resolvePromise('resolved');
+  await assert.strictEqual(binding.promise.isPromise(resolving), true);
+  resolving.then(common.mustCall()).catch(common.mustNotCall());
+
+  const rejecting = binding.promise.rejectPromise('error');
+  await assert.strictEqual(binding.promise.isPromise(rejecting), true);
+  rejecting.then(common.mustNotCall()).catch(common.mustCall());
+}

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

@@ -1,24 +1,24 @@
-#include "napi.h"
-
-using namespace Napi;
-
-static Reference<Buffer<uint8_t>> weak;
-
-void  CreateWeakArray(const CallbackInfo& info) {
-  weak = Weak(Buffer<uint8_t>::New(info.Env(), 1));
-  weak.SuppressDestruct();
-}
-
-napi_value AccessWeakArrayEmpty(const CallbackInfo& info) {
-  Buffer<uint8_t> value = weak.Value();
-  return Napi::Boolean::New(info.Env(), value.IsEmpty());
-}
-
-Object InitReference(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createWeakArray"] = Function::New(env, CreateWeakArray);
-  exports["accessWeakArrayEmpty"] = Function::New(env, AccessWeakArrayEmpty);
-
-  return exports;
-}
+#include "napi.h"
+
+using namespace Napi;
+
+static Reference<Buffer<uint8_t>> weak;
+
+void  CreateWeakArray(const CallbackInfo& info) {
+  weak = Weak(Buffer<uint8_t>::New(info.Env(), 1));
+  weak.SuppressDestruct();
+}
+
+napi_value AccessWeakArrayEmpty(const CallbackInfo& info) {
+  Buffer<uint8_t> value = weak.Value();
+  return Napi::Boolean::New(info.Env(), value.IsEmpty());
+}
+
+Object InitReference(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createWeakArray"] = Function::New(env, CreateWeakArray);
+  exports["accessWeakArrayEmpty"] = Function::New(env, AccessWeakArrayEmpty);
+
+  return exports;
+}

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

@@ -1,14 +1,14 @@
-'use strict';
-
-const assert = require('assert');
-const testUtil = require('./testUtil');
-
-module.exports = require('./common').runTest(test);
-
-function test(binding) {
-  return testUtil.runGCTests([
-    'test reference',
-    () => binding.reference.createWeakArray(),
-    () => assert.strictEqual(true, binding.reference.accessWeakArrayEmpty())
-  ]);
-};
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('./testUtil');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  return testUtil.runGCTests([
+    'test reference',
+    () => binding.reference.createWeakArray(),
+    () => assert.strictEqual(true, binding.reference.accessWeakArrayEmpty())
+  ]);
+};

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

@@ -1,56 +1,56 @@
-#include "napi.h"
-#include "test_helper.h"
-
-using namespace Napi;
-
-namespace {
-
-Value RunPlainString(const CallbackInfo& info) {
-  Env env = info.Env();
-  return MaybeUnwrap(env.RunScript("1 + 2 + 3"));
-}
-
-Value RunStdString(const CallbackInfo& info) {
-  Env env = info.Env();
-  std::string str = "1 + 2 + 3";
-  return MaybeUnwrap(env.RunScript(str));
-}
-
-Value RunJsString(const CallbackInfo& info) {
-  Env env = info.Env();
-  return MaybeUnwrapOr(env.RunScript(info[0].As<String>()), Value());
-}
-
-Value RunWithContext(const CallbackInfo& info) {
-  Env env = info.Env();
-
-  Array keys = MaybeUnwrap(info[1].As<Object>().GetPropertyNames());
-  std::string code = "(";
-  for (unsigned int i = 0; i < keys.Length(); i++) {
-    if (i != 0) code += ",";
-    code += MaybeUnwrap(keys.Get(i)).As<String>().Utf8Value();
-  }
-  code += ") => " + info[0].As<String>().Utf8Value();
-
-  Value ret = MaybeUnwrap(env.RunScript(code));
-  Function fn = ret.As<Function>();
-  std::vector<napi_value> args;
-  for (unsigned int i = 0; i < keys.Length(); i++) {
-    Value key = MaybeUnwrap(keys.Get(i));
-    args.push_back(MaybeUnwrap(info[1].As<Object>().Get(key)));
-  }
-  return MaybeUnwrap(fn.Call(args));
-}
-
-} // end anonymous namespace
-
-Object InitRunScript(Env env) {
-  Object exports = Object::New(env);
-
-  exports["plainString"] = Function::New(env, RunPlainString);
-  exports["stdString"] = Function::New(env, RunStdString);
-  exports["jsString"] = Function::New(env, RunJsString);
-  exports["withContext"] = Function::New(env, RunWithContext);
-
-  return exports;
-}
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+namespace {
+
+Value RunPlainString(const CallbackInfo& info) {
+  Env env = info.Env();
+  return MaybeUnwrap(env.RunScript("1 + 2 + 3"));
+}
+
+Value RunStdString(const CallbackInfo& info) {
+  Env env = info.Env();
+  std::string str = "1 + 2 + 3";
+  return MaybeUnwrap(env.RunScript(str));
+}
+
+Value RunJsString(const CallbackInfo& info) {
+  Env env = info.Env();
+  return MaybeUnwrapOr(env.RunScript(info[0].As<String>()), Value());
+}
+
+Value RunWithContext(const CallbackInfo& info) {
+  Env env = info.Env();
+
+  Array keys = MaybeUnwrap(info[1].As<Object>().GetPropertyNames());
+  std::string code = "(";
+  for (unsigned int i = 0; i < keys.Length(); i++) {
+    if (i != 0) code += ",";
+    code += MaybeUnwrap(keys.Get(i)).As<String>().Utf8Value();
+  }
+  code += ") => " + info[0].As<String>().Utf8Value();
+
+  Value ret = MaybeUnwrap(env.RunScript(code));
+  Function fn = ret.As<Function>();
+  std::vector<napi_value> args;
+  for (unsigned int i = 0; i < keys.Length(); i++) {
+    Value key = MaybeUnwrap(keys.Get(i));
+    args.push_back(MaybeUnwrap(info[1].As<Object>().Get(key)));
+  }
+  return MaybeUnwrap(fn.Call(args));
+}
+
+} // end anonymous namespace
+
+Object InitRunScript(Env env) {
+  Object exports = Object::New(env);
+
+  exports["plainString"] = Function::New(env, RunPlainString);
+  exports["stdString"] = Function::New(env, RunStdString);
+  exports["jsString"] = Function::New(env, RunJsString);
+  exports["withContext"] = Function::New(env, RunWithContext);
+
+  return exports;
+}