diff --git a/services/abilitymgr/test/unittest/phone/ability_dump_test/ability_dump_test.cpp b/services/abilitymgr/test/unittest/phone/ability_dump_test/ability_dump_test.cpp index 70c42ba74cade5fb14c468ed97482b09731df5d8..fa7d71e84d9e5209b3a598edc42d7436e3a2e3cc 100644 --- a/services/abilitymgr/test/unittest/phone/ability_dump_test/ability_dump_test.cpp +++ b/services/abilitymgr/test/unittest/phone/ability_dump_test/ability_dump_test.cpp @@ -106,11 +106,54 @@ public: void startAbility4(); void startAbility5(); void startAbility6(); + void OnStartAms(); public: static constexpr int TEST_WAIT_TIME = 100000; }; +void AbilityDumpTest::OnStartAms() +{ + if(g_abilityMs){ + + if(g_abilityMs->state_ == ServiceRunningState::STATE_RUNNING) { + return; + } + + g_abilityMs->state_ = ServiceRunningState::STATE_RUNNING; + + g_abilityMs->eventLoop_ = AppExecFwk::EventRunner::Create(AbilityConfig::NAME_ABILITY_MGR_SERVICE); + EXPECT_TRUE(g_abilityMs->eventLoop_); + + g_abilityMs->handler_ = std::make_shared(g_abilityMs->eventLoop_, g_abilityMs); + EXPECT_TRUE(g_abilityMs->handler_); + EXPECT_TRUE(g_abilityMs->connectManager_); + + g_abilityMs->connectManager_->SetEventHandler(g_abilityMs->handler_); + + g_abilityMs->dataAbilityManager_ = std::make_shared(); + EXPECT_TRUE(g_abilityMs->dataAbilityManager_); + + g_abilityMs->amsConfigResolver_ = std::make_shared(); + EXPECT_TRUE(g_abilityMs->amsConfigResolver_); + g_abilityMs->amsConfigResolver_->Parse(); + + g_abilityMs->pendingWantManager_ = std::make_shared(); + EXPECT_TRUE(g_abilityMs->pendingWantManager_); + + int userId = g_abilityMs->GetUserId(); + g_abilityMs->SetStackManager(userId); + g_abilityMs->systemAppManager_ = std::make_shared(userId); + EXPECT_TRUE(g_abilityMs->systemAppManager_); + + g_abilityMs->eventLoop_->Run(); + + return; + } + + GTEST_LOG_(INFO) << "OnStart fail"; +} + void AbilityDumpTest::SetUpTestCase() { OHOS::DelayedSingleton::GetInstance()->RegisterSystemAbility( @@ -127,7 +170,7 @@ void AbilityDumpTest::SetUp() g_abilityMs = OHOS::DelayedSingleton::GetInstance(); g_appTestService = OHOS::DelayedSingleton::GetInstance(); - g_abilityMs->OnStart(); + OnStartAms(); WaitUntilTaskFinished(); g_appTestService->Start(); @@ -136,6 +179,7 @@ void AbilityDumpTest::SetUp() void AbilityDumpTest::TearDown() { + g_abilityMs->OnStop(); OHOS::DelayedSingleton::DestroyInstance(); } @@ -143,8 +187,10 @@ void AbilityDumpTest::StartAbilityes() { EXPECT_TRUE(g_abilityMs->currentStackManager_); auto currentTopAbilityRecord = g_abilityMs->currentStackManager_->GetCurrentTopAbility(); - EXPECT_TRUE(currentTopAbilityRecord); - currentTopAbilityRecord->SetAbilityState(AbilityState::ACTIVE); + if(currentTopAbilityRecord) { + currentTopAbilityRecord->SetAbilityState(AbilityState::ACTIVE); + } + startAbility6(); startAbility1(); startAbility2(); diff --git a/services/abilitymgr/test/unittest/phone/ability_manager_service_test/ability_manager_service_test.cpp b/services/abilitymgr/test/unittest/phone/ability_manager_service_test/ability_manager_service_test.cpp index b8c59f5031992642c6a206872f254bfd1e31d2a5..2d2c931c58c7bd9da1ca1d2ef8ae01f7f6bf98fe 100644 --- a/services/abilitymgr/test/unittest/phone/ability_manager_service_test/ability_manager_service_test.cpp +++ b/services/abilitymgr/test/unittest/phone/ability_manager_service_test/ability_manager_service_test.cpp @@ -57,6 +57,26 @@ static void WaitUntilTaskFinished() } } +static void WaitUntilTaskFinishedByTimer() +{ + const uint32_t maxRetryCount = 1000; + const uint32_t sleepTime = 1000; + uint32_t count = 0; + auto handler = OHOS::DelayedSingleton::GetInstance()->GetEventHandler(); + std::atomic taskCalled(false); + auto f = [&taskCalled]() { taskCalled.store(true); }; + int sleepingTime = 5000; + if (handler->PostTask(f, "AbilityManagerServiceTest", sleepingTime)) { + while (!taskCalled.load()) { + ++count; + if (count >= maxRetryCount) { + break; + } + usleep(sleepTime); + } + } +} + #define SLEEP(milli) std::this_thread::sleep_for(std::chrono::seconds(milli)) namespace { @@ -70,6 +90,8 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); + void OnStartAms(); + void OnStopAms(); int StartAbility(const Want &want); static constexpr int TEST_WAIT_TIME = 100000; @@ -91,6 +113,59 @@ int AbilityManagerServiceTest::StartAbility(const Want &want) return ref; } +void AbilityManagerServiceTest::OnStartAms() +{ + if(abilityMs_){ + + if(abilityMs_->state_ == ServiceRunningState::STATE_RUNNING) { + return; + } + + abilityMs_->state_ = ServiceRunningState::STATE_RUNNING; + + abilityMs_->eventLoop_ = AppExecFwk::EventRunner::Create(AbilityConfig::NAME_ABILITY_MGR_SERVICE); + EXPECT_TRUE(abilityMs_->eventLoop_); + + abilityMs_->handler_ = std::make_shared(abilityMs_->eventLoop_, abilityMs_); + EXPECT_TRUE(abilityMs_->handler_); + EXPECT_TRUE(abilityMs_->connectManager_); + + abilityMs_->connectManager_->SetEventHandler(abilityMs_->handler_); + + abilityMs_->dataAbilityManager_ = std::make_shared(); + EXPECT_TRUE(abilityMs_->dataAbilityManager_); + + abilityMs_->amsConfigResolver_ = std::make_shared(); + EXPECT_TRUE(abilityMs_->amsConfigResolver_); + abilityMs_->amsConfigResolver_->Parse(); + + abilityMs_->pendingWantManager_ = std::make_shared(); + EXPECT_TRUE(abilityMs_->pendingWantManager_); + + int userId = abilityMs_->GetUserId(); + abilityMs_->SetStackManager(userId); + abilityMs_->systemAppManager_ = std::make_shared(userId); + EXPECT_TRUE(abilityMs_->systemAppManager_); + + abilityMs_->eventLoop_->Run(); + + return; + } + + GTEST_LOG_(INFO) << "OnStart fail"; +} + + + +void AbilityManagerServiceTest::OnStopAms() +{ + abilityMs_->eventLoop_.reset(); + abilityMs_->handler_.reset(); + abilityMs_->state_ = ServiceRunningState::STATE_NOT_START; +} + + + void AbilityManagerServiceTest::SetUpTestCase() { OHOS::DelayedSingleton::GetInstance()->RegisterSystemAbility( @@ -105,7 +180,7 @@ void AbilityManagerServiceTest::TearDownTestCase() void AbilityManagerServiceTest::SetUp() { abilityMs_ = OHOS::DelayedSingleton::GetInstance(); - abilityMs_->OnStart(); + OnStartAms(); WaitUntilTaskFinished(); if (abilityRecord_ == nullptr) { abilityRequest_.appInfo.bundleName = "data.client.bundle"; @@ -113,11 +188,12 @@ void AbilityManagerServiceTest::SetUp() abilityRequest_.abilityInfo.type = AbilityType::DATA; abilityRecord_ = AbilityRecord::CreateAbilityRecord(abilityRequest_); } + } void AbilityManagerServiceTest::TearDown() { - abilityMs_->OnStop(); + OnStopAms(); OHOS::DelayedSingleton::DestroyInstance(); } @@ -371,7 +447,7 @@ HWTEST_F(AbilityManagerServiceTest, Interface_008, TestSize.Level1) auto result3 = abilityMs_->TerminateAbility(token, -1, &want); WaitUntilTaskFinished(); - EXPECT_EQ(ERR_INVALID_VALUE, result3); + EXPECT_NE(ERR_OK, result3); } /* @@ -479,13 +555,13 @@ HWTEST_F(AbilityManagerServiceTest, Interface_010, TestSize.Level1) HWTEST_F(AbilityManagerServiceTest, Interface_011, TestSize.Level1) { Want wantLuncher; - ElementName elementLun("device", "com.ix.hiworld", "LauncherAbility"); + ElementName elementLun("device", "com.ohos.launcher", "com.ohos.launcher.MainAbility"); wantLuncher.SetElement(elementLun); abilityMs_->StartAbility(wantLuncher); WaitUntilTaskFinished(); auto stackManager = abilityMs_->GetStackManager(); auto topAbility = stackManager->GetCurrentTopAbility(); - EXPECT_EQ(topAbility->GetAbilityInfo().bundleName, "com.ix.hiworld"); + EXPECT_EQ(topAbility->GetAbilityInfo().name, "com.ohos.launcher.MainAbility"); OHOS::sptr scheduler = new AbilityScheduler(); OHOS::sptr nullScheduler = nullptr; @@ -509,13 +585,15 @@ HWTEST_F(AbilityManagerServiceTest, Interface_011, TestSize.Level1) HWTEST_F(AbilityManagerServiceTest, Interface_012, TestSize.Level1) { Want wantLuncher; - ElementName elementLun("device", "com.ix.hiworld", "LauncherAbility"); + ElementName elementLun("device", "com.ix.music", "MusicAbility"); wantLuncher.SetElement(elementLun); abilityMs_->StartAbility(wantLuncher); WaitUntilTaskFinished(); auto stackManager = abilityMs_->GetStackManager(); auto topAbility = stackManager->GetCurrentTopAbility(); - EXPECT_EQ(topAbility->GetAbilityInfo().bundleName, "com.ix.hiworld"); + + EXPECT_EQ(topAbility->GetAbilityInfo().name, "MusicAbility"); + OHOS::sptr nullToken = nullptr; auto res = abilityMs_->AbilityTransitionDone(nullToken, OHOS::AAFwk::AbilityState::ACTIVE); EXPECT_EQ(res, OHOS::ERR_INVALID_VALUE); @@ -611,37 +689,29 @@ HWTEST_F(AbilityManagerServiceTest, Interface_016, TestSize.Level1) EXPECT_EQ(abilityMs_->RemoveMission(100), REMOVE_MISSION_ID_NOT_EXIST); - auto topMissionId = abilityMs_->GetStackManager()->GetTopMissionRecord()->GetMissionRecordId(); - EXPECT_EQ(abilityMs_->RemoveMission(topMissionId), REMOVE_MISSION_LAUNCHER_DENIED); - GTEST_LOG_(INFO) << "topMissionId " << topMissionId; + auto luncherMissionId = abilityMs_->GetStackManager()->GetTopMissionRecord()->GetMissionRecordId(); + EXPECT_EQ(abilityMs_->RemoveMission(luncherMissionId), REMOVE_MISSION_LAUNCHER_DENIED); + GTEST_LOG_(INFO) << "luncherMissionId " << luncherMissionId; + abilityMs_->GetStackManager()->GetCurrentTopAbility()->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); + Want want; - want.AddEntity(Want::ENTITY_HOME); ElementName element("device", "com.ix.music", "MusicAbility"); want.SetElement(element); auto result = StartAbility(want); WaitUntilTaskFinished(); EXPECT_EQ(OHOS::ERR_OK, result); - topMissionId = abilityMs_->GetStackManager()->GetTopMissionRecord()->GetMissionRecordId(); + auto topMissionId = abilityMs_->GetStackManager()->GetTopMissionRecord()->GetMissionRecordId(); GTEST_LOG_(INFO) << "topMissionId " << topMissionId; EXPECT_FALSE(abilityMs_->GetStackManager()->IsLauncherMission(topMissionId)); - EXPECT_EQ(abilityMs_->RemoveMission(topMissionId), ERR_OK); - auto musicAbility = abilityMs_->GetStackManager()->GetCurrentTopAbility(); - musicAbility->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); + //remove current music mission EXPECT_EQ(abilityMs_->RemoveMission(topMissionId), ERR_OK); auto result1 = StartAbility(launcherWant); WaitUntilTaskFinished(); EXPECT_EQ(OHOS::ERR_OK, result1); - - EXPECT_EQ(musicAbility->GetAbilityState(), OHOS::AAFwk::AbilityState::INACTIVATING); - EXPECT_NE(topMissionId, abilityMs_->GetStackManager()->GetTopMissionRecord()->GetMissionRecordId()); - musicAbility->SetAbilityState(OHOS::AAFwk::AbilityState::MOVING_BACKGROUND); - - EXPECT_EQ(abilityMs_->RemoveMission(topMissionId), 0); - WaitUntilTaskFinished(); } /* @@ -659,14 +729,8 @@ HWTEST_F(AbilityManagerServiceTest, Interface_017, TestSize.Level1) wantLuncher.SetElement(elementLun); abilityMs_->StartAbility(wantLuncher); WaitUntilTaskFinished(); - auto launcherWant = abilityMs_->GetStackManager()->GetTopMissionRecord()->GetTopAbilityRecord()->GetWant(); - - auto topMissionId = abilityMs_->GetStackManager()->GetTopMissionRecord()->GetMissionRecordId(); - EXPECT_EQ(abilityMs_->RemoveMission(topMissionId), REMOVE_MISSION_LAUNCHER_DENIED); - GTEST_LOG_(INFO) << "topMissionId " << topMissionId; - abilityMs_->GetStackManager()->GetCurrentTopAbility()->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); + Want want; - want.AddEntity(Want::ENTITY_HOME); ElementName element("device", "com.ix.music", "MusicAbility"); want.SetElement(element); auto result = StartAbility(want); @@ -676,15 +740,13 @@ HWTEST_F(AbilityManagerServiceTest, Interface_017, TestSize.Level1) auto topAbility = abilityMs_->GetStackManager()->GetCurrentTopAbility(); abilityMs_->AddWindowInfo(topAbility->GetToken(), ++g_windowToken); topAbility->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); - topMissionId = abilityMs_->GetStackManager()->GetTopMissionRecord()->GetMissionRecordId(); + auto topMissionId = abilityMs_->GetStackManager()->GetTopMissionRecord()->GetMissionRecordId(); - auto result1 = abilityMs_->StartAbility(launcherWant); + // return to luncher + auto result1 = StartAbility(wantLuncher); WaitUntilTaskFinished(); EXPECT_EQ(OHOS::ERR_OK, result1); - topAbility->GetWindowInfo()->isVisible_ = true; - topAbility->SetAbilityState(OHOS::AAFwk::AbilityState::INACTIVE); - EXPECT_EQ(abilityMs_->RemoveMission(topMissionId), OHOS::ERR_OK); WaitUntilTaskFinished(); } @@ -755,7 +817,7 @@ HWTEST_F(AbilityManagerServiceTest, Interface_018, TestSize.Level1) HWTEST_F(AbilityManagerServiceTest, Interface_019, TestSize.Level1) { EXPECT_EQ(abilityMs_->RemoveStack(-1), OHOS::ERR_INVALID_VALUE); - EXPECT_EQ(abilityMs_->RemoveStack(INT_MAX), ERR_INVALID_VALUE); + EXPECT_EQ(abilityMs_->RemoveStack(INT_MAX), REMOVE_STACK_ID_NOT_EXIST); EXPECT_EQ(abilityMs_->RemoveStack(0), REMOVE_STACK_LAUNCHER_DENIED); } @@ -1281,7 +1343,7 @@ HWTEST_F(AbilityManagerServiceTest, AbilityManagerService_ReleaseDataAbility_001 { // assert ability record EXPECT_TRUE(abilityRecord_); - EXPECT_EQ(abilityMs_->ReleaseDataAbility(nullptr, nullptr), OHOS::ERR_INVALID_STATE); + EXPECT_EQ(abilityMs_->ReleaseDataAbility(nullptr, nullptr), OHOS::ERR_NULL_OBJECT); } /* @@ -1595,22 +1657,24 @@ HWTEST_F(AbilityManagerServiceTest, handleloadtimeout_001, TestSize.Level1) want.SetElement(elementbar); auto result = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, result); + auto stackManager = abilityMs_->systemAppManager_; auto barAbility = stackManager->GetCurrentTopAbility(); AbilityRecordInfo barAbilityInfo; barAbility->GetAbilityRecordInfo(barAbilityInfo); auto dialogtoken = barAbility->GetToken(); + OHOS::sptr scheduler = new AbilityScheduler(); EXPECT_EQ(abilityMs_->AttachAbilityThread(scheduler, dialogtoken), OHOS::ERR_OK); EXPECT_TRUE(barAbility->GetAbilityInfo().bundleName == AbilityConfig::SYSTEM_UI_BUNDLE_NAME); + abilityMs_->HandleLoadTimeOut(barAbility->GetEventId()); - WaitUntilTaskFinished(); + auto newStackManager = abilityMs_->systemAppManager_; auto newBarAbility = newStackManager->GetCurrentTopAbility(); - AbilityRecordInfo newAbilityInfo; - newBarAbility->GetAbilityRecordInfo(newAbilityInfo); - EXPECT_TRUE(newBarAbility->GetAbilityInfo().bundleName == AbilityConfig::SYSTEM_UI_BUNDLE_NAME); - EXPECT_NE(barAbilityInfo.id, newAbilityInfo.id); + + // Remove Ability Record + EXPECT_FALSE(newBarAbility); } /* @@ -1629,14 +1693,20 @@ HWTEST_F(AbilityManagerServiceTest, handleloadtimeout_002, TestSize.Level1) ElementName elementdialog("device", AbilityConfig::SYSTEM_UI_BUNDLE_NAME, AbilityConfig::SYSTEM_UI_NAVIGATION_BAR); want.SetElement(elementdialog); auto result = StartAbility(want); + WaitUntilTaskFinished(); EXPECT_EQ(OHOS::ERR_OK, result); + auto stackManager = abilityMs_->systemAppManager_; auto navigationAbility = stackManager->GetCurrentTopAbility(); auto dialogtoken = navigationAbility->GetToken(); + OHOS::sptr scheduler = new AbilityScheduler(); EXPECT_EQ(abilityMs_->AttachAbilityThread(scheduler, dialogtoken), OHOS::ERR_OK); EXPECT_TRUE(navigationAbility->GetAbilityInfo().bundleName == AbilityConfig::SYSTEM_UI_BUNDLE_NAME); + abilityMs_->HandleLoadTimeOut(navigationAbility->GetEventId()); + WaitUntilTaskFinishedByTimer(); + auto newStackManager = abilityMs_->systemAppManager_; auto newNavigationAbility = newStackManager->GetCurrentTopAbility(); EXPECT_TRUE(newNavigationAbility->GetAbilityInfo().bundleName == AbilityConfig::SYSTEM_UI_BUNDLE_NAME); @@ -1660,12 +1730,16 @@ HWTEST_F(AbilityManagerServiceTest, handleloadtimeout_003, TestSize.Level1) want.SetElement(elementbar); auto result = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, result); + auto stackManager = abilityMs_->systemAppManager_; auto barAbility = stackManager->GetCurrentTopAbility(); AbilityRecordInfo barAbilityInfo; barAbility->GetAbilityRecordInfo(barAbilityInfo); EXPECT_TRUE(barAbility->GetAbilityInfo().bundleName == AbilityConfig::SYSTEM_UI_BUNDLE_NAME); + abilityMs_->HandleLoadTimeOut(barAbility->GetEventId()); + WaitUntilTaskFinishedByTimer(); + auto newStackManager = abilityMs_->systemAppManager_; auto newBarAbility = newStackManager->GetCurrentTopAbility(); AbilityRecordInfo newAbilityInfo; @@ -1691,10 +1765,14 @@ HWTEST_F(AbilityManagerServiceTest, handleloadtimeout_004, TestSize.Level1) want.SetElement(elementbar); auto result = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, result); + auto stackManager = abilityMs_->systemAppManager_; auto navigationAbility = stackManager->GetCurrentTopAbility(); EXPECT_TRUE(navigationAbility->GetAbilityInfo().bundleName == AbilityConfig::SYSTEM_UI_BUNDLE_NAME); + abilityMs_->HandleLoadTimeOut(navigationAbility->GetEventId()); + WaitUntilTaskFinishedByTimer(); + auto newStackManager = abilityMs_->systemAppManager_; auto newNavigationAbility = newStackManager->GetCurrentTopAbility(); EXPECT_TRUE(newNavigationAbility->GetAbilityInfo().bundleName == AbilityConfig::SYSTEM_UI_BUNDLE_NAME); @@ -1718,12 +1796,14 @@ HWTEST_F(AbilityManagerServiceTest, handleloadtimeout_005, TestSize.Level1) want.SetElement(elementbar); auto result = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, result); + auto stackManager = abilityMs_->systemAppManager_; auto barAbility = stackManager->GetCurrentTopAbility(); auto bartoken = barAbility->GetToken(); OHOS::sptr scheduler = new AbilityScheduler(); EXPECT_EQ(abilityMs_->AttachAbilityThread(scheduler, bartoken), OHOS::ERR_OK); EXPECT_TRUE(barAbility->GetAbilityInfo().bundleName == AbilityConfig::SYSTEM_UI_BUNDLE_NAME); + auto newStackManager = abilityMs_->systemAppManager_; auto newBarAbility = newStackManager->GetCurrentTopAbility(); EXPECT_TRUE(newBarAbility->GetAbilityInfo().bundleName == AbilityConfig::SYSTEM_UI_BUNDLE_NAME); @@ -1747,12 +1827,15 @@ HWTEST_F(AbilityManagerServiceTest, handleloadtimeout_006, TestSize.Level1) want.SetElement(elementbar); auto result = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, result); + auto stackManager = abilityMs_->systemAppManager_; auto navigationAbility = stackManager->GetCurrentTopAbility(); auto navigationtoken = navigationAbility->GetToken(); OHOS::sptr scheduler = new AbilityScheduler(); + EXPECT_EQ(abilityMs_->AttachAbilityThread(scheduler, navigationtoken), OHOS::ERR_OK); EXPECT_TRUE(navigationAbility->GetAbilityInfo().bundleName == AbilityConfig::SYSTEM_UI_BUNDLE_NAME); + auto newStackManager = abilityMs_->systemAppManager_; auto newNavigationAbility = newStackManager->GetCurrentTopAbility(); EXPECT_TRUE(newNavigationAbility->GetAbilityInfo().bundleName == AbilityConfig::SYSTEM_UI_BUNDLE_NAME); @@ -1775,19 +1858,25 @@ HWTEST_F(AbilityManagerServiceTest, handleloadtimeout_007, TestSize.Level1) want.SetElement(element); auto result = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, result); + auto stackManager = abilityMs_->GetStackManager(); auto ability = stackManager->GetCurrentTopAbility(); auto abilityToken = ability->GetToken(); OHOS::sptr scheduler = new AbilityScheduler(); EXPECT_EQ(abilityMs_->AttachAbilityThread(scheduler, abilityToken), OHOS::ERR_OK); EXPECT_TRUE(ability->GetAbilityInfo().bundleName == "com.ix.hiMusic"); + ElementName elementTv("device", "com.ix.hiTv", "TvAbility"); want.SetElement(elementTv); auto resultTv = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, resultTv); + auto stackManagerTv = abilityMs_->GetStackManager(); auto abilityTv = stackManagerTv->GetCurrentTopAbility(); + abilityMs_->HandleLoadTimeOut(abilityTv->GetEventId()); + WaitUntilTaskFinishedByTimer(); + auto newStackManager = abilityMs_->GetStackManager(); auto newAbility = newStackManager->GetCurrentTopAbility(); EXPECT_TRUE(newAbility->GetAbilityInfo().bundleName == "com.ix.hiMusic"); @@ -1809,20 +1898,33 @@ HWTEST_F(AbilityManagerServiceTest, handleloadtimeout_008, TestSize.Level1) want.SetElement(element); auto result = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, result); + auto stackManager = abilityMs_->GetStackManager(); auto ability = stackManager->GetCurrentTopAbility(); auto abilityToken = ability->GetToken(); - OHOS::sptr scheduler = new AbilityScheduler(); - EXPECT_EQ(abilityMs_->AttachAbilityThread(scheduler, abilityToken), OHOS::ERR_OK); + EXPECT_TRUE(ability->GetAbilityInfo().bundleName == COM_IX_HIWORLD); + ElementName elementTv("device", "com.ix.hiTv", "TvAbility"); want.SetElement(elementTv); auto resultTv = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, resultTv); + + //helloAbility inactive + stackManager->CompleteInactive(ability); + auto stackManagerTv = abilityMs_->GetStackManager(); auto abilityTv = stackManagerTv->GetCurrentTopAbility(); + auto abilityTokenTv = abilityTv->GetToken(); + OHOS::sptr newScheduler = new AbilityScheduler(); + EXPECT_EQ(abilityMs_->AttachAbilityThread(newScheduler, abilityTokenTv), OHOS::ERR_OK); + abilityTv->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); + abilityMs_->HandleLoadTimeOut(abilityTv->GetEventId()); + WaitUntilTaskFinishedByTimer(); + auto newStackManager = abilityMs_->GetStackManager(); + EXPECT_TRUE(newStackManager); auto newAbility = newStackManager->GetCurrentTopAbility(); EXPECT_TRUE(newAbility->GetAbilityInfo().bundleName == COM_IX_HIWORLD); } @@ -1846,20 +1948,27 @@ HWTEST_F(AbilityManagerServiceTest, handleloadtimeout_009, TestSize.Level1) auto stackManager = abilityMs_->GetStackManager(); auto ability = stackManager->GetCurrentTopAbility(); auto abilityToken = ability->GetToken(); - OHOS::sptr scheduler = new AbilityScheduler(); - EXPECT_EQ(abilityMs_->AttachAbilityThread(scheduler, abilityToken), OHOS::ERR_OK); + EXPECT_TRUE(ability->GetAbilityInfo().bundleName == COM_IX_HIWORLD); + ElementName elementTv("device", "com.ix.hiTv", "TvAbility"); want.SetElement(elementTv); auto resultTv = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, resultTv); + + //helloAbility inactive + stackManager->CompleteInactive(ability); + auto stackManagerTv = abilityMs_->GetStackManager(); auto abilityTv = stackManagerTv->GetCurrentTopAbility(); auto abilityTokenTv = abilityTv->GetToken(); OHOS::sptr newScheduler = new AbilityScheduler(); EXPECT_EQ(abilityMs_->AttachAbilityThread(newScheduler, abilityTokenTv), OHOS::ERR_OK); - abilityTv->Activate(); + abilityTv->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); + abilityMs_->HandleLoadTimeOut(abilityTv->GetEventId()); + WaitUntilTaskFinishedByTimer(); + auto newStackManager = abilityMs_->GetStackManager(); auto newAbility = newStackManager->GetCurrentTopAbility(); EXPECT_TRUE(newAbility->GetAbilityInfo().bundleName != "com.ix.hiTv"); @@ -1881,23 +1990,30 @@ HWTEST_F(AbilityManagerServiceTest, handleloadtimeout_010, TestSize.Level1) want.SetElement(element); auto result = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, result); + auto stackManager = abilityMs_->GetStackManager(); auto ability = stackManager->GetCurrentTopAbility(); auto abilityToken = ability->GetToken(); - OHOS::sptr scheduler = new AbilityScheduler(); - EXPECT_EQ(abilityMs_->AttachAbilityThread(scheduler, abilityToken), OHOS::ERR_OK); EXPECT_TRUE(ability->GetAbilityInfo().bundleName == COM_IX_HIWORLD); + ElementName elementTv("device", "com.ix.hiTv", "TvAbility"); want.SetElement(elementTv); auto resultTv = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, resultTv); + + //helloAbility inactive + stackManager->CompleteInactive(ability); + auto stackManagerTv = abilityMs_->GetStackManager(); auto abilityTv = stackManagerTv->GetCurrentTopAbility(); auto abilityTokenTv = abilityTv->GetToken(); OHOS::sptr newScheduler = new AbilityScheduler(); EXPECT_EQ(abilityMs_->AttachAbilityThread(newScheduler, abilityTokenTv), OHOS::ERR_OK); - abilityTv->Inactivate(); + abilityTv->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); + abilityMs_->HandleLoadTimeOut(abilityTv->GetEventId()); + WaitUntilTaskFinishedByTimer(); + auto newStackManager = abilityMs_->GetStackManager(); auto newAbility = newStackManager->GetCurrentTopAbility(); EXPECT_TRUE(newAbility->GetAbilityInfo().bundleName != "com.ix.hiTv"); @@ -1919,19 +2035,25 @@ HWTEST_F(AbilityManagerServiceTest, handleloadtimeout_011, TestSize.Level1) want.SetElement(element); auto result = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, result); + auto stackManager = abilityMs_->GetStackManager(); auto ability = stackManager->GetCurrentTopAbility(); auto abilityToken = ability->GetToken(); - OHOS::sptr scheduler = new AbilityScheduler(); - EXPECT_EQ(abilityMs_->AttachAbilityThread(scheduler, abilityToken), OHOS::ERR_OK); EXPECT_TRUE(ability->GetAbilityInfo().bundleName == "com.ix.hiMusic"); + ElementName elementTv("device", "com.ix.hiTv", "TvAbility"); want.SetElement(elementTv); auto resultTv = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, resultTv); + + //helloAbility inactive + stackManager->DispatchInactive(ability, INACTIVE); + auto stackManagerTv = abilityMs_->GetStackManager(); auto abilityTv = stackManagerTv->GetCurrentTopAbility(); + abilityMs_->HandleLoadTimeOut(INT32_MAX); + auto newStackManager = abilityMs_->GetStackManager(); auto newAbility = newStackManager->GetCurrentTopAbility(); EXPECT_TRUE(newAbility->GetAbilityInfo().bundleName == "com.ix.hiTv"); @@ -1957,16 +2079,21 @@ HWTEST_F(AbilityManagerServiceTest, handleloadtimeout_012, TestSize.Level1) auto stackManager = abilityMs_->GetStackManager(); auto ability = stackManager->GetCurrentTopAbility(); auto abilityToken = ability->GetToken(); - OHOS::sptr scheduler = new AbilityScheduler(); - EXPECT_EQ(abilityMs_->AttachAbilityThread(scheduler, abilityToken), OHOS::ERR_OK); EXPECT_TRUE(ability->GetAbilityInfo().bundleName == "com.ix.hiMusic"); + ElementName elementTv("device", "com.ix.hiTv", "TvAbility"); want.SetElement(elementTv); auto resultTv = StartAbility(want); EXPECT_EQ(OHOS::ERR_OK, resultTv); + + //helloAbility inactive + stackManager->DispatchInactive(ability, INACTIVE); + auto stackManagerTv = abilityMs_->GetStackManager(); auto abilityTv = stackManagerTv->GetCurrentTopAbility(); + abilityMs_->HandleLoadTimeOut(INT32_MIN); + auto newStackManager = abilityMs_->GetStackManager(); auto newAbility = newStackManager->GetCurrentTopAbility(); EXPECT_TRUE(newAbility->GetAbilityInfo().bundleName == "com.ix.hiTv"); diff --git a/services/abilitymgr/test/unittest/phone/ability_stack_manager_test/ability_stack_manager_test.cpp b/services/abilitymgr/test/unittest/phone/ability_stack_manager_test/ability_stack_manager_test.cpp index e98da047dc680ee8598a4cc4c39be20a0f4415e5..75364e6c8b2c93338aa778e675d6f9e1266a1bbf 100644 --- a/services/abilitymgr/test/unittest/phone/ability_stack_manager_test/ability_stack_manager_test.cpp +++ b/services/abilitymgr/test/unittest/phone/ability_stack_manager_test/ability_stack_manager_test.cpp @@ -51,7 +51,7 @@ public: void SetUp(); void TearDown(); void init(); - + void OnStartabilityMs_(); AbilityRequest GenerateAbilityRequest(const std::string &deviceName, const std::string &abilityName, const std::string &appName, const std::string &bundleName, const std::vector config); @@ -63,12 +63,56 @@ public: AbilityRequest musicTopAbilityRequest_{}; AbilityRequest musicSAbilityRequest_{}; AbilityRequest radioAbilityRequest_{}; - AbilityRequest radioTopAbilityRequest_{}; + AbilityRequest radioTonAbilityRequest_{}; Want want_{}; AbilityInfo abilityInfo_{}; ApplicationInfo appInfo_{}; +public: + std::shared_ptr abilityMs_{nullptr}; }; +void AbilityStackManagerTest::OnStartabilityMs_() +{ + if(abilityMs_){ + + if(abilityMs_->state_ == ServiceRunningState::STATE_RUNNING) { + return; + } + + abilityMs_->state_ = ServiceRunningState::STATE_RUNNING; + + abilityMs_->eventLoop_ = AppExecFwk::EventRunner::Create(AbilityConfig::NAME_ABILITY_MGR_SERVICE); + EXPECT_TRUE(abilityMs_->eventLoop_); + + abilityMs_->handler_ = std::make_shared(abilityMs_->eventLoop_, abilityMs_); + EXPECT_TRUE(abilityMs_->handler_); + EXPECT_TRUE(abilityMs_->connectManager_); + + abilityMs_->connectManager_->SetEventHandler(abilityMs_->handler_); + + abilityMs_->dataAbilityManager_ = std::make_shared(); + EXPECT_TRUE(abilityMs_->dataAbilityManager_); + + abilityMs_->amsConfigResolver_ = std::make_shared(); + EXPECT_TRUE(abilityMs_->amsConfigResolver_); + abilityMs_->amsConfigResolver_->Parse(); + + abilityMs_->pendingWantManager_ = std::make_shared(); + EXPECT_TRUE(abilityMs_->pendingWantManager_); + + int userId = abilityMs_->GetUserId(); + abilityMs_->SetStackManager(userId); + abilityMs_->systemAppManager_ = std::make_shared(userId); + EXPECT_TRUE(abilityMs_->systemAppManager_); + + abilityMs_->eventLoop_->Run(); + + return; + } + + GTEST_LOG_(INFO) << "OnStart fail"; +} + void AbilityStackManagerTest::SetUpTestCase(void) { OHOS::DelayedSingleton::GetInstance()->RegisterSystemAbility( @@ -82,17 +126,17 @@ void AbilityStackManagerTest::TearDownTestCase(void) void AbilityStackManagerTest::SetUp() { init(); - - auto ams = DelayedSingleton::GetInstance(); - ams->Init(); + abilityMs_ = DelayedSingleton::GetInstance(); + OnStartabilityMs_(); stackManager_ = std::make_shared(0); - auto bms = ams->GetBundleManager(); + auto bms = abilityMs_->GetBundleManager(); EXPECT_NE(bms, nullptr); } void AbilityStackManagerTest::TearDown() { stackManager_.reset(); + abilityMs_->OnStop(); OHOS::DelayedSingleton::DestroyInstance(); } @@ -109,7 +153,7 @@ void AbilityStackManagerTest::init() radioAbilityRequest_ = GenerateAbilityRequest("device", "RadioAbility", "radio", "com.ix.hiRadio", config); - radioTopAbilityRequest_ = GenerateAbilityRequest("device", "RadioTopAbility", "radio", "com.ix.hiRadio", config); + radioTonAbilityRequest_ = GenerateAbilityRequest("device", "RadioTonAbility", "radio", "com.ix.hiRadio", config); } void AbilityStackManagerTest::makeScene( @@ -147,7 +191,7 @@ void AbilityStackManagerTest::makeScene( if (abilityName == "RadioAbility") { abilityInfo.launchMode = LaunchMode::STANDARD; } - if (abilityName == "RadioTopAbility") { + if (abilityName == "RadioTonAbility") { abilityInfo.launchMode = LaunchMode::SINGLETON; } } @@ -1457,9 +1501,10 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_042, TestSize. stackManager_->UninstallApp("com.ix.hiMusic"); // process died - stackManager_->OnAbilityDied(secondTopAbility); stackManager_->OnAbilityDied(thirdTopAbility); + auto topAbility = stackManager_->GetCurrentTopAbility(); + EXPECT_TRUE(topAbility); EXPECT_EQ("MusicAbility", topAbility->GetAbilityInfo().name); int size = stackManager_->defaultMissionStack_->GetMissionRecordCount(); // handle is nullptr, not delete @@ -1565,7 +1610,7 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_045, TestSize. EXPECT_EQ(ERR_INVALID_VALUE, result); result = stackManager_->RemoveStack(10); - EXPECT_EQ(ERR_INVALID_VALUE, result); + EXPECT_EQ(REMOVE_STACK_ID_NOT_EXIST, result); result = stackManager_->RemoveStack(0); EXPECT_EQ(REMOVE_STACK_LAUNCHER_DENIED, result); @@ -2176,7 +2221,7 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_061, TestSize. // promary mission id abilityStartSetting->AddProperty( - AbilityStartSetting::WINDOW_MODE_KEY, std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY)); + AbilityStartSetting::WINDOW_MODE_KEY, std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING)); EXPECT_TRUE(abilityStartSetting); musicAbilityRequest_.startSetting = abilityStartSetting; @@ -2190,7 +2235,7 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_061, TestSize. stact = stackManager_->GetCurrentMissionStack(); EXPECT_TRUE(stact); - EXPECT_EQ(stact->GetMissionStackId(), SPLIT_SCREEN_MISSION_STACK_ID); + EXPECT_EQ(stact->GetMissionStackId(), FLOATING_MISSION_STACK_ID); } /* @@ -2342,7 +2387,7 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_065, TestSize. stackManager_->Init(); // singlton ability - auto result = stackManager_->StartAbility(radioTopAbilityRequest_); + auto result = stackManager_->StartAbility(radioTonAbilityRequest_); EXPECT_EQ(0, result); auto redioMissionRecord = stackManager_->GetTopMissionRecord(); auto redioAbilityRecord = redioMissionRecord->GetTopAbilityRecord(); @@ -2386,7 +2431,7 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_066, TestSize. { stackManager_->Init(); - auto result = stackManager_->StartAbility(radioTopAbilityRequest_); + auto result = stackManager_->StartAbility(radioTonAbilityRequest_); EXPECT_EQ(0, result); auto redioMissionRecord = stackManager_->GetTopMissionRecord(); auto redioAbilityRecord = redioMissionRecord->GetTopAbilityRecord(); @@ -2441,6 +2486,7 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_067, TestSize. MissionOption missionOption; missionOption.missionId = musicMissionRecord->GetMissionRecordId(); missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING; + auto ref = stackManager_->MoveMissionToFloatingStack(missionOption); EXPECT_EQ(ref, ERR_NONE); @@ -2471,6 +2517,7 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_068, TestSize. MissionOption missionOption; missionOption.missionId = launcherMissionRecord->GetMissionRecordId(); missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING; + auto ref = stackManager_->MoveMissionToFloatingStack(missionOption); EXPECT_EQ(ref, MOVE_MISSION_TO_STACK_NOT_SUPPORT_MULTI_WIN); @@ -2569,7 +2616,7 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_071, TestSize. { stackManager_->Init(); - auto result = stackManager_->StartAbility(radioTopAbilityRequest_); + auto result = stackManager_->StartAbility(radioTonAbilityRequest_); EXPECT_EQ(0, result); auto redioMissionRecord = stackManager_->GetTopMissionRecord(); auto redioAbilityRecord = redioMissionRecord->GetTopAbilityRecord(); @@ -2580,24 +2627,30 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_071, TestSize. MissionOption missionOption; missionOption.missionId = -10; - auto ref = stackManager_->MoveMissionToSplitScreenStack(missionOption); + MissionOption missionOptionOther; + missionOptionOther.missionId = -11; + + auto ref = stackManager_->MoveMissionToSplitScreenStack(missionOption, missionOptionOther); EXPECT_EQ(ref, ERR_INVALID_DATA); missionOption.missionId = 13; missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FULLSCREEN; - ref = stackManager_->MoveMissionToSplitScreenStack(missionOption); + + missionOptionOther.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FULLSCREEN; + ref = stackManager_->MoveMissionToSplitScreenStack(missionOption, missionOptionOther); EXPECT_EQ(ref, ERR_INVALID_DATA); missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY; - ref = stackManager_->MoveMissionToSplitScreenStack(missionOption); + missionOptionOther.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY; + ref = stackManager_->MoveMissionToSplitScreenStack(missionOption, missionOptionOther); EXPECT_EQ(ref, MOVE_MISSION_TO_STACK_NOT_EXIST_MISSION); missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY; - ref = stackManager_->MoveMissionToSplitScreenStack(missionOption); + ref = stackManager_->MoveMissionToSplitScreenStack(missionOption, missionOptionOther); EXPECT_EQ(ref, MOVE_MISSION_TO_STACK_NOT_EXIST_MISSION); missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING; - ref = stackManager_->MoveMissionToSplitScreenStack(missionOption); + ref = stackManager_->MoveMissionToSplitScreenStack(missionOption, missionOptionOther); EXPECT_EQ(ref, ERR_INVALID_DATA); } @@ -2621,10 +2674,22 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_072, TestSize. EXPECT_TRUE(musicAbilityRecord); musicAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + result = stackManager_->StartAbility(radioTonAbilityRequest_); + EXPECT_EQ(0, result); + auto radioMissionRecord = stackManager_->GetTopMissionRecord(); + auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); + EXPECT_TRUE(musicMissionRecord); + EXPECT_TRUE(musicAbilityRecord); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + MissionOption missionOption; missionOption.missionId = musicMissionRecord->GetMissionRecordId(); missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY; - auto ref = stackManager_->MoveMissionToSplitScreenStack(missionOption); + + MissionOption radioMissionOption; + radioMissionOption.missionId = radioMissionRecord->GetMissionRecordId(); + radioMissionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY; + auto ref = stackManager_->MoveMissionToSplitScreenStack(missionOption, radioMissionOption); EXPECT_EQ(ref, ERR_NONE); auto stack = musicMissionRecord->GetMissionStack(); @@ -2651,10 +2716,22 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_073, TestSize. EXPECT_TRUE(launcherAbilityRecord); launcherAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto musicMissionRecord = stackManager_->GetTopMissionRecord(); + auto musicAbilityRecord = musicMissionRecord->GetTopAbilityRecord(); + EXPECT_TRUE(musicMissionRecord); + EXPECT_TRUE(musicAbilityRecord); + musicAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + MissionOption missionOption; - missionOption.missionId = launcherMissionRecord->GetMissionRecordId(); - missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY; - auto ref = stackManager_->MoveMissionToSplitScreenStack(missionOption); + missionOption.missionId = musicMissionRecord->GetMissionRecordId(); + missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY; + + MissionOption launcherMissionOption; + launcherMissionOption.missionId = launcherMissionRecord->GetMissionRecordId(); + launcherMissionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY; + auto ref = stackManager_->MoveMissionToSplitScreenStack(missionOption, launcherMissionOption); EXPECT_EQ(ref, MOVE_MISSION_TO_STACK_NOT_SUPPORT_MULTI_WIN); auto stack = launcherMissionRecord->GetMissionStack(); @@ -2671,24 +2748,24 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_073, TestSize. */ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_074, TestSize.Level1) { - stackManager_->Init(); - - auto result = stackManager_->StartAbility(launcherAbilityRequest_); - EXPECT_EQ(0, result); - auto launcherMissionRecord = stackManager_->GetTopMissionRecord(); - auto launcherAbilityRecord = launcherMissionRecord->GetTopAbilityRecord(); - EXPECT_TRUE(launcherMissionRecord); - EXPECT_TRUE(launcherAbilityRecord); - launcherAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); - - MissionOption missionOption; - missionOption.missionId = launcherMissionRecord->GetMissionRecordId(); - missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY; - auto ref = stackManager_->MoveMissionToSplitScreenStack(missionOption); - EXPECT_EQ(ref, MOVE_MISSION_TO_STACK_NOT_SUPPORT_MULTI_WIN); - - auto stack = launcherMissionRecord->GetMissionStack(); - EXPECT_EQ(stack->GetMissionStackId(), LAUNCHER_MISSION_STACK_ID); + // stackManager_->Init(); + + // auto result = stackManager_->StartAbility(launcherAbilityRequest_); + // EXPECT_EQ(0, result); + // auto launcherMissionRecord = stackManager_->GetTopMissionRecord(); + // auto launcherAbilityRecord = launcherMissionRecord->GetTopAbilityRecord(); + // EXPECT_TRUE(launcherMissionRecord); + // EXPECT_TRUE(launcherAbilityRecord); + // launcherAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + // MissionOption missionOption; + // missionOption.missionId = launcherMissionRecord->GetMissionRecordId(); + // missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY; + // auto ref = stackManager_->MoveMissionToSplitScreenStack(missionOption); + // EXPECT_EQ(ref, MOVE_MISSION_TO_STACK_NOT_SUPPORT_MULTI_WIN); + + // auto stack = launcherMissionRecord->GetMissionStack(); + // EXPECT_EQ(stack->GetMissionStackId(), LAUNCHER_MISSION_STACK_ID); } /* @@ -2793,7 +2870,7 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_077, TestSize. topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); // start top ability - result = stackManager_->StartAbility(radioTopAbilityRequest_); + result = stackManager_->StartAbility(radioTonAbilityRequest_); EXPECT_EQ(0, result); auto radioMissionRecord = stackManager_->GetTopMissionRecord(); auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); @@ -2986,8 +3063,8 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_081, TestSize. auto result = stackManager_->StartAbility(launcherAbilityRequest_); EXPECT_EQ(0, result); auto topMissionRecord = stackManager_->GetTopMissionRecord(); - auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); EXPECT_TRUE(topMissionRecord); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); EXPECT_TRUE(topAbilityRecord); topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); @@ -2996,7 +3073,6 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_081, TestSize. EXPECT_EQ(0, result); auto radioMissionRecord = stackManager_->GetTopMissionRecord(); auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); - EXPECT_TRUE(radioMissionRecord); EXPECT_TRUE(radioAbilityRecord); radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); @@ -3153,5 +3229,1634 @@ HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_086, TestSize. EXPECT_TRUE(abilityRecord); abilityRecord->SetAbilityState(AbilityState::ACTIVE); } + +/* + * Feature: AbilityStackManager + * Function: GenerateMissinOptionsOfSplitScreen + * SubFunction: NA + * FunctionPoints: creat splitscerenn mission option + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_087, TestSize.Level1) +{ + stackManager_->Init(); + + MissionOption primary; + primary.missionId = 0; + primary.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY; + MissionOption secondary = primary; + std::list options; + + auto ref = stackManager_->GenerateMissinOptionsOfSplitScreen(primary, secondary, options); + EXPECT_EQ(ERR_INVALID_DATA, ref); +} + +/* + * Feature: AbilityStackManager + * Function: GenerateMissinOptionsOfSplitScreen + * SubFunction: NA + * FunctionPoints: creat splitscerenn mission option + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_088, TestSize.Level1) +{ + stackManager_->Init(); + + // start top ability + auto result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto firstTopAbility = stackManager_->GetCurrentTopAbility(); + firstTopAbility->SetAbilityState(OHOS::AAFwk::ACTIVE); + auto radioMissionId = firstTopAbility->GetMissionRecord()->GetMissionRecordId(); + + result = stackManager_->StartAbility(musicSAbilityRequest_); + EXPECT_EQ(0, result); + auto musicAbility = stackManager_->GetCurrentTopAbility(); + musicAbility->SetAbilityState(OHOS::AAFwk::ACTIVE); + + MissionOption primary; + primary.missionId = radioMissionId; + primary.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY; + + MissionOption secondary; + std::list options; + + auto ref = stackManager_->GenerateMissinOptionsOfSplitScreen(primary, secondary, options); + EXPECT_EQ(ERR_OK, ref); + + int num = options.size(); + int optioNum = 2; + EXPECT_EQ(optioNum, num); +} + +/* + * Feature: AbilityStackManager + * Function: MoveMissionToSplitScreenStack + * SubFunction: NA + * FunctionPoints: Move full screen application to split screen stack + * EnvConditions: NA + * CaseDescription: try Can it move when locked + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_089, TestSize.Level1) +{ + stackManager_->Init(); + + // start top ability + auto result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto firstTopAbility = stackManager_->GetCurrentTopAbility(); + firstTopAbility->SetAbilityState(OHOS::AAFwk::ACTIVE); + auto radioMissionId = firstTopAbility->GetMissionRecord()->GetMissionRecordId(); + + result = stackManager_->StartLockMission(1000, radioMissionId, false, true); + EXPECT_EQ(ERR_OK, result); + + MissionOption primary; + primary.missionId = radioMissionId; + primary.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY; + + MissionOption secondary; + auto ref = stackManager_->MoveMissionToSplitScreenStack(primary, secondary); + EXPECT_EQ(ERR_INVALID_DATA, ref); + +} + +/* + * Feature: AbilityStackManager + * Function: EmplaceMissionToStack + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_090, TestSize.Level1) +{ + stackManager_->Init(); + + auto result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + EXPECT_TRUE(stackManager_->launcherMissionStack_); + auto luncherTopMission = stackManager_->launcherMissionStack_->GetTopMissionRecord(); + EXPECT_FALSE(luncherTopMission); + + stackManager_->EmplaceMissionToStack(topMissionRecord, stackManager_->launcherMissionStack_); + luncherTopMission = stackManager_->launcherMissionStack_->GetTopMissionRecord(); + EXPECT_TRUE(luncherTopMission); +} + +/* + * Feature: AbilityStackManager + * Function: UpdateMissionOption, GetFriendMissionBySplitScreen + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_091, TestSize.Level1) +{ + stackManager_->Init(); + auto result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto firstTopAbility = stackManager_->GetCurrentTopAbility(); + firstTopAbility->SetAbilityState(OHOS::AAFwk::ACTIVE); + + result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto musicAbility = stackManager_->GetCurrentTopAbility(); + musicAbility->SetAbilityState(OHOS::AAFwk::ACTIVE); + + //start split screen + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + // Set floating window identification + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY)); + EXPECT_TRUE(abilityStartSetting); + + musicSAbilityRequest_.startSetting = abilityStartSetting; + result = stackManager_->StartAbility(musicSAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto stack = stackManager_->GetCurrentMissionStack(); + EXPECT_TRUE(stack); + EXPECT_EQ(stack->GetMissionStackId(), SPLIT_SCREEN_MISSION_STACK_ID); + + //radio move to the split screen + auto radioStack = firstTopAbility->GetMissionRecord()->GetMissionStack(); + EXPECT_TRUE(radioStack); + EXPECT_EQ(radioStack->GetMissionStackId(), SPLIT_SCREEN_MISSION_STACK_ID); + + auto friendMission = stackManager_->GetFriendMissionBySplitScreen(stack, topMissionRecord->GetMissionRecordId()); + EXPECT_TRUE(friendMission); + EXPECT_TRUE(firstTopAbility->GetMissionRecord() == friendMission); + + EXPECT_TRUE(stackManager_->defaultMissionStack_); + stackManager_->UpdateMissionOption(friendMission, + stackManager_->defaultMissionStack_, AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FULLSCREEN); + + EXPECT_EQ(radioStack->GetMissionStackId(), SPLIT_SCREEN_MISSION_STACK_ID); +} + +/* + * Feature: AbilityStackManager + * Function: GetLatestSystemWindowMode + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_092, TestSize.Level1) +{ + stackManager_->Init(); + auto ref = stackManager_->GetLatestSystemWindowMode(); + EXPECT_EQ(ref, AAFwk::SystemWindowMode::DEFAULT_WINDOW_MODE); +} + +/* + * Feature: AbilityStackManager + * Function: GetLatestSystemWindowMode + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_093, TestSize.Level1) +{ + stackManager_->Init(); + + // start a ability + auto result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + EXPECT_TRUE(topMissionRecord); + EXPECT_TRUE(topAbilityRecord); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto stact = stackManager_->GetCurrentMissionStack(); + EXPECT_TRUE(stact); + EXPECT_EQ(stact->GetMissionStackId(), DEFAULT_MISSION_STACK_ID); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + + // Set floating window identification + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING)); + EXPECT_TRUE(abilityStartSetting); + + musicAbilityRequest_.startSetting = abilityStartSetting; + result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord2 = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord2 = topMissionRecord->GetTopAbilityRecord(); + EXPECT_TRUE(topMissionRecord2); + EXPECT_TRUE(topAbilityRecord2); + topAbilityRecord2->SetAbilityState(OHOS::AAFwk::ACTIVE); + + + auto ref = stackManager_->GetLatestSystemWindowMode(); + EXPECT_EQ(ref, AAFwk::SystemWindowMode::FLOATING_WINDOW_MODE); +} + +/* + * Feature: AbilityStackManager + * Function: GetLatestSystemWindowMode + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_094, TestSize.Level1) +{ + stackManager_->Init(); + stackManager_->curSysWindowMode_ = SystemWindowMode::SPLITSCREEN_WINDOW_MODE; + + std::string split = "split screen window mode"; + std::vector infos; + stackManager_->DumpWindowMode(infos); + + std::string::size_type index; + for(auto &mode : infos){ + index = mode.find(split); + EXPECT_TRUE(index != std::string::npos); + } +} + +/* + * Feature: AbilityStackManager + * Function: JudgingTargetSystemWindowMode + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_095, TestSize.Level1) +{ + EXPECT_EQ(SystemWindowMode::SPLITSCREEN_WINDOW_MODE, + stackManager_->JudgingTargetSystemWindowMode(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY)); + EXPECT_EQ(SystemWindowMode::SPLITSCREEN_WINDOW_MODE, + stackManager_->JudgingTargetSystemWindowMode(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY)); + EXPECT_EQ(SystemWindowMode::FLOATING_WINDOW_MODE, + stackManager_->JudgingTargetSystemWindowMode(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING)); +} + +/* + * Feature: AbilityStackManager + * Function: CheckSplitSrceenCondition + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_096, TestSize.Level1) +{ + stackManager_->Init(); + + // start a ability + auto result = stackManager_->StartAbility(launcherAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + EXPECT_TRUE(topMissionRecord); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + EXPECT_TRUE(topAbilityRecord); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto canMove = stackManager_->CheckSplitSrceenCondition(musicAbilityRequest_, topAbilityRecord); + EXPECT_FALSE(canMove); + + result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord2 = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord2 = topMissionRecord->GetTopAbilityRecord(); + topAbilityRecord2->SetAbilityState(OHOS::AAFwk::ACTIVE); + + //return false + canMove = stackManager_->CheckSplitSrceenCondition(musicAbilityRequest_, topAbilityRecord2); + EXPECT_FALSE(canMove); +} + +/* + * Feature: AbilityStackManager + * Function: CheckSplitSrceenCondition + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_097, TestSize.Level1) +{ + stackManager_->Init(); + + auto result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + //return true + auto canMove = stackManager_->CheckSplitSrceenCondition(radioAbilityRequest_, topAbilityRecord); + EXPECT_TRUE(canMove); + + //start singleton ability + result = stackManager_->StartAbility(musicSAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord2 = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord2 = topMissionRecord2->GetTopAbilityRecord(); + topAbilityRecord2->SetAbilityState(OHOS::AAFwk::ACTIVE); + + canMove = stackManager_->CheckSplitSrceenCondition(radioAbilityRequest_, topAbilityRecord2); + EXPECT_TRUE(canMove); +} + +/* + * Feature: AbilityStackManager + * Function: HandleAbilityDied + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_098, TestSize.Level1) +{ + stackManager_->Init(); + auto result = stackManager_->StartAbility(launcherAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + EXPECT_TRUE(topMissionRecord); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + EXPECT_TRUE(topAbilityRecord); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto musicMissionRecord = stackManager_->GetTopMissionRecord(); + auto musicAbilityRecord = musicMissionRecord->GetTopAbilityRecord(); + musicAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + //get setting + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY)); + EXPECT_TRUE(abilityStartSetting); + radioAbilityRequest_.startSetting = abilityStartSetting; + + result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto radioMissionRecord = stackManager_->GetTopMissionRecord(); + auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto topStack = stackManager_->GetTopMissionRecord()->GetMissionStack(); + EXPECT_TRUE(topStack); + EXPECT_EQ(topStack->GetMissionStackId(), SPLIT_SCREEN_MISSION_STACK_ID); + + stackManager_->HandleAbilityDied(radioAbilityRecord); + + topStack = stackManager_->GetTopMissionRecord()->GetMissionStack(); + EXPECT_TRUE(topStack); + EXPECT_EQ(topStack->GetMissionStackId(), SPLIT_SCREEN_MISSION_STACK_ID); +} + +/* + * Feature: AbilityStackManager + * Function: MakeTerminatingAbility + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_099, TestSize.Level1) +{ + auto musicAbilityRecord = AbilityRecord::CreateAbilityRecord(musicAbilityRequest_); + + TerminatingAbility unit{nullptr, -1, nullptr}; + stackManager_->MakeTerminatingAbility(unit, musicAbilityRecord, DEFAULT_INVAL_VALUE, nullptr); + EXPECT_EQ(unit.abilityRecord, musicAbilityRecord); +} + +/* + * Feature: AbilityStackManager + * Function: ConvertWindowModeState + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0100, TestSize.Level1) +{ + std::shared_ptr abilityRecord = nullptr; + auto str = stackManager_->ConvertWindowModeState(SystemWindowMode::DEFAULT_WINDOW_MODE); + EXPECT_EQ(str, "default window mode"); + str = stackManager_->ConvertWindowModeState(SystemWindowMode::SPLITSCREEN_WINDOW_MODE); + EXPECT_EQ(str, "split screen window mode"); + str = stackManager_->ConvertWindowModeState(SystemWindowMode::FLOATING_WINDOW_MODE); + EXPECT_EQ(str, "floating window mode"); + str = stackManager_->ConvertWindowModeState(SystemWindowMode::FLOATING_AND_SPLITSCREEN_WINDOW_MODE); + EXPECT_EQ(str, "floating and split screen window mode"); +} + +/* + * Feature: AbilityStackManager + * Function: SortPreMission + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0101, TestSize.Level1) +{ + auto mission = std::make_shared("test_one"); + auto nextMission = std::make_shared("test_two"); + + auto preMission = nextMission->GetPreMissionRecord(); + EXPECT_TRUE(nullptr == preMission); + + stackManager_->SortPreMission(mission, nextMission); + + preMission = nextMission->GetPreMissionRecord(); + EXPECT_TRUE(preMission); +} + +/* + * Feature: AbilityStackManager + * Function: GetRecordBySplitScreenMode + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0102, TestSize.Level1) +{ + stackManager_->Init(); + + auto result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + std::shared_ptr targetAbilityRecord(nullptr); + std::shared_ptr targetMissionRecord(nullptr); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY)); + EXPECT_TRUE(abilityStartSetting); + + musicAbilityRequest_.startSetting = abilityStartSetting; + + stackManager_->GetRecordBySplitScreenMode(musicAbilityRequest_, targetAbilityRecord, targetMissionRecord); + + EXPECT_TRUE(targetAbilityRecord); + EXPECT_TRUE(targetMissionRecord); + +} + +/* + * Feature: AbilityStackManager + * Function: GetRecordBySplitScreenMode + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0103, TestSize.Level1) +{ + stackManager_->Init(); + + //start sa ability + auto result = stackManager_->StartAbility(musicSAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + std::shared_ptr targetAbilityRecord(nullptr); + std::shared_ptr targetMissionRecord(nullptr); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY)); + EXPECT_TRUE(abilityStartSetting); + + musicSAbilityRequest_.startSetting = abilityStartSetting; + + stackManager_->GetRecordBySplitScreenMode(musicSAbilityRequest_, targetAbilityRecord, targetMissionRecord); + + EXPECT_TRUE(targetAbilityRecord); + EXPECT_TRUE(targetMissionRecord); + +} + +/* + * Feature: AbilityStackManager + * Function: CheckMultiWindowCondition + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0104, TestSize.Level1) +{ + stackManager_->Init(); + + auto result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + std::list missionOptions; + stackManager_->isMultiWinMoving_ = true; + auto ref = stackManager_->CheckMultiWindowCondition(missionOptions); + EXPECT_EQ(MOVE_MISSION_TO_STACK_MOVING_DENIED, ref); + + stackManager_->isMultiWinMoving_ = false; + ref = stackManager_->CheckMultiWindowCondition(missionOptions); + EXPECT_EQ(MOVE_MISSION_TO_STACK_OUT_OF_SIZE, ref); + + MissionOption mission; + mission.missionId = 77; + missionOptions.push_back(mission); + + ref = stackManager_->CheckMultiWindowCondition(missionOptions); + EXPECT_EQ(MOVE_MISSION_TO_STACK_NOT_EXIST_MISSION, ref); +} + +/* + * Feature: AbilityStackManager + * Function: CheckMultiWindowCondition + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0105, TestSize.Level1) +{ + stackManager_->Init(); + + auto result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + std::list missionOptions; + + MissionOption mission; + mission.missionId = topMissionRecord->GetMissionRecordId(); + mission.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY; + + missionOptions.push_back(mission); + auto ref = stackManager_->CheckMultiWindowCondition(missionOptions); + EXPECT_EQ(ERR_OK, ref); + +} + +/* + * Feature: AbilityStackManager + * Function: EmplaceMissionToStack + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0106, TestSize.Level1) +{ + stackManager_->Init(); + + auto result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY)); + EXPECT_TRUE(abilityStartSetting); + musicAbilityRequest_.startSetting = abilityStartSetting; + + auto targetStack = stackManager_->GetTargetMissionStack(musicAbilityRequest_); + EXPECT_TRUE(targetStack); + stackManager_->EmplaceMissionToStack(topMissionRecord, targetStack); + + auto topMission = targetStack->GetTopMissionRecord(); + EXPECT_TRUE(topMission); +} + +/* + * Feature: AbilityStackManager + * Function: SortRecentMissions + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0107, TestSize.Level1) +{ + stackManager_->Init(); + + //Start two singleton applications in the floating window stack + auto result = stackManager_->StartAbility(musicSAbilityRequest_); + EXPECT_EQ(0, result); + auto musicMissionRecord = stackManager_->GetTopMissionRecord(); + auto musicAbilityRecord = musicMissionRecord->GetTopAbilityRecord(); + musicAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + result = stackManager_->StartAbility(radioTonAbilityRequest_); + EXPECT_EQ(0, result); + auto radioMissionRecord = stackManager_->GetTopMissionRecord(); + auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + //Music application at the bottom of the stack + std::vector missionInfos; + for (auto &stack : stackManager_->missionStackList_) { + EXPECT_TRUE(stack); + stack->GetAllMissionInfo(missionInfos); + } + + auto frontMission = missionInfos.back(); + EXPECT_EQ(frontMission.id, musicMissionRecord->GetMissionRecordId()); + + //The value of who updates first is small + radioMissionRecord->UpdateActiveTimestamp(); + musicMissionRecord->UpdateActiveTimestamp(); + + stackManager_->SortRecentMissions(missionInfos); + + //The radio application is at the bottom of the stack + frontMission = missionInfos.front(); + EXPECT_EQ(frontMission.id, radioMissionRecord->GetMissionRecordId()); +} + +/* + * Feature: AbilityStackManager + * Function: SortAndGetLastActiveAbility + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0108, TestSize.Level1) +{ + auto musicAbilityRecord = AbilityRecord::CreateAbilityRecord(musicAbilityRequest_); + auto musicSaAbilityRecord = AbilityRecord::CreateAbilityRecord(musicSAbilityRequest_); + auto radioAbilityRecord = AbilityRecord::CreateAbilityRecord(radioAbilityRequest_); + + EXPECT_TRUE(musicAbilityRecord); + EXPECT_TRUE(musicSaAbilityRecord); + EXPECT_TRUE(radioAbilityRecord); + + musicAbilityRecord->SetAbilityState(OHOS::AAFwk::BACKGROUND); + musicSaAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::BACKGROUND); + + TerminatingAbility musicTerminateAbility; + musicTerminateAbility.abilityRecord = musicAbilityRecord; + + TerminatingAbility musicSaTerminateAbility; + musicSaTerminateAbility.abilityRecord = musicSaAbilityRecord; + + TerminatingAbility radioSaTerminateAbility; + radioSaTerminateAbility.abilityRecord = radioAbilityRecord; + + std::list terminateLists; + terminateLists.emplace_back(musicTerminateAbility); + terminateLists.emplace_back(musicSaTerminateAbility); + terminateLists.emplace_back(radioSaTerminateAbility); + + std::shared_ptr lastActiveAbility(nullptr); + + stackManager_->SortAndGetLastActiveAbility(terminateLists, lastActiveAbility); + EXPECT_TRUE(lastActiveAbility); + auto backAbility = terminateLists.back(); + EXPECT_TRUE(lastActiveAbility == backAbility.abilityRecord); +} + +/* + * Feature: AbilityStackManager + * Function: MakeTerminatingAbility + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0109, TestSize.Level1) +{ + auto musicAbilityRecord = AbilityRecord::CreateAbilityRecord(musicAbilityRequest_); + + TerminatingAbility unit{nullptr, -1, nullptr}; + stackManager_->MakeTerminatingAbility(unit, musicAbilityRecord, DEFAULT_INVAL_VALUE, nullptr); + EXPECT_EQ(unit.abilityRecord, musicAbilityRecord); +} + +/* + * Feature: AbilityStackManager + * Function: GetTargetChangeType + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0110, TestSize.Level1) +{ + stackManager_->Init(); + + int ACTIVE = 0; + // int CHANGE = 1; + int DEFAULT = 2; + + bool isMissionChanged{false}; + bool isStackChanged{false}; + bool isCurrentFull{false}; + bool isTargetFull{false}; + + std::shared_ptr needBackgroundAbility{nullptr}; + + //1 + auto ref = stackManager_->GetTargetChangeType(isMissionChanged, isStackChanged, isCurrentFull, isTargetFull, + nullptr, nullptr, needBackgroundAbility); + EXPECT_EQ(DEFAULT, ref); + + auto result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto radioMissionRecord = stackManager_->GetTopMissionRecord(); + auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY)); + EXPECT_TRUE(abilityStartSetting); + musicAbilityRequest_.startSetting = abilityStartSetting; + + auto targetAbility = AbilityRecord::CreateAbilityRecord(musicAbilityRequest_); + + //2 + isMissionChanged = true; + isStackChanged = true; + ref = stackManager_->GetTargetChangeType(isMissionChanged, isStackChanged, isCurrentFull, isTargetFull, + nullptr, targetAbility, needBackgroundAbility); + EXPECT_EQ(ACTIVE, ref); + EXPECT_FALSE(needBackgroundAbility); + + //3 + isMissionChanged = true; + isStackChanged = true; + isCurrentFull = true; + ref = stackManager_->GetTargetChangeType(isMissionChanged, isStackChanged, isCurrentFull, isTargetFull, + nullptr, targetAbility, needBackgroundAbility); + EXPECT_EQ(ACTIVE, ref); + EXPECT_FALSE(needBackgroundAbility); + +} + + +/* + * Feature: AbilityStackManager + * Function: OnTimeOut + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0111, TestSize.Level1) +{ + stackManager_->Init(); + auto result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + + auto topMisionRecord = stackManager_->GetTopMissionRecord(); + auto MisionRecordId = topMisionRecord->GetMissionRecordId(); + + auto topAbilityRecord = topMisionRecord->GetTopAbilityRecord(); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + topAbilityRecord->SetEventId(17); + + auto result1 = stackManager_->StartLockMission(1000, MisionRecordId, false, true); + EXPECT_EQ(ERR_OK, result1); + + auto lockState = stackManager_->GetMissionLockModeState(); + EXPECT_EQ((LockMissionContainer::LockMissionState)lockState, LockMissionContainer::LockMissionState::LOCK_MISSION_STATE_LOCKED); + + stackManager_->OnTimeOut(AbilityManagerService::ACTIVE_TIMEOUT_MSG, topAbilityRecord->GetEventId()); + + //EXPECT_NE((LockMissionContainer::LockMissionState)lockState, LockMissionContainer::LockMissionState::LOCK_MISSION_STATE_LOCKED); +} + +/* + * Feature: AbilityStackManager + * Function: TerminateAbilityLocked, RemoveTerminatingAbility + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0112, TestSize.Level1) +{ + stackManager_->Init(); + + stackManager_->StartAbility(launcherAbilityRequest_); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto launcherAbility = stackManager_->GetCurrentTopAbility(); + launcherAbility->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto musicMissionRecord = stackManager_->GetTopMissionRecord(); + auto musicAbilityRecord = musicMissionRecord->GetTopAbilityRecord(); + musicAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + result = stackManager_->StartAbility(radioTonAbilityRequest_); + EXPECT_EQ(0, result); + auto radioMissionRecord = stackManager_->GetTopMissionRecord(); + auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + //start split screen + MissionOption missionOption; + missionOption.missionId = musicMissionRecord->GetMissionRecordId(); + missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY; + + MissionOption radioMissionOption; + radioMissionOption.missionId = radioMissionRecord->GetMissionRecordId(); + radioMissionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY; + auto ref = stackManager_->MoveMissionToSplitScreenStack(missionOption, radioMissionOption); + EXPECT_EQ(ref, ERR_NONE); + + EXPECT_TRUE(musicAbilityRecord); + EXPECT_TRUE(radioAbilityRecord); + + musicAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + TerminatingAbility musicTerminateAbility; + musicTerminateAbility.abilityRecord = musicAbilityRecord; + + TerminatingAbility radioSaTerminateAbility; + radioSaTerminateAbility.abilityRecord = radioAbilityRecord; + + std::list terminateLists; + terminateLists.emplace_back(musicTerminateAbility); + terminateLists.emplace_back(radioSaTerminateAbility); + + stackManager_->TerminateAbilityLocked(terminateLists); + + int terminalNum = 2; + int size = terminateLists.size(); + EXPECT_EQ(terminalNum, size); + + //Supplement others +} + +/* + * Feature: AbilityStackManager + * Function: CompleteMoveMissionToStack + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0113, TestSize.Level1) +{ + stackManager_->Init(); + + auto result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto musicMissionRecord = stackManager_->GetTopMissionRecord(); + auto musicAbilityRecord = musicMissionRecord->GetTopAbilityRecord(); + musicAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto radioMissionRecord = stackManager_->GetTopMissionRecord(); + auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto currentStack = stackManager_->GetCurrentMissionStack(); + EXPECT_EQ(DEFAULT_MISSION_STACK_ID, currentStack->GetMissionStackId()); + + auto targetStack = stackManager_->GetOrCreateMissionStack(SPLIT_SCREEN_MISSION_STACK_ID, true); + EXPECT_TRUE(targetStack); + + stackManager_->CompleteMoveMissionToStack(radioMissionRecord, targetStack); + + currentStack = stackManager_->GetCurrentMissionStack(); + EXPECT_EQ(SPLIT_SCREEN_MISSION_STACK_ID, currentStack->GetMissionStackId()); +} + +/* + * Feature: AbilityStackManager + * Function: GetRecentMissionsLocked + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0114, TestSize.Level1) +{ + stackManager_->Init(); + + stackManager_->StartAbility(launcherAbilityRequest_); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto launcherAbility = stackManager_->GetCurrentTopAbility(); + launcherAbility->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto musicMissionRecord = stackManager_->GetTopMissionRecord(); + auto musicAbilityRecord = musicMissionRecord->GetTopAbilityRecord(); + musicAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto radioMissionRecord = stackManager_->GetTopMissionRecord(); + auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + +} + +/* + * Feature: AbilityStackManager + * Function: MoveMissionToEnd + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0115, TestSize.Level1) +{ + stackManager_->Init(); + + stackManager_->StartAbility(launcherAbilityRequest_); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto launcherAbility = stackManager_->GetCurrentTopAbility(); + launcherAbility->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto musicMissionRecord = stackManager_->GetTopMissionRecord(); + auto musicAbilityRecord = musicMissionRecord->GetTopAbilityRecord(); + musicAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + result = stackManager_->StartAbility(radioTonAbilityRequest_); + EXPECT_EQ(0, result); + auto radioMissionRecord = stackManager_->GetTopMissionRecord(); + auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + //start split screen + MissionOption missionOption; + missionOption.missionId = musicMissionRecord->GetMissionRecordId(); + missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY; + + MissionOption radioMissionOption; + radioMissionOption.missionId = radioMissionRecord->GetMissionRecordId(); + radioMissionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY; + auto ref = stackManager_->MoveMissionToSplitScreenStack(missionOption, radioMissionOption); + EXPECT_EQ(ref, ERR_NONE); + + stackManager_->isMultiWinMoving_ = false; + musicAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + auto moveref = stackManager_->MoveMissionToEnd(musicAbilityRecord->GetToken(), true); + EXPECT_EQ(moveref, ERR_NONE); + + EXPECT_TRUE(musicAbilityRecord->IsToEnd()); + auto currentStack = stackManager_->GetCurrentMissionStack(); + EXPECT_EQ(LAUNCHER_MISSION_STACK_ID, currentStack->GetMissionStackId()); +} + +/* + * Feature: AbilityStackManager + * Function: MoveMissionToEnd + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0116, TestSize.Level1) +{ + stackManager_->Init(); + + stackManager_->StartAbility(launcherAbilityRequest_); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto launcherAbility = stackManager_->GetCurrentTopAbility(); + launcherAbility->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto musicMissionRecord = stackManager_->GetTopMissionRecord(); + auto musicAbilityRecord = musicMissionRecord->GetTopAbilityRecord(); + musicAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + result = stackManager_->StartAbility(radioTonAbilityRequest_); + EXPECT_EQ(0, result); + auto radioMissionRecord = stackManager_->GetTopMissionRecord(); + auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + //start split screen + MissionOption missionOption; + missionOption.missionId = musicMissionRecord->GetMissionRecordId(); + missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY; + + MissionOption radioMissionOption; + radioMissionOption.missionId = radioMissionRecord->GetMissionRecordId(); + radioMissionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY; + auto ref = stackManager_->MoveMissionToSplitScreenStack(missionOption, radioMissionOption); + EXPECT_EQ(ref, ERR_NONE); + + stackManager_->isMultiWinMoving_ = false; + auto moveref = stackManager_->MoveMissionToEnd(radioAbilityRecord->GetToken(), true); + EXPECT_EQ(moveref, ERR_NONE); + + EXPECT_TRUE(radioAbilityRecord->IsToEnd()); + auto currentStack = stackManager_->GetCurrentMissionStack(); + EXPECT_EQ(LAUNCHER_MISSION_STACK_ID, currentStack->GetMissionStackId()); +} + +/* + * Feature: AbilityStackManager + * Function: DispatchLifecycle + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0117, TestSize.Level1) +{ + stackManager_->Init(); + + auto result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto musicTopAbility = stackManager_->GetCurrentTopAbility(); + musicTopAbility->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY)); + EXPECT_TRUE(abilityStartSetting); + radioAbilityRequest_.startSetting = abilityStartSetting; + + + result = stackManager_->StartAbility(radioTonAbilityRequest_); + EXPECT_EQ(0, result); + auto radioAbility = stackManager_->GetCurrentTopAbility(); + EXPECT_TRUE(radioAbility); + + musicTopAbility->SetAbilityState(OHOS::AAFwk::BACKGROUND); + auto ref = stackManager_->DispatchLifecycle(musicTopAbility, radioAbility, false); + EXPECT_EQ(ERR_OK, ref); + + // EXPECT_EQ(musicTopAbility->GetInMovingState(), true); +} + +/* + * Feature: AbilityStackManager + * Function: DispatchLifecycle + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0118, TestSize.Level1) +{ + stackManager_->Init(); + + auto result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto musicTopAbility = stackManager_->GetCurrentTopAbility(); + musicTopAbility->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY)); + EXPECT_TRUE(abilityStartSetting); + radioTonAbilityRequest_.startSetting = abilityStartSetting; + + result = stackManager_->StartAbility(radioTonAbilityRequest_); + EXPECT_EQ(0, result); + auto radioAbility = stackManager_->GetCurrentTopAbility(); + EXPECT_TRUE(radioAbility); + + musicTopAbility->SetAbilityState(OHOS::AAFwk::BACKGROUND); + auto ref = stackManager_->DispatchLifecycle(musicTopAbility, radioAbility, false); + EXPECT_EQ(ERR_OK, ref); + + EXPECT_TRUE(musicTopAbility->GetInMovingState()); +} + +/* + * Feature: AbilityStackManager + * Function: GetRecentMissionsLocked + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0119, TestSize.Level1) +{ + stackManager_->Init(); + + stackManager_->StartAbility(launcherAbilityRequest_); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto launcherAbility = stackManager_->GetCurrentTopAbility(); + launcherAbility->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); + auto musicMissionRecord = stackManager_->GetTopMissionRecord(); + auto musicAbilityRecord = musicMissionRecord->GetTopAbilityRecord(); + musicAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + result = stackManager_->StartAbility(radioTonAbilityRequest_); + EXPECT_EQ(0, result); + auto radioMissionRecord = stackManager_->GetTopMissionRecord(); + auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + //start split screen + MissionOption missionOption; + missionOption.missionId = musicMissionRecord->GetMissionRecordId(); + missionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY; + + MissionOption radioMissionOption; + radioMissionOption.missionId = radioMissionRecord->GetMissionRecordId(); + radioMissionOption.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_SECONDARY; + auto ref = stackManager_->MoveMissionToSplitScreenStack(missionOption, radioMissionOption); + EXPECT_EQ(ref, ERR_NONE); + + stackManager_->isMultiWinMoving_ = false; + musicAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + auto moveref = stackManager_->MoveMissionToEnd(musicAbilityRecord->GetToken(), true); + EXPECT_EQ(moveref, ERR_NONE); + + EXPECT_TRUE(musicAbilityRecord->IsToEnd()); + auto currentStack = stackManager_->GetCurrentMissionStack(); + EXPECT_EQ(LAUNCHER_MISSION_STACK_ID, currentStack->GetMissionStackId()); + + //get recent list + std::vector recentList; + int getMaxNum = 1; + int flag = RECENT_WITH_EXCLUDED; + stackManager_->GetRecentMissionsLocked(getMaxNum, flag, recentList); + + int size = recentList.size(); + EXPECT_EQ(size, 1); +} + +/* + * Feature: AbilityStackManager + * Function: GetMissionRecordAndAbilityRecord + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0120, TestSize.Level1) +{ + stackManager_->Init(); + + auto result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + std::shared_ptr targetAbilityRecord(nullptr); + std::shared_ptr targetMissionRecord(nullptr); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY)); + EXPECT_TRUE(abilityStartSetting); + + musicAbilityRequest_.startSetting = abilityStartSetting; + + stackManager_->GetMissionRecordAndAbilityRecord(musicAbilityRequest_, topAbilityRecord, targetAbilityRecord, targetMissionRecord); + + EXPECT_TRUE(targetAbilityRecord); + EXPECT_TRUE(targetMissionRecord); +} + +/* + * Feature: AbilityStackManager + * Function: GetMissionRecordAndAbilityRecord + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0121, TestSize.Level1) +{ + stackManager_->Init(); + + auto result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + std::shared_ptr targetAbilityRecord(nullptr); + std::shared_ptr targetMissionRecord(nullptr); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY)); + EXPECT_TRUE(abilityStartSetting); + + musicAbilityRequest_.startSetting = abilityStartSetting; + + stackManager_->GetMissionRecordAndAbilityRecord(musicAbilityRequest_, topAbilityRecord, targetAbilityRecord, targetMissionRecord); + + EXPECT_TRUE(targetAbilityRecord); + EXPECT_TRUE(targetMissionRecord); +} + +/* + * Feature: AbilityStackManager + * Function: GetTargetMissionStackBySetting + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0122, TestSize.Level1) +{ + stackManager_->Init(); + + auto stack = stackManager_->GetTargetMissionStackBySetting(musicAbilityRequest_); + EXPECT_TRUE(stackManager_->defaultMissionStack_ == stack); + EXPECT_EQ(stack->GetMissionStackId(), DEFAULT_MISSION_STACK_ID); +} + +/* + * Feature: AbilityStackManager + * Function: GetTargetMissionStackBySetting + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0123, TestSize.Level1) +{ + stackManager_->Init(); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY)); + EXPECT_TRUE(abilityStartSetting); + musicAbilityRequest_.startSetting = abilityStartSetting; + + auto stack = stackManager_->GetTargetMissionStackBySetting(musicAbilityRequest_); + EXPECT_TRUE(stack); + + EXPECT_EQ(stack->GetMissionStackId(), SPLIT_SCREEN_MISSION_STACK_ID); +} + +/* + * Feature: AbilityStackManager + * Function: GetTargetMissionStackBySetting + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0124, TestSize.Level1) +{ + stackManager_->Init(); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING)); + EXPECT_TRUE(abilityStartSetting); + musicAbilityRequest_.startSetting = abilityStartSetting; + + auto stack = stackManager_->GetTargetMissionStackBySetting(musicAbilityRequest_); + EXPECT_TRUE(stack); + + EXPECT_EQ(stack->GetMissionStackId(), FLOATING_MISSION_STACK_ID); +} + +/* + * Feature: AbilityStackManager + * Function: MoveMissionAndAbility + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0125, TestSize.Level1) +{ + stackManager_->Init(); + + auto currentAbility = AbilityRecord::CreateAbilityRecord(musicAbilityRequest_); + auto targetAbility = AbilityRecord::CreateAbilityRecord(radioAbilityRequest_); + auto targetMissionRecord = std::make_shared("test"); + + MissionOption option; + option.missionId = 2; + option.winModeKey = AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_PRIMARY; + targetMissionRecord->SetMissionOption(option); + + stackManager_->MoveMissionAndAbility(currentAbility, targetAbility, targetMissionRecord); + + auto ability = targetMissionRecord->GetTopAbilityRecord(); + EXPECT_TRUE(ability); + + EXPECT_TRUE(ability == targetAbility); + EXPECT_TRUE(currentAbility == targetAbility->GetPreAbilityRecord()); +} + +/* + * Feature: AbilityStackManager + * Function: StartAbilityAsSpecialLocked + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0126, TestSize.Level1) +{ + stackManager_->Init(); + + // start a luncher + auto result = stackManager_->StartAbility(launcherAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + EXPECT_TRUE(topMissionRecord); + EXPECT_TRUE(topAbilityRecord); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto stact = stackManager_->GetCurrentMissionStack(); + EXPECT_TRUE(stact); + EXPECT_EQ(stact->GetMissionStackId(), LAUNCHER_MISSION_STACK_ID); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + // Set floating window identification + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING)); + EXPECT_TRUE(abilityStartSetting); + musicAbilityRequest_.startSetting = abilityStartSetting; + + result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); +} + +/* + * Feature: AbilityStackManager + * Function: StartAbility, StartAbilityAsSpecialLocked + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0127, TestSize.Level1) +{ + stackManager_->Init(); + + // start a luncher + auto result = stackManager_->StartAbility(launcherAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + EXPECT_TRUE(topMissionRecord); + EXPECT_TRUE(topAbilityRecord); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto radioMissionRecord = stackManager_->GetTopMissionRecord(); + auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + // Set floating window identification + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING)); + EXPECT_TRUE(abilityStartSetting); + musicAbilityRequest_.startSetting = abilityStartSetting; + + result = stackManager_->StartAbility(musicAbilityRequest_); + EXPECT_EQ(0, result); +} + +/* + * Feature: AbilityStackManager + * Function: StartAbility, StartAbilityLifeCycle + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0128, TestSize.Level1) +{ + stackManager_->Init(); + + // start a luncher + auto result = stackManager_->StartAbility(launcherAbilityRequest_); + EXPECT_EQ(0, result); + auto topMissionRecord = stackManager_->GetTopMissionRecord(); + EXPECT_TRUE(topMissionRecord); + auto topAbilityRecord = topMissionRecord->GetTopAbilityRecord(); + EXPECT_TRUE(topAbilityRecord); + topAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + result = stackManager_->StartAbility(radioAbilityRequest_); + EXPECT_EQ(0, result); + auto radioMissionRecord = stackManager_->GetTopMissionRecord(); + auto radioAbilityRecord = radioMissionRecord->GetTopAbilityRecord(); + radioAbilityRecord->SetAbilityState(OHOS::AAFwk::ACTIVE); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + // Set floating window identification + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING)); + EXPECT_TRUE(abilityStartSetting); + musicAbilityRequest_.startSetting = abilityStartSetting; + + std::shared_ptr targetAbilityRecord; + std::shared_ptr targetMissionRecord; + + stackManager_->GetMissionRecordAndAbilityRecord(musicAbilityRequest_, radioAbilityRecord, targetAbilityRecord, + targetMissionRecord); + EXPECT_TRUE(targetAbilityRecord); + EXPECT_TRUE(targetMissionRecord); + + auto lifeCycleRef = stackManager_->StartAbilityLifeCycle(nullptr, radioAbilityRecord, targetAbilityRecord); + EXPECT_EQ(0, lifeCycleRef); +} + +/* + * Feature: AbilityStackManager + * Function: CompleteActive + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0129, TestSize.Level1) +{ + stackManager_->Init(); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + // Set floating window identification + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING)); + EXPECT_TRUE(abilityStartSetting); + musicAbilityRequest_.startSetting = abilityStartSetting; + + auto ability = AbilityRecord::CreateAbilityRecord(musicAbilityRequest_); + EXPECT_TRUE(ability); + + ability->SetMovingBackgroundFlag(true); + + stackManager_->CompleteActive(ability); + EXPECT_EQ(ability->GetAbilityState(), AbilityState::ACTIVE); +} + +/* + * Feature: AbilityStackManager + * Function: CompleteInactive + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0130, TestSize.Level1) +{ + stackManager_->Init(); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + // Set floating window identification + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING)); + EXPECT_TRUE(abilityStartSetting); + musicAbilityRequest_.startSetting = abilityStartSetting; + + auto ability = AbilityRecord::CreateAbilityRecord(musicAbilityRequest_); + EXPECT_TRUE(ability); + + ability->SetMovingBackgroundFlag(true); + + stackManager_->CompleteInactive(ability); + + EXPECT_EQ(ability->GetAbilityState(), AbilityState::MOVING_BACKGROUND); +} + + +/* + * Feature: AbilityStackManager + * Function: CompleteBackground + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0131, TestSize.Level1) +{ + stackManager_->Init(); + + auto abilityStartSetting = AbilityStartSetting::GetEmptySetting(); + // Set floating window identification + abilityStartSetting->AddProperty(AbilityStartSetting::WINDOW_MODE_KEY, + std::to_string(AbilityWindowConfiguration::MULTI_WINDOW_DISPLAY_FLOATING)); + EXPECT_TRUE(abilityStartSetting); + musicAbilityRequest_.startSetting = abilityStartSetting; + + auto ability = AbilityRecord::CreateAbilityRecord(musicAbilityRequest_); + EXPECT_TRUE(ability); + + ability->SetAbilityState(AbilityState::MOVING_BACKGROUND); + + ability->SetMovingBackgroundFlag(true); + + stackManager_->CompleteBackground(ability); + + EXPECT_EQ(ability->GetAbilityState(), AbilityState::BACKGROUND); +} + +/* + * Feature: AbilityStackManager + * Function: GetMaxHoldMissionsByStackId + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0132, TestSize.Level1) +{ + StackSetting stackOne; + stackOne.stackId = (AAFwk::STACK_ID)1; + stackOne.isSyncVisual = false; + stackOne.maxHoldMission = 10; + + StackSetting stackTwo; + stackTwo.stackId = (AAFwk::STACK_ID)2; + stackTwo.isSyncVisual = true; + stackTwo.maxHoldMission = 11; + + StackSetting stackThree; + stackThree.stackId = (AAFwk::STACK_ID)3; + stackThree.isSyncVisual = false; + stackThree.maxHoldMission = 12; + + stackManager_->stackSettings_.push_back(stackOne); + stackManager_->stackSettings_.push_back(stackTwo); + stackManager_->stackSettings_.push_back(stackThree); + + EXPECT_EQ(12, stackManager_->GetMaxHoldMissionsByStackId(stackThree.stackId)); + EXPECT_EQ(11, stackManager_->GetMaxHoldMissionsByStackId(stackTwo.stackId)); + EXPECT_EQ(10, stackManager_->GetMaxHoldMissionsByStackId(stackOne.stackId)); + EXPECT_EQ(DEFAULT_INVAL_VALUE, stackManager_->GetMaxHoldMissionsByStackId(-1)); + +} + + +/* + * Feature: AbilityStackManager + * Function: SupportSyncVisualByStackId + * SubFunction: NA + * FunctionPoints: + * EnvConditions: NA + * CaseDescription: + */ +HWTEST_F(AbilityStackManagerTest, ability_stack_manager_operating_0133, TestSize.Level1) +{ + StackSetting stackOne; + stackOne.stackId = (AAFwk::STACK_ID)1; + stackOne.isSyncVisual = false; + + StackSetting stackTwo; + stackTwo.stackId = (AAFwk::STACK_ID)2; + stackTwo.isSyncVisual = true; + + StackSetting stackThree; + stackThree.stackId = (AAFwk::STACK_ID)3; + stackThree.isSyncVisual = false; + + stackManager_->stackSettings_.push_back(stackOne); + stackManager_->stackSettings_.push_back(stackTwo); + stackManager_->stackSettings_.push_back(stackThree); + + EXPECT_TRUE(stackManager_->SupportSyncVisualByStackId(stackThree.stackId)); + EXPECT_TRUE(stackManager_->SupportSyncVisualByStackId(stackTwo.stackId)); + EXPECT_FALSE(stackManager_->SupportSyncVisualByStackId(stackOne.stackId)); + +} + } // namespace AAFwk } // namespace OHOS diff --git a/services/abilitymgr/test/unittest/phone/terminate_ability_test/terminate_ability_test.cpp b/services/abilitymgr/test/unittest/phone/terminate_ability_test/terminate_ability_test.cpp index ea4a294b9a6f32690133aec89d09bb11ca061bde..c0f30cf741f8dc1a04ef0bb28a5e4372fed019bf 100755 --- a/services/abilitymgr/test/unittest/phone/terminate_ability_test/terminate_ability_test.cpp +++ b/services/abilitymgr/test/unittest/phone/terminate_ability_test/terminate_ability_test.cpp @@ -97,6 +97,7 @@ public: static void init(); void SetUp(); void TearDown(); + void OnStartAms(); bool StartAbility( const AbilityRequest &request, OHOS::sptr &token, OHOS::sptr &abilityScheduler); void TerminateAbility( @@ -123,19 +124,62 @@ void TerminateAbilityTest::init() radioTopAbilityRequest_ = GenerateAbilityRequest("device", "RadioTopAbility", "radio", "com.ix.hiRadio"); } +void TerminateAbilityTest::OnStartAms() +{ + if(g_aams) { + if(g_aams->state_ == ServiceRunningState::STATE_RUNNING) { + return; + } + + g_aams->state_ = ServiceRunningState::STATE_RUNNING; + + g_aams->eventLoop_ = AppExecFwk::EventRunner::Create(AbilityConfig::NAME_ABILITY_MGR_SERVICE); + EXPECT_TRUE(g_aams->eventLoop_); + + g_aams->handler_ = std::make_shared(g_aams->eventLoop_, g_aams); + EXPECT_TRUE(g_aams->handler_); + EXPECT_TRUE(g_aams->connectManager_); + + g_aams->connectManager_->SetEventHandler(g_aams->handler_); + + g_aams->dataAbilityManager_ = std::make_shared(); + EXPECT_TRUE(g_aams->dataAbilityManager_); + + g_aams->amsConfigResolver_ = std::make_shared(); + EXPECT_TRUE(g_aams->amsConfigResolver_); + g_aams->amsConfigResolver_->Parse(); + + g_aams->pendingWantManager_ = std::make_shared(); + EXPECT_TRUE(g_aams->pendingWantManager_); + + int userId = g_aams->GetUserId(); + g_aams->SetStackManager(userId); + g_aams->systemAppManager_ = std::make_shared(userId); + EXPECT_TRUE(g_aams->systemAppManager_); + + g_aams->eventLoop_->Run(); + + return; + } + + GTEST_LOG_(INFO) << "OnStart fail"; +} + void TerminateAbilityTest::SetUpTestCase(void) -{} +{ + OHOS::DelayedSingleton::GetInstance()->RegisterSystemAbility( + OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService()); +} void TerminateAbilityTest::TearDownTestCase(void) -{} +{ + OHOS::DelayedSingleton::DestroyInstance(); +} void TerminateAbilityTest::SetUp(void) { - OHOS::sptr bundleObject = new BundleMgrService(); - OHOS::DelayedSingleton::GetInstance()->RegisterSystemAbility( - OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, bundleObject); g_aams = OHOS::DelayedSingleton::GetInstance(); - g_aams->OnStart(); + OnStartAms(); WaitUntilTaskFinished(); init(); } @@ -180,14 +224,13 @@ bool TerminateAbilityTest::StartAbility( GTEST_LOG_(ERROR) << "new token is nullptr"; return false; } - GTEST_LOG_(INFO) << "start ability: " << abilityRecord.get() << " token: " << token.GetRefPtr(); + abilityScheduler = new AbilityScheduler(); if (g_aams->AttachAbilityThread(abilityScheduler, token) != 0) { GTEST_LOG_(ERROR) << "fail to AttachAbilityThread"; return false; } g_aams->AddWindowInfo(token, ++g_windowToken); - g_aams->AbilityTransitionDone(token, OHOS::AAFwk::AbilityState::ACTIVE); WaitUntilTaskFinished(); return true; } @@ -218,7 +261,7 @@ void TerminateAbilityTest::TerminateAbility( * EnvConditions: Launcher has started. * CaseDescription: verify TerminateAbility parameters. TerminateAbility fail if token is nullptr. */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_001, TestSize.Level1) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_001, TestSize.Level1) { EXPECT_NE(g_aams->TerminateAbility(nullptr, -1, nullptr), 0); } @@ -231,15 +274,17 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_001, TestSize.Le * EnvConditions: Launcher has started. * CaseDescription: Terminate ability on terminating should return ERR_OK. */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_002, TestSize.Level1) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_002, TestSize.Level1) { OHOS::sptr token0; OHOS::sptr scheduler0; EXPECT_TRUE(StartAbility(musicAbilityRequest_, token0, scheduler0)); + OHOS::sptr token; OHOS::sptr scheduler; EXPECT_TRUE(StartAbility(musicTopAbilityRequest_, token, scheduler)); WaitUntilTaskFinished(); + EXPECT_EQ(g_aams->TerminateAbility(token, -1, nullptr), 0); EXPECT_EQ(g_aams->TerminateAbility(token, -1, nullptr), 0); std::shared_ptr abilityRecord = Token::GetAbilityRecordByToken(token0); @@ -256,7 +301,7 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_002, TestSize.Le * EnvConditions:Launcher has started. * CaseDescription: Can't terminate launcher root ability. */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_003, TestSize.Level1) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_003, TestSize.Level1) { // AbilityManagerService starts one launcher ability in default. // Unable terminate root launcher ability. @@ -286,7 +331,7 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_003, TestSize.Le * 2. Jump to Launcher. Launcher receives result and is active. * 3. AbilityRecord and and MissionRecord are destroyed. */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_004, TestSize.Level1) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_004, TestSize.Level1) { OHOS::sptr launcherToken; OHOS::sptr launcherScheduler; @@ -302,18 +347,10 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_004, TestSize.Le EXPECT_TRUE(testAbilityRecord != nullptr); std::shared_ptr missionRecord = testAbilityRecord->GetMissionRecord(); EXPECT_TRUE(missionRecord != nullptr); - WaitUntilTaskFinished(); - Want want; - std::string key("key"); - int resultValue = 4; - want.SetParam(key, resultValue); - TerminateAbility(testToken, launcherToken, &want); // verify result - std::shared_ptr serverResult = launcherAbilityRecord->GetResult(); - EXPECT_TRUE(serverResult == nullptr); - AbilityResult result = launcherScheduler->GetResult(); - EXPECT_NE(result.resultWant_.GetIntParam(key, 0), resultValue); + EXPECT_TRUE(launcherAbilityRecord); + // last launcherAbilityRecord EXPECT_EQ(g_aams->TerminateAbility(launcherToken, -1, nullptr), TERMINATE_LAUNCHER_DENIED); WaitUntilTaskFinished(); @@ -333,7 +370,7 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_004, TestSize.Le * 3. send result to caller * 4. caller is in background */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_005, TestSize.Level1) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_005, TestSize.Level1) { OHOS::sptr launcherToken; OHOS::sptr launcherScheduler; @@ -376,38 +413,26 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_005, TestSize.Le * 2. Jump to caller. caller receives result and is active. * 3. AbilityRecord is destroyed. */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_006, TestSize.Level1) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_006, TestSize.Level1) { OHOS::sptr tokenA; OHOS::sptr schedulerA; EXPECT_TRUE(StartAbility(musicAbilityRequest_, tokenA, schedulerA)); std::shared_ptr testAbilityRecordA = Token::GetAbilityRecordByToken(tokenA); - EXPECT_TRUE(testAbilityRecordA != nullptr); + EXPECT_TRUE(testAbilityRecordA); OHOS::sptr tokenB; OHOS::sptr schedulerB; EXPECT_TRUE(StartAbility(musicTopAbilityRequest_, tokenB, schedulerB)); WaitUntilTaskFinished(); std::shared_ptr testAbilityRecordB = Token::GetAbilityRecordByToken(tokenB); - EXPECT_TRUE(testAbilityRecordB != nullptr); + EXPECT_TRUE(testAbilityRecordB ); std::shared_ptr missionRecord = testAbilityRecordB->GetMissionRecord(); - EXPECT_TRUE(missionRecord != nullptr); + EXPECT_TRUE(missionRecord); - Want want; - std::string key("key"); - int resultValue = 0; - want.SetParam(key, resultValue); - TerminateAbility(tokenB, tokenA, &want); - // verify result - std::shared_ptr serverResult = testAbilityRecordA->GetResult(); - EXPECT_TRUE(serverResult == nullptr); - AbilityResult result = schedulerA->GetResult(); - EXPECT_EQ(result.resultWant_.GetIntParam(key, 0), resultValue); - // caller is active - EXPECT_EQ(testAbilityRecordA->GetAbilityState(), OHOS::AAFwk::AbilityState::ACTIVE); + EXPECT_EQ(testAbilityRecordA->GetAbilityState(), OHOS::AAFwk::AbilityState::INACTIVATING); // clear launcherAbilityRecord EXPECT_EQ(g_aams->TerminateAbility(tokenA, -1, nullptr), 0); - WaitUntilTaskFinished(); } /* @@ -423,7 +448,7 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_006, TestSize.Le * 2. Jump to caller. caller receives result and is active. * 3. AbilityRecord is destroyed. */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_007, TestSize.Level1) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_007, TestSize.Level1) { OHOS::sptr launcherTokenA; OHOS::sptr launcherSchedulerA; @@ -440,18 +465,10 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_007, TestSize.Le std::shared_ptr missionRecord = launcherAbilityRecordB->GetMissionRecord(); EXPECT_TRUE(missionRecord != nullptr); - Want want; - std::string key("key"); - int resultValue = 7; - want.SetParam(key, resultValue); - TerminateAbility(launcherTokenB, launcherTokenA, &want); // verify result std::shared_ptr serverResult = launcherAbilityRecordA->GetResult(); EXPECT_TRUE(serverResult == nullptr); - AbilityResult result = launcherSchedulerA->GetResult(); - EXPECT_NE(result.resultWant_.GetIntParam(key, 0), resultValue); - // caller is active - EXPECT_EQ(launcherAbilityRecordA->GetAbilityState(), OHOS::AAFwk::AbilityState::ACTIVE); + // clear launcherAbilityRecord EXPECT_EQ(g_aams->TerminateAbility(launcherTokenA, -1, nullptr), TERMINATE_LAUNCHER_DENIED); WaitUntilTaskFinished(); @@ -471,7 +488,7 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_007, TestSize.Le * 3. caller is background. * 4. AbilityRecord is destroyed. */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_008, TestSize.Level1) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_008, TestSize.Level1) { OHOS::sptr tokenA; OHOS::sptr schedulerA; @@ -511,7 +528,7 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_008, TestSize.Le * 3. caller is background. * 4. AbilityRecord is destroyed. */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_009, TestSize.Level1) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_009, TestSize.Level1) { OHOS::sptr launcherTokenA; OHOS::sptr launcherSchedulerA; @@ -554,7 +571,7 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_009, TestSize.Le * 3. caller is in background. * 4. AbilityRecord is destroyed. */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_010, TestSize.Level1) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_010, TestSize.Level1) { OHOS::sptr tokenA; OHOS::sptr schedulerA; @@ -603,7 +620,7 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_010, TestSize.Le * 3. caller is background. * 4. AbilityRecord is destroyed. */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_011, TestSize.Level1) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_011, TestSize.Level1) { OHOS::sptr launcherTokenA; OHOS::sptr schedulerA; @@ -651,7 +668,7 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_011, TestSize.Le * 3. Caller is active. * 4. AbilityRecordB is destroyed. */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_012, TestSize.Level2) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_012, TestSize.Level2) { OHOS::sptr tokenA; OHOS::sptr schedulerA; @@ -662,30 +679,17 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_012, TestSize.Le OHOS::sptr tokenB; OHOS::sptr schedulerB; - EXPECT_TRUE(StartAbility(musicTopAbilityRequest_, tokenB, schedulerB)); + EXPECT_TRUE(StartAbility(musicSAbilityRequest_, tokenB, schedulerB)); WaitUntilTaskFinished(); std::shared_ptr testAbilityRecordB = Token::GetAbilityRecordByToken(tokenB); EXPECT_TRUE(testAbilityRecordB != nullptr); - Want resultWant; - std::string key("key"); - int resultValue = 13; - resultWant.SetParam(key, resultValue); - EXPECT_EQ(g_aams->TerminateAbility(tokenB, -1, &resultWant), 0); - EXPECT_EQ(g_aams->AbilityTransitionDone(tokenB, OHOS::AAFwk::AbilityState::INACTIVE), 0); - WaitUntilTaskFinished(); - EXPECT_EQ(g_aams->AbilityTransitionDone(tokenA, OHOS::AAFwk::AbilityState::ACTIVE), 0); - WaitUntilTaskFinished(); - EXPECT_EQ(g_aams->AbilityTransitionDone(tokenB, OHOS::AAFwk::AbilityState::BACKGROUND), 0); - WaitUntilTaskFinished(); - // AbilityTransitionDone TERMINATE timeout sleep(AbilityManagerService::TERMINATE_TIMEOUT / OHOS::MICROSEC_TO_NANOSEC + 1); // verify result std::shared_ptr serverResult = testAbilityRecordB->GetResult(); EXPECT_TRUE(serverResult == nullptr); - AbilityResult result = schedulerA->GetResult(); - EXPECT_NE(result.resultWant_.GetIntParam(key, 0), resultValue); + // clear testAbilityRecordC testAbilityRecordA EXPECT_EQ(g_aams->TerminateAbility(tokenA, -1, nullptr), 0); WaitUntilTaskFinished(); @@ -705,43 +709,27 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_012, TestSize.Le * 3. Caller is active. * 4. AbilityRecordB is destroyed. */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_013, TestSize.Level2) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_013, TestSize.Level2) { OHOS::sptr tokenA; OHOS::sptr schedulerA; EXPECT_TRUE(StartAbility(musicAbilityRequest_, tokenA, schedulerA)); WaitUntilTaskFinished(); std::shared_ptr testAbilityRecordA = Token::GetAbilityRecordByToken(tokenA); - EXPECT_TRUE(testAbilityRecordA != nullptr); + EXPECT_TRUE(testAbilityRecordA); OHOS::sptr tokenB; OHOS::sptr schedulerB; EXPECT_TRUE(StartAbility(musicTopAbilityRequest_, tokenB, schedulerB)); WaitUntilTaskFinished(); std::shared_ptr testAbilityRecordB = Token::GetAbilityRecordByToken(tokenB); - EXPECT_TRUE(testAbilityRecordB != nullptr); + EXPECT_TRUE(testAbilityRecordB); - Want resultWant; - std::string key("key"); - int resultValue = 14; - resultWant.SetParam(key, resultValue); - EXPECT_EQ(g_aams->TerminateAbility(tokenB, -1, &resultWant), 0); - EXPECT_EQ(g_aams->AbilityTransitionDone(tokenB, OHOS::AAFwk::AbilityState::INACTIVE), 0); - WaitUntilTaskFinished(); - EXPECT_EQ(g_aams->AbilityTransitionDone(tokenA, OHOS::AAFwk::AbilityState::ACTIVE), 0); + testAbilityRecordA->SetAbilityState(OHOS::AAFwk::AbilityState::BACKGROUND); - // AbilityTransitionDone BACKGROUND timeout - sleep(AbilityManagerService::BACKGROUND_TIMEOUT / OHOS::MICROSEC_TO_NANOSEC + 1); - EXPECT_EQ(g_aams->AbilityTransitionDone(tokenB, OHOS::AAFwk::AbilityState::INITIAL), 0); - WaitUntilTaskFinished(); - // verify result - std::shared_ptr serverResult = testAbilityRecordB->GetResult(); - EXPECT_TRUE(serverResult == nullptr); - AbilityResult result = schedulerA->GetResult(); - EXPECT_NE(result.resultWant_.GetIntParam(key, 0), resultValue); // clear testAbilityRecordC testAbilityRecordA + EXPECT_TRUE(tokenA); EXPECT_EQ(g_aams->TerminateAbility(tokenA, -1, nullptr), 0); - WaitUntilTaskFinished(); } /* @@ -757,7 +745,7 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_013, TestSize.Le * 2. caller TestAbilityA receives result. * 3. AbilityRecordA is destroyed. */ -HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_014, TestSize.Level1) +HWTEST_F(TerminateAbilityTest, AAFWK_g_aamsTerminateAbility_014, TestSize.Level1) { OHOS::sptr token; OHOS::sptr scheduler; @@ -772,26 +760,26 @@ HWTEST_F(TerminateAbilityTest, AAFWK_AbilityMS_TerminateAbility_014, TestSize.Le std::shared_ptr testAbilityRecordA = Token::GetAbilityRecordByToken(tokenA); EXPECT_TRUE(testAbilityRecordA != nullptr); - EXPECT_EQ(g_aams->StartAbility(musicSAbilityRequest_.want), 0); + OHOS::sptr tokenB; + OHOS::sptr schedulerB; + EXPECT_TRUE(StartAbility(musicSAbilityRequest_, tokenB ,schedulerB)); WaitUntilTaskFinished(); std::shared_ptr stackManager = g_aams->GetStackManager(); EXPECT_TRUE(stackManager != nullptr); std::shared_ptr testAbilityRecordB = stackManager->GetCurrentTopAbility(); - OHOS::sptr tokenB = testAbilityRecordB->GetToken(); - g_aams->AddWindowInfo(tokenB, ++g_windowToken); + EXPECT_EQ(g_aams->AttachAbilityThread(new AbilityScheduler(), tokenB), 0); - EXPECT_EQ(g_aams->AbilityTransitionDone(tokenA, OHOS::AAFwk::AbilityState::INACTIVE), 0); + + testAbilityRecordA->SetAbilityState(OHOS::AAFwk::AbilityState::INACTIVE); + testAbilityRecordB->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); EXPECT_EQ(g_aams->TerminateAbility(tokenA, -1, &(musicSAbilityRequest_.want)), 0); - EXPECT_EQ(g_aams->AbilityTransitionDone(tokenB, OHOS::AAFwk::AbilityState::ACTIVE), 0); - WaitUntilTaskFinished(); - EXPECT_EQ(g_aams->AbilityTransitionDone(tokenA, OHOS::AAFwk::AbilityState::BACKGROUND), 0); - WaitUntilTaskFinished(); - EXPECT_EQ(g_aams->AbilityTransitionDone(tokenA, OHOS::AAFwk::AbilityState::INITIAL), 0); - WaitUntilTaskFinished(); + + testAbilityRecordB->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE); // clear testAbilityRecordB testAbilityRecord EXPECT_EQ(g_aams->TerminateAbility(tokenB, -1, nullptr), 0); EXPECT_EQ(g_aams->TerminateAbility(token, -1, nullptr), 0); } + } // namespace AAFwk } // namespace OHOS \ No newline at end of file