koffi 0.9.33 → 0.9.34

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

@@ -1,13 +0,0 @@
-'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 +0,0 @@
-#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 +0,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 +0,0 @@
-'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 +0,0 @@
-#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 +0,0 @@
-'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 +0,0 @@
-#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 +0,0 @@
-'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 +0,0 @@
-#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

@@ -1,45 +0,0 @@
-'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

@@ -1,79 +0,0 @@
-#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

@@ -1,73 +0,0 @@
-'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

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