koffi 2.16.0-beta.2 → 2.16.0

package/vendor/node-addon-api/test/globalObject/global_object_set_property.cc

@@ -1,31 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-void SetPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  String key = info[0].UnsafeAs<String>();
-  Value value = info[1];
-  globalObject.Set(key.Utf8Value().c_str(), value);
-}
-
-void SetPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  String key = info[0].UnsafeAs<String>();
-  Value value = info[1];
-  globalObject.Set(key.Utf8Value(), value);
-}
-
-void SetPropertyWithInt32AsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  Number key = info[0].UnsafeAs<Number>();
-  Value value = info[1];
-  globalObject.Set(key.Uint32Value(), value);
-}
-
-void SetPropertyWithNapiValueAsKey(const CallbackInfo& info) {
-  Object globalObject = info.Env().Global();
-  Name key = info[0].UnsafeAs<Name>();
-  Value value = info[1];
-  globalObject.Set(key, value);
-}

package/vendor/node-addon-api/test/globalObject/global_object_set_property.js

@@ -1,56 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test (binding) {
-  const KEY_TYPE = {
-    C_STR: 'KEY_AS_C_STRING',
-    CPP_STR: 'KEY_AS_CPP_STRING',
-    NAPI: 'KEY_AS_NAPI_VALUES',
-    INT_32: 'KEY_AS_INT_32_NUM'
-  };
-
-  function setGlobalObjectKeyValue (key, value, keyType) {
-    switch (keyType) {
-      case KEY_TYPE.CPP_STR:
-        binding.globalObject.setPropertyWithCppStyleString(key, value);
-        break;
-
-      case KEY_TYPE.C_STR:
-        binding.globalObject.setPropertyWithCStyleString(key, value);
-        break;
-
-      case KEY_TYPE.INT_32:
-        binding.globalObject.setPropertyWithInt32(key, value);
-        break;
-
-      case KEY_TYPE.NAPI:
-        binding.globalObject.setPropertyWithNapiValue(key, value);
-        break;
-    }
-  }
-
-  function assertErrMessageIsThrown (nativeObjectSetFunction, errMsg) {
-    assert.throws(() => {
-      nativeObjectSetFunction(undefined, 1);
-    }, errMsg);
-  }
-
-  setGlobalObjectKeyValue('cKey', 'cValue', KEY_TYPE.CPP_STR);
-  setGlobalObjectKeyValue(1, 10, KEY_TYPE.INT_32);
-  setGlobalObjectKeyValue('napi_key', 'napi_value', KEY_TYPE.NAPI);
-  setGlobalObjectKeyValue('cppKey', 'cppValue', KEY_TYPE.CPP_STR);
-  setGlobalObjectKeyValue('circular', global, KEY_TYPE.NAPI);
-
-  assert.deepStrictEqual(global.circular, global);
-  assert.deepStrictEqual(global.cppKey, 'cppValue');
-  assert.deepStrictEqual(global.napi_key, 'napi_value');
-  assert.deepStrictEqual(global[1], 10);
-  assert.deepStrictEqual(global.cKey, 'cValue');
-
-  assertErrMessageIsThrown(binding.globalObject.setPropertyWithCppStyleString, 'Error: A string was expected');
-  assertErrMessageIsThrown(binding.globalObject.setPropertyWithCStyleString, 'Error: A string was expected');
-  assertErrMessageIsThrown(binding.globalObject.setPropertyWithInt32, 'Error: A number was expected');
-}

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

