koffi 0.9.2 → 0.9.5

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

@@ -1,81 +1,81 @@
-'use strict';
-
-const assert = require('assert');
-
-if (process.argv[2] === 'fatal') {
-  const binding = require(process.argv[3]);
-  binding.error.throwFatalError();
-}
-
-module.exports = require('./common').runTestWithBindingPath(test);
-
-function test (bindingPath) {
-  const binding = require(bindingPath);
-
-  assert.throws(() => binding.error.throwApiError('test'), function (err) {
-    return err instanceof Error && err.message.includes('Invalid');
-  });
-
-  assert.throws(() => binding.error.lastExceptionErrorCode(), function (err) {
-    return err instanceof TypeError && err.message === 'A boolean was expected';
-  });
-
-  assert.throws(() => binding.error.throwJSError('test'), function (err) {
-    return err instanceof Error && err.message === 'test';
-  });
-
-  assert.throws(() => binding.error.throwTypeError('test'), function (err) {
-    return err instanceof TypeError && err.message === 'test';
-  });
-
-  assert.throws(() => binding.error.throwRangeError('test'), function (err) {
-    return err instanceof RangeError && err.message === 'test';
-  });
-
-  assert.throws(
-    () => binding.error.doNotCatch(
-      () => {
-        throw new TypeError('test');
-      }),
-    function (err) {
-      return err instanceof TypeError && err.message === 'test' && !err.caught;
-    });
-
-  assert.throws(
-    () => binding.error.catchAndRethrowError(
-      () => {
-        throw new TypeError('test');
-      }),
-    function (err) {
-      return err instanceof TypeError && err.message === 'test' && err.caught;
-    });
-
-  const err = binding.error.catchError(
-    () => { throw new TypeError('test'); });
-  assert(err instanceof TypeError);
-  assert.strictEqual(err.message, 'test');
-
-  const msg = binding.error.catchErrorMessage(
-    () => { throw new TypeError('test'); });
-  assert.strictEqual(msg, 'test');
-
-  assert.throws(() => binding.error.throwErrorThatEscapesScope('test'), function (err) {
-    return err instanceof Error && err.message === 'test';
-  });
-
-  assert.throws(() => binding.error.catchAndRethrowErrorThatEscapesScope('test'), function (err) {
-    return err instanceof Error && err.message === 'test' && err.caught;
-  });
-
-  const p = require('./napi_child').spawnSync(
-    process.execPath, [__filename, 'fatal', bindingPath]);
-  assert.ifError(p.error);
-  assert.ok(p.stderr.toString().includes(
-    'FATAL ERROR: Error::ThrowFatalError This is a fatal error'));
-
-  assert.throws(() => binding.error.throwDefaultError(false),
-    /Cannot convert undefined or null to object/);
-
-  assert.throws(() => binding.error.throwDefaultError(true),
-    /A number was expected/);
-}
+'use strict';
+
+const assert = require('assert');
+
+if (process.argv[2] === 'fatal') {
+  const binding = require(process.argv[3]);
+  binding.error.throwFatalError();
+}
+
+module.exports = require('./common').runTestWithBindingPath(test);
+
+function test (bindingPath) {
+  const binding = require(bindingPath);
+
+  assert.throws(() => binding.error.throwApiError('test'), function (err) {
+    return err instanceof Error && err.message.includes('Invalid');
+  });
+
+  assert.throws(() => binding.error.lastExceptionErrorCode(), function (err) {
+    return err instanceof TypeError && err.message === 'A boolean was expected';
+  });
+
+  assert.throws(() => binding.error.throwJSError('test'), function (err) {
+    return err instanceof Error && err.message === 'test';
+  });
+
+  assert.throws(() => binding.error.throwTypeError('test'), function (err) {
+    return err instanceof TypeError && err.message === 'test';
+  });
+
+  assert.throws(() => binding.error.throwRangeError('test'), function (err) {
+    return err instanceof RangeError && err.message === 'test';
+  });
+
+  assert.throws(
+    () => binding.error.doNotCatch(
+      () => {
+        throw new TypeError('test');
+      }),
+    function (err) {
+      return err instanceof TypeError && err.message === 'test' && !err.caught;
+    });
+
+  assert.throws(
+    () => binding.error.catchAndRethrowError(
+      () => {
+        throw new TypeError('test');
+      }),
+    function (err) {
+      return err instanceof TypeError && err.message === 'test' && err.caught;
+    });
+
+  const err = binding.error.catchError(
+    () => { throw new TypeError('test'); });
+  assert(err instanceof TypeError);
+  assert.strictEqual(err.message, 'test');
+
+  const msg = binding.error.catchErrorMessage(
+    () => { throw new TypeError('test'); });
+  assert.strictEqual(msg, 'test');
+
+  assert.throws(() => binding.error.throwErrorThatEscapesScope('test'), function (err) {
+    return err instanceof Error && err.message === 'test';
+  });
+
+  assert.throws(() => binding.error.catchAndRethrowErrorThatEscapesScope('test'), function (err) {
+    return err instanceof Error && err.message === 'test' && err.caught;
+  });
+
+  const p = require('./napi_child').spawnSync(
+    process.execPath, [__filename, 'fatal', bindingPath]);
+  assert.ifError(p.error);
+  assert.ok(p.stderr.toString().includes(
+    'FATAL ERROR: Error::ThrowFatalError This is a fatal error'));
+
+  assert.throws(() => binding.error.throwDefaultError(false),
+    /Cannot convert undefined or null to object/);
+
+  assert.throws(() => binding.error.throwDefaultError(true),
+    /A number was expected/);
+}

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

