koffi 0.9.0 → 0.9.3

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

@@ -0,0 +1,136 @@
+'use strict';
+
+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 majorV8Version = process.versions.v8.split('.')[0];
+  if (majorV8Version < 9) {
+    args.push('--no-concurrent-array-buffer-freeing');
+  }
+  if (majorNodeVersion >= 14) {
+    args.push('--no-concurrent-array-buffer-sweeping');
+  }
+  args.push(__filename);
+
+  const child = require('./napi_child').spawnSync(process.argv[0], args, {
+    stdio: 'inherit',
+  });
+
+  if (child.signal) {
+    console.error(`Tests aborted with ${child.signal}`);
+    process.exitCode = 1;
+  } else {
+    process.exitCode = child.status;
+  }
+  process.exit(process.exitCode);
+}
+
+const fs = require('fs');
+const path = require('path');
+
+let testModules = [];
+
+// TODO(RaisinTen): Update this when the test filenames
+// are changed into test_*.js.
+function loadTestModules(currentDirectory = __dirname, pre = '') {
+  fs.readdirSync(currentDirectory).forEach((file) => {
+    if (currentDirectory === __dirname && (
+          file === 'binding.cc' ||
+          file === 'binding.gyp' ||
+          file === 'build' ||
+          file === 'common' ||
+          file === 'napi_child.js' ||
+          file === 'testUtil.js' ||
+          file === 'thunking_manual.cc' ||
+          file === 'thunking_manual.js' ||
+          file === 'index.js' ||
+          file[0] === '.')) {
+      return;
+    }
+    const absoluteFilepath = path.join(currentDirectory, file);
+    if (fs.statSync(absoluteFilepath).isDirectory()) {
+      if (fs.existsSync(absoluteFilepath + '/index.js')) {
+        testModules.push(pre + file);
+      } else {
+        loadTestModules(absoluteFilepath, pre + file + '/');
+      }
+    } else {
+      const parsedFilepath = path.parse(file);
+      if (parsedFilepath.ext === '.js') {
+        testModules.push(pre + parsedFilepath.name);
+      }
+    }
+  });
+}
+
+loadTestModules();
+
+process.config.target_defaults.default_configuration =
+  fs
+    .readdirSync(path.join(__dirname, '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
+  // on methods that are not available in the NAPI_VERSION
+  // specified
+  napiVersion = process.env.NAPI_VERSION;
+}
+console.log('napiVersion:' + napiVersion);
+
+if (napiVersion < 3) {
+  testModules.splice(testModules.indexOf('env_cleanup'), 1);
+  testModules.splice(testModules.indexOf('callbackscope'), 1);
+  testModules.splice(testModules.indexOf('version_management'), 1);
+}
+
+if (napiVersion < 4) {
+  testModules.splice(testModules.indexOf('asyncprogressqueueworker'), 1);
+  testModules.splice(testModules.indexOf('asyncprogressworker'), 1);
+  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_ctx'), 1);
+  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_existing_tsfn'), 1);
+  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_ptr'), 1);
+  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_sum'), 1);
+  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function_unref'), 1);
+  testModules.splice(testModules.indexOf('threadsafe_function/threadsafe_function'), 1);
+}
+
+if (napiVersion < 5) {
+  testModules.splice(testModules.indexOf('date'), 1);
+}
+
+if (napiVersion < 6) {
+  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) {
+  testModules.splice(testModules.indexOf('objectwrap_worker_thread'), 1);
+  testModules.splice(testModules.indexOf('error_terminating_environment'), 1);
+}
+
+if (napiVersion < 8) {
+  testModules.splice(testModules.indexOf('object/object_freeze_seal'), 1);
+}
+
+(async function() {
+  console.log(`Testing with Node-API Version '${napiVersion}'.`);
+
+  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) => {
+  console.log(error);
+  process.exit(1);
+});

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

@@ -0,0 +1,23 @@
+#include "napi.h"
+#if defined(NODE_ADDON_API_ENABLE_MAYBE)
+
+using namespace Napi;
+
+namespace {
+
+void VoidCallback(const CallbackInfo& info) {
+  Function fn = info[0].As<Function>();
+
+  Maybe<Value> it = fn.Call({});
+
+  it.Check();
+}
+
+}  // end anonymous namespace
+
+Object InitMaybeCheck(Env env) {
+  Object exports = Object::New(env);
+  exports.Set("voidCallback", Function::New(env, VoidCallback));
+  return exports;
+}
+#endif

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

@@ -0,0 +1,38 @@
+'use strict';
+
+const buildType = process.config.target_defaults.default_configuration;
+const assert = require('assert');
+const os = require('os');
+
+const napiChild = require('../napi_child');
+
+module.exports = test(require(`../build/${buildType}/binding_noexcept_maybe.node`).maybe_check);
+
+function test(binding) {
+  if (process.argv.includes('child')) {
+    child(binding);
+    return;
+  }
+  const cp = napiChild.spawn(process.execPath, [__filename, 'child'], {
+    stdio: ['ignore', 'inherit', 'pipe'],
+  });
+  cp.stderr.setEncoding('utf8');
+  let stderr = '';
+  cp.stderr.on('data', chunk => {
+    stderr += chunk;
+  });
+  cp.on('exit', (code, signal) => {
+    if (process.platform === 'win32') {
+      assert.strictEqual(code, 128 + 6 /* SIGABRT */);
+    } else {
+      assert.strictEqual(signal, 'SIGABRT');
+    }
+    assert.ok(stderr.match(/FATAL ERROR: Napi::Maybe::Check Maybe value is Nothing./));
+  });
+}
+
+function child(binding) {
+  binding.voidCallback(() => {
+    throw new Error('foobar');
+  })
+}

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

@@ -0,0 +1,17 @@
+#include "napi.h"
+
+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);
+}
+
+Object InitMemoryManagement(Env env) {
+    Object exports = Object::New(env);
+    exports["externalAllocatedMemory"] = Function::New(env, externalAllocatedMemory);
+    return exports;
+}

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