@@ -1,86 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-#include "napi.h"
-#include "string.h"
-
-using namespace Napi;
-
-Value createScope(const CallbackInfo& info) {
-  {
-    HandleScope scope(info.Env());
-    String::New(info.Env(), "inner-scope");
-  }
-  return String::New(info.Env(), "scope");
-}
-
-Value createScopeFromExisting(const CallbackInfo& info) {
-  {
-    napi_handle_scope scope;
-    napi_open_handle_scope(info.Env(), &scope);
-    HandleScope scope_existing(info.Env(), scope);
-    String::New(scope_existing.Env(), "inner-existing-scope");
-  }
-  return String::New(info.Env(), "existing_scope");
-}
-
-Value escapeFromScope(const CallbackInfo& info) {
-  Value result;
-  {
-    EscapableHandleScope scope(info.Env());
-    result = scope.Escape(String::New(info.Env(), "inner-scope"));
-  }
-  return result;
-}
-
-Value escapeFromExistingScope(const CallbackInfo& info) {
-  Value result;
-  {
-    napi_escapable_handle_scope scope;
-    napi_open_escapable_handle_scope(info.Env(), &scope);
-    EscapableHandleScope scope_existing(info.Env(), scope);
-    result = scope_existing.Escape(
-        String::New(scope_existing.Env(), "inner-existing-scope"));
-  }
-  return result;
-}
-
-#define LOOP_MAX 1000000
-Value stressEscapeFromScope(const CallbackInfo& info) {
-  Value result;
-  for (int i = 0; i < LOOP_MAX; i++) {
-    EscapableHandleScope scope(info.Env());
-    char buffer[128];
-    snprintf(buffer, 128, "%d", i);
-    std::string name = std::string("inner-scope") + std::string(buffer);
-    Value newValue = String::New(info.Env(), name.c_str());
-    if (i == (LOOP_MAX - 1)) {
-      result = scope.Escape(newValue);
-    }
-  }
-  return result;
-}
-
-Value doubleEscapeFromScope(const CallbackInfo& info) {
-  Value result;
-  {
-    EscapableHandleScope scope(info.Env());
-    result = scope.Escape(String::New(info.Env(), "inner-scope"));
-    result = scope.Escape(String::New(info.Env(), "inner-scope"));
-  }
-  return result;
-}
-
-Object InitHandleScope(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createScope"] = Function::New(env, createScope);
-  exports["createScopeFromExisting"] =
-      Function::New(env, createScopeFromExisting);
-  exports["escapeFromScope"] = Function::New(env, escapeFromScope);
-  exports["escapeFromExistingScope"] =
-      Function::New(env, escapeFromExistingScope);
-  exports["stressEscapeFromScope"] = Function::New(env, stressEscapeFromScope);
-  exports["doubleEscapeFromScope"] = Function::New(env, doubleEscapeFromScope);
-
-  return exports;
-}

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

@@ -1,16 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test (binding) {
-  assert.strictEqual(binding.handlescope.createScope(), 'scope');
-  assert.strictEqual(binding.handlescope.createScopeFromExisting(), 'existing_scope');
-  assert.strictEqual(binding.handlescope.escapeFromScope(), 'inner-scope');
-  assert.strictEqual(binding.handlescope.escapeFromExistingScope(), 'inner-existing-scope');
-  assert.strictEqual(binding.handlescope.stressEscapeFromScope(), 'inner-scope999999');
-  assert.throws(() => binding.handlescope.doubleEscapeFromScope(),
-    Error,
-    ' napi_escape_handle already called on scope');
-}

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