@@ -1,13 +1,13 @@
-#include <napi.h>
-
-namespace {
-void Test(const Napi::CallbackInfo& info) {
-  info[0].As<Napi::Function>().Call({});
-}
-
-}  // namespace
-Napi::Object InitErrorHandlingPrim(Napi::Env env) {
-  Napi::Object exports = Napi::Object::New(env);
-  exports.Set("errorHandlingPrim", Napi::Function::New<Test>(env));
-  return exports;
-}
+#include <napi.h>
+
+namespace {
+void Test(const Napi::CallbackInfo& info) {
+  info[0].As<Napi::Function>().Call({});
+}
+
+}  // namespace
+Napi::Object InitErrorHandlingPrim(Napi::Env env) {
+  Napi::Object exports = Napi::Object::New(env);
+  exports.Set("errorHandlingPrim", Napi::Function::New<Test>(env));
+  return exports;
+}

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

@@ -1,29 +1,29 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('./common').runTest((binding) => {
-  test(binding.errorHandlingPrim);
-});
-
-function canThrow (binding, errorMessage, errorType) {
-  try {
-    binding.errorHandlingPrim(() => {
-      throw errorMessage;
-    });
-  } catch (e) {
-    // eslint-disable-next-line valid-typeof
-    assert(typeof e === errorType);
-    assert(e === errorMessage);
-  }
-}
-
-function test (binding) {
-  canThrow(binding, '404 server not found!', 'string');
-  canThrow(binding, 42, 'number');
-  canThrow(binding, Symbol.for('newSym'), 'symbol');
-  canThrow(binding, false, 'boolean');
-  canThrow(binding, BigInt(123), 'bigint');
-  canThrow(binding, () => { console.log('Logger shutdown incorrectly'); }, 'function');
-  canThrow(binding, { status: 403, errorMsg: 'Not authenticated' }, 'object');
-}
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest((binding) => {
+  test(binding.errorHandlingPrim);
+});
+
+function canThrow (binding, errorMessage, errorType) {
+  try {
+    binding.errorHandlingPrim(() => {
+      throw errorMessage;
+    });
+  } catch (e) {
+    // eslint-disable-next-line valid-typeof
+    assert(typeof e === errorType);
+    assert(e === errorMessage);
+  }
+}
+
+function test (binding) {
+  canThrow(binding, '404 server not found!', 'string');
+  canThrow(binding, 42, 'number');
+  canThrow(binding, Symbol.for('newSym'), 'symbol');
+  canThrow(binding, false, 'boolean');
+  canThrow(binding, BigInt(123), 'bigint');
+  canThrow(binding, () => { console.log('Logger shutdown incorrectly'); }, 'function');
+  canThrow(binding, { status: 403, errorMsg: 'Not authenticated' }, 'object');
+}

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

