koffi 1.0.3 → 1.1.0-beta.0

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

@@ -1,202 +0,0 @@
-#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

@@ -1,157 +0,0 @@
-'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

@@ -1,61 +0,0 @@
-#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

@@ -1,31 +0,0 @@
-#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

@@ -1,61 +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 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

@@ -1,40 +0,0 @@
-#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

@@ -1,57 +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'
-    };
-
-  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

@@ -1,28 +0,0 @@
-#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

@@ -1,48 +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 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');
-}