@@ -1,160 +0,0 @@
-'use strict';
-
-const majorNodeVersion = process.versions.node.split('.')[0];
-
-if (typeof global.gc !== 'function') {
-  // Construct the correct (version-dependent) command-line args.
-  const args = ['--expose-gc'];
-  const majorV8Version = process.versions.v8.split('.')[0];
-  if (majorV8Version < 9) {
-    args.push('--no-concurrent-array-buffer-freeing');
-  }
-  if (majorNodeVersion >= 14) {
-    args.push('--no-concurrent-array-buffer-sweeping');
-  }
-  args.push(__filename);
-
-  const child = require('./napi_child').spawnSync(process.argv[0], args, {
-    stdio: 'inherit'
-  });
-
-  if (child.signal) {
-    console.error(`Tests aborted with ${child.signal}`);
-    process.exitCode = 1;
-  } else {
-    process.exitCode = child.status;
-  }
-  process.exit(process.exitCode);
-}
-
-const testModules = [];
-
-const fs = require('fs');
-const path = require('path');
-
-let filterCondition = process.env.npm_config_filter || '';
-let filterConditionFiles = [];
-
-if (filterCondition !== '') {
-  filterCondition = require('../unit-test/matchModules').matchWildCards(process.env.npm_config_filter);
-  filterConditionFiles = filterCondition.split(' ').length > 0 ? filterCondition.split(' ') : [filterCondition];
-}
-
-const filterConditionsProvided = filterConditionFiles.length > 0;
-
-function checkFilterCondition (fileName, parsedFilepath) {
-  let result = false;
-
-  if (!filterConditionsProvided) return true;
-  if (filterConditionFiles.includes(parsedFilepath)) result = true;
-  if (filterConditionFiles.includes(fileName)) result = true;
-  return result;
-}
-
-// TODO(RaisinTen): Update this when the test filenames
-// are changed into test_*.js.
-function loadTestModules (currentDirectory = __dirname, pre = '') {
-  fs.readdirSync(currentDirectory).forEach((file) => {
-    if (currentDirectory === __dirname && (
-      file === 'binding.cc' ||
-          file === 'binding.gyp' ||
-          file === 'build' ||
-          file === 'common' ||
-          file === 'child_processes' ||
-          file === 'napi_child.js' ||
-          file === 'testUtil.js' ||
-          file === 'thunking_manual.cc' ||
-          file === 'thunking_manual.js' ||
-          file === 'index.js' ||
-          file[0] === '.')) {
-      return;
-    }
-    const absoluteFilepath = path.join(currentDirectory, file);
-    const parsedFilepath = path.parse(file);
-    const parsedPath = path.parse(currentDirectory);
-
-    if (fs.statSync(absoluteFilepath).isDirectory()) {
-      if (fs.existsSync(absoluteFilepath + '/index.js')) {
-        if (checkFilterCondition(parsedFilepath.name, parsedPath.base)) {
-          testModules.push(pre + file);
-        }
-      } else {
-        loadTestModules(absoluteFilepath, pre + file + '/');
-      }
-    } else {
-      if (parsedFilepath.ext === '.js' && checkFilterCondition(parsedFilepath.name, parsedPath.base)) {
-        testModules.push(pre + parsedFilepath.name);
-      }
-    }
-  });
-}
-
-loadTestModules();
-
-let napiVersion = Number(process.versions.napi);
-if (process.env.NAPI_VERSION) {
-  // we need this so that we don't try run tests that rely
-  // on methods that are not available in the NAPI_VERSION
-  // specified
-  napiVersion = process.env.NAPI_VERSION;
-}
-console.log('napiVersion:' + napiVersion);
-
-if (napiVersion < 3) {
-  testModules.splice(testModules.indexOf('env_cleanup'), 1);
-  testModules.splice(testModules.indexOf('callbackscope'), 1);
-  testModules.splice(testModules.indexOf('version_management'), 1);
-}
-
-if (napiVersion < 4 && !filterConditionsProvided) {
-  testModules.splice(testModules.indexOf('asyncprogressqueueworker'), 1);
-  testModules.splice(testModules.indexOf('asyncprogressworker'), 1);
-  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_ctx'), 1);
-  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_existing_tsfn'), 1);
-  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_ptr'), 1);
-  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_sum'), 1);
-  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_unref'), 1);
-  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function'), 1);
-}
-
-if (napiVersion < 5 && !filterConditionsProvided) {
-  testModules.splice(testModules.indexOf('date'), 1);
-}
-
-if (napiVersion < 6 && !filterConditionsProvided) {
-  testModules.splice(testModules.indexOf('addon'), 1);
-  testModules.splice(testModules.indexOf('addon_data'), 1);
-  testModules.splice(testModules.indexOf('bigint'), 1);
-  testModules.splice(testModules.indexOf('typedarray-bigint'), 1);
-}
-
-if (majorNodeVersion < 12 && !filterConditionsProvided) {
-  testModules.splice(testModules.indexOf('objectwrap_worker_thread'), 1);
-  testModules.splice(testModules.indexOf('error_terminating_environment'), 1);
-}
-
-if (napiVersion < 8 && !filterConditionsProvided) {
-  testModules.splice(testModules.indexOf('object/object_freeze_seal'), 1);
-  testModules.splice(testModules.indexOf('type_taggable'), 1);
-}
-
-if (napiVersion < 9 && !filterConditionsProvided) {
-  testModules.splice(testModules.indexOf('env_misc'), 1);
-}
-
-(async function () {
-  console.log(`Testing with Node-API Version '${napiVersion}'.`);
-
-  if (filterConditionsProvided) { console.log('Starting test suite\n', testModules); } else { console.log('Starting test suite\n'); }
-
-  // Requiring each module runs tests in the module.
-  for (const name of testModules) {
-    console.log(`Running test '${name}'`);
-    await require('./' + name);
-  }
-
-  console.log('\nAll tests passed!');
-})().catch((error) => {
-  console.log(error);
-  process.exit(1);
-});

package/vendor/node-addon-api/test/maybe/check.cc