@@ -1,94 +1,94 @@
-'use strict';
-const buildType = process.config.target_defaults.default_configuration;
-const assert = require('assert');
-
-// These tests ensure that Error types can be used in a terminating
-// environment without triggering any fatal errors.
-
-if (process.argv[2] === 'runInChildProcess') {
-  const binding_path = process.argv[3];
-  const index_for_test_case = Number(process.argv[4]);
-
-  const binding = require(binding_path);
-
-  // Use C++ promises to ensure the worker thread is terminated right
-  // before running the testable code in the binding.
-
-  binding.error.resetPromises()
-
-  const { Worker } = require('worker_threads');
-
-  const worker = new Worker(
-    __filename,
-    {
-      argv: [
-        'runInWorkerThread',
-        binding_path,
-        index_for_test_case,
-      ]
-    }
-  );
-
-  binding.error.waitForWorkerThread()
-
-  worker.terminate();
-
-  binding.error.releaseWorkerThread()
-
-  return;
-}
-
-if (process.argv[2] === 'runInWorkerThread') {
-  const binding_path = process.argv[3];
-  const index_for_test_case = Number(process.argv[4]);
-
-  const binding = require(binding_path);
-
-  switch (index_for_test_case) {
-    case 0:
-      binding.error.throwJSError('test', true);
-      break;
-    case 1:
-      binding.error.throwTypeError('test', true);
-      break;
-    case 2:
-      binding.error.throwRangeError('test', true);
-      break;
-    case 3:
-      binding.error.throwDefaultError(false, true);
-      break;
-    case 4:
-      binding.error.throwDefaultError(true, true);
-      break;
-    default: assert.fail('Invalid index');
-  }
-
-  assert.fail('This should not be reachable');
-}
-
-test(`./build/${buildType}/binding.node`, true);
-test(`./build/${buildType}/binding_noexcept.node`, true);
-test(`./build/${buildType}/binding_swallowexcept.node`, false);
-test(`./build/${buildType}/binding_swallowexcept_noexcept.node`, false);
-
-function test(bindingPath, process_should_abort) {
-  const number_of_test_cases = 5;
-
-  for (let i = 0; i < number_of_test_cases; ++i) {
-    const child_process = require('./napi_child').spawnSync(
-      process.execPath,
-      [
-        __filename,
-        'runInChildProcess',
-        bindingPath,
-        i,
-      ]
-    );
-
-    if (process_should_abort) {
-      assert(child_process.status !== 0, `Test case ${bindingPath} ${i} failed: Process exited with status code 0.`);
-    } else {
-      assert(child_process.status === 0, `Test case ${bindingPath} ${i} failed: Process status ${child_process.status} is non-zero`);
-    }
-  }
-}
+'use strict';
+const buildType = process.config.target_defaults.default_configuration;
+const assert = require('assert');
+
+// These tests ensure that Error types can be used in a terminating
+// environment without triggering any fatal errors.
+
+if (process.argv[2] === 'runInChildProcess') {
+  const binding_path = process.argv[3];
+  const index_for_test_case = Number(process.argv[4]);
+
+  const binding = require(binding_path);
+
+  // Use C++ promises to ensure the worker thread is terminated right
+  // before running the testable code in the binding.
+
+  binding.error.resetPromises()
+
+  const { Worker } = require('worker_threads');
+
+  const worker = new Worker(
+    __filename,
+    {
+      argv: [
+        'runInWorkerThread',
+        binding_path,
+        index_for_test_case,
+      ]
+    }
+  );
+
+  binding.error.waitForWorkerThread()
+
+  worker.terminate();
+
+  binding.error.releaseWorkerThread()
+
+  return;
+}
+
+if (process.argv[2] === 'runInWorkerThread') {
+  const binding_path = process.argv[3];
+  const index_for_test_case = Number(process.argv[4]);
+
+  const binding = require(binding_path);
+
+  switch (index_for_test_case) {
+    case 0:
+      binding.error.throwJSError('test', true);
+      break;
+    case 1:
+      binding.error.throwTypeError('test', true);
+      break;
+    case 2:
+      binding.error.throwRangeError('test', true);
+      break;
+    case 3:
+      binding.error.throwDefaultError(false, true);
+      break;
+    case 4:
+      binding.error.throwDefaultError(true, true);
+      break;
+    default: assert.fail('Invalid index');
+  }
+
+  assert.fail('This should not be reachable');
+}
+
+test(`./build/${buildType}/binding.node`, true);
+test(`./build/${buildType}/binding_noexcept.node`, true);
+test(`./build/${buildType}/binding_swallowexcept.node`, false);
+test(`./build/${buildType}/binding_swallowexcept_noexcept.node`, false);
+
+function test(bindingPath, process_should_abort) {
+  const number_of_test_cases = 5;
+
+  for (let i = 0; i < number_of_test_cases; ++i) {
+    const child_process = require('./napi_child').spawnSync(
+      process.execPath,
+      [
+        __filename,
+        'runInChildProcess',
+        bindingPath,
+        i,
+      ]
+    );
+
+    if (process_should_abort) {
+      assert(child_process.status !== 0, `Test case ${bindingPath} ${i} failed: Process exited with status code 0.`);
+    } else {
+      assert(child_process.status === 0, `Test case ${bindingPath} ${i} failed: Process status ${child_process.status} is non-zero`);
+    }
+  }
+}

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

