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 2e83bc629e77250989f238bc3a32bfe20581bc70..7ed3a7cdc91ed3125e373428651c4dd84d095734 100644 --- a/static_core/plugins/ets/runtime/ani/ani_interaction_api.cpp +++ b/static_core/plugins/ets/runtime/ani/ani_interaction_api.cpp @@ -533,18 +533,6 @@ static std::optional ReplaceArrayInSignature(const char *signature) return ss.str(); } -// NOTE(@srokashevich, #25051): This function is used only for warnings about old mangling, remove it after issue -// resolution -static void CheckSignatureMangling(const char *str) -{ - static std::regex rgx1(":[ZCBSIJFDV]$"); - static std::regex rgx2(".*L.*;.*"); - static std::regex rgx3(".*\\[.*"); - if (std::regex_match(str, rgx1) || std::regex_match(str, rgx2) || std::regex_match(str, rgx3)) { - LOG(ERROR, ANI) << "Use new mangling rules for signature \"" << str << "\""; - } -} - template static ani_status DoGetClassMethod(EtsClass *klass, const char *name, const char *signature, EtsMethod **result) { @@ -557,16 +545,19 @@ static ani_status DoGetClassMethod(EtsClass *klass, const char *name, const char } std::optional replacedSignature; if (signature != nullptr) { - CheckSignatureMangling(signature); replacedSignature = ReplaceArrayInSignature(signature); signature = replacedSignature.has_value() ? replacedSignature->c_str() : signature; } + std::optional oldSignature = Mangle::ConvertSignature(signature); + ANI_CHECK_RETURN_IF_EQ(oldSignature.has_value(), false, ANI_INVALID_ARGS); + signature = oldSignature.value().c_str(); + // CC-OFFNXT(G.FMT.14-CPP) project code style auto *method = [klass, name, signature]() -> EtsMethod * { if constexpr (IS_STATIC_METHOD) { - return klass->GetStaticMethod(name, signature, true); + return klass->GetStaticMethod(name, signature); } else { - return klass->GetInstanceMethod(name, signature, true); + return klass->GetInstanceMethod(name, signature); } }(); @@ -576,9 +567,9 @@ static ani_status DoGetClassMethod(EtsClass *klass, const char *name, const char } PandaVector methodVec; if constexpr (IS_STATIC_METHOD) { - methodVec = klass->GetStaticMethodOverload(name, signature, true); + methodVec = klass->GetStaticMethodOverload(name, signature); } else { - methodVec = klass->GetInstanceMethodOverload(name, signature, true); + methodVec = klass->GetInstanceMethodOverload(name, signature); } if (methodVec.empty()) { return ANI_NOT_FOUND; @@ -673,12 +664,11 @@ static ani_status FindInModule(ani_env *env, ani_module module, const char *targ PandaString descriptor; ANI_CHECK_RETURN_IF_NE(etsModule->GetModulePrefix(descriptor), ANI_OK, ANI_INVALID_DESCRIPTOR); - PandaString className = Mangle::ConvertDescriptor(targetDescriptor); - ANI_CHECK_RETURN_IF_LE(className.length(), 2U, ANI_INVALID_ARGS); - ANI_CHECK_RETURN_IF_NE(className[0], 'L', ANI_INVALID_ARGS); + std::optional className = Mangle::ConvertDescriptor(targetDescriptor); + ANI_CHECK_RETURN_IF_EQ(className.has_value(), false, ANI_INVALID_ARGS); - className[0] = '/'; - descriptor += className; + className.value()[0] = '/'; + descriptor += className.value(); return DoFind(pandaEnv, descriptor.c_str(), s, result); } @@ -836,10 +826,10 @@ NO_UB_SANITIZE static ani_status FindModule(ani_env *env, const char *moduleDesc CHECK_PTR_ARG(moduleDescriptor); CHECK_PTR_ARG(result); - PandaString desc = Mangle::ConvertDescriptor(moduleDescriptor); - ANI_CHECK_RETURN_IF_LE(desc.size(), 2U, ANI_INVALID_DESCRIPTOR); - ANI_CHECK_RETURN_IF_NE(desc.back(), ';', ANI_INVALID_DESCRIPTOR); - PandaString descriptor(desc.data(), desc.size() - 1); + std::optional desc = Mangle::ConvertDescriptor(moduleDescriptor); + ANI_CHECK_RETURN_IF_EQ(desc.has_value(), false, ANI_INVALID_ARGS); + + PandaString descriptor(desc.value().data(), desc.value().size() - 1); descriptor += "/ETSGLOBAL;"; // NOTE: Check that results is namespace, #22400 @@ -853,9 +843,11 @@ NO_UB_SANITIZE static ani_status FindNamespace(ani_env *env, const char *namespa CHECK_PTR_ARG(namespaceDescriptor); CHECK_PTR_ARG(result); - PandaString desc = Mangle::ConvertDescriptor(namespaceDescriptor); + std::optional desc = Mangle::ConvertDescriptor(namespaceDescriptor); + ANI_CHECK_RETURN_IF_EQ(desc.has_value(), false, ANI_INVALID_ARGS); + // NOTE: Check that results is namespace, #22400 - return DoFind(env, desc.c_str(), result); + return DoFind(env, desc.value().c_str(), result); } NO_UB_SANITIZE static ani_status FindClass(ani_env *env, const char *classDescriptor, ani_class *result) @@ -864,10 +856,11 @@ NO_UB_SANITIZE static ani_status FindClass(ani_env *env, const char *classDescri CHECK_ENV(env); CHECK_PTR_ARG(classDescriptor); CHECK_PTR_ARG(result); - PandaString desc = Mangle::ConvertDescriptor(classDescriptor, true); + std::optional desc = Mangle::ConvertDescriptor(classDescriptor, true); + ANI_CHECK_RETURN_IF_EQ(desc.has_value(), false, ANI_INVALID_ARGS); // NOTE: Check that results is class, #22400 - return DoFind(env, desc.c_str(), result); + return DoFind(env, desc.value().c_str(), result); } // NOLINTNEXTLINE(readability-identifier-naming) @@ -1799,17 +1792,21 @@ static ani_status DoBindNativeFunctions(ani_env *env, ani_namespace ns, const an const char *signature = fn.signature; std::optional replacedSignature; if (signature != nullptr) { - CheckSignatureMangling(signature); replacedSignature = ReplaceArrayInSignature(signature); signature = replacedSignature.has_value() ? replacedSignature->c_str() : signature; } + + std::optional oldSignature = Mangle::ConvertSignature(signature); + ANI_CHECK_RETURN_IF_EQ(oldSignature.has_value(), false, ANI_INVALID_ARGS); + signature = oldSignature.value().c_str(); + // NOLINTNEXTLINE(cppcoreguidelines-pro-bounds-pointer-arithmetic) - EtsMethod *method = etsNs->GetFunction(name, signature, true); + EtsMethod *method = etsNs->GetFunction(name, signature); if (method != nullptr) { etsMethods.push_back(method); continue; } - PandaVector methodVec = etsNs->GetFunctionOverload(name, signature, true); + PandaVector methodVec = etsNs->GetFunctionOverload(name, signature); if (methodVec.size() == 1U) { etsMethods.push_back(methodVec[0]); continue; @@ -1995,7 +1992,7 @@ NO_UB_SANITIZE static ani_status FixedArray_SetRegion_Byte(ani_env *env, ani_fix static ani_status GetDirectMethodOverload(EtsClass *klass, const char *name, const char *signature, EtsMethod **result) { - PandaVector methodVec = klass->GetDirectMethodOverload(name, signature, true); + PandaVector methodVec = klass->GetDirectMethodOverload(name, signature); if (!methodVec.empty()) { ANI_CHECK_RETURN_IF_GT(methodVec.size(), 1U, ANI_AMBIGUOUS); ASSERT(methodVec.size() == 1U); @@ -2044,11 +2041,15 @@ static ani_status BindNativeMethods(ani_env *env, ani_class cls, const ani_nativ const char *signature = m.signature; std::optional replacedSignature; if (signature != nullptr) { - CheckSignatureMangling(signature); replacedSignature = ReplaceArrayInSignature(signature); signature = replacedSignature.has_value() ? replacedSignature->c_str() : signature; } EtsMethod *method = nullptr; + + std::optional oldSignature = Mangle::ConvertSignature(signature); + ANI_CHECK_RETURN_IF_EQ(oldSignature.has_value(), false, ANI_INVALID_ARGS); + signature = oldSignature.value().c_str(); + if (signature == nullptr) { bool isUnique = false; method = klass->GetDirectMethod(isStatic, name, &isUnique); @@ -6377,9 +6378,11 @@ NO_UB_SANITIZE static ani_status FindEnum(ani_env *env, const char *enumDescript CHECK_PTR_ARG(enumDescriptor); CHECK_PTR_ARG(result); - PandaString enumDesc = Mangle::ConvertDescriptor(enumDescriptor); + std::optional enumDesc = Mangle::ConvertDescriptor(enumDescriptor); + ANI_CHECK_RETURN_IF_EQ(enumDesc.has_value(), false, ANI_INVALID_ARGS); + // NOTE: Check that result is enum, #22400 - return DoFind(env, enumDesc.c_str(), result); + return DoFind(env, enumDesc.value().c_str(), result); } static ani_status GetArrayFromEnum(ScopedManagedCodeFix &s, ani_enum enm, const char *name, EtsObjectArray **result) diff --git a/static_core/plugins/ets/runtime/ani/ani_mangle.cpp b/static_core/plugins/ets/runtime/ani/ani_mangle.cpp index a891164982b4697826b5d40ae7bbf6b7a4f76fec..2ffb2dcc373a2fc7af9c3a3876213de0ee4810b0 100644 --- a/static_core/plugins/ets/runtime/ani/ani_mangle.cpp +++ b/static_core/plugins/ets/runtime/ani/ani_mangle.cpp @@ -22,14 +22,14 @@ namespace ark::ets::ani { static size_t ParseArrayBody(const std::string_view data, PandaStringStream &ss); /*static*/ -PandaString Mangle::ConvertDescriptor(const std::string_view descriptor, bool allowArray) +std::optional Mangle::ConvertDescriptor(const std::string_view descriptor, bool allowArray) { if (descriptor.empty() || descriptor.back() == ';' || descriptor.find('/') != std::string::npos) { // The 'descriptor' does not have a new format, so no conversion is required. if (!descriptor.empty()) { LOG(ERROR, ANI) << "Use new mangling rules for descriptor \"" << descriptor << "\""; } - return PandaString(descriptor); + return std::nullopt; } PandaStringStream ss; @@ -39,7 +39,7 @@ PandaString Mangle::ConvertDescriptor(const std::string_view descriptor, bool al auto bodySize = ParseArrayBody(descriptor.substr(1), ss); if (bodySize == std::string_view::npos) { // The 'descriptor' has wrong format, so can't be convert - return PandaString(""); + return std::nullopt; } return ss.str(); } @@ -112,6 +112,7 @@ static size_t ParseArrayBody(const std::string_view data, PandaStringStream &ss) static size_t ParseBody(char type, const std::string_view data, PandaStringStream &ss) { ASSERT(type != 'A'); + ASSERT(type != 'X'); if (data.size() < MIN_BODY_SIZE || data[0] != '{') { return std::string_view::npos; @@ -121,7 +122,7 @@ static size_t ParseBody(char type, const std::string_view data, PandaStringStrea continue; } PandaString oldName(data.substr(1, pos - 1)); - if (oldName.find('/') != std::string::npos) { + if (oldName.find('/') != std::string::npos || oldName.find(':') != std::string::npos) { // The new format 'descriptor' can't contain '/' return std::string_view::npos; } @@ -167,7 +168,7 @@ static size_t ParseType(char type, const std::string_view data, PandaStringStrea } /*static*/ -PandaString Mangle::ConvertSignature(const std::string_view descriptor) +std::optional Mangle::ConvertSignature(const std::string_view descriptor) { PandaStringStream ss; int nr = -1; @@ -183,14 +184,14 @@ PandaString Mangle::ConvertSignature(const std::string_view descriptor) size_t sz = ParseType(type, descriptor.substr(i), ss); if (sz == std::string_view::npos) { // The 'descriptor' does not have a new format, so no conversion is required. - return PandaString(descriptor); + return std::nullopt; } i += sz - 1; nr += k; } if (k == -1) { // The 'descriptor' does not have a ':' symbol - return PandaString(descriptor); + return std::nullopt; } if (nr == 0) { ss << 'V'; diff --git a/static_core/plugins/ets/runtime/ani/ani_mangle.h b/static_core/plugins/ets/runtime/ani/ani_mangle.h index 9c43bed5e89756908cccf3c34ec4cf42d75d2549..41509108316c4693f31eaa5ddc86a4ca208856af 100644 --- a/static_core/plugins/ets/runtime/ani/ani_mangle.h +++ b/static_core/plugins/ets/runtime/ani/ani_mangle.h @@ -22,8 +22,8 @@ namespace ark::ets::ani { class Mangle { public: - static PandaString ConvertDescriptor(const std::string_view descriptor, bool allowArray = false); - static PandaString ConvertSignature(const std::string_view descriptor); + static std::optional ConvertDescriptor(const std::string_view descriptor, bool allowArray = false); + static std::optional ConvertSignature(const std::string_view descriptor); }; } // namespace ark::ets::ani diff --git a/static_core/plugins/ets/runtime/ani/docs/mangling.md b/static_core/plugins/ets/runtime/ani/docs/mangling.md index 02a44ed0a7e6c34bbe5dcf9fc61cb95f46453f0a..c820323765cc29adcaf723303fd62d7205d4c69b 100644 --- a/static_core/plugins/ets/runtime/ani/docs/mangling.md +++ b/static_core/plugins/ets/runtime/ani/docs/mangling.md @@ -153,7 +153,7 @@ SignatureEncoding ::= function foo(a0: Integral, a1: double, arg2: float, arg3: SomeEnum): void // ANI mangled type -"C{std.core.Integral}dfE{app.ns.SomeEnum}:V" +"C{std.core.Integral}dfE{app.ns.SomeEnum}:" ``` ### Function types in arguments diff --git a/static_core/plugins/ets/runtime/interop_js/timer_module.cpp b/static_core/plugins/ets/runtime/interop_js/timer_module.cpp index c0460ee1c8b63269c11645fcb19dcadfbc3a4465..11cfccaf229f05c86c58cbaea50a438f1e77b520 100644 --- a/static_core/plugins/ets/runtime/interop_js/timer_module.cpp +++ b/static_core/plugins/ets/runtime/interop_js/timer_module.cpp @@ -84,16 +84,16 @@ __attribute__((weak)) void uv_walk([[maybe_unused]] uv_loop_t *loop, [[maybe_unu bool TimerModule::Init(ani_env *env) { ani_module module {}; - auto status = env->FindModule("Lescompat;", &module); + auto status = env->FindModule("escompat", &module); if (status != ANI_OK) { INTEROP_LOG(ERROR) << "Cannot find ESCOMPAT module"; return false; } std::array methods = { - ani_native_function {"startTimerImpl", "Lstd/core/Object;IZ:I", + ani_native_function {"startTimerImpl", "C{std.core.Object}iz:i", reinterpret_cast(TimerModule::StartTimer)}, - ani_native_function {"stopTimerImpl", "I:V", reinterpret_cast(TimerModule::StopTimer)}, + ani_native_function {"stopTimerImpl", "i:", reinterpret_cast(TimerModule::StopTimer)}, }; return env->Module_BindNativeFunctions(module, methods.data(), methods.size()) == ANI_OK; } @@ -106,7 +106,7 @@ ani_int TimerModule::StartTimer(ani_env *env, ani_object funcObject, ani_int del auto timerTable = GetTimerTable(env); ani_ref timerInfoRef {}; - static constexpr auto SIGNATURE = "Lstd/core/Object;IZJ:Lstd/concurrency/Timer;"; + static constexpr auto SIGNATURE = "C{std.core.Object}izj:C{std.concurrency.Timer}"; [[maybe_unused]] auto status = // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg) env->Object_CallMethodByName_Ref(timerTable, "createTimer", SIGNATURE, &timerInfoRef, funcObject, delayMs, @@ -116,7 +116,7 @@ ani_int TimerModule::StartTimer(ani_env *env, ani_object funcObject, ani_int del ani_int timerId {}; // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg) - status = env->Object_CallMethodByName_Int(timerInfo, "getId", ":I", &timerId); + status = env->Object_CallMethodByName_Int(timerInfo, "getId", ":i", &timerId); ASSERT(status == ANI_OK); timer->data = reinterpret_cast(timerId); @@ -214,7 +214,7 @@ std::pair TimerModule::FindTimerInfo(ani_env *env, ani_int tim { auto timerTable = GetTimerTable(env); ani_ref timerInfoRef {}; - static constexpr auto SIGNATURE = "I:Lstd/concurrency/Timer;"; + static constexpr auto SIGNATURE = "i:C{std.concurrency.Timer}"; [[maybe_unused]] ani_status status {}; // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg) status = env->Object_CallMethodByName_Ref(timerTable, "findTimer", SIGNATURE, &timerInfoRef, timerId); @@ -231,7 +231,7 @@ void TimerModule::ClearTimerInfo(ani_env *env, ani_int timerId) { auto timerTable = GetTimerTable(env); // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg) - [[maybe_unused]] auto status = env->Object_CallMethodByName_Void(timerTable, "clearTimer", "I:V", timerId); + [[maybe_unused]] auto status = env->Object_CallMethodByName_Void(timerTable, "clearTimer", "i:", timerId); ASSERT(status == ANI_OK); } diff --git a/static_core/plugins/ets/runtime/libani_helpers/concurrency_helpers.cpp b/static_core/plugins/ets/runtime/libani_helpers/concurrency_helpers.cpp index 530f73ae1e175cb1c73caf038fdf57d8581d16f1..08ceb8aefbe57f1a9151d58528692540e6623c65 100644 --- a/static_core/plugins/ets/runtime/libani_helpers/concurrency_helpers.cpp +++ b/static_core/plugins/ets/runtime/libani_helpers/concurrency_helpers.cpp @@ -102,7 +102,7 @@ WorkStatus QueueAsyncWork(ani_env *env, AsyncWork *work) } ani_class cls = nullptr; - env->FindClass("Lstd/concurrency/NativeAsyncWorkHelper;", &cls); + env->FindClass("std.concurrency.NativeAsyncWorkHelper", &cls); ani_static_method queueMethod; env->Class_FindStaticMethod(cls, "queue", nullptr, &queueMethod); // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg, modernize-avoid-c-arrays) diff --git a/static_core/plugins/ets/runtime/types/ets_class.cpp b/static_core/plugins/ets/runtime/types/ets_class.cpp index ba928ab9fe3944d268088f4d51c0a4fff9646a1f..031bb8fae650d1b3cb02a044bdffbf706435259f 100644 --- a/static_core/plugins/ets/runtime/types/ets_class.cpp +++ b/static_core/plugins/ets/runtime/types/ets_class.cpp @@ -337,10 +337,10 @@ EtsField *EtsClass::GetOwnFieldByIndex(uint32_t i) return EtsField::FromRuntimeField(&GetRuntimeClass()->GetFields()[i]); } -EtsMethod *EtsClass::GetDirectMethod(const char *name, const char *signature, bool isANIFormat) +EtsMethod *EtsClass::GetDirectMethod(const char *name, const char *signature) { auto coreName = reinterpret_cast(name); - return GetDirectMethod(coreName, signature, isANIFormat); + return GetDirectMethod(coreName, signature); } EtsMethod *EtsClass::GetDirectMethod(const char *name) @@ -350,9 +350,9 @@ EtsMethod *EtsClass::GetDirectMethod(const char *name) return EtsMethod::FromRuntimeMethod(rtMethod); } -EtsMethod *EtsClass::GetDirectMethod(const uint8_t *name, const char *signature, bool isANIFormat) +EtsMethod *EtsClass::GetDirectMethod(const uint8_t *name, const char *signature) { - EtsMethodSignature methodSignature(signature, isANIFormat); + EtsMethodSignature methodSignature(signature); if (!methodSignature.IsValid()) { LOG(ERROR, RUNTIME) << "Wrong method signature: " << signature; return nullptr; @@ -378,7 +378,7 @@ EtsMethod *EtsClass::GetDirectMethod(bool isStatic, const char *name, const char panda_file::File::StringData key = {static_cast(ark::utf::MUtf8ToUtf16Size(mutf8Name)), mutf8Name}; auto it = std::lower_bound(methods.begin(), methods.end(), key, comp); - EtsMethodSignature methodSignature(signature, true); + EtsMethodSignature methodSignature(signature); if (!methodSignature.IsValid()) { LOG(ERROR, ANI) << "Wrong method signature: " << signature; return nullptr; diff --git a/static_core/plugins/ets/runtime/types/ets_class.h b/static_core/plugins/ets/runtime/types/ets_class.h index 78083df593fa74107af7995ca86a732906ee4bcb..00bbebb71a7aaad7e75c740b089cab59d386c62d 100644 --- a/static_core/plugins/ets/runtime/types/ets_class.h +++ b/static_core/plugins/ets/runtime/types/ets_class.h @@ -130,45 +130,41 @@ public: EtsField *GetStaticFieldIDByOffset(uint32_t fieldOffset); PANDA_PUBLIC_API EtsMethod *GetDirectMethod(const char *name); - PANDA_PUBLIC_API EtsMethod *GetDirectMethod(const uint8_t *name, const char *signature, bool isANIFormat = false); - PANDA_PUBLIC_API EtsMethod *GetDirectMethod(const char *name, const char *signature, bool isANIFormat = false); + PANDA_PUBLIC_API EtsMethod *GetDirectMethod(const uint8_t *name, const char *signature); + PANDA_PUBLIC_API EtsMethod *GetDirectMethod(const char *name, const char *signature); PANDA_PUBLIC_API EtsMethod *GetDirectMethod(bool isStatic, const char *name, const char *signature) const; PANDA_PUBLIC_API EtsMethod *GetDirectMethod(bool isStatic, const char *name, bool *outIsUnique) const; - PANDA_PUBLIC_API EtsMethod *GetStaticMethod(const char *name, const char *signature, bool isANIFormat = false) const + PANDA_PUBLIC_API EtsMethod *GetStaticMethod(const char *name, const char *signature) const { if (signature == nullptr) { return GetMethodInternal(name); } - return GetMethodInternal(name, signature, isANIFormat); + return GetMethodInternal(name, signature); } - PANDA_PUBLIC_API EtsMethod *GetInstanceMethod(const char *name, const char *signature, - bool isANIFormat = false) const + PANDA_PUBLIC_API EtsMethod *GetInstanceMethod(const char *name, const char *signature) const { if (signature == nullptr) { return GetMethodInternal(name); } - return GetMethodInternal(name, signature, isANIFormat); + return GetMethodInternal(name, signature); } - PANDA_PUBLIC_API PandaVector GetStaticMethodOverload(const char *name, const char *signature, - bool isANIFormat = false) + PANDA_PUBLIC_API PandaVector GetStaticMethodOverload(const char *name, const char *signature) { - return GetMethodOverloadInternal(name, signature, isANIFormat); + return GetMethodOverloadInternal(name, signature); } - PANDA_PUBLIC_API PandaVector GetInstanceMethodOverload(const char *name, const char *signature, - bool isANIFormat = false) + PANDA_PUBLIC_API PandaVector GetInstanceMethodOverload(const char *name, const char *signature) { - return GetMethodOverloadInternal(name, signature, isANIFormat); + return GetMethodOverloadInternal(name, signature); } - PANDA_PUBLIC_API PandaVector GetDirectMethodOverload(const char *name, const char *signature, - bool isANIFormat = false) + PANDA_PUBLIC_API PandaVector GetDirectMethodOverload(const char *name, const char *signature) { - return GetMethodOverloadInternal(name, signature, isANIFormat); + return GetMethodOverloadInternal(name, signature); } PANDA_PUBLIC_API EtsMethod *GetDirectMethod(const PandaString &name, const PandaString &signature) @@ -681,9 +677,9 @@ private: } template - EtsMethod *GetMethodInternal(const char *name, const char *signature, bool isANIFormat) const + EtsMethod *GetMethodInternal(const char *name, const char *signature) const { - EtsMethodSignature methodSignature(signature, isANIFormat); + EtsMethodSignature methodSignature(signature); if (!methodSignature.IsValid()) { LOG(ERROR, ETS_NAPI) << "Wrong method signature:" << signature; return nullptr; @@ -715,7 +711,7 @@ private: std::optional &methodSignature); template - PandaVector GetMethodOverloadInternal(const char *name, const char *signature, bool isANIFormat) + PandaVector GetMethodOverloadInternal(const char *name, const char *signature) { PandaVector etsMethods; auto overloadName = PandaString(name); @@ -723,7 +719,7 @@ private: auto staticOverloadKey = OverloadKey(overloadName, true); auto instanceOverloadKey = OverloadKey(overloadName, false); if (signature) { - methodSignature.emplace(signature, isANIFormat); + methodSignature.emplace(signature); } for (auto curClass = this; curClass != nullptr; curClass = curClass->GetBase()) { if constexpr (FILTER == FindFilter::ALL || FILTER == FindFilter::STATIC) { diff --git a/static_core/plugins/ets/runtime/types/ets_method_signature.h b/static_core/plugins/ets/runtime/types/ets_method_signature.h index 8c5a9b112d1481a841bfa1ac40acd6afc449ee7c..a3ec17687f98b374a62117114c9c7ae72aad3b8c 100644 --- a/static_core/plugins/ets/runtime/types/ets_method_signature.h +++ b/static_core/plugins/ets/runtime/types/ets_method_signature.h @@ -29,10 +29,9 @@ namespace ark::ets { */ class EtsMethodSignature { public: - explicit EtsMethodSignature(const std::string_view sign, bool isANIFormat = false) + explicit EtsMethodSignature(const std::string_view sign) { - const PandaString signature = isANIFormat ? ani::Mangle::ConvertSignature(sign) : PandaString(sign); - + auto signature = PandaString(sign); size_t dots = signature.find(':'); // Return if ':' wasn't founded or was founded at the end if (dots == PandaString::npos || dots == signature.size() - 1) { diff --git a/static_core/plugins/ets/runtime/types/ets_module.h b/static_core/plugins/ets/runtime/types/ets_module.h index 1138732d5c3a6dc1492810073fc29e63ab606bbb..573cf8520ef570beabf78a9c96994bbe88b1ea7d 100644 --- a/static_core/plugins/ets/runtime/types/ets_module.h +++ b/static_core/plugins/ets/runtime/types/ets_module.h @@ -41,9 +41,9 @@ public: return EtsVariable::FromField(field); } - EtsMethod *GetFunction(const char *name, const char *signature, bool isANIFormat = false) + EtsMethod *GetFunction(const char *name, const char *signature) { - return GetStaticMethod(name, signature, isANIFormat); + return GetStaticMethod(name, signature); } ani_status GetModulePrefix(PandaString &prefix) diff --git a/static_core/plugins/ets/runtime/types/ets_namespace.h b/static_core/plugins/ets/runtime/types/ets_namespace.h index 63df5636fe9aa478149a8ea9176db4696af76ae2..d6962d52e89e6798eb1008def5cc3c5d5c5e3385 100644 --- a/static_core/plugins/ets/runtime/types/ets_namespace.h +++ b/static_core/plugins/ets/runtime/types/ets_namespace.h @@ -40,14 +40,14 @@ public: return EtsVariable::FromField(field); } - EtsMethod *GetFunction(const char *name, const char *signature, bool isANIFormat = false) + EtsMethod *GetFunction(const char *name, const char *signature) { - return GetStaticMethod(name, signature, isANIFormat); + return GetStaticMethod(name, signature); } - PandaVector GetFunctionOverload(const char *name, const char *signature, bool isANIFormat = false) + PandaVector GetFunctionOverload(const char *name, const char *signature) { - return GetStaticMethodOverload(name, signature, isANIFormat); + return GetStaticMethodOverload(name, signature); } }; diff --git a/static_core/plugins/ets/stdlib/native/escompat/RegExp.cpp b/static_core/plugins/ets/stdlib/native/escompat/RegExp.cpp index 66b2f20b28d1e792e381a65718eecdf41b1c3abf..bc12f10487f5f8a13244a8f011d729ccef4224e3 100644 --- a/static_core/plugins/ets/stdlib/native/escompat/RegExp.cpp +++ b/static_core/plugins/ets/stdlib/native/escompat/RegExp.cpp @@ -106,12 +106,12 @@ uint32_t CastToBitMask(ani_env *env, ani_string checkStr) flagsBitsTemp = FLAG_STICKY; break; default: { - ThrowNewError(env, "Lstd/core/IllegalArgumentError;", "invalid regular expression flags"); + ThrowNewError(env, "std.core.IllegalArgumentError", "invalid regular expression flags"); return 0; } } if ((flagsBits & flagsBitsTemp) != 0) { - ThrowNewError(env, "Lstd/core/IllegalArgumentError;", "invalid regular expression flags"); + ThrowNewError(env, "std.core.IllegalArgumentError", "invalid regular expression flags"); return 0; } flagsBits |= flagsBitsTemp; @@ -138,7 +138,7 @@ std::vector ExtractStringAsUtf16(ani_env *env, ani_string strANI, const } auto *buffer = new uint16_t[bufferSize]; if (buffer == nullptr) { - ThrowNewError(env, "Lstd/core/OutOfMemoryError;", "Can't create buffer"); + ThrowNewError(env, "std.core.OutOfMemoryError", "Can't create buffer"); return result; } ani_size strSize; @@ -160,7 +160,7 @@ std::vector ExtractStringAsUtf16(ani_env *env, ani_string strANI, const } char *buffer = new char[bufferSize]; if (buffer == nullptr) { - ThrowNewError(env, "Lstd/core/OutOfMemoryError;", "Can't create buffer"); + ThrowNewError(env, "std.core.OutOfMemoryError", "Can't create buffer"); return result; } ani_size strSize; diff --git a/static_core/plugins/ets/stdlib/native/escompat/regexp/regexp.cpp b/static_core/plugins/ets/stdlib/native/escompat/regexp/regexp.cpp index 8012727670658aab4e23cfb118583fea14dfd4eb..2134462aab751706f91c214a6e3a443fb150c3ac 100644 --- a/static_core/plugins/ets/stdlib/native/escompat/regexp/regexp.cpp +++ b/static_core/plugins/ets/stdlib/native/escompat/regexp/regexp.cpp @@ -102,7 +102,7 @@ void EtsRegExp::SetUnicodeFlag(const char &chr) void EtsRegExp::ThrowBadFlagsException(ani_env *env) { - ThrowNewError(env, "Lstd/core/RuntimeError;", "invalid regular expression flags"); + ThrowNewError(env, "std.core.RuntimeError", "invalid regular expression flags"); } void EtsRegExp::SetIfNotSet(bool &flag) 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 53cf195150ed9fe15c37d06b6eba647b1416ff1e..d73cddd934efdad89e90f255af84548a44633686 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 @@ -138,17 +138,18 @@ public: bool IsRuntimeClassInitialized(std::string_view classDescriptor, bool isClass = true) { - PandaString desc; + std::optional desc; if (isClass) { desc = Mangle::ConvertDescriptor(classDescriptor, true); } else { desc = Mangle::ConvertDescriptor(std::string(classDescriptor) + ".ETSGLOBAL", true); } + ASSERT(desc.has_value()); PandaEnv *pandaEnv = PandaEnv::FromAniEnv(env_); ScopedManagedCodeFix s(pandaEnv); EtsClassLinker *classLinker = pandaEnv->GetEtsVM()->GetClassLinker(); - EtsClass *klass = classLinker->GetClass(desc.c_str(), true, GetClassLinkerContext(s.GetCoroutine())); + EtsClass *klass = classLinker->GetClass(desc.value().c_str(), true, GetClassLinkerContext(s.GetCoroutine())); ASSERT(klass); return klass->IsInitialized(); diff --git a/static_core/plugins/ets/tests/ani/tests/mangling/mangle_descriptor_test.cpp b/static_core/plugins/ets/tests/ani/tests/mangling/mangle_descriptor_test.cpp index ff1ad68e48dee2b0e39d19ad753049afca2ad342..f9e838a8a0cdcd70313b994f100525a4a2497d41 100644 --- a/static_core/plugins/ets/tests/ani/tests/mangling/mangle_descriptor_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/mangling/mangle_descriptor_test.cpp @@ -22,77 +22,90 @@ class MangleDescriptorTest : public AniTest {}; TEST_F(MangleDescriptorTest, Format_NewToOld) { - PandaString desc; + std::optional desc; desc = Mangle::ConvertDescriptor("a"); - EXPECT_STREQ(desc.c_str(), "La;"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "La;"); desc = Mangle::ConvertDescriptor("a.b"); - EXPECT_STREQ(desc.c_str(), "La/b;"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "La/b;"); desc = Mangle::ConvertDescriptor("a.b.c"); - EXPECT_STREQ(desc.c_str(), "La/b/c;"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "La/b/c;"); desc = Mangle::ConvertDescriptor("A{C{a.b.c}}"); - EXPECT_STREQ(desc.c_str(), "LA{C{a/b/c}};"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "LA{C{a/b/c}};"); desc = Mangle::ConvertDescriptor("A{A{C{a.b.c}}}"); - EXPECT_STREQ(desc.c_str(), "LA{A{C{a/b/c}}};"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "LA{A{C{a/b/c}}};"); desc = Mangle::ConvertDescriptor("A{A{E{a.b.c}}}"); - EXPECT_STREQ(desc.c_str(), "LA{A{E{a/b/c}}};"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "LA{A{E{a/b/c}}};"); desc = Mangle::ConvertDescriptor("A{A{A{C{a.b.c}}}}"); - EXPECT_STREQ(desc.c_str(), "LA{A{A{C{a/b/c}}}};"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "LA{A{A{C{a/b/c}}}};"); desc = Mangle::ConvertDescriptor("A{C{a.b.c}}", true); - EXPECT_STREQ(desc.c_str(), "[La/b/c;"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[La/b/c;"); desc = Mangle::ConvertDescriptor("A{A{C{a.b.c}}}", true); - EXPECT_STREQ(desc.c_str(), "[[La/b/c;"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[[La/b/c;"); desc = Mangle::ConvertDescriptor("A{A{E{a.b.c}}}", true); - EXPECT_STREQ(desc.c_str(), "[[La/b/c;"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[[La/b/c;"); desc = Mangle::ConvertDescriptor("A{A{A{C{a.b.c}}}}", true); - EXPECT_STREQ(desc.c_str(), "[[[La/b/c;"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[[[La/b/c;"); desc = Mangle::ConvertDescriptor("C{a.b.c}"); - EXPECT_STREQ(desc.c_str(), "LC{a/b/c};"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "LC{a/b/c};"); desc = Mangle::ConvertDescriptor("C{a.b.c}", true); - EXPECT_STREQ(desc.c_str(), "LC{a/b/c};"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "LC{a/b/c};"); } TEST_F(MangleDescriptorTest, Format_OldToOld) { - PandaString desc; + std::optional desc; desc = Mangle::ConvertDescriptor("La;"); - EXPECT_STREQ(desc.c_str(), "La;"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertDescriptor("La/b;"); - EXPECT_STREQ(desc.c_str(), "La/b;"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertDescriptor("La/b/c;"); - EXPECT_STREQ(desc.c_str(), "La/b/c;"); + ASSERT_FALSE(desc.has_value()); } TEST_F(MangleDescriptorTest, Format_Wrong) { - PandaString desc; + std::optional desc; desc = Mangle::ConvertDescriptor(""); - EXPECT_STREQ(desc.c_str(), ""); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertDescriptor("a;"); - EXPECT_STREQ(desc.c_str(), "a;"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertDescriptor("a/b"); - EXPECT_STREQ(desc.c_str(), "a/b"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertDescriptor("a/b/c"); - EXPECT_STREQ(desc.c_str(), "a/b/c"); + ASSERT_FALSE(desc.has_value()); } TEST_F(MangleDescriptorTest, FindModule) @@ -104,7 +117,7 @@ TEST_F(MangleDescriptorTest, FindModule) TEST_F(MangleDescriptorTest, FindModule_OldFormat) { ani_module mod {}; - EXPECT_EQ(env_->FindModule("Lmm/mangle_descriptor_test;", &mod), ANI_OK); + EXPECT_EQ(env_->FindModule("Lmm/mangle_descriptor_test;", &mod), ANI_INVALID_ARGS); } TEST_F(MangleDescriptorTest, FindNamespace) @@ -117,8 +130,8 @@ TEST_F(MangleDescriptorTest, FindNamespace) TEST_F(MangleDescriptorTest, FindNamespace_OldFormat) { ani_namespace ns {}; - EXPECT_EQ(env_->FindNamespace("Lmm/mangle_descriptor_test/rls;", &ns), ANI_OK); - EXPECT_EQ(env_->FindNamespace("Lmm/mangle_descriptor_test/rls/ns;", &ns), ANI_OK); + EXPECT_EQ(env_->FindNamespace("Lmm/mangle_descriptor_test/rls;", &ns), ANI_INVALID_ARGS); + EXPECT_EQ(env_->FindNamespace("Lmm/mangle_descriptor_test/rls/ns;", &ns), ANI_INVALID_ARGS); } TEST_F(MangleDescriptorTest, FindClass) @@ -140,12 +153,12 @@ TEST_F(MangleDescriptorTest, FindClass) TEST_F(MangleDescriptorTest, FindClass_OldFormat) { ani_class cls {}; - EXPECT_EQ(env_->FindClass("Lmm/mangle_descriptor_test/A;", &cls), ANI_OK); - EXPECT_EQ(env_->FindClass("Lmm/mangle_descriptor_test/B;", &cls), ANI_OK); - EXPECT_EQ(env_->FindClass("Lmm/mangle_descriptor_test/rls/A;", &cls), ANI_OK); - EXPECT_EQ(env_->FindClass("Lmm/mangle_descriptor_test/rls/B;", &cls), ANI_OK); - EXPECT_EQ(env_->FindClass("Lmm/mangle_descriptor_test/rls/ns/A;", &cls), ANI_OK); - EXPECT_EQ(env_->FindClass("Lmm/mangle_descriptor_test/rls/ns/B;", &cls), ANI_OK); + EXPECT_EQ(env_->FindClass("Lmm/mangle_descriptor_test/A;", &cls), ANI_INVALID_ARGS); + EXPECT_EQ(env_->FindClass("Lmm/mangle_descriptor_test/B;", &cls), ANI_INVALID_ARGS); + EXPECT_EQ(env_->FindClass("Lmm/mangle_descriptor_test/rls/A;", &cls), ANI_INVALID_ARGS); + EXPECT_EQ(env_->FindClass("Lmm/mangle_descriptor_test/rls/B;", &cls), ANI_INVALID_ARGS); + EXPECT_EQ(env_->FindClass("Lmm/mangle_descriptor_test/rls/ns/A;", &cls), ANI_INVALID_ARGS); + EXPECT_EQ(env_->FindClass("Lmm/mangle_descriptor_test/rls/ns/B;", &cls), ANI_INVALID_ARGS); } TEST_F(MangleDescriptorTest, FindEnum) @@ -160,9 +173,9 @@ TEST_F(MangleDescriptorTest, FindEnum) TEST_F(MangleDescriptorTest, FindEnum_OldFormat) { ani_enum enm {}; - EXPECT_EQ(env_->FindEnum("Lmm/mangle_descriptor_test/E;", &enm), ANI_OK); - EXPECT_EQ(env_->FindEnum("Lmm/mangle_descriptor_test/rls/E;", &enm), ANI_OK); - EXPECT_EQ(env_->FindEnum("Lmm/mangle_descriptor_test/rls/ns/E;", &enm), ANI_OK); + EXPECT_EQ(env_->FindEnum("Lmm/mangle_descriptor_test/E;", &enm), ANI_INVALID_ARGS); + EXPECT_EQ(env_->FindEnum("Lmm/mangle_descriptor_test/rls/E;", &enm), ANI_INVALID_ARGS); + EXPECT_EQ(env_->FindEnum("Lmm/mangle_descriptor_test/rls/ns/E;", &enm), ANI_INVALID_ARGS); } } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/ani/tests/mangling/mangle_signature_test.cpp b/static_core/plugins/ets/tests/ani/tests/mangling/mangle_signature_test.cpp index 243d0400dd6d7813406ea5debd063a27f9d01853..630760c101e597461740e3f78ea38e6b97e54be2 100644 --- a/static_core/plugins/ets/tests/ani/tests/mangling/mangle_signature_test.cpp +++ b/static_core/plugins/ets/tests/ani/tests/mangling/mangle_signature_test.cpp @@ -36,367 +36,417 @@ static constexpr std::string_view NAMESPACE_FOO1_UNION_SIGNATURE = TEST_F(MangleSignatureTest, FormatVoid_NewToOld) { - PandaString desc; + std::optional desc; desc = Mangle::ConvertSignature(":"); - EXPECT_STREQ(desc.c_str(), ":V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":V"); } TEST_F(MangleSignatureTest, FormatVoid_OldToOld) { - PandaString desc; + std::optional desc; desc = Mangle::ConvertSignature(":V"); - EXPECT_STREQ(desc.c_str(), ":V"); + ASSERT_FALSE(desc.has_value()); } TEST_F(MangleSignatureTest, FormatPrimitives_NewToOld) { - PandaString desc; + std::optional desc; // Check 'boolean' desc = Mangle::ConvertSignature("z:"); - EXPECT_STREQ(desc.c_str(), "Z:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "Z:V"); desc = Mangle::ConvertSignature(":z"); - EXPECT_STREQ(desc.c_str(), ":Z"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":Z"); // Check 'char' desc = Mangle::ConvertSignature("c:"); - EXPECT_STREQ(desc.c_str(), "C:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "C:V"); desc = Mangle::ConvertSignature(":c"); - EXPECT_STREQ(desc.c_str(), ":C"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":C"); // Check 'byte' desc = Mangle::ConvertSignature("b:"); - EXPECT_STREQ(desc.c_str(), "B:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "B:V"); desc = Mangle::ConvertSignature(":b"); - EXPECT_STREQ(desc.c_str(), ":B"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":B"); // Check 'short' desc = Mangle::ConvertSignature("s:"); - EXPECT_STREQ(desc.c_str(), "S:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "S:V"); desc = Mangle::ConvertSignature(":s"); - EXPECT_STREQ(desc.c_str(), ":S"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":S"); // Check 'int' desc = Mangle::ConvertSignature("i:"); - EXPECT_STREQ(desc.c_str(), "I:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "I:V"); desc = Mangle::ConvertSignature(":i"); - EXPECT_STREQ(desc.c_str(), ":I"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":I"); // Check 'long' desc = Mangle::ConvertSignature("l:"); - EXPECT_STREQ(desc.c_str(), "J:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "J:V"); desc = Mangle::ConvertSignature(":l"); - EXPECT_STREQ(desc.c_str(), ":J"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":J"); // Check 'float' desc = Mangle::ConvertSignature("f:"); - EXPECT_STREQ(desc.c_str(), "F:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "F:V"); desc = Mangle::ConvertSignature(":f"); - EXPECT_STREQ(desc.c_str(), ":F"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":F"); // Check 'double' desc = Mangle::ConvertSignature("d:"); - EXPECT_STREQ(desc.c_str(), "D:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "D:V"); desc = Mangle::ConvertSignature(":d"); - EXPECT_STREQ(desc.c_str(), ":D"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":D"); // Check mixed primitives desc = Mangle::ConvertSignature("zcbsilfd:z"); - EXPECT_STREQ(desc.c_str(), "ZCBSIJFD:Z"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "ZCBSIJFD:Z"); } TEST_F(MangleSignatureTest, FormatPrimitives_OldToOld) { - PandaString desc; + std::optional desc; // Check 'boolean' desc = Mangle::ConvertSignature("Z:V"); - EXPECT_STREQ(desc.c_str(), "Z:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":Z"); - EXPECT_STREQ(desc.c_str(), ":Z"); + ASSERT_FALSE(desc.has_value()); // Check 'char' desc = Mangle::ConvertSignature("C:V"); - EXPECT_STREQ(desc.c_str(), "C:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":C"); - EXPECT_STREQ(desc.c_str(), ":C"); + ASSERT_FALSE(desc.has_value()); // Check 'byte' desc = Mangle::ConvertSignature("B:V"); - EXPECT_STREQ(desc.c_str(), "B:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":B"); - EXPECT_STREQ(desc.c_str(), ":B"); + ASSERT_FALSE(desc.has_value()); // Check 'short' desc = Mangle::ConvertSignature("S:V"); - EXPECT_STREQ(desc.c_str(), "S:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":S"); - EXPECT_STREQ(desc.c_str(), ":S"); + ASSERT_FALSE(desc.has_value()); // Check 'int' desc = Mangle::ConvertSignature("I:V"); - EXPECT_STREQ(desc.c_str(), "I:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":I"); - EXPECT_STREQ(desc.c_str(), ":I"); + ASSERT_FALSE(desc.has_value()); // Check 'long' desc = Mangle::ConvertSignature("J:V"); - EXPECT_STREQ(desc.c_str(), "J:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":J"); - EXPECT_STREQ(desc.c_str(), ":J"); + ASSERT_FALSE(desc.has_value()); // Check 'float' desc = Mangle::ConvertSignature("F:V"); - EXPECT_STREQ(desc.c_str(), "F:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":F"); - EXPECT_STREQ(desc.c_str(), ":F"); + ASSERT_FALSE(desc.has_value()); // Check 'double' desc = Mangle::ConvertSignature("D:V"); - EXPECT_STREQ(desc.c_str(), "D:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":D"); - EXPECT_STREQ(desc.c_str(), ":D"); + ASSERT_FALSE(desc.has_value()); // Check mixed primitives desc = Mangle::ConvertSignature("ZCBSIJFD:Z"); - EXPECT_STREQ(desc.c_str(), "ZCBSIJFD:Z"); + ASSERT_FALSE(desc.has_value()); } TEST_F(MangleSignatureTest, FormatNullAndUndefined_NewToOld) { - PandaString desc; + std::optional desc; desc = Mangle::ConvertSignature("N:"); - EXPECT_STREQ(desc.c_str(), "Lstd/core/Null;:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "Lstd/core/Null;:V"); desc = Mangle::ConvertSignature(":N"); - EXPECT_STREQ(desc.c_str(), ":Lstd/core/Null;"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":Lstd/core/Null;"); desc = Mangle::ConvertSignature("U:"); - EXPECT_STREQ(desc.c_str(), "Lstd/core/Object;:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "Lstd/core/Object;:V"); desc = Mangle::ConvertSignature(":U"); - EXPECT_STREQ(desc.c_str(), ":Lstd/core/Object;"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":Lstd/core/Object;"); } TEST_F(MangleSignatureTest, FormatReferences_NewToOld) { - PandaString desc; + std::optional desc; // Check 'class' desc = Mangle::ConvertSignature("C{std.core.Object}:"); - EXPECT_STREQ(desc.c_str(), "Lstd/core/Object;:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "Lstd/core/Object;:V"); desc = Mangle::ConvertSignature(":C{std.core.Object}"); - EXPECT_STREQ(desc.c_str(), ":Lstd/core/Object;"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":Lstd/core/Object;"); // Check 'enume' desc = Mangle::ConvertSignature("E{a.b.c.Color}:"); - EXPECT_STREQ(desc.c_str(), "La/b/c/Color;:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "La/b/c/Color;:V"); desc = Mangle::ConvertSignature(":E{a.b.c.Color}"); - EXPECT_STREQ(desc.c_str(), ":La/b/c/Color;"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":La/b/c/Color;"); // Check 'Partial' desc = Mangle::ConvertSignature("P{a.b.c.X}:"); - EXPECT_STREQ(desc.c_str(), "La/b/c/X$partial;:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "La/b/c/X$partial;:V"); desc = Mangle::ConvertSignature(":P{a.b.c.X}"); - EXPECT_STREQ(desc.c_str(), ":La/b/c/X$partial;"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":La/b/c/X$partial;"); } TEST_F(MangleSignatureTest, FormatPrimitivesFixedArray_NewToOld) { - PandaString desc; + std::optional desc; // Check 'FixedArray' desc = Mangle::ConvertSignature("A{z}:"); - EXPECT_STREQ(desc.c_str(), "[Z:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[Z:V"); desc = Mangle::ConvertSignature(":A{z}"); - EXPECT_STREQ(desc.c_str(), ":[Z"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":[Z"); // Check 'FixedArray' desc = Mangle::ConvertSignature("A{c}:"); - EXPECT_STREQ(desc.c_str(), "[C:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[C:V"); desc = Mangle::ConvertSignature(":A{c}"); - EXPECT_STREQ(desc.c_str(), ":[C"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":[C"); // Check 'FixedArray' desc = Mangle::ConvertSignature("A{b}:"); - EXPECT_STREQ(desc.c_str(), "[B:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[B:V"); desc = Mangle::ConvertSignature(":A{b}"); - EXPECT_STREQ(desc.c_str(), ":[B"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":[B"); // Check 'FixedArray' desc = Mangle::ConvertSignature("A{s}:"); - EXPECT_STREQ(desc.c_str(), "[S:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[S:V"); desc = Mangle::ConvertSignature(":A{s}"); - EXPECT_STREQ(desc.c_str(), ":[S"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":[S"); // Check 'FixedArray' desc = Mangle::ConvertSignature("i:"); - EXPECT_STREQ(desc.c_str(), "I:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "I:V"); desc = Mangle::ConvertSignature(":i"); - EXPECT_STREQ(desc.c_str(), ":I"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":I"); // Check 'FixedArray' desc = Mangle::ConvertSignature("A{l}:"); - EXPECT_STREQ(desc.c_str(), "[J:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[J:V"); desc = Mangle::ConvertSignature(":A{l}"); - EXPECT_STREQ(desc.c_str(), ":[J"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":[J"); // Check 'FixedArray' desc = Mangle::ConvertSignature("A{f}:"); - EXPECT_STREQ(desc.c_str(), "[F:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[F:V"); desc = Mangle::ConvertSignature(":A{f}"); - EXPECT_STREQ(desc.c_str(), ":[F"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":[F"); // Check 'FixedArray' desc = Mangle::ConvertSignature("A{d}:"); - EXPECT_STREQ(desc.c_str(), "[D:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[D:V"); desc = Mangle::ConvertSignature(":A{d}"); - EXPECT_STREQ(desc.c_str(), ":[D"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), ":[D"); // Check mixed 'FixedArray' types desc = Mangle::ConvertSignature("A{z}A{c}A{b}A{s}A{i}A{l}A{f}A{d}:A{b}"); - EXPECT_STREQ(desc.c_str(), "[Z[C[B[S[I[J[F[D:[B"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[Z[C[B[S[I[J[F[D:[B"); // Check nested 'FixedArray' types desc = Mangle::ConvertSignature("A{A{A{A{A{c}}}}}:A{b}"); - EXPECT_STREQ(desc.c_str(), "[[[[[C:[B"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[[[[[C:[B"); } TEST_F(MangleSignatureTest, FormatPrimitivesFixedArray_OldToOld) { - PandaString desc; + std::optional desc; // Check 'FixedArray' desc = Mangle::ConvertSignature("[Z:V"); - EXPECT_STREQ(desc.c_str(), "[Z:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":[Z"); - EXPECT_STREQ(desc.c_str(), ":[Z"); + ASSERT_FALSE(desc.has_value()); // Check 'FixedArray' desc = Mangle::ConvertSignature("[C:V"); - EXPECT_STREQ(desc.c_str(), "[C:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":[C"); - EXPECT_STREQ(desc.c_str(), ":[C"); + ASSERT_FALSE(desc.has_value()); // Check 'FixedArray' desc = Mangle::ConvertSignature("[B:V"); - EXPECT_STREQ(desc.c_str(), "[B:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":[B"); - EXPECT_STREQ(desc.c_str(), ":[B"); - + ASSERT_FALSE(desc.has_value()); // Check 'FixedArray' desc = Mangle::ConvertSignature("[S:V"); - EXPECT_STREQ(desc.c_str(), "[S:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":[S"); - EXPECT_STREQ(desc.c_str(), ":[S"); + ASSERT_FALSE(desc.has_value()); // Check 'FixedArray' desc = Mangle::ConvertSignature("I:V"); - EXPECT_STREQ(desc.c_str(), "I:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":I"); - EXPECT_STREQ(desc.c_str(), ":I"); + ASSERT_FALSE(desc.has_value()); // Check 'FixedArray' desc = Mangle::ConvertSignature("[J:V"); - EXPECT_STREQ(desc.c_str(), "[J:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":[J"); - EXPECT_STREQ(desc.c_str(), ":[J"); + ASSERT_FALSE(desc.has_value()); // Check 'FixedArray' desc = Mangle::ConvertSignature("[F:V"); - EXPECT_STREQ(desc.c_str(), "[F:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":[F"); - EXPECT_STREQ(desc.c_str(), ":[F"); + ASSERT_FALSE(desc.has_value()); // Check 'FixedArray' desc = Mangle::ConvertSignature("[D:V"); - EXPECT_STREQ(desc.c_str(), "[D:V"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":[D"); - EXPECT_STREQ(desc.c_str(), ":[D"); + ASSERT_FALSE(desc.has_value()); // Check mixed 'FixedArray' types desc = Mangle::ConvertSignature("[Z[C[B[S[I[J[F[D:[B"); - EXPECT_STREQ(desc.c_str(), "[Z[C[B[S[I[J[F[D:[B"); + ASSERT_FALSE(desc.has_value()); // Check nested 'FixedArray' types desc = Mangle::ConvertSignature("[[[[[C:[B"); - EXPECT_STREQ(desc.c_str(), "[[[[[C:[B"); + ASSERT_FALSE(desc.has_value()); } TEST_F(MangleSignatureTest, FormatReferencesFixedArray_NewToOld) { - PandaString desc; + std::optional desc; desc = Mangle::ConvertSignature("A{C{std.core.String}}dA{A{E{a.b.Color}}}:A{P{a.b.X}}"); - EXPECT_STREQ(desc.c_str(), "[Lstd/core/String;D[[La/b/Color;:[La/b/X$partial;"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "[Lstd/core/String;D[[La/b/Color;:[La/b/X$partial;"); } TEST_F(MangleSignatureTest, FormatReferencesFixedArray_OldToOld) { - PandaString desc; + std::optional desc; desc = Mangle::ConvertSignature("[Lstd/core/String;D[[La/b/Color;:[La/b/X$partial;"); - EXPECT_STREQ(desc.c_str(), "[Lstd/core/String;D[[La/b/Color;:[La/b/X$partial;"); + ASSERT_FALSE(desc.has_value()); } TEST_F(MangleSignatureTest, FormatUnion_NewToRuntime) { - PandaString desc; + std::optional desc; // type F = (u: a.b | double | FixedArray) => null | e desc = Mangle::ConvertSignature("X{C{a.b}C{std.core.Double}A{i}}:X{NE{e}}"); - EXPECT_STREQ(desc.c_str(), "{ULa/b;[ILstd/core/Double;}:{ULe;Lstd/core/Null;}"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "{ULa/b;[ILstd/core/Double;}:{ULe;Lstd/core/Null;}"); // type F = (u: (e | double) | FixedArray) => void desc = Mangle::ConvertSignature("X{X{E{e}C{std.core.Double}}A{X{A{C{std.core.String}}C{std.core.FunctionR1}}}}:"); - EXPECT_STREQ(desc.c_str(), "{U{ULe;Lstd/core/Double;}[{ULstd/core/FunctionR1;[Lstd/core/String;}}:V"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "{U{ULe;Lstd/core/Double;}[{ULstd/core/FunctionR1;[Lstd/core/String;}}:V"); // type F = (u: number | string | FixedArray) => (msig.E | msig.B) | Partial desc = Mangle::ConvertSignature(FOO_UNION_SIGNATURE); - EXPECT_STREQ(desc.c_str(), "{ULstd/core/Double;Lstd/core/String;[C}:{ULmsig/A$partial;Lmsig/B;Lmsig/E;}"); + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "{ULstd/core/Double;Lstd/core/String;[C}:{ULmsig/A$partial;Lmsig/B;Lmsig/E;}"); // type F = (u: T | V | A | number): FixedArray | null | V desc = Mangle::ConvertSignature(FOO1_UNION_SIGNATURE); - EXPECT_STREQ(desc.c_str(), + ASSERT_TRUE(desc.has_value()); + EXPECT_STREQ(desc.value().c_str(), "{ULmsig/A;Lstd/core/Double;Lstd/core/String;}:{ULmsig/A;[Lmsig/A;Lstd/core/Null;Lstd/core/String;}"); } TEST_F(MangleSignatureTest, Format_Wrong) { - PandaString desc; + std::optional desc; desc = Mangle::ConvertSignature(""); - EXPECT_STREQ(desc.c_str(), ""); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature("b:A{A{c}"); - EXPECT_STREQ(desc.c_str(), "b:A{A{c}"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature("A{A{c}}}:z"); - EXPECT_STREQ(desc.c_str(), "A{A{c}}}:z"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature("A{A{c}}"); - EXPECT_STREQ(desc.c_str(), "A{A{c}}"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature("C{a:b}:f"); - EXPECT_STREQ(desc.c_str(), "La:b;:F"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature("C{a/b}:"); - EXPECT_STREQ(desc.c_str(), "C{a/b}:"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature("A{C{a/b}}:"); - EXPECT_STREQ(desc.c_str(), "A{C{a/b}}:"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature("C{a.b}:C{a/b}"); - EXPECT_STREQ(desc.c_str(), "C{a.b}:C{a/b}"); + ASSERT_FALSE(desc.has_value()); desc = Mangle::ConvertSignature(":X{C{a.b}C{c/d}}"); - EXPECT_STREQ(desc.c_str(), ":X{C{a.b}C{c/d}}"); + ASSERT_FALSE(desc.has_value()); } TEST_F(MangleSignatureTest, Module_FindFunction) { - PandaString desc; + std::optional desc; ani_module m {}; ASSERT_EQ(env_->FindModule("msig", &m), ANI_OK); @@ -422,31 +472,31 @@ TEST_F(MangleSignatureTest, Module_FindFunction) TEST_F(MangleSignatureTest, Module_FindFunction_OldFormat) { - PandaString desc; + std::optional desc; ani_module m {}; ASSERT_EQ(env_->FindModule("msig", &m), ANI_OK); ani_function fn {}; - EXPECT_EQ(env_->Module_FindFunction(m, "foo", ":V", &fn), ANI_OK); + EXPECT_EQ(env_->Module_FindFunction(m, "foo", ":V", &fn), ANI_INVALID_ARGS); // Check primitives - EXPECT_EQ(env_->Module_FindFunction(m, "foo", "Z:V", &fn), ANI_OK); - EXPECT_EQ(env_->Module_FindFunction(m, "foo", "C:V", &fn), ANI_OK); - EXPECT_EQ(env_->Module_FindFunction(m, "foo", "S:V", &fn), ANI_OK); - EXPECT_EQ(env_->Module_FindFunction(m, "foo", "I:V", &fn), ANI_OK); - EXPECT_EQ(env_->Module_FindFunction(m, "foo", "J:V", &fn), ANI_OK); - EXPECT_EQ(env_->Module_FindFunction(m, "foo", "F:V", &fn), ANI_OK); - EXPECT_EQ(env_->Module_FindFunction(m, "foo", "D:V", &fn), ANI_OK); + EXPECT_EQ(env_->Module_FindFunction(m, "foo", "Z:V", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Module_FindFunction(m, "foo", "C:V", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Module_FindFunction(m, "foo", "S:V", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Module_FindFunction(m, "foo", "I:V", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Module_FindFunction(m, "foo", "J:V", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Module_FindFunction(m, "foo", "F:V", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Module_FindFunction(m, "foo", "D:V", &fn), ANI_INVALID_ARGS); // Check references - EXPECT_EQ(env_->Module_FindFunction(m, "foo", "DLmsig/A;Lmsig/B;:Lmsig/E;", &fn), ANI_OK); - EXPECT_EQ(env_->Module_FindFunction(m, "foo", "Lmsig/A$partial;Lescompat/Array;:V", &fn), ANI_OK); + EXPECT_EQ(env_->Module_FindFunction(m, "foo", "DLmsig/A;Lmsig/B;:Lmsig/E;", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Module_FindFunction(m, "foo", "Lmsig/A$partial;Lescompat/Array;:V", &fn), ANI_INVALID_ARGS); } TEST_F(MangleSignatureTest, Namespace_FindFunction) { - PandaString desc; + std::optional desc; ani_namespace ns {}; ASSERT_EQ(env_->FindNamespace("msig.rls", &ns), ANI_OK); @@ -472,31 +522,31 @@ TEST_F(MangleSignatureTest, Namespace_FindFunction) TEST_F(MangleSignatureTest, Namespace_FindFunction_OldFormat) { - PandaString desc; + std::optional desc; ani_namespace ns {}; ASSERT_EQ(env_->FindNamespace("msig.rls", &ns), ANI_OK); ani_function fn {}; - EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", ":V", &fn), ANI_OK); + EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", ":V", &fn), ANI_INVALID_ARGS); // Check primitives - EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "Z:V", &fn), ANI_OK); - EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "C:V", &fn), ANI_OK); - EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "S:V", &fn), ANI_OK); - EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "I:V", &fn), ANI_OK); - EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "J:V", &fn), ANI_OK); - EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "F:V", &fn), ANI_OK); - EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "D:V", &fn), ANI_OK); + EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "Z:V", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "C:V", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "S:V", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "I:V", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "J:V", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "F:V", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "D:V", &fn), ANI_INVALID_ARGS); // Check references - EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "DLmsig/rls/A;Lmsig/rls/B;:Lmsig/rls/E;", &fn), ANI_OK); - EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "Lmsig/A$partial;Lescompat/Array;:V", &fn), ANI_OK); + EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "DLmsig/rls/A;Lmsig/rls/B;:Lmsig/rls/E;", &fn), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Namespace_FindFunction(ns, "foo", "Lmsig/A$partial;Lescompat/Array;:V", &fn), ANI_INVALID_ARGS); } TEST_F(MangleSignatureTest, Class_FindMethod) { - PandaString desc; + std::optional desc; ani_class cls {}; ASSERT_EQ(env_->FindClass("msig.F", &cls), ANI_OK); @@ -522,31 +572,31 @@ TEST_F(MangleSignatureTest, Class_FindMethod) TEST_F(MangleSignatureTest, Class_FindMethod_OldFormat) { - PandaString desc; + std::optional desc; ani_class cls {}; - ASSERT_EQ(env_->FindClass("Lmsig/F;", &cls), ANI_OK); + ASSERT_EQ(env_->FindClass("msig.F", &cls), ANI_OK); ani_method method {}; - EXPECT_EQ(env_->Class_FindMethod(cls, "foo", ":V", &method), ANI_OK); + EXPECT_EQ(env_->Class_FindMethod(cls, "foo", ":V", &method), ANI_INVALID_ARGS); // Check primitives - EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "Z:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "C:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "S:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "I:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "J:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "F:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "D:V", &method), ANI_OK); + EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "Z:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "C:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "S:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "I:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "J:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "F:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "D:V", &method), ANI_INVALID_ARGS); // Check references - EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "DLmsig/A;Lmsig/B;:Lmsig/E;", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "Lmsig/A$partial;Lescompat/Array;:V", &method), ANI_OK); + EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "DLmsig/A;Lmsig/B;:Lmsig/E;", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindMethod(cls, "foo", "Lmsig/A$partial;Lescompat/Array;:V", &method), ANI_INVALID_ARGS); } TEST_F(MangleSignatureTest, Class_FindStaticMethod) { - PandaString desc; + std::optional desc; ani_class cls {}; ASSERT_EQ(env_->FindClass("msig.G", &cls), ANI_OK); @@ -572,31 +622,32 @@ TEST_F(MangleSignatureTest, Class_FindStaticMethod) TEST_F(MangleSignatureTest, Class_FindStaticMethod_OldFormat) { - PandaString desc; + std::optional desc; ani_class cls {}; - ASSERT_EQ(env_->FindClass("Lmsig/G;", &cls), ANI_OK); + ASSERT_EQ(env_->FindClass("msig.G", &cls), ANI_OK); ani_static_method method {}; - EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", ":V", &method), ANI_OK); + EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", ":V", &method), ANI_INVALID_ARGS); // Check primitives - EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "Z:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "C:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "S:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "I:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "J:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "F:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "D:V", &method), ANI_OK); + EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "Z:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "C:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "S:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "I:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "J:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "F:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "D:V", &method), ANI_INVALID_ARGS); // Check references - EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "DLmsig/A;Lmsig/B;:Lmsig/E;", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "Lmsig/A$partial;Lescompat/Array;:V", &method), ANI_OK); + EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "DLmsig/A;Lmsig/B;:Lmsig/E;", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindStaticMethod(cls, "foo", "Lmsig/A$partial;Lescompat/Array;:V", &method), + ANI_INVALID_ARGS); } TEST_F(MangleSignatureTest, Class_FindIndexableGetter) { - PandaString desc; + std::optional desc; ani_class cls {}; ASSERT_EQ(env_->FindClass("msig.F", &cls), ANI_OK); @@ -607,18 +658,18 @@ TEST_F(MangleSignatureTest, Class_FindIndexableGetter) TEST_F(MangleSignatureTest, Class_FindIndexableGetter_OldFormat) { - PandaString desc; + std::optional desc; ani_class cls {}; - ASSERT_EQ(env_->FindClass("Lmsig/F;", &cls), ANI_OK); + ASSERT_EQ(env_->FindClass("msig.F", &cls), ANI_OK); ani_method method {}; - EXPECT_EQ(env_->Class_FindIndexableGetter(cls, "D:I", &method), ANI_OK); + EXPECT_EQ(env_->Class_FindIndexableGetter(cls, "D:I", &method), ANI_INVALID_ARGS); } TEST_F(MangleSignatureTest, Class_FindIndexableSetter) { - PandaString desc; + std::optional desc; ani_class cls {}; ASSERT_EQ(env_->FindClass("msig.F", &cls), ANI_OK); @@ -639,29 +690,29 @@ TEST_F(MangleSignatureTest, Class_FindIndexableSetter) TEST_F(MangleSignatureTest, Class_FindIndexableSetter_OldFormat) { - PandaString desc; + std::optional desc; ani_class cls {}; - ASSERT_EQ(env_->FindClass("Lmsig/F;", &cls), ANI_OK); + ASSERT_EQ(env_->FindClass("msig.F", &cls), ANI_OK); ani_method method {}; // Check primitives - EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DZ:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DC:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DS:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DI:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DJ:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DF:V", &method), ANI_OK); - EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DD:V", &method), ANI_OK); + EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DZ:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DC:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DS:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DI:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DJ:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DF:V", &method), ANI_INVALID_ARGS); + EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DD:V", &method), ANI_INVALID_ARGS); // Check references - EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DLstd/core/String;:V", &method), ANI_OK); + EXPECT_EQ(env_->Class_FindIndexableSetter(cls, "DLstd/core/String;:V", &method), ANI_INVALID_ARGS); } TEST_F(MangleSignatureTest, Class_CallStaticMethodByName) { - PandaString desc; + std::optional desc; ani_class cls {}; ASSERT_EQ(env_->FindClass("msig.G", &cls), ANI_OK); @@ -691,20 +742,19 @@ TEST_F(MangleSignatureTest, Class_CallStaticMethodByName) TEST_F(MangleSignatureTest, Class_CallStaticMethodByName_OldFormat) { - PandaString desc; + std::optional desc; ani_class cls {}; - ASSERT_EQ(env_->FindClass("Lmsig/G;", &cls), ANI_OK); + ASSERT_EQ(env_->FindClass("msig.G", &cls), ANI_OK); ani_int result {}; // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg) - ASSERT_EQ(env_->Class_CallStaticMethodByName_Int(cls, "foo", "III:I", &result, 1, 2U, 3U), ANI_OK); - ASSERT_EQ(result, 1 + 2U + 3U); + ASSERT_EQ(env_->Class_CallStaticMethodByName_Int(cls, "foo", "III:I", &result, 1, 2U, 3U), ANI_INVALID_ARGS); } TEST_F(MangleSignatureTest, Object_CallMethodByName) { - PandaString desc; + std::optional desc; ani_class cls {}; ASSERT_EQ(env_->FindClass("msig.F", &cls), ANI_OK); @@ -741,13 +791,13 @@ TEST_F(MangleSignatureTest, Object_CallMethodByName) TEST_F(MangleSignatureTest, Object_CallMethodByName_OldFormat) { - PandaString desc; + std::optional desc; ani_class cls {}; - ASSERT_EQ(env_->FindClass("Lmsig/F;", &cls), ANI_OK); + ASSERT_EQ(env_->FindClass("msig.F", &cls), ANI_OK); ani_method ctor {}; - ASSERT_EQ(env_->Class_FindMethod(cls, "", ":V", &ctor), ANI_OK); + ASSERT_EQ(env_->Class_FindMethod(cls, "", ":", &ctor), ANI_OK); ani_object object {}; // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg) @@ -755,8 +805,7 @@ TEST_F(MangleSignatureTest, Object_CallMethodByName_OldFormat) ani_int result {}; // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg) - ASSERT_EQ(env_->Object_CallMethodByName_Int(object, "foo", "II:I", &result, 1, 2U), ANI_OK); - ASSERT_EQ(result, 1 + 2U); + ASSERT_EQ(env_->Object_CallMethodByName_Int(object, "foo", "II:I", &result, 1, 2U), ANI_INVALID_ARGS); } static EtsArray *ClassBindNativeFunctionsFoo1(EtsArray *data) @@ -792,8 +841,8 @@ TEST_F(MangleSignatureTest, Class_BindNativeMethods_OldFormat) }; ani_class cls {}; - ASSERT_EQ(env_->FindClass("Lmsig/F;", &cls), ANI_OK); - ASSERT_EQ(env_->Class_BindNativeMethods(cls, functions.data(), functions.size()), ANI_OK); + ASSERT_EQ(env_->FindClass("Lmsig/F;", &cls), ANI_INVALID_ARGS); + ASSERT_EQ(env_->Class_BindNativeMethods(cls, functions.data(), functions.size()), ANI_INVALID_ARGS); } TEST_F(MangleSignatureTest, Namespace_BindNativeFunctions) @@ -822,8 +871,8 @@ TEST_F(MangleSignatureTest, Namespace_BindNativeFunctions_OldFormat) }; ani_namespace ns {}; - ASSERT_EQ(env_->FindNamespace("Lmsig/rls;", &ns), ANI_OK); - ASSERT_EQ(env_->Namespace_BindNativeFunctions(ns, functions.data(), functions.size()), ANI_OK); + ASSERT_EQ(env_->FindNamespace("Lmsig/rls;", &ns), ANI_INVALID_ARGS); + ASSERT_EQ(env_->Namespace_BindNativeFunctions(ns, functions.data(), functions.size()), ANI_INVALID_ARGS); } TEST_F(MangleSignatureTest, Module_BindNativeFunctions) @@ -852,8 +901,8 @@ TEST_F(MangleSignatureTest, Module_BindNativeFunctions_OldFormat) }; ani_module m {}; - ASSERT_EQ(env_->FindModule("Lmsig;", &m), ANI_OK); - ASSERT_EQ(env_->Module_BindNativeFunctions(m, functions.data(), functions.size()), ANI_OK); + ASSERT_EQ(env_->FindModule("Lmsig;", &m), ANI_INVALID_ARGS); + ASSERT_EQ(env_->Module_BindNativeFunctions(m, functions.data(), functions.size()), ANI_INVALID_ARGS); } } // namespace ark::ets::ani::testing diff --git a/static_core/plugins/ets/tests/checked/ani/quick_native.cpp b/static_core/plugins/ets/tests/checked/ani/quick_native.cpp index 3b155c4cbfcc775d2dfa906c2176d1d8aab5a6b4..a35a24c7c4cb02692719bd1321bc7535553c7123 100644 --- a/static_core/plugins/ets/tests/checked/ani/quick_native.cpp +++ b/static_core/plugins/ets/tests/checked/ani/quick_native.cpp @@ -287,7 +287,7 @@ static Type Virtual(ani_env *env, ani_object that, ani_object i0, ani_byte i1, a } else { static_assert(std::is_same_v); ani_method ctor; - CHECK_EQUAL(env->Class_FindMethod(intWrapper, "", "I:V", &ctor), ANI_OK); + CHECK_EQUAL(env->Class_FindMethod(intWrapper, "", "i:", &ctor), ANI_OK); ani_object newObj; // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg) CHECK_EQUAL(env->Object_New(intWrapper, ctor, &newObj, errorCount), ANI_OK); diff --git a/static_core/plugins/ets/tests/ets_test_suite/ani/example_lib.cpp b/static_core/plugins/ets/tests/ets_test_suite/ani/example_lib.cpp index e114c4b5840d95ce712823f97e06f85040730ef5..30466fabe72a32e9b460c9efd6720164573cbeab 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/ani/example_lib.cpp +++ b/static_core/plugins/ets/tests/ets_test_suite/ani/example_lib.cpp @@ -90,7 +90,7 @@ static void TestCheck3() ASSERT_EQ(env->Class_CallStaticMethod_Ref(cls, newMethod, &ref), ANI_OK); ASSERT_NE(ref, nullptr); - // Retrieve a method named "boolean_method" with signature "II:Z" + // Retrieve a method named "boolean_method" with signature "ii:z" ani_method method; ASSERT_EQ(env->Class_FindMethod(cls, "boolean_method", "ii:z", &method), ANI_OK); ASSERT_NE(method, nullptr); diff --git a/static_core/plugins/ets/tests/ets_test_suite/coroutines/dfx/coroutine_dfx_test.cpp b/static_core/plugins/ets/tests/ets_test_suite/coroutines/dfx/coroutine_dfx_test.cpp index 6f624a5238fbc5f8716a22e020509aea5517d847..feb2f80a9c6906df52cdacea3a4081f891b28a9e 100644 --- a/static_core/plugins/ets/tests/ets_test_suite/coroutines/dfx/coroutine_dfx_test.cpp +++ b/static_core/plugins/ets/tests/ets_test_suite/coroutines/dfx/coroutine_dfx_test.cpp @@ -34,7 +34,7 @@ public: static ani_function ResolveFunction(ani_env *env, std::string_view methodName, std::string_view signature) { ani_module md; - [[maybe_unused]] auto status = env->FindModule("Lcoroutine_dfx_test;", &md); + [[maybe_unused]] auto status = env->FindModule("coroutine_dfx_test", &md); ASSERT(status == ANI_OK); ani_function func; status = env->Module_FindFunction(md, methodName.data(), signature.data(), &func); diff --git a/static_core/plugins/ets/tests/runtime/tooling/sampler/asm/SamplerAsmTest.cpp b/static_core/plugins/ets/tests/runtime/tooling/sampler/asm/SamplerAsmTest.cpp index 9987702a62d1c3d95794de8b4f67811f02400c21..1ca924d03859c2ed519a4becb39c5281557c0d57 100644 --- a/static_core/plugins/ets/tests/runtime/tooling/sampler/asm/SamplerAsmTest.cpp +++ b/static_core/plugins/ets/tests/runtime/tooling/sampler/asm/SamplerAsmTest.cpp @@ -61,16 +61,16 @@ ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result) ani_module md; if (ANI_OK != env->FindModule(moduleName, &md)) { auto msg = std::string("Cannot find \"") + moduleName + std::string("\" module!"); - ark::ets::stdlib::ThrowNewError(env, "Lstd/core/RuntimeException;", msg.data(), "Lstd/core/String;:V"); + ark::ets::stdlib::ThrowNewError(env, "std.core.RuntimeException", msg.data(), "C{std.core.String}:"); return ANI_ERROR; } const auto functions = std::array { - ani_native_function {"NativeSumEightElements", ":I", reinterpret_cast(NativeSumEightElements)}}; + ani_native_function {"NativeSumEightElements", ":i", reinterpret_cast(NativeSumEightElements)}}; if (ANI_OK != env->Module_BindNativeFunctions(md, functions.data(), functions.size())) { auto msg = std::string("Cannot bind native functions to '") + moduleName + std::string("'"); - ark::ets::stdlib::ThrowNewError(env, "Lstd/core/RuntimeException;", msg.data(), "Lstd/core/String;:V"); + ark::ets::stdlib::ThrowNewError(env, "std.core.RuntimeException", msg.data(), "C{std.core.String}:"); return ANI_ERROR; }; diff --git a/static_core/plugins/ets/tests/runtime/tooling/sampler/native/SamplerAniTest.cpp b/static_core/plugins/ets/tests/runtime/tooling/sampler/native/SamplerAniTest.cpp index ad14bc0ff7c5aed380318fb1eb6d8001b09f1d03..fdf397b304e5835b4cc1bc93398ec02599d5cfd1 100644 --- a/static_core/plugins/ets/tests/runtime/tooling/sampler/native/SamplerAniTest.cpp +++ b/static_core/plugins/ets/tests/runtime/tooling/sampler/native/SamplerAniTest.cpp @@ -52,7 +52,7 @@ static ani_int NativeANISlowFunction(ani_env *env, ani_int iterations) ani_int res = 0; ani_module module; - static const char *moduleName = "LSamplerAniTest;"; + static const char *moduleName = "SamplerAniTest"; auto status = env->FindModule(moduleName, &module); if (status != ANI_OK) { std::cerr << "Not found '" << moduleName << "'" << std::endl; @@ -60,7 +60,7 @@ static ani_int NativeANISlowFunction(ani_env *env, ani_int iterations) } ani_function fn; - status = env->Module_FindFunction(module, "SlowETSFunction", "I:I", &fn); + status = env->Module_FindFunction(module, "SlowETSFunction", "i:i", &fn); if (status != ANI_OK) { std::cerr << "Function 'SlowETSFunction' not found" << std::endl; return ANI_ERROR; @@ -77,7 +77,7 @@ static ani_int NativeANISlowFunction(ani_env *env, ani_int iterations) static ani_int NativeANIFastFunction(ani_env *env, ani_int iterations) { ani_module module; - static const char *moduleName = "LSamplerAniTest;"; + static const char *moduleName = "SamplerAniTest"; auto status = env->FindModule(moduleName, &module); if (status != ANI_OK) { std::cerr << "Not found '" << moduleName << "'" << std::endl; @@ -85,7 +85,7 @@ static ani_int NativeANIFastFunction(ani_env *env, ani_int iterations) } ani_function fn; - status = env->Module_FindFunction(module, "FastETSFunction", ":I", &fn); + status = env->Module_FindFunction(module, "FastETSFunction", ":i", &fn); if (status != ANI_OK) { std::cerr << "Function 'FastETSFunction' not found" << std::endl; return ANI_ERROR; @@ -112,7 +112,7 @@ ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result) } ani_module module; - static const char *moduleName = "LSamplerAniTest;"; + static const char *moduleName = "SamplerAniTest"; auto status = env->FindModule(moduleName, &module); if (status != ANI_OK) { std::cerr << "Not found '" << moduleName << "'" << std::endl; @@ -120,10 +120,10 @@ ANI_EXPORT ani_status ANI_Constructor(ani_vm *vm, uint32_t *result) } std::array methods = { - ani_native_function {"NativeSlowFunction", "I:I", reinterpret_cast(NativeSlowFunction)}, - ani_native_function {"NativeFastFunction", ":I", reinterpret_cast(NativeFastFunction)}, - ani_native_function {"NativeANIFastFunction", "I:I", reinterpret_cast(NativeANIFastFunction)}, - ani_native_function {"NativeANISlowFunction", "I:I", reinterpret_cast(NativeANISlowFunction)}, + ani_native_function {"NativeSlowFunction", "i:i", reinterpret_cast(NativeSlowFunction)}, + ani_native_function {"NativeFastFunction", ":i", reinterpret_cast(NativeFastFunction)}, + ani_native_function {"NativeANIFastFunction", "i:i", reinterpret_cast(NativeANIFastFunction)}, + ani_native_function {"NativeANISlowFunction", "i:i", reinterpret_cast(NativeANISlowFunction)}, }; if (ANI_OK != env->Module_BindNativeFunctions(module, methods.data(), methods.size())) { diff --git a/static_core/plugins/ets/tests/runtime/tooling/sampler/sampler_ani/create_vm_sampler.cpp b/static_core/plugins/ets/tests/runtime/tooling/sampler/sampler_ani/create_vm_sampler.cpp index 7936d1efc8b0979c9146bb72e75d53bc70006701..41a5d9d940ce6294fb7c980a5dd11a08739fda6c 100644 --- a/static_core/plugins/ets/tests/runtime/tooling/sampler/sampler_ani/create_vm_sampler.cpp +++ b/static_core/plugins/ets/tests/runtime/tooling/sampler/sampler_ani/create_vm_sampler.cpp @@ -47,11 +47,11 @@ public: ASSERT_TRUE(aniVersion == ANI_VERSION_1) << "Incorrect ani version"; ani_module module {}; - ASSERT_EQ(env->FindModule("Lcreate_vm_sampler;", &module), ANI_OK) << "Cannot find module create_vm_sampler"; + ASSERT_EQ(env->FindModule("create_vm_sampler", &module), ANI_OK) << "Cannot find module create_vm_sampler"; ASSERT_NE(module, nullptr); ani_function fn {}; - ASSERT_EQ(env->Module_FindFunction(module, "main", ":I", &fn), ANI_OK); + ASSERT_EQ(env->Module_FindFunction(module, "main", ":i", &fn), ANI_OK); ASSERT_NE(fn, nullptr); ani_int res {}; // NOLINTNEXTLINE(cppcoreguidelines-pro-type-vararg)