@@ -1,69 +0,0 @@
-#include "assert.h"
-#include "napi.h"
-#if defined(NODE_ADDON_API_ENABLE_MAYBE)
-
-using namespace Napi;
-
-namespace {
-
-void VoidCallback(const CallbackInfo& info) {
-  Napi::Function fn = info[0].As<Function>();
-  Maybe<Value> ret = fn.Call({});
-
-  assert(ret.IsNothing() == true);
-  assert(ret.IsJust() == false);
-
-  Napi::Value placeHolder = Napi::Number::New(info.Env(), 12345);
-  Napi::Value unwrappedValue = ret.UnwrapOr(placeHolder);
-
-  assert(unwrappedValue.As<Number>().Uint32Value() == 12345);
-
-  assert(ret.UnwrapTo(&placeHolder) == false);
-  assert(placeHolder.As<Number>().Uint32Value() == 12345);
-
-  ret.Check();
-}
-
-void TestMaybeOperatorOverload(const CallbackInfo& info) {
-  Napi::Function fn_a = info[0].As<Function>();
-  Napi::Function fn_b = info[1].As<Function>();
-
-  assert(fn_a.Call({}) == fn_a.Call({}));
-  assert(fn_a.Call({}) != fn_b.Call({}));
-}
-
-void NormalJsCallback(const CallbackInfo& info) {
-  Napi::Function fn = info[0].As<Function>();
-  uint32_t magic_number = info[1].As<Number>().Uint32Value();
-
-  Maybe<Value> ret = fn.Call({});
-
-  assert(ret.IsNothing() == false);
-  assert(ret.IsJust() == true);
-
-  Napi::Value unwrappedValue = ret.Unwrap();
-  assert(unwrappedValue.IsNumber() == true);
-
-  assert(unwrappedValue.As<Number>().Uint32Value() == magic_number);
-
-  unwrappedValue =
-      ret.UnwrapOr(Napi::Number::New(info.Env(), magic_number - 1));
-  assert(unwrappedValue.As<Number>().Uint32Value() == magic_number);
-
-  Napi::Value placeHolder = Napi::Number::New(info.Env(), magic_number - 1);
-  assert(ret.UnwrapTo(&placeHolder) == true);
-  assert(placeHolder.As<Number>().Uint32Value() == magic_number);
-}
-
-}  // end anonymous namespace
-
-Object InitMaybeCheck(Env env) {
-  Object exports = Object::New(env);
-  exports.Set("voidCallback", Function::New(env, VoidCallback));
-  exports.Set("normalJsCallback", Function::New(env, NormalJsCallback));
-  exports.Set("testMaybeOverloadOp",
-              Function::New(env, TestMaybeOperatorOverload));
-  return exports;
-}
-
-#endif

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

@@ -1,50 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-const { whichBuildType } = require('../common');
-
-const napiChild = require('../napi_child');
-
-module.exports = async function wrapTest () {
-  const buildType = await whichBuildType();
-  test(require(`../build/${buildType}/binding_noexcept_maybe.node`).maybe_check);
-};
-
-function test (binding) {
-  if (process.argv.includes('child')) {
-    child(binding);
-    return;
-  }
-  const cp = napiChild.spawn(process.execPath, [__filename, 'child'], {
-    stdio: ['ignore', 'inherit', 'pipe']
-  });
-  cp.stderr.setEncoding('utf8');
-  let stderr = '';
-  cp.stderr.on('data', chunk => {
-    stderr += chunk;
-  });
-  cp.on('exit', (code, signal) => {
-    if (process.platform === 'win32') {
-      assert.strictEqual(code, 128 + 6 /* SIGABRT */);
-    } else {
-      assert.strictEqual(signal, 'SIGABRT');
-    }
-    assert.ok(stderr.match(/FATAL ERROR: Napi::Maybe::Check Maybe value is Nothing./));
-  });
-}
-
-function child (binding) {
-  const MAGIC_NUMBER = 12459062;
-  binding.normalJsCallback(() => {
-    return MAGIC_NUMBER;
-  }, MAGIC_NUMBER);
-
-  binding.testMaybeOverloadOp(
-    () => { return MAGIC_NUMBER; },
-    () => { throw Error('Foobar'); }
-  );
-
-  binding.voidCallback(() => {
-    throw new Error('foobar');
-  });
-}

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

@@ -1,18 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-Value externalAllocatedMemory(const CallbackInfo& info) {
-  int64_t kSize = 1024 * 1024;
-  int64_t baseline = MemoryManagement::AdjustExternalMemory(info.Env(), 0);
-  int64_t tmp = MemoryManagement::AdjustExternalMemory(info.Env(), kSize);
-  tmp = MemoryManagement::AdjustExternalMemory(info.Env(), -kSize);
-  return Boolean::New(info.Env(), tmp == baseline);
-}
-
-Object InitMemoryManagement(Env env) {
-  Object exports = Object::New(env);
-  exports["externalAllocatedMemory"] =
-      Function::New(env, externalAllocatedMemory);
-  return exports;
-}

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

@@ -1,9 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest(test);
-
-function test (binding) {
-  assert.strictEqual(binding.memory_management.externalAllocatedMemory(), true);
-}

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

