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 2c46026297ae97e5809698b35f2db15dae2e689f..b9d0f018ca04112e7fb3bf81ca35662e5462f7be 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
@@ -1358,7 +1358,250 @@ HWTEST_F(AbilityManagerServiceTwelfthTest, HandleExtensionAbility_001, TestSize.
     EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect,
         [](std::shared_ptr<AbilityConnectManager> connectManager, sptr<IAbilityConnection> connect) {
             return connectManager->ResumeExtensionAbilityLocked(connect);}), ERR_NO_INIT);
+
+    abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
+    IPCSkeleton::SetCallingUid(BASE_USER_RANGE);
+    std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(ONE);
+    EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect,
+        [](std::shared_ptr<AbilityConnectManager> connectManager, sptr<IAbilityConnection> connect) {
+            return connectManager->ResumeExtensionAbilityLocked(connect);}), ERR_NO_INIT);
+
+    abilityMs_->subManagersHelper_->currentConnectManager_ = connectManager;
+    std::shared_ptr<AbilityConnectManager> connectManager2 = std::make_shared<AbilityConnectManager>(TWO);
+    abilityMs_->subManagersHelper_->connectManagers_.insert(std::make_pair(0, connectManager2));
+    EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect,
+        [](std::shared_ptr<AbilityConnectManager> connectManager, sptr<IAbilityConnection> connect) {
+            return connectManager->ResumeExtensionAbilityLocked(connect);}), ERR_NO_INIT);
+
+    abilityMs_->subManagersHelper_->connectManagers_.insert(std::make_pair(1, connectManager2));
+    EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect,
+        [](std::shared_ptr<AbilityConnectManager> connectManager, sptr<IAbilityConnection> connect) {
+            return connectManager->ResumeExtensionAbilityLocked(connect);}), CONNECTION_NOT_EXIST);
+
+    abilityMs_->subManagersHelper_->connectManagers_.insert(std::make_pair(2, connectManager2));
+    EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect,
+        [](std::shared_ptr<AbilityConnectManager> connectManager, sptr<IAbilityConnection> connect) {
+            return connectManager->ResumeExtensionAbilityLocked(connect);}), CONNECTION_NOT_EXIST);
+
+    IPCSkeleton::SetCallingUid(RESOURCE_SCHEDULE_UID);
+    abilityMs_->subManagersHelper_->connectManagers_.insert(std::make_pair(RESOURCE_SCHEDULE_UID, connectManager2));
+    EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect,
+        [](std::shared_ptr<AbilityConnectManager> connectManager, sptr<IAbilityConnection> connect) {
+            return connectManager->ResumeExtensionAbilityLocked(connect);}), CONNECTION_NOT_EXIST);
+
     TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest HandleExtensionAbility_001 end");
 }
