koffi 2.3.4 → 2.3.6-beta.1

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

@@ -4,8 +4,8 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
-  function testHasProperty(nativeHasProperty) {
+function test (binding) {
+  function testHasProperty (nativeHasProperty) {
     const obj = { one: 1 };
 
     Object.defineProperty(obj, 'two', { value: 2 });
@@ -16,14 +16,14 @@ function test(binding) {
     assert.strictEqual(nativeHasProperty(obj, 'toString'), true);
   }
 
-  function testShouldThrowErrorIfKeyIsInvalid(nativeHasProperty) {
+  function testShouldThrowErrorIfKeyIsInvalid (nativeHasProperty) {
     assert.throws(() => {
       nativeHasProperty(undefined, 'test');
     }, /Cannot convert undefined or null to object/);
   }
 
   const objectWithInt32Key = { 12: 101 };
-  assert.strictEqual(binding.object.hasPropertyWithUint32(objectWithInt32Key,12),true);
+  assert.strictEqual(binding.object.hasPropertyWithUint32(objectWithInt32Key, 12), true);
 
   testHasProperty(binding.object.hasPropertyWithNapiValue);
   testHasProperty(binding.object.hasPropertyWithNapiWrapperValue);

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

@@ -56,11 +56,11 @@ struct UserDataHolder {
 };
 
 Value TestGetter(const CallbackInfo& info) {
-   return Boolean::New(info.Env(), testValue);
+  return Boolean::New(info.Env(), testValue);
 }
 
 void TestSetter(const CallbackInfo& info) {
-   testValue = info[0].As<Boolean>();
+  testValue = info[0].As<Boolean>();
 }
 
 Value TestGetterWithUserData(const CallbackInfo& info) {
@@ -74,7 +74,7 @@ void TestSetterWithUserData(const CallbackInfo& info) {
 }
 
 Value TestFunction(const CallbackInfo& info) {
-   return Boolean::New(info.Env(), true);
+  return Boolean::New(info.Env(), true);
 }
 
 Value TestFunctionWithUserData(const CallbackInfo& info) {
@@ -112,36 +112,56 @@ void DefineProperties(const CallbackInfo& info) {
 
   if (nameType.Utf8Value() == "literal") {
     obj.DefineProperties({
-      PropertyDescriptor::Accessor(env, obj, "readonlyAccessor", TestGetter),
-      PropertyDescriptor::Accessor(env, obj, "readwriteAccessor", TestGetter, TestSetter),
-      PropertyDescriptor::Accessor(env, obj, "readonlyAccessorWithUserData", TestGetterWithUserData, napi_property_attributes::napi_default, reinterpret_cast<void*>(holder)),
-      PropertyDescriptor::Accessor(env, obj, "readwriteAccessorWithUserData", TestGetterWithUserData, TestSetterWithUserData, napi_property_attributes::napi_default, reinterpret_cast<void*>(holder)),
-
-      PropertyDescriptor::Accessor<TestGetter>("readonlyAccessorT"),
-      PropertyDescriptor::Accessor<TestGetter, TestSetter>(
-          "readwriteAccessorT"),
-      PropertyDescriptor::Accessor<TestGetterWithUserData>(
-          "readonlyAccessorWithUserDataT",
-          napi_property_attributes::napi_default,
-          reinterpret_cast<void*>(holder)),
-      PropertyDescriptor::Accessor<
-          TestGetterWithUserData,
-          TestSetterWithUserData>("readwriteAccessorWithUserDataT",
-                                  napi_property_attributes::napi_default,
-                                  reinterpret_cast<void*>(holder)),
-
-      PropertyDescriptor::Value("readonlyValue", trueValue),
-      PropertyDescriptor::Value("readwriteValue", trueValue, napi_writable),
-      PropertyDescriptor::Value("enumerableValue", trueValue, napi_enumerable),
-      PropertyDescriptor::Value("configurableValue", trueValue, napi_configurable),
-      PropertyDescriptor::Function(env, obj, "function", TestFunction),
-      PropertyDescriptor::Function(env, obj, "functionWithUserData", TestFunctionWithUserData, napi_property_attributes::napi_default, reinterpret_cast<void*>(holder)),
+        PropertyDescriptor::Accessor(env, obj, "readonlyAccessor", TestGetter),
+        PropertyDescriptor::Accessor(
+            env, obj, "readwriteAccessor", TestGetter, TestSetter),
+        PropertyDescriptor::Accessor(env,
+                                     obj,
+                                     "readonlyAccessorWithUserData",
+                                     TestGetterWithUserData,
+                                     napi_property_attributes::napi_default,
+                                     reinterpret_cast<void*>(holder)),
+        PropertyDescriptor::Accessor(env,
+                                     obj,
+                                     "readwriteAccessorWithUserData",
+                                     TestGetterWithUserData,
+                                     TestSetterWithUserData,
+                                     napi_property_attributes::napi_default,
+                                     reinterpret_cast<void*>(holder)),
+
+        PropertyDescriptor::Accessor<TestGetter>("readonlyAccessorT"),
+        PropertyDescriptor::Accessor<TestGetter, TestSetter>(
+            "readwriteAccessorT"),
+        PropertyDescriptor::Accessor<TestGetterWithUserData>(
+            "readonlyAccessorWithUserDataT",
+            napi_property_attributes::napi_default,
+            reinterpret_cast<void*>(holder)),
+        PropertyDescriptor::Accessor<TestGetterWithUserData,
+                                     TestSetterWithUserData>(
+            "readwriteAccessorWithUserDataT",
+            napi_property_attributes::napi_default,
+            reinterpret_cast<void*>(holder)),
+
+        PropertyDescriptor::Value("readonlyValue", trueValue),
+        PropertyDescriptor::Value("readwriteValue", trueValue, napi_writable),
+        PropertyDescriptor::Value(
+            "enumerableValue", trueValue, napi_enumerable),
+        PropertyDescriptor::Value(
+            "configurableValue", trueValue, napi_configurable),
+        PropertyDescriptor::Function(env, obj, "function", TestFunction),
+        PropertyDescriptor::Function(env,
+                                     obj,
+                                     "functionWithUserData",
+                                     TestFunctionWithUserData,
+                                     napi_property_attributes::napi_default,
+                                     reinterpret_cast<void*>(holder)),
     });
   } else if (nameType.Utf8Value() == "string") {
-    // VS2013 has lifetime issues when passing temporary objects into the constructor of another
-    // object. It generates code to destruct the object as soon as the constructor call returns.
-    // Since this isn't a common case for using std::string objects, I'm refactoring the test to
-    // work around the issue.
+    // VS2013 has lifetime issues when passing temporary objects into the
+    // constructor of another object. It generates code to destruct the object
+    // as soon as the constructor call returns. Since this isn't a common case
+    // for using std::string objects, I'm refactoring the test to work around
+    // the issue.
     std::string str1("readonlyAccessor");
     std::string str2("readwriteAccessor");
     std::string str1a("readonlyAccessorWithUserData");
@@ -160,66 +180,105 @@ void DefineProperties(const CallbackInfo& info) {
     std::string str8("functionWithUserData");
 
     obj.DefineProperties({
-      PropertyDescriptor::Accessor(env, obj, str1, TestGetter),
-      PropertyDescriptor::Accessor(env, obj, str2, TestGetter, TestSetter),
-      PropertyDescriptor::Accessor(env, obj, str1a, TestGetterWithUserData, napi_property_attributes::napi_default, reinterpret_cast<void*>(holder)),
-      PropertyDescriptor::Accessor(env, obj, str2a, TestGetterWithUserData, TestSetterWithUserData, napi_property_attributes::napi_default, reinterpret_cast<void*>(holder)),
-
-      PropertyDescriptor::Accessor<TestGetter>(str1t),
-      PropertyDescriptor::Accessor<TestGetter, TestSetter>(str2t),
-      PropertyDescriptor::Accessor<TestGetterWithUserData>(str1at,
-                                         napi_property_attributes::napi_default,
-                                         reinterpret_cast<void*>(holder)),
-      PropertyDescriptor::Accessor<
-          TestGetterWithUserData,
-          TestSetterWithUserData>(str2at,
-                                  napi_property_attributes::napi_default,
-                                  reinterpret_cast<void*>(holder)),
-
-      PropertyDescriptor::Value(str3, trueValue),
-      PropertyDescriptor::Value(str4, trueValue, napi_writable),
-      PropertyDescriptor::Value(str5, trueValue, napi_enumerable),
-      PropertyDescriptor::Value(str6, trueValue, napi_configurable),
-      PropertyDescriptor::Function(env, obj, str7, TestFunction),
-      PropertyDescriptor::Function(env, obj, str8, TestFunctionWithUserData, napi_property_attributes::napi_default, reinterpret_cast<void*>(holder)),
+        PropertyDescriptor::Accessor(env, obj, str1, TestGetter),
+        PropertyDescriptor::Accessor(env, obj, str2, TestGetter, TestSetter),
+        PropertyDescriptor::Accessor(env,
+                                     obj,
+                                     str1a,
+                                     TestGetterWithUserData,
+                                     napi_property_attributes::napi_default,
+                                     reinterpret_cast<void*>(holder)),
+        PropertyDescriptor::Accessor(env,
+                                     obj,
+                                     str2a,
+                                     TestGetterWithUserData,
+                                     TestSetterWithUserData,
+                                     napi_property_attributes::napi_default,
+                                     reinterpret_cast<void*>(holder)),
+
+        PropertyDescriptor::Accessor<TestGetter>(str1t),
+        PropertyDescriptor::Accessor<TestGetter, TestSetter>(str2t),
+        PropertyDescriptor::Accessor<TestGetterWithUserData>(
+            str1at,
+            napi_property_attributes::napi_default,
+            reinterpret_cast<void*>(holder)),
+        PropertyDescriptor::Accessor<TestGetterWithUserData,
+                                     TestSetterWithUserData>(
+            str2at,
+            napi_property_attributes::napi_default,
+            reinterpret_cast<void*>(holder)),
+
+        PropertyDescriptor::Value(str3, trueValue),
+        PropertyDescriptor::Value(str4, trueValue, napi_writable),
+        PropertyDescriptor::Value(str5, trueValue, napi_enumerable),
+        PropertyDescriptor::Value(str6, trueValue, napi_configurable),
+        PropertyDescriptor::Function(env, obj, str7, TestFunction),
+        PropertyDescriptor::Function(env,
+                                     obj,
+                                     str8,
+                                     TestFunctionWithUserData,
+                                     napi_property_attributes::napi_default,
+                                     reinterpret_cast<void*>(holder)),
     });
   } else if (nameType.Utf8Value() == "value") {
     obj.DefineProperties({
-      PropertyDescriptor::Accessor(env, obj,
-        Napi::String::New(env, "readonlyAccessor"), TestGetter),
-      PropertyDescriptor::Accessor(env, obj,
-        Napi::String::New(env, "readwriteAccessor"), TestGetter, TestSetter),
-      PropertyDescriptor::Accessor(env, obj,
-        Napi::String::New(env, "readonlyAccessorWithUserData"), TestGetterWithUserData, napi_property_attributes::napi_default, reinterpret_cast<void*>(holder)),
-      PropertyDescriptor::Accessor(env, obj,
-        Napi::String::New(env, "readwriteAccessorWithUserData"), TestGetterWithUserData, TestSetterWithUserData, napi_property_attributes::napi_default, reinterpret_cast<void*>(holder)),
-
-      PropertyDescriptor::Accessor<TestGetter>(
-                                   Napi::String::New(env, "readonlyAccessorT")),
-      PropertyDescriptor::Accessor<TestGetter, TestSetter>(
-                                  Napi::String::New(env, "readwriteAccessorT")),
-      PropertyDescriptor::Accessor<TestGetterWithUserData>(
-                        Napi::String::New(env, "readonlyAccessorWithUserDataT"),
-                        napi_property_attributes::napi_default,
-                        reinterpret_cast<void*>(holder)),
-      PropertyDescriptor::Accessor<
-          TestGetterWithUserData, TestSetterWithUserData>(
-                       Napi::String::New(env, "readwriteAccessorWithUserDataT"),
-                       napi_property_attributes::napi_default,
-                       reinterpret_cast<void*>(holder)),
-
-      PropertyDescriptor::Value(
-        Napi::String::New(env, "readonlyValue"), trueValue),
-      PropertyDescriptor::Value(
-        Napi::String::New(env, "readwriteValue"), trueValue, napi_writable),
-      PropertyDescriptor::Value(
-        Napi::String::New(env, "enumerableValue"), trueValue, napi_enumerable),
-      PropertyDescriptor::Value(
-        Napi::String::New(env, "configurableValue"), trueValue, napi_configurable),
-      PropertyDescriptor::Function(env, obj,
-        Napi::String::New(env, "function"), TestFunction),
-      PropertyDescriptor::Function(env, obj,
-        Napi::String::New(env, "functionWithUserData"), TestFunctionWithUserData, napi_property_attributes::napi_default, reinterpret_cast<void*>(holder)),
+        PropertyDescriptor::Accessor(
+            env, obj, Napi::String::New(env, "readonlyAccessor"), TestGetter),
+        PropertyDescriptor::Accessor(
+            env,
+            obj,
+            Napi::String::New(env, "readwriteAccessor"),
+            TestGetter,
+            TestSetter),
+        PropertyDescriptor::Accessor(
+            env,
+            obj,
+            Napi::String::New(env, "readonlyAccessorWithUserData"),
+            TestGetterWithUserData,
+            napi_property_attributes::napi_default,
+            reinterpret_cast<void*>(holder)),
+        PropertyDescriptor::Accessor(
+            env,
+            obj,
+            Napi::String::New(env, "readwriteAccessorWithUserData"),
+            TestGetterWithUserData,
+            TestSetterWithUserData,
+            napi_property_attributes::napi_default,
+            reinterpret_cast<void*>(holder)),
+
+        PropertyDescriptor::Accessor<TestGetter>(
+            Napi::String::New(env, "readonlyAccessorT")),
+        PropertyDescriptor::Accessor<TestGetter, TestSetter>(
+            Napi::String::New(env, "readwriteAccessorT")),
+        PropertyDescriptor::Accessor<TestGetterWithUserData>(
+            Napi::String::New(env, "readonlyAccessorWithUserDataT"),
+            napi_property_attributes::napi_default,
+            reinterpret_cast<void*>(holder)),
+        PropertyDescriptor::Accessor<TestGetterWithUserData,
+                                     TestSetterWithUserData>(
+            Napi::String::New(env, "readwriteAccessorWithUserDataT"),
+            napi_property_attributes::napi_default,
+            reinterpret_cast<void*>(holder)),
+
+        PropertyDescriptor::Value(Napi::String::New(env, "readonlyValue"),
+                                  trueValue),
+        PropertyDescriptor::Value(
+            Napi::String::New(env, "readwriteValue"), trueValue, napi_writable),
+        PropertyDescriptor::Value(Napi::String::New(env, "enumerableValue"),
+                                  trueValue,
+                                  napi_enumerable),
+        PropertyDescriptor::Value(Napi::String::New(env, "configurableValue"),
+                                  trueValue,
+                                  napi_configurable),
+        PropertyDescriptor::Function(
+            env, obj, Napi::String::New(env, "function"), TestFunction),
+        PropertyDescriptor::Function(
+            env,
+            obj,
+            Napi::String::New(env, "functionWithUserData"),
+            TestFunctionWithUserData,
+            napi_property_attributes::napi_default,
+            reinterpret_cast<void*>(holder)),
     });
   }
 }
@@ -295,36 +354,57 @@ Object InitObject(Env env) {
   exports["defineValueProperty"] = Function::New(env, DefineValueProperty);
 
   exports["getPropertyWithUint32"] = Function::New(env, GetPropertyWithUint32);
-  exports["getPropertyWithNapiValue"] = Function::New(env, GetPropertyWithNapiValue);
-  exports["getPropertyWithNapiWrapperValue"] = Function::New(env, GetPropertyWithNapiWrapperValue);
-  exports["getPropertyWithCStyleString"] = Function::New(env, GetPropertyWithCStyleString);
-  exports["getPropertyWithCppStyleString"] = Function::New(env, GetPropertyWithCppStyleString);
+  exports["getPropertyWithNapiValue"] =
+      Function::New(env, GetPropertyWithNapiValue);
+  exports["getPropertyWithNapiWrapperValue"] =
+      Function::New(env, GetPropertyWithNapiWrapperValue);
+  exports["getPropertyWithCStyleString"] =
+      Function::New(env, GetPropertyWithCStyleString);
+  exports["getPropertyWithCppStyleString"] =
+      Function::New(env, GetPropertyWithCppStyleString);
 
   exports["setPropertyWithUint32"] = Function::New(env, SetPropertyWithUint32);
-  exports["setPropertyWithNapiValue"] = Function::New(env, SetPropertyWithNapiValue);
-  exports["setPropertyWithNapiWrapperValue"] = Function::New(env, SetPropertyWithNapiWrapperValue);
-  exports["setPropertyWithCStyleString"] = Function::New(env, SetPropertyWithCStyleString);
-  exports["setPropertyWithCppStyleString"] = Function::New(env, SetPropertyWithCppStyleString);
+  exports["setPropertyWithNapiValue"] =
+      Function::New(env, SetPropertyWithNapiValue);
+  exports["setPropertyWithNapiWrapperValue"] =
+      Function::New(env, SetPropertyWithNapiWrapperValue);
+  exports["setPropertyWithCStyleString"] =
+      Function::New(env, SetPropertyWithCStyleString);
+  exports["setPropertyWithCppStyleString"] =
+      Function::New(env, SetPropertyWithCppStyleString);
 
   exports["deletePropertyWithUint32"] =
       Function::New(env, DeletePropertyWithUint32);
-  exports["deletePropertyWithNapiValue"] = Function::New(env, DeletePropertyWithNapiValue);
-  exports["deletePropertyWithNapiWrapperValue"] = Function::New(env, DeletePropertyWithNapiWrapperValue);
-  exports["deletePropertyWithCStyleString"] = Function::New(env, DeletePropertyWithCStyleString);
-  exports["deletePropertyWithCppStyleString"] = Function::New(env, DeletePropertyWithCppStyleString);
-
-  exports["hasOwnPropertyWithNapiValue"] = Function::New(env, HasOwnPropertyWithNapiValue);
-  exports["hasOwnPropertyWithNapiWrapperValue"] = Function::New(env, HasOwnPropertyWithNapiWrapperValue);
-  exports["hasOwnPropertyWithCStyleString"] = Function::New(env, HasOwnPropertyWithCStyleString);
-  exports["hasOwnPropertyWithCppStyleString"] = Function::New(env, HasOwnPropertyWithCppStyleString);
+  exports["deletePropertyWithNapiValue"] =
+      Function::New(env, DeletePropertyWithNapiValue);
+  exports["deletePropertyWithNapiWrapperValue"] =
+      Function::New(env, DeletePropertyWithNapiWrapperValue);
+  exports["deletePropertyWithCStyleString"] =
+      Function::New(env, DeletePropertyWithCStyleString);
+  exports["deletePropertyWithCppStyleString"] =
+      Function::New(env, DeletePropertyWithCppStyleString);
+
+  exports["hasOwnPropertyWithNapiValue"] =
+      Function::New(env, HasOwnPropertyWithNapiValue);
+  exports["hasOwnPropertyWithNapiWrapperValue"] =
+      Function::New(env, HasOwnPropertyWithNapiWrapperValue);
+  exports["hasOwnPropertyWithCStyleString"] =
+      Function::New(env, HasOwnPropertyWithCStyleString);
+  exports["hasOwnPropertyWithCppStyleString"] =
+      Function::New(env, HasOwnPropertyWithCppStyleString);
 
   exports["hasPropertyWithUint32"] = Function::New(env, HasPropertyWithUint32);
-  exports["hasPropertyWithNapiValue"] = Function::New(env, HasPropertyWithNapiValue);
-  exports["hasPropertyWithNapiWrapperValue"] = Function::New(env, HasPropertyWithNapiWrapperValue);
-  exports["hasPropertyWithCStyleString"] = Function::New(env, HasPropertyWithCStyleString);
-  exports["hasPropertyWithCppStyleString"] = Function::New(env, HasPropertyWithCppStyleString);
-
-  exports["createObjectUsingMagic"] = Function::New(env, CreateObjectUsingMagic);
+  exports["hasPropertyWithNapiValue"] =
+      Function::New(env, HasPropertyWithNapiValue);
+  exports["hasPropertyWithNapiWrapperValue"] =
+      Function::New(env, HasPropertyWithNapiWrapperValue);
+  exports["hasPropertyWithCStyleString"] =
+      Function::New(env, HasPropertyWithCStyleString);
+  exports["hasPropertyWithCppStyleString"] =
+      Function::New(env, HasPropertyWithCppStyleString);
+
+  exports["createObjectUsingMagic"] =
+      Function::New(env, CreateObjectUsingMagic);
 #ifdef NAPI_CPP_EXCEPTIONS
   exports["sum"] = Function::New(env, Sum);
   exports["increment"] = Function::New(env, Increment);

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

@@ -4,20 +4,20 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
-  function assertPropertyIs(obj, key, attribute) {
+function test (binding) {
+  function assertPropertyIs (obj, key, attribute) {
     const propDesc = Object.getOwnPropertyDescriptor(obj, key);
     assert.ok(propDesc);
     assert.ok(propDesc[attribute]);
   }
 
-  function assertPropertyIsNot(obj, key, attribute) {
+  function assertPropertyIsNot (obj, key, attribute) {
     const propDesc = Object.getOwnPropertyDescriptor(obj, key);
     assert.ok(propDesc);
     assert.ok(!propDesc[attribute]);
   }
 
-  function testDefineProperties(nameType) {
+  function testDefineProperties (nameType) {
     const obj = {};
     binding.object.defineProperties(obj, nameType);
 
@@ -101,28 +101,29 @@ function test(binding) {
   testDefineProperties('string');
   testDefineProperties('value');
 
+  // eslint-disable-next-line no-lone-blocks
   {
     assert.strictEqual(binding.object.emptyConstructor(true), true);
     assert.strictEqual(binding.object.emptyConstructor(false), false);
   }
 
   {
-    const expected = { 'one': 1, 'two': 2, 'three': 3 };
+    const expected = { one: 1, two: 2, three: 3 };
     const actual = binding.object.constructorFromObject(expected);
     assert.deepStrictEqual(actual, expected);
   }
 
   {
     const obj = {};
-    const testSym = Symbol();
+    const testSym = Symbol('testSym');
     binding.object.defineValueProperty(obj, testSym, 1);
     assert.strictEqual(obj[testSym], 1);
   }
 
   {
-    const testSym = Symbol();
-    const obj = { 'one': 1, 'two': 2, 'three': 3, [testSym]: 4 };
-    var arr = binding.object.GetPropertyNames(obj);
+    const testSym = Symbol('testSym');
+    const obj = { one: 1, two: 2, three: 3, [testSym]: 4 };
+    const arr = binding.object.GetPropertyNames(obj);
     assert.deepStrictEqual(arr, ['one', 'two', 'three']);
   }
 
@@ -149,7 +150,7 @@ function test(binding) {
   }
 
   {
-    function Ctor() {};
+    function Ctor () {}
 
     assert.strictEqual(binding.object.instanceOf(new Ctor(), Ctor), true);
     assert.strictEqual(binding.object.instanceOf(new Ctor(), Object), true);
@@ -158,60 +159,60 @@ function test(binding) {
   }
 
   if ('sum' in binding.object) {
-      {
-        const obj = {
-          '-forbid': -0x4B1D,
-          '-feedcode': -0xFEEDC0DE,
-          '+office': +0x0FF1CE,
-          '+forbid': +0x4B1D,
-          '+deadbeef': +0xDEADBEEF,
-          '+feedcode': +0xFEEDC0DE,
-        };
-
-        let sum = 0;
-        for (const key in obj) {
-          sum += obj[key];
-        }
-
-        assert.strictEqual(binding.object.sum(obj), sum);
+    {
+      const obj = {
+        '-forbid': -0x4B1D,
+        '-feedcode': -0xFEEDC0DE,
+        '+office': +0x0FF1CE,
+        '+forbid': +0x4B1D,
+        '+deadbeef': +0xDEADBEEF,
+        '+feedcode': +0xFEEDC0DE
+      };
+
+      let sum = 0;
+      for (const key in obj) {
+        sum += obj[key];
       }
 
-      {
-        const obj = new Proxy({
-          '-forbid': -0x4B1D,
-          '-feedcode': -0xFEEDC0DE,
-          '+office': +0x0FF1CE,
-          '+forbid': +0x4B1D,
-          '+deadbeef': +0xDEADBEEF,
-          '+feedcode': +0xFEEDC0DE,
-        }, {
-          getOwnPropertyDescriptor(target, p) {
-            throw new Error("getOwnPropertyDescriptor error");
-          },
-          ownKeys(target) {
-            throw new Error("ownKeys error");
-          },
-        });
-
-        assert.throws(() => {
-          binding.object.sum(obj);
-        }, /ownKeys error/);
+      assert.strictEqual(binding.object.sum(obj), sum);
+    }
+
+    {
+      const obj = new Proxy({
+        '-forbid': -0x4B1D,
+        '-feedcode': -0xFEEDC0DE,
+        '+office': +0x0FF1CE,
+        '+forbid': +0x4B1D,
+        '+deadbeef': +0xDEADBEEF,
+        '+feedcode': +0xFEEDC0DE
+      }, {
+        getOwnPropertyDescriptor (target, p) {
+          throw new Error('getOwnPropertyDescriptor error');
+        },
+        ownKeys (target) {
+          throw new Error('ownKeys error');
+        }
+      });
+
+      assert.throws(() => {
+        binding.object.sum(obj);
+      }, /ownKeys error/);
     }
   }
 
   if ('increment' in binding.object) {
     const obj = {
-      'a': 0,
-      'b': 1,
-      'c': 2,
+      a: 0,
+      b: 1,
+      c: 2
     };
 
     binding.object.increment(obj);
 
     assert.deepStrictEqual(obj, {
-      'a': 1,
-      'b': 2,
-      'c': 3,
+      a: 1,
+      b: 2,
+      c: 3
     });
   }
 }

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

@@ -7,15 +7,15 @@ static bool testValue = true;
 namespace {
 
 Value TestGetter(const CallbackInfo& info) {
-   return Boolean::New(info.Env(), testValue);
+  return Boolean::New(info.Env(), testValue);
 }
 
 void TestSetter(const CallbackInfo& info) {
-   testValue = info[0].As<Boolean>();
+  testValue = info[0].As<Boolean>();
 }
 
 Value TestFunction(const CallbackInfo& info) {
-   return Boolean::New(info.Env(), true);
+  return Boolean::New(info.Env(), true);
 }
 
 void DefineProperties(const CallbackInfo& info) {
@@ -25,37 +25,41 @@ void DefineProperties(const CallbackInfo& info) {
 
   if (nameType.Utf8Value() == "literal") {
     obj.DefineProperties({
-      PropertyDescriptor::Accessor("readonlyAccessor", TestGetter),
-      PropertyDescriptor::Accessor("readwriteAccessor", TestGetter, TestSetter),
-      PropertyDescriptor::Function("function", TestFunction),
+        PropertyDescriptor::Accessor("readonlyAccessor", TestGetter),
+        PropertyDescriptor::Accessor(
+            "readwriteAccessor", TestGetter, TestSetter),
+        PropertyDescriptor::Function("function", TestFunction),
     });
   } else if (nameType.Utf8Value() == "string") {
-    // VS2013 has lifetime issues when passing temporary objects into the constructor of another
-    // object. It generates code to destruct the object as soon as the constructor call returns.
-    // Since this isn't a common case for using std::string objects, I'm refactoring the test to
-    // work around the issue.
+    // VS2013 has lifetime issues when passing temporary objects into the
+    // constructor of another object. It generates code to destruct the object
+    // as soon as the constructor call returns. Since this isn't a common case
+    // for using std::string objects, I'm refactoring the test to work around
+    // the issue.
     std::string str1("readonlyAccessor");
     std::string str2("readwriteAccessor");
     std::string str7("function");
 
     obj.DefineProperties({
-      PropertyDescriptor::Accessor(str1, TestGetter),
-      PropertyDescriptor::Accessor(str2, TestGetter, TestSetter),
-      PropertyDescriptor::Function(str7, TestFunction),
+        PropertyDescriptor::Accessor(str1, TestGetter),
+        PropertyDescriptor::Accessor(str2, TestGetter, TestSetter),
+        PropertyDescriptor::Function(str7, TestFunction),
     });
   } else if (nameType.Utf8Value() == "value") {
     obj.DefineProperties({
-      PropertyDescriptor::Accessor(
-        Napi::String::New(env, "readonlyAccessor"), TestGetter),
-      PropertyDescriptor::Accessor(
-        Napi::String::New(env, "readwriteAccessor"), TestGetter, TestSetter),
-      PropertyDescriptor::Function(
-        Napi::String::New(env, "function"), TestFunction),
+        PropertyDescriptor::Accessor(Napi::String::New(env, "readonlyAccessor"),
+                                     TestGetter),
+        PropertyDescriptor::Accessor(
+            Napi::String::New(env, "readwriteAccessor"),
+            TestGetter,
+            TestSetter),
+        PropertyDescriptor::Function(Napi::String::New(env, "function"),
+                                     TestFunction),
     });
   }
 }
 
-} // end of anonymous namespace
+}  // end of anonymous namespace
 
 Object InitObjectDeprecated(Env env) {
   Object exports = Object::New(env);