diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp
index d8f99214ddd8e73e413f6eb7e037214798e2f082..a436a3802f940c974a3b0d2c0ad30e923330e1fc 100644
--- a/services/abilitymgr/src/ability_manager_service.cpp
+++ b/services/abilitymgr/src/ability_manager_service.cpp
@@ -14610,6 +14610,10 @@ int32_t AbilityManagerService::HandleExtensionAbility(sptr<IAbilityConnection> c
 int AbilityManagerService::SuspendExtensionAbility(sptr<IAbilityConnection> 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,
@@ -14627,6 +14631,10 @@ int AbilityManagerService::SuspendExtensionAbility(sptr<IAbilityConnection> conn
 int AbilityManagerService::ResumeExtensionAbility(sptr<IAbilityConnection> 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 dd82a30d2b410501864e550f80631ef903bb7c27..c7a44e7ce3620286704c6b9713ad7594aaf521f9 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<sptr<IRemoteObject>, 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<sptr<IRemoteObject>, 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 b5a7832e7d282693f5d006a9f049df858839c747..8286f39e3383bfa78d478eb0a57265c43804adb8 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<IAbilityConnection> connect = sptr<MockIAbilityConnection>::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<IAbilityConnection> connect = sptr<MockIAbilityConnection>::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 831df63efd8a40f021f87b20bf2c33e4911cc0e5..8821cf55563323a08d77b137deb2f68c9fb2ee62 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<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(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<int>(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<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(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<int>(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 fd41e991ff4658b41fa747193a4d53e1627c361c..058de4c2026f24ba4cbe05d8f61ec19c935d655b 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
@@ -1276,5 +1276,28 @@ HWTEST_F(AbilityManagerServiceTwelfthTest, OnAbilityDied_001, TestSize.Level1)
     EXPECT_FALSE(abilityMs->VerificationToken(token));
     TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest OnAbilityDied_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<AbilityManagerService>();
+    sptr<IAbilityConnection> connect = nullptr;
+
+    EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect,
+        [](std::shared_ptr<AbilityConnectManager> connectManager, sptr<IAbilityConnection> connect) {
+            return connectManager->ResumeExtensionAbilityLocked(connect);}), ERR_INVALID_VALUE);
+
+    connect = new AbilityConnectCallback();
+    EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect,
+        [](std::shared_ptr<AbilityConnectManager> connectManager, sptr<IAbilityConnection> 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 8356fd11feb7c70fdf4d45075fce6df060547bde..f939c0739c7d74cbb1b0547e7f11982be859a986 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<IAbilityConnection> 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<IAbilityConnection> 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 79f927e6f12e2cb6dde6dda253cba9f18a5e5730..6c038867e41ea071765f07bd72a834ec26393a6d 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<MyConnectionObserver> 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 68cc95bb2ddbf57df9417b3328a6fee0bac0d184..800a2ba42b2eb7967daf99b527530de79ccfcf05 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<ConnectionStateItem> Init();
     std::shared_ptr<AbilityRecord> InitAbilityRecord();
     std::shared_ptr<DataAbilityRecord> InitDataAbilityRecord();
+    std::shared_ptr<AbilityRecord> InitAbilityRecord1();
 };
 
 void ConnectionStateItemTest::SetUpTestCase(void)
@@ -74,6 +75,16 @@ std::shared_ptr<AbilityRecord> ConnectionStateItemTest::InitAbilityRecord()
     abilityRequest.abilityInfo.type = AbilityType::PAGE;
     return AbilityRecord::CreateAbilityRecord(abilityRequest);
 }
+
+std::shared_ptr<AbilityRecord> 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<DataAbilityRecord> 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> abilityRecord = InitAbilityRecord();
+    sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
+        abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
+    ConnectionData data;
+    ConnectionEvent event;
+    connectionStateItem->AddConnection(record, data, event);
+    sptr<IAbilityConnection> connCallback1 = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record1 = std::make_shared<ConnectionRecord>(
+        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> abilityRecord = InitAbilityRecord();
+    sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
+        abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
+    ConnectionData data;
+    ConnectionEvent event;
+    connectionStateItem->AddConnection(record, data, event);
+    sptr<IAbilityConnection> connCallback1 = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record1 = std::make_shared<ConnectionRecord>(
+        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> abilityRecord = InitAbilityRecord();
+    sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
+        abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
+    ConnectionData data;
+    ConnectionEvent event;
+    connectionStateItem->AddConnection(record, data, event);
+    sptr<IAbilityConnection> connCallback1 = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record1 = std::make_shared<ConnectionRecord>(
+        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> abilityRecord = InitAbilityRecord();
+    sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
+        abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
+    ConnectionData data;
+    ConnectionEvent event;
+    connectionStateItem->AddConnection(record, data, event);
+    sptr<IAbilityConnection> connCallback1 = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record1 = std::make_shared<ConnectionRecord>(
+        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> abilityRecord = InitAbilityRecord();
+    sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
+        abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
+    ConnectionData data;
+    ConnectionEvent event;
+    connectionStateItem->AddConnection(record, data, event);
+    sptr<IAbilityConnection> connCallback1 = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record1 = std::make_shared<ConnectionRecord>(
+        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> abilityRecord = InitAbilityRecord();
+    std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
+        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> abilityRecord = InitAbilityRecord();
+    sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
+        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> abilityRecord = InitAbilityRecord();
+    sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
+        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> abilityRecord = InitAbilityRecord();
+    std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
+        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> abilityRecord = InitAbilityRecord();
+    sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
+        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> abilityRecord = InitAbilityRecord();
+    sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
+        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> abilityRecord = InitAbilityRecord();
+    sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
+    std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
+        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> 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 12f37a259bf0d827100156e11e09f88b5e14bdb7..400c33aa84b9619cf64f6f127b21e46764e11f00 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 =
+        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 =
+        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 =
+        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