@@ -0,0 +1,9 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+    assert.strictEqual(binding.memory_management.externalAllocatedMemory(), true)
+}

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

@@ -0,0 +1,23 @@
+#include "napi.h"
+
+using namespace Napi;
+
+Value createExternal(const CallbackInfo& info) {
+  FunctionReference ref = Reference<Function>::New(info[0].As<Function>(), 1);
+  auto ret = External<char>::New(
+      info.Env(),
+      nullptr,
+      [ref = std::move(ref)](Napi::Env /*env*/, char* /*data*/) {
+        ref.Call({});
+      });
+
+  return ret;
+}
+
+Object InitMovableCallbacks(Env env) {
+  Object exports = Object::New(env);
+
+  exports["createExternal"] = Function::New(env, createExternal);
+
+  return exports;
+}

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

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

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

@@ -0,0 +1,108 @@
+#include "napi.h"
+
+using namespace Napi;
+
+const char* testValueUtf8 = "123456789";
+const char16_t* testValueUtf16 = NAPI_WIDE_TEXT("123456789");
+
+Value EchoString(const CallbackInfo& info) {
+  String value = info[0].As<String>();
+  String encoding = info[1].As<String>();
+
+  if (encoding.Utf8Value() == "utf8") {
+    return String::New(info.Env(), value.Utf8Value().c_str());
+  } else if (encoding.Utf8Value() == "utf16") {
+    return String::New(info.Env(), value.Utf16Value().c_str());
+  } else {
+    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
+    return Value();
+  }
+}
+
+Value CreateString(const CallbackInfo& info) {
+  String encoding = info[0].As<String>();
+  Number length = info[1].As<Number>();
+
+  if (encoding.Utf8Value() == "utf8") {
+    if (length.IsUndefined()) {
+      return String::New(info.Env(), testValueUtf8);
+    } else {
+      return String::New(info.Env(), testValueUtf8, length.Uint32Value());
+    }
+  } else if (encoding.Utf8Value() == "utf16") {
+    if (length.IsUndefined()) {
+      return String::New(info.Env(), testValueUtf16);
+    } else {
+      return String::New(info.Env(), testValueUtf16, length.Uint32Value());
+    }
+  } else {
+    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
+    return Value();
+  }
+}
+
+Value CheckString(const CallbackInfo& info) {
+  String value = info[0].As<String>();
+  String encoding = info[1].As<String>();
+  Number length = info[2].As<Number>();
+
+  if (encoding.Utf8Value() == "utf8") {
+    std::string testValue = testValueUtf8;
+    if (!length.IsUndefined()) {
+      testValue = testValue.substr(0, length.Uint32Value());
+    }
+
+    std::string stringValue = value;
+    return Boolean::New(info.Env(), stringValue == testValue);
+  } else if (encoding.Utf8Value() == "utf16") {
+    std::u16string testValue = testValueUtf16;
+    if (!length.IsUndefined()) {
+      testValue = testValue.substr(0, length.Uint32Value());
+    }
+
+    std::u16string stringValue = value;
+    return Boolean::New(info.Env(), stringValue == testValue);
+  } else {
+    Error::New(info.Env(), "Invalid encoding.").ThrowAsJavaScriptException();
+    return Value();
+  }
+}
+
+Value CreateSymbol(const CallbackInfo& info) {
+  String description = info[0].As<String>();
+
+  if (!description.IsUndefined()) {
+    return Symbol::New(info.Env(), description);
+  } else {
+    return Symbol::New(info.Env());
+  }
+}
+
+Value CheckSymbol(const CallbackInfo& info) {
+  return Boolean::New(info.Env(), info[0].Type() == napi_symbol);
+}
+
+void NullStringShouldThrow(const CallbackInfo& info) {
+  const char* nullStr = nullptr;
+  String::New(info.Env(), nullStr);
+}
+
+void NullString16ShouldThrow(const CallbackInfo& info) {
+  const char16_t* nullStr = nullptr;
+  String::New(info.Env(), nullStr);
+}
+
+Object InitName(Env env) {
+  Object exports = Object::New(env);
+
+  exports["echoString"] = Function::New(env, EchoString);
+  exports["createString"] = Function::New(env, CreateString);
+  exports["nullStringShouldThrow"] = Function::New(env, NullStringShouldThrow);
+  exports["nullString16ShouldThrow"] =
+      Function::New(env, NullString16ShouldThrow);
+  exports["checkString"] = Function::New(env, CheckString);
+  exports["createSymbol"] = Function::New(env, CreateSymbol);
+  exports["checkSymbol"] = Function::New(env, CheckSymbol);
+
+  return exports;
+}

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

