koffi 2.3.4 → 2.3.6-beta.1

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

@@ -4,45 +4,43 @@ 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 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');
+  }
+
+  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');
 }

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

@@ -4,55 +4,53 @@ 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'
-    };
-
-    function setGlobalObjectKeyValue(key, value, keyType) {
-        switch(keyType)
-        {
-            case KEY_TYPE.CPP_STR:
-            binding.globalObject.setPropertyWithCppStyleString(key,value);
-            break;
-
-            case KEY_TYPE.C_STR:
-            binding.globalObject.setPropertyWithCStyleString(key,value);
-            break;
-
-            case KEY_TYPE.INT_32:
-            binding.globalObject.setPropertyWithInt32(key,value);
-            break;
-
-            case KEY_TYPE.NAPI:
-            binding.globalObject.setPropertyWithNapiValue(key,value);
-            break;
-        }
+    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 setGlobalObjectKeyValue (key, value, keyType) {
+    switch (keyType) {
+      case KEY_TYPE.CPP_STR:
+        binding.globalObject.setPropertyWithCppStyleString(key, value);
+        break;
+
+      case KEY_TYPE.C_STR:
+        binding.globalObject.setPropertyWithCStyleString(key, value);
+        break;
+
+      case KEY_TYPE.INT_32:
+        binding.globalObject.setPropertyWithInt32(key, value);
+        break;
+
+      case KEY_TYPE.NAPI:
+        binding.globalObject.setPropertyWithNapiValue(key, value);
+        break;
     }
-
-    function assertErrMessageIsThrown(nativeObjectSetFunction, errMsg) {
-        assert.throws(() => {
-          nativeObjectSetFunction(undefined, 1);
-        }, errMsg);
-      }
-
-
-    setGlobalObjectKeyValue("cKey","cValue",KEY_TYPE.CPP_STR);
-    setGlobalObjectKeyValue(1,10,KEY_TYPE.INT_32);
-    setGlobalObjectKeyValue("napi_key","napi_value",KEY_TYPE.NAPI);
-    setGlobalObjectKeyValue("cppKey","cppValue",KEY_TYPE.CPP_STR);
-    setGlobalObjectKeyValue("circular",global,KEY_TYPE.NAPI);
-
-    assert.deepStrictEqual(global["circular"], global);
-    assert.deepStrictEqual(global["cppKey"],"cppValue");
-    assert.deepStrictEqual(global["napi_key"],"napi_value");
-    assert.deepStrictEqual(global[1],10);
-    assert.deepStrictEqual(global["cKey"],"cValue");
-
-    assertErrMessageIsThrown(binding.globalObject.setPropertyWithCppStyleString, 'Error: A string was expected');
-    assertErrMessageIsThrown(binding.globalObject.setPropertyWithCStyleString, 'Error: A string was expected');
-    assertErrMessageIsThrown(binding.globalObject.setPropertyWithInt32, 'Error: A number was expected');
+  }
+
+  function assertErrMessageIsThrown (nativeObjectSetFunction, errMsg) {
+    assert.throws(() => {
+      nativeObjectSetFunction(undefined, 1);
+    }, errMsg);
+  }
+
+  setGlobalObjectKeyValue('cKey', 'cValue', KEY_TYPE.CPP_STR);
+  setGlobalObjectKeyValue(1, 10, KEY_TYPE.INT_32);
+  setGlobalObjectKeyValue('napi_key', 'napi_value', KEY_TYPE.NAPI);
+  setGlobalObjectKeyValue('cppKey', 'cppValue', KEY_TYPE.CPP_STR);
+  setGlobalObjectKeyValue('circular', global, KEY_TYPE.NAPI);
+
+  assert.deepStrictEqual(global.circular, global);
+  assert.deepStrictEqual(global.cppKey, 'cppValue');
+  assert.deepStrictEqual(global.napi_key, 'napi_value');
+  assert.deepStrictEqual(global[1], 10);
+  assert.deepStrictEqual(global.cKey, 'cValue');
+
+  assertErrMessageIsThrown(binding.globalObject.setPropertyWithCppStyleString, 'Error: A string was expected');
+  assertErrMessageIsThrown(binding.globalObject.setPropertyWithCStyleString, 'Error: A string was expected');
+  assertErrMessageIsThrown(binding.globalObject.setPropertyWithInt32, 'Error: A number was expected');
 }

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

@@ -1,7 +1,7 @@
-#include "napi.h"
-#include "string.h"
 #include <stdio.h>
 #include <stdlib.h>
