koffi 1.1.0-beta.1 → 1.1.0-beta.4

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

@@ -0,0 +1,268 @@
+#include <napi.h>
+#include "test_helper.h"
+
+Napi::ObjectReference testStaticContextRef;
+
+Napi::Value StaticGetter(const Napi::CallbackInfo& /*info*/) {
+  return MaybeUnwrap(testStaticContextRef.Value().Get("value"));
+}
+
+void StaticSetter(const Napi::CallbackInfo& /*info*/, const Napi::Value& value) {
+  testStaticContextRef.Value().Set("value", value);
+}
+
+Napi::Value TestStaticMethod(const Napi::CallbackInfo& info) {
+  std::string str = MaybeUnwrap(info[0].ToString());
+  return Napi::String::New(info.Env(), str + " static");
+}
+
+Napi::Value TestStaticMethodInternal(const Napi::CallbackInfo& info) {
+  std::string str = MaybeUnwrap(info[0].ToString());
+  return Napi::String::New(info.Env(), str + " static internal");
+}
+
+class Test : public Napi::ObjectWrap<Test> {
+public:
+  Test(const Napi::CallbackInfo& info) :
+    Napi::ObjectWrap<Test>(info) {
+
+    if(info.Length() > 0) {
+      finalizeCb_ = Napi::Persistent(info[0].As<Napi::Function>());
+    }
+    // Create an own instance property.
+    info.This().As<Napi::Object>().DefineProperty(
+        Napi::PropertyDescriptor::Accessor(info.Env(),
+                                           info.This().As<Napi::Object>(),
+                                           "ownProperty",
+                                           OwnPropertyGetter,
+                                           napi_enumerable, this));
+
+    // Create an own instance property with a templated function.
+    info.This().As<Napi::Object>().DefineProperty(
+        Napi::PropertyDescriptor::Accessor<OwnPropertyGetter>("ownPropertyT",
+                                                              napi_enumerable, this));
+
+    bufref_ = Napi::Persistent(Napi::Buffer<uint8_t>::New(
+        Env(),
+        static_cast<uint8_t*>(malloc(1)),
+        1,
+        [](Napi::Env, uint8_t* bufaddr) {
+            free(bufaddr);
+        }));
+  }
+
+  static Napi::Value OwnPropertyGetter(const Napi::CallbackInfo& info) {
+    return static_cast<Test*>(info.Data())->Getter(info);
+  }
+
+  void Setter(const Napi::CallbackInfo& /*info*/, const Napi::Value& value) {
+    value_ = MaybeUnwrap(value.ToString());
+  }
+
+  Napi::Value Getter(const Napi::CallbackInfo& info) {
+    return Napi::String::New(info.Env(), value_);
+  }
+
+  Napi::Value TestMethod(const Napi::CallbackInfo& info) {
+    std::string str = MaybeUnwrap(info[0].ToString());
+    return Napi::String::New(info.Env(), str + " instance");
+  }
+
+  Napi::Value TestMethodInternal(const Napi::CallbackInfo& info) {
+    std::string str = MaybeUnwrap(info[0].ToString());
+    return Napi::String::New(info.Env(), str + " instance internal");
+  }
+
+  Napi::Value ToStringTag(const Napi::CallbackInfo& info) {
+    return Napi::String::From(info.Env(), "TestTag");
+  }
+
+  // creates dummy array, returns `([value])[Symbol.iterator]()`
+  Napi::Value Iterator(const Napi::CallbackInfo& info) {
+    Napi::Array array = Napi::Array::New(info.Env());
+    array.Set(array.Length(), Napi::String::From(info.Env(), value_));
+    return MaybeUnwrap(
+        MaybeUnwrap(array.Get(MaybeUnwrap(
+                        Napi::Symbol::WellKnown(info.Env(), "iterator"))))
+            .As<Napi::Function>()
+            .Call(array, {}));
+  }
+
+  void TestVoidMethodT(const Napi::CallbackInfo &info) {
+    value_ = MaybeUnwrap(info[0].ToString());
+  }
+
+  Napi::Value TestMethodT(const Napi::CallbackInfo &info) {
+      return Napi::String::New(info.Env(), value_);
+  }
+
+  static Napi::Value TestStaticMethodT(const Napi::CallbackInfo& info) {
+      return Napi::String::New(info.Env(), s_staticMethodText);
+  }
+
+  static void TestStaticVoidMethodT(const Napi::CallbackInfo& info) {
+    s_staticMethodText = MaybeUnwrap(info[0].ToString());
+  }
+
+  static void Initialize(Napi::Env env, Napi::Object exports) {
+
+    Napi::Symbol kTestStaticValueInternal = Napi::Symbol::New(env, "kTestStaticValueInternal");
+    Napi::Symbol kTestStaticAccessorInternal = Napi::Symbol::New(env, "kTestStaticAccessorInternal");
+    Napi::Symbol kTestStaticAccessorTInternal = Napi::Symbol::New(env, "kTestStaticAccessorTInternal");
+    Napi::Symbol kTestStaticMethodInternal = Napi::Symbol::New(env, "kTestStaticMethodInternal");
+    Napi::Symbol kTestStaticMethodTInternal     = Napi::Symbol::New(env, "kTestStaticMethodTInternal");
+    Napi::Symbol kTestStaticVoidMethodTInternal = Napi::Symbol::New(env, "kTestStaticVoidMethodTInternal");
+
+    Napi::Symbol kTestValueInternal = Napi::Symbol::New(env, "kTestValueInternal");
+    Napi::Symbol kTestAccessorInternal = Napi::Symbol::New(env, "kTestAccessorInternal");
+    Napi::Symbol kTestAccessorTInternal = Napi::Symbol::New(env, "kTestAccessorTInternal");
+    Napi::Symbol kTestMethodInternal = Napi::Symbol::New(env, "kTestMethodInternal");
+    Napi::Symbol kTestMethodTInternal     = Napi::Symbol::New(env, "kTestMethodTInternal");
+    Napi::Symbol kTestVoidMethodTInternal = Napi::Symbol::New(env, "kTestVoidMethodTInternal");
+
+    exports.Set(
+        "Test",
+        DefineClass(
+            env,
+            "Test",
+            {
+
+                // expose symbols for testing
+                StaticValue("kTestStaticValueInternal",
+                            kTestStaticValueInternal),
+                StaticValue("kTestStaticAccessorInternal",
+                            kTestStaticAccessorInternal),
+                StaticValue("kTestStaticAccessorTInternal",
+                            kTestStaticAccessorTInternal),
+                StaticValue("kTestStaticMethodInternal",
+                            kTestStaticMethodInternal),
+                StaticValue("kTestStaticMethodTInternal",
+                            kTestStaticMethodTInternal),
+                StaticValue("kTestStaticVoidMethodTInternal",
+                            kTestStaticVoidMethodTInternal),
+                StaticValue("kTestValueInternal", kTestValueInternal),
+                StaticValue("kTestAccessorInternal", kTestAccessorInternal),
+                StaticValue("kTestAccessorTInternal", kTestAccessorTInternal),
+                StaticValue("kTestMethodInternal", kTestMethodInternal),
+                StaticValue("kTestMethodTInternal", kTestMethodTInternal),
+                StaticValue("kTestVoidMethodTInternal",
+                            kTestVoidMethodTInternal),
+
+                // test data
+                StaticValue("testStaticValue",
+                            Napi::String::New(env, "value"),
+                            napi_enumerable),
+                StaticValue(kTestStaticValueInternal,
+                            Napi::Number::New(env, 5),
+                            napi_default),
+
+                StaticAccessor("testStaticGetter",
+                               &StaticGetter,
+                               nullptr,
+                               napi_enumerable),
+                StaticAccessor(
+                    "testStaticSetter", nullptr, &StaticSetter, napi_default),
+                StaticAccessor("testStaticGetSet",
+                               &StaticGetter,
+                               &StaticSetter,
+                               napi_enumerable),
+                StaticAccessor(kTestStaticAccessorInternal,
+                               &StaticGetter,
+                               &StaticSetter,
+                               napi_enumerable),
+                StaticAccessor<&StaticGetter>("testStaticGetterT"),
+                StaticAccessor<&StaticGetter, &StaticSetter>(
+                    "testStaticGetSetT"),
+                StaticAccessor<&StaticGetter, &StaticSetter>(
+                    kTestStaticAccessorTInternal),
+
+                StaticMethod(
+                    "testStaticMethod", &TestStaticMethod, napi_enumerable),
+                StaticMethod(kTestStaticMethodInternal,
+                             &TestStaticMethodInternal,
+                             napi_default),
+                StaticMethod<&TestStaticVoidMethodT>("testStaticVoidMethodT"),
+                StaticMethod<&TestStaticMethodT>("testStaticMethodT"),
+                StaticMethod<&TestStaticVoidMethodT>(
+                    kTestStaticVoidMethodTInternal),
+                StaticMethod<&TestStaticMethodT>(kTestStaticMethodTInternal),
+
+                InstanceValue("testValue",
+                              Napi::Boolean::New(env, true),
+                              napi_enumerable),
+                InstanceValue(kTestValueInternal,
+                              Napi::Boolean::New(env, false),
+                              napi_enumerable),
+
+                InstanceAccessor(
+                    "testGetter", &Test::Getter, nullptr, napi_enumerable),
+                InstanceAccessor(
+                    "testSetter", nullptr, &Test::Setter, napi_default),
+                InstanceAccessor("testGetSet",
+                                 &Test::Getter,
+                                 &Test::Setter,
+                                 napi_enumerable),
+                InstanceAccessor(kTestAccessorInternal,
+                                 &Test::Getter,
+                                 &Test::Setter,
+                                 napi_enumerable),
+                InstanceAccessor<&Test::Getter>("testGetterT"),
+                InstanceAccessor<&Test::Getter, &Test::Setter>("testGetSetT"),
+                InstanceAccessor<&Test::Getter, &Test::Setter>(
+                    kTestAccessorInternal),
+
+                InstanceMethod(
+                    "testMethod", &Test::TestMethod, napi_enumerable),
+                InstanceMethod(kTestMethodInternal,
+                               &Test::TestMethodInternal,
+                               napi_default),
+                InstanceMethod<&Test::TestMethodT>("testMethodT"),
+                InstanceMethod<&Test::TestVoidMethodT>("testVoidMethodT"),
+                InstanceMethod<&Test::TestMethodT>(kTestMethodTInternal),
+                InstanceMethod<&Test::TestVoidMethodT>(
+                    kTestVoidMethodTInternal),
+
+                // conventions
+                InstanceAccessor(
+                    MaybeUnwrap(Napi::Symbol::WellKnown(env, "toStringTag")),
+                    &Test::ToStringTag,
+                    nullptr,
+                    napi_enumerable),
+                InstanceMethod(
+                    MaybeUnwrap(Napi::Symbol::WellKnown(env, "iterator")),
+                    &Test::Iterator,
+                    napi_default),
+
+            }));
+  }
+
+  void Finalize(Napi::Env env) {
+
+    if(finalizeCb_.IsEmpty()) {
+      return;
+    }
+
+    finalizeCb_.Call(env.Global(), {Napi::Boolean::New(env, true)});
+    finalizeCb_.Unref();
+
+  }
+
+private:
+  std::string value_;
+  Napi::FunctionReference finalizeCb_;
+
+  static std::string s_staticMethodText;
+
+  Napi::Reference<Napi::Buffer<uint8_t>> bufref_;
+};
+
+std::string Test::s_staticMethodText;
+
+Napi::Object InitObjectWrap(Napi::Env env) {
+  testStaticContextRef = Napi::Persistent(Napi::Object::New(env));
+  testStaticContextRef.SuppressDestruct();
+
+  Napi::Object exports = Napi::Object::New(env);
+  Test::Initialize(env, exports);
+  return exports;
+}

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