@@ -0,0 +1,59 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('./common').runTest(test);
+
+function test(binding) {
+  const expected = '123456789';
+
+
+  assert.throws(binding.name.nullStringShouldThrow, {
+    name: 'Error',
+    message: 'Error in native callback',
+  });
+  assert.ok(binding.name.checkString(expected, 'utf8'));
+  assert.ok(binding.name.checkString(expected, 'utf16'));
+  assert.ok(binding.name.checkString(expected.substr(0, 3), 'utf8', 3));
+  assert.ok(binding.name.checkString(expected.substr(0, 3), 'utf16', 3));
+
+  const str1 = binding.name.createString('utf8');
+  assert.strictEqual(str1, expected);
+  assert.ok(binding.name.checkString(str1, 'utf8'));
+  assert.ok(binding.name.checkString(str1, 'utf16'));
+
+  const substr1 = binding.name.createString('utf8', 3);
+  assert.strictEqual(substr1, expected.substr(0, 3));
+  assert.ok(binding.name.checkString(substr1, 'utf8', 3));
+  assert.ok(binding.name.checkString(substr1, 'utf16', 3));
+
+  const str2 = binding.name.createString('utf16');
+  assert.strictEqual(str1, expected);
+  assert.ok(binding.name.checkString(str2, 'utf8'));
+  assert.ok(binding.name.checkString(str2, 'utf16'));
+
+  const substr2 = binding.name.createString('utf16', 3);
+  assert.strictEqual(substr1, expected.substr(0, 3));
+  assert.ok(binding.name.checkString(substr2, 'utf8', 3));
+  assert.ok(binding.name.checkString(substr2, 'utf16', 3));
+
+  assert.ok(binding.name.checkSymbol(Symbol()));
+  assert.ok(binding.name.checkSymbol(Symbol('test')));
+
+  const sym1 = binding.name.createSymbol();
+  assert.strictEqual(typeof sym1, 'symbol');
+  assert.ok(binding.name.checkSymbol(sym1));
+
+  const sym2 = binding.name.createSymbol('test');
+  assert.strictEqual(typeof sym2, 'symbol');
+  assert.ok(binding.name.checkSymbol(sym1));
+
+  // Check for off-by-one errors which might only appear for strings of certain sizes,
+  // due to how std::string increments its capacity in chunks.
+  const longString = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+  for (let i = 10; i <= longString.length; i++) {
+    const str = longString.substr(0, i);
+    assert.strictEqual(binding.name.echoString(str, 'utf8'), str);
+    assert.strictEqual(binding.name.echoString(str, 'utf16'), str);
+  }
+}

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

