koffi 0.9.34 → 0.9.37

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

@@ -0,0 +1,202 @@
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+class FuncRefObject : public Napi::ObjectWrap<FuncRefObject> {
+ public:
+  FuncRefObject(const Napi::CallbackInfo& info)
+      : Napi::ObjectWrap<FuncRefObject>(info) {
+    Napi::Env env = info.Env();
+    int argLen = info.Length();
+    if (argLen <= 0 || !info[0].IsNumber()) {
+      Napi::TypeError::New(env, "First param should be a number")
+          .ThrowAsJavaScriptException();
+      return;
+    }
+    Napi::Number value = info[0].As<Napi::Number>();
+    this->_value = value.Int32Value();
+  }
+
+  Napi::Value GetValue(const Napi::CallbackInfo& info) {
+    int value = this->_value;
+    return Napi::Number::New(info.Env(), value);
+  }
+
+ private:
+  int _value;
+};
+
+namespace {
+
+Value ConstructRefFromExisitingRef(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  FunctionReference movedRef;
+  ref.Reset(info[0].As<Function>());
+  movedRef = std::move(ref);
+
+  return MaybeUnwrap(movedRef({}));
+}
+
+Value CallWithVectorArgs(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  std::vector<napi_value> newVec;
+  FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+
+  for (int i = 1; i < (int)info.Length(); i++) {
+    newVec.push_back(info[i]);
+  }
+  return MaybeUnwrap(ref.Call(newVec));
+}
+
+Value CallWithInitList(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+
+  return MaybeUnwrap(ref.Call({info[1], info[2], info[3]}));
+}
+
+Value CallWithRecvInitList(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+
+  return MaybeUnwrap(ref.Call(info[1], {info[2], info[3], info[4]}));
+}
+
+Value CallWithRecvVector(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  std::vector<napi_value> newVec;
+  ref.Reset(info[0].As<Function>());
+
+  for (int i = 2; i < (int)info.Length(); i++) {
+    newVec.push_back(info[i]);
+  }
+  return MaybeUnwrap(ref.Call(info[1], newVec));
+}
+
+Value CallWithRecvArgc(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  int argLength = info.Length() - 2;
+  napi_value* args = new napi_value[argLength];
+  ref.Reset(info[0].As<Function>());
+
+  int argIdx = 0;
+  for (int i = 2; i < (int)info.Length(); i++, argIdx++) {
+    args[argIdx] = info[i];
+  }
+
+  return MaybeUnwrap(ref.Call(info[1], argLength, args));
+}
+
+Value MakeAsyncCallbackWithInitList(const Napi::CallbackInfo& info) {
+  Napi::FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+
+  Napi::AsyncContext context(info.Env(), "func_ref_resources", {});
+
+  return MaybeUnwrap(
+      ref.MakeCallback(Napi::Object::New(info.Env()), {}, context));
+}
+
+Value MakeAsyncCallbackWithVector(const Napi::CallbackInfo& info) {
+  Napi::FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+  std::vector<napi_value> newVec;
+  Napi::AsyncContext context(info.Env(), "func_ref_resources", {});
+
+  for (int i = 1; i < (int)info.Length(); i++) {
+    newVec.push_back(info[i]);
+  }
+
+  return MaybeUnwrap(
+      ref.MakeCallback(Napi::Object::New(info.Env()), newVec, context));
+}
+
+Value MakeAsyncCallbackWithArgv(const Napi::CallbackInfo& info) {
+  Napi::FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+  int argLength = info.Length() - 1;
+  napi_value* args = new napi_value[argLength];
+
+  int argIdx = 0;
+  for (int i = 1; i < (int)info.Length(); i++, argIdx++) {
+    args[argIdx] = info[i];
+  }
+
+  Napi::AsyncContext context(info.Env(), "func_ref_resources", {});
+  return MaybeUnwrap(ref.MakeCallback(
+      Napi::Object::New(info.Env()), argLength, args, context));
+}
+
+Value CreateFunctionReferenceUsingNew(const Napi::CallbackInfo& info) {
+  Napi::Function func = ObjectWrap<FuncRefObject>::DefineClass(
+      info.Env(),
+      "MyObject",
+      {ObjectWrap<FuncRefObject>::InstanceMethod("getValue",
+                                                 &FuncRefObject::GetValue)});
+  Napi::FunctionReference* constructor = new Napi::FunctionReference();
+  *constructor = Napi::Persistent(func);
+
+  return MaybeUnwrapOr(constructor->New({info[0].As<Number>()}), Object());
+}
+
+Value CreateFunctionReferenceUsingNewVec(const Napi::CallbackInfo& info) {
+  Napi::Function func = ObjectWrap<FuncRefObject>::DefineClass(
+      info.Env(),
+      "MyObject",
+      {ObjectWrap<FuncRefObject>::InstanceMethod("getValue",
+                                                 &FuncRefObject::GetValue)});
+  Napi::FunctionReference* constructor = new Napi::FunctionReference();
+  *constructor = Napi::Persistent(func);
+  std::vector<napi_value> newVec;
+  newVec.push_back(info[0]);
+
+  return MaybeUnwrapOr(constructor->New(newVec), Object());
+}
+
+Value Call(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+
+  return MaybeUnwrapOr(ref.Call({}), Value());
+}
+
+Value Construct(const CallbackInfo& info) {
+  HandleScope scope(info.Env());
+  FunctionReference ref;
+  ref.Reset(info[0].As<Function>());
+
+  return MaybeUnwrapOr(ref.New({}), Object());
+}
+}  // namespace
+
+Object InitFunctionReference(Env env) {
+  Object exports = Object::New(env);
+  exports["CreateFuncRefWithNew"] =
+      Function::New(env, CreateFunctionReferenceUsingNew);
+  exports["CreateFuncRefWithNewVec"] =
+      Function::New(env, CreateFunctionReferenceUsingNewVec);
+  exports["CallWithRecvArgc"] = Function::New(env, CallWithRecvArgc);
+  exports["CallWithRecvVector"] = Function::New(env, CallWithRecvVector);
+  exports["CallWithRecvInitList"] = Function::New(env, CallWithRecvInitList);
+  exports["CallWithInitList"] = Function::New(env, CallWithInitList);
+  exports["CallWithVec"] = Function::New(env, CallWithVectorArgs);
+  exports["ConstructWithMove"] =
+      Function::New(env, ConstructRefFromExisitingRef);
+  exports["AsyncCallWithInitList"] =
+      Function::New(env, MakeAsyncCallbackWithInitList);
+  exports["AsyncCallWithVector"] =
+      Function::New(env, MakeAsyncCallbackWithVector);
+  exports["AsyncCallWithArgv"] = Function::New(env, MakeAsyncCallbackWithArgv);
+  exports["call"] = Function::New(env, Call);
+  exports["construct"] = Function::New(env, Construct);
+
+  return exports;
+}

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

