koffi 0.9.33 → 0.9.34

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

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

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

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

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

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

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

@@ -1,30 +0,0 @@
-#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;
-}