From 374b04caba8045ce699900ea50660bd36eb18a0f Mon Sep 17 00:00:00 2001 From: huangxiaolinabc123 Date: Thu, 20 Oct 2022 17:04:49 +0800 Subject: [PATCH] add tdd Signed-off-by: huangxiaolinabc123 Change-Id: I2eb0cf2e6e569503752b0f9c25918529ff4a9dc5 --- .../src/system_ability_mgr_proxy_test.cpp | 217 ++++++++ .../src/system_ability_mgr_stub_test.cpp | 492 ++++++++++++++++++ 2 files changed, 709 insertions(+) diff --git a/services/samgr/native/test/unittest/src/system_ability_mgr_proxy_test.cpp b/services/samgr/native/test/unittest/src/system_ability_mgr_proxy_test.cpp index 42032194..8141006d 100644 --- a/services/samgr/native/test/unittest/src/system_ability_mgr_proxy_test.cpp +++ b/services/samgr/native/test/unittest/src/system_ability_mgr_proxy_test.cpp @@ -103,6 +103,131 @@ HWTEST_F(SystemAbilityMgrProxyTest, AddSystemProcess002, TestSize.Level1) EXPECT_EQ(ret, ERR_OK); } +/** + * @tc.name: CheckSystemAbility001 + * @tc.desc: CheckSystemAbility, systemAbilityId: invalid! + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, CheckSystemAbility001, TestSize.Level1) +{ + DTEST_LOG << " CheckSystemAbility001 start " << std::endl; + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + sptr ret = sm->CheckSystemAbility(TEST_ID_NORANGE_SAID); + EXPECT_EQ(ret, nullptr); +} + +/** + * @tc.name: CheckSystemAbility002 + * @tc.desc: CheckSystemAbility, CheckSystemAbility:systemAbilityId or deviceId is nullptr + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, CheckSystemAbility002, TestSize.Level1) +{ + DTEST_LOG << " CheckSystemAbility002 start " << std::endl; + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + std::string deviceId = ""; + sptr ret = sm->CheckSystemAbility(TEST_ID_NORANGE_SAID, deviceId); + EXPECT_EQ(ret, nullptr); +} + +/** + * @tc.name: CheckSystemAbility003 + * @tc.desc: CheckSystemAbility, CheckSystemAbility:systemAbilityId or deviceId is nullptr + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, CheckSystemAbility003, TestSize.Level1) +{ + DTEST_LOG << " CheckSystemAbility003 start " << std::endl; + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + std::string deviceId = ""; + sptr ret = sm->CheckSystemAbility(TEST_ID_VAILD, deviceId); + EXPECT_EQ(ret, nullptr); +} + +/** + * @tc.name: CheckSystemAbility004 + * @tc.desc: CheckSystemAbility, CheckSystemAbility:systemAbilityId invalid! + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, CheckSystemAbility004, TestSize.Level1) +{ + DTEST_LOG << " CheckSystemAbility004 start " << std::endl; + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + bool isExist = true; + sptr ret = sm->CheckSystemAbility(TEST_ID_VAILD, isExist); + EXPECT_EQ(ret, nullptr); +} + +/** + * @tc.name: AddOnDemandSystemAbilityInfo001 + * @tc.desc: AddOnDemandSystemAbilityInfo, AddOnDemandSystemAbilityInfo invalid params + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, AddOnDemandSystemAbilityInfo001, TestSize.Level1) +{ + DTEST_LOG << " AddOnDemandSystemAbilityInfo001 start " << std::endl; + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + std::u16string localAbilityManagerName = u""; + int32_t ret = sm->AddOnDemandSystemAbilityInfo(TEST_ID_NORANGE_SAID, localAbilityManagerName); + EXPECT_EQ(ret, ERR_INVALID_VALUE); +} + +/** + * @tc.name: AddOnDemandSystemAbilityInfo002 + * @tc.desc: AddOnDemandSystemAbilityInfo, AddOnDemandSystemAbilityInfo invalid params + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, AddOnDemandSystemAbilityInfo002, TestSize.Level1) +{ + DTEST_LOG << " AddOnDemandSystemAbilityInfo002 start " << std::endl; + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + std::u16string localAbilityManagerName = u""; + int32_t ret = sm->AddOnDemandSystemAbilityInfo(TEST_ID_VAILD, localAbilityManagerName); + EXPECT_EQ(ret, ERR_INVALID_VALUE); +} + +/** + * @tc.name: SubscribeSystemAbility001 + * @tc.desc: SubscribeSystemAbility, SubscribeSystemAbility systemAbilityId: or listener invalid! + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, SubscribeSystemAbility001, TestSize.Level1) +{ + DTEST_LOG << " SubscribeSystemAbility001 start " << std::endl; + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + int32_t ret = sm->SubscribeSystemAbility(TEST_ID_NORANGE_SAID, nullptr); + EXPECT_EQ(ret, ERR_INVALID_VALUE); +} + +/** + * @tc.name: SubscribeSystemAbility002 + * @tc.desc: SubscribeSystemAbility, SubscribeSystemAbility systemAbilityId: or listener invalid! + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, SubscribeSystemAbility002, TestSize.Level1) +{ + DTEST_LOG << " SubscribeSystemAbility002 start " << std::endl; + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + int32_t ret = sm->SubscribeSystemAbility(TEST_ID_VAILD, nullptr); + EXPECT_EQ(ret, ERR_INVALID_VALUE); +} + /** * @tc.name: UnSubscribeSystemAbility001 * @tc.desc: check UnSubscribeSystemAbility @@ -135,6 +260,98 @@ HWTEST_F(SystemAbilityMgrProxyTest, UnSubscribeSystemAbility002, TestSize.Level1 EXPECT_EQ(res, ERR_OK); } +/** + * @tc.name: UnSubscribeSystemAbility003 + * @tc.desc: check UnSubscribeSystemAbility + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, UnSubscribeSystemAbility003, TestSize.Level1) +{ + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + sptr callback(new SaStatusChangeMock()); + int32_t res = sm->UnSubscribeSystemAbility(TEST_ID_NORANGE_SAID, callback); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: UnSubscribeSystemAbility004 + * @tc.desc: check UnSubscribeSystemAbility + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, UnSubscribeSystemAbility004, TestSize.Level1) +{ + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + int32_t res = sm->UnSubscribeSystemAbility(TEST_ID_VAILD, nullptr); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: LoadSystemAbility001 + * @tc.desc: check LoadSystemAbility + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, LoadSystemAbility001, TestSize.Level1) +{ + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + std::string deviceId = "deviceId"; + sptr callback(new SystemAbilityLoadCallbackMock()); + int32_t res = sm->LoadSystemAbility(TEST_ID_NORANGE_SAID, deviceId, callback); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: LoadSystemAbility002 + * @tc.desc: check LoadSystemAbility + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, LoadSystemAbility002, TestSize.Level1) +{ + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + std::string deviceId = ""; + sptr callback(new SystemAbilityLoadCallbackMock()); + int32_t res = sm->LoadSystemAbility(TEST_ID_VAILD, deviceId, callback); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: LoadSystemAbility003 + * @tc.desc: check LoadSystemAbility + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, LoadSystemAbility003, TestSize.Level1) +{ + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + std::string deviceId = "deviceId"; + int32_t res = sm->LoadSystemAbility(TEST_ID_VAILD, deviceId, nullptr); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: LoadSystemAbility004 + * @tc.desc: check LoadSystemAbility + * @tc.type: FUNC + * @tc.require: I5KMF7 + */ +HWTEST_F(SystemAbilityMgrProxyTest, LoadSystemAbility004, TestSize.Level1) +{ + sptr sm = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + EXPECT_NE(sm, nullptr); + std::string deviceId = "deviceId"; + sptr callback(new SystemAbilityLoadCallbackMock()); + int32_t res = sm->LoadSystemAbility(TEST_ID_VAILD, deviceId, callback); + EXPECT_EQ(res, ERR_NONE); +} + /** * @tc.name: ServiceRegistry001 * @tc.desc: check ServiceRegistry diff --git a/services/samgr/native/test/unittest/src/system_ability_mgr_stub_test.cpp b/services/samgr/native/test/unittest/src/system_ability_mgr_stub_test.cpp index 206083c1..fe9c6fb6 100644 --- a/services/samgr/native/test/unittest/src/system_ability_mgr_stub_test.cpp +++ b/services/samgr/native/test/unittest/src/system_ability_mgr_stub_test.cpp @@ -1467,4 +1467,496 @@ HWTEST_F(SystemAbilityMgrStubTest, RemoveSystemAbility007, TestSize.Level3) int32_t res = saMgr->RemoveSystemAbility(saMgr); EXPECT_EQ(res, ERR_OK); } + +/** + * @tc.name: SubscribeSystemAbility001 + * @tc.desc: test SubscribeSystemAbility, systemAbilityId or listener invalid! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, SubscribeSystemAbility001, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr listener(new SaStatusChangeMock()); + int32_t res = saMgr->SubscribeSystemAbility(INVALID_SAID, listener); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: SubscribeSystemAbility002 + * @tc.desc: test SubscribeSystemAbility, systemAbilityId or listener invalid! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, SubscribeSystemAbility002, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr listener(nullptr); + int32_t res = saMgr->SubscribeSystemAbility(SAID, listener); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: SubscribeSystemAbility003 + * @tc.desc: test SubscribeSystemAbility, systemAbilityId or listener invalid! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, SubscribeSystemAbility003, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr listener(nullptr); + int32_t res = saMgr->SubscribeSystemAbility(INVALID_SAID, listener); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: SubscribeSystemAbility004 + * @tc.desc: test SubscribeSystemAbility, already exist listener! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, SubscribeSystemAbility004, TestSize.Level3) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr listener(new SaStatusChangeMock()); + saMgr->listenerMap_[SAID].push_back(make_pair(listener, SAID)); + int32_t res = saMgr->SubscribeSystemAbility(SAID, listener); + EXPECT_EQ(res, ERR_OK); +} + +/** + * @tc.name: UnSubscribeSystemAbility001 + * @tc.desc: test UnSubscribeSystemAbility, UnSubscribeSystemAbility systemAbilityId or listener invalid!! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, UnSubscribeSystemAbility001, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr listener(new SaStatusChangeMock()); + int32_t res = saMgr->UnSubscribeSystemAbility(INVALID_SAID, listener); + u16string name = u"device_saname"; + saMgr->NotifyRemoteSaDied(name); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: UnSubscribeSystemAbility002 + * @tc.desc: test UnSubscribeSystemAbility, UnSubscribeSystemAbility systemAbilityId or listener invalid!! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, UnSubscribeSystemAbility002, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr listener(nullptr); + int32_t res = saMgr->UnSubscribeSystemAbility(SAID, listener); + u16string name = u"deviceSaname"; + saMgr->dBinderService_ = nullptr; + saMgr->NotifyRemoteSaDied(name); + saMgr->dBinderService_ = DBinderService::GetInstance(); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: UnSubscribeSystemAbility003 + * @tc.desc: test UnSubscribeSystemAbility, UnSubscribeSystemAbility systemAbilityId or listener invalid!! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, UnSubscribeSystemAbility003, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr listener(nullptr); + int32_t res = saMgr->UnSubscribeSystemAbility(INVALID_SAID, listener); + string deviceId = "device"; + saMgr->NotifyRemoteDeviceOffline(deviceId); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: UnSubscribeSystemAbility004 + * @tc.desc: test UnSubscribeSystemAbility + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, UnSubscribeSystemAbility004, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr listener(new SaStatusChangeMock()); + saMgr->listenerMap_[SAID].push_back(make_pair(listener, SAID)); + saMgr->abilityStatusDeath_ = nullptr; + saMgr->subscribeCountMap_.clear(); + int32_t res = saMgr->UnSubscribeSystemAbility(SAID, listener); + saMgr->dBinderService_ = nullptr; + string deviceId = "device"; + saMgr->NotifyRemoteDeviceOffline(deviceId); + saMgr->dBinderService_ = DBinderService::GetInstance(); + EXPECT_EQ(res, ERR_OK); +} + +/** + * @tc.name: UnSubscribeSystemAbility005 + * @tc.desc: test UnSubscribeSystemAbility + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, UnSubscribeSystemAbility005, TestSize.Level3) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr listener(new SaStatusChangeMock()); + saMgr->listenerMap_[SAID].push_back(make_pair(listener, SAID)); + saMgr->abilityStatusDeath_ = nullptr; + int countNum = 2; + saMgr->subscribeCountMap_[SAID] = countNum; + int32_t res = saMgr->UnSubscribeSystemAbility(SAID, listener); + EXPECT_EQ(res, ERR_OK); +} + +/** + * @tc.name: AddSystemAbility001 + * @tc.desc: test AddSystemAbility, input params is invalid + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, AddSystemAbility001, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr testAbility(new SaStatusChangeMock()); + SystemAbilityManager::SAExtraProp extraProp; + int32_t res = saMgr->AddSystemAbility(INVALID_SAID, testAbility, extraProp); + saMgr->workHandler_ = nullptr; + saMgr->SendSystemAbilityRemovedMsg(SAID); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: AddSystemAbility002 + * @tc.desc: test AddSystemAbility, input params is invalid, work handler not initialized + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, AddSystemAbility002, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr testAbility(nullptr); + SystemAbilityManager::SAExtraProp extraProp; + int32_t res = saMgr->AddSystemAbility(SAID, testAbility, extraProp); + u16string name; + string srcDeviceId; + sptr callback = new SystemAbilityLoadCallbackMock(); + saMgr->SendCheckLoadedMsg(SAID, name, srcDeviceId, callback); + saMgr->SendLoadedSystemAblityMsg(SAID, testAbility, callback); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: AddSystemAbility003 + * @tc.desc: test AddSystemAbility, input params is invalid + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, AddSystemAbility003, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr testAbility(nullptr); + SystemAbilityManager::SAExtraProp extraProp; + int32_t res = saMgr->AddSystemAbility(INVALID_SAID, testAbility, extraProp); + auto runner = AppExecFwk::EventRunner::Create("workHandler"); + saMgr->workHandler_ = make_shared(runner); + u16string name; + string srcDeviceId; + sptr callback = new SystemAbilityLoadCallbackMock(); + saMgr->SendCheckLoadedMsg(SAID, name, srcDeviceId, callback); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: AddSystemAbility004 + * @tc.desc: test AddSystemAbility, return ERR_OK,SendCheckLoadedMsg SA loaded + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, AddSystemAbility004, TestSize.Level3) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr testAbility(new SaStatusChangeMock()); + SystemAbilityManager::SAExtraProp extraProp; + extraProp.isDistributed = false; + saMgr->dBinderService_ = nullptr; + int32_t res = saMgr->AddSystemAbility(SAID, testAbility, extraProp); + saMgr->dBinderService_ = DBinderService::GetInstance(); + u16string name; + string srcDeviceId; + sptr callback = new SystemAbilityLoadCallbackMock(); + SAInfo saInfo; + saMgr->abilityMap_[SAID] = saInfo; + saMgr->SendCheckLoadedMsg(SAID, name, srcDeviceId, callback); + EXPECT_EQ(res, ERR_OK); +} + +/** + * @tc.name: AddSystemAbility005 + * @tc.desc: test AddSystemAbility, return ERR_OK + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, AddSystemAbility005, TestSize.Level3) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr testAbility(new SaStatusChangeMock()); + SystemAbilityManager::SAExtraProp extraProp; + saMgr->dBinderService_ = nullptr; + int32_t res = saMgr->AddSystemAbility(SOFTBUS_SERVER_SA_ID, testAbility, extraProp); + saMgr->dBinderService_ = DBinderService::GetInstance(); + u16string name = u"test"; + string srcDeviceId; + int64_t id = 1; + saMgr->startingProcessMap_[name] = id; + saMgr->startingAbilityMap_.clear(); + sptr callback = new SystemAbilityLoadCallbackMock(); + saMgr->CleanCallbackForLoadFailed(SAID, name, srcDeviceId, callback); + EXPECT_EQ(res, ERR_OK); +} + +/** + * @tc.name: AddSystemAbility006 + * @tc.desc: test AddSystemAbility, return ERR_OK + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, AddSystemAbility006, TestSize.Level3) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr testAbility(new SaStatusChangeMock()); + SystemAbilityManager::SAExtraProp extraProp; + saMgr->rpcCallbackImp_ = nullptr; + int32_t res = saMgr->AddSystemAbility(SOFTBUS_SERVER_SA_ID, testAbility, extraProp); + saMgr->rpcCallbackImp_ = make_shared(); + u16string name = u"test"; + string srcDeviceId = "srcDeviceId"; + saMgr->startingProcessMap_.clear(); + sptr callback = new SystemAbilityLoadCallbackMock(); + SystemAbilityManager::AbilityItem abilityItem; + abilityItem.callbackMap[srcDeviceId].push_back(make_pair(callback, SAID)); + saMgr->startingAbilityMap_[SAID] = abilityItem; + saMgr->CleanCallbackForLoadFailed(SAID, name, srcDeviceId, callback); + EXPECT_EQ(res, ERR_OK); +} + +/** + * @tc.name: AddSystemProcess001 + * @tc.desc: test AddSystemProcess, return ERR_INVALID_VALUE + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, AddSystemProcess001, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr testAbility(new SaStatusChangeMock()); + u16string procName = u""; + int32_t res = saMgr->AddSystemProcess(procName, testAbility); + u16string name = u"test"; + string srcDeviceId = "srcDeviceId"; + saMgr->startingProcessMap_.clear(); + sptr callbackOne = new SystemAbilityLoadCallbackMock(); + sptr callbackTwo = new SystemAbilityLoadCallbackMock(); + SystemAbilityManager::AbilityItem abilityItem; + abilityItem.callbackMap[srcDeviceId].push_back(make_pair(callbackOne, SAID)); + abilityItem.callbackMap[srcDeviceId].push_back(make_pair(callbackTwo, SAID)); + saMgr->startingAbilityMap_[SAID] = abilityItem; + saMgr->CleanCallbackForLoadFailed(SAID, name, srcDeviceId, callbackOne); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: AddSystemProcess002 + * @tc.desc: test AddSystemProcess, return ERR_INVALID_VALUE + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, AddSystemProcess002, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr testAbility(nullptr); + u16string procName = u"proname"; + int32_t res = saMgr->AddSystemProcess(procName, testAbility); + sptr callback = new SystemAbilityLoadCallbackMock(); + saMgr->SendLoadedSystemAblityMsg(SAID, testAbility, callback); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: RemoveSystemProcess001 + * @tc.desc: test RemoveSystemProcess, return ERR_INVALID_VALUE + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, RemoveSystemProcess001, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr testAbility(nullptr); + int32_t res = saMgr->RemoveSystemProcess(testAbility); + saMgr->NotifySystemAbilityLoadFail(SAID, nullptr); + EXPECT_EQ(res, ERR_INVALID_VALUE); +} + +/** + * @tc.name: RemoveSystemProcess002 + * @tc.desc: test RemoveSystemProcess, return ERR_OK + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, RemoveSystemProcess002, TestSize.Level3) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr testAbility(new SaStatusChangeMock()); + u16string procName = u"proname"; + int32_t res = saMgr->AddSystemProcess(procName, testAbility); + EXPECT_EQ(res, ERR_OK); + saMgr->systemProcessDeath_ = nullptr; + res = saMgr->RemoveSystemProcess(testAbility); + sptr callback = new SystemAbilityLoadCallbackMock(); + saMgr->NotifySystemAbilityLoadFail(SAID, callback); + EXPECT_EQ(res, ERR_OK); +} + +/** + * @tc.name: GetSystemProcess001 + * @tc.desc: test GetSystemProcess, process found + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, GetSystemProcess001, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr testAbility(new SaStatusChangeMock()); + u16string procName = u"proTest"; + int32_t res = saMgr->AddSystemProcess(procName, testAbility); + EXPECT_EQ(res, ERR_OK); + sptr resObj = saMgr->GetSystemProcess(procName); + saMgr->WatchDogInit(); + EXPECT_NE(resObj, nullptr); +} + +/** + * @tc.name: StartingSystemProcess001 + * @tc.desc: test StartingSystemProcess, process already starting! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, StartingSystemProcess001, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + u16string procName = u"proTest"; + saMgr->startingProcessMap_.clear(); + int countNum = 2; + saMgr->startingProcessMap_[procName] = countNum; + int32_t res = saMgr->StartingSystemProcess(procName, SAID); + EXPECT_EQ(res, ERR_OK); +} + +/** + * @tc.name: StartingSystemProcess002 + * @tc.desc: test StartingSystemProcess, return ERR_OK! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, StartingSystemProcess002, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr testAbility(new SaStatusChangeMock()); + u16string procName = u"proTest"; + saMgr->startingProcessMap_.clear(); + saMgr->systemProcessMap_[procName] = testAbility; + int32_t res = saMgr->StartingSystemProcess(procName, SAID); + EXPECT_EQ(res, ERR_OK); +} + +/** + * @tc.name: LoadSystemAbilityFromRpc001 + * @tc.desc: test LoadSystemAbilityFromRpc, not supported! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, LoadSystemAbilityFromRpc001, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + SaProfile saProfile; + string srcDeviceId; + sptr callback = new SystemAbilityLoadCallbackMock(); + saMgr->saProfileMap_.clear(); + bool res = saMgr->LoadSystemAbilityFromRpc(srcDeviceId, SAID, callback); + EXPECT_FALSE(res); +} + +/** + * @tc.name: LoadSystemAbilityFromRpc002 + * @tc.desc: test LoadSystemAbilityFromRpc, not distributed! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, LoadSystemAbilityFromRpc002, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + SaProfile saProfile; + saProfile.distributed = false; + string srcDeviceId; + sptr callback = new SystemAbilityLoadCallbackMock(); + saMgr->saProfileMap_[SAID] = saProfile; + bool res = saMgr->LoadSystemAbilityFromRpc(srcDeviceId, SAID, callback); + EXPECT_FALSE(res); +} + +/** + * @tc.name: LoadSystemAbilityFromRpc003 + * @tc.desc: test LoadSystemAbilityFromRpc, return true! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, LoadSystemAbilityFromRpc003, TestSize.Level3) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr testAbility(new SaStatusChangeMock()); + sptr callback = new SystemAbilityLoadCallbackMock(); + SaProfile saProfile; + saProfile.distributed = true; + SAInfo saInfo; + saInfo.remoteObj = testAbility; + string srcDeviceId; + saMgr->saProfileMap_[SAID] = saProfile; + saMgr->abilityMap_[SAID] = saInfo; + bool res = saMgr->LoadSystemAbilityFromRpc(srcDeviceId, SAID, callback); + EXPECT_TRUE(res); +} + +/** + * @tc.name: LoadSystemAbilityFromRpc004 + * @tc.desc: test LoadSystemAbilityFromRpc, return true! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, LoadSystemAbilityFromRpc004, TestSize.Level3) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr callback = new SystemAbilityLoadCallbackMock(); + SaProfile saProfile; + u16string procName = u"procname"; + int countNum = 2; + saProfile.distributed = true; + saProfile.process = procName; + SAInfo saInfo; + SystemAbilityManager::AbilityItem abilityItem; + saInfo.remoteObj = nullptr; + string srcDeviceId = "srcDeviceId"; + saMgr->saProfileMap_[SAID] = saProfile; + saMgr->abilityMap_[SAID] = saInfo; + saMgr->startingAbilityMap_[SAID] = abilityItem; + saMgr->startingProcessMap_[procName] = countNum; + bool res = saMgr->LoadSystemAbilityFromRpc(srcDeviceId, SAID, callback); + EXPECT_TRUE(res); +} + +/** + * @tc.name: LoadSystemAbilityFromRpc005 + * @tc.desc: test LoadSystemAbilityFromRpc, LoadSystemAbility said or callback invalid!! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, LoadSystemAbilityFromRpc005, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr callback = nullptr; + string srcDeviceId = "srcDeviceId"; + bool res = saMgr->LoadSystemAbilityFromRpc(srcDeviceId, SAID, callback); + EXPECT_FALSE(res); +} + +/** + * @tc.name: LoadSystemAbilityFromRpc006 + * @tc.desc: test LoadSystemAbilityFromRpc, LoadSystemAbility said or callback invalid!! + * @tc.type: FUNC + */ +HWTEST_F(SystemAbilityMgrStubTest, LoadSystemAbilityFromRpc006, TestSize.Level1) +{ + sptr saMgr = SystemAbilityManager::GetInstance(); + sptr callback = new SystemAbilityLoadCallbackMock(); + string srcDeviceId = "srcDeviceId"; + bool res = saMgr->LoadSystemAbilityFromRpc(srcDeviceId, INVALID_SAID, callback); + EXPECT_FALSE(res); +} } -- Gitee