+
+/*
+ * Feature: AbilityManagerService
+ * Function: HandleExtensionAbility
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService HandleExtensionAbility
+ */
+HWTEST_F(AbilityManagerServiceTwelfthTest, HandleExtensionAbility_002, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest HandleExtensionAbility_002 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    auto connect = new AbilityConnectCallback();
+
+    abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
+
+    IPCSkeleton::SetCallingUid(BASE_USER_RANGE);
+    AbilityRequest abilityRequest{};
+    std::string deviceName = "device";
+    std::string abilityName = "ServiceAbility";
+    std::string appName = "hiservcie";
+    std::string bundleName = "com.ix.hiservcie";
+    std::string moduleName = "entry";
+    abilityRequest = GenerateAbilityRequest(deviceName, abilityName, appName, bundleName, moduleName);
+    std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
+    EXPECT_NE(connectManager, nullptr);
+    auto result = connectManager->ConnectAbilityLocked(abilityRequest, connect, nullptr);
+    EXPECT_EQ(0, result);
+    auto list = connectManager->GetConnectRecordListByCallback(connect);
+    EXPECT_EQ(static_cast<int>(list.size()), 1);
+
+    for (auto& it : list) {
+        it->SetConnectState(ConnectionState::CONNECTED);
+    }
+    abilityMs_->subManagersHelper_->currentConnectManager_ = connectManager;
+    EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect,
+        [](std::shared_ptr<AbilityConnectManager> connectManager, sptr<IAbilityConnection> connect) {
+            return connectManager->SuspendExtensionAbilityLocked(connect);}), ERR_OK);
+
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest HandleExtensionAbility_002 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Function: HandleExtensionAbility
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService HandleExtensionAbility
+ */
+HWTEST_F(AbilityManagerServiceTwelfthTest, HandleExtensionAbility_003, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest HandleExtensionAbility_003 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    auto connect = new AbilityConnectCallback();
+
+    abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
+
+    abilityMs_->subManagersHelper_->currentConnectManager_ = std::make_shared<AbilityConnectManager>(ONE);
+    AbilityRequest abilityRequest{};
+    std::string deviceName = "device";
+    std::string abilityName = "ServiceAbility";
+    std::string appName = "hiservcie";
+    std::string bundleName = "com.ix.hiservcie";
+    std::string moduleName = "entry";
+    abilityRequest = GenerateAbilityRequest(deviceName, abilityName, appName, bundleName, moduleName);
+    std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
+    EXPECT_NE(connectManager, nullptr);
+    auto result = connectManager->ConnectAbilityLocked(abilityRequest, connect, nullptr);
+    EXPECT_EQ(0, result);
+    auto list = connectManager->GetConnectRecordListByCallback(connect);
+    EXPECT_EQ(static_cast<int>(list.size()), 1);
+
+    for (auto& it : list) {
+        it->SetConnectState(ConnectionState::CONNECTED);
+    }
+    abilityMs_->subManagersHelper_->connectManagers_.insert(std::make_pair(0, connectManager));
+    EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect,
+        [](std::shared_ptr<AbilityConnectManager> connectManager, sptr<IAbilityConnection> connect) {
+            return connectManager->SuspendExtensionAbilityLocked(connect);}), ERR_OK);
+
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest HandleExtensionAbility_003 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Function: HandleExtensionAbility
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService HandleExtensionAbility
+ */
+HWTEST_F(AbilityManagerServiceTwelfthTest, HandleExtensionAbility_004, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest HandleExtensionAbility_004 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    auto connect = new AbilityConnectCallback();
+
+    abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
+
+    abilityMs_->subManagersHelper_->currentConnectManager_ = std::make_shared<AbilityConnectManager>(ONE);
+    abilityMs_->subManagersHelper_->connectManagers_.insert(
+        std::make_pair(0, std::make_shared<AbilityConnectManager>(0)));
+    AbilityRequest abilityRequest{};
+    std::string deviceName = "device";
+    std::string abilityName = "ServiceAbility";
+    std::string appName = "hiservcie";
+    std::string bundleName = "com.ix.hiservcie";
+    std::string moduleName = "entry";
+    abilityRequest = GenerateAbilityRequest(deviceName, abilityName, appName, bundleName, moduleName);
+    std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(1);
+    EXPECT_NE(connectManager, nullptr);
+    auto result = connectManager->ConnectAbilityLocked(abilityRequest, connect, nullptr);
+    EXPECT_EQ(0, result);
+    auto list = connectManager->GetConnectRecordListByCallback(connect);
+    EXPECT_EQ(static_cast<int>(list.size()), 1);
+
+    for (auto& it : list) {
+        it->SetConnectState(ConnectionState::CONNECTED);
+    }
+    abilityMs_->subManagersHelper_->connectManagers_.insert(std::make_pair(1, connectManager));
+    EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect,
+        [](std::shared_ptr<AbilityConnectManager> connectManager, sptr<IAbilityConnection> connect) {
+            return connectManager->SuspendExtensionAbilityLocked(connect);}), ERR_OK);
+
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest HandleExtensionAbility_004 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Function: HandleExtensionAbility
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService HandleExtensionAbility
+ */
+HWTEST_F(AbilityManagerServiceTwelfthTest, HandleExtensionAbility_005, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest HandleExtensionAbility_005 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    auto connect = new AbilityConnectCallback();
+
+    abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
+
+    IPCSkeleton::SetCallingUid(BASE_USER_RANGE);
+    abilityMs_->subManagersHelper_->currentConnectManager_ = std::make_shared<AbilityConnectManager>(ONE);
+    abilityMs_->subManagersHelper_->connectManagers_.insert(
+        std::make_pair(0, std::make_shared<AbilityConnectManager>(0)));
+    abilityMs_->subManagersHelper_->connectManagers_.insert(
+        std::make_pair(1, std::make_shared<AbilityConnectManager>(1)));
+    AbilityRequest abilityRequest{};
+    std::string deviceName = "device";
+    std::string abilityName = "ServiceAbility";
+    std::string appName = "hiservcie";
+    std::string bundleName = "com.ix.hiservcie";
+    std::string moduleName = "entry";
+    abilityRequest = GenerateAbilityRequest(deviceName, abilityName, appName, bundleName, moduleName);
+    std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(1);
+    EXPECT_NE(connectManager, nullptr);
+    auto result = connectManager->ConnectAbilityLocked(abilityRequest, connect, nullptr);
+    EXPECT_EQ(0, result);
+    auto list = connectManager->GetConnectRecordListByCallback(connect);
+    EXPECT_EQ(static_cast<int>(list.size()), 1);
+
+    for (auto& it : list) {
+        it->SetConnectState(ConnectionState::CONNECTED);
+    }
+    abilityMs_->subManagersHelper_->connectManagers_.insert(std::make_pair(2, connectManager));
+    EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect,
+        [](std::shared_ptr<AbilityConnectManager> connectManager, sptr<IAbilityConnection> connect) {
+            return connectManager->SuspendExtensionAbilityLocked(connect);}), ERR_OK);
+
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest HandleExtensionAbility_005 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Function: HandleExtensionAbility
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService HandleExtensionAbility
+ */
+HWTEST_F(AbilityManagerServiceTwelfthTest, HandleExtensionAbility_006, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest HandleExtensionAbility_006 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    auto connect = new AbilityConnectCallback();
+
+    abilityMs_->subManagersHelper_ = std::make_shared<SubManagersHelper>(nullptr, nullptr);
+
+    IPCSkeleton::SetCallingUid(RESOURCE_SCHEDULE_UID);
+    abilityMs_->subManagersHelper_->currentConnectManager_ = std::make_shared<AbilityConnectManager>(ONE);
+    abilityMs_->subManagersHelper_->connectManagers_.insert(
+        std::make_pair(0, std::make_shared<AbilityConnectManager>(0)));
+    abilityMs_->subManagersHelper_->connectManagers_.insert(
+        std::make_pair(1, std::make_shared<AbilityConnectManager>(1)));
+    AbilityRequest abilityRequest{};
+    std::string deviceName = "device";
+    std::string abilityName = "ServiceAbility";
+    std::string appName = "hiservcie";
+    std::string bundleName = "com.ix.hiservcie";
+    std::string moduleName = "entry";
+    abilityRequest = GenerateAbilityRequest(deviceName, abilityName, appName, bundleName, moduleName);
+    std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(1);
+    EXPECT_NE(connectManager, nullptr);
+    auto result = connectManager->ConnectAbilityLocked(abilityRequest, connect, nullptr);
+    EXPECT_EQ(0, result);
+    auto list = connectManager->GetConnectRecordListByCallback(connect);
+    EXPECT_EQ(static_cast<int>(list.size()), 1);
+
+    for (auto& it : list) {
+        it->SetConnectState(ConnectionState::CONNECTED);
+    }
+    abilityMs_->subManagersHelper_->connectManagers_.insert(std::make_pair(RESOURCE_SCHEDULE_UID, connectManager));
+    EXPECT_EQ(abilityMs_->HandleExtensionAbility(connect,
+        [](std::shared_ptr<AbilityConnectManager> connectManager, sptr<IAbilityConnection> connect) {
+            return connectManager->SuspendExtensionAbilityLocked(connect);}), ERR_OK);
+
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceTwelfthTest HandleExtensionAbility_006 end");
+}
 } // namespace AAFwk
 } // namespace OHOS
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 e9a548a4a46b1e66abfbe9651f3392fc342a4c02..d1b6444bf17262191f2f95f74a3898238485fa8e 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
@@ -20,6 +20,7 @@
 #include "ability_connection.h"
 #include "ability_record.h"
 #include "connection_observer_errors.h"
