| #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); |
| } |
| |
| void StaticMethodVoidCb(const Napi::CallbackInfo& info) { |
| StaticSetter(info, info[0].As<Napi::Number>()); |
| } |
| |
| 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); |
| } |
| |
| static Napi::Value CanUnWrap(const Napi::CallbackInfo& info) { |
| Napi::Object wrappedObject = info[0].As<Napi::Object>(); |
| std::string expectedString = info[1].As<Napi::String>(); |
| Test* nativeObject = Test::Unwrap(wrappedObject); |
| std::string strVal = MaybeUnwrap(nativeObject->Getter(info).ToString()); |
| |
| return Napi::Boolean::New(info.Env(), strVal == expectedString); |
| } |
| |
| 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 kTestStaticVoidMethodInternal = |
| Napi::Symbol::New(env, "kTestStaticVoidMethodInternal"); |
| 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("kTestStaticVoidMethodInternal", |
| kTestStaticVoidMethodInternal), |
| 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( |
| "testStaticVoidMethod", &StaticMethodVoidCb, napi_default), |
| StaticMethod(kTestStaticVoidMethodInternal, |
| &StaticMethodVoidCb, |
| napi_default), |
| StaticMethod( |
| "testStaticMethod", &TestStaticMethod, napi_enumerable), |
| StaticMethod(kTestStaticMethodInternal, |
| &TestStaticMethodInternal, |
| napi_default), |
| StaticMethod<&TestStaticVoidMethodT>("testStaticVoidMethodT"), |
| StaticMethod<&TestStaticMethodT>("testStaticMethodT"), |
| StaticMethod<&TestStaticVoidMethodT>( |
| kTestStaticVoidMethodTInternal), |
| StaticMethod<&TestStaticMethodT>(kTestStaticMethodTInternal), |
| StaticMethod("canUnWrap", &CanUnWrap, napi_enumerable), |
| 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; |
| } |