@@ -0,0 +1,157 @@
+'use strict';
+
+const assert = require('assert');
+const asyncHook = require('async_hooks');
+
+module.exports = require('./common').runTest(async (binding) => {
+  await test(binding.functionreference);
+});
+
+function installAsyncHook () {
+  let id;
+  let destroyed;
+  let hook;
+  const events = [];
+  return new Promise((resolve, reject) => {
+    const interval = setInterval(() => {
+      if (destroyed) {
+        hook.disable();
+        clearInterval(interval);
+        resolve(events);
+      }
+    }, 10);
+
+    hook = asyncHook
+      .createHook({
+        init (asyncId, type, triggerAsyncId, resource) {
+          if (id === undefined && type === 'func_ref_resources') {
+            id = asyncId;
+            events.push({ eventName: 'init', type, triggerAsyncId, resource });
+          }
+        },
+        before (asyncId) {
+          if (asyncId === id) {
+            events.push({ eventName: 'before' });
+          }
+        },
+        after (asyncId) {
+          if (asyncId === id) {
+            events.push({ eventName: 'after' });
+          }
+        },
+        destroy (asyncId) {
+          if (asyncId === id) {
+            events.push({ eventName: 'destroy' });
+            destroyed = true;
+          }
+        }
+      })
+      .enable();
+  });
+}
+
+function canConstructRefFromExistingRef (binding) {
+  const testFunc = () => 240;
+  assert(binding.ConstructWithMove(testFunc) === 240);
+}
+
+function canCallFunctionWithDifferentOverloads (binding) {
+  let outsideRef = {};
+  const testFunc = (a, b) => a * a - b * b;
+  const testFuncB = (a, b, c) => a + b - c * c;
+  const testFuncC = (a, b, c) => {
+    outsideRef.a = a;
+    outsideRef.b = b;
+    outsideRef.c = c;
+  };
+  const testFuncD = (a, b, c, d) => {
+    outsideRef.result = a + b * c - d;
+    return outsideRef.result;
+  };
+
+  assert(binding.CallWithVec(testFunc, 5, 4) === testFunc(5, 4));
+  assert(binding.CallWithInitList(testFuncB, 2, 4, 5) === testFuncB(2, 4, 5));
+
+  binding.CallWithRecvVector(testFuncC, outsideRef, 1, 2, 4);
+  assert(outsideRef.a === 1 && outsideRef.b === 2 && outsideRef.c === 4);
+
+  outsideRef = {};
+  binding.CallWithRecvInitList(testFuncC, outsideRef, 1, 2, 4);
+  assert(outsideRef.a === 1 && outsideRef.b === 2 && outsideRef.c === 4);
+
+  outsideRef = {};
+  binding.CallWithRecvArgc(testFuncD, outsideRef, 2, 4, 5, 6);
+  assert(outsideRef.result === testFuncD(2, 4, 5, 6));
+}
+
+async function canCallAsyncFunctionWithDifferentOverloads (binding) {
+  const testFunc = () => 2100;
+  const testFuncB = (a, b, c, d) => a + b + c + d;
+  let hook = installAsyncHook();
+  binding.AsyncCallWithInitList(testFunc);
+  let triggerAsyncId = asyncHook.executionAsyncId();
+  let res = await hook;
+  assert.deepStrictEqual(res, [
+    {
+      eventName: 'init',
+      type: 'func_ref_resources',
+      triggerAsyncId: triggerAsyncId,
+      resource: {}
+    },
+    { eventName: 'before' },
+    { eventName: 'after' },
+    { eventName: 'destroy' }
+  ]);
+
+  hook = installAsyncHook();
+  triggerAsyncId = asyncHook.executionAsyncId();
+  assert(
+    binding.AsyncCallWithVector(testFuncB, 2, 4, 5, 6) === testFuncB(2, 4, 5, 6)
+  );
+  res = await hook;
+  assert.deepStrictEqual(res, [
+    {
+      eventName: 'init',
+      type: 'func_ref_resources',
+      triggerAsyncId: triggerAsyncId,
+      resource: {}
+    },
+    { eventName: 'before' },
+    { eventName: 'after' },
+    { eventName: 'destroy' }
+  ]);
+
+  hook = installAsyncHook();
+  triggerAsyncId = asyncHook.executionAsyncId();
+  assert(
+    binding.AsyncCallWithArgv(testFuncB, 2, 4, 5, 6) === testFuncB(2, 4, 5, 6)
+  );
+}
+async function test (binding) {
+  const e = new Error('foobar');
+  const functionMayThrow = () => {
+    throw e;
+  };
+  const classMayThrow = class {
+    constructor () {
+      throw e;
+    }
+  };
+
+  const newRef = binding.CreateFuncRefWithNew(120);
+  assert(newRef.getValue() === 120);
+
+  const newRefWithVecArg = binding.CreateFuncRefWithNewVec(80);
+  assert(newRefWithVecArg.getValue() === 80);
+
+  assert.throws(() => {
+    binding.call(functionMayThrow);
+  }, /foobar/);
+  assert.throws(() => {
+    binding.construct(classMayThrow);
+  }, /foobar/);
+
+  canConstructRefFromExistingRef(binding);
+  canCallFunctionWithDifferentOverloads(binding);
+  await canCallAsyncFunctionWithDifferentOverloads(binding);
+}

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

