From afeb7054ac3a35510768d43d6053f6987f71e3ff Mon Sep 17 00:00:00 2001 From: BrainL Date: Tue, 17 Jun 2025 20:29:43 +0800 Subject: [PATCH] add continuation_test UT Signed-off-by: BrainL --- .../continuation_manager_stage.cpp | 20 ++-- .../include/mock_continuation_ability.h | 20 ++++ .../BUILD.gn | 9 ++ .../continuation_test.cpp | 94 ++++++++++++++++++- 4 files changed, 132 insertions(+), 11 deletions(-) diff --git a/frameworks/native/ability/native/continuation/distributed/continuation_manager_stage.cpp b/frameworks/native/ability/native/continuation/distributed/continuation_manager_stage.cpp index c5bf27c5bdc..1df793e4319 100644 --- a/frameworks/native/ability/native/continuation/distributed/continuation_manager_stage.cpp +++ b/frameworks/native/ability/native/continuation/distributed/continuation_manager_stage.cpp @@ -242,7 +242,8 @@ static int64_t AddProcessor() return HiAppEvent::AppEventProcessorMgr::AddProcessor(config); } -static void WriteEndEvent(const std::string& transId, const int result, const int errCode, const time_t beginTime) +static void WriteEndEvent(const std::string& transId, const int result, const int errCode, const time_t beginTime, + int64_t processorId) { HiAppEvent::Event event("api_diagnostic", "api_exec_end", HiAppEvent::BEHAVIOR); event.AddParam("transId", transId); @@ -252,7 +253,9 @@ static void WriteEndEvent(const std::string& transId, const int result, const in event.AddParam("sdk_name", std::string("AbilityKit")); event.AddParam("begin_time", beginTime); event.AddParam("end_time", time(nullptr)); - Write(event); + if (processorId > 0) { + Write(event); + } } #endif @@ -263,10 +266,7 @@ int32_t ContinuationManagerStage::OnContinue(WantParams &wantParams, bool &isAsy #ifdef NO_RUNTIME_EMULATOR int64_t processorId = -1; processorId = AddProcessor(); - if (processorId <= 0) { - TAG_LOGE(AAFwkTag::CONTINUATION, "Add processor fail.Error code is %{public}lld", processorId); - return ERR_INVALID_VALUE; - } + TAG_LOGI(AAFwkTag::CONTINUATION, "Add processor start.Processor id is %{public}lld", processorId); time_t beginTime = time(nullptr); std::string transId = std::string("transId_") + std::to_string(std::rand()); #endif @@ -276,7 +276,7 @@ int32_t ContinuationManagerStage::OnContinue(WantParams &wantParams, bool &isAsy if (ability == nullptr || abilityInfo == nullptr) { TAG_LOGE(AAFwkTag::CONTINUATION, "null ability or abilityInfo"); #ifdef NO_RUNTIME_EMULATOR - WriteEndEvent(transId, EVENT_RESULT_FAIL, ERR_INVALID_VALUE, beginTime); + WriteEndEvent(transId, EVENT_RESULT_FAIL, ERR_INVALID_VALUE, beginTime, processorId); #endif return ERR_INVALID_VALUE; } @@ -285,13 +285,15 @@ int32_t ContinuationManagerStage::OnContinue(WantParams &wantParams, bool &isAsy if (!stageBased) { ret = OnStartAndSaveData(wantParams); #ifdef NO_RUNTIME_EMULATOR - WriteEndEvent(transId, EVENT_RESULT_FAIL, ret, beginTime); + int32_t result = (ret == ERR_OK) ? EVENT_RESULT_SUCCESS : EVENT_RESULT_FAIL; + WriteEndEvent(transId, result, ret, beginTime, processorId); #endif return ret; } ret = OnContinueAndGetContent(wantParams, isAsyncOnContinue, tmpAbilityInfo); #ifdef NO_RUNTIME_EMULATOR - WriteEndEvent(transId, EVENT_RESULT_SUCCESS, ret, beginTime); + int32_t result = (ret == ERR_OK) ? EVENT_RESULT_SUCCESS : EVENT_RESULT_FAIL; + WriteEndEvent(transId, result, ret, beginTime, processorId); #endif return ret; } diff --git a/test/mock/frameworks_kits_ability_native_test/include/mock_continuation_ability.h b/test/mock/frameworks_kits_ability_native_test/include/mock_continuation_ability.h index 7c8b93fa9b5..54b7dcff38f 100644 --- a/test/mock/frameworks_kits_ability_native_test/include/mock_continuation_ability.h +++ b/test/mock/frameworks_kits_ability_native_test/include/mock_continuation_ability.h @@ -20,6 +20,7 @@ #include #include "ability.h" +#include "ui_ability.h" namespace OHOS { namespace AppExecFwk { @@ -44,6 +45,25 @@ public: return abilityInfo_; } }; + +class MockContinuationUIAbility : public AbilityRuntime::UIAbility { +public: + MockContinuationUIAbility() = default; + virtual ~MockContinuationUIAbility() = default; + + MOCK_METHOD0(OnStartContinuation, bool()); + MOCK_METHOD0(TerminateAbility, int()); + MOCK_METHOD0(OnRemoteTerminated, void()); + MOCK_METHOD0(GetContentInfo, std::string()); + MOCK_METHOD1(OnSaveData, bool(WantParams &saveData)); + MOCK_METHOD3(OnContinue, int32_t(AAFwk::WantParams &wantParams, bool &isAsyncOnContinue, + const AppExecFwk::AbilityInfo &abilityInfo)); + + const std::shared_ptr GetAbilityInfo() + { + return abilityInfo_; + } +}; } // namespace AppExecFwk } // namespace OHOS #endif // MOCK_OHOS_ABILITY_RUNTIME_MOCK_CONTINUATION_ABILITY_H diff --git a/test/unittest/frameworks_kits_ability_native_test/BUILD.gn b/test/unittest/frameworks_kits_ability_native_test/BUILD.gn index 475cb31348a..da4b38ece5a 100644 --- a/test/unittest/frameworks_kits_ability_native_test/BUILD.gn +++ b/test/unittest/frameworks_kits_ability_native_test/BUILD.gn @@ -2130,6 +2130,7 @@ ohos_unittest("continuation_test") { "${ability_runtime_innerkits_path}/deps_wrapper:ability_deps_wrapper", "${ability_runtime_native_path}/ability/native:ability_thread", "${ability_runtime_native_path}/ability/native:abilitykit_native", + "${ability_runtime_native_path}/ability/native:uiabilitykit_native", "${ability_runtime_native_path}/ability/native:configuration_helper", "${ability_runtime_native_path}/appkit:app_context", "${ability_runtime_native_path}/appkit:appkit_manager_helper", @@ -2164,6 +2165,14 @@ ohos_unittest("continuation_test") { "runtime_core:ani", ] + defines = [] + + if (hiappevent_part_enabled) { + defines += [ "NO_RUNTIME_EMULATOR" ] + + external_deps += [ "hiappevent:hiappevent_innerapi" ] + } + if (ability_runtime_graphics) { external_deps += [ "form_fwk:fmskit_native", diff --git a/test/unittest/frameworks_kits_ability_native_test/continuation_test.cpp b/test/unittest/frameworks_kits_ability_native_test/continuation_test.cpp index e321c616266..a756cb5ce48 100644 --- a/test/unittest/frameworks_kits_ability_native_test/continuation_test.cpp +++ b/test/unittest/frameworks_kits_ability_native_test/continuation_test.cpp @@ -21,9 +21,14 @@ #include "ability.h" #include "ability_impl.h" #include "abs_shared_result_set.h" +#ifdef NO_RUNTIME_EMULATOR +#include "app_event.h" +#include "app_event_processor_mgr.h" +#endif #include "bool_wrapper.h" #include "context_deal.h" #include "continuation_manager.h" +#include "continuation_manager_stage.h" #include "continuation_handler.h" #include "data_ability_predicates.h" #include "mock_ability_connect_callback.h" @@ -41,6 +46,9 @@ namespace AppExecFwk { using namespace testing::ext; using namespace OHOS; using namespace OHOS::AppExecFwk; +#ifdef NO_RUNTIME_EMULATOR +using namespace OHOS::HiviewDFX; +#endif using testing::_; using testing::Return; const std::string SUPPORT_CONTINUE_PAGE_STACK_PROPERTY_NAME = "ohos.extra.param.key.supportContinuePageStack"; @@ -53,14 +61,17 @@ const int32_t CONTINUE_GET_CONTENT_FAILED = 29360200; #endif class ContinuationTest : public testing::Test { public: - ContinuationTest() : continuationManager_(nullptr), ability_(nullptr), abilityInfo_(nullptr), - continueToken_(nullptr) + ContinuationTest() : continuationManager_(nullptr), continuationManagerStage_(nullptr), + ability_(nullptr), uiAbility_(nullptr), abilityInfo_(nullptr), continueToken_(nullptr) {} ~ContinuationTest() {} std::shared_ptr continuationManager_; + std::shared_ptr continuationManagerStage_; std::shared_ptr ability_; + std::shared_ptr uiAbility_; std::shared_ptr mockAbility_; + std::shared_ptr mockUIAbility_; std::shared_ptr abilityInfo_; sptr continueToken_; @@ -98,6 +109,7 @@ void ContinuationTest::TearDownTestCase(void) void ContinuationTest::SetUp(void) { continuationManager_ = std::make_shared(); + continuationManagerStage_ = std::make_shared(); continueToken_ = sptr(new (std::nothrow)MockAbilityToken()); abilityInfo_ = std::make_shared(); abilityInfo_->name = "ability"; @@ -108,6 +120,13 @@ void ContinuationTest::SetUp(void) ability_->Init(abilityInfo_, application, handler, continueToken_); mockAbility_ = std::make_shared(); mockAbility_->Init(abilityInfo_, application, handler, continueToken_); + mockUIAbility_ = std::make_shared(); + std::shared_ptr want = std::make_shared(); + std::shared_ptr record = std::make_shared(abilityInfo_, continueToken_, + want, 0); + mockUIAbility_->Init(record, application, handler, continueToken_); + uiAbility_ = std::make_shared(); + uiAbility_->Init(record, application, handler, continueToken_); } void ContinuationTest::TearDown(void) @@ -1397,6 +1416,77 @@ HWTEST_F(ContinuationTest, continue_manager_OnContinue_003, TestSize.Level1) GTEST_LOG_(INFO) << "continue_manager_OnContinue_003 end"; } +#ifdef NO_RUNTIME_EMULATOR +/* + * @tc.number: continue_manager_stage_OnContinue_001 + * @tc.name: OnContinue + * @tc.desc: call OnContinue with ability_ is null or abilityInfo is nullptr + */ +HWTEST_F(ContinuationTest, continue_manager_stage_OnContinue_001, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "continue_manager_OnContinue_stage_001 start"; + std::weak_ptr continuationManagerStage = continuationManagerStage_; + std::weak_ptr abilityTmp = uiAbility_; + auto continuationHandlerStage = std::make_shared(continuationManagerStage, abilityTmp); + continuationManagerStage_->Init(uiAbility_, continueToken_, abilityInfo_, continuationHandlerStage); + WantParams wantParams; + continuationManager_->ability_.reset(); + bool isAsyncOnContinue = true; + AbilityInfo tmpAbilityInfo; + int32_t result = continuationManagerStage_->OnContinue(wantParams, isAsyncOnContinue, tmpAbilityInfo); + EXPECT_EQ(ERR_INVALID_VALUE, result); + GTEST_LOG_(INFO) << "continue_manager_stage_OnContinue_001 end"; +} + +/* + * @tc.number: continue_manager_stage_OnContinue_002 + * @tc.name: OnContinue + * @tc.desc: call OnContinue with stageBased is false + */ +HWTEST_F(ContinuationTest, continue_manager_stage_OnContinue_002, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "continue_manager_stage_OnContinue_002 start"; + EXPECT_CALL(*mockUIAbility_, OnStartContinuation()).Times(1).WillOnce(Return(true)); + EXPECT_CALL(*mockUIAbility_, OnSaveData(_)).Times(1).WillOnce(Return(true)); + std::weak_ptr continuationManagerStage = continuationManagerStage_; + std::weak_ptr abilityTmp = mockUIAbility_; + auto continuationHandlerStage = std::make_shared(continuationManagerStage, abilityTmp); + continuationManagerStage_->Init(mockUIAbility_, continueToken_, abilityInfo_, continuationHandlerStage); + WantParams wantParams; + ability_->abilityInfo_->isStageBasedModel = false; + bool isAsyncOnContinue = true; + AbilityInfo tmpAbilityInfo; + int32_t result = continuationManagerStage_->OnContinue(wantParams, isAsyncOnContinue, tmpAbilityInfo); + EXPECT_EQ(ERR_OK, result); + GTEST_LOG_(INFO) << "continue_manager_stage_OnContinue_002 end"; +} + +/* + * @tc.number: continue_manager_stage_OnContinue_003 + * @tc.name: OnContinue + * @tc.desc: call OnContinue with stageBased is true + */ +HWTEST_F(ContinuationTest, continue_manager_stage_OnContinue_003, TestSize.Level1) +{ + GTEST_LOG_(INFO) << "continue_manager_stage_OnContinue_003 start"; + EXPECT_CALL(*mockUIAbility_, OnContinue(_, _, _)) + .Times(1) + .WillOnce(Return(ContinuationManagerStage::OnContinueResult::AGREE)); + EXPECT_CALL(*mockUIAbility_, GetContentInfo()).Times(1).WillOnce(Return("ContentInfo")); + std::weak_ptr continuationManagerStage = continuationManagerStage_; + std::weak_ptr abilityTmp = mockUIAbility_; + auto continuationHandlerStage = std::make_shared(continuationManagerStage, abilityTmp); + continuationManagerStage_->Init(mockUIAbility_, continueToken_, abilityInfo_, continuationHandlerStage); + WantParams wantParams; + ability_->abilityInfo_->isStageBasedModel = true; + bool isAsyncOnContinue = true; + AbilityInfo tmpAbilityInfo; + int32_t result = continuationManagerStage_->OnContinue(wantParams, isAsyncOnContinue, tmpAbilityInfo); + EXPECT_EQ(ERR_OK, result); + GTEST_LOG_(INFO) << "continue_manager_stage_OnContinue_003 end"; +} +#endif + /* * @tc.number: continue_manager_OnStartAndSaveData_001 * @tc.name: OnStartAndSaveData -- Gitee