@@ -0,0 +1,284 @@
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('./testUtil');
+
+module.exports = require('./common').runTest(test);
+
+async function test(binding) {
+  const Test = binding.objectwrap.Test;
+
+  const testValue = (obj, clazz) => {
+    assert.strictEqual(obj.testValue, true);
+    assert.strictEqual(obj[clazz.kTestValueInternal], false);
+  };
+
+  const testAccessor = (obj, clazz) => {
+    // read-only, write-only
+    {
+      obj.testSetter = 'instance getter';
+      assert.strictEqual(obj.testGetter, 'instance getter');
+      assert.strictEqual(obj.testGetterT, 'instance getter');
+
+      obj.testSetter = 'instance getter 2';
+      assert.strictEqual(obj.testGetter, 'instance getter 2');
+      assert.strictEqual(obj.testGetterT, 'instance getter 2');
+    }
+
+    // read write-only
+    {
+      let error;
+      try { const read = obj.testSetter; } catch (e) { error = e; }
+      // no error
+      assert.strictEqual(error, undefined);
+
+      // read is undefined
+      assert.strictEqual(obj.testSetter, undefined);
+    }
+
+    // write read-only
+    {
+      let error;
+      try { obj.testGetter = 'write'; } catch (e) { error = e; }
+      assert.strictEqual(error.name, 'TypeError');
+
+      try { obj.testGetterT = 'write'; } catch (e) { error = e; }
+      assert.strictEqual(error.name, 'TypeError');
+    }
+
+    // rw
+    {
+      obj.testGetSet = 'instance getset';
+      assert.strictEqual(obj.testGetSet, 'instance getset');
+
+      obj.testGetSet = 'instance getset 2';
+      assert.strictEqual(obj.testGetSet, 'instance getset 2');
+
+      obj.testGetSetT = 'instance getset 3';
+      assert.strictEqual(obj.testGetSetT, 'instance getset 3');
+
+      obj.testGetSetT = 'instance getset 4';
+      assert.strictEqual(obj.testGetSetT, 'instance getset 4');
+    }
+
+    // rw symbol
+    {
+      obj[clazz.kTestAccessorInternal] = 'instance internal getset';
+      assert.strictEqual(obj[clazz.kTestAccessorInternal], 'instance internal getset');
+
+      obj[clazz.kTestAccessorInternal] = 'instance internal getset 2';
+      assert.strictEqual(obj[clazz.kTestAccessorInternal], 'instance internal getset 2');
+
+      obj[clazz.kTestAccessorTInternal] = 'instance internal getset 3';
+      assert.strictEqual(obj[clazz.kTestAccessorTInternal], 'instance internal getset 3');
+
+      obj[clazz.kTestAccessorTInternal] = 'instance internal getset 4';
+      assert.strictEqual(obj[clazz.kTestAccessorTInternal], 'instance internal getset 4');
+    }
+
+    // own property
+    {
+      obj.testSetter = 'own property value';
+      // Make sure the properties are enumerable.
+      assert(Object.getOwnPropertyNames(obj).indexOf('ownProperty') >= 0);
+      assert(Object.getOwnPropertyNames(obj).indexOf('ownPropertyT') >= 0);
+
+      // Make sure the properties return the right value.
+      assert.strictEqual(obj.ownProperty, 'own property value');
+      assert.strictEqual(obj.ownPropertyT, 'own property value');
+    }
+  };
+
+  const testMethod = (obj, clazz) => {
+    assert.strictEqual(obj.testMethod('method'), 'method instance');
+    assert.strictEqual(obj[clazz.kTestMethodInternal]('method'), 'method instance internal');
+    obj.testVoidMethodT('method<>(const char*)');
+    assert.strictEqual(obj.testMethodT(), 'method<>(const char*)');
+    obj[clazz.kTestVoidMethodTInternal]('method<>(Symbol)');
+    assert.strictEqual(obj[clazz.kTestMethodTInternal](), 'method<>(Symbol)');
+  };
+
+  const testEnumerables = (obj, clazz) => {
+    // Object.keys: only object without prototype
+    assert(Object.keys(obj).length === 2);
+    assert(Object.keys(obj).includes('ownProperty'));
+    assert(Object.keys(obj).indexOf('ownPropertyT') >= 0);
+
+    // for..in: object and prototype
+    {
+      const keys = [];
+      for (let key in obj) {
+        keys.push(key);
+      }
+
+      assert(keys.length == 6);
+      // on prototype
+      assert(keys.includes("testGetSet"));
+      assert(keys.includes("testGetter"));
+      assert(keys.includes("testValue"));
+      assert(keys.includes("testMethod"));
+      // on object only
+      assert(keys.includes("ownProperty"));
+      assert(keys.includes("ownPropertyT"));
+    }
+  };
+
+  const testConventions = (obj, clazz) => {
+    // test @@toStringTag
+    {
+      assert.strictEqual(obj[Symbol.toStringTag], 'TestTag');
+      assert.strictEqual('' + obj, '[object TestTag]');
+    }
+
+    // test @@iterator
+    {
+      obj.testSetter = 'iterator';
+      const values = [];
+
+      for (let item of obj) {
+        values.push(item);
+      }
+
+      assert.deepEqual(values, ['iterator']);
+    }
+  };
+
+  const testStaticValue = (clazz) => {
+    assert.strictEqual(clazz.testStaticValue, 'value');
+    assert.strictEqual(clazz[clazz.kTestStaticValueInternal], 5);
+  }
+
+  const testStaticAccessor = (clazz) => {
+    // read-only, write-only
+    {
+      const tempObj = {};
+      clazz.testStaticSetter = tempObj;
+      assert.strictEqual(clazz.testStaticGetter, tempObj);
+      assert.strictEqual(clazz.testStaticGetterT, tempObj);
+
+      const tempArray = [];
+      clazz.testStaticSetter = tempArray;
+      assert.strictEqual(clazz.testStaticGetter, tempArray);
+      assert.strictEqual(clazz.testStaticGetterT, tempArray);
+    }
+
+    // read write-only
+    {
+      let error;
+      try { const read = clazz.testStaticSetter; } catch (e) { error = e; }
+      // no error
+      assert.strictEqual(error, undefined);
+
+      // read is undefined
+      assert.strictEqual(clazz.testStaticSetter, undefined);
+    }
+
+    // write-read-only
+    {
+      let error;
+      try { clazz.testStaticGetter = 'write'; } catch (e) { error = e; }
+      assert.strictEqual(error.name, 'TypeError');
+      try { clazz.testStaticGetterT = 'write'; } catch (e) { error = e; }
+      assert.strictEqual(error.name, 'TypeError');
+    }
+
+    // rw
+    {
+      clazz.testStaticGetSet = 9;
+      assert.strictEqual(clazz.testStaticGetSet, 9);
+
+      clazz.testStaticGetSet = 4;
+      assert.strictEqual(clazz.testStaticGetSet, 4);
+
+      clazz.testStaticGetSetT = -9;
+      assert.strictEqual(clazz.testStaticGetSetT, -9);
+
+      clazz.testStaticGetSetT = -4;
+      assert.strictEqual(clazz.testStaticGetSetT, -4);
+    }
+
+    // rw symbol
+    {
+      clazz[clazz.kTestStaticAccessorInternal] = 'static internal getset';
+      assert.strictEqual(clazz[clazz.kTestStaticAccessorInternal], 'static internal getset');
+      clazz[clazz.kTestStaticAccessorTInternal] = 'static internal getset <>';
+      assert.strictEqual(clazz[clazz.kTestStaticAccessorTInternal], 'static internal getset <>');
+    }
+  };
+
+  const testStaticMethod = (clazz) => {
+    assert.strictEqual(clazz.testStaticMethod('method'), 'method static');
+    assert.strictEqual(clazz[clazz.kTestStaticMethodInternal]('method'), 'method static internal');
+    clazz.testStaticVoidMethodT('static method<>(const char*)');
+    assert.strictEqual(clazz.testStaticMethodT(), 'static method<>(const char*)');
+    clazz[clazz.kTestStaticVoidMethodTInternal]('static method<>(Symbol)');
+    assert.strictEqual(clazz[clazz.kTestStaticMethodTInternal](), 'static method<>(Symbol)');
+  };
+
+  const testStaticEnumerables = (clazz) => {
+    // Object.keys
+    assert.deepEqual(Object.keys(clazz), [
+      'testStaticValue',
+      'testStaticGetter',
+      'testStaticGetSet',
+      'testStaticMethod'
+    ]);
+
+    // for..in
+    {
+      const keys = [];
+      for (let key in clazz) {
+        keys.push(key);
+      }
+
+      assert.deepEqual(keys, [
+        'testStaticValue',
+        'testStaticGetter',
+        'testStaticGetSet',
+        'testStaticMethod'
+      ]);
+    }
+  };
+
+  async function testFinalize(clazz) {
+    let finalizeCalled = false;
+    await testUtil.runGCTests([
+      'test finalize',
+      () => {
+        const finalizeCb = function(called) {
+          finalizeCalled = called;
+        };
+
+        //Scope Test instance so that it can be gc'd.
+        (() => { new Test(finalizeCb); })();
+      },
+      () => assert.strictEqual(finalizeCalled, true)
+    ]);
+  };
+
+  const testObj = (obj, clazz) => {
+    testValue(obj, clazz);
+    testAccessor(obj, clazz);
+    testMethod(obj, clazz);
+
+    testEnumerables(obj, clazz);
+
+    testConventions(obj, clazz);
+  }
+
+  async function testClass(clazz) {
+    testStaticValue(clazz);
+    testStaticAccessor(clazz);
+    testStaticMethod(clazz);
+
+    testStaticEnumerables(clazz);
+    await testFinalize(clazz);
+  };
+
+  // `Test` is needed for accessing exposed symbols
+  testObj(new Test(), Test);
+  await testClass(Test);
+
+  // Make sure the C++ object can be garbage collected without issues.
+  await testUtil.runGCTests(['one last gc', () => {}, () => {}]);
+}

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

