koffi 1.1.0-beta.1 → 1.1.0-beta.4

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

@@ -0,0 +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);

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

@@ -0,0 +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;
+}

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

@@ -0,0 +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);
+}

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

@@ -0,0 +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'));
+  }
+}

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

@@ -0,0 +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;
+}

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

@@ -0,0 +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());
+}

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

@@ -0,0 +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;
+}

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

@@ -0,0 +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())
+  ]);
+};

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

@@ -0,0 +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;
+}

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

@@ -0,0 +1,45 @@
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('./testUtil');
+
+module.exports = require('./common').runTest(test);
+
+function test (binding) {
+  return testUtil.runGCTests([
+    'Plain C string',
+    () => {
+      const sum = binding.run_script.plainString();
+      assert.strictEqual(sum, 1 + 2 + 3);
+    },
+
+    'std::string',
+    () => {
+      const sum = binding.run_script.stdString();
+      assert.strictEqual(sum, 1 + 2 + 3);
+    },
+
+    'JavaScript string',
+    () => {
+      const sum = binding.run_script.jsString('1 + 2 + 3');
+      assert.strictEqual(sum, 1 + 2 + 3);
+    },
+
+    'JavaScript, but not a string',
+    () => {
+      assert.throws(() => {
+        binding.run_script.jsString(true);
+      }, {
+        name: 'TypeError',
+        message: 'A string was expected'
+      });
+    },
+
+    'With context',
+    () => {
+      const a = 1; const b = 2; const c = 3;
+      const sum = binding.run_script.withContext('a + b + c', { a, b, c });
+      assert.strictEqual(sum, a + b + c);
+    }
+  ]);
+}

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

@@ -0,0 +1,79 @@
+#include <napi.h>
+#include "test_helper.h"
+using namespace Napi;
+
+Symbol CreateNewSymbolWithNoArgs(const Napi::CallbackInfo&) {
+  return Napi::Symbol();
+}
+
+Symbol CreateNewSymbolWithCppStrDesc(const Napi::CallbackInfo& info) {
+  String cppStrKey = info[0].As<String>();
+  return Napi::Symbol::New(info.Env(), cppStrKey.Utf8Value());
+}
+
+Symbol CreateNewSymbolWithCStrDesc(const Napi::CallbackInfo& info) {
+  String cStrKey = info[0].As<String>();
+  return Napi::Symbol::New(info.Env(), cStrKey.Utf8Value().c_str());
+}
+
+Symbol CreateNewSymbolWithNapiString(const Napi::CallbackInfo& info) {
+  String strKey = info[0].As<String>();
+  return Napi::Symbol::New(info.Env(), strKey);
+}
+
+Symbol GetWellknownSymbol(const Napi::CallbackInfo& info) {
+  String registrySymbol = info[0].As<String>();
+  return MaybeUnwrap(
+      Napi::Symbol::WellKnown(info.Env(), registrySymbol.Utf8Value().c_str()));
+}
+
+Symbol FetchSymbolFromGlobalRegistry(const Napi::CallbackInfo& info) {
+  String registrySymbol = info[0].As<String>();
+  return MaybeUnwrap(Napi::Symbol::For(info.Env(), registrySymbol));
+}
+
+Symbol FetchSymbolFromGlobalRegistryWithCppKey(const Napi::CallbackInfo& info) {
+  String cppStringKey = info[0].As<String>();
+  return MaybeUnwrap(Napi::Symbol::For(info.Env(), cppStringKey.Utf8Value()));
+}
+
+Symbol FetchSymbolFromGlobalRegistryWithCKey(const Napi::CallbackInfo& info) {
+  String cppStringKey = info[0].As<String>();
+  return MaybeUnwrap(
+      Napi::Symbol::For(info.Env(), cppStringKey.Utf8Value().c_str()));
+}
+
+Symbol TestUndefinedSymbolsCanBeCreated(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return MaybeUnwrap(Napi::Symbol::For(env, env.Undefined()));
+}
+
+Symbol TestNullSymbolsCanBeCreated(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+  return MaybeUnwrap(Napi::Symbol::For(env, env.Null()));
+}
+
+Object InitSymbol(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createNewSymbolWithNoArgs"] =
+      Function::New(env, CreateNewSymbolWithNoArgs);
+  exports["createNewSymbolWithCppStr"] =
+      Function::New(env, CreateNewSymbolWithCppStrDesc);
+  exports["createNewSymbolWithCStr"] =
+      Function::New(env, CreateNewSymbolWithCStrDesc);
+  exports["createNewSymbolWithNapi"] =
+      Function::New(env, CreateNewSymbolWithNapiString);
+  exports["getWellKnownSymbol"] = Function::New(env, GetWellknownSymbol);
+  exports["getSymbolFromGlobalRegistry"] =
+      Function::New(env, FetchSymbolFromGlobalRegistry);
+  exports["getSymbolFromGlobalRegistryWithCKey"] =
+      Function::New(env, FetchSymbolFromGlobalRegistryWithCKey);
+  exports["getSymbolFromGlobalRegistryWithCppKey"] =
+      Function::New(env, FetchSymbolFromGlobalRegistryWithCppKey);
+  exports["testUndefinedSymbolCanBeCreated"] =
+      Function::New(env, TestUndefinedSymbolsCanBeCreated);
+  exports["testNullSymbolCanBeCreated"] =
+      Function::New(env, TestNullSymbolsCanBeCreated);
+  return exports;
+}

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