@@ -0,0 +1,61 @@
+#include "napi.h"
+
+using namespace Napi;
+
+// Wrappers for testing Object::Get() for global Objects
+Value GetPropertyWithCppStyleStringAsKey(const CallbackInfo& info);
+Value GetPropertyWithCStyleStringAsKey(const CallbackInfo& info);
+Value GetPropertyWithInt32AsKey(const CallbackInfo& info);
+Value GetPropertyWithNapiValueAsKey(const CallbackInfo& info);
+void CreateMockTestObject(const CallbackInfo& info);
+
+// Wrapper for testing Object::Set() for global Objects
+void SetPropertyWithCStyleStringAsKey(const CallbackInfo& info);
+void SetPropertyWithCppStyleStringAsKey(const CallbackInfo& info);
+void SetPropertyWithInt32AsKey(const CallbackInfo& info);
+void SetPropertyWithNapiValueAsKey(const CallbackInfo& info);
+
+Value HasPropertyWithCStyleStringAsKey(const CallbackInfo& info);
+Value HasPropertyWithCppStyleStringAsKey(const CallbackInfo& info);
+Value HasPropertyWithNapiValueAsKey(const CallbackInfo& info);
+
+Value DeletePropertyWithCStyleStringAsKey(const CallbackInfo& info);
+Value DeletePropertyWithCppStyleStringAsKey(const CallbackInfo& info);
+Value DeletePropertyWithInt32AsKey(const CallbackInfo& info);
+Value DeletePropertyWithNapiValueAsKey(const CallbackInfo& info);
+
+Object InitGlobalObject(Env env) {
+  Object exports = Object::New(env);
+  exports["getPropertyWithInt32"] =
+      Function::New(env, GetPropertyWithInt32AsKey);
+  exports["getPropertyWithNapiValue"] =
+      Function::New(env, GetPropertyWithNapiValueAsKey);
+  exports["getPropertyWithCppString"] =
+      Function::New(env, GetPropertyWithCppStyleStringAsKey);
+  exports["getPropertyWithCString"] =
+      Function::New(env, GetPropertyWithCStyleStringAsKey);
+  exports["createMockTestObject"] = Function::New(env, CreateMockTestObject);
+  exports["setPropertyWithCStyleString"] =
+      Function::New(env, SetPropertyWithCStyleStringAsKey);
+  exports["setPropertyWithCppStyleString"] =
+      Function::New(env, SetPropertyWithCppStyleStringAsKey);
+  exports["setPropertyWithNapiValue"] =
+      Function::New(env, SetPropertyWithNapiValueAsKey);
+  exports["setPropertyWithInt32"] =
+      Function::New(env, SetPropertyWithInt32AsKey);
+  exports["hasPropertyWithCStyleString"] =
+      Function::New(env, HasPropertyWithCStyleStringAsKey);
+  exports["hasPropertyWithCppStyleString"] =
+      Function::New(env, HasPropertyWithCppStyleStringAsKey);
+  exports["hasPropertyWithNapiValue"] =
+      Function::New(env, HasPropertyWithNapiValueAsKey);
+  exports["deletePropertyWithCStyleString"] =
+      Function::New(env, DeletePropertyWithCStyleStringAsKey);
+  exports["deletePropertyWithCppStyleString"] =
+      Function::New(env, DeletePropertyWithCppStyleStringAsKey);
+  exports["deletePropertyWithInt32"] =
+      Function::New(env, DeletePropertyWithInt32AsKey);
+  exports["deletePropertyWithNapiValue"] =
+      Function::New(env, DeletePropertyWithNapiValueAsKey);
+  return exports;
+}

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