@@ -0,0 +1,26 @@
+#include <napi.h>
+
+class ConstructorExceptionTest :
+  public Napi::ObjectWrap<ConstructorExceptionTest> {
+public:
+  ConstructorExceptionTest(const Napi::CallbackInfo& info) :
+    Napi::ObjectWrap<ConstructorExceptionTest>(info) {
+    Napi::Error error = Napi::Error::New(info.Env(), "an exception");
+#ifdef NAPI_DISABLE_CPP_EXCEPTIONS
+    error.ThrowAsJavaScriptException();
+#else
+    throw error;
+#endif  // NAPI_DISABLE_CPP_EXCEPTIONS
+  }
+
+  static void Initialize(Napi::Env env, Napi::Object exports) {
+    const char* name = "ConstructorExceptionTest";
+    exports.Set(name, DefineClass(env, name, {}));
+  }
+};
+
+Napi::Object InitObjectWrapConstructorException(Napi::Env env) {
+  Napi::Object exports = Napi::Object::New(env);
+  ConstructorExceptionTest::Initialize(env, exports);
+  return exports;
+}

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

@@ -0,0 +1,18 @@
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('./testUtil');
+
+function test(binding) {
+  return testUtil.runGCTests([
+    'objectwrap constructor exception',
+    () => {
+      const { ConstructorExceptionTest } = binding.objectwrapConstructorException;
+      assert.throws(() => (new ConstructorExceptionTest()), /an exception/);
+    },
+    // Do on gc before returning.
+    () => {}
+  ]);
+}
+
+module.exports = require('./common').runTest(test);

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;
+}

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

