From 3118ff0a824b64936d90681d1f2952896721baa8 Mon Sep 17 00:00:00 2001 From: wangbing Date: Sat, 14 Jun 2025 17:53:44 +0800 Subject: [PATCH] Add tdd Signed-off-by: wangbing --- .../ability_interceptor_second_test.cpp | 85 ++++ .../unittest/app_running_record_test/BUILD.gn | 4 + .../app_running_record_test.cpp | 414 ++++++++++++++++++ .../ecological_rule_interceptor_test.cpp | 154 +++++++ .../multi_instance_utils_test.cpp | 67 +++ .../start_ability_utils_test/BUILD.gn | 13 +- .../start_ability_utils_test.cpp | 158 +++++++ .../update_caller_info_util_test.cpp | 117 +++++ .../uri_utils_test/uri_utils_test.cpp | 34 ++ 9 files changed, 1045 insertions(+), 1 deletion(-) diff --git a/test/unittest/ability_interceptor_second_test/ability_interceptor_second_test.cpp b/test/unittest/ability_interceptor_second_test/ability_interceptor_second_test.cpp index 0905fb988a4..418e743cb73 100644 --- a/test/unittest/ability_interceptor_second_test/ability_interceptor_second_test.cpp +++ b/test/unittest/ability_interceptor_second_test/ability_interceptor_second_test.cpp @@ -249,5 +249,90 @@ HWTEST_F(AbilityInterceptorSecondTest, DisposedRuleInterceptor_008, TestSize.Lev TAG_LOGI(AAFwkTag::TEST, "%{public}s end.", __func__); } +/** + * @tc.name: AbilityInterceptorSecondTest_DisposedRuleInterceptor_009 + * @tc.desc: DisposedRuleInterceptor + * @tc.type: FUNC + * @tc.require: No + */ +HWTEST_F(AbilityInterceptorSecondTest, DisposedRuleInterceptor_009, TestSize.Level1) +{ + std::shared_ptr executer = std::make_shared(); + ASSERT_NE(executer, nullptr); + std::string bundleName = "interceptor_callerBundleName"; + Want want; + want.SetBundle(bundleName); + int32_t userId = 10; + int32_t appIndex = 10000; + DisposedRule disposedRule; + disposedRule.disposedType = AppExecFwk::DisposedType::BLOCK_APPLICATION; + disposedRule.controlType == AppExecFwk::ControlType::DISALLOWED_LIST; + executer->CheckDisposedRule(want, disposedRule); + bool result = executer->CheckControl(want, userId, disposedRule, appIndex); + EXPECT_EQ(result, false); +} + +/** + * @tc.name: AbilityInterceptorSecondTest_DisposedRuleInterceptor_010 + * @tc.desc: DisposedRuleInterceptor + * @tc.type: FUNC + * @tc.require: No + */ +HWTEST_F(AbilityInterceptorSecondTest, DisposedRuleInterceptor_010, TestSize.Level1) +{ + std::shared_ptr executer = std::make_shared(); + ASSERT_NE(executer, nullptr); + std::string bundleName = "interceptor_callerBundleName"; + Want want; + want.SetBundle(bundleName); + int32_t userId = 10; + int32_t appIndex = 1; + DisposedRule disposedRule; + disposedRule.disposedType = AppExecFwk::DisposedType::BLOCK_APPLICATION; + disposedRule.controlType == AppExecFwk::ControlType::DISALLOWED_LIST; + executer->CheckDisposedRule(want, disposedRule); + bool result = executer->CheckControl(want, userId, disposedRule, appIndex); + EXPECT_EQ(result, false); +} + +/** + * @tc.name: AbilityInterceptorSecondTest_DisposedRuleInterceptor_011 + * @tc.desc: DisposedRuleInterceptor + * @tc.type: FUNC + * @tc.require: No + */ +HWTEST_F(AbilityInterceptorSecondTest, DisposedRuleInterceptor_011, TestSize.Level1) +{ + std::shared_ptr executer = std::make_shared(); + ASSERT_NE(executer, nullptr); + std::string bundleName = "com.example.disposedruletest"; + Want want; + DisposedRule disposedRule; + disposedRule.want = nullptr; + ErrCode result = executer->StartNonBlockRule(want, disposedRule, 0); + EXPECT_EQ(result, ERR_OK); +} + +/** + * @tc.name: AbilityInterceptorSecondTest_DisposedRuleInterceptor_012 + * @tc.desc: DisposedRuleInterceptor + * @tc.type: FUNC + * @tc.require: No + */ +HWTEST_F(AbilityInterceptorSecondTest, DisposedRuleInterceptor_012, TestSize.Level1) +{ + std::shared_ptr executer = std::make_shared(); + ASSERT_NE(executer, nullptr); + executer->disposedObserverMap_.emplace(0, nullptr); + std::string bundleName1 = "com.example.disposedruletest1"; + std::string bundleName2 = "com.example.disposedruletest2"; + Want want; + want.SetBundle(bundleName1); + DisposedRule disposedRule; + disposedRule.want = std::make_shared(); + disposedRule.want->SetBundle(bundleName2); + ErrCode result = executer->StartNonBlockRule(want, disposedRule, 0); + EXPECT_EQ(result, ERR_OK); +} } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/app_running_record_test/BUILD.gn b/test/unittest/app_running_record_test/BUILD.gn index 9d7d28544d7..5a2b87d7530 100644 --- a/test/unittest/app_running_record_test/BUILD.gn +++ b/test/unittest/app_running_record_test/BUILD.gn @@ -79,6 +79,10 @@ ohos_unittest("app_running_record_test") { } if (ability_runtime_graphics) { external_deps += [ "window_manager:libwm" ] + defines += [ + "SUPPORT_SCREEN", + "SUPPORT_GRAPHICS", + ] } if (ability_runtime_upms) { deps += [ diff --git a/test/unittest/app_running_record_test/app_running_record_test.cpp b/test/unittest/app_running_record_test/app_running_record_test.cpp index b05fe9ec74d..2570c60a7b6 100644 --- a/test/unittest/app_running_record_test/app_running_record_test.cpp +++ b/test/unittest/app_running_record_test/app_running_record_test.cpp @@ -872,5 +872,419 @@ HWTEST_F(AppRunningRecordTest, AppRunningRecord_GetUserId_0100, TestSize.Level1) EXPECT_EQ(result, 1); TAG_LOGI(AAFwkTag::TEST, "AppRunningRecord_GetUserId_0100 end."); } + +/** + * @tc.name: AppRunningRecord_UpdateApplicationInfoInstalled_0100 + * @tc.desc: Test UpdateApplicationInfoInstalled works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_UpdateApplicationInfoInstalled_0100, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + auto appRecord = std::make_shared(appInfo, RECORD_ID, "com.example.child"); + ASSERT_NE(appRecord, nullptr); + appRecord->isStageBasedModel_ = true; + appRecord->appLifeCycleDeal_ == nullptr; + std::string moduleName = "moduleName"; + ApplicationInfo applicationInfo; + appRecord->UpdateApplicationInfoInstalled(applicationInfo, moduleName); + EXPECT_TRUE(applicationInfo.name.empty()); +} + +/** + * @tc.name: AppRunningRecord_UpdateApplicationInfoInstalled_0200 + * @tc.desc: Test UpdateApplicationInfoInstalled works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_UpdateApplicationInfoInstalled_0200, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + auto appRecord = std::make_shared(appInfo, RECORD_ID, "com.example.child"); + ASSERT_NE(appRecord, nullptr); + appRecord->isStageBasedModel_ = true; + appRecord->appLifeCycleDeal_ = std::make_shared(); + std::string moduleName = "moduleName"; + ApplicationInfo applicationInfo; + appRecord->UpdateApplicationInfoInstalled(applicationInfo, moduleName); + EXPECT_TRUE(applicationInfo.name.empty()); +} + +/** + * @tc.name: AppRunningRecord_SetModuleLoaded_0100 + * @tc.desc: Test SetModuleLoaded works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_SetModuleLoaded_0100, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + auto appRecord = std::make_shared(appInfo, RECORD_ID, "com.example.child"); + ASSERT_NE(appRecord, nullptr); + std::string moduleName = "moduleName"; + std::vector> moduleRecords; + std::shared_ptr moduleRunningRecord = std::make_shared(appInfo, nullptr); + moduleRunningRecord->moduleName_ = moduleName; + moduleRecords.emplace_back(moduleRunningRecord); + appRecord->hapModules_.emplace("key", moduleRecords); + appRecord->SetModuleLoaded(moduleName); + EXPECT_TRUE(moduleRunningRecord->IsLoaded()); +} + +/** + * @tc.name: AppRunningRecord_ScheduleForegroundRunning_0100 + * @tc.desc: Test ScheduleForegroundRunning works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_ScheduleForegroundRunning_0100, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + auto appRecord = std::make_shared(appInfo, RECORD_ID, "com.example.child"); + ASSERT_NE(appRecord, nullptr); + appRecord->appLifeCycleDeal_ = std::make_shared(); + appRecord->appLifeCycleDeal_->SetApplicationClient(nullptr); + appRecord->ScheduleTerminate(); + appRecord->ScheduleClearPageStack(); + EXPECT_FALSE(appRecord->ScheduleForegroundRunning()); +} + +/** + * @tc.name: AppRunningRecord_StateChangedNotifyObserver_0100 + * @tc.desc: Test StateChangedNotifyObserver works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_StateChangedNotifyObserver_0100, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + appInfo->multiAppMode.multiAppModeType = MultiAppModeType::APP_CLONE; + ASSERT_NE(appInfo, nullptr); + auto appRecord = std::make_shared(appInfo, RECORD_ID, "com.example.child"); + ASSERT_NE(appRecord, nullptr); + std::shared_ptr abilityInfo = std::make_shared(); + ASSERT_NE(abilityInfo, nullptr); + sptr token = nullptr; + auto abilityRecord = std::make_shared(abilityInfo, token, 0); + ASSERT_NE(abilityRecord, nullptr); + appRecord->StateChangedNotifyObserver(abilityRecord, 1, true, true); + auto applicationInfo = appRecord->GetApplicationInfo(); + EXPECT_EQ(applicationInfo->multiAppMode.multiAppModeType, MultiAppModeType::APP_CLONE); +} + +/** + * @tc.name: AppRunningRecord_StateChangedNotifyObserver_0200 + * @tc.desc: Test StateChangedNotifyObserver works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_StateChangedNotifyObserver_0200, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + appInfo->multiAppMode.multiAppModeType = MultiAppModeType::APP_CLONE; + ASSERT_NE(appInfo, nullptr); + auto appRecord = std::make_shared(appInfo, RECORD_ID, "com.example.child"); + ASSERT_NE(appRecord, nullptr); + std::shared_ptr abilityInfo = std::make_shared(); + ASSERT_NE(abilityInfo, nullptr); + sptr token = nullptr; + auto abilityRecord = std::make_shared(abilityInfo, token, 0); + std::shared_ptr want = std::make_shared(); + abilityRecord->SetWant(want); + ASSERT_NE(abilityRecord, nullptr); + appRecord->StateChangedNotifyObserver(abilityRecord, 1, true, true); + auto applicationInfo = appRecord->GetApplicationInfo(); + EXPECT_EQ(applicationInfo->multiAppMode.multiAppModeType, MultiAppModeType::APP_CLONE); +} + +/** + * @tc.name: AppRunningRecord_StateChangedNotifyObserver_0300 + * @tc.desc: Test StateChangedNotifyObserver works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_StateChangedNotifyObserver_0300, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + appInfo->multiAppMode.multiAppModeType = MultiAppModeType::APP_CLONE; + appInfo->bundleType = AppExecFwk::BundleType::ATOMIC_SERVICE; + ASSERT_NE(appInfo, nullptr); + auto appRecord = std::make_shared(appInfo, RECORD_ID, "com.example.child"); + ASSERT_NE(appRecord, nullptr); + std::shared_ptr abilityInfo = std::make_shared(); + ASSERT_NE(abilityInfo, nullptr); + sptr token = nullptr; + auto abilityRecord = std::make_shared(abilityInfo, token, 0); + std::shared_ptr want = std::make_shared(); + abilityRecord->SetWant(want); + ASSERT_NE(abilityRecord, nullptr); + appRecord->StateChangedNotifyObserver(abilityRecord, 1, true, true); + auto applicationInfo = appRecord->GetApplicationInfo(); + EXPECT_EQ(applicationInfo->multiAppMode.multiAppModeType, MultiAppModeType::APP_CLONE); + EXPECT_EQ(applicationInfo->bundleType, AppExecFwk::BundleType::ATOMIC_SERVICE); +} + +/** + * @tc.name: AppRunningRecord_StateChangedNotifyObserver_0400 + * @tc.desc: Test StateChangedNotifyObserver works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_StateChangedNotifyObserver_0400, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + appInfo->multiAppMode.multiAppModeType = MultiAppModeType::APP_CLONE; + appInfo->bundleType = AppExecFwk::BundleType::ATOMIC_SERVICE; + ASSERT_NE(appInfo, nullptr); + auto appRecord = std::make_shared(appInfo, RECORD_ID, "com.example.child"); + ASSERT_NE(appRecord, nullptr); + std::shared_ptr abilityInfo = std::make_shared(); + ASSERT_NE(abilityInfo, nullptr); + abilityInfo->extensionAbilityType = AppExecFwk::ExtensionAbilityType::SHARE; + sptr token = nullptr; + auto abilityRecord = std::make_shared(abilityInfo, token, 0); + std::shared_ptr want = std::make_shared(); + abilityRecord->SetWant(want); + ASSERT_NE(abilityRecord, nullptr); + appRecord->StateChangedNotifyObserver(abilityRecord, 1, true, true); + auto applicationInfo = appRecord->GetApplicationInfo(); + EXPECT_EQ(applicationInfo->multiAppMode.multiAppModeType, MultiAppModeType::APP_CLONE); + EXPECT_EQ(applicationInfo->bundleType, AppExecFwk::BundleType::ATOMIC_SERVICE); +} + +/** + * @tc.name: AppRunningRecord_StateChangedNotifyObserver_0500 + * @tc.desc: Test StateChangedNotifyObserver works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_StateChangedNotifyObserver_0500, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + appInfo->multiAppMode.multiAppModeType = MultiAppModeType::APP_CLONE; + appInfo->bundleType = AppExecFwk::BundleType::ATOMIC_SERVICE; + ASSERT_NE(appInfo, nullptr); + auto appRecord = std::make_shared(appInfo, RECORD_ID, "com.example.child"); + ASSERT_NE(appRecord, nullptr); + std::shared_ptr abilityInfo = std::make_shared(); + ASSERT_NE(abilityInfo, nullptr); + abilityInfo->extensionAbilityType = AppExecFwk::ExtensionAbilityType::SHARE; + sptr token = nullptr; + auto abilityRecord = std::make_shared(abilityInfo, token, 0); + std::shared_ptr want = std::make_shared(); + abilityRecord->SetWant(want); + ASSERT_NE(abilityRecord, nullptr); + appRecord->StateChangedNotifyObserver(abilityRecord, 1, false, true); + auto applicationInfo = appRecord->GetApplicationInfo(); + EXPECT_EQ(applicationInfo->multiAppMode.multiAppModeType, MultiAppModeType::APP_CLONE); + EXPECT_EQ(applicationInfo->bundleType, AppExecFwk::BundleType::ATOMIC_SERVICE); +} + +/** + * @tc.name: AppRunningRecord_PopForegroundingAbilityTokens_0100 + * @tc.desc: Test PopForegroundingAbilityTokens works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_PopForegroundingAbilityTokens_0100, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + auto appRecord = std::make_shared(appInfo, RECORD_ID, "com.example.child"); + ASSERT_NE(appRecord, nullptr); + appRecord->foregroundingAbilityTokens_.insert(nullptr); + appRecord->PopForegroundingAbilityTokens(); + EXPECT_EQ(appRecord->foregroundingAbilityTokens_.size(), 0); +} + +/** + * @tc.name: AppRunningRecord_SendEvent_0300 + * @tc.desc: Test SendEvent works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_SendEvent_0300, TestSize.Level1) +{ + uint32_t msg = AMSEventHandler::START_PROCESS_SPECIFIED_ABILITY_TIMEOUT_MSG; + int64_t timeOut = TIMEOUT; + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + int32_t recordId = RECORD_ID; + std::string processName; + auto appRunningRecord = std::make_shared(appInfo, recordId, processName); + ASSERT_NE(appRunningRecord, nullptr); + appRunningRecord->taskHandler_ = AAFwk::TaskHandlerWrap::CreateQueueHandler(Constants::APP_MGR_SERVICE_NAME); + appRunningRecord->eventHandler_ = + std::make_shared(appRunningRecord->taskHandler_, appRunningRecord->appMgrServiceInner_); + appRunningRecord->isDebugApp_ = true; + appRunningRecord->isNativeDebug_ = false; + appRunningRecord->isAttachDebug_ = false; + appRunningRecord->SendEvent(msg, timeOut); + EXPECT_EQ(appRunningRecord->appEventId_, 2); +} + +/** + * @tc.name: AppRunningRecord_SendEvent_0400 + * @tc.desc: Test SendEvent works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_SendEvent_0400, TestSize.Level1) +{ + uint32_t msg = AMSEventHandler::START_PROCESS_SPECIFIED_ABILITY_TIMEOUT_MSG; + int64_t timeOut = TIMEOUT; + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + int32_t recordId = RECORD_ID; + std::string processName; + auto appRunningRecord = std::make_shared(appInfo, recordId, processName); + ASSERT_NE(appRunningRecord, nullptr); + appRunningRecord->appEventId_ = 0; + appRunningRecord->taskHandler_ = AAFwk::TaskHandlerWrap::CreateQueueHandler(Constants::APP_MGR_SERVICE_NAME); + appRunningRecord->eventHandler_ = + std::make_shared(appRunningRecord->taskHandler_, appRunningRecord->appMgrServiceInner_); + appRunningRecord->isDebugApp_ = false; + appRunningRecord->isNativeDebug_ = true; + appRunningRecord->isAttachDebug_ = false; + appRunningRecord->SendEvent(msg, timeOut); + EXPECT_EQ(appRunningRecord->appEventId_, 0); +} + +/** + * @tc.name: AppRunningRecord_SendEvent_0500 + * @tc.desc: Test SendEvent works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_SendEvent_0500, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + int32_t recordId = RECORD_ID; + std::string processName; + auto appRunningRecord = std::make_shared(appInfo, recordId, processName); + ASSERT_NE(appRunningRecord, nullptr); + appRunningRecord->appEventId_ = 0; + appRunningRecord->taskHandler_ = AAFwk::TaskHandlerWrap::CreateQueueHandler(Constants::APP_MGR_SERVICE_NAME); + appRunningRecord->eventHandler_ = + std::make_shared(appRunningRecord->taskHandler_, appRunningRecord->appMgrServiceInner_); + appRunningRecord->isDebugApp_ = false; + appRunningRecord->isNativeDebug_ = false; + appRunningRecord->isAttachDebug_ = true; + uint32_t msg = AMSEventHandler::START_PROCESS_SPECIFIED_ABILITY_TIMEOUT_MSG; + int64_t timeOut = TIMEOUT; + appRunningRecord->SendEvent(msg, timeOut); + EXPECT_EQ(appRunningRecord->appEventId_, 0); +} + +/** + * @tc.name: AppRunningRecord_OnWindowVisibilityChangedWithPendingState_0100 + * @tc.desc: Test OnWindowVisibilityChangedWithPendingState works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_OnWindowVisibilityChangedWithPendingState_0100, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + int32_t recordId = RECORD_ID; + std::string processName; + auto appRunningRecord = std::make_shared(appInfo, recordId, processName); + ASSERT_NE(appRunningRecord, nullptr); + appRunningRecord->pendingState_ == ApplicationPendingState::FOREGROUNDING; + appRunningRecord->hapModules_.clear(); + appRunningRecord->windowIds_.clear(); + appRunningRecord->foregroundingAbilityTokens_.clear(); + appRunningRecord->OnWindowVisibilityChangedWithPendingState(); + EXPECT_EQ(appRunningRecord->pendingState_, ApplicationPendingState::READY); +} + +/** + * @tc.name: AppRunningRecord_OnWindowVisibilityChangedWithPendingState_0200 + * @tc.desc: Test OnWindowVisibilityChangedWithPendingState works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_OnWindowVisibilityChangedWithPendingState_0200, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + int32_t recordId = RECORD_ID; + std::string processName; + auto appRunningRecord = std::make_shared(appInfo, recordId, processName); + ASSERT_NE(appRunningRecord, nullptr); + appRunningRecord->pendingState_ == ApplicationPendingState::BACKGROUNDING; + appRunningRecord->windowIds_.emplace(100); + appRunningRecord->OnWindowVisibilityChangedWithPendingState(); + EXPECT_EQ(appRunningRecord->pendingState_, ApplicationPendingState::FOREGROUNDING); +} + +/** + * @tc.name: AppRunningRecord_OnWindowVisibilityChangedWithPendingState_0300 + * @tc.desc: Test OnWindowVisibilityChangedWithPendingState works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_OnWindowVisibilityChangedWithPendingState_0300, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + int32_t recordId = RECORD_ID; + std::string processName; + auto appRunningRecord = std::make_shared(appInfo, recordId, processName); + ASSERT_NE(appRunningRecord, nullptr); + appRunningRecord->pendingState_ == ApplicationPendingState::READY; + appRunningRecord->curState_ == ApplicationState::APP_STATE_FOREGROUND; + appRunningRecord->hapModules_.clear(); + appRunningRecord->OnWindowVisibilityChangedWithPendingState(); + EXPECT_EQ(appRunningRecord->pendingState_, ApplicationPendingState::READY); +} + +/** + * @tc.name: AppRunningRecord_OnWindowVisibilityChangedWithPendingState_0400 + * @tc.desc: Test OnWindowVisibilityChangedWithPendingState works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_OnWindowVisibilityChangedWithPendingState_0400, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + int32_t recordId = RECORD_ID; + std::string processName; + auto appRunningRecord = std::make_shared(appInfo, recordId, processName); + ASSERT_NE(appRunningRecord, nullptr); + appRunningRecord->pendingState_ == ApplicationPendingState::READY; + appRunningRecord->OnWindowVisibilityChangedWithPendingState(); + EXPECT_EQ(appRunningRecord->pendingState_, ApplicationPendingState::READY); +} + +/** + * @tc.name: AppRunningRecord_OnWindowVisibilityChangedWithPendingState_0500 + * @tc.desc: Test OnWindowVisibilityChangedWithPendingState works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_OnWindowVisibilityChangedWithPendingState_0500, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + int32_t recordId = RECORD_ID; + std::string processName; + auto appRunningRecord = std::make_shared(appInfo, recordId, processName); + ASSERT_NE(appRunningRecord, nullptr); + appRunningRecord->pendingState_ == ApplicationPendingState::READY; + appRunningRecord->watchdogVisibilityState_ = WatchdogVisibilityState::WATCHDOG_STATE_UNVISIBILITY; + appRunningRecord->OnWindowVisibilityChangedWithPendingState(); + EXPECT_EQ(appRunningRecord->pendingState_, ApplicationPendingState::READY); + EXPECT_EQ(appRunningRecord->watchdogVisibilityState_, WatchdogVisibilityState::WATCHDOG_STATE_UNVISIBILITY); +} + +/** + * @tc.name: AppRunningRecord_OnWindowVisibilityChangedWithPendingState_0600 + * @tc.desc: Test OnWindowVisibilityChangedWithPendingState works. + * @tc.type: FUNC + */ +HWTEST_F(AppRunningRecordTest, AppRunningRecord_OnWindowVisibilityChangedWithPendingState_0600, TestSize.Level1) +{ + std::shared_ptr appInfo = std::make_shared(); + ASSERT_NE(appInfo, nullptr); + int32_t recordId = RECORD_ID; + std::string processName; + auto appRunningRecord = std::make_shared(appInfo, recordId, processName); + ASSERT_NE(appRunningRecord, nullptr); + appRunningRecord->pendingState_ == ApplicationPendingState::READY; + appRunningRecord->watchdogVisibilityState_ = WatchdogVisibilityState::WATCHDOG_STATE_VISIBILITY; + appRunningRecord->OnWindowVisibilityChangedWithPendingState(); + EXPECT_EQ(appRunningRecord->pendingState_, ApplicationPendingState::READY); + EXPECT_EQ(appRunningRecord->watchdogVisibilityState_, WatchdogVisibilityState::WATCHDOG_STATE_UNVISIBILITY); +} } // namespace AppExecFwk } // namespace OHOS diff --git a/test/unittest/ecological_rule_interceptor_test/ecological_rule_interceptor_test.cpp b/test/unittest/ecological_rule_interceptor_test/ecological_rule_interceptor_test.cpp index 53e60514d3c..ca86c281d58 100644 --- a/test/unittest/ecological_rule_interceptor_test/ecological_rule_interceptor_test.cpp +++ b/test/unittest/ecological_rule_interceptor_test/ecological_rule_interceptor_test.cpp @@ -1339,5 +1339,159 @@ HWTEST_F(EcologicalRuleInterceptorTest, DoProcess_018, TestSize.Level1) bool result = interceptor->DoProcess(want, userId); EXPECT_TRUE(result); } + +/** + * @tc.name: GetEcologicalTargetInfo_004 + * @tc.desc: Tests GetEcologicalTargetInfo + * @tc.type: FUNC + * @tc.require: No + */ +HWTEST_F(EcologicalRuleInterceptorTest, GetEcologicalTargetInfo_004, TestSize.Level1) +{ + std::shared_ptr interceptor = std::make_shared(); + ASSERT_NE(interceptor, nullptr); + StartAbilityUtils::callerAbilityInfo = std::make_shared(); + StartAbilityUtils::callerAbilityInfo->abilityInfo.applicationInfo.bundleType = + AppExecFwk::BundleType::ATOMIC_SERVICE; + Want want; + ErmsCallerInfo callerInfo; + sptr callerToken = nullptr; + int userId = 100; + interceptor->GetEcologicalCallerInfo(want, callerInfo, userId, callerToken); + EXPECT_EQ(callerInfo.callerAppType, ErmsCallerInfo::TYPE_ATOM_SERVICE); +} + +/** + * @tc.name: GetEcologicalTargetInfo_005 + * @tc.desc: Tests GetEcologicalTargetInfo + * @tc.type: FUNC + * @tc.require: No + */ +HWTEST_F(EcologicalRuleInterceptorTest, GetEcologicalTargetInfo_005, TestSize.Level1) +{ + std::shared_ptr interceptor = std::make_shared(); + ASSERT_NE(interceptor, nullptr); + StartAbilityUtils::callerAbilityInfo = std::make_shared(); + StartAbilityUtils::callerAbilityInfo->abilityInfo.applicationInfo.bundleType = AppExecFwk::BundleType::APP; + Want want; + ErmsCallerInfo callerInfo; + sptr callerToken = nullptr; + int userId = 100; + interceptor->GetEcologicalCallerInfo(want, callerInfo, userId, callerToken); + EXPECT_EQ(callerInfo.callerAppType, ErmsCallerInfo::TYPE_HARMONY_APP); +} + +/** + * @tc.name: GetEcologicalTargetInfo_006 + * @tc.desc: Tests GetEcologicalTargetInfo + * @tc.type: FUNC + * @tc.require: No + */ +HWTEST_F(EcologicalRuleInterceptorTest, GetEcologicalTargetInfo_006, TestSize.Level1) +{ + std::shared_ptr interceptor = std::make_shared(); + ASSERT_NE(interceptor, nullptr); + StartAbilityUtils::callerAbilityInfo = std::make_shared(); + StartAbilityUtils::callerAbilityInfo->abilityInfo.applicationInfo.bundleType = + AppExecFwk::BundleType::APP_SERVICE_FWK; + Want want; + ErmsCallerInfo callerInfo; + sptr callerToken = nullptr; + int userId = 100; + interceptor->GetEcologicalCallerInfo(want, callerInfo, userId, callerToken); + EXPECT_EQ(callerInfo.callerAppType, ErmsCallerInfo::TYPE_APP_SERVICE); +} + +/** + * @tc.name: GetEcologicalTargetInfo_007 + * @tc.desc: Tests GetEcologicalTargetInfo + * @tc.type: FUNC + * @tc.require: No + */ +HWTEST_F(EcologicalRuleInterceptorTest, GetEcologicalTargetInfo_007, TestSize.Level1) +{ + std::shared_ptr interceptor = std::make_shared(); + ASSERT_NE(interceptor, nullptr); + StartAbilityUtils::callerAbilityInfo = std::make_shared(); + StartAbilityUtils::callerAbilityInfo->abilityInfo.applicationInfo.bundleType = AppExecFwk::BundleType::APP; + StartAbilityUtils::callerAbilityInfo->abilityInfo.applicationInfo.name = "test"; + Want want; + ErmsCallerInfo callerInfo; + callerInfo.packageName = ""; + sptr callerToken = nullptr; + int userId = 100; + interceptor->GetEcologicalCallerInfo(want, callerInfo, userId, callerToken); + EXPECT_EQ(callerInfo.callerAppType, ErmsCallerInfo::TYPE_HARMONY_APP); + EXPECT_NE(callerInfo.packageName, BUNDLE_NAME_SCENEBOARD); +} + +/** + * @tc.name: GetEcologicalTargetInfo_008 + * @tc.desc: Tests GetEcologicalTargetInfo + * @tc.type: FUNC + * @tc.require: No + */ +HWTEST_F(EcologicalRuleInterceptorTest, GetEcologicalTargetInfo_008, TestSize.Level1) +{ + std::shared_ptr interceptor = std::make_shared(); + ASSERT_NE(interceptor, nullptr); + StartAbilityUtils::callerAbilityInfo = std::make_shared(); + StartAbilityUtils::callerAbilityInfo->abilityInfo.applicationInfo.bundleType = AppExecFwk::BundleType::APP; + StartAbilityUtils::callerAbilityInfo->abilityInfo.applicationInfo.name = BUNDLE_NAME_SCENEBOARD; + Want want; + ErmsCallerInfo callerInfo; + callerInfo.packageName = ""; + sptr callerToken = nullptr; + int userId = 100; + interceptor->GetEcologicalCallerInfo(want, callerInfo, userId, callerToken); + EXPECT_EQ(callerInfo.callerAppType, ErmsCallerInfo::TYPE_HARMONY_APP); + EXPECT_EQ(callerInfo.packageName, BUNDLE_NAME_SCENEBOARD); +} + +/** + * @tc.name: GetEcologicalTargetInfo_009 + * @tc.desc: Tests GetEcologicalTargetInfo + * @tc.type: FUNC + * @tc.require: No + */ +HWTEST_F(EcologicalRuleInterceptorTest, GetEcologicalTargetInfo_009, TestSize.Level1) +{ + std::shared_ptr interceptor = std::make_shared(); + ASSERT_NE(interceptor, nullptr); + StartAbilityUtils::callerAbilityInfo = std::make_shared(); + StartAbilityUtils::callerAbilityInfo->abilityInfo.applicationInfo.bundleType = AppExecFwk::BundleType::APP; + StartAbilityUtils::callerAbilityInfo->abilityInfo.applicationInfo.name = BUNDLE_NAME_SCENEBOARD; + Want want; + ErmsCallerInfo callerInfo; + callerInfo.packageName = "test"; + sptr callerToken = nullptr; + int userId = 100; + interceptor->GetEcologicalCallerInfo(want, callerInfo, userId, callerToken); + EXPECT_EQ(callerInfo.callerAppType, ErmsCallerInfo::TYPE_HARMONY_APP); + EXPECT_NE(callerInfo.packageName, BUNDLE_NAME_SCENEBOARD); +} + +/** + * @tc.name: GetEcologicalTargetInfo_010 + * @tc.desc: Tests GetEcologicalTargetInfo + * @tc.type: FUNC + * @tc.require: No + */ +HWTEST_F(EcologicalRuleInterceptorTest, GetEcologicalTargetInfo_010, TestSize.Level1) +{ + std::shared_ptr interceptor = std::make_shared(); + ASSERT_NE(interceptor, nullptr); + StartAbilityUtils::callerAbilityInfo = std::make_shared(); + StartAbilityUtils::callerAbilityInfo->abilityInfo.applicationInfo.bundleType = AppExecFwk::BundleType::APP; + StartAbilityUtils::callerAbilityInfo->abilityInfo.applicationInfo.name = "test"; + Want want; + ErmsCallerInfo callerInfo; + callerInfo.packageName = "test"; + sptr callerToken = nullptr; + int userId = 100; + interceptor->GetEcologicalCallerInfo(want, callerInfo, userId, callerToken); + EXPECT_EQ(callerInfo.callerAppType, ErmsCallerInfo::TYPE_HARMONY_APP); + EXPECT_NE(callerInfo.packageName, BUNDLE_NAME_SCENEBOARD); +} } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/multi_instance_utils_test/multi_instance_utils_test.cpp b/test/unittest/multi_instance_utils_test/multi_instance_utils_test.cpp index 404d120087b..02570116036 100644 --- a/test/unittest/multi_instance_utils_test/multi_instance_utils_test.cpp +++ b/test/unittest/multi_instance_utils_test/multi_instance_utils_test.cpp @@ -34,6 +34,7 @@ public: static void TearDownTestCase(); void SetUp() override; void TearDown() override; + std::shared_ptr MockAbilityRecord(AppExecFwk::AbilityType abilityType); }; void MultiInstanceUtilsTest::SetUpTestCase(void) {} @@ -41,6 +42,15 @@ void MultiInstanceUtilsTest::TearDownTestCase(void) {} void MultiInstanceUtilsTest::SetUp() {} void MultiInstanceUtilsTest::TearDown() {} +std::shared_ptr MultiInstanceUtilsTest::MockAbilityRecord(AppExecFwk::AbilityType abilityType) +{ + AbilityRequest abilityRequest; + abilityRequest.appInfo.bundleName = "com.test.demo"; + abilityRequest.abilityInfo.name = "MainAbility"; + abilityRequest.abilityInfo.type = abilityType; + return AbilityRecord::CreateAbilityRecord(abilityRequest); +} + /** * @tc.name: MultiInstanceUtils_GetInstanceKey_0100 * @tc.desc: GetInstanceKey @@ -92,6 +102,49 @@ HWTEST_F(MultiInstanceUtilsTest, MultiInstanceUtils_GetValidExtensionInstanceKey TAG_LOGI(AAFwkTag::TEST, "MultiInstanceUtils_GetValidExtensionInstanceKey_0200 end"); } +/** + * @tc.name: MultiInstanceUtils_GetValidExtensionInstanceKey_0300 + * @tc.desc: GetValidExtensionInstanceKey + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(MultiInstanceUtilsTest, MultiInstanceUtils_GetValidExtensionInstanceKey_0300, TestSize.Level1) +{ + AbilityRequest abilityRequest; + abilityRequest.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::WORK_SCHEDULER; + sptr callerToken = nullptr; + std::shared_ptr abilityRecord = MockAbilityRecord(AppExecFwk::AbilityType::PAGE); + ASSERT_NE(abilityRecord, nullptr); + callerToken = abilityRecord->GetToken(); + abilityRequest.callerToken = callerToken; + auto key = MultiInstanceUtils::GetValidExtensionInstanceKey(abilityRequest); + EXPECT_EQ(key, "app_instance_0"); +} + +/** + * @tc.name: MultiInstanceUtils_GetValidExtensionInstanceKey_0400 + * @tc.desc: GetValidExtensionInstanceKey + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(MultiInstanceUtilsTest, MultiInstanceUtils_GetValidExtensionInstanceKey_0400, TestSize.Level1) +{ + AbilityRequest abilityRequest; + abilityRequest.abilityInfo.extensionAbilityType = AppExecFwk::ExtensionAbilityType::WORK_SCHEDULER; + std::string bundleName = ""; + Want want; + want.SetBundle(bundleName); + sptr callerToken = nullptr; + std::shared_ptr abilityRecord = MockAbilityRecord(AppExecFwk::AbilityType::PAGE); + ASSERT_NE(abilityRecord, nullptr); + std::string instanceKey = "instanceKey"; + abilityRecord->SetInstanceKey(instanceKey); + callerToken = abilityRecord->GetToken(); + abilityRequest.callerToken = callerToken; + auto key = MultiInstanceUtils::GetValidExtensionInstanceKey(abilityRequest); + EXPECT_EQ(key, instanceKey); +} + /** * @tc.name: MultiInstanceUtils_GetSelfCallerInstanceKey_0100 * @tc.desc: GetSelfCallerInstanceKey @@ -139,6 +192,20 @@ HWTEST_F(MultiInstanceUtilsTest, MultiInstanceUtils_IsMultiInstanceApp_0100, Tes TAG_LOGI(AAFwkTag::TEST, "MultiInstanceUtils_IsMultiInstanceApp_0100 end"); } +/** + * @tc.name: MultiInstanceUtils_IsMultiInstanceApp_0200 + * @tc.desc: IsMultiInstanceApp + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(MultiInstanceUtilsTest, MultiInstanceUtils_IsMultiInstanceApp_0200, TestSize.Level1) +{ + AbilityRequest abilityRequest; + abilityRequest.appInfo.multiAppMode.multiAppModeType = AppExecFwk::MultiAppModeType::MULTI_INSTANCE; + auto ret = MultiInstanceUtils::IsMultiInstanceApp(abilityRequest.appInfo); + EXPECT_EQ(ret, false); +} + /** * @tc.name: MultiInstanceUtils_IsSupportedExtensionType_0100 * @tc.desc: IsSupportedExtensionType diff --git a/test/unittest/start_ability_utils_test/BUILD.gn b/test/unittest/start_ability_utils_test/BUILD.gn index c65e4353f43..7ebdfb0e2fc 100644 --- a/test/unittest/start_ability_utils_test/BUILD.gn +++ b/test/unittest/start_ability_utils_test/BUILD.gn @@ -27,6 +27,7 @@ ohos_unittest("start_ability_utils_test") { ] sources = [ + "${ability_runtime_services_path}/abilitymgr/src/utils/start_ability_utils.cpp", "mock/src/mock_bundle_mgr_helper.cpp", "mock/src/mock_my_status.cpp", "start_ability_utils_test.cpp", @@ -37,15 +38,25 @@ ohos_unittest("start_ability_utils_test") { cflags += [ "-DBINDER_IPC_32BIT" ] } - deps = [ "${ability_runtime_services_path}/abilitymgr:abilityms" ] + deps = [ + "${ability_runtime_innerkits_path}/ability_manager:ability_manager", + "${ability_runtime_native_path}/appkit:appkit_manager_helper", + "${ability_runtime_path}/utils/server/startup:startup_util", + "${ability_runtime_services_path}/abilitymgr:abilityms", + "${ability_runtime_services_path}/common:app_util", + ] external_deps = [ "ability_base:want", "bundle_framework:appexecfwk_base", "bundle_framework:appexecfwk_core", "c_utils:utils", + "ffrt:libffrt", "googletest:gmock_main", "googletest:gtest_main", + "hilog:libhilog", + "hisysevent:libhisysevent", + "hitrace:hitrace_meter", "ipc:ipc_core", ] } diff --git a/test/unittest/start_ability_utils_test/start_ability_utils_test.cpp b/test/unittest/start_ability_utils_test/start_ability_utils_test.cpp index 19202516491..2ed2ed36cff 100644 --- a/test/unittest/start_ability_utils_test/start_ability_utils_test.cpp +++ b/test/unittest/start_ability_utils_test/start_ability_utils_test.cpp @@ -166,5 +166,163 @@ HWTEST_F(StartAbilityUtilsTest, CheckAppProvisionMode_005, TestSize.Level1) int32_t ret = StartAbilityUtils::CheckAppProvisionMode(want, userId); EXPECT_EQ(ret, StartAbilityUtils::startAbilityInfo->status); } + +/** + * @tc.name: CheckAppProvisionMode_006 + * @tc.desc: test class StartAbilityUtil CheckAppProvisionMode function + * @tc.type: FUNC + */ +HWTEST_F(StartAbilityUtilsTest, CheckAppProvisionMode_006, TestSize.Level1) +{ + std::string bundleName = "testName"; + Want want; + want.SetBundle(bundleName); + int32_t userId = 0; + StartAbilityUtils::startAbilityInfo = std::make_shared(); + AppExecFwk::ApplicationInfo applicationInfo; + applicationInfo.bundleName = bundleName; + StartAbilityUtils::startAbilityInfo->abilityInfo.applicationInfo = applicationInfo; + auto ret = StartAbilityUtils::CheckAppProvisionMode(want, userId); + EXPECT_EQ(ret, ERR_NOT_IN_APP_PROVISION_MODE); +} + +/** + * @tc.name: CheckAppProvisionMode_007 + * @tc.desc: test class StartAbilityUtil CheckAppProvisionMode function + * @tc.type: FUNC + */ +HWTEST_F(StartAbilityUtilsTest, CheckAppProvisionMode_007, TestSize.Level1) +{ + std::string bundleName = "testName"; + Want want; + want.SetParam("ohos.dlp.params.index", 5); + int32_t userId = 0; + StartAbilityUtils::startAbilityInfo = std::make_shared(); + AppExecFwk::ApplicationInfo applicationInfo; + applicationInfo.bundleName = bundleName; + StartAbilityUtils::startAbilityInfo->abilityInfo.applicationInfo = applicationInfo; + auto ret = StartAbilityUtils::CheckAppProvisionMode(want, userId); + EXPECT_EQ(ret, ERR_APP_CLONE_INDEX_INVALID); +} + +/** + * @tc.name: CheckAppProvisionMode_008 + * @tc.desc: test class StartAbilityUtil CheckAppProvisionMode function + * @tc.type: FUNC + */ +HWTEST_F(StartAbilityUtilsTest, CheckAppProvisionMode_008, TestSize.Level1) +{ + std::string bundleName = "testName"; + Want want; + want.SetBundle(bundleName); + int32_t userId = 0; + StartAbilityUtils::startAbilityInfo = std::make_shared(); + AppExecFwk::ApplicationInfo applicationInfo; + applicationInfo.bundleName = bundleName; + applicationInfo.appProvisionType = AppExecFwk::Constants::APP_PROVISION_TYPE_DEBUG; + StartAbilityUtils::startAbilityInfo->abilityInfo.applicationInfo = applicationInfo; + auto ret = StartAbilityUtils::CheckAppProvisionMode(want, userId); + EXPECT_EQ(ret, ERR_OK); +} + +/** + * @tc.name: CheckAppProvisionMode_009 + * @tc.desc: test class StartAbilityUtil CheckAppProvisionMode function + * @tc.type: FUNC + */ +HWTEST_F(StartAbilityUtilsTest, CheckAppProvisionMode_009, TestSize.Level1) +{ + std::string bundleName = "testName"; + Want want; + want.SetParam("ohos.dlp.params.index", 0); + want.SetParam(AAFwk::Want::PARAM_APP_CLONE_INDEX_KEY, 0); + want.SetParam(AAFwk::Want::DESTINATION_PLUGIN_ABILITY, true); + int32_t userId = 0; + StartAbilityUtils::startAbilityInfo = std::make_shared(); + AppExecFwk::ApplicationInfo applicationInfo; + applicationInfo.bundleName = bundleName; + StartAbilityUtils::startAbilityInfo->abilityInfo.applicationInfo = applicationInfo; + auto ret = StartAbilityUtils::CheckAppProvisionMode(want, userId); + EXPECT_EQ(ret, RESOLVE_ABILITY_ERR); +} + +/** + * @tc.name: CreateStartExtensionInfo_001 + * @tc.desc: test class StartAbilityUtil CreateStartExtensionInfo function + * @tc.type: FUNC + */ +HWTEST_F(StartAbilityUtilsTest, CreateStartExtensionInfo_001, TestSize.Level1) +{ + Want want; + int32_t userId = 0; + int32_t appIndex = 1; + auto ret = StartAbilityInfo::CreateStartExtensionInfo(want, userId, appIndex); + ASSERT_NE(ret, nullptr); +} + +/** + * @tc.name: CreateStartExtensionInfo_002 + * @tc.desc: test class StartAbilityUtil CreateStartExtensionInfo function + * @tc.type: FUNC + */ +HWTEST_F(StartAbilityUtilsTest, CreateStartExtensionInfo_002, TestSize.Level1) +{ + Want want; + int32_t userId = 0; + int32_t appIndex = 10000; + auto ret = StartAbilityInfo::CreateStartExtensionInfo(want, userId, appIndex); + ASSERT_NE(ret, nullptr); +} + +/** + * @tc.name: CreateStartExtensionInfo_003 + * @tc.desc: test class StartAbilityUtil CreateStartExtensionInfo function + * @tc.type: FUNC + */ +HWTEST_F(StartAbilityUtilsTest, CreateStartExtensionInfo_003, TestSize.Level1) +{ + Want want; + int32_t userId = 0; + int32_t appIndex = 0; + int32_t validUserId = 0; + StartAbilityUtils::startAbilityInfo = std::make_shared(); + StartAbilityInfoWrap threadLocalInfo(want, validUserId, appIndex, nullptr); + auto ret = StartAbilityInfo::CreateStartExtensionInfo(want, userId, appIndex); + ASSERT_NE(ret, nullptr); +} + +/** + * @tc.name: SetStartAbilityInfo_001 + * @tc.desc: test class StartAbilityUtil SetStartAbilityInfo_ function + * @tc.type: FUNC + */ +HWTEST_F(StartAbilityUtilsTest, SetStartAbilityInfo_001, TestSize.Level1) +{ + StartAbilityUtils::startAbilityInfo = nullptr; + AppExecFwk::AbilityInfo abilityInfo; + StartAbilityInfoWrap startAbilityInfoWrap; + startAbilityInfoWrap.SetStartAbilityInfo(abilityInfo); + ASSERT_NE(StartAbilityUtils::startAbilityInfo, nullptr); + + StartAbilityUtils::startAbilityInfo = std::make_shared(); + abilityInfo.name = "abilityName"; + startAbilityInfoWrap.SetStartAbilityInfo(abilityInfo); + auto abilityName = StartAbilityUtils::startAbilityInfo->abilityInfo.name; + EXPECT_NE(abilityName, abilityInfo.name); +} + +/** + * @tc.name: CreateStartAbilityInfo_001 + * @tc.desc: test class StartAbilityUtil CreateStartAbilityInfo function + * @tc.type: FUNC + */ +HWTEST_F(StartAbilityUtilsTest, CreateStartAbilityInfo_001, TestSize.Level1) +{ + Want want; + int32_t userId = 0; + int32_t appIndex = 0; + auto ret = StartAbilityInfo::CreateStartAbilityInfo(want, userId, appIndex, nullptr); + ASSERT_NE(ret, nullptr); +} } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/update_caller_info_util_test/update_caller_info_util_test.cpp b/test/unittest/update_caller_info_util_test/update_caller_info_util_test.cpp index a2ad17cbe38..153dd98d132 100644 --- a/test/unittest/update_caller_info_util_test/update_caller_info_util_test.cpp +++ b/test/unittest/update_caller_info_util_test/update_caller_info_util_test.cpp @@ -34,6 +34,10 @@ using OHOS::AppExecFwk::AbilityType; using OHOS::AppExecFwk::ExtensionAbilityType; namespace OHOS { namespace AAFwk { + +constexpr const char *CALLER_REQUEST_CODE = "ohos.extra.param.key.callerRequestCode"; +constexpr const char *DMS_CALLER_BUNDLE_NAME = "ohos.dms.param.sourceCallerBundleName"; + class UpdateCallerInfoUtilTest : public testing::Test { public: static void SetUpTestCase(); @@ -211,5 +215,118 @@ HWTEST_F(UpdateCallerInfoUtilTest, UpdateAsCallerInfoFromDialog_0002, TestSize.L bool ret = updateCallerUtil->UpdateAsCallerInfoFromDialog(want); EXPECT_FALSE(ret); } + +/** + * @tc.name: UpdateCallerInfoUtilTest_UpdateAsCallerInfoFromToken_0001 + * @tc.desc: Test the state of UpdateAsCallerInfoFromToken + * @tc.type: FUNC + */ +HWTEST_F(UpdateCallerInfoUtilTest, UpdateAsCallerInfoFromToken_0001, TestSize.Level1) +{ + std::shared_ptr updateCallerUtil = std::make_shared(); + ASSERT_NE(updateCallerUtil, nullptr); + Want want; + sptr callerToken = nullptr; + updateCallerUtil->UpdateAsCallerInfoFromToken(want, callerToken); + auto bundleName = want.GetStringParam(Want::PARAM_RESV_CALLER_BUNDLE_NAME); + EXPECT_TRUE(bundleName.empty()); +} + +/** + * @tc.name: UpdateCallerInfoUtilTest_UpdateAsCallerInfoFromToken_0002 + * @tc.desc: Test the state of UpdateAsCallerInfoFromToken + * @tc.type: FUNC + */ +HWTEST_F(UpdateCallerInfoUtilTest, UpdateAsCallerInfoFromToken_0002, TestSize.Level1) +{ + std::shared_ptr updateCallerUtil = std::make_shared(); + ASSERT_NE(updateCallerUtil, nullptr); + Want want; + sptr callerToken = nullptr; + std::shared_ptr abilityRecord = MockAbilityRecord(AbilityType::PAGE); + ASSERT_NE(abilityRecord, nullptr); + callerToken = abilityRecord->GetToken(); + updateCallerUtil->UpdateAsCallerInfoFromToken(want, callerToken); + EXPECT_TRUE(want.HasParameter(Want::PARAM_RESV_CALLER_TOKEN)); +} + +/** + * @tc.name: UpdateCallerInfoUtilTest_UpdateBackToCallerFlag_0001 + * @tc.desc: Test the state of UpdateBackToCallerFlag + * @tc.type: FUNC + */ +HWTEST_F(UpdateCallerInfoUtilTest, UpdateBackToCallerFlag_0001, TestSize.Level1) +{ + std::shared_ptr updateCallerUtil = std::make_shared(); + ASSERT_NE(updateCallerUtil, nullptr); + Want want; + want.SetParam(OHOS::AAFwk::CALLER_REQUEST_CODE, 0); + sptr callerToken = nullptr; + std::shared_ptr abilityRecord = MockAbilityRecord(AbilityType::PAGE); + ASSERT_NE(abilityRecord, nullptr); + callerToken = abilityRecord->GetToken(); + int32_t requestCode = 0; + bool backFlag = true; + updateCallerUtil->UpdateBackToCallerFlag(callerToken, want, requestCode, backFlag); + EXPECT_FALSE(want.HasParameter(OHOS::AAFwk::CALLER_REQUEST_CODE)); +} + +/** + * @tc.name: UpdateCallerInfoUtilTest_UpdateBackToCallerFlag_0002 + * @tc.desc: Test the state of UpdateBackToCallerFlag + * @tc.type: FUNC + */ +HWTEST_F(UpdateCallerInfoUtilTest, UpdateBackToCallerFlag_0002, TestSize.Level1) +{ + std::shared_ptr updateCallerUtil = std::make_shared(); + ASSERT_NE(updateCallerUtil, nullptr); + Want want; + sptr callerToken = nullptr; + std::shared_ptr abilityRecord = MockAbilityRecord(AbilityType::PAGE); + ASSERT_NE(abilityRecord, nullptr); + callerToken = abilityRecord->GetToken(); + int32_t requestCode = 0; + bool backFlag = true; + updateCallerUtil->UpdateBackToCallerFlag(callerToken, want, requestCode, backFlag); + EXPECT_FALSE(want.HasParameter(OHOS::AAFwk::CALLER_REQUEST_CODE)); +} + +/** + * @tc.name: UpdateCallerInfoUtilTest_UpdateBackToCallerFlag_0003 + * @tc.desc: Test the state of UpdateBackToCallerFlag + * @tc.type: FUNC + */ +HWTEST_F(UpdateCallerInfoUtilTest, UpdateBackToCallerFlag_0003, TestSize.Level1) +{ + std::shared_ptr updateCallerUtil = std::make_shared(); + ASSERT_NE(updateCallerUtil, nullptr); + Want want; + sptr callerToken = nullptr; + std::shared_ptr abilityRecord = MockAbilityRecord(AbilityType::PAGE); + ASSERT_NE(abilityRecord, nullptr); + callerToken = abilityRecord->GetToken(); + int32_t requestCode = 1; + bool backFlag = true; + updateCallerUtil->UpdateBackToCallerFlag(callerToken, want, requestCode, backFlag); + EXPECT_TRUE(want.HasParameter(OHOS::AAFwk::CALLER_REQUEST_CODE)); +} + +/** + * @tc.name: UpdateCallerInfoUtilTest_UpdateDmsCallerInfo_0001 + * @tc.desc: Test the state of UpdateDmsCallerInfo + * @tc.type: FUNC + */ +HWTEST_F(UpdateCallerInfoUtilTest, UpdateDmsCallerInfo_0001, TestSize.Level1) +{ + std::shared_ptr updateCallerUtil = std::make_shared(); + ASSERT_NE(updateCallerUtil, nullptr); + Want want; + sptr callerToken = nullptr; + std::shared_ptr abilityRecord = MockAbilityRecord(AbilityType::PAGE); + ASSERT_NE(abilityRecord, nullptr); + callerToken = abilityRecord->GetToken(); + updateCallerUtil->UpdateDmsCallerInfo(want, callerToken); + EXPECT_TRUE(want.HasParameter(OHOS::AAFwk::DMS_CALLER_BUNDLE_NAME)); +} } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/uri_utils_test/uri_utils_test.cpp b/test/unittest/uri_utils_test/uri_utils_test.cpp index 2e77f32d2c8..0df8901cc02 100644 --- a/test/unittest/uri_utils_test/uri_utils_test.cpp +++ b/test/unittest/uri_utils_test/uri_utils_test.cpp @@ -760,5 +760,39 @@ HWTEST_F(UriUtilsTest, ProcessUDMFKey_002, TestSize.Level1) uriUtils.ProcessUDMFKey(want); EXPECT_EQ(want.GetStringParam(Want::PARAM_ABILITY_UNIFIED_DATA_KEY).empty(), true); } + +/* + * Feature: UriUtils + * Function: IsInAncoAppIdentifier + * SubFunction: NA + * FunctionPoints: UriUtils IsInAncoAppIdentifier + */ +HWTEST_F(UriUtilsTest, IsInAncoAppIdentifier_001, TestSize.Level1) +{ + auto &uriUtils = UriUtils::GetInstance(); + std::string uri = ""; + Want want; + want.SetUri(uri); + uriUtils.PublishFileOpenEvent(want); + auto result = uriUtils.IsInAncoAppIdentifier("com.example.test"); + EXPECT_FALSE(result); +} + +/* + * Feature: UriUtils + * Function: IsInAncoAppIdentifier + * SubFunction: NA + * FunctionPoints: UriUtils IsInAncoAppIdentifier + */ +HWTEST_F(UriUtilsTest, IsInAncoAppIdentifier_002, TestSize.Level1) +{ + auto &uriUtils = UriUtils::GetInstance(); + std::string uri = "file://com.example.test/test.txt"; + Want want; + want.SetUri(uri); + uriUtils.PublishFileOpenEvent(want); + auto result = uriUtils.IsInAncoAppIdentifier("com.example.test"); + EXPECT_FALSE(result); +} } } \ No newline at end of file -- Gitee