@@ -1,23 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-Value createExternal(const CallbackInfo& info) {
-  FunctionReference ref = Reference<Function>::New(info[0].As<Function>(), 1);
-  auto ret = External<char>::New(
-      info.Env(),
-      nullptr,
-      [ref = std::move(ref)](Napi::Env /*env*/, char* /*data*/) {
-        ref.Call({});
-      });
-
-  return ret;
-}
-
-Object InitMovableCallbacks(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createExternal"] = Function::New(env, createExternal);
-
-  return exports;
-}

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

@@ -1,21 +0,0 @@
-'use strict';
-
-const common = require('./common');
-const testUtil = require('./testUtil');
-
-module.exports = require('./common').runTest(binding => test(binding.movable_callbacks));
-
-async function test (binding) {
-  await testUtil.runGCTests([
-    'External',
-    () => {
-      const fn = common.mustCall(() => {
-        // noop
-      }, 1);
-      binding.createExternal(fn);
-    },
-    () => {
-      // noop, wait for gc
-    }
-  ]);
-}

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

@@ -1,110 +0,0 @@
-#include "napi.h"
-
-using namespace Napi;
-
-const char* testValueUtf8 = "123456789";
-const char16_t* testValueUtf16 = NAPI_WIDE_TEXT("123456789");
-
-Value EchoString(const CallbackInfo& info) {
-  String value = info[0].As<String>();
-  String encoding = info[1].As<String>();
-
-  if (encoding.Utf8Value() == "utf8") {
-    return String::New(info.Env(), value.Utf8Value().c_str());
-  } else if (encoding.Utf8Value() == "utf16") {
-    return String::New(info.Env(), value.Utf16Value().c_str());
-  } else {
-    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
-    return Value();
-  }
-}
-
-Value CreateString(const CallbackInfo& info) {
-  String encoding = info[0].As<String>();
-  Value length = info[1];
-
-  if (encoding.Utf8Value() == "utf8") {
-    if (length.IsUndefined()) {
-      return String::New(info.Env(), testValueUtf8);
-    } else {
-      return String::New(
-          info.Env(), testValueUtf8, length.As<Number>().Uint32Value());
-    }
-  } else if (encoding.Utf8Value() == "utf16") {
-    if (length.IsUndefined()) {
-      return String::New(info.Env(), testValueUtf16);
-    } else {
-      return String::New(
-          info.Env(), testValueUtf16, length.As<Number>().Uint32Value());
-    }
-  } else {
-    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
-    return Value();
-  }
-}
-
-Value CheckString(const CallbackInfo& info) {
-  String value = info[0].As<String>();
-  String encoding = info[1].As<String>();
-  Value length = info[2];
-
-  if (encoding.Utf8Value() == "utf8") {
-    std::string testValue = testValueUtf8;
-    if (!length.IsUndefined()) {
-      testValue = testValue.substr(0, length.As<Number>().Uint32Value());
-    }
-
-    std::string stringValue = value;
-    return Boolean::New(info.Env(), stringValue == testValue);
-  } else if (encoding.Utf8Value() == "utf16") {
-    std::u16string testValue = testValueUtf16;
-    if (!length.IsUndefined()) {
-      testValue = testValue.substr(0, length.As<Number>().Uint32Value());
-    }
-
-    std::u16string stringValue = value;
-    return Boolean::New(info.Env(), stringValue == testValue);
-  } else {
-    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
-    return Value();
-  }
-}
-
-Value CreateSymbol(const CallbackInfo& info) {
-  Value description = info[0];
-
-  if (!description.IsUndefined()) {
-    return Symbol::New(info.Env(), description.As<String>());
-  } else {
-    return Symbol::New(info.Env());
-  }
-}
-
-Value CheckSymbol(const CallbackInfo& info) {
-  return Boolean::New(info.Env(), info[0].Type() == napi_symbol);
-}
-
-void NullStringShouldThrow(const CallbackInfo& info) {
-  const char* nullStr = nullptr;
-  String::New(info.Env(), nullStr);
-}
-
-void NullString16ShouldThrow(const CallbackInfo& info) {
-  const char16_t* nullStr = nullptr;
-  String::New(info.Env(), nullStr);
-}
-
-Object InitName(Env env) {
-  Object exports = Object::New(env);
-
-  exports["echoString"] = Function::New(env, EchoString);
-  exports["createString"] = Function::New(env, CreateString);
-  exports["nullStringShouldThrow"] = Function::New(env, NullStringShouldThrow);
-  exports["nullString16ShouldThrow"] =
-      Function::New(env, NullString16ShouldThrow);
-  exports["checkString"] = Function::New(env, CheckString);
-  exports["createSymbol"] = Function::New(env, CreateSymbol);
-  exports["checkSymbol"] = Function::New(env, CheckSymbol);
-
-  return exports;
-}