koffi 0.9.30 → 0.9.33

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

@@ -7,10 +7,10 @@ const noop = () => {};
 
 const mustCallChecks = [];
 
-function runCallChecks(exitCode) {
+function runCallChecks (exitCode) {
   if (exitCode !== 0) return;
 
-  const failed = mustCallChecks.filter(function(context) {
+  const failed = mustCallChecks.filter(function (context) {
     if ('minimum' in context) {
       context.messageSegment = `at least ${context.minimum}`;
       return context.actual < context.minimum;
@@ -20,25 +20,25 @@ function runCallChecks(exitCode) {
     }
   });
 
-  failed.forEach(function(context) {
+  failed.forEach(function (context) {
     console.log('Mismatched %s function calls. Expected %s, actual %d.',
-                context.name,
-                context.messageSegment,
-                context.actual);
+      context.name,
+      context.messageSegment,
+      context.actual);
     console.log(context.stack.split('\n').slice(2).join('\n'));
   });
 
   if (failed.length) process.exit(1);
 }
 
-exports.mustCall = function(fn, exact) {
+exports.mustCall = function (fn, exact) {
   return _mustCallInner(fn, exact, 'exact');
 };
-exports.mustCallAtLeast = function(fn, minimum) {
+exports.mustCallAtLeast = function (fn, minimum) {
   return _mustCallInner(fn, minimum, 'minimum');
 };
 
-function _mustCallInner(fn, criteria, field) {
+function _mustCallInner (fn, criteria, field) {
   if (typeof fn === 'number') {
     criteria = fn;
     fn = noop;
@@ -49,8 +49,7 @@ function _mustCallInner(fn, criteria, field) {
     criteria = 1;
   }
 
-  if (typeof criteria !== 'number')
-    throw new TypeError(`Invalid ${field} value: ${criteria}`);
+  if (typeof criteria !== 'number') { throw new TypeError(`Invalid ${field} value: ${criteria}`); }
 
   const context = {
     [field]: criteria,
@@ -64,50 +63,52 @@ function _mustCallInner(fn, criteria, field) {
 
   mustCallChecks.push(context);
 
-  return function() {
+  return function () {
     context.actual++;
     return fn.apply(this, arguments);
   };
 }
 
-exports.mustNotCall = function(msg) {
-  return function mustNotCall() {
+exports.mustNotCall = function (msg) {
+  return function mustNotCall () {
     assert.fail(msg || 'function should not have been called');
   };
 };
 
-exports.runTest = async function(test, buildType, buildPathRoot = process.env.REL_BUILD_PATH || '') {
+exports.runTest = async function (test, buildType, buildPathRoot = process.env.BUILD_PATH || '') {
   buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
 
   const bindings = [
     path.join(buildPathRoot, `../build/${buildType}/binding.node`),
     path.join(buildPathRoot, `../build/${buildType}/binding_noexcept.node`),
     path.join(buildPathRoot, `../build/${buildType}/binding_noexcept_maybe.node`),
+    path.join(buildPathRoot, `../build/${buildType}/binding_custom_namespace.node`)
   ].map(it => require.resolve(it));
 
   for (const item of bindings) {
     await Promise.resolve(test(require(item)))
       .finally(exports.mustCall());
   }
-}
+};
 
-exports.runTestWithBindingPath = async function(test, buildType, buildPathRoot = process.env.REL_BUILD_PATH || '') {
+exports.runTestWithBindingPath = async function (test, buildType, buildPathRoot = process.env.BUILD_PATH || '') {
   buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
 
   const bindings = [
     path.join(buildPathRoot, `../build/${buildType}/binding.node`),
     path.join(buildPathRoot, `../build/${buildType}/binding_noexcept.node`),
     path.join(buildPathRoot, `../build/${buildType}/binding_noexcept_maybe.node`),
+    path.join(buildPathRoot, `../build/${buildType}/binding_custom_namespace.node`)
   ].map(it => require.resolve(it));
 
   for (const item of bindings) {
     await test(item);
   }
-}
+};
 
-exports.runTestWithBuildType = async function(test, buildType) {
+exports.runTestWithBuildType = async function (test, buildType) {
   buildType = buildType || process.config.target_defaults.default_configuration || 'Release';
 
-   await Promise.resolve(test(buildType))
-     .finally(exports.mustCall());
-}
+  await Promise.resolve(test(buildType))
+    .finally(exports.mustCall());
+};

package/vendor/node-addon-api/test/common/test_helper.h

@@ -3,6 +3,12 @@
 
 namespace Napi {
 
+// Needs this here since the MaybeUnwrap() functions need to be in the
+// same namespace as their arguments for C++ argument-dependent lookup
+#ifdef NAPI_CPP_CUSTOM_NAMESPACE
+namespace NAPI_CPP_CUSTOM_NAMESPACE {
+#endif
+
 // Use this when a variable or parameter is unused in order to explicitly
 // silence a compiler warning about that.
 template <typename T>
@@ -58,4 +64,8 @@ inline bool MaybeUnwrapTo(MaybeOrValue<T> maybe, T* out) {
 #endif
 }
 
+#ifdef NAPI_CPP_CUSTOM_NAMESPACE
+}  // namespace NAPI_CPP_CUSTOM_NAMESPACE
+#endif
+
 }  // namespace Napi

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

@@ -70,6 +70,7 @@ test(`./build/${buildType}/binding.node`, true);
 test(`./build/${buildType}/binding_noexcept.node`, true);
 test(`./build/${buildType}/binding_swallowexcept.node`, false);
 test(`./build/${buildType}/binding_swallowexcept_noexcept.node`, false);
+test(`./build/${buildType}/binding_custom_namespace.node`, true);
 
 function test(bindingPath, process_should_abort) {
   const number_of_test_cases = 5;

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

@@ -69,6 +69,16 @@ Value CallWithVector(const CallbackInfo& info) {
    return MaybeUnwrap(func.Call(args));
 }
 
+Value CallWithVectorUsingCppWrapper(const CallbackInfo& info) {
+  Function func = info[0].As<Function>();
+  std::vector<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 CallWithCStyleArray(const CallbackInfo& info) {
   Function func = info[0].As<Function>();
   std::vector<napi_value> args;
@@ -108,6 +118,17 @@ Value CallWithReceiverAndVector(const CallbackInfo& info) {
    return MaybeUnwrap(func.Call(receiver, args));
 }
 
+Value CallWithReceiverAndVectorUsingCppWrapper(const CallbackInfo& info) {
+  Function func = info[0].As<Function>();
+  Value receiver = info[1];
+  std::vector<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 CallWithInvalidReceiver(const CallbackInfo& info) {
    Function func = info[0].As<Function>();
    return MaybeUnwrapOr(func.Call(Value(), std::initializer_list<napi_value>{}),
@@ -213,11 +234,15 @@ Object InitFunction(Env env) {
     Function::New(env, ValueCallbackWithData, nullptr, &testData);
   exports["callWithArgs"] = Function::New(env, CallWithArgs);
   exports["callWithVector"] = Function::New(env, CallWithVector);
+  exports["callWithVectorUsingCppWrapper"] =
+      Function::New(env, CallWithVectorUsingCppWrapper);
   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["callWithReceiverAndVectorUsingCppWrapper"] =
+      Function::New(env, CallWithReceiverAndVectorUsingCppWrapper);
   exports["callWithInvalidReceiver"] = Function::New(env, CallWithInvalidReceiver);
   exports["callConstructorWithArgs"] = Function::New(env, CallConstructorWithArgs);
   exports["callConstructorWithVector"] = Function::New(env, CallConstructorWithVector);
@@ -246,6 +271,8 @@ Object InitFunction(Env env) {
       Function::New<ValueCallbackWithData>(env, nullptr, &testData);
   exports["callWithArgs"] = Function::New<CallWithArgs>(env);
   exports["callWithVector"] = Function::New<CallWithVector>(env);
+  exports["callWithVectorUsingCppWrapper"] =
+      Function::New<CallWithVectorUsingCppWrapper>(env);
   exports["callWithCStyleArray"] = Function::New<CallWithCStyleArray>(env);
   exports["callWithReceiverAndCStyleArray"] =
       Function::New<CallWithReceiverAndCStyleArray>(env);
@@ -253,6 +280,8 @@ Object InitFunction(Env env) {
       Function::New<CallWithReceiverAndArgs>(env);
   exports["callWithReceiverAndVector"] =
       Function::New<CallWithReceiverAndVector>(env);
+  exports["callWithReceiverAndVectorUsingCppWrapper"] =
+      Function::New<CallWithReceiverAndVectorUsingCppWrapper>(env);
   exports["callWithInvalidReceiver"] =
       Function::New<CallWithInvalidReceiver>(env);
   exports["callConstructorWithArgs"] =

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

@@ -8,71 +8,81 @@ module.exports = require('./common').runTest(binding => {
   testLambda(binding.function.lambda);
 });
 
-function test(binding) {
+function test (binding) {
   assert.strictEqual(binding.emptyConstructor(true), true);
   assert.strictEqual(binding.emptyConstructor(false), false);
 
   let obj = {};
   assert.deepStrictEqual(binding.voidCallback(obj), undefined);
-  assert.deepStrictEqual(obj, { "foo": "bar" });
+  assert.deepStrictEqual(obj, { foo: 'bar' });
 
-  assert.deepStrictEqual(binding.valueCallback(), { "foo": "bar" });
+  assert.deepStrictEqual(binding.valueCallback(), { foo: 'bar' });
 
   let args = null;
   let ret = null;
   let receiver = null;
-  function testFunction() {
+  function testFunction () {
     receiver = this;
     args = [].slice.call(arguments);
     return ret;
   }
-  function testConstructor() {
+  function testConstructor () {
     args = [].slice.call(arguments);
   }
 
-  function makeCallbackTestFunction(receiver, expectedOne, expectedTwo, expectedThree) {
-    return function callback(one, two, three) {
+  function makeCallbackTestFunction (receiver, expectedOne, expectedTwo, expectedThree) {
+    return function callback (one, two, three) {
       assert.strictEqual(this, receiver);
       assert.strictEqual(one, expectedOne);
       assert.strictEqual(two, expectedTwo);
       assert.strictEqual(three, expectedThree);
-    }
+    };
   }
 
   ret = 4;
   assert.strictEqual(binding.callWithArgs(testFunction, 1, 2, 3), 4);
   assert.strictEqual(receiver, undefined);
-  assert.deepStrictEqual(args, [ 1, 2, 3 ]);
+  assert.deepStrictEqual(args, [1, 2, 3]);
 
   ret = 5;
   assert.strictEqual(binding.callWithVector(testFunction, 2, 3, 4), 5);
   assert.strictEqual(receiver, undefined);
-  assert.deepStrictEqual(args, [ 2, 3, 4 ]);
+  assert.deepStrictEqual(args, [2, 3, 4]);
+
+  ret = 5;
+  assert.strictEqual(binding.callWithVectorUsingCppWrapper(testFunction, 2, 3, 4), 5);
+  assert.strictEqual(receiver, undefined);
+  assert.deepStrictEqual(args, [2, 3, 4]);
 
   ret = 6;
   assert.strictEqual(binding.callWithReceiverAndArgs(testFunction, obj, 3, 4, 5), 6);
   assert.deepStrictEqual(receiver, obj);
-  assert.deepStrictEqual(args, [ 3, 4, 5 ]);
+  assert.deepStrictEqual(args, [3, 4, 5]);
 
   ret = 7;
   assert.strictEqual(binding.callWithReceiverAndVector(testFunction, obj, 4, 5, 6), 7);
   assert.deepStrictEqual(receiver, obj);
-  assert.deepStrictEqual(args, [ 4, 5, 6 ]);
+  assert.deepStrictEqual(args, [4, 5, 6]);
+
+  ret = 7;
+  assert.strictEqual(binding.callWithReceiverAndVectorUsingCppWrapper(testFunction, obj, 4, 5, 6), 7);
+  assert.deepStrictEqual(receiver, obj);
+  assert.deepStrictEqual(args, [4, 5, 6]);
 
   ret = 8;
   assert.strictEqual(binding.callWithCStyleArray(testFunction, 5, 6, 7), ret);
   assert.deepStrictEqual(receiver, undefined);
-  assert.deepStrictEqual(args, [ 5, 6, 7 ]);
+  assert.deepStrictEqual(args, [5, 6, 7]);
 
   ret = 9;
   assert.strictEqual(binding.callWithReceiverAndCStyleArray(testFunction, obj, 6, 7, 8), ret);
   assert.deepStrictEqual(receiver, obj);
-  assert.deepStrictEqual(args, [ 6, 7, 8 ]);
+  assert.deepStrictEqual(args, [6, 7, 8]);
 
   ret = 10;
   assert.strictEqual(binding.callWithFunctionOperator(testFunction, 7, 8, 9), ret);
   assert.strictEqual(receiver, undefined);
-  assert.deepStrictEqual(args, [ 7, 8, 9 ]);
+  assert.deepStrictEqual(args, [7, 8, 9]);
 
   assert.throws(() => {
     binding.callWithInvalidReceiver();
@@ -80,33 +90,35 @@ function test(binding) {
 
   obj = binding.callConstructorWithArgs(testConstructor, 5, 6, 7);
   assert(obj instanceof testConstructor);
-  assert.deepStrictEqual(args, [ 5, 6, 7 ]);
+  assert.deepStrictEqual(args, [5, 6, 7]);
 
   obj = binding.callConstructorWithVector(testConstructor, 6, 7, 8);
   assert(obj instanceof testConstructor);
-  assert.deepStrictEqual(args, [ 6, 7, 8 ]);
+  assert.deepStrictEqual(args, [6, 7, 8]);
 
   obj = binding.callConstructorWithCStyleArray(testConstructor, 7, 8, 9);
   assert(obj instanceof testConstructor);
-  assert.deepStrictEqual(args, [ 7, 8, 9 ]);
+  assert.deepStrictEqual(args, [7, 8, 9]);
 
   obj = {};
   assert.deepStrictEqual(binding.voidCallbackWithData(obj), undefined);
-  assert.deepStrictEqual(obj, { "foo": "bar", "data": 1 });
+  assert.deepStrictEqual(obj, { foo: 'bar', data: 1 });
 
-  assert.deepStrictEqual(binding.valueCallbackWithData(), { "foo": "bar", "data": 1 });
+  assert.deepStrictEqual(binding.valueCallbackWithData(), { foo: 'bar', data: 1 });
 
   assert.strictEqual(binding.voidCallback.name, 'voidCallback');
   assert.strictEqual(binding.valueCallback.name, 'valueCallback');
 
-  let testConstructCall = undefined;
+  let testConstructCall;
   binding.isConstructCall((result) => { testConstructCall = result; });
   assert.ok(!testConstructCall);
+  /* eslint-disable no-new, new-cap */
   new binding.isConstructCall((result) => { testConstructCall = result; });
+  /* eslint-enable no-new, new-cap */
   assert.ok(testConstructCall);
 
   obj = {};
-  binding.makeCallbackWithArgs(makeCallbackTestFunction(obj, "1", "2", "3"), obj, "1", "2", "3");
+  binding.makeCallbackWithArgs(makeCallbackTestFunction(obj, '1', '2', '3'), obj, '1', '2', '3');
   binding.makeCallbackWithVector(makeCallbackTestFunction(obj, 4, 5, 6), obj, 4, 5, 6);
   binding.makeCallbackWithCStyleArray(makeCallbackTestFunction(obj, 7, 8, 9), obj, 7, 8, 9);
   assert.throws(() => {
@@ -114,7 +126,7 @@ function test(binding) {
   });
 }
 
-function testLambda(binding) {
+function testLambda (binding) {
   assert.ok(binding.lambdaWithNoCapture());
   assert.ok(binding.lambdaWithCapture());
   assert.ok(binding.lambdaWithMoveOnlyCapture());

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

@@ -4,7 +4,7 @@ const majorNodeVersion = process.versions.node.split('.')[0];
 
 if (typeof global.gc !== 'function') {
   // Construct the correct (version-dependent) command-line args.
-  let args = ['--expose-gc'];
+  const args = ['--expose-gc'];
   const majorV8Version = process.versions.v8.split('.')[0];
   if (majorV8Version < 9) {
     args.push('--no-concurrent-array-buffer-freeing');
@@ -15,7 +15,7 @@ if (typeof global.gc !== 'function') {
   args.push(__filename);
 
   const child = require('./napi_child').spawnSync(process.argv[0], args, {
-    stdio: 'inherit',
+    stdio: 'inherit'
   });
 
   if (child.signal) {
@@ -27,17 +27,36 @@ if (typeof global.gc !== 'function') {
   process.exit(process.exitCode);
 }
 
+const testModules = [];
+
 const fs = require('fs');
 const path = require('path');
 
-let testModules = [];
+let filterCondition = process.env.npm_config_filter || '';
+let filterConditionFiles = [];
+
+if (filterCondition !== '') {
+  filterCondition = require('../unit-test/matchModules').matchWildCards(process.env.npm_config_filter);
+  filterConditionFiles = filterCondition.split(' ').length > 0 ? filterCondition.split(' ') : [filterCondition];
+}
+
+const filterConditionsProvided = filterConditionFiles.length > 0;
+
+function checkFilterCondition (fileName, parsedFilepath) {
+  let result = false;
+
+  if (!filterConditionsProvided) return true;
+  if (filterConditionFiles.includes(parsedFilepath)) result = true;
+  if (filterConditionFiles.includes(fileName)) result = true;
+  return result;
+}
 
 // TODO(RaisinTen): Update this when the test filenames
 // are changed into test_*.js.
-function loadTestModules(currentDirectory = __dirname, pre = '') {
+function loadTestModules (currentDirectory = __dirname, pre = '') {
   fs.readdirSync(currentDirectory).forEach((file) => {
     if (currentDirectory === __dirname && (
-          file === 'binding.cc' ||
+      file === 'binding.cc' ||
           file === 'binding.gyp' ||
           file === 'build' ||
           file === 'common' ||
@@ -50,15 +69,19 @@ function loadTestModules(currentDirectory = __dirname, pre = '') {
       return;
     }
     const absoluteFilepath = path.join(currentDirectory, file);
+    const parsedFilepath = path.parse(file);
+    const parsedPath = path.parse(currentDirectory);
+
     if (fs.statSync(absoluteFilepath).isDirectory()) {
       if (fs.existsSync(absoluteFilepath + '/index.js')) {
-        testModules.push(pre + file);
+        if (checkFilterCondition(parsedFilepath.name, parsedPath.base)) {
+          testModules.push(pre + file);
+        }
       } else {
         loadTestModules(absoluteFilepath, pre + file + '/');
       }
     } else {
-      const parsedFilepath = path.parse(file);
-      if (parsedFilepath.ext === '.js') {
+      if (parsedFilepath.ext === '.js' && checkFilterCondition(parsedFilepath.name, parsedPath.base)) {
         testModules.push(pre + parsedFilepath.name);
       }
     }
@@ -69,7 +92,7 @@ loadTestModules();
 
 process.config.target_defaults.default_configuration =
   fs
-    .readdirSync(path.join(__dirname, 'build'))
+    .readdirSync(path.join(__dirname, process.env.REL_BUILD_PATH || '', 'build'))
     .filter((item) => (item === 'Debug' || item === 'Release'))[0];
 
 let napiVersion = Number(process.versions.napi);
@@ -87,7 +110,7 @@ if (napiVersion < 3) {
   testModules.splice(testModules.indexOf('version_management'), 1);
 }
 
-if (napiVersion < 4) {
+if (napiVersion < 4 && !filterConditionsProvided) {
   testModules.splice(testModules.indexOf('asyncprogressqueueworker'), 1);
   testModules.splice(testModules.indexOf('asyncprogressworker'), 1);
   testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_ctx'), 1);
@@ -98,36 +121,36 @@ if (napiVersion < 4) {
   testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function'), 1);
 }
 
-if (napiVersion < 5) {
+if (napiVersion < 5 && !filterConditionsProvided) {
   testModules.splice(testModules.indexOf('date'), 1);
 }
 
-if (napiVersion < 6) {
+if (napiVersion < 6 && !filterConditionsProvided) {
   testModules.splice(testModules.indexOf('addon'), 1);
   testModules.splice(testModules.indexOf('addon_data'), 1);
   testModules.splice(testModules.indexOf('bigint'), 1);
   testModules.splice(testModules.indexOf('typedarray-bigint'), 1);
 }
 
-if (majorNodeVersion < 12) {
+if (majorNodeVersion < 12 && !filterConditionsProvided) {
   testModules.splice(testModules.indexOf('objectwrap_worker_thread'), 1);
   testModules.splice(testModules.indexOf('error_terminating_environment'), 1);
 }
 
-if (napiVersion < 8) {
+if (napiVersion < 8 && !filterConditionsProvided) {
   testModules.splice(testModules.indexOf('object/object_freeze_seal'), 1);
 }
 
-(async function() {
+(async function () {
   console.log(`Testing with Node-API Version '${napiVersion}'.`);
 
-  console.log('Starting test suite\n');
+  if (filterConditionsProvided) { console.log('Starting test suite\n', testModules); } else { console.log('Starting test suite\n'); }
 
   // Requiring each module runs tests in the module.
   for (const name of testModules) {
     console.log(`Running test '${name}'`);
     await require('./' + name);
-  };
+  }
 
   console.log('\nAll tests passed!');
 })().catch((error) => {

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

@@ -11,6 +11,7 @@ Value GetPropertyWithCStyleString(const CallbackInfo& info);
 Value GetPropertyWithCppStyleString(const CallbackInfo& info);
 
 // Native wrappers for testing Object::Set()
+Value SetPropertyWithUint32(const CallbackInfo& info);
 Value SetPropertyWithNapiValue(const CallbackInfo& info);
 Value SetPropertyWithNapiWrapperValue(const CallbackInfo& info);
 Value SetPropertyWithCStyleString(const CallbackInfo& info);
@@ -299,6 +300,7 @@ Object InitObject(Env env) {
   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);

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

@@ -19,6 +19,14 @@ Value SetPropertyWithNapiWrapperValue(const CallbackInfo& info) {
   return Boolean::New(info.Env(), MaybeUnwrapOr(obj.Set(key, value), false));
 }
 
+Value SetPropertyWithUint32(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  Number key = info[1].As<Number>();
+  Value value = info[2];
+  return Boolean::New(info.Env(),
+                      MaybeUnwrapOr(obj.Set(key.Uint32Value(), value), false));
+}
+
 Value SetPropertyWithCStyleString(const CallbackInfo& info) {
   Object obj = info[0].As<Object>();
   String jsKey = info[1].As<String>();

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

@@ -4,14 +4,14 @@ const assert = require('assert');
 
 module.exports = require('../common').runTest(test);
 
-function test(binding) {
-  function testSetProperty(nativeSetProperty) {
+function test (binding) {
+  function testSetProperty (nativeSetProperty, key = 'test') {
     const obj = {};
-    assert.strictEqual(nativeSetProperty(obj, 'test', 1), true);
-    assert.strictEqual(obj.test, 1);
+    assert.strictEqual(nativeSetProperty(obj, key, 1), true);
+    assert.strictEqual(obj[key], 1);
   }
 
-  function testShouldThrowErrorIfKeyIsInvalid(nativeSetProperty) {
+  function testShouldThrowErrorIfKeyIsInvalid (nativeSetProperty) {
     assert.throws(() => {
       nativeSetProperty(undefined, 'test', 1);
     }, /Cannot convert undefined or null to object/);
@@ -21,6 +21,7 @@ function test(binding) {
   testSetProperty(binding.object.setPropertyWithNapiWrapperValue);
   testSetProperty(binding.object.setPropertyWithCStyleString);
   testSetProperty(binding.object.setPropertyWithCppStyleString);
+  testSetProperty(binding.object.setPropertyWithUint32, 12);
 
   testShouldThrowErrorIfKeyIsInvalid(binding.object.setPropertyWithNapiValue);
   testShouldThrowErrorIfKeyIsInvalid(binding.object.setPropertyWithNapiWrapperValue);

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

@@ -1,22 +1,38 @@
 #include "napi.h"
+#include "test_helper.h"
 
 using namespace Napi;
 
 Value SubscriptGetWithCStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
   String jsKey = info[1].As<String>();
+
+  // make sure const case compiles
+  const Object obj2 = info[0].As<Object>();
+  MaybeUnwrap(obj2[jsKey.Utf8Value().c_str()]).As<Boolean>();
+
+  Object obj = info[0].As<Object>();
   return obj[jsKey.Utf8Value().c_str()];
 }
 
 Value SubscriptGetWithCppStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
   String jsKey = info[1].As<String>();
+
+  // make sure const case compiles
+  const Object obj2 = info[0].As<Object>();
+  MaybeUnwrap(obj2[jsKey.Utf8Value()]).As<Boolean>();
+
+  Object obj = info[0].As<Object>();
   return obj[jsKey.Utf8Value()];
 }
 
 Value SubscriptGetAtIndex(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
   uint32_t index = info[1].As<Napi::Number>();
+
+  // make sure const case compiles
+  const Object obj2 = info[0].As<Object>();
+  MaybeUnwrap(obj2[index]).As<Boolean>();
+
+  Object obj = info[0].As<Object>();
   return obj[index];
 }
 

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

@@ -0,0 +1,45 @@
+#include <napi.h>
+#include <unordered_map>
+#include "test_helper.h"
+
+class FunctionTest : public Napi::ObjectWrap<FunctionTest> {
+ public:
+  FunctionTest(const Napi::CallbackInfo& info)
+      : Napi::ObjectWrap<FunctionTest>(info) {}
+
+  static Napi::Value OnCalledAsFunction(const Napi::CallbackInfo& info) {
+    // If called with a "true" argument, throw an exeption to test the handling.
+    if (!info[0].IsUndefined() && MaybeUnwrap(info[0].ToBoolean())) {
+      NAPI_THROW(Napi::Error::New(info.Env(), "an exception"), Napi::Value());
+    }
+    // Otherwise, act as a factory.
+    std::vector<napi_value> args;
+    for (size_t i = 0; i < info.Length(); i++) args.push_back(info[i]);
+    return MaybeUnwrap(GetConstructor(info.Env()).New(args));
+  }
+
+  // Constructor-per-env map in a static member because env.SetInstanceData()
+  // would interfere with Napi::Addon<T>
+  static std::unordered_map<napi_env, Napi::FunctionReference> constructors;
+
+  static void Initialize(Napi::Env env, Napi::Object exports) {
+    const char* name = "FunctionTest";
+    Napi::Function func = DefineClass(env, name, {});
+    constructors[env] = Napi::Persistent(func);
+    env.AddCleanupHook([env] { constructors.erase(env); });
+    exports.Set(name, func);
+  }
+
+  static Napi::Function GetConstructor(Napi::Env env) {
+    return constructors[env].Value();
+  }
+};
+
+std::unordered_map<napi_env, Napi::FunctionReference>
+    FunctionTest::constructors;
+
+Napi::Object InitObjectWrapFunction(Napi::Env env) {
+  Napi::Object exports = Napi::Object::New(env);
+  FunctionTest::Initialize(env, exports);
+  return exports;
+}