+#include "napi.h"
+#include "string.h"
 
 using namespace Napi;
 
@@ -13,6 +13,16 @@ Value createScope(const CallbackInfo& info) {
   return String::New(info.Env(), "scope");
 }
 
+Value createScopeFromExisting(const CallbackInfo& info) {
+  {
+    napi_handle_scope scope;
+    napi_open_handle_scope(info.Env(), &scope);
+    HandleScope scope_existing(info.Env(), scope);
+    String::New(scope_existing.Env(), "inner-existing-scope");
+  }
+  return String::New(info.Env(), "existing_scope");
+}
+
 Value escapeFromScope(const CallbackInfo& info) {
   Value result;
   {
@@ -22,6 +32,18 @@ Value escapeFromScope(const CallbackInfo& info) {
   return result;
 }
 
+Value escapeFromExistingScope(const CallbackInfo& info) {
+  Value result;
+  {
+    napi_escapable_handle_scope scope;
+    napi_open_escapable_handle_scope(info.Env(), &scope);
+    EscapableHandleScope scope_existing(info.Env(), scope);
+    result = scope_existing.Escape(
+        String::New(scope_existing.Env(), "inner-existing-scope"));
+  }
+  return result;
+}
+
 #define LOOP_MAX 1000000
 Value stressEscapeFromScope(const CallbackInfo& info) {
   Value result;
@@ -31,7 +53,7 @@ Value stressEscapeFromScope(const CallbackInfo& info) {
     snprintf(buffer, 128, "%d", i);
     std::string name = std::string("inner-scope") + std::string(buffer);
     Value newValue = String::New(info.Env(), name.c_str());
-    if (i == (LOOP_MAX -1)) {
+    if (i == (LOOP_MAX - 1)) {
       result = scope.Escape(newValue);
     }
   }
@@ -52,7 +74,11 @@ Object InitHandleScope(Env env) {
   Object exports = Object::New(env);
 
   exports["createScope"] = Function::New(env, createScope);
+  exports["createScopeFromExisting"] =
+      Function::New(env, createScopeFromExisting);
   exports["escapeFromScope"] = Function::New(env, escapeFromScope);
+  exports["escapeFromExistingScope"] =
+      Function::New(env, escapeFromExistingScope);
   exports["stressEscapeFromScope"] = Function::New(env, stressEscapeFromScope);
   exports["doubleEscapeFromScope"] = Function::New(env, doubleEscapeFromScope);
 

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

@@ -4,11 +4,13 @@ const assert = require('assert');
 
 module.exports = require('./common').runTest(test);
 
-function test(binding) {
+function test (binding) {
   assert.strictEqual(binding.handlescope.createScope(), 'scope');
+  assert.strictEqual(binding.handlescope.createScopeFromExisting(), 'existing_scope');
   assert.strictEqual(binding.handlescope.escapeFromScope(), 'inner-scope');
+  assert.strictEqual(binding.handlescope.escapeFromExistingScope(), 'inner-existing-scope');
   assert.strictEqual(binding.handlescope.stressEscapeFromScope(), 'inner-scope999999');
   assert.throws(() => binding.handlescope.doubleEscapeFromScope(),
-                Error,
-                ' napi_escape_handle already called on scope');
+    Error,
+    ' napi_escape_handle already called on scope');
 }

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

@@ -90,11 +90,6 @@ function loadTestModules (currentDirectory = __dirname, pre = '') {
 
 loadTestModules();
 
-process.config.target_defaults.default_configuration =
-  fs
-    .readdirSync(path.join(__dirname, process.env.REL_BUILD_PATH || '', 'build'))
-    .filter((item) => (item === 'Debug' || item === 'Release'))[0];
-
 let napiVersion = Number(process.versions.napi);
 if (process.env.NAPI_VERSION) {
   // we need this so that we don't try run tests that rely
@@ -139,6 +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);
 }
 
 (async function () {

package/vendor/node-addon-api/test/maybe/check.cc

@@ -1,3 +1,4 @@
+#include "assert.h"
 #include "napi.h"
 #if defined(NODE_ADDON_API_ENABLE_MAYBE)
 
@@ -6,11 +7,52 @@ using namespace Napi;
 namespace {
 
 void VoidCallback(const CallbackInfo& info) {
-  Function fn = info[0].As<Function>();
+  Napi::Function fn = info[0].As<Function>();
+  Maybe<Value> ret = fn.Call({});
 
-  Maybe<Value> it = fn.Call({});
+  assert(ret.IsNothing() == true);
+  assert(ret.IsJust() == false);
 
-  it.Check();
+  Napi::Value placeHolder = Napi::Number::New(info.Env(), 12345);
+  Napi::Value unwrappedValue = ret.UnwrapOr(placeHolder);
+
+  assert(unwrappedValue.As<Number>().Uint32Value() == 12345);
+
+  assert(ret.UnwrapTo(&placeHolder) == false);
+  assert(placeHolder.As<Number>().Uint32Value() == 12345);
+
+  ret.Check();
+}
+
+void TestMaybeOperatorOverload(const CallbackInfo& info) {
+  Napi::Function fn_a = info[0].As<Function>();
+  Napi::Function fn_b = info[1].As<Function>();
+
+  assert(fn_a.Call({}) == fn_a.Call({}));
+  assert(fn_a.Call({}) != fn_b.Call({}));
+}
+
+void NormalJsCallback(const CallbackInfo& info) {
+  Napi::Function fn = info[0].As<Function>();
+  uint32_t magic_number = info[1].As<Number>().Uint32Value();
+
+  Maybe<Value> ret = fn.Call({});
+
+  assert(ret.IsNothing() == false);
+  assert(ret.IsJust() == true);
+
+  Napi::Value unwrappedValue = ret.Unwrap();
+  assert(unwrappedValue.IsNumber() == true);
+
+  assert(unwrappedValue.As<Number>().Uint32Value() == magic_number);
+
+  unwrappedValue =
+      ret.UnwrapOr(Napi::Number::New(info.Env(), magic_number - 1));
+  assert(unwrappedValue.As<Number>().Uint32Value() == magic_number);
+
+  Napi::Value placeHolder = Napi::Number::New(info.Env(), magic_number - 1);
+  assert(ret.UnwrapTo(&placeHolder) == true);
+  assert(placeHolder.As<Number>().Uint32Value() == magic_number);
 }
 
 }  // end anonymous namespace
@@ -18,6 +60,10 @@ void VoidCallback(const CallbackInfo& info) {
 Object InitMaybeCheck(Env env) {
   Object exports = Object::New(env);
   exports.Set("voidCallback", Function::New(env, VoidCallback));
+  exports.Set("normalJsCallback", Function::New(env, NormalJsCallback));
+  exports.Set("testMaybeOverloadOp",
+              Function::New(env, TestMaybeOperatorOverload));
   return exports;
 }
+
 #endif

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

@@ -1,20 +1,22 @@
 'use strict';
 
-const buildType = process.config.target_defaults.default_configuration;
 const assert = require('assert');
-const os = require('os');
+const { whichBuildType } = require('../common');
 
 const napiChild = require('../napi_child');
 
-module.exports = test(require(`../build/${buildType}/binding_noexcept_maybe.node`).maybe_check);
+module.exports = async function wrapTest () {
+  const buildType = await whichBuildType();
+  test(require(`../build/${buildType}/binding_noexcept_maybe.node`).maybe_check);
+};
 
-function test(binding) {
+function test (binding) {
   if (process.argv.includes('child')) {
     child(binding);
     return;
   }
   const cp = napiChild.spawn(process.execPath, [__filename, 'child'], {
-    stdio: ['ignore', 'inherit', 'pipe'],
+    stdio: ['ignore', 'inherit', 'pipe']
   });
   cp.stderr.setEncoding('utf8');
   let stderr = '';
@@ -31,8 +33,18 @@ function test(binding) {
   });
 }
 
-function child(binding) {
+function child (binding) {
+  const MAGIC_NUMBER = 12459062;
+  binding.normalJsCallback(() => {
+    return MAGIC_NUMBER;
+  }, MAGIC_NUMBER);
+
+  binding.testMaybeOverloadOp(
+    () => { return MAGIC_NUMBER; },
+    () => { throw Error('Foobar'); }
+  );
+
   binding.voidCallback(() => {
     throw new Error('foobar');
-  })
+  });
 }

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

@@ -3,15 +3,16 @@
 using namespace Napi;
 
 Value externalAllocatedMemory(const CallbackInfo& info) {
-    int64_t kSize = 1024 * 1024;
-    int64_t baseline = MemoryManagement::AdjustExternalMemory(info.Env(), 0);
-    int64_t tmp = MemoryManagement::AdjustExternalMemory(info.Env(), kSize);
-    tmp = MemoryManagement::AdjustExternalMemory(info.Env(), -kSize);
-    return Boolean::New(info.Env(), tmp == baseline);
+  int64_t kSize = 1024 * 1024;
+  int64_t baseline = MemoryManagement::AdjustExternalMemory(info.Env(), 0);
+  int64_t tmp = MemoryManagement::AdjustExternalMemory(info.Env(), kSize);
+  tmp = MemoryManagement::AdjustExternalMemory(info.Env(), -kSize);
+  return Boolean::New(info.Env(), tmp == baseline);
 }
 
 Object InitMemoryManagement(Env env) {
-    Object exports = Object::New(env);
-    exports["externalAllocatedMemory"] = Function::New(env, externalAllocatedMemory);
-    return exports;
+  Object exports = Object::New(env);
+  exports["externalAllocatedMemory"] =
+      Function::New(env, externalAllocatedMemory);
+  return exports;
 }

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

@@ -4,6 +4,6 @@ const assert = require('assert');
 
 module.exports = require('./common').runTest(test);
 
-function test(binding) {
-    assert.strictEqual(binding.memory_management.externalAllocatedMemory(), true)
+function test (binding) {
+  assert.strictEqual(binding.memory_management.externalAllocatedMemory(), true);
 }

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

@@ -5,14 +5,14 @@ const testUtil = require('./testUtil');
 
 module.exports = require('./common').runTest(binding => test(binding.movable_callbacks));
 
-async function test(binding) {
+async function test (binding) {
   await testUtil.runGCTests([
     'External',
     () => {
       const fn = common.mustCall(() => {
         // noop
       }, 1);
-      const external = binding.createExternal(fn);
+      binding.createExternal(fn);
     },
     () => {
       // noop, wait for gc

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

@@ -4,13 +4,12 @@ const assert = require('assert');
 
 module.exports = require('./common').runTest(test);
 
-function test(binding) {
+function test (binding) {
   const expected = '123456789';
 
-
   assert.throws(binding.name.nullStringShouldThrow, {
     name: 'Error',
-    message: 'Error in native callback',
+    message: 'Error in native callback'
   });
   assert.ok(binding.name.checkString(expected, 'utf8'));
   assert.ok(binding.name.checkString(expected, 'utf16'));
@@ -37,6 +36,7 @@ function test(binding) {
   assert.ok(binding.name.checkString(substr2, 'utf8', 3));
   assert.ok(binding.name.checkString(substr2, 'utf16', 3));
 
+  // eslint-disable-next-line symbol-description
   assert.ok(binding.name.checkSymbol(Symbol()));
   assert.ok(binding.name.checkSymbol(Symbol('test')));
 

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

@@ -1,12 +1,12 @@
 // Makes sure that child processes are spawned appropriately.
-exports.spawnSync = function(command, args, options) {
+exports.spawnSync = function (command, args, options) {
   if (require('../index').needsFlag) {
     args.splice(0, 0, '--napi-modules');
   }
   return require('child_process').spawnSync(command, args, options);
 };
 
-exports.spawn = function(command, args, options) {
+exports.spawn = function (command, args, options) {
   if (require('../index').needsFlag) {
     args.splice(0, 0, '--napi-modules');
   }

package/vendor/node-addon-api/test/object/delete_property.js

@@ -4,10 +4,10 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
-  function testDeleteProperty(nativeDeleteProperty) {
+function test (binding) {
+  function testDeleteProperty (nativeDeleteProperty) {
     const obj = { one: 1, two: 2 };
-    Object.defineProperty(obj, "three", {configurable: false, value: 3});
+    Object.defineProperty(obj, 'three', { configurable: false, value: 3 });
     assert.strictEqual(nativeDeleteProperty(obj, 'one'), true);
     assert.strictEqual(nativeDeleteProperty(obj, 'missing'), true);
 
@@ -17,17 +17,17 @@ function test(binding) {
     assert.deepStrictEqual(obj, { two: 2 });
   }
 
-  function testShouldThrowErrorIfKeyIsInvalid(nativeDeleteProperty) {
+  function testShouldThrowErrorIfKeyIsInvalid (nativeDeleteProperty) {
     assert.throws(() => {
       nativeDeleteProperty(undefined, 'test');
     }, /Cannot convert undefined or null to object/);
   }
 
-  const testObj = { 15 : 42 , three: 3};
+  const testObj = { 15: 42, three: 3 };
 
-  binding.object.deletePropertyWithUint32(testObj,15);
+  binding.object.deletePropertyWithUint32(testObj, 15);
 
-  assert.strictEqual(testObj.hasOwnProperty(15),false);
+  assert.strictEqual(Object.prototype.hasOwnProperty.call(testObj, 15), false);
 
   testDeleteProperty(binding.object.deletePropertyWithNapiValue);
   testDeleteProperty(binding.object.deletePropertyWithNapiWrapperValue);

package/vendor/node-addon-api/test/object/finalizer.cc

@@ -7,23 +7,24 @@ static int dummy;
 Value AddFinalizer(const CallbackInfo& info) {
   ObjectReference* ref = new ObjectReference;
   *ref = Persistent(Object::New(info.Env()));
-  info[0]
-    .As<Object>()
-    .AddFinalizer([](Napi::Env /*env*/, ObjectReference* ref) {
-      ref->Set("finalizerCalled", true);
-      delete ref;
-    }, ref);
+  info[0].As<Object>().AddFinalizer(
+      [](Napi::Env /*env*/, ObjectReference* ref) {
+        ref->Set("finalizerCalled", true);
+        delete ref;
+      },
+      ref);
   return ref->Value();
 }
 
 Value AddFinalizerWithHint(const CallbackInfo& info) {
   ObjectReference* ref = new ObjectReference;
   *ref = Persistent(Object::New(info.Env()));
-  info[0]
-    .As<Object>()
-    .AddFinalizer([](Napi::Env /*env*/, ObjectReference* ref, int* dummy_p) {
-      ref->Set("finalizerCalledWithCorrectHint", dummy_p == &dummy);
-      delete ref;
-    }, ref, &dummy);
+  info[0].As<Object>().AddFinalizer(
+      [](Napi::Env /*env*/, ObjectReference* ref, int* dummy_p) {
+        ref->Set("finalizerCalledWithCorrectHint", dummy_p == &dummy);
+        delete ref;
+      },
+      ref,
+      &dummy);
   return ref->Value();
 }

package/vendor/node-addon-api/test/object/finalizer.js

@@ -5,11 +5,11 @@ const testUtil = require('../testUtil');
 
 module.exports = require('../common').runTest(test);
 
-function createWeakRef(binding, bindingToTest) {
+function createWeakRef (binding, bindingToTest) {
   return binding.object[bindingToTest]({});
 }
 
-function test(binding) {
+function test (binding) {
   let obj1;
   let obj2;
   return testUtil.runGCTests([

package/vendor/node-addon-api/test/object/get_property.js

@@ -4,26 +4,26 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
-  function testGetProperty(nativeGetProperty) {
+function test (binding) {
+  function testGetProperty (nativeGetProperty) {
     const obj = { test: 1 };
     assert.strictEqual(nativeGetProperty(obj, 'test'), 1);
   }
 
-  function testShouldReturnUndefinedIfKeyIsNotPresent(nativeGetProperty) {
+  function testShouldReturnUndefinedIfKeyIsNotPresent (nativeGetProperty) {
     const obj = { };
     assert.strictEqual(nativeGetProperty(obj, 'test'), undefined);
   }
 
-  function testShouldThrowErrorIfKeyIsInvalid(nativeGetProperty) {
+  function testShouldThrowErrorIfKeyIsInvalid (nativeGetProperty) {
     assert.throws(() => {
       nativeGetProperty(undefined, 'test');
     }, /Cannot convert undefined or null to object/);
   }
 
   const testObject = { 42: 100 };
-  const property =  binding.object.getPropertyWithUint32(testObject, 42);
-  assert.strictEqual(property,100)
+  const property = binding.object.getPropertyWithUint32(testObject, 42);
+  assert.strictEqual(property, 100);
 
   const nativeFunctions = [
     binding.object.getPropertyWithNapiValue,

package/vendor/node-addon-api/test/object/has_own_property.js

@@ -4,8 +4,8 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
-  function testHasOwnProperty(nativeHasOwnProperty) {
+function test (binding) {
+  function testHasOwnProperty (nativeHasOwnProperty) {
     const obj = { one: 1 };
 
     Object.defineProperty(obj, 'two', { value: 2 });
@@ -16,7 +16,7 @@ function test(binding) {
     assert.strictEqual(nativeHasOwnProperty(obj, 'toString'), false);
   }
 
-  function testShouldThrowErrorIfKeyIsInvalid(nativeHasOwnProperty) {
+  function testShouldThrowErrorIfKeyIsInvalid (nativeHasOwnProperty) {
     assert.throws(() => {
       nativeHasOwnProperty(undefined, 'test');
     }, /Cannot convert undefined or null to object/);