@@ -0,0 +1,14 @@
+// Makes sure that child processes are spawned appropriately.
+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) {
+  if (require('../index').needsFlag) {
+    args.splice(0, 0, '--napi-modules');
+  }
+  return require('child_process').spawn(command, args, options);
+};

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

@@ -0,0 +1,38 @@
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+Value DeletePropertyWithUint32(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  Number key = info[1].As<Number>();
+  return Boolean::New(info.Env(), MaybeUnwrap(obj.Delete(key.Uint32Value())));
+}
+
+Value DeletePropertyWithNapiValue(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  Name key = info[1].As<Name>();
+  return Boolean::New(
+      info.Env(),
+      MaybeUnwrapOr(obj.Delete(static_cast<napi_value>(key)), false));
+}
+
+Value DeletePropertyWithNapiWrapperValue(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  Name key = info[1].As<Name>();
+  return Boolean::New(info.Env(), MaybeUnwrapOr(obj.Delete(key), false));
+}
+
+Value DeletePropertyWithCStyleString(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  String jsKey = info[1].As<String>();
+  return Boolean::New(
+      info.Env(), MaybeUnwrapOr(obj.Delete(jsKey.Utf8Value().c_str()), false));
+}
+
+Value DeletePropertyWithCppStyleString(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  String jsKey = info[1].As<String>();
+  return Boolean::New(info.Env(),
+                      MaybeUnwrapOr(obj.Delete(jsKey.Utf8Value()), false));
+}

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

@@ -0,0 +1,41 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  function testDeleteProperty(nativeDeleteProperty) {
+    const obj = { one: 1, two: 2 };
+    Object.defineProperty(obj, "three", {configurable: false, value: 3});
+    assert.strictEqual(nativeDeleteProperty(obj, 'one'), true);
+    assert.strictEqual(nativeDeleteProperty(obj, 'missing'), true);
+
+    /* Returns true for all cases except when the property is an own non-
+       configurable property, in which case, false is returned in non-strict mode. */
+    assert.strictEqual(nativeDeleteProperty(obj, 'three'), false);
+    assert.deepStrictEqual(obj, { two: 2 });
+  }
+
+  function testShouldThrowErrorIfKeyIsInvalid(nativeDeleteProperty) {
+    assert.throws(() => {
+      nativeDeleteProperty(undefined, 'test');
+    }, /Cannot convert undefined or null to object/);
+  }
+
+  const testObj = { 15 : 42 , three: 3};
+
+  binding.object.deletePropertyWithUint32(testObj,15);
+
+  assert.strictEqual(testObj.hasOwnProperty(15),false);
+
+  testDeleteProperty(binding.object.deletePropertyWithNapiValue);
+  testDeleteProperty(binding.object.deletePropertyWithNapiWrapperValue);
+  testDeleteProperty(binding.object.deletePropertyWithCStyleString);
+  testDeleteProperty(binding.object.deletePropertyWithCppStyleString);
+
+  testShouldThrowErrorIfKeyIsInvalid(binding.object.deletePropertyWithNapiValue);
+  testShouldThrowErrorIfKeyIsInvalid(binding.object.deletePropertyWithNapiWrapperValue);
+  testShouldThrowErrorIfKeyIsInvalid(binding.object.deletePropertyWithCStyleString);
+  testShouldThrowErrorIfKeyIsInvalid(binding.object.deletePropertyWithCppStyleString);
+}

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