@@ -0,0 +1,31 @@
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+Value DeletePropertyWithCStyleStringAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  String key = info[0].As<String>();
+  return Boolean::New(
+      info.Env(), MaybeUnwrap(globalObject.Delete(key.Utf8Value().c_str())));
+}
+
+Value DeletePropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  String key = info[0].As<String>();
+  return Boolean::New(info.Env(),
+                      MaybeUnwrap(globalObject.Delete(key.Utf8Value())));
+}
+
+Value DeletePropertyWithInt32AsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  Number key = info[0].As<Number>();
+  return Boolean::New(info.Env(),
+                      MaybeUnwrap(globalObject.Delete(key.Uint32Value())));
+}
+
+Value DeletePropertyWithNapiValueAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  Name key = info[0].As<Name>();
+  return Boolean::New(info.Env(), MaybeUnwrap(globalObject.Delete(key)));
+}

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

@@ -0,0 +1,61 @@
+'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 assertNotGlobalObjectHasNoProperty(key, keyType)
+    {
+        switch(keyType)
+        {
+            case KEY_TYPE.NAPI:
+                assert.notStrictEqual(binding.globalObject.hasPropertyWithNapiValue(key), true);
+                break;
+
+              case KEY_TYPE.C_STR:
+                assert.notStrictEqual(binding.globalObject.hasPropertyWithCStyleString(key), true);
+                break;
+
+              case KEY_TYPE.CPP_STR:
+                assert.notStrictEqual(binding.globalObject.hasPropertyWithCppStyleString(key), true);
+                break;
+
+              case KEY_TYPE.INT_32:
+                assert.notStrictEqual(binding.globalObject.hasPropertyWithInt32(key), true);
+                break;
+        }
+    }
+
+    function assertErrMessageIsThrown(propertyCheckExistenceFunction, errMsg) {
+        assert.throws(() => {
+          propertyCheckExistenceFunction(undefined);
+        }, errMsg);
+    }
+
+    binding.globalObject.createMockTestObject();
+
+    binding.globalObject.deletePropertyWithCStyleString('c_str_key');
+    binding.globalObject.deletePropertyWithCppStyleString('cpp_string_key');
+    binding.globalObject.deletePropertyWithCppStyleString('circular');
+    binding.globalObject.deletePropertyWithInt32(15);
+    binding.globalObject.deletePropertyWithNapiValue('2');
+
+
+    assertNotGlobalObjectHasNoProperty('c_str_key',KEY_TYPE.C_STR);
+    assertNotGlobalObjectHasNoProperty('cpp_string_key',KEY_TYPE.CPP_STR);
+    assertNotGlobalObjectHasNoProperty('circular',KEY_TYPE.CPP_STR);
+    assertNotGlobalObjectHasNoProperty(15,true);
+    assertNotGlobalObjectHasNoProperty('2', KEY_TYPE.NAPI);
+
+    assertErrMessageIsThrown(binding.globalObject.hasPropertyWithCppStyleString, 'Error: A string was expected');
+    assertErrMessageIsThrown(binding.globalObject.hasPropertyWithCStyleString, 'Error: A string was expected');
+    assertErrMessageIsThrown(binding.globalObject.hasPropertyWithInt32, 'Error: A number was expected');
+}

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