@@ -0,0 +1,73 @@
+'use strict';
+
+const buildType = process.config.target_defaults.default_configuration;
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+
+function test(binding)
+{
+    const majorNodeVersion = process.versions.node.split('.')[0];
+
+    let wellKnownSymbolFunctions = ['asyncIterator','hasInstance','isConcatSpreadable', 'iterator','match','replace','search','split','species','toPrimitive','toStringTag','unscopables'];
+    if (majorNodeVersion >= 12) {
+      wellKnownSymbolFunctions.push('matchAll');
+    }
+
+    function assertCanCreateSymbol(symbol)
+    {
+      assert(binding.symbol.createNewSymbolWithCppStr(symbol) !== null);
+      assert(binding.symbol.createNewSymbolWithCStr(symbol) !== null);
+      assert(binding.symbol.createNewSymbolWithNapi(symbol) !== null);
+    }
+
+    function assertSymbolAreUnique(symbol)
+    {
+        const symbolOne = binding.symbol.createNewSymbolWithCppStr(symbol);
+        const symbolTwo = binding.symbol.createNewSymbolWithCppStr(symbol);
+
+        assert(symbolOne !== symbolTwo);
+    }
+
+    function assertSymbolIsWellknown(symbol)
+    {
+      const symbOne = binding.symbol.getWellKnownSymbol(symbol);
+      const symbTwo = binding.symbol.getWellKnownSymbol(symbol);
+      assert(symbOne && symbTwo);
+      assert(symbOne === symbTwo);
+    }
+
+    function assertSymbolIsNotWellknown(symbol)
+    {
+      const symbolTest = binding.symbol.getWellKnownSymbol(symbol);
+      assert(symbolTest === undefined);
+    }
+
+    function assertCanCreateOrFetchGlobalSymbols(symbol, fetchFunction)
+    {
+      const symbOne = fetchFunction(symbol);
+      const symbTwo = fetchFunction(symbol);
+      assert(symbOne && symbTwo);
+      assert(symbOne === symbTwo);
+    }
+
+    assertCanCreateSymbol("testing");
+    assertSymbolAreUnique("symbol");
+    assertSymbolIsNotWellknown("testing");
+
+     for(const wellknownProperty of wellKnownSymbolFunctions)
+     {
+       assertSymbolIsWellknown(wellknownProperty);
+     }
+
+     assertCanCreateOrFetchGlobalSymbols("data", binding.symbol.getSymbolFromGlobalRegistry);
+     assertCanCreateOrFetchGlobalSymbols("CppKey", binding.symbol.getSymbolFromGlobalRegistryWithCppKey);
+     assertCanCreateOrFetchGlobalSymbols("CKey", binding.symbol.getSymbolFromGlobalRegistryWithCKey);
+
+    assert(binding.symbol.createNewSymbolWithNoArgs() === undefined);
+
+    assert(binding.symbol.testNullSymbolCanBeCreated() === binding.symbol.testNullSymbolCanBeCreated());
+    assert(binding.symbol.testUndefinedSymbolCanBeCreated() === binding.symbol.testUndefinedSymbolCanBeCreated());
+    assert(binding.symbol.testUndefinedSymbolCanBeCreated() !== binding.symbol.testNullSymbolCanBeCreated());
+}

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

@@ -0,0 +1,54 @@
+// Run each test function in sequence,
+// with an async delay and GC call between each.
+
+function tick(x) {
+  return new Promise((resolve) => {
+    setImmediate(function ontick() {
+      if (--x === 0) {
+        resolve();
+      } else {
+        setImmediate(ontick);
+      }
+    });
+  });
+};
+
+async function runGCTests(tests) {
+  // Break up test list into a list of lists of the form
+  // [ [ 'test name', function() {}, ... ], ..., ].
+  const testList = [];
+  let currentTest;
+  for (const item of tests) {
+    if (typeof item === 'string') {
+      currentTest = [];
+      testList.push(currentTest);
+    }
+    currentTest.push(item);
+  }
+
+  for (const test of testList) {
+    await (async function(test) {
+      let title;
+      for (let i = 0; i < test.length; i++) {
+        if (i === 0) {
+          title = test[i];
+        } else {
+          try {
+            test[i]();
+          } catch (e) {
+            console.error('Test failed: ' + title);
+            throw e;
+          }
+          if (i < tests.length - 1) {
+            global.gc();
+            await tick(10);
+          }
+        }
+      }
+    })(test);
+  }
+}
+
+module.exports = {
+  runGCTests,
+};