diff --git a/static_core/plugins/ets/runtime/ani/ani_interaction_api.cpp b/static_core/plugins/ets/runtime/ani/ani_interaction_api.cpp index 8c6bb18b2c566f8dca75ea67568ab667f64e9aeb..f788d36674cf322cef4be32f2ed1ba5089d291c1 100644 --- a/static_core/plugins/ets/runtime/ani/ani_interaction_api.cpp +++ b/static_core/plugins/ets/runtime/ani/ani_interaction_api.cpp @@ -185,10 +185,9 @@ static ClassLinkerContext *GetClassLinkerContext(EtsCoroutine *coroutine) return nullptr; } -static ani_status DoGetInternalClass(ScopedManagedCodeFix &s, EtsClass *klass, EtsClass **result) +static ani_status InitializeClass(ScopedManagedCodeFix &s, EtsClass *klass) { if (klass->IsInitialized()) { - *result = klass; return ANI_OK; } @@ -203,34 +202,9 @@ static ani_status DoGetInternalClass(ScopedManagedCodeFix &s, EtsClass *klass, E } return ANI_ERROR; } - *result = klass; return ANI_OK; } -static ani_status GetInternalClass(ScopedManagedCodeFix &s, ani_class cls, EtsClass **result) -{ - EtsClass *klass = s.ToInternalType(cls); - return DoGetInternalClass(s, klass, result); -} - -static ani_status GetInternalNamespace(ScopedManagedCodeFix &s, ani_namespace ns, EtsNamespace **result) -{ - EtsNamespace *nsp = s.ToInternalType(ns); - EtsClass *klass {}; - ani_status status = DoGetInternalClass(s, nsp->AsClass(), &klass); - *result = EtsNamespace::FromClass(klass); - return status; -} - -static ani_status GetInternalModule(ScopedManagedCodeFix &s, ani_module module, EtsModule **result) -{ - EtsModule *etsModule = s.ToInternalType(module); - EtsClass *klass {}; - ani_status status = DoGetInternalClass(s, etsModule->AsClass(), &klass); - *result = EtsModule::FromClass(klass); - return status; -} - static Value ConstructValueFromFloatingPoint(float val) { return Value(bit_cast(val)); @@ -365,8 +339,14 @@ static ani_status DoGeneralMethodCall(ScopedManagedCodeFix &s, ani_object obj, M m = ResolveVirtualMethod(&s, obj, method); } else if constexpr (std::is_same_v) { m = ToInternalMethod(method); + + ani_status status = InitializeClass(s, m->GetClass()); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); } else if constexpr (std::is_same_v) { m = ToInternalFunction(method); + + ani_status status = InitializeClass(s, m->GetClass()); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); } else { static_assert(!(std::is_same_v || std::is_same_v || std::is_same_v), @@ -439,10 +419,15 @@ static ani_status ClassGetStaticField(ani_env *env, ani_class cls, ani_static_fi CHECK_PTR_ARG(cls); CHECK_PTR_ARG(field); CHECK_PTR_ARG(result); + EtsField *etsField = ToInternalField(field); ANI_CHECK_RETURN_IF_NE(etsField->GetEtsType(), AniTypeInfo::ETS_TYPE_VALUE, ANI_INVALID_TYPE); + ScopedManagedCodeFix s(env); EtsClass *etsClass = s.ToInternalType(cls); + ani_status status = InitializeClass(s, etsClass); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + *result = etsClass->GetStaticFieldPrimitive(etsField); return ANI_OK; } @@ -453,10 +438,15 @@ static ani_status ClassSetStaticField(ani_env *env, ani_class cls, ani_static_fi CHECK_ENV(env); CHECK_PTR_ARG(cls); CHECK_PTR_ARG(field); + EtsField *etsField = ToInternalField(field); ANI_CHECK_RETURN_IF_NE(etsField->GetEtsType(), AniTypeInfo::ETS_TYPE_VALUE, ANI_INVALID_TYPE); + ScopedManagedCodeFix s(env); EtsClass *etsClass = s.ToInternalType(cls); + ani_status status = InitializeClass(s, etsClass); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + etsClass->SetStaticFieldPrimitive(etsField, value); return ANI_OK; } @@ -468,13 +458,17 @@ static ani_status ClassGetStaticFieldByName(ani_env *env, ani_class cls, const c CHECK_PTR_ARG(cls); CHECK_PTR_ARG(name); CHECK_PTR_ARG(result); + ScopedManagedCodeFix s(env); - EtsClass *etsClass; - ani_status status = GetInternalClass(s, cls, &etsClass); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsClass *etsClass = s.ToInternalType(cls); + EtsField *etsField = etsClass->GetStaticFieldIDByName(name, nullptr); ANI_CHECK_RETURN_IF_EQ(etsField, nullptr, ANI_NOT_FOUND); ANI_CHECK_RETURN_IF_NE(etsField->GetEtsType(), AniTypeInfo::ETS_TYPE_VALUE, ANI_INVALID_TYPE); + + ani_status status = InitializeClass(s, etsClass); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + *result = etsClass->GetStaticFieldPrimitive(etsField); return ANI_OK; } @@ -485,13 +479,17 @@ static ani_status ClassSetStaticFieldByName(ani_env *env, ani_class cls, const c CHECK_ENV(env); CHECK_PTR_ARG(cls); CHECK_PTR_ARG(name); + ScopedManagedCodeFix s(env); - EtsClass *etsClass; - ani_status status = GetInternalClass(s, cls, &etsClass); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsClass *etsClass = s.ToInternalType(cls); + EtsField *etsField = etsClass->GetStaticFieldIDByName(name, nullptr); ANI_CHECK_RETURN_IF_EQ(etsField, nullptr, ANI_NOT_FOUND); ANI_CHECK_RETURN_IF_NE(etsField->GetEtsType(), AniTypeInfo::ETS_TYPE_VALUE, ANI_INVALID_TYPE); + + ani_status status = InitializeClass(s, etsClass); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + etsClass->SetStaticFieldPrimitive(etsField, value); return ANI_OK; } @@ -656,9 +654,7 @@ static ani_status GetClassMethod(ani_env *env, ani_class cls, const char *name, EtsMethod **result) { ScopedManagedCodeFix s(PandaEnv::FromAniEnv(env)); - EtsClass *klass; - ani_status status = GetInternalClass(s, cls, &klass); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsClass *klass = s.ToInternalType(cls); return DoGetClassMethod(klass, name, signature, result); } @@ -689,9 +685,7 @@ static ani_status GetNamespaceFunction(ani_env *env, ani_namespace ns, const cha EtsMethod **result) { ScopedManagedCodeFix s(env); - EtsNamespace *etsNs; - ani_status status = GetInternalNamespace(s, ns, &etsNs); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsNamespace *etsNs = EtsNamespace::FromClass(s.ToInternalType(ns)->AsClass()); return DoGetClassMethod(etsNs->AsClass(), name, signature, result); } @@ -699,9 +693,7 @@ static ani_status GetModuleFunction(ani_env *env, ani_module ns, const char *nam EtsMethod **result) { ScopedManagedCodeFix s(env); - EtsModule *etsModule; - ani_status status = GetInternalModule(s, ns, &etsModule); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsModule *etsModule = EtsModule::FromClass(s.ToInternalType(ns)->AsClass()); return DoGetClassMethod(etsModule->AsClass(), name, signature, result); } @@ -734,9 +726,7 @@ static ani_status FindInModule(ani_env *env, ani_module module, const char *targ PandaEnv *pandaEnv = PandaEnv::FromAniEnv(env); ScopedManagedCodeFix s(pandaEnv); - EtsModule *etsModule {}; - ani_status status = GetInternalModule(s, module, &etsModule); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsModule *etsModule = EtsModule::FromClass(s.ToInternalType(module)->AsClass()); PandaString descriptor; ANI_CHECK_RETURN_IF_NE(etsModule->GetModulePrefix(descriptor), ANI_OK, ANI_INVALID_DESCRIPTOR); @@ -772,9 +762,7 @@ ani_status GetVM(ani_env *env, ani_vm **result) static ani_status AllocObject(ScopedManagedCodeFix &s, ani_class cls, ani_object *result) { - EtsClass *klass; - ani_status status = GetInternalClass(s, cls, &klass); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsClass *klass = s.ToInternalType(cls); ANI_CHECK_RETURN_IF_EQ(klass->IsAbstract(), true, ANI_INVALID_TYPE); ANI_CHECK_RETURN_IF_EQ(klass->IsInterface(), true, ANI_INVALID_TYPE); @@ -795,6 +783,10 @@ static ani_status DoNewObject(ani_env *env, ani_class cls, ani_method method, an ani_status status = AllocObject(s, cls, &object); ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsClass *klass = s.ToInternalType(cls); + status = InitializeClass(s, klass); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + // Use any primitive type as template parameter and just ignore the result ani_int tmp; status = DoGeneralMethodCall(s, object, method, &tmp, args); @@ -868,8 +860,6 @@ ani_status Type_GetSuperClass(ani_env *env, ani_type type, ani_class *result) ScopedManagedCodeFix s(env); EtsClass *cls = s.ToInternalType(type); - ani_status status = DoGetInternalClass(s, cls, &cls); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); EtsClass *superCls = cls->GetSuperClass(); if (superCls != nullptr) { @@ -891,12 +881,7 @@ ani_status Type_IsAssignableFrom(ani_env *env, ani_type fromType, ani_type toTyp ScopedManagedCodeFix s(env); EtsClass *toClass = s.ToInternalType(toType); - ani_status status = DoGetInternalClass(s, toClass, &toClass); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); - EtsClass *fromClass = s.ToInternalType(fromType); - status = DoGetInternalClass(s, fromClass, &fromClass); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); *result = toClass->IsAssignableFrom(fromClass) ? ANI_TRUE : ANI_FALSE; return ANI_OK; @@ -972,9 +957,7 @@ NO_UB_SANITIZE static ani_status Namespace_FindNamespace(ani_env *env, ani_names auto pandaEnv = PandaEtsNapiEnv::FromAniEnv(env); ScopedManagedCodeFix s(pandaEnv); - EtsNamespace *etsNs {}; - ani_status status = GetInternalNamespace(s, ns, &etsNs); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsNamespace *etsNs = EtsNamespace::FromClass(s.ToInternalType(ns)->AsClass()); std::string_view nsDescriptor = etsNs->AsClass()->GetDescriptor(); ASSERT(nsDescriptor.size() > 2U); @@ -1004,9 +987,7 @@ NO_UB_SANITIZE static ani_status Namespace_FindClass(ani_env *env, ani_namespace auto pandaEnv = PandaEtsNapiEnv::FromAniEnv(env); ScopedManagedCodeFix s(pandaEnv); - EtsNamespace *etsNs {}; - ani_status status = GetInternalNamespace(s, ns, &etsNs); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsNamespace *etsNs = EtsNamespace::FromClass(s.ToInternalType(ns)->AsClass()); std::string_view nsDescriptor = etsNs->AsClass()->GetDescriptor(); ASSERT(nsDescriptor.size() > 2U); @@ -1035,9 +1016,7 @@ NO_UB_SANITIZE static ani_status Namespace_FindVariable(ani_env *env, ani_namesp CHECK_PTR_ARG(result); ScopedManagedCodeFix s(env); - EtsNamespace *etsNs {}; - ani_status status = GetInternalNamespace(s, ns, &etsNs); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsNamespace *etsNs = EtsNamespace::FromClass(s.ToInternalType(ns)->AsClass()); EtsVariable *variable = etsNs->GetVariabe(variableDescriptor); ANI_CHECK_RETURN_IF_EQ(variable, nullptr, ANI_NOT_FOUND); @@ -1073,9 +1052,7 @@ NO_UB_SANITIZE static ani_status Module_FindVariable(ani_env *env, ani_module mo CHECK_PTR_ARG(result); ScopedManagedCodeFix s(env); - EtsModule *etsModule {}; - ani_status status = GetInternalModule(s, module, &etsModule); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsModule *etsModule = EtsModule::FromClass(s.ToInternalType(module)->AsClass()); EtsVariable *variable = etsModule->GetVariabe(variableDescriptor); ANI_CHECK_RETURN_IF_EQ(variable, nullptr, ANI_NOT_FOUND); @@ -1710,13 +1687,16 @@ static ani_status SetVariableValue(ani_env *env, ani_variable variable, T value) CHECK_ENV(env); CHECK_PTR_ARG(variable); + ScopedManagedCodeFix s(env); EtsVariable *etsVariable = ToInternalVariable(variable); EtsField *etsField = etsVariable->AsField(); ANI_CHECK_RETURN_IF_NE(etsField->GetEtsType(), AniTypeInfo::ETS_TYPE_VALUE, ANI_INVALID_TYPE); + EtsClass *cls = etsField->GetDeclaringClass(); + ani_status status = InitializeClass(s, cls); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); static constexpr auto IS_REF = std::is_same_v; - ScopedManagedCodeFix s(env); if constexpr (IS_REF) { EtsObject *object = s.ToInternalType(value); cls->SetStaticFieldObject(etsField, object); @@ -1836,9 +1816,7 @@ NO_UB_SANITIZE static ani_status Variable_SetValue_Ref(ani_env *env, ani_variabl template static ani_status DoGetField(ScopedManagedCodeFix &s, ani_class cls, const char *name, EtsField **result) { - EtsClass *klass; - ani_status status = GetInternalClass(s, cls, &klass); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsClass *klass = s.ToInternalType(cls); EtsField *field = [&]() { if constexpr (IS_STATIC_FIELD) { @@ -2039,6 +2017,9 @@ NO_UB_SANITIZE static ani_status Class_GetStaticField_Ref(ani_env *env, ani_clas ScopedManagedCodeFix s(env); EtsClass *etsClass = s.ToInternalType(cls); + ani_status status = InitializeClass(s, etsClass); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + auto *etsRes = etsClass->GetStaticFieldObject(etsField); return s.AddLocalRef(etsRes, result); } @@ -2130,6 +2111,9 @@ NO_UB_SANITIZE static ani_status Class_SetStaticField_Ref(ani_env *env, ani_clas ScopedManagedCodeFix s(env); EtsClass *etsClass = s.ToInternalType(cls); + ani_status status = InitializeClass(s, etsClass); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsObject *etsValue = s.ToInternalType(value); etsClass->SetStaticFieldObject(etsField, etsValue); return ANI_OK; @@ -2218,13 +2202,15 @@ NO_UB_SANITIZE static ani_status Class_GetStaticFieldByName_Ref(ani_env *env, an CHECK_PTR_ARG(result); ScopedManagedCodeFix s(env); - EtsClass *klass; - ani_status status = GetInternalClass(s, cls, &klass); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsClass *klass = s.ToInternalType(cls); EtsField *etsField = klass->GetStaticFieldIDByName(name, nullptr); ANI_CHECK_RETURN_IF_EQ(etsField, nullptr, ANI_NOT_FOUND); ANI_CHECK_RETURN_IF_NE(etsField->GetEtsType(), AniTypeInfo::ETS_TYPE_VALUE, ANI_INVALID_TYPE); + + ani_status status = InitializeClass(s, klass); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsObject *etsRes = klass->GetStaticFieldObject(etsField); return s.AddLocalRef(etsRes, result); } @@ -2310,14 +2296,15 @@ NO_UB_SANITIZE static ani_status Class_SetStaticFieldByName_Ref(ani_env *env, an CHECK_PTR_ARG(value); ScopedManagedCodeFix s(env); - EtsClass *klass; - ani_status status = GetInternalClass(s, cls, &klass); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsClass *klass = s.ToInternalType(cls); EtsField *etsField = klass->GetStaticFieldIDByName(name, nullptr); ANI_CHECK_RETURN_IF_EQ(etsField, nullptr, ANI_NOT_FOUND); ANI_CHECK_RETURN_IF_NE(etsField->GetEtsType(), AniTypeInfo::ETS_TYPE_VALUE, ANI_INVALID_TYPE); + ani_status status = InitializeClass(s, klass); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsObject *etsValue = s.ToInternalType(value); klass->SetStaticFieldObject(etsField, etsValue); return ANI_OK; @@ -4762,7 +4749,11 @@ static ani_status DoVariableGetValue(ani_env *env, ani_variable variable, R *res EtsVariable *internalVariable = ToInternalVariable(variable); EtsField *field = internalVariable->AsField(); ANI_CHECK_RETURN_IF_NE(field->GetEtsType(), AniTypeInfo::ETS_TYPE_VALUE, ANI_INVALID_TYPE); + EtsClass *cls = field->GetDeclaringClass(); + ani_status status = InitializeClass(s, cls); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + Res etsRes {}; if constexpr (IS_REF) { etsRes = cls->GetStaticFieldObject(field); @@ -6005,9 +5996,7 @@ NO_UB_SANITIZE static ani_status Namespace_FindEnum(ani_env *env, ani_namespace PandaEnv *pandaEnv = PandaEnv::FromAniEnv(env); ScopedManagedCodeFix s(env); - EtsNamespace *etsNs; - ani_status status = GetInternalNamespace(s, ns, &etsNs); - ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsNamespace *etsNs = EtsNamespace::FromClass(s.ToInternalType(ns)->AsClass()); PandaString enumDescriptorPandStr = Mangle::ConvertDescriptor(enumDescriptor); if (!enumDescriptorPandStr.empty() && enumDescriptorPandStr[0] == 'L') { @@ -6045,6 +6034,9 @@ static ani_status GetArrayFromEnum(ScopedManagedCodeFix &s, ani_enum enm, const ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); EtsClass *cls = field->GetDeclaringClass(); + status = InitializeClass(s, cls); + ANI_CHECK_RETURN_IF_NE(status, ANI_OK, status); + EtsObject *etsObject = cls->GetStaticFieldObject(field); *result = EtsObjectArray::FromCoreType(etsObject->GetCoreType()); return ANI_OK; diff --git a/static_core/plugins/ets/tests/ani/ani_gtest/ani_gtest.h b/static_core/plugins/ets/tests/ani/ani_gtest/ani_gtest.h index 1c407443a4dd7daac4dfe7f87ef2882db59eee60..e3d3c2ca2d1206579e8aeead9828ebe681e2a4df 100644 --- a/static_core/plugins/ets/tests/ani/ani_gtest/ani_gtest.h +++ b/static_core/plugins/ets/tests/ani/ani_gtest/ani_gtest.h @@ -23,7 +23,7 @@ #include "libpandabase/macros.h" #include "plugins/ets/runtime/ani/ani.h" -#include "plugins/ets/runtime/napi/ets_napi.h" +#include "plugins/ets/runtime/ani/scoped_objects_fix.h" namespace ark::ets::ani::testing { @@ -137,6 +137,24 @@ public: result.resize(sz); } + bool IsRuntimeClassInitialized(std::string_view classDescriptor, bool isClass = true) + { + PandaString desc; + if (isClass) { + desc = Mangle::ConvertDescriptor(classDescriptor, true); + } else { + desc = Mangle::ConvertDescriptor(std::string(classDescriptor) + ".ETSGLOBAL", true); + } + PandaEnv *pandaEnv = PandaEnv::FromAniEnv(env_); + ScopedManagedCodeFix s(pandaEnv); + + EtsClassLinker *classLinker = pandaEnv->GetEtsVM()->GetClassLinker(); + EtsClass *klass = classLinker->GetClass(desc.c_str(), true, GetClassLinkerContext(s.GetCoroutine())); + ASSERT(klass); + + return klass->IsInitialized(); + } + protected: virtual std::vector GetExtraAniOptions() { @@ -236,6 +254,20 @@ private: } // NOLINTEND(cppcoreguidelines-pro-type-vararg) + static ClassLinkerContext *GetClassLinkerContext(ark::ets::EtsCoroutine *coroutine) + { + auto stack = StackWalker::Create(coroutine); + if (!stack.HasFrame()) { + return nullptr; + } + + auto *method = ark::ets::EtsMethod::FromRuntimeMethod(stack.GetMethod()); + if (method != nullptr) { + return method->GetClass()->GetLoadContext(); + } + return nullptr; + } + protected: ani_env *env_ {nullptr}; // NOLINT(misc-non-private-member-variables-in-classes) ani_vm *vm_ {nullptr}; // NOLINT(misc-non-private-member-variables-in-classes) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_bool_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_bool_test.cpp index a8579da1506e59bddf8db876e8dc1bd219b231e3..735af810db184d4ec55e7f53f4fc38ab15be8711 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_bool_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_bool_test.cpp @@ -334,5 +334,33 @@ TEST_F(CallStaticMethodTest, call_static_method_bool_combine_scenes_8) ASSERT_EQ(env_->Class_CallStaticMethod_Boolean_A(cls, method2, &valueA, args), ANI_OK); ASSERT_EQ(valueA, ANI_FALSE); } + +TEST_F(CallStaticMethodTest, check_initialization_bool) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_bool_test.Operations")); + ani_boolean value {}; + ASSERT_EQ(env_->Class_CallStaticMethod_Boolean(cls, method, &value, ANI_TRUE, ANI_FALSE), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_bool_test.Operations")); +} + +TEST_F(CallStaticMethodTest, check_initialization_bool_a) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_bool_test.Operations")); + ani_boolean value {}; + ani_value args[2U]; + args[0U].z = ANI_TRUE; + args[1U].z = ANI_FALSE; + ASSERT_EQ(env_->Class_CallStaticMethod_Boolean_A(cls, method, &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_bool_test.Operations")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_byte_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_byte_test.cpp index b92ac1b07a897afec745ac247ebe211fa3fae319..5df997b67da03a9e67aaaa7b6dfd8df502cfe81d 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_byte_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_byte_test.cpp @@ -323,5 +323,33 @@ TEST_F(CallStaticMethodTest, call_static_method_byte_combine_scenes_8) ASSERT_EQ(env_->Class_CallStaticMethod_Byte_A(cls, method2, &valueA, args), ANI_OK); ASSERT_EQ(valueA, VAL2 - VAL1); } + +TEST_F(CallStaticMethodTest, check_initialization_byte) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_byte_test.Operations")); + ani_byte value {}; + ASSERT_EQ(env_->Class_CallStaticMethod_Byte(cls, method, &value, VAL1, VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_byte_test.Operations")); +} + +TEST_F(CallStaticMethodTest, check_initialization_byte_a) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_byte_test.Operations")); + ani_byte value {}; + ani_value args[2U]; + args[0U].b = VAL1; + args[1U].b = VAL2; + ASSERT_EQ(env_->Class_CallStaticMethod_Byte_A(cls, method, &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_byte_test.Operations")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_char_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_char_test.cpp index eaca029831aaba31d58ea526c254b7eeea517928..2c8ee22b3dd604ee74c465aa0851a721de08f390 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_char_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_char_test.cpp @@ -352,5 +352,33 @@ TEST_F(CallStaticMethodTest, call_static_method_char_combine_scenes_8) ASSERT_EQ(env_->Class_CallStaticMethod_Char_A(cls, method2, &valueA, args), ANI_OK); ASSERT_EQ(valueA, 'C' - 'A'); } + +TEST_F(CallStaticMethodTest, check_initialization_char) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_char_test.Operations")); + ani_char value {}; + ASSERT_EQ(env_->Class_CallStaticMethod_Char(cls, method, &value, 'A', 'C'), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_char_test.Operations")); +} + +TEST_F(CallStaticMethodTest, check_initialization_char_a) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_char_test.Operations")); + ani_char value {}; + ani_value args[2U]; + args[0U].c = 'A'; + args[1U].c = 'B'; + ASSERT_EQ(env_->Class_CallStaticMethod_Char_A(cls, method, &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_char_test.Operations")); +} + } // namespace ark::ets::ani::testing - // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file + // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_double_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_double_test.cpp index 47d30336482a7a43677a8bc9445898f043344f31..9196d5f12f0e0f996878994d7cad056ff9b72e4f 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_double_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_double_test.cpp @@ -325,5 +325,33 @@ TEST_F(CallStaticMethodTest, call_static_method_double_combine_scenes_8) ASSERT_EQ(env_->Class_CallStaticMethod_Double_A(cls, method2, &valueA, args), ANI_OK); ASSERT_EQ(valueA, VAL2 - VAL1); } + +TEST_F(CallStaticMethodTest, check_initialization_double) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_double_test.Operations")); + ani_double value {}; + ASSERT_EQ(env_->Class_CallStaticMethod_Double(cls, method, &value, VAL1, VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_double_test.Operations")); +} + +TEST_F(CallStaticMethodTest, check_initialization_double_a) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_double_test.Operations")); + ani_double value {}; + ani_value args[2U]; + args[0U].d = VAL1; + args[1U].d = VAL2; + ASSERT_EQ(env_->Class_CallStaticMethod_Double_A(cls, method, &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_double_test.Operations")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_float_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_float_test.cpp index 13ea5727d18378a41484236e469344df2d708490..69bce1d0bd461bc65c950628f6b43c98e26ee073 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_float_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_float_test.cpp @@ -326,5 +326,33 @@ TEST_F(CallStaticMethodTest, call_static_method_float_combine_scenes_8) ASSERT_EQ(env_->Class_CallStaticMethod_Float_A(cls, method2, &valueA, args), ANI_OK); ASSERT_EQ(valueA, FLOAT_VAL2 - FLOAT_VAL1); } + +TEST_F(CallStaticMethodTest, check_initialization_float) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_float_test.Operations")); + ani_float value {}; + ASSERT_EQ(env_->Class_CallStaticMethod_Float(cls, method, &value, FLOAT_VAL1, FLOAT_VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_float_test.Operations")); +} + +TEST_F(CallStaticMethodTest, check_initialization_float_a) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_float_test.Operations")); + ani_float value {}; + ani_value args[2U]; + args[0U].f = FLOAT_VAL1; + args[1U].f = FLOAT_VAL2; + ASSERT_EQ(env_->Class_CallStaticMethod_Float_A(cls, method, &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_float_test.Operations")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_int_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_int_test.cpp index bbd86dc90dc023ebb23675d40297ef4531c1c965..55b9d03da2217845fd999eb4ff8aa03719485276 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_int_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_int_test.cpp @@ -351,5 +351,33 @@ TEST_F(CallStaticMethodTest, call_static_method_int_combine_scenes_8) ASSERT_EQ(env_->Class_CallStaticMethod_Int_A(cls, method2, &valueA, args), ANI_OK); ASSERT_EQ(valueA, VAL2 - VAL1); } + +TEST_F(CallStaticMethodTest, check_initialization_int) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_int_test.Operations")); + ani_int value {}; + ASSERT_EQ(env_->Class_CallStaticMethod_Int(cls, method, &value, VAL1, VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_int_test.Operations")); +} + +TEST_F(CallStaticMethodTest, check_initialization_int_a) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_int_test.Operations")); + ani_int value {}; + ani_value args[2U]; + args[0U].i = VAL1; + args[1U].i = VAL2; + ASSERT_EQ(env_->Class_CallStaticMethod_Int_A(cls, method, &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_int_test.Operations")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_long_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_long_test.cpp index 62bccd6535dd251ec47207c308ddf1a85b13a516..82cd20f0883a7b33adf222c0fd151d6850c7dc01 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_long_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_long_test.cpp @@ -328,5 +328,33 @@ TEST_F(CallStaticMethodTest, call_static_method_long_combine_scenes_8) ASSERT_EQ(env_->Class_CallStaticMethod_Long_A(cls, method2, &valueA, args), ANI_OK); ASSERT_EQ(valueA, VAL2 - VAL1); } + +TEST_F(CallStaticMethodTest, check_initialization_long) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_long_test.Operations")); + ani_long value {}; + ASSERT_EQ(env_->Class_CallStaticMethod_Long(cls, method, &value, VAL1, VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_long_test.Operations")); +} + +TEST_F(CallStaticMethodTest, check_initialization_long_a) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_long_test.Operations")); + ani_long value {}; + ani_value args[2U]; + args[0U].l = VAL1; + args[1U].l = VAL2; + ASSERT_EQ(env_->Class_CallStaticMethod_Long_A(cls, method, &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_long_test.Operations")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_ref_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_ref_test.cpp index 5da2e67a696e094b84cb184243f1a16c59f8ec6a..17aeac003e4aa4ae726cbaa9e10f8b75a84c4a59 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_ref_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_ref_test.cpp @@ -467,6 +467,34 @@ TEST_F(CallStaticMethodTest, call_static_method_ref_combine_scenes_8) ASSERT_EQ(env_->Class_CallStaticMethod_Ref_A(cls, method2, &valueA, args), ANI_OK); CheckRefUp(valueA); } + +TEST_F(CallStaticMethodTest, check_initialization_ref) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodDataButton(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_ref_test.Phone")); + ani_ref value {}; + ASSERT_EQ(env_->Class_CallStaticMethod_Ref(cls, method, &value, VAL1, VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_ref_test.Phone")); +} + +TEST_F(CallStaticMethodTest, check_initialization_ref_a) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodDataButton(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_ref_test.Phone")); + ani_ref value {}; + ani_value args[2U]; + args[0U].i = VAL1; + args[1U].i = VAL2; + ASSERT_EQ(env_->Class_CallStaticMethod_Ref_A(cls, method, &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_ref_test.Phone")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_short_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_short_test.cpp index 2ed9fe618a39e0fb09fc0ebe58d4e28226c7f506..01fae1a8eb8e872c04e13c99014aedb993c341a2 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_short_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_short_test.cpp @@ -323,5 +323,33 @@ TEST_F(CallStaticMethodTest, call_static_method_short_combine_scenes_8) ASSERT_EQ(env_->Class_CallStaticMethod_Short_A(cls, method2, &valueA, args), ANI_OK); ASSERT_EQ(valueA, VAL2 - VAL1); } + +TEST_F(CallStaticMethodTest, check_initialization_short) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_short_test.Operations")); + ani_short value {}; + ASSERT_EQ(env_->Class_CallStaticMethod_Short(cls, method, &value, VAL1, VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_short_test.Operations")); +} + +TEST_F(CallStaticMethodTest, check_initialization_short_a) +{ + ani_class cls {}; + ani_static_method method {}; + GetMethodData(&cls, &method); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_short_test.Operations")); + ani_short value {}; + ani_value args[2U]; + args[0U].s = VAL1; + args[1U].s = VAL2; + ASSERT_EQ(env_->Class_CallStaticMethod_Short_A(cls, method, &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_short_test.Operations")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_void_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_void_test.cpp index ad7ecb89df899bba3ad37f476800f9b9ac44f082..aa9a0efe55ebeacae5db1e7e0aacd757c760deb7 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_void_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/call_static_method_void_test.cpp @@ -379,5 +379,33 @@ TEST_F(CallStaticMethodTest, call_static_method_void_combine_scenes_8) GetCount(cls, getMethod, &valueA); ASSERT_EQ(valueA, VAL2 - VAL1); } + +TEST_F(CallStaticMethodTest, check_initialization_void) +{ + ani_class cls {}; + ani_static_method voidMethod {}; + ani_static_method getMethod {}; + GetMethodData(&cls, &voidMethod, &getMethod); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_void_test.Operations")); + ASSERT_EQ(env_->Class_CallStaticMethod_Void(cls, voidMethod, VAL1, VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_void_test.Operations")); +} + +TEST_F(CallStaticMethodTest, check_initialization_void_a) +{ + ani_class cls {}; + ani_static_method voidMethod {}; + ani_static_method getMethod {}; + GetMethodData(&cls, &voidMethod, &getMethod); + + ASSERT_FALSE(IsRuntimeClassInitialized("call_static_method_void_test.Operations")); + ani_value args[2U]; + args[0U].i = VAL1; + args[1U].i = VAL2; + ASSERT_EQ(env_->Class_CallStaticMethod_Void_A(cls, voidMethod, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("call_static_method_void_test.Operations")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_boolean_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_boolean_test.cpp index 9159cee8e7d81b4556e89adae6060227e2f3e6fd..99c704c327224ffb939f4b41f1750d3e58fdc17a 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_boolean_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_boolean_test.cpp @@ -444,5 +444,41 @@ TEST_F(ClassCallStaticMethodByNameBooleanTest, call_static_method_by_name_bool_c ASSERT_EQ(env_->Class_CallStaticMethodByName_Boolean_A(cls, "callPrivateMethod", "ZZ:Z", &valueA, args), ANI_OK); ASSERT_EQ(valueA, ANI_FALSE); } + +TEST_F(ClassCallStaticMethodByNameBooleanTest, check_initialization_boolean) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_boolean_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_boolean_test.G")); + ani_boolean value {}; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Boolean(cls, "publicMethodx", "zz:z", &value, ANI_TRUE, ANI_FALSE), + ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_boolean_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Boolean(cls, "publicMethod", "zz:z", &value, ANI_TRUE, ANI_FALSE), + ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_boolean_test.G")); +} + +TEST_F(ClassCallStaticMethodByNameBooleanTest, check_initialization_boolean_a) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_boolean_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_boolean_test.G")); + ani_boolean value {}; + ani_value args[2U]; + args[0U].z = ANI_TRUE; + args[1U].z = ANI_FALSE; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Boolean_A(cls, "publicMethodx", "zz:z", &value, args), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_boolean_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Boolean_A(cls, "publicMethod", "zz:z", &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_boolean_test.G")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_byte_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_byte_test.cpp index 039bc126b328d30f9dabc730f003a80a2c571b76..0fc0cce49af9d44944862f5b1b7d1e53e2b5246f 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_byte_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_byte_test.cpp @@ -413,5 +413,39 @@ TEST_F(ClassCallStaticMethodByNameTest, call_static_method_by_name_byte_combine_ ASSERT_EQ(env_->Class_CallStaticMethodByName_Byte_A(cls, "callPrivateMethod", "BB:B", &valueA, args), ANI_OK); ASSERT_EQ(valueA, VAL2 - VAL1); } + +TEST_F(ClassCallStaticMethodByNameTest, check_initialization_byte) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_byte_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_byte_test.G")); + ani_byte value {}; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Byte(cls, "publicMethodx", "bb:b", &value, VAL1, VAL2), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_byte_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Byte(cls, "publicMethod", "bb:b", &value, VAL1, VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_byte_test.G")); +} + +TEST_F(ClassCallStaticMethodByNameTest, check_initialization_byte_a) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_byte_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_byte_test.G")); + ani_byte value {}; + ani_value args[2U]; + args[0U].b = VAL1; + args[1U].b = VAL2; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Byte(cls, "publicMethodx", "bb:b", &value, VAL1, VAL2), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_byte_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Byte_A(cls, "publicMethod", "bb:b", &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_byte_test.G")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_char_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_char_test.cpp index d9ff9d055bb1867be2a3e31b615fd77b6f5b22c3..3193f468e6855da59a7ee3616e802e2ed57be21b 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_char_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_char_test.cpp @@ -464,5 +464,39 @@ TEST_F(ClassCallStaticMethodByNameTest, call_static_method_by_name_char_combine_ ASSERT_EQ(env_->Class_CallStaticMethodByName_Char_A(cls, "callPrivateMethod", "CC:C", &valueA, args), ANI_OK); ASSERT_EQ(valueA, 'C' - 'A'); } + +TEST_F(ClassCallStaticMethodByNameTest, check_initialization_char) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_char_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_char_test.G")); + ani_char value {}; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Char(cls, "publicMethodx", "cc:c", &value, 'A', 'B'), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_char_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Char(cls, "publicMethod", "cc:c", &value, 'A', 'B'), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_char_test.G")); +} + +TEST_F(ClassCallStaticMethodByNameTest, check_initialization_char_a) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_char_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_char_test.G")); + ani_char value {}; + ani_value args[2U]; + args[0U].c = 'A'; + args[1U].c = 'B'; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Char(cls, "publicMethodx", "cc:c", &value, 'A', 'B'), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_char_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Char_A(cls, "publicMethod", "cc:c", &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_char_test.G")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_double_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_double_test.cpp index 1719574ee8f4100bce43afd208a355f8e95fb2bf..877cf94da7354990fd469f6429c3472ab60081a6 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_double_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_double_test.cpp @@ -382,5 +382,40 @@ TEST_F(ClassCallStaticMethodByNameDoubleTest, call_static_method_by_name_double_ ASSERT_EQ(env_->Class_CallStaticMethodByName_Double_A(cls, "callPrivateMethod", "DD:D", &valueA, args), ANI_OK); ASSERT_EQ(valueA, VAL2 - VAL1); } + +TEST_F(ClassCallStaticMethodByNameDoubleTest, check_initialization_double) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_double_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_double_test.G")); + ani_double value {}; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Double(cls, "publicMethodx", "dd:d", &value, VAL1, VAL2), + ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_double_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Double(cls, "publicMethod", "dd:d", &value, VAL1, VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_double_test.G")); +} + +TEST_F(ClassCallStaticMethodByNameDoubleTest, check_initialization_double_a) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_double_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_double_test.G")); + ani_double value {}; + ani_value args[2U]; + args[0U].d = VAL1; + args[1U].d = VAL2; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Double_A(cls, "publicMethodx", "dd:d", &value, args), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_double_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Double_A(cls, "publicMethod", "dd:d", &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_double_test.G")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_float_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_float_test.cpp index 3b12769c92d33d3c6ceec535683a090232b769c7..64011c91fa45ac184ccc4bcc814a55a5f2791cc9 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_float_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_float_test.cpp @@ -394,5 +394,41 @@ TEST_F(ClassCallStaticMethodByNameFloatTest, call_static_method_by_name_float_co ASSERT_EQ(env_->Class_CallStaticMethodByName_Float_A(cls, "callPrivateMethod", "FF:F", &valueA, args), ANI_OK); ASSERT_EQ(valueA, FLOAT_VAL2 - FLOAT_VAL1); } + +TEST_F(ClassCallStaticMethodByNameFloatTest, check_initialization_float) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_float_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_float_test.G")); + ani_float value {}; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Float(cls, "publicMethodx", "ff:f", &value, FLOAT_VAL1, FLOAT_VAL2), + ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_float_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Float(cls, "publicMethod", "ff:f", &value, FLOAT_VAL1, FLOAT_VAL2), + ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_float_test.G")); +} + +TEST_F(ClassCallStaticMethodByNameFloatTest, check_initialization_float_a) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_float_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_float_test.G")); + ani_float value {}; + ani_value args[2U]; + args[0U].d = FLOAT_VAL1; + args[1U].d = FLOAT_VAL1; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Float_A(cls, "publicMethodx", "ff:f", &value, args), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_float_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Float_A(cls, "publicMethod", "ff:f", &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_float_test.G")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_int_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_int_test.cpp index db93f3c764e81e43d1972c472a4659d321ea96e9..712848385c9f5fcae7863bfc68b0e18b86e0be3e 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_int_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_int_test.cpp @@ -400,5 +400,39 @@ TEST_F(ClassCallStaticMethodByNameIntTest, call_static_method_by_name_int_combin ASSERT_EQ(env_->Class_CallStaticMethodByName_Int_A(cls, "callPrivateMethod", "II:I", &valueA, args), ANI_OK); ASSERT_EQ(valueA, VAL4 - VAL3); } + +TEST_F(ClassCallStaticMethodByNameIntTest, check_initialization_int) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_int_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_int_test.G")); + ani_int value {}; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Int(cls, "publicMethodx", "ii:i", &value, VAL3, VAL4), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_int_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Int(cls, "publicMethod", "ii:i", &value, VAL3, VAL4), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_int_test.G")); +} + +TEST_F(ClassCallStaticMethodByNameIntTest, check_initialization_int_a) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_int_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_int_test.G")); + ani_int value {}; + ani_value args[2U]; + args[0U].i = VAL3; + args[1U].i = VAL4; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Int_A(cls, "publicMethodx", "ii:i", &value, args), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_int_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Int_A(cls, "publicMethod", "ii:i", &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_int_test.G")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_long_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_long_test.cpp index 54e2d95df38ccf13b1cd0d264534968b50677bb3..cb28c524586460eae8e50f1cbd980650c2517ff1 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_long_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_long_test.cpp @@ -386,5 +386,39 @@ TEST_F(ClassCallStaticMethodByNameLongTest, call_static_method_by_name_long_comb ASSERT_EQ(env_->Class_CallStaticMethodByName_Long_A(cls, "callPrivateMethod", "JJ:J", &valueA, args), ANI_OK); ASSERT_EQ(valueA, VAL2 - VAL1); } + +TEST_F(ClassCallStaticMethodByNameLongTest, check_initialization_long) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_long_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_long_test.G")); + ani_long value {}; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Long(cls, "publicMethodx", "ll:l", &value, VAL1, VAL2), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_long_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Long(cls, "publicMethod", "ll:l", &value, VAL1, VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_long_test.G")); +} + +TEST_F(ClassCallStaticMethodByNameLongTest, check_initialization_long_a) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_long_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_long_test.G")); + ani_long value {}; + ani_value args[2U]; + args[0U].l = VAL1; + args[1U].l = VAL2; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Long_A(cls, "publicMethodx", "ll:l", &value, args), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_long_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Long_A(cls, "publicMethod", "ll:l", &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_long_test.G")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_ref_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_ref_test.cpp index 9ae64fd9b5bb7286833a3ba7ea34db3bfc464b48..beef334fb7a073d0c666a079d087bb6440820ff6 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_ref_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_ref_test.cpp @@ -515,6 +515,44 @@ TEST_F(ClassCallStaticMethodByNameRefTest, call_static_method_by_name_ref_combin ANI_OK); CheckRefUp(valueA); } + +TEST_F(ClassCallStaticMethodByNameRefTest, check_initialization_ref) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_ref_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_ref_test.G")); + ani_ref value {}; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Ref(cls, "publicMethodx", "ii:C{std.core.String}", &value, VAL3, VAL4), + ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_ref_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Ref(cls, "publicMethod", "ii:C{std.core.String}", &value, VAL3, VAL4), + ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_ref_test.G")); +} + +TEST_F(ClassCallStaticMethodByNameRefTest, check_initialization_ref_a) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_ref_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_ref_test.G")); + ani_ref value {}; + ani_value args[2U]; + args[0U].i = VAL3; + args[1U].i = VAL4; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Ref_A(cls, "publicMethodx", "ii:C{std.core.String}", &value, args), + ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_ref_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Ref_A(cls, "publicMethod", "ii:C{std.core.String}", &value, args), + ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_ref_test.G")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_short_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_short_test.cpp index 018795c911f044d41018a0f9057a6acf0e9c4417..ce72eebce00250d1b388e1c7fe8f27c932bc9e35 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_short_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_short_test.cpp @@ -430,5 +430,40 @@ TEST_F(ClassCallStaticMethodByNameShortTest, call_static_method_by_name_short_co ASSERT_EQ(env_->Class_CallStaticMethodByName_Short_A(cls, "callPrivateMethod", "SS:S", &valueA, args), ANI_OK); ASSERT_EQ(valueA, VAL2 - VAL1); } + +TEST_F(ClassCallStaticMethodByNameShortTest, check_initialization_short) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_short_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_short_test.G")); + ani_short value {}; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Short(cls, "publicMethodx", "ss:s", &value, VAL1, VAL2), + ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_short_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Short(cls, "publicMethod", "ss:s", &value, VAL1, VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_short_test.G")); +} + +TEST_F(ClassCallStaticMethodByNameShortTest, check_initialization_short_a) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_short_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_short_test.G")); + ani_short value {}; + ani_value args[2U]; + args[0U].s = VAL1; + args[1U].s = VAL2; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Short_A(cls, "publicMethodx", "ss:s", &value, args), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_short_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Short_A(cls, "publicMethod", "ss:s", &value, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_short_test.G")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_void_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_void_test.cpp index 39b105849fd260552d7c888b8eeda21c110f12ca..c6c3711a50def31a5ba75e9d922b8bff6f86bdf3 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_void_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_call_static_method_by_name_void_test.cpp @@ -383,6 +383,38 @@ TEST_F(ClassCallStaticMethodByNameVoidTest, call_static_method_by_name_void_comb GetCount(cls, &valueA); ASSERT_EQ(valueA, VAL2 - VAL1); } + +TEST_F(ClassCallStaticMethodByNameVoidTest, check_initialization_void) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_void_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_void_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Void(cls, "publicMethodx", "ii:", VAL1, VAL2), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_void_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Void(cls, "publicMethod", "ii:", VAL1, VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_void_test.G")); +} + +TEST_F(ClassCallStaticMethodByNameVoidTest, check_initialization_void_a) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_call_static_method_by_name_void_test.G", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_void_test.G")); + ani_value args[2U]; + args[0U].i = VAL1; + args[1U].i = VAL2; + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Void_A(cls, "publicMethodx", "ii:", args), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_call_static_method_by_name_void_test.G")); + + ASSERT_EQ(env_->Class_CallStaticMethodByName_Void_A(cls, "publicMethod", "ii:", args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_call_static_method_by_name_void_test.G")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_field_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_field_test.cpp index 24add46a4c2f83e5c4fc45737f5b386b43b7cd95..23b36ebf6a3fce918346470d610d8d53fca17f15 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_field_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_field_test.cpp @@ -192,4 +192,15 @@ TEST_F(ClassFindFieldTest, invalid_argument3) ASSERT_EQ(env_->Class_FindField(cls, "x", nullptr), ANI_INVALID_ARGS); } +TEST_F(ClassFindFieldTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_find_field_test.Point", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_field_test.Point")); + ani_field field {}; + ASSERT_EQ(env_->Class_FindField(cls, "x", &field), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_field_test.Point")); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_indexable_getter_setter_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_indexable_getter_setter_test.cpp index 14a654d2c7a7debcca178ddacdc58501a96f5200..f5d9b6eecc370b49ce93a4ab6200649553fecdd1 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_indexable_getter_setter_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_indexable_getter_setter_test.cpp @@ -35,7 +35,7 @@ TEST_F(FindIndexableGetterTest, get_method) ASSERT_EQ(env_->Class_FindIndexableGetter(cls, "D:I", &method), ANI_NOT_FOUND); } -TEST_F(FindIndexableGetterTest, set_method) +TEST_F(FindIndexableSetterTest, set_method) { ani_class cls; ASSERT_EQ(env_->FindClass("Lclass_find_indexable_getter_setter_test/A;", &cls), ANI_OK); @@ -61,4 +61,26 @@ TEST_F(FindIndexableSetterGetterTest, invalid_args) ASSERT_EQ(env_->Class_FindIndexableGetter(nullptr, "II:V", &method), ANI_INVALID_ARGS); } +TEST_F(FindIndexableGetterTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_find_indexable_getter_setter_test.A", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_indexable_getter_setter_test.A")); + ani_method method {}; + ASSERT_EQ(env_->Class_FindIndexableGetter(cls, "D:Lclass_find_indexable_getter_setter_test/A;", &method), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_indexable_getter_setter_test.A")); +} + +TEST_F(FindIndexableSetterTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_find_indexable_getter_setter_test.A", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_indexable_getter_setter_test.A")); + ani_method method {}; + ASSERT_EQ(env_->Class_FindIndexableSetter(cls, "DZ:V", &method), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_indexable_getter_setter_test.A")); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_iterator_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_iterator_test.cpp index 6e9e53b6cc3330483983a04de4c341b2cf4c871f..109b67f604e9438c20c016fb448c690d85b787f0 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_iterator_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_iterator_test.cpp @@ -63,4 +63,15 @@ TEST_F(ClassFindIteratorTest, invalid_argument1) ASSERT_EQ(env_->Class_FindIterator(cls, nullptr), ANI_INVALID_ARGS); } +TEST_F(ClassFindIteratorTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_find_iterator_test.ops.Singleton", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_iterator_test.ops.Singleton")); + ani_method method {}; + ASSERT_EQ(env_->Class_FindIterator(cls, &method), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_iterator_test.ops.Singleton")); +} + } // namespace ark::ets::ani::testing \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_method_in_module_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_method_in_module_test.cpp index 619ed898da954d61eb8230e7a5995f726977c875..f48112274c93f50e05be2e077dd28dc709d423f3 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_method_in_module_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_method_in_module_test.cpp @@ -84,5 +84,13 @@ TEST_F(ClassFindMethodInModuleTest, find_method_combine_scenes_001) ASSERT_EQ(sum, value1 + value2); } +TEST_F(ClassFindMethodInModuleTest, check_initialization) +{ + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.class_find_method_in_module_test.nsa.A")); + ani_class cls {}; + ASSERT_EQ(env_->FindClass("@abcModule.class_find_method_in_module_test.nsa.A", &cls), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.class_find_method_in_module_test.nsa.A")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_method_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_method_test.cpp index 203afa9ba3f212ded70be5a3ebdd624620e49848..1d0895dad14eae1e7a385d9f6bdc7f1b1e1e20ae 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_method_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_method_test.cpp @@ -1129,5 +1129,16 @@ TEST_F(ClassFindMethodTest, static_no_duplicate) ASSERT_EQ(env_->Class_FindMethod(baseCls, "notOverloaded", nullptr, &method), ANI_OK); } +TEST_F(ClassFindMethodTest, check_initalization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("test.NotOverloaded", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("test.NotOverloaded")); + ani_method method {}; + ASSERT_EQ(env_->Class_FindMethod(cls, "notOverloaded", nullptr, &method), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("test.NotOverloaded")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_setter_getter_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_setter_getter_test.cpp index a0936dd8e4936abe9e449b403da0718a58acd6d7..422cccc29c049400649a56bd4718023f66a39942 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_setter_getter_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_setter_getter_test.cpp @@ -91,4 +91,26 @@ TEST_F(FindGetterSetterTest, invalid_args) ASSERT_EQ(env_->Class_FindGetter(nullptr, "field", &method), ANI_INVALID_ARGS); } +TEST_F(FindSetterTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_find_setter_getter_test.ExplicitMethods", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_setter_getter_test.ExplicitMethods")); + ani_method method {}; + ASSERT_EQ(env_->Class_FindSetter(cls, "age", &method), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_setter_getter_test.ExplicitMethods")); +} + +TEST_F(FindGetterTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_find_setter_getter_test.ExplicitMethods", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_setter_getter_test.ExplicitMethods")); + ani_method method {}; + ASSERT_EQ(env_->Class_FindGetter(cls, "age", &method), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_setter_getter_test.ExplicitMethods")); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_static_field_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_static_field_test.cpp index 0ebce4a3eb6a306116d749239665986d972557f2..b6ffb435d29bd2f08556c5c9f317982975298a61 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_static_field_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_find_static_field_test.cpp @@ -52,4 +52,15 @@ TEST_F(ClassFindStaticFieldTest, invalid_argument3) ASSERT_EQ(env_->Class_FindStaticField(cls, "instance", nullptr), ANI_INVALID_ARGS); } +TEST_F(ClassFindStaticFieldTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_find_static_field_test.Singleton", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_static_field_test.Singleton")); + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "instance", &field), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("class_find_static_field_test.Singleton")); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_boolean_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_boolean_test.cpp index a84cd3396203166a6dbc419be1a2fe1db8284efe..cf2a701a7b723f376ffa6877b0d7dc7a68f6bed2 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_boolean_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_boolean_test.cpp @@ -188,6 +188,21 @@ TEST_F(ClassGetStaticFieldBooleanTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_boolean_test/TestBooleanFinal;", "boolean_value"); } + +TEST_F(ClassGetStaticFieldBooleanTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_boolean_test.TestBooleanFinal", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "boolean_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_boolean_test.TestBooleanFinal")); + ani_boolean boolValue {}; + ASSERT_EQ(env_->Class_GetStaticField_Boolean(cls, field, &boolValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_boolean_test.TestBooleanFinal")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_bool_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_bool_test.cpp index d51d32b13cd2a573841141bd3d925266850357b7..40b0e727cf6593b47bc0fdfaed6273f3390ec2d6 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_bool_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_bool_test.cpp @@ -143,6 +143,22 @@ TEST_F(ClassGetStaticFieldByNameBoolTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_by_name_bool_test/BoolStaticFinal;", "bool_value"); } + +TEST_F(ClassGetStaticFieldByNameBoolTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_by_name_bool_test.BoolStaticA", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_bool_test.BoolStaticA")); + ani_boolean boolValue {}; + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Boolean(cls, "bool_valuex", &boolValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_bool_test.BoolStaticA")); + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Boolean(cls, "bool_value", &boolValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_by_name_bool_test.BoolStaticA")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_byte_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_byte_test.cpp index f5b09dcf75296cf91935018ed997a79ac355cc9f..3b8bc8dc027405988eea458101c4ab137864df68 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_byte_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_byte_test.cpp @@ -149,5 +149,21 @@ TEST_F(ClassGetStaticFieldByNameByteTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_by_name_byte_test/ByteStaticFinal;", "byte_value"); } + +TEST_F(ClassGetStaticFieldByNameByteTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_by_name_byte_test.ByteStaticA", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_byte_test.ByteStaticA")); + ani_byte byteValue {}; + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Byte(cls, "byte_valuex", &byteValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_byte_test.ByteStaticA")); + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Byte(cls, "byte_value", &byteValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_by_name_byte_test.ByteStaticA")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_char_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_char_test.cpp index 7df8db386bc489e3644b0e59e35ca5162160cf17..6233d20a2e8f696dae2e17f9a2281171dc0a38e8 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_char_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_char_test.cpp @@ -160,6 +160,22 @@ TEST_F(ClassGetStaticFieldByNameCharTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_by_name_char_test/CharStaticFinal;", "char_value"); } + +TEST_F(ClassGetStaticFieldByNameCharTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_by_name_char_test.CharStaticFinal", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_char_test.CharStaticFinal")); + ani_char charValue {}; + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Char(cls, "char_valuex", &charValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_char_test.CharStaticFinal")); + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Char(cls, "char_value", &charValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_by_name_char_test.CharStaticFinal")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_double_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_double_test.cpp index a91aefb794220892ce402dd4d875f6a2ebd4f3f4..8543e07b3e0e064513e9aa02718f715cfdbefb13 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_double_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_double_test.cpp @@ -148,6 +148,22 @@ TEST_F(ClassGetStaticFieldByNameDoubleTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_by_name_double_test/DoubleStaticFinal;", "double_value"); } + +TEST_F(ClassGetStaticFieldByNameDoubleTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_by_name_double_test.Woman", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_double_test.Woman")); + ani_double doubleValue {}; + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Double(cls, "agex", &doubleValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_double_test.Woman")); + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Double(cls, "age", &doubleValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_by_name_double_test.Woman")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_float_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_float_test.cpp index 98cf28998f07435fc09fe2ce22604b0f5a6742a1..3ba464dce6a66187af5f34a92263857e87f653af 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_float_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_float_test.cpp @@ -147,6 +147,21 @@ TEST_F(ClassGetStaticFieldByNameFloatTest, combination_test4) CheckFieldValue("Lclass_get_static_field_by_name_float_test/FloatStaticFinal;", "float_value"); } +TEST_F(ClassGetStaticFieldByNameFloatTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_by_name_float_test.GetFloatStatic", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_float_test.GetFloatStatic")); + ani_float floatValue {}; + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Float(cls, "agex", &floatValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_float_test.GetFloatStatic")); + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Float(cls, "age", &floatValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_by_name_float_test.GetFloatStatic")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_int_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_int_test.cpp index 0f8a36c992b7a1f8c7a2df92ec3c2e6ad7e1a3dd..5a2acf456bad7c6bfa82a8d9a5c579eb7175dc75 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_int_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_int_test.cpp @@ -144,6 +144,22 @@ TEST_F(ClassGetStaticFieldByNameIntTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_by_name_int_test/PackstaticFinal;", "int_value"); } + +TEST_F(ClassGetStaticFieldByNameIntTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_by_name_int_test.GetIntStatic", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_int_test.GetIntStatic")); + ani_int intValue {}; + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Int(cls, "agex", &intValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_int_test.GetIntStatic")); + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Int(cls, "age", &intValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_by_name_int_test.GetIntStatic")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_long_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_long_test.cpp index fe678e53d93e0f652331c5433e1a1a3101d9a6ce..3ce666d9c88c0b1733ce185050aba67114ffcf51 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_long_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_long_test.cpp @@ -143,6 +143,22 @@ TEST_F(ClassGetStaticFieldByNameLongTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_by_name_long_test/PackageStaticFinal;", "long_value"); } + +TEST_F(ClassGetStaticFieldByNameLongTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_by_name_long_test.GetLongStatic", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_long_test.GetLongStatic")); + ani_long longValue {}; + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Long(cls, "agex", &longValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_long_test.GetLongStatic")); + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Long(cls, "age", &longValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_by_name_long_test.GetLongStatic")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_ref_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_ref_test.cpp index 49e095d9909f0404e82e136887e8e8367d05b049..c7658d2e524617a1b31cbc16de83f28773d576c0 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_ref_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_ref_test.cpp @@ -157,6 +157,22 @@ TEST_F(ClassGetStaticFieldByNameRefTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_by_name_ref_test/BoxStaticFinal;", "string_value"); } + +TEST_F(ClassGetStaticFieldByNameRefTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_by_name_ref_test.BoxStaticA", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_ref_test.BoxStaticA")); + ani_ref refValue {}; + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Ref(cls, "string_valuex", &refValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_ref_test.BoxStaticA")); + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Ref(cls, "string_value", &refValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_by_name_ref_test.BoxStaticA")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_short_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_short_test.cpp index 7a78a4159f063917ce4ca2f5bbef0e9949edfa30..91ccd25b8b42689cbd1c2038b3678b5f0bf771d8 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_short_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_by_name_short_test.cpp @@ -143,5 +143,21 @@ TEST_F(ClassGetStaticFieldByNameShortTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_by_name_short_test/ShortStaticFinal;", "short_value"); } + +TEST_F(ClassGetStaticFieldByNameShortTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_by_name_short_test.ShortStaticA", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_short_test.ShortStaticA")); + ani_short shortValue {}; + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Short(cls, "short_valuex", &shortValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_by_name_short_test.ShortStaticA")); + + ASSERT_EQ(env_->Class_GetStaticFieldByName_Short(cls, "short_value", &shortValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_by_name_short_test.ShortStaticA")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_byte_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_byte_test.cpp index e49b19668f87460a466b2f51d1e8484e0442367e..53f37ae421577bdedb4292942ac266e6ead8e898 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_byte_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_byte_test.cpp @@ -185,6 +185,21 @@ TEST_F(ClassGetStaticFieldByteTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_byte_test/TestByteFinal;", "byte_value"); } + +TEST_F(ClassGetStaticFieldByteTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_byte_test.TestByteFinal", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "byte_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_byte_test.TestByteFinal")); + ani_byte byteValue {}; + ASSERT_EQ(env_->Class_GetStaticField_Byte(cls, field, &byteValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_byte_test.TestByteFinal")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_char_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_char_test.cpp index dc0f2ceaffb80259316bd6a65eee2f2581723ba8..82a626b19a5937c41ac44d87c30d0c1cadf1c294 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_char_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_char_test.cpp @@ -178,6 +178,21 @@ TEST_F(ClassGetStaticFieldCharTest, combination_test3) { CheckFieldValue("Lclass_get_static_field_char_test/TestCharFinal;", "char_value"); } + +TEST_F(ClassGetStaticFieldCharTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_char_test.TestChar", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "char_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_char_test.TestChar")); + ani_char charValue {}; + ASSERT_EQ(env_->Class_GetStaticField_Char(cls, field, &charValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_char_test.TestChar")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_double_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_double_test.cpp index 1b93f9e62820d5f19246da7720e8717080a3d7ea..cc11a2a530a0c6978bd1a0fb02353ee6ad480d53 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_double_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_double_test.cpp @@ -178,6 +178,21 @@ TEST_F(ClassGetStaticFieldDoubleTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_double_test/TestDoubleFinal;", "double_value"); } + +TEST_F(ClassGetStaticFieldDoubleTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_double_test.TestDoubleFinal", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "double_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_double_test.TestDoubleFinal")); + ani_double doubleValue {}; + ASSERT_EQ(env_->Class_GetStaticField_Double(cls, field, &doubleValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_double_test.TestDoubleFinal")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_float_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_float_test.cpp index 1494d492397db7bc20180aff661d7a5f4620428d..f73b0c0fb1b2902fc99e0fe8801b9dbae3bb6098 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_float_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_float_test.cpp @@ -179,6 +179,21 @@ TEST_F(ClassGetStaticFieldFloatTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_float_test/TestFloatFinal;", "float_value"); } + +TEST_F(ClassGetStaticFieldFloatTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_float_test.TestFloatFinal", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "float_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_float_test.TestFloatFinal")); + ani_float floatValue {}; + ASSERT_EQ(env_->Class_GetStaticField_Float(cls, field, &floatValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_float_test.TestFloatFinal")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_int_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_int_test.cpp index 2dbe135bc46786b74d237360ba10ff0d72c8f9fe..8de89d394c53218f4c6cdfd6343990dad77ab5b4 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_int_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_int_test.cpp @@ -174,6 +174,21 @@ TEST_F(ClassGetStaticFieldIntTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_int_test/TestIntFinal;", "int_value"); } + +TEST_F(ClassGetStaticFieldIntTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_int_test.TestIntA", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "int_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_int_test.TestIntA")); + ani_int intValue {}; + ASSERT_EQ(env_->Class_GetStaticField_Int(cls, field, &intValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_int_test.TestIntA")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_long_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_long_test.cpp index b7f7ae0ecbc9e42bd62995b091d562fd2b103427..71f2b6fb21b99d97350b6a5daf918af45b07da62 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_long_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_long_test.cpp @@ -173,6 +173,21 @@ TEST_F(ClassGetStaticFieldLongTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_long_test/TestLongFinal;", "long_value"); } + +TEST_F(ClassGetStaticFieldLongTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_long_test.TestLong", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "long_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_long_test.TestLong")); + ani_long longValue {}; + ASSERT_EQ(env_->Class_GetStaticField_Long(cls, field, &longValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_long_test.TestLong")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_ref_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_ref_test.cpp index d1dd2cd41fbf4f81152c1269bf6d9633fd0cf0b9..d8aaeb6afd2d8389ac4911c11659a128437f185d 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_ref_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_ref_test.cpp @@ -172,6 +172,21 @@ TEST_F(ClassGetStaticFieldRefTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_ref_test/TestRefFinal;", "string_value"); } + +TEST_F(ClassGetStaticFieldRefTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_ref_test.TestRefA", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "string_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_ref_test.TestRefA")); + ani_ref refValue {}; + ASSERT_EQ(env_->Class_GetStaticField_Ref(cls, field, &refValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_ref_test.TestRefA")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_short_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_short_test.cpp index 3b1cfe388bbc4fc8348f32f7987ad675dea72111..b0b0e146c839b1110fe8ee1a1b3d776595dd8c7a 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_short_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_get_static_field_short_test.cpp @@ -178,6 +178,21 @@ TEST_F(ClassGetStaticFieldShortTest, combination_test4) { CheckFieldValue("Lclass_get_static_field_short_test/TestShortFinal;", "short_value"); } + +TEST_F(ClassGetStaticFieldShortTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_get_static_field_short_test.TestShort", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "short_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_get_static_field_short_test.TestShort")); + ani_short shortValue {}; + ASSERT_EQ(env_->Class_GetStaticField_Short(cls, field, &shortValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_get_static_field_short_test.TestShort")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_boolean_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_boolean_test.cpp index 056d9e47cdeebb19cbfaeb43437cc49274630dd6..bbc5cebe9ae1f6f5854e81a2debf9d1af62c7d0a 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_boolean_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_boolean_test.cpp @@ -171,5 +171,19 @@ TEST_F(ClassSetStaticFieldBooleanTest, combination_test4) { CheckFieldValue("Lclass_set_static_field_boolean_test/TestSetBooleanFinal;", "bool_value"); } + +TEST_F(ClassSetStaticFieldBooleanTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_boolean_test.TestSetBoolean", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "bool_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_boolean_test.TestSetBoolean")); + ASSERT_EQ(env_->Class_SetStaticField_Boolean(cls, field, ANI_FALSE), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_boolean_test.TestSetBoolean")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_bool_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_bool_test.cpp index 2d13adaa4c06a507970cd97f3cb707d2a7fca28f..1d6f0407aaffdf0bbdab1b4cc068c1ede08ba283 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_bool_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_bool_test.cpp @@ -142,5 +142,20 @@ TEST_F(ClassSetStaticFieldByNameBoolTest, invalid_argument1) ASSERT_EQ(env_->Class_SetStaticFieldByName_Boolean(cls, "\n", ANI_TRUE), ANI_NOT_FOUND); ASSERT_EQ(env_->c_api->Class_SetStaticFieldByName_Boolean(nullptr, cls, "bool_value", ANI_TRUE), ANI_INVALID_ARGS); } + +TEST_F(ClassSetStaticFieldByNameBoolTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_by_name_bool_test.BoolStatic", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_bool_test.BoolStatic")); + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Boolean(cls, "bool_valuex", ANI_TRUE), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_bool_test.BoolStatic")); + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Boolean(cls, "bool_value", ANI_TRUE), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_by_name_bool_test.BoolStatic")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_byte_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_byte_test.cpp index ea3c25dfc2671214d1da72acd113ee04b0344f83..420b53605e9c8134bd4807ecb7a20482a760776a 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_byte_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_byte_test.cpp @@ -174,6 +174,22 @@ TEST_F(ClassSetStaticFieldByNameByteTest, invalid_argument) ASSERT_EQ(env_->Class_SetStaticFieldByName_Byte(cls, "\n", setTarget), ANI_NOT_FOUND); ASSERT_EQ(env_->c_api->Class_SetStaticFieldByName_Byte(nullptr, cls, "byte_value", setTarget), ANI_INVALID_ARGS); } + +TEST_F(ClassSetStaticFieldByNameByteTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_by_name_byte_test.ByteStatic", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_byte_test.ByteStatic")); + const ani_short byteValue = 1U; + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Byte(cls, "byte_valuex", byteValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_byte_test.ByteStatic")); + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Byte(cls, "byte_value", byteValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_by_name_byte_test.ByteStatic")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_char_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_char_test.cpp index 00906cb5b88e1192bfa7fc86b5907e21d81a4e05..59137a3e17a1e512eab4134bfb10ed8378f1b11c 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_char_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_char_test.cpp @@ -181,5 +181,21 @@ TEST_F(ClassSetStaticFieldByNameCharTest, invalid_argument1) ASSERT_EQ(env_->Class_SetStaticFieldByName_Char(cls, "\n", setTarget), ANI_NOT_FOUND); ASSERT_EQ(env_->c_api->Class_SetStaticFieldByName_Char(nullptr, cls, "char_value", setTarget), ANI_INVALID_ARGS); } + +TEST_F(ClassSetStaticFieldByNameCharTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_by_name_char_test.CharStatic", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_char_test.CharStatic")); + const ani_char charValue = 'n'; + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Char(cls, "char_valuex", charValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_char_test.CharStatic")); + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Char(cls, "char_value", charValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_by_name_char_test.CharStatic")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_double_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_double_test.cpp index 2d879ef96c4b4fea941b24cc47e5415c1312af8a..aaddb4654bcf753fc318fbe9a6fe160308acbe54 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_double_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_double_test.cpp @@ -153,5 +153,21 @@ TEST_F(ClassSetStaticFieldByNameDoubleTest, combination_test3) { CheckFieldValue("Lclass_set_static_field_by_name_double_test/DoubleStaticFinal;", "double_value"); } + +TEST_F(ClassSetStaticFieldByNameDoubleTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_by_name_double_test.DoubleStaticA", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_double_test.DoubleStaticA")); + const ani_double doubleValue = 2.2; + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Double(cls, "double_valuex", doubleValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_double_test.DoubleStaticA")); + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Double(cls, "double_value", doubleValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_by_name_double_test.DoubleStaticA")); +} + } // namespace ark::ets::ani::testing - // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file + // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_float_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_float_test.cpp index 2c8f056eab28985848a57906a11e9a4219f1d708..630292ed77254acfbc336d7f89c5c9f804ac3a3d 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_float_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_float_test.cpp @@ -152,5 +152,21 @@ TEST_F(ClassSetStaticFieldByNameFloatTest, invalid_argument1) ASSERT_EQ(env_->Class_SetStaticFieldByName_Float(cls, "\n", setTarget), ANI_NOT_FOUND); ASSERT_EQ(env_->c_api->Class_SetStaticFieldByName_Float(nullptr, cls, "float_value", setTarget), ANI_INVALID_ARGS); } + +TEST_F(ClassSetStaticFieldByNameFloatTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_by_name_float_test.FloatStatic", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_float_test.FloatStatic")); + const ani_float floatValue = 2.2; + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Float(cls, "float_valuex", floatValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_float_test.FloatStatic")); + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Float(cls, "float_value", floatValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_by_name_float_test.FloatStatic")); +} + } // namespace ark::ets::ani::testing - // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file + // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_int_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_int_test.cpp index 0c8de768133abb6d9717829ab064c75da9490783..bcd0f40d79bd5acffdc6d3d06c1f05fa6acbdc2f 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_int_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_int_test.cpp @@ -147,5 +147,21 @@ TEST_F(ClassSetStaticFieldByNameIntTest, invalid_argument1) ASSERT_EQ(env_->Class_SetStaticFieldByName_Int(cls, "\n", setTarget), ANI_NOT_FOUND); ASSERT_EQ(env_->c_api->Class_SetStaticFieldByName_Int(nullptr, cls, "int_value", setTarget), ANI_INVALID_ARGS); } + +TEST_F(ClassSetStaticFieldByNameIntTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_by_name_int_test.PackstaticFinal", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_int_test.PackstaticFinal")); + const ani_int intValue = 24; + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Int(cls, "int_valuex", intValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_int_test.PackstaticFinal")); + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Int(cls, "int_value", intValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_by_name_int_test.PackstaticFinal")); +} + } // namespace ark::ets::ani::testing - // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file + // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_long_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_long_test.cpp index 0466c18dd3b64ed96e39af6ac1d2d9c7332d9d65..09eb53fde5fb14ecf6581e763a76fe5c034a0c1e 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_long_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_long_test.cpp @@ -142,5 +142,21 @@ TEST_F(ClassSetStaticFieldByNameLongTest, invalid_argument1) ASSERT_EQ(env_->Class_SetStaticFieldByName_Long(cls, "\n", setTarget), ANI_NOT_FOUND); ASSERT_EQ(env_->c_api->Class_SetStaticFieldByName_Long(nullptr, cls, "long_value", setTarget), ANI_INVALID_ARGS); } + +TEST_F(ClassSetStaticFieldByNameLongTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_by_name_long_test.PackageStaticFinal", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_long_test.PackageStaticFinal")); + const ani_long longValue = 10; + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Long(cls, "long_valuex", longValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_long_test.PackageStaticFinal")); + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Long(cls, "long_value", longValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_by_name_long_test.PackageStaticFinal")); +} + } // namespace ark::ets::ani::testing - // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file + // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_ref_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_ref_test.cpp index 827622bbd93aea5c990b4d9ba56a70a298ce48a7..f64324664390560c79ffbeb6f9e66b771d96d68f 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_ref_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_ref_test.cpp @@ -174,5 +174,23 @@ TEST_F(ClassSetStaticFieldByNameRefTest, invalid_argument1) ASSERT_EQ(env_->Class_SetStaticFieldByName_Ref(cls, "\n", string), ANI_NOT_FOUND); ASSERT_EQ(env_->c_api->Class_SetStaticFieldByName_Ref(nullptr, cls, "string_value", string), ANI_INVALID_ARGS); } + +TEST_F(ClassSetStaticFieldByNameRefTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_by_name_ref_test.BoxStaticFinal", &cls), ANI_OK); + + ani_string stringValue {}; + ASSERT_EQ(env_->String_NewUTF8("test", 6U, &stringValue), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_ref_test.BoxStaticFinal")); + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Ref(cls, "string_valuex", stringValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_ref_test.BoxStaticFinal")); + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Ref(cls, "string_value", stringValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_by_name_ref_test.BoxStaticFinal")); +} + } // namespace ark::ets::ani::testing - // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) \ No newline at end of file + // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_short_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_short_test.cpp index 569167dd63f99c3cafd3d0f63160ffed9126db83..2f60b241802b263f1259ac3c2c0917129ea04a45 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_short_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_by_name_short_test.cpp @@ -147,5 +147,21 @@ TEST_F(ClassSetStaticFieldByNameShortTest, invalid_argument1) ASSERT_EQ(env_->Class_SetStaticFieldByName_Short(cls, "\n", setTarget), ANI_NOT_FOUND); ASSERT_EQ(env_->c_api->Class_SetStaticFieldByName_Short(nullptr, cls, "short_value", setTarget), ANI_INVALID_ARGS); } + +TEST_F(ClassSetStaticFieldByNameShortTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_by_name_short_test.ShortStatic", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_short_test.ShortStatic")); + const ani_short shortValue = 10; + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Short(cls, "short_valuex", shortValue), ANI_NOT_FOUND); + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_by_name_short_test.ShortStatic")); + + ASSERT_EQ(env_->Class_SetStaticFieldByName_Short(cls, "short_value", shortValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_by_name_short_test.ShortStatic")); +} + } // namespace ark::ets::ani::testing - // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file + // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_byte_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_byte_test.cpp index 0a47f1f17f9bce5751c8e21802589b340f5696cb..31506727e47b4275cde156233cd27542c5c7fab0 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_byte_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_byte_test.cpp @@ -171,6 +171,21 @@ TEST_F(ClassSetStaticFieldByteTest, combination_test4) { CheckFieldValue("Lclass_set_static_field_byte_test/TestSetByteFinal;", "byte_value"); } + +TEST_F(ClassSetStaticFieldByteTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_byte_test.TestSetByteFinal", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "byte_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_byte_test.TestSetByteFinal")); + const ani_byte byteValue = 127; + ASSERT_EQ(env_->Class_SetStaticField_Byte(cls, field, byteValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_byte_test.TestSetByteFinal")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_char_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_char_test.cpp index 5f7ededa0d9f24b9ccfdb093225685c3dab9d73a..f3901f9d35b2caef37d588eb35e9deb8c46a6402 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_char_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_char_test.cpp @@ -171,6 +171,21 @@ TEST_F(ClassSetStaticFieldCharTest, combination_test4) { CheckFieldValue("Lclass_set_static_field_char_test/TestSetCharFinal;", "char_value"); } + +TEST_F(ClassSetStaticFieldCharTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_char_test.TestSetCharFinal", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "char_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_char_test.TestSetCharFinal")); + const ani_char charValue = 'a'; + ASSERT_EQ(env_->Class_SetStaticField_Char(cls, field, charValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_char_test.TestSetCharFinal")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_double_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_double_test.cpp index bdf636d7b5938f02555acbeaacef64972699e920..413f09ed36601c25043e6ff34edd44728ad1ebca 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_double_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_double_test.cpp @@ -173,6 +173,21 @@ TEST_F(ClassSetStaticFieldDoubleTest, combination_test3) { CheckFieldValue("Lclass_set_static_field_double_test/TestSetDoubleFinal;", "double_value"); } + +TEST_F(ClassSetStaticFieldDoubleTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_double_test.TestSetDoubleFinal", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "double_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_double_test.TestSetDoubleFinal")); + const ani_double doubleValue = 16.05; + ASSERT_EQ(env_->Class_SetStaticField_Double(cls, field, doubleValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_double_test.TestSetDoubleFinal")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_float_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_float_test.cpp index 7411beba652b3f41113ab5d50147ae6126cf0640..e77203bdef54493536d86e1665259873d0da4dec 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_float_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_float_test.cpp @@ -172,6 +172,21 @@ TEST_F(ClassSetStaticFieldFloatTest, combination_test3) { CheckFieldValue("Lclass_set_static_field_float_test/TestSetFloatFinal;", "float_value"); } + +TEST_F(ClassSetStaticFieldFloatTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_float_test.TestSetFloatFinal", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "float_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_float_test.TestSetFloatFinal")); + const ani_float floatValue = 20.03F; + ASSERT_EQ(env_->Class_SetStaticField_Float(cls, field, floatValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_float_test.TestSetFloatFinal")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_int_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_int_test.cpp index 80ec3e338a9d34a9735bf2bf43a12102d49085ce..c8dee607e7376382e3555a3a7089b1b378ddc0f7 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_int_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_int_test.cpp @@ -160,6 +160,21 @@ TEST_F(ClassSetStaticFieldIntTest, combination_test3) { CheckFieldValue("Lclass_set_static_field_int_test/TestSetIntFinal;", "int_value"); } + +TEST_F(ClassSetStaticFieldIntTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_int_test.TestSetIntFinal", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "int_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_int_test.TestSetIntFinal")); + const ani_int intValue = 2410; + ASSERT_EQ(env_->Class_SetStaticField_Int(cls, field, intValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_int_test.TestSetIntFinal")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_long_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_long_test.cpp index eebd48a88a7afea046595db912300a0eda0118d3..a74e2735c51ef4a96da782eb240fb1b1749e9583 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_long_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_long_test.cpp @@ -159,6 +159,21 @@ TEST_F(ClassSetStaticFieldLongTest, combination_test3) { CheckFieldValue("Lclass_set_static_field_long_test/TestSetLongFinal;", "long_value"); } + +TEST_F(ClassSetStaticFieldLongTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_long_test.TestSetLongFinal", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "long_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_long_test.TestSetLongFinal")); + const ani_long longValue = 20L; + ASSERT_EQ(env_->Class_SetStaticField_Long(cls, field, longValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_long_test.TestSetLongFinal")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_ref_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_ref_test.cpp index ed6df44d1b7c0c255a237676c0976587858a1a2d..08f58b707077466cc2e873b2cd24a2105ab2ba32 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_ref_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_ref_test.cpp @@ -180,6 +180,23 @@ TEST_F(ClassSetStaticFieldRefTest, combination_test3) { CheckFieldValue("Lclass_set_static_field_ref_test/TestSetRefFinal;", "string_value"); } + +TEST_F(ClassSetStaticFieldRefTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_ref_test.TestSetRefA", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "string_value", &field), ANI_OK); + + ani_string string {}; + ASSERT_EQ(env_->String_NewUTF8("test", 10U, &string), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_ref_test.TestSetRefA")); + ASSERT_EQ(env_->Class_SetStaticField_Ref(cls, field, string), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_ref_test.TestSetRefA")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) diff --git a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_short_test.cpp b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_short_test.cpp index 080c7719e12614047886ebc58e8fabb2728b98ec..bbba478e575c7093337a763fc490b7c1ebc3a075 100644 --- a/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_short_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/class_ops/class_set_static_field_short_test.cpp @@ -163,6 +163,21 @@ TEST_F(ClassSetStaticFieldShortTest, combination_test4) { CheckFieldValue("Lclass_set_static_field_short_test/TestSetShortFinal;", "short_value"); } + +TEST_F(ClassSetStaticFieldShortTest, check_initialization) +{ + ani_class cls {}; + ASSERT_EQ(env_->FindClass("class_set_static_field_short_test.TestSetShortFinal", &cls), ANI_OK); + + ani_static_field field {}; + ASSERT_EQ(env_->Class_FindStaticField(cls, "short_value", &field), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("class_set_static_field_short_test.TestSetShortFinal")); + const ani_short shortValue = 127U; + ASSERT_EQ(env_->Class_SetStaticField_Short(cls, field, shortValue), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("class_set_static_field_short_test.TestSetShortFinal")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/enum_ops/enum_item_get_index_test.cpp b/static_core/plugins/ets/tests/ani/tests/enum_ops/enum_item_get_index_test.cpp index e92e08a5ae3192b591001e7bec852f973ce12295..15fc54985f11fe968436727e2e3d8b1906b522ad 100644 --- a/static_core/plugins/ets/tests/ani/tests/enum_ops/enum_item_get_index_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/enum_ops/enum_item_get_index_test.cpp @@ -204,4 +204,16 @@ TEST_F(EnumItemGetIndexTest, enum_get_item_by_index_combine_scenes_001) ASSERT_EQ(env_->EnumItem_GetIndex(blue, &blueIndex), ANI_OK); ASSERT_EQ(blueIndex, 2U); } + +TEST_F(EnumItemGetIndexTest, check_initialization) +{ + ani_enum aniEnum {}; + ASSERT_EQ(env_->FindEnum("enum_item_get_index_test.Color", &aniEnum), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("enum_item_get_index_test.Color")); + ani_enum_item red {}; + ASSERT_EQ(env_->Enum_GetEnumItemByIndex(aniEnum, 0U, &red), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("enum_item_get_index_test.Color")); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/enum_ops/enum_item_get_name_test.cpp b/static_core/plugins/ets/tests/ani/tests/enum_ops/enum_item_get_name_test.cpp index 81f16e43a7c16135bb199aef827476d8a6288769..d696ba1772788f67c35b1c3eca0906e1c61275fa 100644 --- a/static_core/plugins/ets/tests/ani/tests/enum_ops/enum_item_get_name_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/enum_ops/enum_item_get_name_test.cpp @@ -150,4 +150,15 @@ TEST_F(EnumItemGetNameTest, enum_get_name_test_one_item) ASSERT_STREQ(itemName.data(), "ONE"); } +TEST_F(EnumItemGetNameTest, check_initialization) +{ + ani_enum aniEnum {}; + ASSERT_EQ(env_->FindEnum("enum_item_get_name_test.OneItem", &aniEnum), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("enum_item_get_name_test.OneItem")); + ani_enum_item one {}; + ASSERT_EQ(env_->Enum_GetEnumItemByName(aniEnum, "ONE", &one), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("enum_item_get_name_test.OneItem")); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/find_ops/find_class_test.cpp b/static_core/plugins/ets/tests/ani/tests/find_ops/find_class_test.cpp index e916e9b0d1e9ed421da870da60ed6c2e767b18bd..8a92f762cbaf2b3a7d9f8b39bcde0ef0f128d218 100644 --- a/static_core/plugins/ets/tests/ani/tests/find_ops/find_class_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/find_ops/find_class_test.cpp @@ -53,4 +53,12 @@ TEST_F(FindClassTest, class_is_not_module) ASSERT_EQ(env_->FindModule("LPoint;", &md), ANI_NOT_FOUND); } +TEST_F(FindClassTest, check_initialization) +{ + ASSERT_FALSE(IsRuntimeClassInitialized("find_class_test.Point")); + ani_class cls {}; + ASSERT_EQ(env_->FindClass("find_class_test.Point", &cls), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("find_class_test.Point")); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/find_ops/find_enum_test.cpp b/static_core/plugins/ets/tests/ani/tests/find_ops/find_enum_test.cpp index 51e0919c8169cf4f6479675f92c828861696957b..19b3159aa1e7a618fe8a3c21754c922565221230 100644 --- a/static_core/plugins/ets/tests/ani/tests/find_ops/find_enum_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/find_ops/find_enum_test.cpp @@ -249,4 +249,13 @@ TEST_F(EnumFindTest, find_enum_combine_scenes_004) RetrieveStringFromAni(env_, blueName, itemName); ASSERT_STREQ(itemName.data(), "BLUE"); } + +TEST_F(EnumFindTest, check_initialization) +{ + ASSERT_FALSE(IsRuntimeClassInitialized("find_enum_test.EnumA001")); + ani_enum aniEnum {}; + ASSERT_EQ(env_->FindEnum("find_enum_test.EnumA001", &aniEnum), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("find_enum_test.EnumA001")); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/find_ops/find_module_test.cpp b/static_core/plugins/ets/tests/ani/tests/find_ops/find_module_test.cpp index 167aa43121a2e4f63ccae30302c21c7e165778ce..181192668814da22c9006d9cb37b7ce3029f41d7 100644 --- a/static_core/plugins/ets/tests/ani/tests/find_ops/find_module_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/find_ops/find_module_test.cpp @@ -50,6 +50,14 @@ TEST_F(FindModuleTest, invalid_argument_env) ASSERT_EQ(env_->c_api->FindModule(nullptr, "L@abcModule/find_module_test;", &module), ANI_INVALID_ARGS); } +TEST_F(FindModuleTest, check_initialization) +{ + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.find_module_test", false)); + ani_module module {}; + ASSERT_EQ(env_->FindModule("@abcModule.find_module_test", &module), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.find_module_test", false)); +} + } // namespace ark::ets::ani::testing // NOLINTEND(modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/find_ops/find_namespace_test.cpp b/static_core/plugins/ets/tests/ani/tests/find_ops/find_namespace_test.cpp index 6a067dbbe01cb32e63c39b6cc072d3faed57b10d..8c9effa0d0e508bcc7aaf7431c774952352c556b 100644 --- a/static_core/plugins/ets/tests/ani/tests/find_ops/find_namespace_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/find_ops/find_namespace_test.cpp @@ -88,6 +88,15 @@ TEST_F(FindNamespaceTest, find_namespace_combine_scenes_003) ASSERT_EQ(env_->Function_Call_Int_A(fn, &value, args), ANI_OK); ASSERT_EQ(value, VAL1 * VAL2); } + +TEST_F(FindNamespaceTest, check_initialization) +{ + ASSERT_FALSE(IsRuntimeClassInitialized("find_namespace_test.geometry")); + ani_namespace ns {}; + ASSERT_EQ(env_->FindNamespace("find_namespace_test.geometry", &ns), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("find_namespace_test.geometry")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(modernize-avoid-c-arrays) \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_boolean_test.cpp b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_boolean_test.cpp index 3394f73b28a7f9be5adceca34236499605c30869..5d24fa9bbbe123f64720a4a375eeea97e65521e9 100644 --- a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_boolean_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_boolean_test.cpp @@ -385,6 +385,34 @@ TEST_F(FunctionCallBooleanTest, function_call_boolean_010) ASSERT_EQ(env_->Function_Call_Boolean(fn, &result, nullptr), ANI_OK); ASSERT_EQ(env_->Function_Call_Boolean_A(fn, &result, nullptr), ANI_INVALID_ARGS); } + +TEST_F(FunctionCallBooleanTest, check_initialization_bool) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_boolean_test.ops")); + ani_boolean result = ANI_FALSE; + ASSERT_EQ(env_->Function_Call_Boolean(fn, &result, ANI_TRUE, ANI_FALSE), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_boolean_test.ops")); +} + +TEST_F(FunctionCallBooleanTest, check_initialization_bool_a) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_boolean_test.ops")); + ani_boolean result = ANI_FALSE; + ani_value args[2U]; + args[0U].z = ANI_TRUE; + args[1U].z = ANI_FALSE; + ASSERT_EQ(env_->Function_Call_Boolean_A(fn, &result, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_boolean_test.ops")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) diff --git a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_byte_test.cpp b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_byte_test.cpp index 3f5332be66ad8a5c98696d33662a5ad0b7218d51..15af5e36e54efb74ab4c365476d11f82ec196c69 100644 --- a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_byte_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_byte_test.cpp @@ -385,6 +385,34 @@ TEST_F(FunctionCallByteTest, function_call_byte_010) ASSERT_EQ(env_->Function_Call_Byte(fn, &result, nullptr), ANI_OK); ASSERT_EQ(env_->Function_Call_Byte_A(fn, &result, nullptr), ANI_INVALID_ARGS); } + +TEST_F(FunctionCallByteTest, check_initialization_byte) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_byte_test.ops")); + ani_byte result {}; + ASSERT_EQ(env_->Function_Call_Byte(fn, &result, BYTE_VAL1, BYTE_VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_byte_test.ops")); +} + +TEST_F(FunctionCallByteTest, check_initialization_byte_a) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_byte_test.ops")); + ani_byte result {}; + ani_value args[2U]; + args[0U].b = BYTE_VAL1; + args[1U].b = BYTE_VAL2; + ASSERT_EQ(env_->Function_Call_Byte_A(fn, &result, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_byte_test.ops")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) diff --git a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_char_test.cpp b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_char_test.cpp index 10a8f7d56b40a2d16eb1c5c90853af27c8c61731..dc1758170c8e19a09252f58b53a7501ffd2e6f3a 100644 --- a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_char_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_char_test.cpp @@ -399,6 +399,34 @@ TEST_F(FunctionCallCharTest, function_call_char_010) ASSERT_EQ(env_->Function_Call_Char(fn, &result, nullptr), ANI_OK); ASSERT_EQ(env_->Function_Call_Char_A(fn, &result, nullptr), ANI_INVALID_ARGS); } + +TEST_F(FunctionCallCharTest, check_initialization_char) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_char_test.ops")); + ani_char result {}; + ASSERT_EQ(env_->Function_Call_Char(fn, &result, CHAR_VAL1, CHAR_VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_char_test.ops")); +} + +TEST_F(FunctionCallCharTest, check_initialization_char_a) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_char_test.ops")); + ani_char result {}; + ani_value args[2U]; + args[0U].c = CHAR_VAL1; + args[1U].c = CHAR_VAL2; + ASSERT_EQ(env_->Function_Call_Char_A(fn, &result, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_char_test.ops")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_double_test.cpp b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_double_test.cpp index 2247fc91e5cd7cf01c0eb5974150ed4f625de754..cc75c8878391748ac386b757c5ca19cc1a29f87c 100644 --- a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_double_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_double_test.cpp @@ -399,6 +399,34 @@ TEST_F(FunctionCallDoubleTest, function_call_double_010) ASSERT_EQ(env_->Function_Call_Double(fn, &result, nullptr), ANI_OK); ASSERT_EQ(env_->Function_Call_Double_A(fn, &result, nullptr), ANI_INVALID_ARGS); } + +TEST_F(FunctionCallDoubleTest, check_initialization_double) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_double_test.ops")); + ani_double result {}; + ASSERT_EQ(env_->Function_Call_Double(fn, &result, VAL1, VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_double_test.ops")); +} + +TEST_F(FunctionCallDoubleTest, check_initialization_double_a) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_double_test.ops")); + ani_double result {}; + ani_value args[2U]; + args[0U].d = VAL1; + args[1U].d = VAL2; + ASSERT_EQ(env_->Function_Call_Double_A(fn, &result, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_double_test.ops")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) diff --git a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_float_test.cpp b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_float_test.cpp index cd6a77daca57111baa029fa5be3deccca8b5e320..ecab587a31ab0959e8a836ed81024c4b47368f83 100644 --- a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_float_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_float_test.cpp @@ -399,6 +399,34 @@ TEST_F(FunctionCallFloatTest, function_call_float_010) ASSERT_EQ(env_->Function_Call_Float(fn, &result, nullptr), ANI_OK); ASSERT_EQ(env_->Function_Call_Float_A(fn, &result, nullptr), ANI_INVALID_ARGS); } + +TEST_F(FunctionCallFloatTest, check_initialization_float) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_float_test.ops")); + ani_float result {}; + ASSERT_EQ(env_->Function_Call_Float(fn, &result, FLOAT_VAL1, FLOAT_VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_float_test.ops")); +} + +TEST_F(FunctionCallFloatTest, check_initialization_float_a) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_float_test.ops")); + ani_float result {}; + ani_value args[2U]; + args[0U].f = FLOAT_VAL1; + args[1U].f = FLOAT_VAL2; + ASSERT_EQ(env_->Function_Call_Float_A(fn, &result, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_float_test.ops")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) diff --git a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_int_test.cpp b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_int_test.cpp index d231bbe94efe2e63bb804371d175324807842ff0..a539f09cc0dfbd1b4efc22bb14d711053a0f931b 100644 --- a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_int_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_int_test.cpp @@ -398,6 +398,34 @@ TEST_F(FunctionCallTest, function_call_int_010) ASSERT_EQ(env_->Function_Call_Int(fn, &result, nullptr), ANI_OK); ASSERT_EQ(env_->Function_Call_Int_A(fn, &result, nullptr), ANI_INVALID_ARGS); } + +TEST_F(FunctionCallTest, check_initialization_int) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_int_test.ops")); + ani_int result {}; + ASSERT_EQ(env_->Function_Call_Int(fn, &result, INT_VAL1, INT_VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_int_test.ops")); +} + +TEST_F(FunctionCallTest, check_initialization_int_a) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_int_test.ops")); + ani_int result {}; + ani_value args[2U]; + args[0U].i = INT_VAL1; + args[1U].i = INT_VAL2; + ASSERT_EQ(env_->Function_Call_Int_A(fn, &result, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_int_test.ops")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_long_test.cpp b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_long_test.cpp index 0d82705ec71620270a4e6819e6b5bd0fa06e300f..6dfccba1699f20f7c974e64faf7a3034bbd9a6af 100644 --- a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_long_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_long_test.cpp @@ -398,6 +398,34 @@ TEST_F(FunctionCallTest, function_call_long_010) ASSERT_EQ(env_->Function_Call_Long(fn, &result, nullptr), ANI_OK); ASSERT_EQ(env_->Function_Call_Long_A(fn, &result, nullptr), ANI_INVALID_ARGS); } + +TEST_F(FunctionCallTest, check_initialization_long) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_long_test.ops")); + ani_long result {}; + ASSERT_EQ(env_->Function_Call_Long(fn, &result, LONG_VAL1, LONG_VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_long_test.ops")); +} + +TEST_F(FunctionCallTest, check_initialization_long_a) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_long_test.ops")); + ani_long result {}; + ani_value args[2U]; + args[0U].l = LONG_VAL1; + args[1U].l = LONG_VAL2; + ASSERT_EQ(env_->Function_Call_Long_A(fn, &result, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_long_test.ops")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_ref_test.cpp b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_ref_test.cpp index 2206deab41540a0bdfb68fb15b5b1a99002a366f..ed8979c194a63f284425f7cfd96b787d0778c367 100644 --- a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_ref_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_ref_test.cpp @@ -451,6 +451,34 @@ TEST_F(FunctionCallRefTest, function_call_ref_010) ASSERT_EQ(env_->Function_Call_Ref(fn, &result, nullptr), ANI_OK); ASSERT_EQ(env_->Function_Call_Ref_A(fn, &result, nullptr), ANI_INVALID_ARGS); } + +TEST_F(FunctionCallRefTest, check_initialization_ref) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_ref_test.ops")); + ani_ref result {}; + ASSERT_EQ(env_->Function_Call_Ref(fn, &result, INT_VAL1, INT_VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_ref_test.ops")); +} + +TEST_F(FunctionCallRefTest, check_initialization_ref_a) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_ref_test.ops")); + ani_ref result {}; + ani_value args[2U]; + args[0U].i = INT_VAL1; + args[1U].i = INT_VAL2; + ASSERT_EQ(env_->Function_Call_Ref_A(fn, &result, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_ref_test.ops")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) diff --git a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_short_test.cpp b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_short_test.cpp index 97da176b32fad64d3d9002eb1c571fc8d7e0125d..b63c20b8ff0a2aaa2d060da2be9876d4ff732c7d 100644 --- a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_short_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_short_test.cpp @@ -398,6 +398,34 @@ TEST_F(FunctionCallTest, function_call_short_010) ASSERT_EQ(env_->Function_Call_Short(fn, &result, nullptr), ANI_OK); ASSERT_EQ(env_->Function_Call_Short_A(fn, &result, nullptr), ANI_INVALID_ARGS); } + +TEST_F(FunctionCallTest, check_initialization_short) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_short_test.ops")); + ani_short result {}; + ASSERT_EQ(env_->Function_Call_Short(fn, &result, SHORT_VAL1, SHORT_VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_short_test.ops")); +} + +TEST_F(FunctionCallTest, check_initialization_short_a) +{ + ani_namespace ns {}; + ani_function fn {}; + GetMethod(&ns, &fn); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_short_test.ops")); + ani_short result {}; + ani_value args[2U]; + args[0U].s = SHORT_VAL1; + args[1U].s = SHORT_VAL2; + ASSERT_EQ(env_->Function_Call_Short_A(fn, &result, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_short_test.ops")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) diff --git a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_void_test.cpp b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_void_test.cpp index af78394a71dc7b8b031a73201847a95e3d9b48cb..b5dc97bc52c4e23729cdfb75fa5a485f23631e96 100644 --- a/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_void_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/function_ops/function_call_void_test.cpp @@ -429,6 +429,34 @@ TEST_F(FunctionCallVoidTest, function_call_void_010) ASSERT_EQ(env_->Function_Call_Void(fn1, nullptr), ANI_OK); ASSERT_EQ(env_->Function_Call_Void_A(fn1, nullptr), ANI_INVALID_ARGS); } + +TEST_F(FunctionCallVoidTest, check_initialization_void) +{ + ani_namespace ns {}; + ani_function fn1 {}; + ani_function fn2 {}; + GetMethod(&ns, &fn1, &fn2); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_void_test.ops")); + ASSERT_EQ(env_->Function_Call_Void(fn1, INT_VAL1, INT_VAL2), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_void_test.ops")); +} + +TEST_F(FunctionCallVoidTest, check_initialization_void_a) +{ + ani_namespace ns {}; + ani_function fn1 {}; + ani_function fn2 {}; + GetMethod(&ns, &fn1, &fn2); + + ASSERT_FALSE(IsRuntimeClassInitialized("@functionModule.function_call_void_test.ops")); + ani_value args[2U]; + args[0U].i = INT_VAL1; + args[1U].i = INT_VAL2; + ASSERT_EQ(env_->Function_Call_Void_A(fn1, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("@functionModule.function_call_void_test.ops")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_class_test.cpp b/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_class_test.cpp index cd6c6c42cd0f5c3544945b94443905f9d5c2714f..753348e807091b711f8b4f98ed210fea27198450 100644 --- a/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_class_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_class_test.cpp @@ -267,5 +267,19 @@ TEST_F(ModuleFindClassTest, find_generic_class) ASSERT_EQ(env_->Object_CallMethod_Void(object, method, testIntObject), ANI_OK); ASSERT_NE(method, nullptr); } + +TEST_F(ModuleFindClassTest, check_initialization) +{ + ani_module module {}; + ASSERT_EQ(env_->FindModule("@abcModule.module_find_class_test", &module), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_class_test", false)); + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_class_test.ATest")); + ani_class cls {}; + ASSERT_EQ(env_->Module_FindClass(module, "ATest", &cls), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_class_test.ATest")); + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_class_test", false)); +} + // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_enum_test.cpp b/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_enum_test.cpp index 3b9f9a23c7f6ef2a92446a0988692ece7965f932..5451a0e4ee56872393f32e9d44ad66e4ccb46ce5 100644 --- a/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_enum_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_enum_test.cpp @@ -188,4 +188,18 @@ TEST_F(ModuleFindEnumTest, find_enum_combine_scenes_003) ASSERT_EQ(env_->EnumItem_GetIndex(red, &redIndex), ANI_OK); ASSERT_EQ(redIndex, 0U); } + +TEST_F(ModuleFindEnumTest, check_initialization) +{ + ani_module module {}; + ASSERT_EQ(env_->FindModule("@abcModule.module_find_enum_test", &module), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_enum_test", false)); + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_enum_test.Color")); + ani_enum enm {}; + ASSERT_EQ(env_->Module_FindEnum(module, "Color", &enm), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_enum_test.Color")); + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_enum_test", false)); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_function_test.cpp b/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_function_test.cpp index 718abf16421b35d51001e4c9e80a844c54ac21b3..896f21348e9f1edd0635bf228f55aa074a4b62dc 100644 --- a/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_function_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_function_test.cpp @@ -224,4 +224,16 @@ TEST_F(ModuleFindFunctionTest, find_func_B_in_namespace_A) ASSERT_EQ(env_->Namespace_FindFunction(ns, "getIntValueOps", ":I", &fn), ANI_OK); ASSERT_NE(fn, nullptr); } + +TEST_F(ModuleFindFunctionTest, check_initialization) +{ + ani_module module {}; + ASSERT_EQ(env_->FindModule("@abcModule.module_find_function_test", &module), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_function_test", false)); + ani_function fn {}; + ASSERT_EQ(env_->Module_FindFunction(module, "getIntValue", "I:I", &fn), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_function_test", false)); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_namespace_test.cpp b/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_namespace_test.cpp index 88bdcb0366efe7b85ea01ad67c79bc59155eac1f..c758f5921f6ffc3add83276cf055691a0720ab75 100644 --- a/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_namespace_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_namespace_test.cpp @@ -158,4 +158,17 @@ TEST_F(ModuleFindNamespaceTest, invalid_arg_result) ASSERT_EQ(env_->Module_FindNamespace(module, "Lmodule_find_class_test/atest;", nullptr), ANI_INVALID_ARGS); } +TEST_F(ModuleFindNamespaceTest, check_initialization) +{ + ani_module module {}; + ASSERT_EQ(env_->FindModule("@abcModule.module_find_namespace_test", &module), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_namespace_test", false)); + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_namespace_test.outer.inner")); + ani_namespace nm {}; + ASSERT_EQ(env_->Module_FindNamespace(module, "outer.inner", &nm), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_namespace_test.outer.inner")); + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_namespace_test", false)); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_variable_test.cpp b/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_variable_test.cpp index 73d050ce8488c30a62c74c764f75b8737144dfaf..2a2cc22c4fe966d99bb5f5c30f11db604379fe37 100644 --- a/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_variable_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/module_ops/module_find_variable_test.cpp @@ -316,5 +316,16 @@ TEST_F(ModuleFindVariableTest, combine_test_ref) ASSERT_STREQ(str.c_str(), "hello"); } +TEST_F(ModuleFindVariableTest, check_initialization) +{ + ani_module module {}; + ASSERT_EQ(env_->FindModule("@abcModule.module_find_variable_test", &module), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_variable_test", false)); + ani_variable variable {}; + ASSERT_EQ(env_->Module_FindVariable(module, "moduleXS", &variable), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("@abcModule.module_find_variable_test", false)); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers) diff --git a/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_class_test.cpp b/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_class_test.cpp index 146c2ebaf5042f6dd5d75a75c859d62d981bd911..70bd924c07c66802222d41da9be540c647c8c6ca 100644 --- a/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_class_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_class_test.cpp @@ -198,4 +198,18 @@ TEST_F(NamespaceFindClassTest, find_class11) ASSERT_EQ(env_->Namespace_FindClass(ns, "LB/C;", nullptr), ANI_INVALID_ARGS); } + +TEST_F(NamespaceFindClassTest, check_initialization) +{ + ani_namespace ns {}; + ASSERT_EQ(env_->FindNamespace("namespace_find_class_test.A", &ns), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_class_test.A")); + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_class_test.A.C")); + ani_class result {}; + ASSERT_EQ(env_->Namespace_FindClass(ns, "C", &result), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_class_test.A.C")); + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_class_test.A")); +} + } // namespace ark::ets::ani::testing \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_enum_test.cpp b/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_enum_test.cpp index 3d3a03388e5beb04c1e2aa8b222c429f35939588..9c2462a6a4e05182a858f8b47f4edb00e7418102 100644 --- a/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_enum_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_enum_test.cpp @@ -140,4 +140,18 @@ TEST_F(NamespaceFindEnumTest, find_enum_same_name) ASSERT_EQ(env_->Namespace_FindEnum(ns, "LColor;", &en), ANI_OK); ASSERT_NE(en, nullptr); } + +TEST_F(NamespaceFindEnumTest, check_initialization) +{ + ani_namespace ns {}; + ASSERT_EQ(env_->FindNamespace("namespace_find_enum_test.enumns", &ns), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_enum_test.enumns")); + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_enum_test.enumns.Color")); + ani_enum en {}; + ASSERT_EQ(env_->Namespace_FindEnum(ns, "Color", &en), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_enum_test.enumns.Color")); + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_enum_test.enumns")); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_function_test.cpp b/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_function_test.cpp index 0e808818730bb8688fe6230760b75359d3d48028..11223464f938b0c6727a67ba16db0d4505b91103 100644 --- a/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_function_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_function_test.cpp @@ -132,4 +132,16 @@ TEST_F(NamespaceFindFunctionTest, duplicate_no_signature) ani_function fn {}; ASSERT_EQ(env_->Namespace_FindFunction(ns, "overloaded", nullptr, &fn), ANI_AMBIGUOUS); } + +TEST_F(NamespaceFindFunctionTest, check_initialization) +{ + ani_namespace ns {}; + ASSERT_EQ(env_->FindNamespace("namespace_find_function_test.Fnns", &ns), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_function_test.Fnns")); + ani_function fn {}; + ASSERT_EQ(env_->Namespace_FindFunction(ns, "getInitialIntValue", ":i", &fn), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_function_test.Fnns")); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_namespace_test.cpp b/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_namespace_test.cpp index bc5465373c7675f87f96a16465cfd74e61cca7ae..dda6ef04308bc1627668ef9b622a16c967bfe326 100644 --- a/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_namespace_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_namespace_test.cpp @@ -146,4 +146,18 @@ TEST_F(NamespaceFindNamespaceTest, find_namespace07) ASSERT_EQ(env_->Namespace_FindNamespace(ns, "LA/C;", nullptr), ANI_INVALID_ARGS); } + +TEST_F(NamespaceFindNamespaceTest, check_initialization) +{ + ani_namespace ns {}; + ASSERT_EQ(env_->FindNamespace("namespace_find_namespace_test.test", &ns), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_namespace_test.test")); + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_namespace_test.test.A")); + ani_namespace result {}; + ASSERT_EQ(env_->Namespace_FindNamespace(ns, "A", &result), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_namespace_test.test.A")); + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_namespace_test.test")); +} + } // namespace ark::ets::ani::testing \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_variable_test.cpp b/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_variable_test.cpp index 3d46c18899ef9efc7f0bc3bb01fd9ca2e5c1f3c6..a9a43b3428d9958815c4f020c32a3ab3df144df7 100644 --- a/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_variable_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/namespace_ops/namespace_find_variable_test.cpp @@ -116,4 +116,15 @@ TEST_F(NamespaceFindVariableTest, invalid_args_result) ASSERT_EQ(env_->Namespace_FindVariable(ns, "s", nullptr), ANI_INVALID_ARGS); } +TEST_F(NamespaceFindVariableTest, check_initialization) +{ + ani_namespace ns {}; + ASSERT_EQ(env_->FindNamespace("namespace_find_variable_test.anyns", &ns), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_variable_test.anyns")); + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns, "x", &variable), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("namespace_find_variable_test.anyns")); +} + } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/object_ops/object_get_type_test.cpp b/static_core/plugins/ets/tests/ani/tests/object_ops/object_get_type_test.cpp index 2d6f481dea9a7abc4ddc9f6fba508654d7705014..59c5141f820c317d42da5bee5da04617751f5aa2 100644 --- a/static_core/plugins/ets/tests/ani/tests/object_ops/object_get_type_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/object_ops/object_get_type_test.cpp @@ -112,4 +112,4 @@ TEST_F(ObjectGetTypeTest, class_obect_type_loop) } } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg) diff --git a/static_core/plugins/ets/tests/ani/tests/object_ops/object_new_test.cpp b/static_core/plugins/ets/tests/ani/tests/object_ops/object_new_test.cpp index b1c7d36966086666f631332dc15a888bb7000a02..0fb9458f2638fc7f9f5b7b37d6a2df934bd4af92 100644 --- a/static_core/plugins/ets/tests/ani/tests/object_ops/object_new_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/object_ops/object_new_test.cpp @@ -586,6 +586,38 @@ TEST_F(ObjectNewTest, object_new_v_normal_method_loop) TestObjectNewV(env_, cls, newTestMethod, tag, animalRef); } } + +TEST_F(ObjectNewTest, check_initialization) +{ + ani_class cls {}; + ani_method ctor {}; + ani_string model {}; + ani_int weight = 0; + GetTestData(&cls, &ctor, &model, &weight); + + ASSERT_FALSE(IsRuntimeClassInitialized("object_new_test.MobilePhone")); + ani_object phone {}; + ASSERT_EQ(env_->Object_New(cls, ctor, &phone, model, weight), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("object_new_test.MobilePhone")); +} + +TEST_F(ObjectNewTest, check_initialization_a) +{ + ani_class cls {}; + ani_method ctor {}; + ani_string model {}; + ani_int weight = 0; + GetTestData(&cls, &ctor, &model, &weight); + + ASSERT_FALSE(IsRuntimeClassInitialized("object_new_test.MobilePhone")); + ani_value args[2U]; + args[0U].r = model; + args[1U].i = weight; + ani_object phone {}; + ASSERT_EQ(env_->Object_New_A(cls, ctor, &phone, args), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("object_new_test.MobilePhone")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, readability-magic-numbers, modernize-avoid-c-arrays) \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/type_ops/get_super_class_test.cpp b/static_core/plugins/ets/tests/ani/tests/type_ops/get_super_class_test.cpp index 4d64334b23d7e7e5241134fe00fcc7194cffd7d7..8e15a8cd30a309dd894179dedefed2cef6077fe8 100644 --- a/static_core/plugins/ets/tests/ani/tests/type_ops/get_super_class_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/type_ops/get_super_class_test.cpp @@ -137,6 +137,17 @@ TEST_F(GetSuperClassTest, get_super_class_combine_scenes_003) TestGetSuperClass("Lget_super_class_test/test002/test003;"); } +TEST_F(GetSuperClassTest, check_initialization) +{ + ani_class cls; + ASSERT_EQ(env_->FindClass("get_super_class_test.A", &cls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("get_super_class_test.A")); + ani_type typeRef = cls; + ASSERT_EQ(env_->Type_GetSuperClass(typeRef, &cls), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("get_super_class_test.A")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/type_ops/is_assignable_from_test.cpp b/static_core/plugins/ets/tests/ani/tests/type_ops/is_assignable_from_test.cpp index c8aaa84fe5a9edc6357a896241f143846e35950c..26d3cdd000ecb257484cfaa5c88421292bb0356a 100644 --- a/static_core/plugins/ets/tests/ani/tests/type_ops/is_assignable_from_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/type_ops/is_assignable_from_test.cpp @@ -115,6 +115,22 @@ TEST_F(IsAssignableFromTest, is_assignable_from_multiple_inheritance) CheckIsAssignableFrom("Lis_assignable_from_test/InterfaceA;", "Lis_assignable_from_test/MyClass;"); } +TEST_F(IsAssignableFromTest, check_initialization) +{ + ani_class fromCls; + ASSERT_EQ(env_->FindClass("is_assignable_from_test.InterfaceA", &fromCls), ANI_OK); + + ani_class toCls; + ASSERT_EQ(env_->FindClass("is_assignable_from_test.InterfaceB", &toCls), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("is_assignable_from_test.InterfaceA")); + ASSERT_FALSE(IsRuntimeClassInitialized("is_assignable_from_test.InterfaceB")); + ani_boolean result; + ASSERT_EQ(env_->Type_IsAssignableFrom(fromCls, toCls, &result), ANI_OK); + ASSERT_FALSE(IsRuntimeClassInitialized("is_assignable_from_test.InterfaceB")); + ASSERT_FALSE(IsRuntimeClassInitialized("is_assignable_from_test.InterfaceA")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_boolean_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_boolean_test.cpp index 04fa08d359f2aa5b05a54ad1bb044538422cf793..3ed6760751a752f944c004d17317e451b1685d79 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_boolean_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_boolean_test.cpp @@ -76,6 +76,17 @@ TEST_F(VariableGetValueBooleanTest, invalid_args_value) ASSERT_EQ(env_->Variable_GetValue_Boolean(variable, nullptr), ANI_INVALID_ARGS); } +TEST_F(VariableGetValueBooleanTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "z", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_get_value_boolean_test.anyns")); + ani_boolean z = ANI_FALSE; + ASSERT_EQ(env_->Variable_GetValue_Boolean(variable, &z), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_get_value_boolean_test.anyns")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(readability-identifier-naming, misc-non-private-member-variables-in-classes) \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_byte_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_byte_test.cpp index dfd4b96be4df500e9bafa382c7ca8ed86b05c4cf..78abed14e04f7451215bee2f870f82f7a0a9d614 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_byte_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_byte_test.cpp @@ -76,6 +76,17 @@ TEST_F(VariableGetValueByteTest, invalid_args_value) ASSERT_EQ(env_->Variable_GetValue_Byte(variable, nullptr), ANI_INVALID_ARGS); } +TEST_F(VariableGetValueByteTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "x", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_get_value_byte_test.anyns")); + ani_byte x; + ASSERT_EQ(env_->Variable_GetValue_Byte(variable, &x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_get_value_byte_test.anyns")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(readability-identifier-naming, misc-non-private-member-variables-in-classes) diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_char_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_char_test.cpp index 854b2f0e1bc0f18568d501f43a9513cf561ebe64..22710e2487bd63af1e98f122e8bf3f45e0bf8108 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_char_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_char_test.cpp @@ -77,6 +77,17 @@ TEST_F(VariableGetValueCharTest, invalid_args_value) ASSERT_EQ(env_->Variable_GetValue_Char(variable, nullptr), ANI_INVALID_ARGS); } +TEST_F(VariableGetValueCharTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "x", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_get_value_char_test.anyns")); + ani_char x; + ASSERT_EQ(env_->Variable_GetValue_Char(variable, &x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_get_value_char_test.anyns")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(readability-identifier-naming, misc-non-private-member-variables-in-classes) diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_double_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_double_test.cpp index d4414215824419de23d914f39aad30c593e4eae3..0d86aa6f3958b21c45a4fca15b0a847c9262574e 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_double_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_double_test.cpp @@ -76,6 +76,17 @@ TEST_F(VariableGetValueDoubleTest, invalid_args_value) ASSERT_EQ(env_->Variable_GetValue_Double(variable, nullptr), ANI_INVALID_ARGS); } +TEST_F(VariableGetValueDoubleTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "x", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_get_value_double_test.anyns")); + ani_double x; + ASSERT_EQ(env_->Variable_GetValue_Double(variable, &x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_get_value_double_test.anyns")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(readability-identifier-naming, misc-non-private-member-variables-in-classes) \ No newline at end of file +// NOLINTEND(readability-identifier-naming, misc-non-private-member-variables-in-classes) diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_float_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_float_test.cpp index 4a580170bd5f6decbddd9d9f9c9259be5aa8bea2..49fec8091ea6e4c6ae5d0c3b0c3c59713697f5d2 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_float_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_float_test.cpp @@ -76,6 +76,17 @@ TEST_F(VariableGetValueFloatTest, invalid_args_value) ASSERT_EQ(env_->Variable_GetValue_Float(variable, nullptr), ANI_INVALID_ARGS); } +TEST_F(VariableGetValueFloatTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "x", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_get_value_float_test.anyns")); + ani_float x; + ASSERT_EQ(env_->Variable_GetValue_Float(variable, &x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_get_value_float_test.anyns")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(readability-identifier-naming, misc-non-private-member-variables-in-classes) diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_int_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_int_test.cpp index 62e0c66c0ed2d939c81e0c0536fe0bb235a180cc..2ed888a224d55e90e8f756ac70511252b69dd6c5 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_int_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_int_test.cpp @@ -76,6 +76,17 @@ TEST_F(VariableGetValueIntTest, invalid_args_value) ASSERT_EQ(env_->Variable_GetValue_Int(variable, nullptr), ANI_INVALID_ARGS); } +TEST_F(VariableGetValueIntTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "x", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_get_value_int_test.anyns")); + ani_int x; + ASSERT_EQ(env_->Variable_GetValue_Int(variable, &x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_get_value_int_test.anyns")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(readability-identifier-naming, misc-non-private-member-variables-in-classes) \ No newline at end of file +// NOLINTEND(readability-identifier-naming, misc-non-private-member-variables-in-classes) diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_long_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_long_test.cpp index 68362e59c02253501d5b903cdade09fb1a00358b..66a3ebe76d91fb40f85d7682a0e23a6397e705a6 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_long_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_long_test.cpp @@ -75,6 +75,18 @@ TEST_F(VariableGetValueLongTest, invalid_args_value) ASSERT_EQ(env_->Variable_GetValue_Long(variable, nullptr), ANI_INVALID_ARGS); } + +TEST_F(VariableGetValueLongTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "x", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_get_value_long_test.anyns")); + ani_long x; + ASSERT_EQ(env_->Variable_GetValue_Long(variable, &x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_get_value_long_test.anyns")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(readability-identifier-naming, misc-non-private-member-variables-in-classes) diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_ref_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_ref_test.cpp index e53231e22e56844a45c7ade2e8da13bdd58ff161..cdf1f073818a1bde332388abd013636c030cc033 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_ref_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_ref_test.cpp @@ -83,6 +83,17 @@ TEST_F(VariableGetValueRefTest, invalid_args_value) ASSERT_EQ(env_->Variable_GetValue_Ref(variable, nullptr), ANI_INVALID_ARGS); } +TEST_F(VariableGetValueRefTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "name", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_get_value_ref_test.anyns")); + ani_ref x; + ASSERT_EQ(env_->Variable_GetValue_Ref(variable, &x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_get_value_ref_test.anyns")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(readability-identifier-naming, misc-non-private-member-variables-in-classes) \ No newline at end of file +// NOLINTEND(readability-identifier-naming, misc-non-private-member-variables-in-classes) diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_short_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_short_test.cpp index 385f562ea11e1fa5c5999f65a9589ef96024c115..981bbc49fe8cbc68b55948e7de68e5c924794699 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_short_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_get_value_short_test.cpp @@ -76,6 +76,17 @@ TEST_F(VariableGetValueShortTest, invalid_args_value) ASSERT_EQ(env_->Variable_GetValue_Short(variable, nullptr), ANI_INVALID_ARGS); } +TEST_F(VariableGetValueShortTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "x", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_get_value_short_test.anyns")); + ani_short x; + ASSERT_EQ(env_->Variable_GetValue_Short(variable, &x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_get_value_short_test.anyns")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(readability-identifier-naming, misc-non-private-member-variables-in-classes) \ No newline at end of file +// NOLINTEND(readability-identifier-naming, misc-non-private-member-variables-in-classes) diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_boolean_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_boolean_test.cpp index 89b7aa563048aebc35bffb8e8dc92e8418563267..95dea0e6a41d00a7d055f62599a7c1fc7bb05c40 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_boolean_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_boolean_test.cpp @@ -174,6 +174,18 @@ TEST_F(VariableSetValueBooleanTest, composite_case_4) ASSERT_EQ(env_->Variable_GetValue_Boolean(variable2, &getValue2), ANI_OK); ASSERT_EQ(getValue2, val2); } + +TEST_F(VariableSetValueBooleanTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "aBool", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_set_value_boolean_test.anyns")); + const ani_boolean x = ANI_TRUE; + ASSERT_EQ(env_->Variable_SetValue_Boolean(variable, x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_set_value_boolean_test.anyns")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-identifier-naming) \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_byte_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_byte_test.cpp index 2bdc4da998320ca49569bc8595567c728da4926c..efabc0d0d88da1403c474451ea0ca2338f5f8d86 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_byte_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_byte_test.cpp @@ -174,6 +174,18 @@ TEST_F(VariableSetValueByteTest, composite_case_4) ASSERT_EQ(env_->Variable_GetValue_Byte(variable2, &getValue2), ANI_OK); ASSERT_EQ(getValue2, val2); } + +TEST_F(VariableSetValueByteTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "aByte", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_set_value_byte_test.anyns")); + const ani_byte x = 24U; + ASSERT_EQ(env_->Variable_SetValue_Byte(variable, x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_set_value_byte_test.anyns")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-identifier-naming) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-identifier-naming) diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_char_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_char_test.cpp index a403b35538151990bee5f041f2c56a83b0f8c671..74c3c56d80b2b2803663ef32a4b4716e943adee7 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_char_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_char_test.cpp @@ -172,6 +172,18 @@ TEST_F(VariableSetValueCharTest, composite_case_4) ASSERT_EQ(env_->Variable_GetValue_Char(variable2, &getValue2), ANI_OK); ASSERT_EQ(getValue2, val2); } + +TEST_F(VariableSetValueCharTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "aChar", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_set_value_char_test.anyns")); + const ani_char x = 'A'; + ASSERT_EQ(env_->Variable_SetValue_Char(variable, x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_set_value_char_test.anyns")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-identifier-naming) \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_double_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_double_test.cpp index 062967669db64bc0d55aebbd03d58c642d941893..ac7be3544ad6800d6272a5038c23fadc1c569b76 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_double_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_double_test.cpp @@ -173,6 +173,18 @@ TEST_F(VariableSetValueDoubleTest, composite_case_4) ASSERT_EQ(env_->Variable_GetValue_Double(variable2, &getValue2), ANI_OK); ASSERT_EQ(getValue2, val2); } + +TEST_F(VariableSetValueDoubleTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "aDouble", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_set_value_double_test.anyns")); + const ani_double x = 12.07F; + ASSERT_EQ(env_->Variable_SetValue_Double(variable, x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_set_value_double_test.anyns")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-identifier-naming) \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_float_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_float_test.cpp index 99a5c558f45d0b4db08a818d0e4566f52cc0bcac..b3ba188600a11529efb68a4ffe42ed9c4643e699 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_float_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_float_test.cpp @@ -182,6 +182,18 @@ TEST_F(VariableSetValueFloatTest, composite_case_4) ASSERT_EQ(env_->Variable_GetValue_Float(variable2, &getValue2), ANI_OK); ASSERT_EQ(getValue2, val2); } + +TEST_F(VariableSetValueFloatTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "floatValue", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_set_value_float_test.anyns")); + const ani_float x = 23.01F; + ASSERT_EQ(env_->Variable_SetValue_Float(variable, x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_set_value_float_test.anyns")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-identifier-naming) \ No newline at end of file diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_int_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_int_test.cpp index c62e990cfed05db6b82fa548a8517b9c8828e444..47973e5b92829763815b4d1e4243d2919259159f 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_int_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_int_test.cpp @@ -178,6 +178,18 @@ TEST_F(VariableSetValueIntTest, composite_case_4) ASSERT_EQ(env_->Variable_GetValue_Int(variable2, &getValue2), ANI_OK); ASSERT_EQ(getValue2, val2); } + +TEST_F(VariableSetValueIntTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "intValue", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_set_value_int_test.anyns")); + const ani_int x = 217U; + ASSERT_EQ(env_->Variable_SetValue_Int(variable, x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_set_value_int_test.anyns")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-identifier-naming) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-identifier-naming) diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_long_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_long_test.cpp index 2253c3d1a3537a7afccdb75beb7b73344fef48b1..7e8202d8dded4574bb160e996ab1b14baf610354 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_long_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_long_test.cpp @@ -176,6 +176,18 @@ TEST_F(VariableSetValueLongTest, composite_case_4) ASSERT_EQ(env_->Variable_GetValue_Long(variable2, &getValue2), ANI_OK); ASSERT_EQ(getValue2, val2); } + +TEST_F(VariableSetValueLongTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "longValue", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_set_value_long_test.anyns")); + const ani_long x = 88L; + ASSERT_EQ(env_->Variable_SetValue_Long(variable, x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_set_value_long_test.anyns")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-identifier-naming) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-identifier-naming) diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_ref_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_ref_test.cpp index 7ed510bcae4ede61981d8228edf41231056e1ccc..c46b8f0a1f06abeb01b653b98596fc0d29e84d09 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_ref_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_ref_test.cpp @@ -241,6 +241,19 @@ TEST_F(VariableSetValueRefTest, composite_case_4) ASSERT_EQ(strSize, 3U); ASSERT_STREQ(buffer.data(), "UVW"); } + +TEST_F(VariableSetValueRefTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "stringValue", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_set_value_ref_test.anyns")); + ani_string string = {}; + ASSERT_EQ(env_->String_NewUTF8("VLG", 3U, &string), ANI_OK); + ASSERT_EQ(env_->Variable_SetValue_Ref(variable, string), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_set_value_ref_test.anyns")); +} + } // namespace ark::ets::ani::testing // NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-magic-numbers, diff --git a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_short_test.cpp b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_short_test.cpp index 74a86bd56bddfef6a7bc01eb40a236239625080f..9ae4d1704316730ec95154c803e64b90bf688f9a 100644 --- a/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_short_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/var_ops/variable_set_value_short_test.cpp @@ -177,6 +177,18 @@ TEST_F(VariableSetValueShortTest, composite_case_4) ASSERT_EQ(env_->Variable_GetValue_Short(variable2, &getValue2), ANI_OK); ASSERT_EQ(getValue2, val2); } + +TEST_F(VariableSetValueShortTest, check_initialization) +{ + ani_variable variable {}; + ASSERT_EQ(env_->Namespace_FindVariable(ns_, "shortValue", &variable), ANI_OK); + + ASSERT_FALSE(IsRuntimeClassInitialized("variable_set_value_short_test.anyns")); + const ani_short x = 166U; + ASSERT_EQ(env_->Variable_SetValue_Short(variable, x), ANI_OK); + ASSERT_TRUE(IsRuntimeClassInitialized("variable_set_value_short_test.anyns")); +} + } // namespace ark::ets::ani::testing -// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-identifier-naming) \ No newline at end of file +// NOLINTEND(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays, readability-identifier-naming)