@@ -0,0 +1,40 @@
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+Value GetPropertyWithNapiValueAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  Name key = info[0].As<Name>();
+  return MaybeUnwrap(globalObject.Get(key));
+}
+
+Value GetPropertyWithInt32AsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  Number key = info[0].As<Napi::Number>();
+  return MaybeUnwrapOr(globalObject.Get(key.Uint32Value()), Value());
+}
+
+Value GetPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  String cStrkey = info[0].As<String>();
+  return MaybeUnwrapOr(globalObject.Get(cStrkey.Utf8Value().c_str()), Value());
+}
+
+Value GetPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  String cppStrKey = info[0].As<String>();
+  return MaybeUnwrapOr(globalObject.Get(cppStrKey.Utf8Value()), Value());
+}
+
+void CreateMockTestObject(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  Number napi_key = Number::New(info.Env(), 2);
+  const char* CStringKey = "c_str_key";
+
+  globalObject.Set(napi_key, "napi_attribute");
+  globalObject[CStringKey] = "c_string_attribute";
+  globalObject[std::string("cpp_string_key")] = "cpp_string_attribute";
+  globalObject[std::string("circular")] = globalObject;
+  globalObject[(uint32_t)15] = 15;
+}

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

@@ -0,0 +1,57 @@
+'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'
+    };
+
+  binding.globalObject.createMockTestObject();
+  function assertGlobalObjectPropertyIs(key, attribute, keyType) {
+    let napiObjectAttr;
+    switch(keyType)
+      {
+        case KEY_TYPE.NAPI:
+          napiObjectAttr = binding.globalObject.getPropertyWithNapiValue(key);
+          assert.deepStrictEqual(attribute, napiObjectAttr);
+          break;
+
+        case KEY_TYPE.C_STR:
+          napiObjectAttr = binding.globalObject.getPropertyWithCString(key);
+          assert.deepStrictEqual(attribute, napiObjectAttr);
+          break;
+
+        case KEY_TYPE.CPP_STR:
+          napiObjectAttr = binding.globalObject.getPropertyWithCppString(key);
+          assert.deepStrictEqual(attribute, napiObjectAttr);
+          break;
+
+        case KEY_TYPE.INT_32:
+          napiObjectAttr = binding.globalObject.getPropertyWithInt32(key);
+          assert.deepStrictEqual(attribute, napiObjectAttr);
+          break;
+      }
+  }
+
+  function assertErrMessageIsThrown(propertyFetchFunction, errMsg) {
+    assert.throws(() => {
+      propertyFetchFunction(undefined);
+    }, errMsg);
+  }
+
+  assertGlobalObjectPropertyIs('2',global['2'], KEY_TYPE.NAPI);
+  assertGlobalObjectPropertyIs('c_str_key',global['c_str_key'],KEY_TYPE.C_STR);
+  assertGlobalObjectPropertyIs('cpp_string_key',global['cpp_string_key'],KEY_TYPE.CPP_STR);
+  assertGlobalObjectPropertyIs('circular',global['circular'],KEY_TYPE.CPP_STR);
+  assertGlobalObjectPropertyIs(15, global['15'], KEY_TYPE.INT_32);
+
+  assertErrMessageIsThrown(binding.globalObject.getPropertyWithCString, 'Error: A string was expected');
+  assertErrMessageIsThrown(binding.globalObject.getPropertyWithCppString, 'Error: A string was expected');
+  assertErrMessageIsThrown(binding.globalObject.getPropertyWithInt32, 'Error: A number was expected');
+}

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