@@ -1,81 +1,81 @@
-#include "napi.h"
-
-using namespace Napi;
-
-namespace {
-
-int testData = 1;
-int finalizeCount = 0;
-
-Value CreateExternal(const CallbackInfo& info) {
-  finalizeCount = 0;
-  return External<int>::New(info.Env(), &testData);
-}
-
-Value CreateExternalWithFinalize(const CallbackInfo& info) {
-  finalizeCount = 0;
-  return External<int>::New(info.Env(), new int(1),
-    [](Env /*env*/, int* data) {
-      delete data;
-      finalizeCount++;
-    });
-}
-
-Value CreateExternalWithFinalizeHint(const CallbackInfo& info) {
-  finalizeCount = 0;
-  char* hint = nullptr;
-  return External<int>::New(info.Env(), new int(1),
-    [](Env /*env*/, int* data, char* /*hint*/) {
-      delete data;
-      finalizeCount++;
-    },
-    hint);
-}
-
-void CheckExternal(const CallbackInfo& info) {
-   Value arg = info[0];
-   if (arg.Type() != napi_external) {
-      Error::New(info.Env(), "An external argument was expected.").ThrowAsJavaScriptException();
-      return;
-   }
-
-   External<int> external = arg.As<External<int>>();
-   int* externalData = external.Data();
-   if (externalData == nullptr || *externalData != 1) {
-      Error::New(info.Env(), "An external value of 1 was expected.").ThrowAsJavaScriptException();
-      return;
-   }
-}
-
-Value GetFinalizeCount(const CallbackInfo& info) {
-   return Number::New(info.Env(), finalizeCount);
-}
-
-Value CreateExternalWithFinalizeException(const CallbackInfo& info) {
-  return External<int>::New(info.Env(), new int(1),
-    [](Env env, int* data) {
-      Error error = Error::New(env, "Finalizer exception");
-      delete data;
-#ifdef NAPI_CPP_EXCEPTIONS
-      throw error;
-#else
-      error.ThrowAsJavaScriptException();
-#endif
-    });
-}
-
-} // end anonymous namespace
-
-Object InitExternal(Env env) {
-  Object exports = Object::New(env);
-
-  exports["createExternal"] = Function::New(env, CreateExternal);
-  exports["createExternalWithFinalize"] = Function::New(env, CreateExternalWithFinalize);
-  exports["createExternalWithFinalizeException"] =
-      Function::New(env, CreateExternalWithFinalizeException);
-  exports["createExternalWithFinalizeHint"] = Function::New(env, CreateExternalWithFinalizeHint);
-  exports["checkExternal"] = Function::New(env, CheckExternal);
-  exports["getFinalizeCount"] = Function::New(env, GetFinalizeCount);
-
-  return exports;
-}
+#include "napi.h"
+
+using namespace Napi;
+
+namespace {
+
+int testData = 1;
+int finalizeCount = 0;
+
+Value CreateExternal(const CallbackInfo& info) {
+  finalizeCount = 0;
+  return External<int>::New(info.Env(), &testData);
+}
+
+Value CreateExternalWithFinalize(const CallbackInfo& info) {
+  finalizeCount = 0;
+  return External<int>::New(info.Env(), new int(1),
+    [](Env /*env*/, int* data) {
+      delete data;
+      finalizeCount++;
+    });
+}
+
+Value CreateExternalWithFinalizeHint(const CallbackInfo& info) {
+  finalizeCount = 0;
+  char* hint = nullptr;
+  return External<int>::New(info.Env(), new int(1),
+    [](Env /*env*/, int* data, char* /*hint*/) {
+      delete data;
+      finalizeCount++;
+    },
+    hint);
+}
+
+void CheckExternal(const CallbackInfo& info) {
+   Value arg = info[0];
+   if (arg.Type() != napi_external) {
+      Error::New(info.Env(), "An external argument was expected.").ThrowAsJavaScriptException();
+      return;
+   }
+
+   External<int> external = arg.As<External<int>>();
+   int* externalData = external.Data();
+   if (externalData == nullptr || *externalData != 1) {
+      Error::New(info.Env(), "An external value of 1 was expected.").ThrowAsJavaScriptException();
+      return;
+   }
+}
+
+Value GetFinalizeCount(const CallbackInfo& info) {
+   return Number::New(info.Env(), finalizeCount);
+}
+
+Value CreateExternalWithFinalizeException(const CallbackInfo& info) {
+  return External<int>::New(info.Env(), new int(1),
+    [](Env env, int* data) {
+      Error error = Error::New(env, "Finalizer exception");
+      delete data;
+#ifdef NAPI_CPP_EXCEPTIONS
+      throw error;
+#else
+      error.ThrowAsJavaScriptException();
+#endif
+    });
+}
+
+} // end anonymous namespace
+
+Object InitExternal(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createExternal"] = Function::New(env, CreateExternal);
+  exports["createExternalWithFinalize"] = Function::New(env, CreateExternalWithFinalize);
+  exports["createExternalWithFinalizeException"] =
+      Function::New(env, CreateExternalWithFinalizeException);
+  exports["createExternalWithFinalizeHint"] = Function::New(env, CreateExternalWithFinalizeHint);
+  exports["checkExternal"] = Function::New(env, CheckExternal);
+  exports["getFinalizeCount"] = Function::New(env, GetFinalizeCount);
+
+  return exports;
+}