koffi 2.3.17 → 2.3.19

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

@@ -1,4 +1,6 @@
+#include <string.h>
 #include <future>
+#include "assert.h"
 #include "napi.h"
 
 using namespace Napi;
@@ -69,6 +71,34 @@ void LastExceptionErrorCode(const CallbackInfo& info) {
   NAPI_THROW_VOID(Error::New(env));
 }
 
+void TestErrorCopySemantics(const Napi::CallbackInfo& info) {
+  Napi::Error newError = Napi::Error::New(info.Env(), "errorCopyCtor");
+  Napi::Error existingErr;
+
+#ifdef NAPI_CPP_EXCEPTIONS
+  std::string msg = "errorCopyCtor";
+  assert(strcmp(newError.what(), msg.c_str()) == 0);
+#endif
+
+  Napi::Error errCopyCtor = newError;
+  assert(errCopyCtor.Message() == "errorCopyCtor");
+
+  existingErr = newError;
+  assert(existingErr.Message() == "errorCopyCtor");
+}
+
+void TestErrorMoveSemantics(const Napi::CallbackInfo& info) {
+  std::string errorMsg = "errorMoveCtor";
+  Napi::Error newError = Napi::Error::New(info.Env(), errorMsg.c_str());
+  Napi::Error errFromMove = std::move(newError);
+  assert(errFromMove.Message() == "errorMoveCtor");
+
+  newError = Napi::Error::New(info.Env(), "errorMoveAssign");
+  Napi::Error existingErr = std::move(newError);
+
+  assert(existingErr.Message() == "errorMoveAssign");
+}
+
 #ifdef NAPI_CPP_EXCEPTIONS
 
 void ThrowJSError(const CallbackInfo& info) {
@@ -78,6 +108,13 @@ void ThrowJSError(const CallbackInfo& info) {
   throw Error::New(info.Env(), message);
 }
 
+void ThrowTypeErrorCtor(const CallbackInfo& info) {
+  Napi::Value js_type_error = info[0];
+  ReleaseAndWaitForChildProcess(info, 1);
+
+  throw Napi::TypeError(info.Env(), js_type_error);
+}
+
 void ThrowTypeError(const CallbackInfo& info) {
   std::string message = info[0].As<String>().Utf8Value();
 
@@ -85,6 +122,30 @@ void ThrowTypeError(const CallbackInfo& info) {
   throw TypeError::New(info.Env(), message);
 }
 
+void ThrowTypeErrorCStr(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+
+  ReleaseAndWaitForChildProcess(info, 1);
+  throw TypeError::New(info.Env(), message.c_str());
+}
+
+void ThrowRangeErrorCStr(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+  ReleaseAndWaitForChildProcess(info, 1);
+  throw RangeError::New(info.Env(), message.c_str());
+}
+
+void ThrowRangeErrorCtor(const CallbackInfo& info) {
+  Napi::Value js_range_err = info[0];
+  ReleaseAndWaitForChildProcess(info, 1);
+  throw Napi::RangeError(info.Env(), js_range_err);
+}
+
+void ThrowEmptyRangeError(const CallbackInfo& info) {
+  ReleaseAndWaitForChildProcess(info, 1);
+  throw RangeError();
+}
+
 void ThrowRangeError(const CallbackInfo& info) {
   std::string message = info[0].As<String>().Utf8Value();
 
@@ -156,6 +217,19 @@ void ThrowTypeError(const CallbackInfo& info) {
   TypeError::New(info.Env(), message).ThrowAsJavaScriptException();
 }
 
+void ThrowTypeErrorCtor(const CallbackInfo& info) {
+  Napi::Value js_type_error = info[0];
+  ReleaseAndWaitForChildProcess(info, 1);
+  TypeError(info.Env(), js_type_error).ThrowAsJavaScriptException();
+}
+
+void ThrowTypeErrorCStr(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+
+  ReleaseAndWaitForChildProcess(info, 1);
+  TypeError::New(info.Env(), message.c_str()).ThrowAsJavaScriptException();
+}
+
 void ThrowRangeError(const CallbackInfo& info) {
   std::string message = info[0].As<String>().Utf8Value();
 
@@ -163,6 +237,24 @@ void ThrowRangeError(const CallbackInfo& info) {
   RangeError::New(info.Env(), message).ThrowAsJavaScriptException();
 }
 
+void ThrowRangeErrorCtor(const CallbackInfo& info) {
+  Napi::Value js_range_err = info[0];
+  ReleaseAndWaitForChildProcess(info, 1);
+  RangeError(info.Env(), js_range_err).ThrowAsJavaScriptException();
+}
+
+void ThrowRangeErrorCStr(const CallbackInfo& info) {
+  std::string message = info[0].As<String>().Utf8Value();
+  ReleaseAndWaitForChildProcess(info, 1);
+  RangeError::New(info.Env(), message.c_str()).ThrowAsJavaScriptException();
+}
+
+// TODO: Figure out the correct api for this
+void ThrowEmptyRangeError(const CallbackInfo& info) {
+  ReleaseAndWaitForChildProcess(info, 1);
+  RangeError().ThrowAsJavaScriptException();
+}
+
 Value CatchError(const CallbackInfo& info) {
   Function thrower = info[0].As<Function>();
   thrower({});
@@ -266,11 +358,20 @@ void ThrowDefaultError(const CallbackInfo& info) {
 Object InitError(Env env) {
   Object exports = Object::New(env);
   exports["throwApiError"] = Function::New(env, ThrowApiError);
+  exports["testErrorCopySemantics"] =
+      Function::New(env, TestErrorCopySemantics);
+  exports["testErrorMoveSemantics"] =
+      Function::New(env, TestErrorMoveSemantics);
   exports["lastExceptionErrorCode"] =
       Function::New(env, LastExceptionErrorCode);
   exports["throwJSError"] = Function::New(env, ThrowJSError);
   exports["throwTypeError"] = Function::New(env, ThrowTypeError);
+  exports["throwTypeErrorCtor"] = Function::New(env, ThrowTypeErrorCtor);
+  exports["throwTypeErrorCStr"] = Function::New(env, ThrowTypeErrorCStr);
   exports["throwRangeError"] = Function::New(env, ThrowRangeError);
+  exports["throwRangeErrorCtor"] = Function::New(env, ThrowRangeErrorCtor);
+  exports["throwRangeErrorCStr"] = Function::New(env, ThrowRangeErrorCStr);
+  exports["throwEmptyRangeError"] = Function::New(env, ThrowEmptyRangeError);
   exports["catchError"] = Function::New(env, CatchError);
   exports["catchErrorMessage"] = Function::New(env, CatchErrorMessage);
   exports["doNotCatch"] = Function::New(env, DoNotCatch);

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

@@ -11,6 +11,8 @@ module.exports = require('./common').runTestWithBindingPath(test);
 
 function test (bindingPath) {
   const binding = require(bindingPath);
+  binding.error.testErrorCopySemantics();
+  binding.error.testErrorMoveSemantics();
 
   assert.throws(() => binding.error.throwApiError('test'), function (err) {
     return err instanceof Error && err.message.includes('Invalid');
@@ -24,14 +26,26 @@ function test (bindingPath) {
     return err instanceof Error && err.message === 'test';
   });
 
-  assert.throws(() => binding.error.throwTypeError('test'), function (err) {
+  assert.throws(() => binding.error.throwTypeErrorCStr('test'), function (err) {
     return err instanceof TypeError && err.message === 'test';
   });
 
+  assert.throws(() => binding.error.throwRangeErrorCStr('test'), function (err) {
+    return err instanceof RangeError && err.message === 'test';
+  });
+
   assert.throws(() => binding.error.throwRangeError('test'), function (err) {
     return err instanceof RangeError && err.message === 'test';
   });
 
+  assert.throws(() => binding.error.throwTypeErrorCtor(new TypeError('jsTypeError')), function (err) {
+    return err instanceof TypeError && err.message === 'jsTypeError';
+  });
+
+  assert.throws(() => binding.error.throwRangeErrorCtor(new RangeError('rangeTypeError')), function (err) {
+    return err instanceof RangeError && err.message === 'rangeTypeError';
+  });
+
   assert.throws(
     () => binding.error.doNotCatch(
       () => {

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

@@ -134,7 +134,7 @@ if (majorNodeVersion < 12 && !filterConditionsProvided) {
 
 if (napiVersion < 8 && !filterConditionsProvided) {
   testModules.splice(testModules.indexOf('object/object_freeze_seal'), 1);
-  testModules.splice(testModules.indexOf('object/object_type_tag'), 1);
+  testModules.splice(testModules.indexOf('type_taggable'), 1);
 }
 
 (async function () {

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

@@ -2,7 +2,7 @@
 are not Objects by creating a blank Object and setting Values to
 it. Subclasses of Objects can only be set using an ObjectReference
 by first casting it as an Object. */
-
+#include "assert.h"
 #include "napi.h"
 #include "test_helper.h"
 
@@ -16,11 +16,146 @@ ObjectReference casted_weak;
 ObjectReference casted_persistent;
 ObjectReference casted_reference;
 
-// info[0] is the key, which can be either a string or a number.
-// info[1] is the value.
-// info[2] is a flag that differentiates whether the key is a
-// C string or a JavaScript string.
-void SetObjects(const CallbackInfo& info) {
+// Set keys can be one of:
+// C style string, std::string& utf8, and const char *
+
+// Set values can be one of:
+//  Napi::Value
+//  napi_value (req static_cast)
+// const char* (c style string)
+// boolean
+// double
+
+enum VAL_TYPES { JS = 0, C_STR, CPP_STR, BOOL, INT, DOUBLE, JS_CAST };
+
+void MoveOperatorsTest(const Napi::CallbackInfo& info) {
+  Napi::ObjectReference existingRef;
+  Napi::ObjectReference existingRef2;
+  Napi::Object testObject = Napi::Object::New(info.Env());
+  testObject.Set("testProp", "tProp");
+
+  // ObjectReference(Reference<Object>&& other);
+  Napi::Reference<Napi::Object> refObj =
+      Napi::Reference<Napi::Object>::New(testObject);
+  Napi::ObjectReference objRef = std::move(refObj);
+  std::string prop = MaybeUnwrap(objRef.Get("testProp")).As<Napi::String>();
+  assert(prop == "tProp");
+
+  // ObjectReference& operator=(Reference<Object>&& other);
+  Napi::Reference<Napi::Object> refObj2 =
+      Napi::Reference<Napi::Object>::New(testObject);
+  existingRef = std::move(refObj2);
+  prop = MaybeUnwrap(existingRef.Get("testProp")).As<Napi::String>();
+  assert(prop == "tProp");
+
+  // ObjectReference(ObjectReference&& other);
+  Napi::ObjectReference objRef3 = std::move(existingRef);
+  prop = MaybeUnwrap(objRef3.Get("testProp")).As<Napi::String>();
+  assert(prop == "tProp");
+
+  // ObjectReference& operator=(ObjectReference&& other);
+  existingRef2 = std::move(objRef3);
+  prop = MaybeUnwrap(objRef.Get("testProp")).As<Napi::String>();
+  assert(prop == "tProp");
+}
+
+void SetObjectWithCStringKey(Napi::ObjectReference& obj,
+                             Napi::Value key,
+                             Napi::Value val,
+                             int valType) {
+  std::string c_key = key.As<Napi::String>().Utf8Value();
+  switch (valType) {
+    case JS:
+      obj.Set(c_key.c_str(), val);
+      break;
+
+    case JS_CAST:
+      obj.Set(c_key.c_str(), static_cast<napi_value>(val));
+      break;
+
+    case C_STR: {
+      std::string c_val = val.As<Napi::String>().Utf8Value();
+      obj.Set(c_key.c_str(), c_val.c_str());
+      break;
+    }
+
+    case BOOL:
+      obj.Set(c_key.c_str(), val.As<Napi::Boolean>().Value());
+      break;
+
+    case DOUBLE:
+      obj.Set(c_key.c_str(), val.As<Napi::Number>().DoubleValue());
+      break;
+  }
+}
+
+void SetObjectWithCppStringKey(Napi::ObjectReference& obj,
+                               Napi::Value key,
+                               Napi::Value val,
+                               int valType) {
+  std::string c_key = key.As<Napi::String>();
+  switch (valType) {
+    case JS:
+      obj.Set(c_key, val);
+      break;
+
+    case JS_CAST:
+      obj.Set(c_key, static_cast<napi_value>(val));
+      break;
+
+    case CPP_STR: {
+      std::string c_val = val.As<Napi::String>();
+      obj.Set(c_key, c_val);
+      break;
+    }
+
+    case BOOL:
+      obj.Set(c_key, val.As<Napi::Boolean>().Value());
+      break;
+
+    case DOUBLE:
+      obj.Set(c_key, val.As<Napi::Number>().DoubleValue());
+      break;
+  }
+}
+
+void SetObjectWithIntKey(Napi::ObjectReference& obj,
+                         Napi::Value key,
+                         Napi::Value val,
+                         int valType) {
+  uint32_t c_key = key.As<Napi::Number>().Uint32Value();
+  switch (valType) {
+    case JS:
+      obj.Set(c_key, val);
+      break;
+
+    case JS_CAST:
+      obj.Set(c_key, static_cast<napi_value>(val));
+      break;
+
+    case C_STR: {
+      std::string c_val = val.As<Napi::String>();
+      obj.Set(c_key, c_val.c_str());
+      break;
+    }
+
+    case CPP_STR: {
+      std::string cpp_val = val.As<Napi::String>();
+      obj.Set(c_key, cpp_val);
+      break;
+    }
+
+    case BOOL:
+      obj.Set(c_key, val.As<Napi::Boolean>().Value());
+      break;
+
+    case DOUBLE:
+      obj.Set(c_key, val.As<Napi::Number>().DoubleValue());
+      break;
+  }
+}
+
+void SetObject(const Napi::CallbackInfo& info) {
   Env env = info.Env();
   HandleScope scope(env);
 
@@ -33,20 +168,35 @@ void SetObjects(const CallbackInfo& info) {
   reference = Reference<Object>::New(Object::New(env), 2);
   reference.SuppressDestruct();
 
-  if (info[0].IsString()) {
-    if (info[2].As<String>() == String::New(env, "javascript")) {
-      weak.Set(info[0].As<String>(), info[1]);
-      persistent.Set(info[0].As<String>(), info[1]);
-      reference.Set(info[0].As<String>(), info[1]);
-    } else {
-      weak.Set(info[0].As<String>().Utf8Value(), info[1]);
-      persistent.Set(info[0].As<String>().Utf8Value(), info[1]);
-      reference.Set(info[0].As<String>().Utf8Value(), info[1]);
-    }
-  } else if (info[0].IsNumber()) {
-    weak.Set(info[0].As<Number>(), info[1]);
-    persistent.Set(info[0].As<Number>(), info[1]);
-    reference.Set(info[0].As<Number>(), info[1]);
+  Napi::Object configObject = info[0].As<Napi::Object>();
+
+  int keyType =
+      MaybeUnwrap(configObject.Get("keyType")).As<Napi::Number>().Uint32Value();
+  int valType =
+      MaybeUnwrap(configObject.Get("valType")).As<Napi::Number>().Uint32Value();
+  Napi::Value key = MaybeUnwrap(configObject.Get("key"));
+  Napi::Value val = MaybeUnwrap(configObject.Get("val"));
+
+  switch (keyType) {
+    case CPP_STR:
+      SetObjectWithCppStringKey(weak, key, val, valType);
+      SetObjectWithCppStringKey(persistent, key, val, valType);
+      SetObjectWithCppStringKey(reference, key, val, valType);
+      break;
+
+    case C_STR:
+      SetObjectWithCStringKey(weak, key, val, valType);
+      SetObjectWithCStringKey(persistent, key, val, valType);
+      SetObjectWithCStringKey(reference, key, val, valType);
+      break;
+
+    case INT:
+      SetObjectWithIntKey(weak, key, val, valType);
+      SetObjectWithIntKey(persistent, key, val, valType);
+      SetObjectWithIntKey(reference, key, val, valType);
+
+    default:
+      break;
   }
 }
 
@@ -87,6 +237,53 @@ Value GetFromValue(const CallbackInfo& info) {
   }
 }
 
+Value GetHelper(ObjectReference& ref,
+                Object& configObject,
+                const Napi::Env& env) {
+  int keyType =
+      MaybeUnwrap(configObject.Get("keyType")).As<Napi::Number>().Uint32Value();
+  if (ref.IsEmpty()) {
+    return String::New(env, "No referenced Value");
+  }
+
+  switch (keyType) {
+    case C_STR: {
+      std::string c_key =
+          MaybeUnwrap(configObject.Get("key")).As<String>().Utf8Value();
+      return MaybeUnwrap(ref.Get(c_key.c_str()));
+      break;
+    }
+    case CPP_STR: {
+      std::string cpp_key =
+          MaybeUnwrap(configObject.Get("key")).As<String>().Utf8Value();
+      return MaybeUnwrap(ref.Get(cpp_key));
+      break;
+    }
+    case INT: {
+      uint32_t key =
+          MaybeUnwrap(configObject.Get("key")).As<Number>().Uint32Value();
+      return MaybeUnwrap(ref.Get(key));
+      break;
+    }
+
+    default:
+      return String::New(env, "Error: Reached end of getter");
+      break;
+  }
+}
+
+Value GetFromGetters(const CallbackInfo& info) {
+  std::string object_req = info[0].As<String>();
+  Object configObject = info[1].As<Object>();
+  if (object_req == "weak") {
+    return GetHelper(weak, configObject, info.Env());
+  } else if (object_req == "persistent") {
+    return GetHelper(persistent, configObject, info.Env());
+  }
+
+  return GetHelper(reference, configObject, info.Env());
+}
+
 // info[0] is a flag to determine if the weak, persistent, or
 // multiple reference ObjectReference is being requested.
 // info[1] is the key, and it be either a String or a Number.
@@ -207,13 +404,14 @@ Object InitObjectReference(Env env) {
   Object exports = Object::New(env);
 
   exports["setCastedObjects"] = Function::New(env, SetCastedObjects);
-  exports["setObjects"] = Function::New(env, SetObjects);
+  exports["setObject"] = Function::New(env, SetObject);
   exports["getCastedFromValue"] = Function::New(env, GetCastedFromValue);
-  exports["getFromGetter"] = Function::New(env, GetFromGetter);
+  exports["getFromGetters"] = Function::New(env, GetFromGetters);
   exports["getCastedFromGetter"] = Function::New(env, GetCastedFromGetter);
   exports["getFromValue"] = Function::New(env, GetFromValue);
   exports["unrefObjects"] = Function::New(env, UnrefObjects);
   exports["refObjects"] = Function::New(env, RefObjects);
+  exports["moveOpTest"] = Function::New(env, MoveOperatorsTest);
 
   return exports;
 }