koffi 1.0.4 → 1.1.0-beta.1

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

@@ -1,41 +0,0 @@
-'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

@@ -1,29 +0,0 @@
-#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

@@ -1,28 +0,0 @@
-'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

@@ -1,34 +0,0 @@
-#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

@@ -1,40 +0,0 @@
-'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);
-  });
-}

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

@@ -1,34 +0,0 @@
-#include "napi.h"
-#include "test_helper.h"
-
-using namespace Napi;
-
-Value HasOwnPropertyWithNapiValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  Name key = info[1].As<Name>();
-  return Boolean::New(
-      info.Env(),
-      MaybeUnwrapOr(obj.HasOwnProperty(static_cast<napi_value>(key)), false));
-}
-
-Value HasOwnPropertyWithNapiWrapperValue(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  Name key = info[1].As<Name>();
-  return Boolean::New(info.Env(),
-                      MaybeUnwrapOr(obj.HasOwnProperty(key), false));
-}
-
-Value HasOwnPropertyWithCStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  String jsKey = info[1].As<String>();
-  return Boolean::New(
-      info.Env(),
-      MaybeUnwrapOr(obj.HasOwnProperty(jsKey.Utf8Value().c_str()), false));
-}
-
-Value HasOwnPropertyWithCppStyleString(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  String jsKey = info[1].As<String>();
-  return Boolean::New(
-      info.Env(), MaybeUnwrapOr(obj.HasOwnProperty(jsKey.Utf8Value()), false));
-}

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

@@ -1,34 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  function testHasOwnProperty(nativeHasOwnProperty) {
-    const obj = { one: 1 };
-
-    Object.defineProperty(obj, 'two', { value: 2 });
-
-    assert.strictEqual(nativeHasOwnProperty(obj, 'one'), true);
-    assert.strictEqual(nativeHasOwnProperty(obj, 'two'), true);
-    assert.strictEqual('toString' in obj, true);
-    assert.strictEqual(nativeHasOwnProperty(obj, 'toString'), false);
-  }
-
-  function testShouldThrowErrorIfKeyIsInvalid(nativeHasOwnProperty) {
-    assert.throws(() => {
-      nativeHasOwnProperty(undefined, 'test');
-    }, /Cannot convert undefined or null to object/);
-  }
-
-  testHasOwnProperty(binding.object.hasOwnPropertyWithNapiValue);
-  testHasOwnProperty(binding.object.hasOwnPropertyWithNapiWrapperValue);
-  testHasOwnProperty(binding.object.hasOwnPropertyWithCStyleString);
-  testHasOwnProperty(binding.object.hasOwnPropertyWithCppStyleString);
-
-  testShouldThrowErrorIfKeyIsInvalid(binding.object.hasOwnPropertyWithNapiValue);
-  testShouldThrowErrorIfKeyIsInvalid(binding.object.hasOwnPropertyWithNapiWrapperValue);
-  testShouldThrowErrorIfKeyIsInvalid(binding.object.hasOwnPropertyWithCStyleString);
-  testShouldThrowErrorIfKeyIsInvalid(binding.object.hasOwnPropertyWithCppStyleString);
-}

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

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

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

@@ -1,37 +0,0 @@
-'use strict';
-
-const assert = require('assert');
-
-module.exports = require('../common').runTest(test);
-
-function test(binding) {
-  function testHasProperty(nativeHasProperty) {
-    const obj = { one: 1 };
-
-    Object.defineProperty(obj, 'two', { value: 2 });
-
-    assert.strictEqual(nativeHasProperty(obj, 'one'), true);
-    assert.strictEqual(nativeHasProperty(obj, 'two'), true);
-    assert.strictEqual('toString' in obj, true);
-    assert.strictEqual(nativeHasProperty(obj, 'toString'), true);
-  }
-
-  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);
-
-  testHasProperty(binding.object.hasPropertyWithNapiValue);
-  testHasProperty(binding.object.hasPropertyWithNapiWrapperValue);
-  testHasProperty(binding.object.hasPropertyWithCStyleString);
-  testHasProperty(binding.object.hasPropertyWithCppStyleString);
-
-  testShouldThrowErrorIfKeyIsInvalid(binding.object.hasPropertyWithNapiValue);
-  testShouldThrowErrorIfKeyIsInvalid(binding.object.hasPropertyWithNapiWrapperValue);
-  testShouldThrowErrorIfKeyIsInvalid(binding.object.hasPropertyWithCStyleString);
-  testShouldThrowErrorIfKeyIsInvalid(binding.object.hasPropertyWithCppStyleString);
-}

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

