koffi 0.9.4 → 0.9.5

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

@@ -1,287 +1,287 @@
-#include <future>
-#include "napi.h"
-
-using namespace Napi;
-
-namespace {
-
-std::promise<void> promise_for_child_process_;
-std::promise<void> promise_for_worker_thread_;
-
-void ResetPromises(const CallbackInfo&) {
-  promise_for_child_process_ = std::promise<void>();
-  promise_for_worker_thread_ = std::promise<void>();
-}
-
-void WaitForWorkerThread(const CallbackInfo&) {
-  std::future<void> future = promise_for_worker_thread_.get_future();
-
-  std::future_status status = future.wait_for(std::chrono::seconds(5));
-
-  if (status != std::future_status::ready) {
-    Error::Fatal("WaitForWorkerThread", "status != std::future_status::ready");
-  }
-}
-
-void ReleaseAndWaitForChildProcess(const CallbackInfo& info,
-                                   const uint32_t index) {
-  if (info.Length() < index + 1) {
-    return;
-  }
-
-  if (!info[index].As<Boolean>().Value()) {
-    return;
-  }
-
-  promise_for_worker_thread_.set_value();
-
-  std::future<void> future = promise_for_child_process_.get_future();
-
-  std::future_status status = future.wait_for(std::chrono::seconds(5));
-
-  if (status != std::future_status::ready) {
-    Error::Fatal("ReleaseAndWaitForChildProcess",
-                 "status != std::future_status::ready");
-  }
-}
-
-void ReleaseWorkerThread(const CallbackInfo&) {
-  promise_for_child_process_.set_value();
-}
-
-void DoNotCatch(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  thrower({});
-}
-
-void ThrowApiError(const CallbackInfo& info) {
-  // Attempting to call an empty function value will throw an API error.
-  Function(info.Env(), nullptr).Call(std::initializer_list<napi_value>{});
-}
-
-void LastExceptionErrorCode(const CallbackInfo& info) {
-  // Previously, `napi_extended_error_info.error_code` got reset to `napi_ok` in
-  // subsequent Node-API function calls, so this would have previously thrown an
-  // `Error` object instead of a `TypeError` object.
-  Env env = info.Env();
-  bool res;
-  napi_get_value_bool(env, Value::From(env, "asd"), &res);
-  NAPI_THROW_VOID(Error::New(env));
-}
-
-#ifdef NAPI_CPP_EXCEPTIONS
-
-void ThrowJSError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw Error::New(info.Env(), message);
-}
-
-void ThrowTypeError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw TypeError::New(info.Env(), message);
-}
-
-void ThrowRangeError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  throw RangeError::New(info.Env(), message);
-}
-
-Value CatchError(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  try {
-    thrower({});
-  } catch (const Error& e) {
-    return e.Value();
-  }
-  return info.Env().Null();
-}
-
-Value CatchErrorMessage(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  try {
-    thrower({});
-  } catch (const Error& e) {
-    std::string message = e.Message();
-    return String::New(info.Env(), message);
-  }
-  return info.Env().Null();
-}
-
-void CatchAndRethrowError(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  try {
-    thrower({});
-  } catch (Error& e) {
-    e.Set("caught", Boolean::New(info.Env(), true));
-    throw;
-  }
-}
-
-void ThrowErrorThatEscapesScope(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-
-  std::string message = info[0].As<String>().Utf8Value();
-  throw Error::New(info.Env(), message);
-}
-
-void CatchAndRethrowErrorThatEscapesScope(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-  try {
-    ThrowErrorThatEscapesScope(info);
-  } catch (Error& e) {
-    e.Set("caught", Boolean::New(info.Env(), true));
-    throw;
-  }
-}
-
-#else // NAPI_CPP_EXCEPTIONS
-
-void ThrowJSError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  Error::New(info.Env(), message).ThrowAsJavaScriptException();
-}
-
-void ThrowTypeError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  TypeError::New(info.Env(), message).ThrowAsJavaScriptException();
-}
-
-void ThrowRangeError(const CallbackInfo& info) {
-  std::string message = info[0].As<String>().Utf8Value();
-
-  ReleaseAndWaitForChildProcess(info, 1);
-  RangeError::New(info.Env(), message).ThrowAsJavaScriptException();
-}
-
-Value CatchError(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  thrower({});
-
-  Env env = info.Env();
-  if (env.IsExceptionPending()) {
-    Error e = env.GetAndClearPendingException();
-    return e.Value();
-  }
-  return info.Env().Null();
-}
-
-Value CatchErrorMessage(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  thrower({});
-
-  Env env = info.Env();
-  if (env.IsExceptionPending()) {
-    Error e = env.GetAndClearPendingException();
-    std::string message = e.Message();
-    return String::New(env, message);
-  }
-  return info.Env().Null();
-}
-
-void CatchAndRethrowError(const CallbackInfo& info) {
-  Function thrower = info[0].As<Function>();
-  thrower({});
-
-  Env env = info.Env();
-  if (env.IsExceptionPending()) {
-    Error e = env.GetAndClearPendingException();
-    e.Set("caught", Boolean::New(info.Env(), true));
-    e.ThrowAsJavaScriptException();
-  }
-}
-
-void ThrowErrorThatEscapesScope(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-
-  std::string message = info[0].As<String>().Utf8Value();
-  Error::New(info.Env(), message).ThrowAsJavaScriptException();
-}
-
-void CatchAndRethrowErrorThatEscapesScope(const CallbackInfo& info) {
-  HandleScope scope(info.Env());
-  ThrowErrorThatEscapesScope(info);
-
-  Env env = info.Env();
-  if (env.IsExceptionPending()) {
-    Error e = env.GetAndClearPendingException();
-    e.Set("caught", Boolean::New(info.Env(), true));
-    e.ThrowAsJavaScriptException();
-  }
-}
-
-#endif // NAPI_CPP_EXCEPTIONS
-
-void ThrowFatalError(const CallbackInfo& /*info*/) {
-  Error::Fatal("Error::ThrowFatalError", "This is a fatal error");
-}
-
-void ThrowDefaultError(const CallbackInfo& info) {
-  napi_value dummy;
-  napi_env env = info.Env();
-  napi_status status = napi_get_undefined(env, &dummy);
-  NAPI_FATAL_IF_FAILED(status, "ThrowDefaultError", "napi_get_undefined");
-
-  if (info[0].As<Boolean>().Value()) {
-    // Provoke Node-API into setting an error, then use the `Napi::Error::New`
-    // factory with only the `env` parameter to throw an exception generated
-    // from the last error.
-    uint32_t dummy_uint32;
-    status = napi_get_value_uint32(env, dummy, &dummy_uint32);
-    if (status == napi_ok) {
-      Error::Fatal("ThrowDefaultError", "napi_get_value_uint32");
-    }
-    // We cannot use `NAPI_THROW_IF_FAILED()` here because we do not wish
-    // control to pass back to the engine if we throw an exception here and C++
-    // exceptions are turned on.
-    Napi::Error::New(env).ThrowAsJavaScriptException();
-  }
-
-  // Produce and throw a second error that has different content than the one
-  // above. If the one above was thrown, then throwing the one below should
-  // have the effect of re-throwing the one above.
-  status = napi_get_named_property(env, dummy, "xyzzy", &dummy);
-  if (status == napi_ok) {
-    Error::Fatal("ThrowDefaultError", "napi_get_named_property");
-  }
-
-  ReleaseAndWaitForChildProcess(info, 1);
-
-  // The macro creates a `Napi::Error` using the factory that takes only the
-  // env, however, it heeds the exception mechanism to be used.
-  NAPI_THROW_IF_FAILED_VOID(env, status);
-}
-
-} // end anonymous namespace
-
-Object InitError(Env env) {
-  Object exports = Object::New(env);
-  exports["throwApiError"] = Function::New(env, ThrowApiError);
-  exports["lastExceptionErrorCode"] =
-      Function::New(env, LastExceptionErrorCode);
-  exports["throwJSError"] = Function::New(env, ThrowJSError);
-  exports["throwTypeError"] = Function::New(env, ThrowTypeError);
-  exports["throwRangeError"] = Function::New(env, ThrowRangeError);
-  exports["catchError"] = Function::New(env, CatchError);
-  exports["catchErrorMessage"] = Function::New(env, CatchErrorMessage);
-  exports["doNotCatch"] = Function::New(env, DoNotCatch);
-  exports["catchAndRethrowError"] = Function::New(env, CatchAndRethrowError);
-  exports["throwErrorThatEscapesScope"] = Function::New(env, ThrowErrorThatEscapesScope);
-  exports["catchAndRethrowErrorThatEscapesScope"] =
-    Function::New(env, CatchAndRethrowErrorThatEscapesScope);
-  exports["throwFatalError"] = Function::New(env, ThrowFatalError);
-  exports["throwDefaultError"] = Function::New(env, ThrowDefaultError);
-  exports["resetPromises"] = Function::New(env, ResetPromises);
-  exports["waitForWorkerThread"] = Function::New(env, WaitForWorkerThread);
-  exports["releaseWorkerThread"] = Function::New(env, ReleaseWorkerThread);
-  return exports;
-}
+#include <future>
+#include "napi.h"
+
+using namespace Napi;
+
+namespace {
+
+std::promise<void> promise_for_child_process_;
+std::promise<void> promise_for_worker_thread_;
+
+void ResetPromises(const CallbackInfo&) {
+  promise_for_child_process_ = std::promise<void>();
+  promise_for_worker_thread_ = std::promise<void>();
+}
+
+void WaitForWorkerThread(const CallbackInfo&) {
+  std::future<void> future = promise_for_worker_thread_.get_future();
+
+  std::future_status status = future.wait_for(std::chrono::seconds(5));
+
+  if (status != std::future_status::ready) {
+    Error::Fatal("WaitForWorkerThread", "status != std::future_status::ready");
+  }
+}
+
+void ReleaseAndWaitForChildProcess(const CallbackInfo& info,
+                                   const uint32_t index) {
+  if (info.Length() < index + 1) {
+    return;
+  }
+
+  if (!info[index].As<Boolean>().Value()) {
+    return;
+  }
+
+  promise_for_worker_thread_.set_value();
+
+  std::future<void> future = promise_for_child_process_.get_future();
+
+  std::future_status status = future.wait_for(std::chrono::seconds(5));
+
+  if (status != std::future_status::ready) {
+    Error::Fatal("ReleaseAndWaitForChildProcess",
+                 "status != std::future_status::ready");
+  }
+}
+
+void ReleaseWorkerThread(const CallbackInfo&) {
+  promise_for_child_process_.set_value();
+}
+
+void DoNotCatch(const CallbackInfo& info) {
+  Function thrower = info[0].As<Function>();
+  thrower({});
+}
+
+void ThrowApiError(const CallbackInfo& info) {
+  // Attempting to call an empty function value will throw an API error.
+  Function(info.Env(), nullptr).Call(std::initializer_list<napi_value>{});
+}
+
+void LastExceptionErrorCode(const CallbackInfo& info) {
+  // Previously, `napi_extended_error_info.error_code` got reset to `napi_ok` in
+  // subsequent Node-API function calls, so this would have previously thrown an
+  // `Error` object instead of a `TypeError` object.
+  Env env = info.Env();
+  bool res;
+  napi_get_value_bool(env, Value::From(env, "asd"), &res);
+  NAPI_THROW_VOID(Error::New(env));
+}
+
+#ifdef NAPI_CPP_EXCEPTIONS
+
+void ThrowJSError(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+
+  ReleaseAndWaitForChildProcess(info, 1);
+  throw Error::New(info.Env(), message);
+}
+
+void ThrowTypeError(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+
+  ReleaseAndWaitForChildProcess(info, 1);
+  throw TypeError::New(info.Env(), message);
+}
+
+void ThrowRangeError(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+
+  ReleaseAndWaitForChildProcess(info, 1);
+  throw RangeError::New(info.Env(), message);
+}
+
+Value CatchError(const CallbackInfo& info) {
+  Function thrower = info[0].As<Function>();
+  try {
+    thrower({});
+  } catch (const Error& e) {
+    return e.Value();
+  }
+  return info.Env().Null();
+}
+
+Value CatchErrorMessage(const CallbackInfo& info) {
+  Function thrower = info[0].As<Function>();
+  try {
+    thrower({});
+  } catch (const Error& e) {
+    std::string message = e.Message();
+    return String::New(info.Env(), message);
+  }
+  return info.Env().Null();
+}
+
+void CatchAndRethrowError(const CallbackInfo& info) {
+  Function thrower = info[0].As<Function>();
+  try {
+    thrower({});
+  } catch (Error& e) {
+    e.Set("caught", Boolean::New(info.Env(), true));
+    throw;
+  }
+}
+
+void ThrowErrorThatEscapesScope(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+
+  std::string message = info[0].As<String>().Utf8Value();
+  throw Error::New(info.Env(), message);
+}
+
+void CatchAndRethrowErrorThatEscapesScope(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  try {
+    ThrowErrorThatEscapesScope(info);
+  } catch (Error& e) {
+    e.Set("caught", Boolean::New(info.Env(), true));
+    throw;
+  }
+}
+
+#else // NAPI_CPP_EXCEPTIONS
+
+void ThrowJSError(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+
+  ReleaseAndWaitForChildProcess(info, 1);
+  Error::New(info.Env(), message).ThrowAsJavaScriptException();
+}
+
+void ThrowTypeError(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+
+  ReleaseAndWaitForChildProcess(info, 1);
+  TypeError::New(info.Env(), message).ThrowAsJavaScriptException();
+}
+
+void ThrowRangeError(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+
+  ReleaseAndWaitForChildProcess(info, 1);
+  RangeError::New(info.Env(), message).ThrowAsJavaScriptException();
+}
+
+Value CatchError(const CallbackInfo& info) {
+  Function thrower = info[0].As<Function>();
+  thrower({});
+
+  Env env = info.Env();
+  if (env.IsExceptionPending()) {
+    Error e = env.GetAndClearPendingException();
+    return e.Value();
+  }
+  return info.Env().Null();
+}
+
+Value CatchErrorMessage(const CallbackInfo& info) {
+  Function thrower = info[0].As<Function>();
+  thrower({});
+
+  Env env = info.Env();
+  if (env.IsExceptionPending()) {
+    Error e = env.GetAndClearPendingException();
+    std::string message = e.Message();
+    return String::New(env, message);
+  }
+  return info.Env().Null();
+}
+
+void CatchAndRethrowError(const CallbackInfo& info) {
+  Function thrower = info[0].As<Function>();
+  thrower({});
+
+  Env env = info.Env();
+  if (env.IsExceptionPending()) {
+    Error e = env.GetAndClearPendingException();
+    e.Set("caught", Boolean::New(info.Env(), true));
+    e.ThrowAsJavaScriptException();
+  }
+}
+
+void ThrowErrorThatEscapesScope(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+
+  std::string message = info[0].As<String>().Utf8Value();
+  Error::New(info.Env(), message).ThrowAsJavaScriptException();
+}
+
+void CatchAndRethrowErrorThatEscapesScope(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  ThrowErrorThatEscapesScope(info);
+
+  Env env = info.Env();
+  if (env.IsExceptionPending()) {
+    Error e = env.GetAndClearPendingException();
+    e.Set("caught", Boolean::New(info.Env(), true));
+    e.ThrowAsJavaScriptException();
+  }
+}
+
+#endif // NAPI_CPP_EXCEPTIONS
+
+void ThrowFatalError(const CallbackInfo& /*info*/) {
+  Error::Fatal("Error::ThrowFatalError", "This is a fatal error");
+}
+
+void ThrowDefaultError(const CallbackInfo& info) {
+  napi_value dummy;
+  napi_env env = info.Env();
+  napi_status status = napi_get_undefined(env, &dummy);
+  NAPI_FATAL_IF_FAILED(status, "ThrowDefaultError", "napi_get_undefined");
+
+  if (info[0].As<Boolean>().Value()) {
+    // Provoke Node-API into setting an error, then use the `Napi::Error::New`
+    // factory with only the `env` parameter to throw an exception generated
+    // from the last error.
+    uint32_t dummy_uint32;
+    status = napi_get_value_uint32(env, dummy, &dummy_uint32);
+    if (status == napi_ok) {
+      Error::Fatal("ThrowDefaultError", "napi_get_value_uint32");
+    }
+    // We cannot use `NAPI_THROW_IF_FAILED()` here because we do not wish
+    // control to pass back to the engine if we throw an exception here and C++
+    // exceptions are turned on.
+    Napi::Error::New(env).ThrowAsJavaScriptException();
+  }
+
+  // Produce and throw a second error that has different content than the one
+  // above. If the one above was thrown, then throwing the one below should
+  // have the effect of re-throwing the one above.
+  status = napi_get_named_property(env, dummy, "xyzzy", &dummy);
+  if (status == napi_ok) {
+    Error::Fatal("ThrowDefaultError", "napi_get_named_property");
+  }
+
+  ReleaseAndWaitForChildProcess(info, 1);
+
+  // The macro creates a `Napi::Error` using the factory that takes only the
+  // env, however, it heeds the exception mechanism to be used.
+  NAPI_THROW_IF_FAILED_VOID(env, status);
+}
+
+} // end anonymous namespace
+
+Object InitError(Env env) {
+  Object exports = Object::New(env);
+  exports["throwApiError"] = Function::New(env, ThrowApiError);
+  exports["lastExceptionErrorCode"] =
+      Function::New(env, LastExceptionErrorCode);
+  exports["throwJSError"] = Function::New(env, ThrowJSError);
+  exports["throwTypeError"] = Function::New(env, ThrowTypeError);
+  exports["throwRangeError"] = Function::New(env, ThrowRangeError);
+  exports["catchError"] = Function::New(env, CatchError);
+  exports["catchErrorMessage"] = Function::New(env, CatchErrorMessage);
+  exports["doNotCatch"] = Function::New(env, DoNotCatch);
+  exports["catchAndRethrowError"] = Function::New(env, CatchAndRethrowError);
+  exports["throwErrorThatEscapesScope"] = Function::New(env, ThrowErrorThatEscapesScope);
+  exports["catchAndRethrowErrorThatEscapesScope"] =
+    Function::New(env, CatchAndRethrowErrorThatEscapesScope);
+  exports["throwFatalError"] = Function::New(env, ThrowFatalError);
+  exports["throwDefaultError"] = Function::New(env, ThrowDefaultError);
+  exports["resetPromises"] = Function::New(env, ResetPromises);
+  exports["waitForWorkerThread"] = Function::New(env, WaitForWorkerThread);
+  exports["releaseWorkerThread"] = Function::New(env, ReleaseWorkerThread);
+  return exports;
+}