From 81a53e8c6aee24cbf57db3d3b73a19323491c5db Mon Sep 17 00:00:00 2001 From: jicheng Date: Mon, 16 Jun 2025 10:38:56 +0800 Subject: [PATCH] =?UTF-8?q?=E8=A1=A5=E5=85=85DT=E7=94=A8=E4=BE=8B?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: jicheng --- .../src/ability_manager_service.cpp | 8 + .../abilitymgr/src/connection_state_item.cpp | 16 +- .../ability_manager_client_test.cpp | 28 ++ .../ability_connect_manager_first_test.cpp | 60 ++++ .../ability_manager_service_twelfth_test.cpp | 23 ++ .../ability_manager_stub_second_test.cpp | 38 +++ .../connection_observer_test.cpp | 87 ++++++ .../connection_state_item_test.cpp | 294 ++++++++++++++++++ .../connection_state_manager_test.cpp | 111 +++++++ 9 files changed, 664 insertions(+), 1 deletion(-) diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp index 796895c2160..c1aa408fb78 100644 --- a/services/abilitymgr/src/ability_manager_service.cpp +++ b/services/abilitymgr/src/ability_manager_service.cpp @@ -14485,6 +14485,10 @@ int32_t AbilityManagerService::HandleExtensionAbility(sptr c int AbilityManagerService::SuspendExtensionAbility(sptr connect) { HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + if (!AAFwk::PermissionVerification::GetInstance()->IsSACall()) { + TAG_LOGE(AAFwkTag::ABILITYMGR, "not sa call"); + return; + } TAG_LOGI(AAFwkTag::SERVICE_EXT, "Suspend extension ability begin."); CHECK_POINTER_AND_RETURN(connect, ERR_INVALID_VALUE); auto err = HandleExtensionAbility(connect, @@ -14502,6 +14506,10 @@ int AbilityManagerService::SuspendExtensionAbility(sptr conn int AbilityManagerService::ResumeExtensionAbility(sptr connect) { HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__); + if (!AAFwk::PermissionVerification::GetInstance()->IsSACall()) { + TAG_LOGE(AAFwkTag::ABILITYMGR, "not sa call"); + return; + } TAG_LOGI(AAFwkTag::SERVICE_EXT, "Resume extension ability begin."); CHECK_POINTER_AND_RETURN(connect, ERR_INVALID_VALUE); auto err = HandleExtensionAbility(connect, diff --git a/services/abilitymgr/src/connection_state_item.cpp b/services/abilitymgr/src/connection_state_item.cpp index dd82a30d2b4..c7a44e7ce36 100644 --- a/services/abilitymgr/src/connection_state_item.cpp +++ b/services/abilitymgr/src/connection_state_item.cpp @@ -102,12 +102,22 @@ public: return false; } std::lock_guard guard(connectionsMutex_); + auto it = connections_.find(connection); + if (it == connections_.end()) { + return false; + } + + bool isUnAvaliable = (*it).second; connections_.erase(connection); if (connections_.empty()) { event.disconnectedEvent = true; return true; } - auto it = std::find_if(connections_.begin(), connections_.end(), + + if (isUnAvaliable) { + return false; + } + it = std::find_if(connections_.begin(), connections_.end(), [](const std::pair, bool>& pair)->bool {return pair.second == false;}); if (it == connections_.end()) { event.suspendedEvent = true; @@ -126,6 +136,10 @@ public: if (it == connections_.end()) { return false; } + + if ((*it).second) { + return false; + } (*it).second = true; it = std::find_if(connections_.begin(), connections_.end(), [](const std::pair, bool>& pair)->bool {return pair.second == false;}); diff --git a/test/moduletest/ability_manager_client_test/ability_manager_client_test.cpp b/test/moduletest/ability_manager_client_test/ability_manager_client_test.cpp index b5a7832e7d2..8286f39e338 100644 --- a/test/moduletest/ability_manager_client_test/ability_manager_client_test.cpp +++ b/test/moduletest/ability_manager_client_test/ability_manager_client_test.cpp @@ -559,5 +559,33 @@ HWTEST_F(AbilityManagerClientTest, GetInsightIntentInfoByIntentName_0100, TestSi EXPECT_EQ(result, ERR_OK); TAG_LOGI(AAFwkTag::TEST, "GetInsightIntentInfoByIntentName_0100 end"); } + +/** + * @tc.name: SuspendExtensionAbility_0100 + * @tc.desc: SuspendExtensionAbility + * @tc.type: FUNC + */ +HWTEST_F(AbilityManagerClientTest, SuspendExtensionAbility_0100, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "SuspendExtensionAbility_0100 start"); + sptr connect = sptr::MakeSptr(); + auto result = AbilityManagerClient::GetInstance()->SuspendExtensionAbility(connect); + EXPECT_EQ(result, ERR_OK); + TAG_LOGI(AAFwkTag::TEST, "SuspendExtensionAbility_0100 end"); +} + +/** + * @tc.name: ResumeExtensionAbility_0100 + * @tc.desc: ResumeExtensionAbility + * @tc.type: FUNC + */ +HWTEST_F(AbilityManagerClientTest, ResumeExtensionAbility_0100, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "ResumeExtensionAbility_0100 start"); + sptr connect = sptr::MakeSptr(); + auto result = AbilityManagerClient::GetInstance()->ResumeExtensionAbility(connect); + EXPECT_EQ(result, ERR_OK); + TAG_LOGI(AAFwkTag::TEST, "ResumeExtensionAbility_0100 end"); +} } // namespace AAFwk } // namespace OHOS \ No newline at end of file diff --git a/test/unittest/ability_connect_manager_first_test/ability_connect_manager_first_test.cpp b/test/unittest/ability_connect_manager_first_test/ability_connect_manager_first_test.cpp index 831df63efd8..8821cf55563 100644 --- a/test/unittest/ability_connect_manager_first_test/ability_connect_manager_first_test.cpp +++ b/test/unittest/ability_connect_manager_first_test/ability_connect_manager_first_test.cpp @@ -945,5 +945,65 @@ HWTEST_F(AbilityConnectManagerTest, HandleActiveAbility_005, TestSize.Level1) EXPECT_NE(targetService->GetWant().GetStringParam(PARAM_RESV_CALLER_APP_ID), "app"); TAG_LOGI(AAFwkTag::TEST, "HandleActiveAbility_005 end"); } + +/* + * Feature: AbilityConnectManager + * Function: SuspendExtensionAbilityLocked + */ +HWTEST_F(AbilityConnectManagerTest, SuspendExtensionAbilityLocked_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "SuspendExtensionAbilityLocked start"); + std::shared_ptr connectManager = std::make_shared(0); + EXPECT_NE(connectManager, nullptr); + + auto result = connectManager->SuspendExtensionAbilityLocked(callbackA_); + EXPECT_EQ(result, OHOS::AAFwk::CONNECTION_NOT_EXIST); + + result = connectManager->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr); + EXPECT_EQ(0, result); + + result = connectManager->SuspendExtensionAbilityLocked(callbackA_); + EXPECT_EQ(result, OHOS::AAFwk::INVALID_CONNECTION_STATE); + + auto list = connectManager->GetConnectRecordListByCallback(callbackA_); + EXPECT_EQ(static_cast(list.size()), 1); + + for (auto& it : list) { + it->SetConnectState(ConnectionState::CONNECTED); + } + + auto result3 = connectManager->SuspendExtensionAbilityLocked(callbackA_); + EXPECT_EQ(result3, OHOS::ERR_OK); + TAG_LOGI(AAFwkTag::TEST, "SuspendExtensionAbilityLocked end"); +} + +/* + * Feature: AbilityConnectManager + * Function: ResumeExtensionAbilityLocked + */ +HWTEST_F(AbilityConnectManagerTest, ResumeExtensionAbilityLocked_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "ResumeExtensionAbilityLocked start"); + std::shared_ptr connectManager = std::make_shared(0); + EXPECT_NE(connectManager, nullptr); + + auto result = connectManager->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr); + EXPECT_EQ(0, result); + + result = connectManager->ResumeExtensionAbilityLocked(callbackA_); + EXPECT_EQ(result, OHOS::AAFwk::INVALID_CONNECTION_STATE); + + auto list = connectManager->GetConnectRecordListByCallback(callbackA_); + EXPECT_EQ(static_cast(list.size()), 1); + + for (auto& it : list) { + it->SetConnectState(ConnectionState::CONNECTED); + } + + connectManager->SuspendExtensionAbilityLocked(callbackA_); + result = connectManager->ResumeExtensionAbilityLocked(callbackA_); + EXPECT_EQ(result, OHOS::ERR_OK); + TAG_LOGI(AAFwkTag::TEST, "ResumeExtensionAbilityLocked end"); +} } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/ability_manager_service_twelfth_test/ability_manager_service_twelfth_test.cpp b/test/unittest/ability_manager_service_twelfth_test/ability_manager_service_twelfth_test.cpp index a6c7632e490..7df9acbdff9 100644 --- a/test/unittest/ability_manager_service_twelfth_test/ability_manager_service_twelfth_test.cpp +++ b/test/unittest/ability_manager_service_twelfth_test/ability_manager_service_twelfth_test.cpp @@ -1220,5 +1220,28 @@ HWTEST_F(AbilityManagerServiceTwelfthTest, ResumeExtensionAbility_001, TestSize. TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest ResumeExtensionAbility_001 end"); } + +/* + * Feature: AbilityManagerService + * Function: HandleExtensionAbility + * SubFunction: NA + * FunctionPoints: AbilityManagerService HandleExtensionAbility + */ +HWTEST_F(AbilityManagerServiceTwelfthTest, HandleExtensionAbility_001, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest HandleExtensionAbility_001 start"); + auto abilityMs_ = std::make_shared(); + sptr connect = nullptr; + + EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect, + [](std::shared_ptr connectManager, sptr connect) { + return connectManager->ResumeExtensionAbilityLocked(connect);}), ERR_INVALID_VALUE); + + connect = new AbilityConnectCallback(); + EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect, + [](std::shared_ptr connectManager, sptr connect) { + return connectManager->ResumeExtensionAbilityLocked(connect);}), ERR_NO_INIT); + TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest HandleExtensionAbility_001 end"); +} } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/ability_manager_stub_second_test/ability_manager_stub_second_test.cpp b/test/unittest/ability_manager_stub_second_test/ability_manager_stub_second_test.cpp index 8356fd11feb..f939c0739c7 100644 --- a/test/unittest/ability_manager_stub_second_test/ability_manager_stub_second_test.cpp +++ b/test/unittest/ability_manager_stub_second_test/ability_manager_stub_second_test.cpp @@ -940,6 +940,25 @@ HWTEST_F(AbilityManagerStubSecondTest, SuspendExtensionAbilityInner_001, TestSiz EXPECT_TRUE(stub_ != nullptr); } +/* + * Feature: AbilityManagerService + * Function: SuspendExtensionAbilityInner + * SubFunction: NA + * FunctionPoints: AbilityManagerService SuspendExtensionAbilityInner + * EnvConditions: NA + * CaseDescription: Verify the function SuspendExtensionAbilityInner is normal flow. + */ +HWTEST_F(AbilityManagerStubSecondTest, SuspendExtensionAbilityInner_002, TestSize.Level1) +{ + MessageParcel data; + MessageParcel reply; + sptr connect = new AbilityConnectCallback(); + WriteInterfaceToken(data); + data.WriteParcelable(connect->AsObject()); + stub_->SuspendExtensionAbilityInner(data, reply); + EXPECT_TRUE(stub_ != nullptr); +} + /* * Feature: AbilityManagerService * Function: ResumeExtensionAbilityInner @@ -955,5 +974,24 @@ HWTEST_F(AbilityManagerStubSecondTest, ResumeExtensionAbilityInner_001, TestSize stub_->ResumeExtensionAbilityInner(data, reply); EXPECT_TRUE(stub_ != nullptr); } + +/* + * Feature: AbilityManagerService + * Function: ResumeExtensionAbilityInner + * SubFunction: NA + * FunctionPoints: AbilityManagerService ResumeExtensionAbilityInner + * EnvConditions: NA + * CaseDescription: Verify the function ResumeExtensionAbilityInner is normal flow. + */ +HWTEST_F(AbilityManagerStubSecondTest, ResumeExtensionAbilityInner_002, TestSize.Level1) +{ + MessageParcel data; + MessageParcel reply; + sptr connect = new AbilityConnectCallback(); + WriteInterfaceToken(data); + data.WriteParcelable(connect->AsObject()); + stub_->ResumeExtensionAbilityInner(data, reply); + EXPECT_TRUE(stub_ != nullptr); +} } // namespace AAFwk } // namespace OHOS diff --git a/test/unittest/connection_observer_test/connection_observer_test.cpp b/test/unittest/connection_observer_test/connection_observer_test.cpp index 79f927e6f12..6c038867e41 100644 --- a/test/unittest/connection_observer_test/connection_observer_test.cpp +++ b/test/unittest/connection_observer_test/connection_observer_test.cpp @@ -23,6 +23,7 @@ #include "connection_data.h" #include "connection_observer_client.h" #include "connection_observer_client_impl.h" +#include "connection_observer_stub_impl.h" #ifdef WITH_DLP #include "dlp_state_data.h" #endif // WITH_DLP @@ -329,6 +330,92 @@ HWTEST_F(ConnectionObserverTest, ConnectionObserver_Observer_0200, TestSize.Leve SetSelfTokenID(currentID); TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0200 end"); } + +/** + * @tc.name: ConnectionObserver_Observer_0300 + * @tc.desc: test observer callback. + * @tc.type: FUNC + * @tc.require: issueI58213 + */ +HWTEST_F(ConnectionObserverTest, ConnectionObserver_Observer_0300, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0300 start"); + + auto clientImpl = ConnectionObserverClient::GetInstance().clientImpl_; + EXPECT_TRUE(clientImpl); + + std::shared_ptr myObserver = nullptr; + clientImpl->userObservers_.emplace(myObserver); + ConnectionData connectionData; + clientImpl->HandleExtensionSuspended(connectionData); + clientImpl->HandleExtensionResumed(connectionData); + + TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0300 end"); +} + +/** + * @tc.name: ConnectionObserver_Observer_0400 + * @tc.desc: test observer callback. + * @tc.type: FUNC + * @tc.require: issueI58213 + */ +HWTEST_F(ConnectionObserverTest, ConnectionObserver_Observer_0400, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0400 start"); + + auto clientImpl = ConnectionObserverClient::GetInstance().clientImpl_; + EXPECT_TRUE(clientImpl); + ConnectionObserverStubImpl connectionObserverStubImpl(clientImpl); + + MessageParcel data; + MessageParcel reply; + MessageOption option; + connectionObserverStubImpl.OnRemoteRequest( + IConnectionObserver::ON_EXTENSION_SUSPENDED, data, reply, option); + connectionObserverStubImpl.OnRemoteRequest( + IConnectionObserver::ON_EXTENSION_RESUMED, data, reply, option); + + ConnectionData connectionData; + connectionData.extensionPid = TEST_PID; + connectionData.extensionUid = TEST_UID; + connectionData.extensionBundleName = TEST_BUNDLE_NAME; + connectionData.extensionModuleName = TEST_MODULE_NAME; + connectionData.extensionName = TEST_ABILITY_NAME; + connectionData.extensionType = OHOS::AppExecFwk::ExtensionAbilityType::SERVICE; + connectionData.callerPid = TEST_CALLER_PID; + connectionData.callerUid = TEST_CALLER_UID; + connectionData.callerName = TEST_CALLER_NAME; + + EXPECT_TRUE(connectionData.Marshalling(data)); + connectionObserverStubImpl.OnRemoteRequest( + IConnectionObserver::ON_EXTENSION_SUSPENDED, data, reply, option); + connectionObserverStubImpl.OnRemoteRequest( + IConnectionObserver::ON_EXTENSION_RESUMED, data, reply, option); + + TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0400 end"); +} + +/** + * @tc.name: ConnectionObserver_Observer_0500 + * @tc.desc: test observer callback. + * @tc.type: FUNC + * @tc.require: issueI58213 + */ +HWTEST_F(ConnectionObserverTest, ConnectionObserver_Observer_0500, TestSize.Level1) +{ + TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0500 start"); + + auto clientImpl = ConnectionObserverClient::GetInstance().clientImpl_; + EXPECT_TRUE(clientImpl); + + ConnectionObserverStubImpl connectionObserverStubImpl(nullptr); + + ConnectionData connectionData; + connectionObserverStubImpl.OnExtensionSuspended(connectionData); + connectionObserverStubImpl.OnExtensionResumed(connectionData); + + TAG_LOGI(AAFwkTag::TEST, "ConnectionObserver_Observer_0500 end"); +} #endif // WITH_DLP } // namespace AbilityRuntime } // namespace OHOS diff --git a/test/unittest/connection_state_item_test/connection_state_item_test.cpp b/test/unittest/connection_state_item_test/connection_state_item_test.cpp index 68cc95bb2dd..800a2ba42b2 100755 --- a/test/unittest/connection_state_item_test/connection_state_item_test.cpp +++ b/test/unittest/connection_state_item_test/connection_state_item_test.cpp @@ -49,6 +49,7 @@ public: std::shared_ptr Init(); std::shared_ptr InitAbilityRecord(); std::shared_ptr InitDataAbilityRecord(); + std::shared_ptr InitAbilityRecord1(); }; void ConnectionStateItemTest::SetUpTestCase(void) @@ -74,6 +75,16 @@ std::shared_ptr ConnectionStateItemTest::InitAbilityRecord() abilityRequest.abilityInfo.type = AbilityType::PAGE; return AbilityRecord::CreateAbilityRecord(abilityRequest); } + +std::shared_ptr ConnectionStateItemTest::InitAbilityRecord1() +{ + AbilityRequest abilityRequest; + abilityRequest.appInfo.bundleName = "com.example.unittest1"; + abilityRequest.abilityInfo.name = "MainAbility1"; + abilityRequest.abilityInfo.type = AbilityType::PAGE; + return AbilityRecord::CreateAbilityRecord(abilityRequest); +} + std::shared_ptr ConnectionStateItemTest::InitDataAbilityRecord() { AbilityRequest abilityRequest; @@ -388,6 +399,141 @@ HWTEST_F(ConnectionStateItemTest, RemoveConnection_007, TestSize.Level1) EXPECT_TRUE(res); } +/* + * Feature: ConnectionStateItem + * Function: RemoveConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateItem RemoveConnection + * EnvConditions: NA + * CaseDescription: Verify RemoveConnection + */ +HWTEST_F(ConnectionStateItemTest, RemoveConnection_008, TestSize.Level1) +{ + auto connectionStateItem = Init(); + std::shared_ptr abilityRecord = InitAbilityRecord(); + sptr connCallback = new MyAbilityConnection(); + std::shared_ptr record = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback, nullptr); + ConnectionData data; + ConnectionEvent event; + connectionStateItem->AddConnection(record, data, event); + sptr connCallback1 = new MyAbilityConnection(); + std::shared_ptr record1 = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback1, nullptr); + connectionStateItem->AddConnection(record, data, event); + connectionStateItem->SuspendConnection(record, data); + connectionStateItem->SuspendConnection(record, data); + auto res = connectionStateItem->RemoveConnection(record, data, event); + EXPECT_TRUE(res); +} + +/* + * Feature: ConnectionStateItem + * Function: RemoveConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateItem RemoveConnection + * EnvConditions: NA + * CaseDescription: Verify RemoveConnection + */ +HWTEST_F(ConnectionStateItemTest, RemoveConnection_009, TestSize.Level1) +{ + auto connectionStateItem = Init(); + std::shared_ptr abilityRecord = InitAbilityRecord(); + sptr connCallback = new MyAbilityConnection(); + std::shared_ptr record = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback, nullptr); + ConnectionData data; + ConnectionEvent event; + connectionStateItem->AddConnection(record, data, event); + sptr connCallback1 = new MyAbilityConnection(); + std::shared_ptr record1 = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback1, nullptr); + connectionStateItem->AddConnection(record1, data, event); + connectionStateItem->SuspendConnection(record, data); + auto res = connectionStateItem->RemoveConnection(record1, data, event); + EXPECT_TRUE(res); +} + +/* + * Feature: ConnectionStateItem + * Function: RemoveConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateItem RemoveConnection + * EnvConditions: NA + * CaseDescription: Verify RemoveConnection + */ +HWTEST_F(ConnectionStateItemTest, RemoveConnection_010, TestSize.Level1) +{ + auto connectionStateItem = Init(); + std::shared_ptr abilityRecord = InitAbilityRecord(); + sptr connCallback = new MyAbilityConnection(); + std::shared_ptr record = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback, nullptr); + ConnectionData data; + ConnectionEvent event; + connectionStateItem->AddConnection(record, data, event); + sptr connCallback1 = new MyAbilityConnection(); + std::shared_ptr record1 = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback1, nullptr); + connectionStateItem->AddConnection(record1, data, event); + auto res = connectionStateItem->RemoveConnection(record1, data, event); + EXPECT_FALSE(res); +} + +/* + * Feature: ConnectionStateItem + * Function: RemoveConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateItem RemoveConnection + * EnvConditions: NA + * CaseDescription: Verify RemoveConnection + */ +HWTEST_F(ConnectionStateItemTest, RemoveConnection_011, TestSize.Level1) +{ + auto connectionStateItem = Init(); + std::shared_ptr abilityRecord = InitAbilityRecord(); + sptr connCallback = new MyAbilityConnection(); + std::shared_ptr record = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback, nullptr); + ConnectionData data; + ConnectionEvent event; + connectionStateItem->AddConnection(record, data, event); + sptr connCallback1 = new MyAbilityConnection(); + std::shared_ptr record1 = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback1, nullptr); + connectionStateItem->AddConnection(record1, data, event); + connectionStateItem->SuspendConnection(record, data); + auto res = connectionStateItem->RemoveConnection(record, data, event); + EXPECT_FALSE(res); +} + +/* + * Feature: ConnectionStateItem + * Function: RemoveConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateItem RemoveConnection + * EnvConditions: NA + * CaseDescription: Verify RemoveConnection + */ +HWTEST_F(ConnectionStateItemTest, RemoveConnection_012, TestSize.Level1) +{ + auto connectionStateItem = Init(); + std::shared_ptr abilityRecord = InitAbilityRecord(); + sptr connCallback = new MyAbilityConnection(); + std::shared_ptr record = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback, nullptr); + ConnectionData data; + ConnectionEvent event; + connectionStateItem->AddConnection(record, data, event); + sptr connCallback1 = new MyAbilityConnection(); + std::shared_ptr record1 = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback1, nullptr); + connectionStateItem->AddConnection(record1, data, event); + connectionStateItem->SuspendConnection(record, data); + auto res = connectionStateItem->RemoveConnection(record1, data, event); + EXPECT_FALSE(res); +} + /* * Feature: ConnectionStateItem * Function: SuspendConnection @@ -450,6 +596,68 @@ HWTEST_F(ConnectionStateItemTest, SuspendConnection_003, TestSize.Level1) EXPECT_FALSE(res); } +/* + * Feature: ConnectionStateItem + * Function: SuspendConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateItem SuspendConnection + * EnvConditions: NA + * CaseDescription: Verify SuspendConnection + */ +HWTEST_F(ConnectionStateItemTest, SuspendConnection_004, TestSize.Level1) +{ + auto connectionStateItem = Init(); + std::shared_ptr abilityRecord = InitAbilityRecord(); + std::shared_ptr record = std::make_shared( + abilityRecord->GetToken(), abilityRecord, nullptr, nullptr); + ConnectionData data; + auto res = connectionStateItem->SuspendConnection(record, data); + EXPECT_FALSE(res); +} + +/* + * Feature: ConnectionStateItem + * Function: SuspendConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateItem SuspendConnection + * EnvConditions: NA + * CaseDescription: Verify SuspendConnection + */ +HWTEST_F(ConnectionStateItemTest, SuspendConnection_005, TestSize.Level1) +{ + auto connectionStateItem = Init(); + std::shared_ptr abilityRecord = InitAbilityRecord(); + sptr connCallback = new MyAbilityConnection(); + std::shared_ptr record = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback, nullptr); + ConnectionData data; + auto res = connectionStateItem->SuspendConnection(record, data); + EXPECT_FALSE(res); +} + +/* + * Feature: ConnectionStateItem + * Function: SuspendConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateItem SuspendConnection + * EnvConditions: NA + * CaseDescription: Verify SuspendConnection + */ +HWTEST_F(ConnectionStateItemTest, SuspendConnection_006, TestSize.Level1) +{ + auto connectionStateItem = Init(); + std::shared_ptr abilityRecord = InitAbilityRecord(); + sptr connCallback = new MyAbilityConnection(); + std::shared_ptr record = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback, nullptr); + ConnectionData data; + ConnectionEvent event; + connectionStateItem->AddConnection(record, data, event); + connectionStateItem->connectionMap_[abilityRecord->GetToken()] = nullptr; + auto res = connectionStateItem->SuspendConnection(record, data); + EXPECT_FALSE(res); +} + /* * Feature: ConnectionStateItem * Function: ResumeConnection @@ -521,6 +729,92 @@ HWTEST_F(ConnectionStateItemTest, ResumeConnection_003, TestSize.Level1) * CaseDescription: Verify ResumeConnection */ HWTEST_F(ConnectionStateItemTest, ResumeConnection_004, TestSize.Level1) +{ + auto connectionStateItem = Init(); + std::shared_ptr abilityRecord = InitAbilityRecord(); + std::shared_ptr record = std::make_shared( + abilityRecord->GetToken(), abilityRecord, nullptr, nullptr); + ConnectionData data; + auto res = connectionStateItem->ResumeConnection(record, data); + EXPECT_FALSE(res); +} + +/* + * Feature: ConnectionStateItem + * Function: ResumeConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateItem ResumeConnection + * EnvConditions: NA + * CaseDescription: Verify ResumeConnection + */ +HWTEST_F(ConnectionStateItemTest, ResumeConnection_005, TestSize.Level1) +{ + auto connectionStateItem = Init(); + std::shared_ptr abilityRecord = InitAbilityRecord(); + sptr connCallback = new MyAbilityConnection(); + std::shared_ptr record = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback, nullptr); + ConnectionData data; + ConnectionEvent event; + connectionStateItem->AddConnection(record, data, event); + connectionStateItem->SuspendConnection(record, data); + connectionStateItem->ResumeConnection(record, data); + auto res = connectionStateItem->ResumeConnection(record, data); + EXPECT_FALSE(res); +} + +/* + * Feature: ConnectionStateItem + * Function: ResumeConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateItem ResumeConnection + * EnvConditions: NA + * CaseDescription: Verify ResumeConnection + */ +HWTEST_F(ConnectionStateItemTest, ResumeConnection_006, TestSize.Level1) +{ + auto connectionStateItem = Init(); + std::shared_ptr abilityRecord = InitAbilityRecord(); + sptr connCallback = new MyAbilityConnection(); + std::shared_ptr record = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback, nullptr); + ConnectionData data; + auto res = connectionStateItem->ResumeConnection(record, data); + EXPECT_FALSE(res); +} + +/* + * Feature: ConnectionStateItem + * Function: ResumeConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateItem ResumeConnection + * EnvConditions: NA + * CaseDescription: Verify ResumeConnection + */ +HWTEST_F(ConnectionStateItemTest, ResumeConnection_007, TestSize.Level1) +{ + auto connectionStateItem = Init(); + std::shared_ptr abilityRecord = InitAbilityRecord(); + sptr connCallback = new MyAbilityConnection(); + std::shared_ptr record = std::make_shared( + abilityRecord->GetToken(), abilityRecord, connCallback, nullptr); + ConnectionData data; + ConnectionEvent event; + connectionStateItem->AddConnection(record, data, event); + connectionStateItem->connectionMap_[abilityRecord->GetToken()] = nullptr; + auto res = connectionStateItem->ResumeConnection(record, data); + EXPECT_FALSE(res); +} + +/* + * Feature: ConnectionStateItem + * Function: ResumeConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateItem ResumeConnection + * EnvConditions: NA + * CaseDescription: Verify ResumeConnection + */ +HWTEST_F(ConnectionStateItemTest, ResumeConnection_008, TestSize.Level1) { auto connectionStateItem = Init(); std::shared_ptr abilityRecord = InitAbilityRecord(); diff --git a/test/unittest/connection_state_manager_test/connection_state_manager_test.cpp b/test/unittest/connection_state_manager_test/connection_state_manager_test.cpp index 12f37a259bf..400c33aa84b 100755 --- a/test/unittest/connection_state_manager_test/connection_state_manager_test.cpp +++ b/test/unittest/connection_state_manager_test/connection_state_manager_test.cpp @@ -232,6 +232,61 @@ HWTEST_F(ConnectionStateManagerTest, SuspendConnection_002, TestSize.Level1) EXPECT_TRUE(manager_ != nullptr); } +/* + * Feature: ConnectionStateManager + * Function: SuspendConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateManager SuspendConnection + * EnvConditions: NA + * CaseDescription: Verify SuspendConnection + */ +HWTEST_F(ConnectionStateManagerTest, SuspendConnection_003, TestSize.Level1) +{ + auto connectionRecord = + ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr); + manager_->Init(); + connectionRecord->callerPid_ = 0; + manager_->connectionStates_[0] = nullptr; + manager_->SuspendConnection(connectionRecord); + EXPECT_TRUE(manager_ != nullptr); +} + +/* + * Feature: ConnectionStateManager + * Function: SuspendConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateManager SuspendConnection + * EnvConditions: NA + * CaseDescription: Verify SuspendConnection + */ +HWTEST_F(ConnectionStateManagerTest, SuspendConnection_004, TestSize.Level1) +{ + auto connectionRecord = + ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr); + manager_->Init(); + connectionRecord->callerPid_ = 0; + manager_->SuspendConnection(connectionRecord); + EXPECT_TRUE(manager_ != nullptr); +} + +/* + * Feature: ConnectionStateManager + * Function: SuspendConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateManager SuspendConnection + * EnvConditions: NA + * CaseDescription: Verify SuspendConnection + */ +HWTEST_F(ConnectionStateManagerTest, SuspendConnection_005, TestSize.Level1) +{ + auto connectionRecord = + ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr); + manager_->Init(); + connectionRecord->callerPid_ = 0; + manager_->SuspendConnection(connectionRecord); + EXPECT_TRUE(manager_ != nullptr); +} + /* * Feature: ConnectionStateManager * Function: ResumeConnection @@ -274,6 +329,43 @@ HWTEST_F(ConnectionStateManagerTest, ResumeConnection_002, TestSize.Level1) EXPECT_TRUE(manager_ != nullptr); } +/* + * Feature: ConnectionStateManager + * Function: ResumeConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateManager ResumeConnection + * EnvConditions: NA + * CaseDescription: Verify ResumeConnection + */ +HWTEST_F(ConnectionStateManagerTest, ResumeConnection_003, TestSize.Level1) +{ + std::shared_ptr connectionRecord = + ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr); + manager_->Init(); + connectionRecord->callerPid_ = 0; + manager_->ResumeConnection(connectionRecord); + EXPECT_TRUE(manager_ != nullptr); +} + +/* + * Feature: ConnectionStateManager + * Function: ResumeConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateManager ResumeConnection + * EnvConditions: NA + * CaseDescription: Verify ResumeConnection + */ +HWTEST_F(ConnectionStateManagerTest, ResumeConnection_004, TestSize.Level1) +{ + std::shared_ptr connectionRecord = + ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr); + manager_->Init(); + connectionRecord->callerPid_ = 0; + manager_->connectionStates_[0] = nullptr; + manager_->ResumeConnection(connectionRecord); + EXPECT_TRUE(manager_ != nullptr); +} + /* * Feature: ConnectionStateManager * Function: RemoveConnection @@ -343,6 +435,25 @@ HWTEST_F(ConnectionStateManagerTest, RemoveConnection_004, TestSize.Level1) EXPECT_TRUE(manager_ != nullptr); } +/* + * Feature: ConnectionStateManager + * Function: RemoveConnection + * SubFunction: NA + * FunctionPoints: ConnectionStateManager RemoveConnection + * EnvConditions: NA + * CaseDescription: Verify RemoveConnection + */ +HWTEST_F(ConnectionStateManagerTest, RemoveConnection_005, TestSize.Level1) +{ + std::shared_ptr connectionRecord = + ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr); + bool isCallerDied = false; + manager_->Init(); + manager_->AddConnection(connectionRecord); + manager_->RemoveConnection(connectionRecord, isCallerDied); + EXPECT_TRUE(manager_ != nullptr); +} + /* * Feature: ConnectionStateManager * Function: AddDataAbilityConnection -- Gitee