@@ -1,350 +0,0 @@
-#include "napi.h"
-#include "test_helper.h"
-
-using namespace Napi;
-
-// Native wrappers for testing Object::Get()
-Value GetPropertyWithUint32(const CallbackInfo& info);
-Value GetPropertyWithNapiValue(const CallbackInfo& info);
-Value GetPropertyWithNapiWrapperValue(const CallbackInfo& info);
-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);
-Value SetPropertyWithCppStyleString(const CallbackInfo& info);
-
-// Native wrappers for testing Object::Delete()
-Value DeletePropertyWithUint32(const CallbackInfo& info);
-Value DeletePropertyWithNapiValue(const CallbackInfo& info);
-Value DeletePropertyWithNapiWrapperValue(const CallbackInfo& info);
-Value DeletePropertyWithCStyleString(const CallbackInfo& info);
-Value DeletePropertyWithCppStyleString(const CallbackInfo& info);
-
-// Native wrappers for testing Object::HasOwnProperty()
-Value HasOwnPropertyWithNapiValue(const CallbackInfo& info);
-Value HasOwnPropertyWithNapiWrapperValue(const CallbackInfo& info);
-Value HasOwnPropertyWithCStyleString(const CallbackInfo& info);
-Value HasOwnPropertyWithCppStyleString(const CallbackInfo& info);
-
-// Native wrappers for testing Object::Has()
-Value HasPropertyWithUint32(const CallbackInfo& info);
-Value HasPropertyWithNapiValue(const CallbackInfo& info);
-Value HasPropertyWithNapiWrapperValue(const CallbackInfo& info);
-Value HasPropertyWithCStyleString(const CallbackInfo& info);
-Value HasPropertyWithCppStyleString(const CallbackInfo& info);
-
-// Native wrappers for testing Object::AddFinalizer()
-Value AddFinalizer(const CallbackInfo& info);
-Value AddFinalizerWithHint(const CallbackInfo& info);
-
-// Native wrappers for testing Object::operator []
-Value SubscriptGetWithCStyleString(const CallbackInfo& info);
-Value SubscriptGetWithCppStyleString(const CallbackInfo& info);
-Value SubscriptGetAtIndex(const CallbackInfo& info);
-void SubscriptSetWithCStyleString(const CallbackInfo& info);
-void SubscriptSetWithCppStyleString(const CallbackInfo& info);
-void SubscriptSetAtIndex(const CallbackInfo& info);
-
-static bool testValue = true;
-// Used to test void* Data() integrity
-struct UserDataHolder {
-  int32_t value;
-};
-
-Value TestGetter(const CallbackInfo& info) {
-   return Boolean::New(info.Env(), testValue);
-}
-
-void TestSetter(const CallbackInfo& info) {
-   testValue = info[0].As<Boolean>();
-}
-
-Value TestGetterWithUserData(const CallbackInfo& info) {
-  const UserDataHolder* holder = reinterpret_cast<UserDataHolder*>(info.Data());
-  return Number::New(info.Env(), holder->value);
-}
-
-void TestSetterWithUserData(const CallbackInfo& info) {
-  UserDataHolder* holder = reinterpret_cast<UserDataHolder*>(info.Data());
-  holder->value = info[0].As<Number>().Int32Value();
-}
-
-Value TestFunction(const CallbackInfo& info) {
-   return Boolean::New(info.Env(), true);
-}
-
-Value TestFunctionWithUserData(const CallbackInfo& info) {
-  UserDataHolder* holder = reinterpret_cast<UserDataHolder*>(info.Data());
-  return Number::New(info.Env(), holder->value);
-}
-
-Value EmptyConstructor(const CallbackInfo& info) {
-  auto env = info.Env();
-  bool isEmpty = info[0].As<Boolean>();
-  Object object = isEmpty ? Object() : Object(env, Object::New(env));
-  return Boolean::New(env, object.IsEmpty());
-}
-
-Value ConstructorFromObject(const CallbackInfo& info) {
-  auto env = info.Env();
-  Object object = info[0].As<Object>();
-  return Object(env, object);
-}
-
-Array GetPropertyNames(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  Array arr = MaybeUnwrap(obj.GetPropertyNames());
-  return arr;
-}
-
-void DefineProperties(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  String nameType = info[1].As<String>();
-  Env env = info.Env();
-
-  Boolean trueValue = Boolean::New(env, true);
-  UserDataHolder* holder = new UserDataHolder();
-  holder->value = 1234;
-
-  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)),
-    });
-  } 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.
-    std::string str1("readonlyAccessor");
-    std::string str2("readwriteAccessor");
-    std::string str1a("readonlyAccessorWithUserData");
-    std::string str2a("readwriteAccessorWithUserData");
-
-    std::string str1t("readonlyAccessorT");
-    std::string str2t("readwriteAccessorT");
-    std::string str1at("readonlyAccessorWithUserDataT");
-    std::string str2at("readwriteAccessorWithUserDataT");
-
-    std::string str3("readonlyValue");
-    std::string str4("readwriteValue");
-    std::string str5("enumerableValue");
-    std::string str6("configurableValue");
-    std::string str7("function");
-    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)),
-    });
-  } 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)),
-    });
-  }
-}
-
-void DefineValueProperty(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  Name name = info[1].As<Name>();
-  Value value = info[2];
-
-  obj.DefineProperty(PropertyDescriptor::Value(name, value));
-}
-
-Value CreateObjectUsingMagic(const CallbackInfo& info) {
-  Env env = info.Env();
-  Object obj = Object::New(env);
-  obj["cp_false"] = false;
-  obj["cp_true"] = true;
-  obj[std::string("s_true")] = true;
-  obj[std::string("s_false")] = false;
-  obj["0"] = 0;
-  obj[(uint32_t)42] = 120;
-  obj["0.0f"] = 0.0f;
-  obj["0.0"] = 0.0;
-  obj["-1"] = -1;
-  obj["foo2"] = u"foo";
-  obj[std::string("foo4")] = NAPI_WIDE_TEXT("foo");
-  obj[std::string("foo5")] = "foo";
-  obj[std::string("foo6")] = std::u16string(NAPI_WIDE_TEXT("foo"));
-  obj[std::string("foo7")] = std::string("foo");
-  obj[std::string("circular")] = obj;
-  obj["circular2"] = obj;
-  return obj;
-}
-
-#ifdef NAPI_CPP_EXCEPTIONS
-Value Sum(const CallbackInfo& info) {
-  Object object = info[0].As<Object>();
-  int64_t sum = 0;
-
-  for (const auto& e : object) {
-    sum += static_cast<Value>(e.second).As<Number>().Int64Value();
-  }
-
-  return Number::New(info.Env(), sum);
-}
-
-void Increment(const CallbackInfo& info) {
-  Env env = info.Env();
-  Object object = info[0].As<Object>();
-
-  for (auto e : object) {
-    int64_t value = static_cast<Value>(e.second).As<Number>().Int64Value();
-    ++value;
-    e.second = Napi::Number::New(env, value);
-  }
-}
-#endif  // NAPI_CPP_EXCEPTIONS
-
-Value InstanceOf(const CallbackInfo& info) {
-  Object obj = info[0].As<Object>();
-  Function constructor = info[1].As<Function>();
-  return Boolean::New(info.Env(), MaybeUnwrap(obj.InstanceOf(constructor)));
-}
-
-Object InitObject(Env env) {
-  Object exports = Object::New(env);
-
-  exports["emptyConstructor"] = Function::New(env, EmptyConstructor);
-  exports["constructorFromObject"] = Function::New(env, ConstructorFromObject);
-
-  exports["GetPropertyNames"] = Function::New(env, GetPropertyNames);
-  exports["defineProperties"] = Function::New(env, DefineProperties);
-  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["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["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["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);
-#ifdef NAPI_CPP_EXCEPTIONS
-  exports["sum"] = Function::New(env, Sum);
-  exports["increment"] = Function::New(env, Increment);
-#endif  // NAPI_CPP_EXCEPTIONS
-
-  exports["addFinalizer"] = Function::New(env, AddFinalizer);
-  exports["addFinalizerWithHint"] = Function::New(env, AddFinalizerWithHint);
-
-  exports["instanceOf"] = Function::New(env, InstanceOf);
-
-  exports["subscriptGetWithCStyleString"] =
-      Function::New(env, SubscriptGetWithCStyleString);
-  exports["subscriptGetWithCppStyleString"] =
-      Function::New(env, SubscriptGetWithCppStyleString);
-  exports["subscriptGetAtIndex"] = Function::New(env, SubscriptGetAtIndex);
-  exports["subscriptSetWithCStyleString"] =
-      Function::New(env, SubscriptSetWithCStyleString);
-  exports["subscriptSetWithCppStyleString"] =
-      Function::New(env, SubscriptSetWithCppStyleString);
-  exports["subscriptSetAtIndex"] = Function::New(env, SubscriptSetAtIndex);
-
-  return exports;
-}