@@ -0,0 +1,28 @@
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+Value HasPropertyWithCStyleStringAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  String key = info[0].As<String>();
+  return Boolean::New(
+      info.Env(),
+      MaybeUnwrapOr(globalObject.HasOwnProperty(key.Utf8Value().c_str()),
+                    false));
+}
+
+Value HasPropertyWithCppStyleStringAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  String key = info[0].As<String>();
+  return Boolean::New(
+      info.Env(),
+      MaybeUnwrapOr(globalObject.HasOwnProperty(key.Utf8Value()), false));
+}
+
+Value HasPropertyWithNapiValueAsKey(const CallbackInfo& info) {
+  Object globalObject = info.Env().Global();
+  Name key = info[0].As<Name>();
+  return Boolean::New(info.Env(),
+                      MaybeUnwrap(globalObject.HasOwnProperty(key)));
+}

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

@@ -0,0 +1,48 @@
+'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 assertGlobalObjectHasProperty(key, keyType)
+    {
+        switch(keyType)
+        {
+            case KEY_TYPE.NAPI:
+                assert.strictEqual(binding.globalObject.hasPropertyWithNapiValue(key), true);
+                break;
+
+              case KEY_TYPE.C_STR:
+                assert.strictEqual(binding.globalObject.hasPropertyWithCStyleString(key), true);
+                break;
+
+              case KEY_TYPE.CPP_STR:
+                assert.strictEqual(binding.globalObject.hasPropertyWithCppStyleString(key), true);
+                break;
+        }
+    }
+
+    function assertErrMessageIsThrown(propertyCheckExistenceFunction, errMsg) {
+        assert.throws(() => {
+          propertyCheckExistenceFunction(undefined);
+        }, errMsg);
+    }
+
+    binding.globalObject.createMockTestObject();
+    assertGlobalObjectHasProperty('c_str_key',KEY_TYPE.C_STR);
+    assertGlobalObjectHasProperty('cpp_string_key',KEY_TYPE.CPP_STR);
+    assertGlobalObjectHasProperty('circular',KEY_TYPE.CPP_STR);
+    assertGlobalObjectHasProperty('2', KEY_TYPE.NAPI);
+
+    assertErrMessageIsThrown(binding.globalObject.hasPropertyWithCppStyleString, 'Error: A string was expected');
+    assertErrMessageIsThrown(binding.globalObject.hasPropertyWithCStyleString, 'Error: A string was expected');
+    assertErrMessageIsThrown(binding.globalObject.hasPropertyWithInt32, 'Error: A number was expected');
+}