@@ -0,0 +1,22 @@
+'use strict';
+
+const assert = require('assert');
+const testUtil = require('./testUtil');
+
+function test (binding) {
+  return testUtil.runGCTests([
+    'objectwrap function',
+    () => {
+      const { FunctionTest } = binding.objectwrap_function;
+      const newConstructed = new FunctionTest();
+      const functionConstructed = FunctionTest();
+      assert(newConstructed instanceof FunctionTest);
+      assert(functionConstructed instanceof FunctionTest);
+      assert.throws(() => (FunctionTest(true)), /an exception/);
+    },
+    // Do on gc before returning.
+    () => {}
+  ]);
+}
+
+module.exports = require('./common').runTest(test);

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

@@ -0,0 +1,30 @@
+#include <napi.h>
+
+class TestMIBase {
+public:
+  TestMIBase() : test(0) {}
+  virtual void dummy() {}
+  uint32_t test;
+};
+
+class TestMI : public TestMIBase, public Napi::ObjectWrap<TestMI> {
+public:
+  TestMI(const Napi::CallbackInfo& info) :
+    Napi::ObjectWrap<TestMI>(info) {}
+
+  Napi::Value GetTest(const Napi::CallbackInfo& info) {
+    return Napi::Number::New(info.Env(), test);
+  }
+
+  static void Initialize(Napi::Env env, Napi::Object exports) {
+    exports.Set("TestMI", DefineClass(env, "TestMI", {
+      InstanceAccessor<&TestMI::GetTest>("test")
+    }));
+  }
+};
+
+Napi::Object InitObjectWrapMultipleInheritance(Napi::Env env) {
+  Napi::Object exports = Napi::Object::New(env);
+  TestMI::Initialize(env, exports);
+  return exports;
+}