koffi 2.3.4 → 2.3.6-beta.1

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

@@ -14,66 +14,70 @@ Value CreateExternal(const CallbackInfo& info) {
 
 Value CreateExternalWithFinalize(const CallbackInfo& info) {
   finalizeCount = 0;
-  return External<int>::New(info.Env(), new int(1),
-    [](Env /*env*/, int* data) {
-      delete data;
-      finalizeCount++;
-    });
+  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);
+  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;
-   }
+  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;
-   }
+  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);
+  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;
+  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;
+    throw error;
 #else
       error.ThrowAsJavaScriptException();
 #endif
-    });
+  });
 }
 
-} // end anonymous namespace
+}  // 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["createExternalWithFinalize"] =
+      Function::New(env, CreateExternalWithFinalize);
   exports["createExternalWithFinalizeException"] =
       Function::New(env, CreateExternalWithFinalizeException);
-  exports["createExternalWithFinalizeHint"] = Function::New(env, CreateExternalWithFinalizeHint);
+  exports["createExternalWithFinalizeHint"] =
+      Function::New(env, CreateExternalWithFinalizeHint);
   exports["checkExternal"] = Function::New(env, CheckExternal);
   exports["getFinalizeCount"] = Function::New(env, GetFinalizeCount);
 

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

@@ -27,62 +27,59 @@ if (process.argv.length === 3) {
   // exception is thrown from a native `SetImmediate()` we cannot catch it
   // anywhere except in the process' `uncaughtException` handler.
   let maxGCTries = 10;
-  (function gcInterval() {
+  (function gcInterval () {
     global.gc();
     if (!interval) {
       interval = setInterval(gcInterval, 100);
     } else if (--maxGCTries === 0) {
       throw new Error('Timed out waiting for the gc to throw');
-      process.exit(1);
     }
   })();
+} else {
+  module.exports = require('./common').runTestWithBindingPath(test);
 
-  return;
-}
-
-module.exports = require('./common').runTestWithBindingPath(test);
-
-function test(bindingPath) {
-  const binding = require(bindingPath);
+  function test (bindingPath) {
+    const binding = require(bindingPath);
 
-  const child = spawnSync(process.execPath, [
-    '--expose-gc', __filename, bindingPath
-  ], { stdio: 'inherit' });
-  assert.strictEqual(child.status, 0);
-  assert.strictEqual(child.signal, null);
+    const child = spawnSync(process.execPath, [
+      '--expose-gc', __filename, bindingPath
+    ], { stdio: 'inherit' });
+    assert.strictEqual(child.status, 0);
+    assert.strictEqual(child.signal, null);
 
-  return testUtil.runGCTests([
-    'External without finalizer',
-    () => {
-      const test = binding.external.createExternal();
-      assert.strictEqual(typeof test, 'object');
-      binding.external.checkExternal(test);
-      assert.strictEqual(0, binding.external.getFinalizeCount());
-    },
-    () => {
-      assert.strictEqual(0, binding.external.getFinalizeCount());
-    },
+    return testUtil.runGCTests([
+      'External without finalizer',
+      () => {
+        const test = binding.external.createExternal();
+        assert.strictEqual(typeof test, 'object');
+        binding.external.checkExternal(test);
+        assert.strictEqual(0, binding.external.getFinalizeCount());
+      },
+      () => {
+        assert.strictEqual(0, binding.external.getFinalizeCount());
+      },
 
-    'External with finalizer',
-    () => {
-      const test = binding.external.createExternalWithFinalize();
-      assert.strictEqual(typeof test, 'object');
-      binding.external.checkExternal(test);
-      assert.strictEqual(0, binding.external.getFinalizeCount());
-    },
-    () => {
-      assert.strictEqual(1, binding.external.getFinalizeCount());
-    },
+      'External with finalizer',
+      () => {
+        const test = binding.external.createExternalWithFinalize();
+        assert.strictEqual(typeof test, 'object');
+        binding.external.checkExternal(test);
+        assert.strictEqual(0, binding.external.getFinalizeCount());
+      },
+      () => {
+        assert.strictEqual(1, binding.external.getFinalizeCount());
+      },
 
-    'External with finalizer hint',
-    () => {
-      const test = binding.external.createExternalWithFinalizeHint();
-      assert.strictEqual(typeof test, 'object');
-      binding.external.checkExternal(test);
-      assert.strictEqual(0, binding.external.getFinalizeCount());
-    },
-    () => {
-      assert.strictEqual(1, binding.external.getFinalizeCount());
-    },
-  ]);
+      'External with finalizer hint',
+      () => {
+        const test = binding.external.createExternalWithFinalizeHint();
+        assert.strictEqual(typeof test, 'object');
+        binding.external.checkExternal(test);
+        assert.strictEqual(0, binding.external.getFinalizeCount());
+      },
+      () => {
+        assert.strictEqual(1, binding.external.getFinalizeCount());
+      }
+    ]);
+  }
 }

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

@@ -60,13 +60,13 @@ Value CallWithArgs(const CallbackInfo& info) {
 }
 
 Value CallWithVector(const CallbackInfo& info) {
-   Function func = info[0].As<Function>();
-   std::vector<napi_value> args;
-   args.reserve(3);
-   args.push_back(info[1]);
-   args.push_back(info[2]);
-   args.push_back(info[3]);
-   return MaybeUnwrap(func.Call(args));
+  Function func = info[0].As<Function>();
+  std::vector<napi_value> args;
+  args.reserve(3);
+  args.push_back(info[1]);
+  args.push_back(info[2]);
+  args.push_back(info[3]);
+  return MaybeUnwrap(func.Call(args));
 }
 
 Value CallWithVectorUsingCppWrapper(const CallbackInfo& info) {
@@ -101,21 +101,21 @@ Value CallWithReceiverAndCStyleArray(const CallbackInfo& info) {
 }
 
 Value CallWithReceiverAndArgs(const CallbackInfo& info) {
-   Function func = info[0].As<Function>();
-   Value receiver = info[1];
-   return MaybeUnwrap(func.Call(
-       receiver, std::initializer_list<napi_value>{info[2], info[3], info[4]}));
+  Function func = info[0].As<Function>();
+  Value receiver = info[1];
+  return MaybeUnwrap(func.Call(
+      receiver, std::initializer_list<napi_value>{info[2], info[3], info[4]}));
 }
 
 Value CallWithReceiverAndVector(const CallbackInfo& info) {
-   Function func = info[0].As<Function>();
-   Value receiver = info[1];
-   std::vector<napi_value> args;
-   args.reserve(3);
-   args.push_back(info[2]);
-   args.push_back(info[3]);
-   args.push_back(info[4]);
-   return MaybeUnwrap(func.Call(receiver, args));
+  Function func = info[0].As<Function>();
+  Value receiver = info[1];
+  std::vector<napi_value> args;
+  args.reserve(3);
+  args.push_back(info[2]);
+  args.push_back(info[3]);
+  args.push_back(info[4]);
+  return MaybeUnwrap(func.Call(receiver, args));
 }
 
 Value CallWithReceiverAndVectorUsingCppWrapper(const CallbackInfo& info) {
@@ -130,25 +130,25 @@ Value CallWithReceiverAndVectorUsingCppWrapper(const CallbackInfo& info) {
 }
 
 Value CallWithInvalidReceiver(const CallbackInfo& info) {
-   Function func = info[0].As<Function>();
-   return MaybeUnwrapOr(func.Call(Value(), std::initializer_list<napi_value>{}),
-                        Value());
+  Function func = info[0].As<Function>();
+  return MaybeUnwrapOr(func.Call(Value(), std::initializer_list<napi_value>{}),
+                       Value());
 }
 
 Value CallConstructorWithArgs(const CallbackInfo& info) {
-   Function func = info[0].As<Function>();
-   return MaybeUnwrap(
-       func.New(std::initializer_list<napi_value>{info[1], info[2], info[3]}));
+  Function func = info[0].As<Function>();
+  return MaybeUnwrap(
+      func.New(std::initializer_list<napi_value>{info[1], info[2], info[3]}));
 }
 
 Value CallConstructorWithVector(const CallbackInfo& info) {
-   Function func = info[0].As<Function>();
-   std::vector<napi_value> args;
-   args.reserve(3);
-   args.push_back(info[1]);
-   args.push_back(info[2]);
-   args.push_back(info[3]);
-   return MaybeUnwrap(func.New(args));
+  Function func = info[0].As<Function>();
+  std::vector<napi_value> args;
+  args.reserve(3);
+  args.push_back(info[1]);
+  args.push_back(info[2]);
+  args.push_back(info[3]);
+  return MaybeUnwrap(func.New(args));
 }
 
 Value CallConstructorWithCStyleArray(const CallbackInfo& info) {
@@ -162,9 +162,13 @@ Value CallConstructorWithCStyleArray(const CallbackInfo& info) {
 }
 
 void IsConstructCall(const CallbackInfo& info) {
-   Function callback = info[0].As<Function>();
-   bool isConstructCall = info.IsConstructCall();
-   callback({Napi::Boolean::New(info.Env(), isConstructCall)});
+  Function callback = info[0].As<Function>();
+  bool isConstructCall = info.IsConstructCall();
+  callback({Napi::Boolean::New(info.Env(), isConstructCall)});
+}
+
+Value NewTargetCallback(const CallbackInfo& info) {
+  return info.NewTarget();
 }
 
 void MakeCallbackWithArgs(const CallbackInfo& info) {
@@ -220,18 +224,21 @@ Value CallWithFunctionOperator(const CallbackInfo& info) {
   return MaybeUnwrap(func({info[1], info[2], info[3]}));
 }
 
-} // end anonymous namespace
+}  // end anonymous namespace
 
 Object InitFunction(Env env) {
   Object result = Object::New(env);
   Object exports = Object::New(env);
   exports["emptyConstructor"] = Function::New(env, EmptyConstructor);
   exports["voidCallback"] = Function::New(env, VoidCallback, "voidCallback");
-  exports["valueCallback"] = Function::New(env, ValueCallback, std::string("valueCallback"));
+  exports["valueCallback"] =
+      Function::New(env, ValueCallback, std::string("valueCallback"));
   exports["voidCallbackWithData"] =
-    Function::New(env, VoidCallbackWithData, nullptr, &testData);
+      Function::New(env, VoidCallbackWithData, nullptr, &testData);
   exports["valueCallbackWithData"] =
-    Function::New(env, ValueCallbackWithData, nullptr, &testData);
+      Function::New(env, ValueCallbackWithData, nullptr, &testData);
+  exports["newTargetCallback"] =
+      Function::New(env, NewTargetCallback, std::string("newTargetCallback"));
   exports["callWithArgs"] = Function::New(env, CallWithArgs);
   exports["callWithVector"] = Function::New(env, CallWithVector);
   exports["callWithVectorUsingCppWrapper"] =
@@ -239,13 +246,18 @@ Object InitFunction(Env env) {
   exports["callWithCStyleArray"] = Function::New(env, CallWithCStyleArray);
   exports["callWithReceiverAndCStyleArray"] =
       Function::New(env, CallWithReceiverAndCStyleArray);
-  exports["callWithReceiverAndArgs"] = Function::New(env, CallWithReceiverAndArgs);
-  exports["callWithReceiverAndVector"] = Function::New(env, CallWithReceiverAndVector);
+  exports["callWithReceiverAndArgs"] =
+      Function::New(env, CallWithReceiverAndArgs);
+  exports["callWithReceiverAndVector"] =
+      Function::New(env, CallWithReceiverAndVector);
   exports["callWithReceiverAndVectorUsingCppWrapper"] =
       Function::New(env, CallWithReceiverAndVectorUsingCppWrapper);
-  exports["callWithInvalidReceiver"] = Function::New(env, CallWithInvalidReceiver);
-  exports["callConstructorWithArgs"] = Function::New(env, CallConstructorWithArgs);
-  exports["callConstructorWithVector"] = Function::New(env, CallConstructorWithVector);
+  exports["callWithInvalidReceiver"] =
+      Function::New(env, CallWithInvalidReceiver);
+  exports["callConstructorWithArgs"] =
+      Function::New(env, CallConstructorWithArgs);
+  exports["callConstructorWithVector"] =
+      Function::New(env, CallConstructorWithVector);
   exports["callConstructorWithCStyleArray"] =
       Function::New(env, CallConstructorWithCStyleArray);
   exports["isConstructCall"] = Function::New(env, IsConstructCall);
@@ -265,6 +277,8 @@ Object InitFunction(Env env) {
   exports["voidCallback"] = Function::New<VoidCallback>(env, "voidCallback");
   exports["valueCallback"] =
       Function::New<ValueCallback>(env, std::string("valueCallback"));
+  exports["newTargetCallback"] =
+      Function::New<NewTargetCallback>(env, std::string("newTargetCallback"));
   exports["voidCallbackWithData"] =
       Function::New<VoidCallbackWithData>(env, nullptr, &testData);
   exports["valueCallbackWithData"] =

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

@@ -18,6 +18,10 @@ function test (binding) {
 
   assert.deepStrictEqual(binding.valueCallback(), { foo: 'bar' });
 
+  /* eslint-disable-next-line no-new, new-cap */
+  assert.strictEqual(new binding.newTargetCallback(), binding.newTargetCallback);
+  assert.strictEqual(binding.newTargetCallback(), undefined);
+
   let args = null;
   let ret = null;
   let receiver = null;

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

@@ -82,16 +82,16 @@ Value CallWithRecvVector(const CallbackInfo& info) {
 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];
+  size_t argLength = info.Length() > 2 ? info.Length() - 2 : 0;
+  std::unique_ptr<napi_value[]> args{argLength > 0 ? new napi_value[argLength]
+                                                   : nullptr};
+  for (size_t i = 0; i < argLength; ++i) {
+    args[i] = info[i + 2];
   }
 
-  return MaybeUnwrap(ref.Call(info[1], argLength, args));
+  return MaybeUnwrap(ref.Call(info[1], argLength, args.get()));
 }
 
 Value MakeAsyncCallbackWithInitList(const Napi::CallbackInfo& info) {
@@ -121,17 +121,19 @@ Value MakeAsyncCallbackWithVector(const Napi::CallbackInfo& info) {
 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];
+  size_t argLength = info.Length() > 1 ? info.Length() - 1 : 0;
+  std::unique_ptr<napi_value[]> args{argLength > 0 ? new napi_value[argLength]
+                                                   : nullptr};
+  for (size_t i = 0; i < argLength; ++i) {
+    args[i] = info[i + 1];
   }
 
   Napi::AsyncContext context(info.Env(), "func_ref_resources", {});
-  return MaybeUnwrap(ref.MakeCallback(
-      Napi::Object::New(info.Env()), argLength, args, context));
+  return MaybeUnwrap(ref.MakeCallback(Napi::Object::New(info.Env()),
+                                      argLength,
+                                      argLength > 0 ? args.get() : nullptr,
+                                      context));
 }
 
 Value CreateFunctionReferenceUsingNew(const Napi::CallbackInfo& info) {

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

@@ -4,58 +4,55 @@ 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 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');
+  }
+
+  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.js

@@ -4,51 +4,50 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
+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'
-    };
+    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) {
+  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;
-      }
+    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) {
+  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('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');