+#include "mock_ability_connect_callback.h"
 #include "data_ability_record.h"
 #ifdef WITH_DLP
 #include "dlp_state_item.h"
@@ -37,6 +38,9 @@ public:
     static void TearDownTestCase(void);
     void SetUp();
     void TearDown();
+    AbilityRequest GenerateAbilityRequest(const std::string& deviceName,
+    const std::string& abilityName, const std::string& appName, const std::string& bundleName,
+    const std::string& moduleName);
     std::shared_ptr<ConnectionStateManager> manager_ {nullptr};
     std::shared_ptr<AbilityRecord> abilityRecord_ {nullptr};
     std::shared_ptr<DataAbilityRecord> dataAbilityRecord_ {nullptr};
@@ -76,6 +80,34 @@ void ConnectionStateManagerTest::SetUp()
     callback_ = new AbilityConnectionMock();
 }
 
+AbilityRequest ConnectionStateManagerTest::GenerateAbilityRequest(const std::string& deviceName,
+    const std::string& abilityName, const std::string& appName, const std::string& bundleName,
+    const std::string& moduleName)
+{
+    ElementName element(deviceName, bundleName, abilityName, moduleName);
+    Want want;
+    want.SetElement(element);
+
+    AbilityInfo abilityInfo;
+    abilityInfo.visible = true;
+    abilityInfo.applicationName = appName;
+    abilityInfo.type = AbilityType::SERVICE;
+    abilityInfo.name = abilityName;
+    abilityInfo.bundleName = bundleName;
+    abilityInfo.moduleName = moduleName;
+    abilityInfo.deviceId = deviceName;
+    ApplicationInfo appinfo;
+    appinfo.name = appName;
+    abilityInfo.applicationInfo = appinfo;
+    AbilityRequest abilityRequest;
+    abilityRequest.want = want;
+    abilityRequest.abilityInfo = abilityInfo;
+    abilityRequest.appInfo = appinfo;
+    abilityInfo.process = bundleName;
+
+    return abilityRequest;
+}
+
 /*
  * Feature: ConnectionStateManager
  * Function: RegisterObserver
@@ -193,6 +225,41 @@ HWTEST_F(ConnectionStateManagerTest, AddConnection_003, TestSize.Level1)
     EXPECT_TRUE(manager_ != nullptr);
 }
 
+/*
+ * Feature: ConnectionStateManager
+ * Function: AddConnection
+ * SubFunction: NA
+ * FunctionPoints: ConnectionStateManager AddConnection
+ * EnvConditions: NA
+ * CaseDescription: Verify AddConnection
+ */
+HWTEST_F(ConnectionStateManagerTest, AddConnection_004, TestSize.Level1)
+{
+    manager_->Init();
+    int32_t callerUid = 0;
+    int32_t callerPid = 0;
+    std::string callerName = "callerName";
+    manager_->connectionStates_[0] = std::make_shared<ConnectionStateItem>(callerUid, callerPid, callerName);
+    std::string deviceName = "device";
+    std::string abilityName = "ServiceAbility";
+    std::string appName = "hiservcie";
+    std::string bundleName = "com.ix.hiservcie";
+    std::string moduleName = "entry";
+    auto abilityRequest = GenerateAbilityRequest(deviceName, abilityName, appName, bundleName, moduleName);
+    auto serviceRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
+    auto callback = new AbilityConnectCallback();
+    auto connectionRecord = ConnectionRecord::CreateConnectionRecord(serviceRecord->GetToken(),
+        serviceRecord, callback, nullptr);
+    connectionRecord->callerPid_ = 0;
+    manager_->AddConnection(connectionRecord);
+    manager_->SuspendConnection(connectionRecord);
+    auto callback1 = new AbilityConnectCallback();
+    auto connectionRecord1 = ConnectionRecord::CreateConnectionRecord(serviceRecord->GetToken(),
+        serviceRecord, callback1, nullptr);
+    manager_->AddConnection(connectionRecord);
+    EXPECT_FALSE(manager_->connectionStates_.empty());
+}
+
 /*
  * Feature: ConnectionStateManager
  * Function: SuspendConnection