@@ -0,0 +1,29 @@
+#include "napi.h"
+
+using namespace Napi;
+
+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);
+  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);
+  return ref->Value();
+}

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

@@ -0,0 +1,28 @@
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('../testUtil');
+
+module.exports = require('../common').runTest(test);
+
+function createWeakRef(binding, bindingToTest) {
+  return binding.object[bindingToTest]({});
+}
+
+function test(binding) {
+  let obj1;
+  let obj2;
+  return testUtil.runGCTests([
+    'addFinalizer',
+    () => {
+      obj1 = createWeakRef(binding, 'addFinalizer');
+    },
+    () => assert.deepStrictEqual(obj1, { finalizerCalled: true }),
+
+    'addFinalizerWithHint',
+    () => {
+      obj2 = createWeakRef(binding, 'addFinalizerWithHint');
+    },
+    () => assert.deepStrictEqual(obj2, { finalizerCalledWithCorrectHint: true })
+  ]);
+}

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

@@ -0,0 +1,34 @@
+#include "napi.h"
+#include "test_helper.h"
+
+using namespace Napi;
+
+Value GetPropertyWithNapiValue(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  Name key = info[1].As<Name>();
+  return MaybeUnwrapOr(obj.Get(static_cast<napi_value>(key)), Value());
+}
+
+Value GetPropertyWithNapiWrapperValue(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  Name key = info[1].As<Name>();
+  return MaybeUnwrapOr(obj.Get(key), Value());
+}
+
+Value GetPropertyWithUint32(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  Number key = info[1].As<Number>();
+  return MaybeUnwrap(obj.Get(key.Uint32Value()));
+}
+
+Value GetPropertyWithCStyleString(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  String jsKey = info[1].As<String>();
+  return MaybeUnwrapOr(obj.Get(jsKey.Utf8Value().c_str()), Value());
+}
+
+Value GetPropertyWithCppStyleString(const CallbackInfo& info) {
+  Object obj = info[0].As<Object>();
+  String jsKey = info[1].As<String>();
+  return MaybeUnwrapOr(obj.Get(jsKey.Utf8Value()), Value());
+}

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

@@ -0,0 +1,40 @@
+'use strict';
+
+const assert = require('assert');
+
+module.exports = require('../common').runTest(test);
+
+function test(binding) {
+  function testGetProperty(nativeGetProperty) {
+    const obj = { test: 1 };
+    assert.strictEqual(nativeGetProperty(obj, 'test'), 1);
+  }
+
+  function testShouldReturnUndefinedIfKeyIsNotPresent(nativeGetProperty) {
+    const obj = { };
+    assert.strictEqual(nativeGetProperty(obj, 'test'), undefined);
+  }
+
+  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 nativeFunctions = [
+    binding.object.getPropertyWithNapiValue,
+    binding.object.getPropertyWithNapiWrapperValue,
+    binding.object.getPropertyWithCStyleString,
+    binding.object.getPropertyWithCppStyleString
+  ];
+
+  nativeFunctions.forEach((nativeFunction) => {
+    testGetProperty(nativeFunction);
+    testShouldReturnUndefinedIfKeyIsNotPresent(nativeFunction);
+    testShouldThrowErrorIfKeyIsInvalid(nativeFunction);
+  });
+}