diff --git a/interfaces/inner_api/ability_manager/include/ability_manager_interface.h b/interfaces/inner_api/ability_manager/include/ability_manager_interface.h
index 9dd2d0b8deb5e797c2c3139315363d6bd77f90ff..051d6df500483288f9bf5746e554ec2e9be2c096 100644
--- a/interfaces/inner_api/ability_manager/include/ability_manager_interface.h
+++ b/interfaces/inner_api/ability_manager/include/ability_manager_interface.h
@@ -305,14 +305,14 @@ public:
     }
 
     /**
-     * Start ui session ability with sourceWindowId and want.
+     * Start ui session ability with windowId and want.
      *
-     * @param primaryWindowId the id of sourceWindow.
+     * @param primaryWindowId the id of window.
      * @param secondaryWant the want of the ability to start.
      * @param callerToken current caller ability token.
      * @return Returns ERR_OK if success.
      */
-    virtual ErrCode StartUIAbilitiesInSplitWindowMode(int32_t primaryWindowId, const AAFwk::Want &secondaryWant,
+    virtual int32_t StartUIAbilitiesInSplitWindowMode(int32_t primaryWindowId, const AAFwk::Want &secondaryWant,
         sptr<IRemoteObject> callerToken)
     {
         return 0;
diff --git a/services/abilitymgr/include/ability_manager_service.h b/services/abilitymgr/include/ability_manager_service.h
index c1d46eaf022f830090aa4290ef5530a38bee5ff2..6a302b4ecf4636fcd9d1c9e1c07b62be5f49f368 100644
--- a/services/abilitymgr/include/ability_manager_service.h
+++ b/services/abilitymgr/include/ability_manager_service.h
@@ -347,7 +347,7 @@ public:
      * @param callerToken current caller ability token.
      * @return Returns ERR_OK if success.
      */
-    ErrCode StartUIAbilitiesInSplitWindowMode(int32_t primaryWindowId, const AAFwk::Want &secondaryWant,
+    int32_t StartUIAbilitiesInSplitWindowMode(int32_t primaryWindowId, const AAFwk::Want &secondaryWant,
         sptr<IRemoteObject> callerToken) override;
     /**
      * Start UI abilities simultaneously.
diff --git a/services/abilitymgr/include/scene_board/ui_ability_lifecycle_manager.h b/services/abilitymgr/include/scene_board/ui_ability_lifecycle_manager.h
index 80ed39a04a73711d23e3b3f120cdea8173e09388..81b1ea819d0e69acd41fc5594a99b6ac3eb03c6a 100644
--- a/services/abilitymgr/include/scene_board/ui_ability_lifecycle_manager.h
+++ b/services/abilitymgr/include/scene_board/ui_ability_lifecycle_manager.h
@@ -445,8 +445,8 @@ private:
     sptr<SessionInfo> CreateSessionInfo(const AbilityRequest &abilityRequest, int32_t requestId) const;
     int NotifySCBPendingActivation(sptr<SessionInfo> &sessionInfo,
         const AbilityRequest &abilityRequest, std::string &errMsg);
-    std::pair<std::vector<sptr<SessionInfo>>, std::vector<Rosen::PendingSessionActivationConfig>>
-        CreateSessionConfigurations(int primaryWindowId, sptr<SessionInfo> sessionInfo);
+    void CreateSessionConfigurations(std::vector<sptr<SessionInfo>> &sessionInfoList, int primaryWindowId,
+        std::vector<Rosen::PendingSessionActivationConfig> &configList, sptr<SessionInfo> sessionInfo);
     int NotifySCBPendingActivationInSplitMode(sptr<SessionInfo> &sessionInfo, const AbilityRequest &abilityRequest);
     int32_t BatchNotifySCBPendingActivations(const AbilitiesRequest &abilitiesRequest);
     void HandleAbilitiesRequestDone(int32_t requestId, int32_t requestListId, sptr<SessionInfo> sessionInfo);
diff --git a/services/abilitymgr/src/ability_manager_service.cpp b/services/abilitymgr/src/ability_manager_service.cpp
index 8ecd3b55ae7b8e364edf309d1e2990eefc2a044e..db0c922cf283be825f042d22e98462a8bd9b85f2 100644
--- a/services/abilitymgr/src/ability_manager_service.cpp
+++ b/services/abilitymgr/src/ability_manager_service.cpp
@@ -2331,13 +2331,11 @@ int32_t AbilityManagerService::CheckWantForSplitMode(const AAFwk::Want &secondar
         TAG_LOGE(AAFwkTag::ABILITYMGR, "StartUIAbilitiesInSplitWindowMode multi-user non-concurrent unsatisfied");
         return ERR_CROSS_USER;
     }
-#ifdef SUPPORT_SCREEN
     auto element = secondaryWant.GetElement();
     if (element.GetBundleName().empty() || element.GetAbilityName().empty()) {
         TAG_LOGE(AAFwkTag::ABILITYMGR, "StartUIAbilitiesInSplitWindowMode not support implicit start");
         return START_UI_ABILITIES_NOT_SUPPORT_IMPLICIT_START;
     }
-#endif
     return ERR_OK;
 }
 
@@ -2414,7 +2412,7 @@ int32_t AbilityManagerService::GenerateAbilityForSplitMode(const AAFwk::Want &se
     return ERR_OK;
 }
 
-ErrCode AbilityManagerService::StartUIAbilitiesInSplitWindowMode(int32_t primaryWindowId,
+int32_t AbilityManagerService::StartUIAbilitiesInSplitWindowMode(int32_t primaryWindowId,
     const AAFwk::Want &secondaryWant, sptr<IRemoteObject> callerToken)
 {
     HITRACE_METER_NAME(HITRACE_TAG_ABILITY_MANAGER, __PRETTY_FUNCTION__);
diff --git a/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp b/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp
index 4655b2331450c2ff0e12bf85631a6ff77146a1e3..ff51bae17cf4befec552f4dbac02b3c5d6210d2b 100644
--- a/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp
+++ b/services/abilitymgr/src/scene_board/ui_ability_lifecycle_manager.cpp
@@ -1536,9 +1536,9 @@ sptr<SessionInfo> UIAbilityLifecycleManager::CreateSessionInfo(const AbilityRequ
 int UIAbilityLifecycleManager::NotifySCBPendingActivationInSplitMode(sptr<SessionInfo> &sessionInfo,
     const AbilityRequest &abilityRequest)
 {
-    auto result = CreateSessionConfigurations(abilityRequest.primaryWindowId, sessionInfo);
-    auto& sessionInfoList = result.first;
-    auto& configs = result.second;
+    std::vector<sptr<SessionInfo>> sessionInfoList;
+    std::vector<Rosen::PendingSessionActivationConfig> configList;
+    CreateSessionConfigurations(sessionInfoList, abilityRequest.primaryWindowId, configList, sessionInfo);
     bool hasStartWindowOption = (sessionInfo->startWindowOption != nullptr);
     bool hasStartWindow = hasStartWindowOption ? sessionInfo->startWindowOption->hasStartWindow : false;
     std::string backgroundColor =
@@ -1555,7 +1555,7 @@ int UIAbilityLifecycleManager::NotifySCBPendingActivationInSplitMode(sptr<Sessio
     for (auto sessionInfo : sessionInfoList) {
         sessionInfo->canStartAbilityFromBackground = true;
     }
-    return static_cast<int>(tmpSceneSession->BatchPendingSessionsActivation(sessionInfoList, configs));
+    return static_cast<int>(tmpSceneSession->BatchPendingSessionsActivation(sessionInfoList, configList));
 }
 
 int UIAbilityLifecycleManager::NotifySCBPendingActivation(sptr<SessionInfo> &sessionInfo,
@@ -2574,6 +2574,11 @@ int32_t UIAbilityLifecycleManager::MoveAbilityToFront(const SpecifiedRequest &sp
         HandleAbilitiesRequestDone(requestId, requestListId, sessionInfo);
         return ERR_OK;
     }
+    if (specifiedRequest.abilityRequest.isStartInSplitMode) {
+        SendSessionInfoToSCBInSplitMode(specifiedRequest.abilityRequest.primaryWindowId, callerAbility, sessionInfo);
+        abilityRecord->RemoveWindowMode();
+        return ERR_OK;
+    }
     SendSessionInfoToSCB(callerAbility, sessionInfo);
     abilityRecord->RemoveWindowMode();
     return ERR_OK;
@@ -2630,54 +2635,32 @@ int UIAbilityLifecycleManager::SendSessionInfoToSCB(std::shared_ptr<AbilityRecor
     return ERR_OK;
 }
 
-std::pair<std::vector<sptr<SessionInfo>>, std::vector<Rosen::PendingSessionActivationConfig>> UIAbilityLifecycleManager
-    ::CreateSessionConfigurations(int primaryWindowId, sptr<SessionInfo> sessionInfo)
+void UIAbilityLifecycleManager::CreateSessionConfigurations(std::vector<sptr<SessionInfo>> &sessionInfoList,
+    int primaryWindowId, std::vector<Rosen::PendingSessionActivationConfig> &configList, sptr<SessionInfo> sessionInfo)
 {
-    std::vector<sptr<SessionInfo>> sessionInfoList;
     sptr<SessionInfo> sourceSessionInfo = new SessionInfo();
     sourceSessionInfo->persistentId = primaryWindowId;
     sessionInfoList.push_back(sourceSessionInfo);
     sessionInfoList.push_back(sessionInfo);
-
-    std::vector<Rosen::PendingSessionActivationConfig> configs;
     Rosen::PendingSessionActivationConfig sourceConfig = {false, false};
     Rosen::PendingSessionActivationConfig targetConfig = {true, true};
-    configs.push_back(sourceConfig);
-    configs.push_back(targetConfig);
-
-    return {sessionInfoList, configs};
+    configList.push_back(sourceConfig);
+    configList.push_back(targetConfig);
 }
 
 int UIAbilityLifecycleManager::SendSessionInfoToSCBInSplitMode(int primaryWindowId,
     std::shared_ptr<AbilityRecord> callerAbility, sptr<SessionInfo> sessionInfo)
 {
     CHECK_POINTER_AND_RETURN(sessionInfo, ERR_INVALID_VALUE);
-    auto result = CreateSessionConfigurations(primaryWindowId, sessionInfo);
-    auto& sessionInfoList = result.first;
-    auto& configs = result.second;
+    std::vector<sptr<SessionInfo>> sessionInfoList;
+    std::vector<Rosen::PendingSessionActivationConfig> configList;
+    CreateSessionConfigurations(sessionInfoList, primaryWindowId, configList, sessionInfo);
     auto tmpSceneSession = iface_cast<Rosen::ISession>(rootSceneSession_);
-    sptr<SessionInfo> callerSessionInfo = nullptr;
-    if (callerAbility != nullptr && (callerSessionInfo = callerAbility->GetSessionInfo()) != nullptr &&
-        callerSessionInfo->sessionToken != nullptr) {
-        auto callerSession = iface_cast<Rosen::ISession>(callerSessionInfo->sessionToken);
-        CHECK_POINTER_AND_RETURN(callerSession, ERR_INVALID_VALUE);
-        CheckCallerFromBackground(callerAbility, sessionInfo);
-        auto requestId = sessionInfo->want.GetStringParam(KEY_REQUEST_ID);
-        if (!requestId.empty()) {
-            TAG_LOGI(AAFwkTag::ABILITYMGR, "notify request success, requestId:%{public}s", requestId.c_str());
-            callerAbility->NotifyAbilityRequestSuccess(requestId, sessionInfo->want.GetElement());
-        }
-        sessionInfo->want.RemoveParam(KEY_REQUEST_ID);
-        TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, NotifySCBPendingActivation for callerSession, target: %{public}s",
-            sessionInfo->want.GetElement().GetAbilityName().c_str());
-        callerSession->BatchPendingSessionsActivation(sessionInfoList, configs);
-        return ERR_OK;
-    }
     CHECK_POINTER_AND_RETURN(tmpSceneSession, ERR_INVALID_VALUE);
     sessionInfo->canStartAbilityFromBackground = true;
     TAG_LOGI(AAFwkTag::ABILITYMGR, "scb call, NotifySCBPendingActivation for rootSceneSession, target: %{public}s",
         sessionInfo->want.GetElement().GetAbilityName().c_str());
-    tmpSceneSession->BatchPendingSessionsActivation(sessionInfoList, configs);
+    tmpSceneSession->BatchPendingSessionsActivation(sessionInfoList, configList);
     return ERR_OK;
 }
 
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 91f7e42f117ce2a600f43825b7b6e2a95b36dff5..b452a504fc98cdb771bacec473ee310de134f1be 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
@@ -488,6 +488,22 @@ HWTEST_F(AbilityManagerClientTest, StartAbilityByCallWithErrMsg_0100, TestSize.L
     TAG_LOGI(AAFwkTag::TEST, "StartAbilityByCallWithErrMsg_0100 end");
 }
 
+/**
+ * @tc.name: AbilityManagerClient_StartUIAbilitiesInSplitWindowMode_0100
+ * @tc.desc: StartUIAbilitiesInSplitWindowMode
+ * @tc.type: FUNC
+ */
+HWTEST_F(AbilityManagerClientTest, StartUIAbilitiesInSplitWindowMode_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "StartUIAbilitiesInSplitWindowMode_0100 start");
+    Want want;
+    int32_t windowID = 1;
+    sptr<IRemoteObject> callToken = sptr<AbilityRuntime::MockIRemoteObject>::MakeSptr();
+    auto result = AbilityManagerClient::GetInstance()->StartUIAbilitiesInSplitWindowMode(windowID, want, callToken);
+    EXPECT_EQ(result, ERR_OK);
+    TAG_LOGI(AAFwkTag::TEST, "startMultiUIAbilities_0100 end");
+}
+
 /**
  * @tc.name: AbilityManagerClient_StartUIAbilities_0100
  * @tc.desc: StartUIAbilities
diff --git a/test/unittest/ability_manager_proxy_test/ability_manager_proxy_test.cpp b/test/unittest/ability_manager_proxy_test/ability_manager_proxy_test.cpp
index 49af01d529d05c1abfd6f3eced456c749b77b207..f74ac0fb85c6c2e7196a445322c432db0ce17302 100644
--- a/test/unittest/ability_manager_proxy_test/ability_manager_proxy_test.cpp
+++ b/test/unittest/ability_manager_proxy_test/ability_manager_proxy_test.cpp
@@ -2853,6 +2853,44 @@ HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_RestartApp_0100, TestSize.
     EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::RESTART_APP), mock_->code_);
 }
 
+/*
+ * Feature: AbilityManagerService
+ * Function: StartUIAbilitiesInSplitWindowMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService StartUIAbilitiesInSplitWindowMode
+ * EnvConditions: NA
+ * CaseDescription: Verify the normal process of StartUIAbilitiesInSplitWindowMode callerToken nullptr
+ */
+HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartUIAbilitiesInSplitWindowMode_001, TestSize.Level1)
+{
+    sptr<IRemoteObject> callerToken = nullptr;
+    int32_t primaryWindowId = 1;
+    AAFwk::Want want;
+    auto res = proxy_->StartUIAbilitiesInSplitWindowMode(primaryWindowId, want, callerToken);
+    EXPECT_EQ(res, INVALID_CALLER_TOKEN);
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Function: StartUIAbilitiesInSplitWindowMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService StartUIAbilitiesInSplitWindowMode
+ * EnvConditions: NA
+ * CaseDescription: Verify the normal process of StartUIAbilities
+ */
+HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartUIAbilitiesInSplitWindowMode_002, TestSize.Level1)
+{
+    EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
+        .Times(1)
+        .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
+    
+    OHOS::sptr<IRemoteObject> callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
+    int32_t primaryWindowId = 1;
+    AAFwk::Want want;
+    auto res = proxy_->StartUIAbilitiesInSplitWindowMode(primaryWindowId, want, callerToken);
+    EXPECT_EQ(res, NO_ERROR);
+}
+
 /*
  * Feature: AbilityManagerService
  * Function: StartUIAbilities
diff --git a/test/unittest/ability_manager_service_thirteenth_test/ability_manager_service_thirteenth_test.cpp b/test/unittest/ability_manager_service_thirteenth_test/ability_manager_service_thirteenth_test.cpp
index 7307f4fbb3c2015934a4335a8d2401ca27511587..a280100a6f51c7a0871d0b128cbace9a4f2ee9eb 100644
--- a/test/unittest/ability_manager_service_thirteenth_test/ability_manager_service_thirteenth_test.cpp
+++ b/test/unittest/ability_manager_service_thirteenth_test/ability_manager_service_thirteenth_test.cpp
@@ -1263,6 +1263,443 @@ HWTEST_F(AbilityManagerServiceThirteenthTest, KillProcessWithReason_003, TestSiz
     TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest KillProcessWithReason_003 end");
 }
 
+/*
+ * Feature: AbilityManagerService
+ * Name: StartUIAbilitiesInSplitWindowMode_001
+ * Function: StartUIAbilitiesInSplitWindowMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService StartUIAbilitiesInSplitWindowMode SCB false
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, StartUIAbilitiesInSplitWindowMode_001, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowMode_001 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+    Want want;
+    want.SetElementName("com.ohos.test", "MainAbility");
+    
+    int32_t windowId = 1;
+    sptr<IRemoteObject> callerToken = nullptr;
+    MyStatus::GetInstance().sbjIsSceneBoardEnabled_ = false;
+ 
+    EXPECT_EQ(abilityMs_->StartUIAbilitiesInSplitWindowMode(windowId, want, callerToken),
+        ERR_CAPABILITY_NOT_SUPPORT);
+ 
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowMode_001 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Name: StartUIAbilitiesInSplitWindowMode_002
+ * Function: StartUIAbilitiesInSplitWindowMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService StartUIAbilitiesInSplitWindowMode SUPPORT_LINKAGE_SCENE false
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, StartUIAbilitiesInSplitWindowMode_002, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowMode_002 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+    Want want;
+    want.SetElementName("com.ohos.test", "MainAbility");
+    
+    int32_t windowId = 1;
+    sptr<IRemoteObject> callerToken = nullptr;
+    MyStatus::GetInstance().sbjIsSceneBoardEnabled_ = true;
+    MyStatus::GetInstance().paramGetBoolParameter_ = false;
+ 
+    EXPECT_EQ(abilityMs_->StartUIAbilitiesInSplitWindowMode(windowId, want, callerToken),
+        ERR_CAPABILITY_NOT_SUPPORT);
+ 
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowMode_002 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Name: StartUIAbilitiesInSplitWindowMode_003
+ * Function: StartUIAbilitiesInSplitWindowMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService StartUIAbilitiesInSplitWindowMode SUPPORT_LINKAGE_SCENE false
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, StartUIAbilitiesInSplitWindowMode_003, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowMode_003 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+    Want want;
+    int32_t windowId = 1;
+    sptr<IRemoteObject> callerToken = nullptr;
+    MyStatus::GetInstance().sbjIsSceneBoardEnabled_ = true;
+    MyStatus::GetInstance().paramGetBoolParameter_ = true;
+    MyStatus::GetInstance().isSystemAppCall_ = false;
+    EXPECT_EQ(abilityMs_->StartUIAbilitiesInSplitWindowMode(windowId, want, callerToken),
+        ERR_NOT_SYSTEM_APP);
+    MyStatus::GetInstance().isSystemAppCall_ = true;
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowMode_003 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Name: StartUIAbilitiesInSplitWindowMode_004
+ * Function: StartUIAbilitiesInSplitWindowMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService StartUIAbilitiesInSplitWindowMode callerToken is null
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, StartUIAbilitiesInSplitWindowMode_004, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowMode_004 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+
+    Want want;
+    want.SetElementName("com.ohos.test", "MainAbility");
+    
+    int32_t windowId = 1;
+    sptr<IRemoteObject> callerToken = nullptr;
+    MyStatus::GetInstance().sbjIsSceneBoardEnabled_ = true;
+    MyStatus::GetInstance().paramGetBoolParameter_ = true;
+    EXPECT_EQ(abilityMs_->StartUIAbilitiesInSplitWindowMode(windowId, want, callerToken),
+        ERR_INVALID_CALLER);
+ 
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowMode_004 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Name: StartUIAbilitiesInSplitWindowMode_005
+ * Function: StartUIAbilitiesInSplitWindowMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService StartUIAbilitiesInSplitWindowMode verifyToken failed
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, StartUIAbilitiesInSplitWindowMode_005, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowMode_005 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+    auto mockSubManagersHelper = std::make_shared<SubManagersHelper>(nullptr, nullptr);
+    EXPECT_NE(mockSubManagersHelper, nullptr);
+    auto mockCurrentUIAbilityManager = std::make_shared<UIAbilityLifecycleManager>(0);
+    EXPECT_NE(mockCurrentUIAbilityManager, nullptr);
+    abilityMs_->subManagersHelper_ = mockSubManagersHelper;
+    abilityMs_->subManagersHelper_->currentUIAbilityManager_ = mockCurrentUIAbilityManager;
+
+    Want want;
+    want.SetElementName("com.ohos.test", "MainAbility");
+    
+    int32_t windowId = 1;
+    sptr<IRemoteObject> callerToken = MockToken(AbilityType::EXTENSION);
+    MyStatus::GetInstance().sbjIsSceneBoardEnabled_ = true;
+    MyStatus::GetInstance().paramGetBoolParameter_ = true;
+    MyStatus::GetInstance().smhVerificationAllToken_ = false;
+    EXPECT_EQ(abilityMs_->StartUIAbilitiesInSplitWindowMode(windowId, want, callerToken),
+        ERR_INVALID_CALLER);
+ 
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowMode_005 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Name: StartUIAbilitiesInSplitWindowMode_006
+ * Function: StartUIAbilitiesInSplitWindowMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService StartUIAbilitiesInSplitWindowModeHandleWant failed
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, StartUIAbilitiesInSplitWindowMode_006, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowMode_006 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+    auto mockSubManagersHelper = std::make_shared<SubManagersHelper>(nullptr, nullptr);
+    EXPECT_NE(mockSubManagersHelper, nullptr);
+    auto mockCurrentUIAbilityManager = std::make_shared<UIAbilityLifecycleManager>(0);
+    EXPECT_NE(mockCurrentUIAbilityManager, nullptr);
+    abilityMs_->subManagersHelper_ = mockSubManagersHelper;
+    abilityMs_->subManagersHelper_->currentUIAbilityManager_ = mockCurrentUIAbilityManager;
+
+    Want want;
+    int32_t windowId = 1;
+    sptr<IRemoteObject> callerToken = MockToken(AbilityType::EXTENSION);
+    MyStatus::GetInstance().sbjIsSceneBoardEnabled_ = true;
+    MyStatus::GetInstance().paramGetBoolParameter_ = true;
+    MyStatus::GetInstance().smhVerificationAllToken_ = true;
+    EXPECT_NE(abilityMs_->StartUIAbilitiesInSplitWindowMode(windowId, want, callerToken),
+        ERR_OK);
+ 
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowMode_006 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Name: StartUIAbilitiesInSplitWindowModeHandleWant_001
+ * Function: StartUIAbilitiesInSplitWindowModeHandleWant
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService StartUIAbilitiesInSplitWindowModeHandleWant failed
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, StartUIAbilitiesInSplitWindowModeHandleWant_001, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST,
+        "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowModeHandleWant_001 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+    
+    Want want;
+    AbilityRequest abilityRequest;
+    int32_t windowId = 1;
+    int32_t validUserId = abilityMs_->GetValidUserId(DEFAULT_INVAL_VALUE);
+    int32_t appIndex = 0;
+    sptr<IRemoteObject> callerToken = MockToken(AbilityType::EXTENSION);
+
+    EXPECT_NE(abilityMs_->StartUIAbilitiesInSplitWindowModeHandleWant(want, callerToken, abilityRequest),
+        ERR_OK);
+ 
+    TAG_LOGI(AAFwkTag::TEST,
+        "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowModeHandleWant_001 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Name: StartUIAbilitiesInSplitWindowModeHandleWant_002
+ * Function: StartUIAbilitiesInSplitWindowModeHandleWant
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService StartUIAbilitiesInSplitWindowModeHandleWant generateRequest
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, StartUIAbilitiesInSplitWindowModeHandleWant_002, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, 
+        "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowModeHandleWant_002 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+
+    Want want;
+    want.SetElementName("com.ohos.test", "MainAbility");
+    AbilityRequest abilityRequest;
+    int32_t windowId = 1;   
+    int32_t validUserId = abilityMs_->GetValidUserId(DEFAULT_INVAL_VALUE);
+    int32_t appIndex = 0;
+    std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
+    EXPECT_NE(abilityRecord, nullptr);
+    sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
+
+    EXPECT_EQ(abilityMs_->StartUIAbilitiesInSplitWindowModeHandleWant(want, callerToken, abilityRequest),
+        RESOLVE_ABILITY_ERR);
+ 
+    TAG_LOGI(AAFwkTag::TEST,
+        "AbilityManagerServiceThirteenthTest StartUIAbilitiesInSplitWindowModeHandleWant_002 end");
+}
+/*
+ * Feature: AbilityManagerService
+ * Name: CheckWantForSplitMode_001
+ * Function: CheckWantForSplitMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService CheckWantForSplitMode verifyToken failed
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, CheckWantForSplitMode_001, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest CheckWantForSplitMode_001 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+    auto mockSubManagersHelper = std::make_shared<SubManagersHelper>(nullptr, nullptr);
+    EXPECT_NE(mockSubManagersHelper, nullptr);
+    auto mockCurrentUIAbilityManager = std::make_shared<UIAbilityLifecycleManager>(0);
+    EXPECT_NE(mockCurrentUIAbilityManager, nullptr);
+    abilityMs_->subManagersHelper_ = mockSubManagersHelper;
+    abilityMs_->subManagersHelper_->currentUIAbilityManager_ = mockCurrentUIAbilityManager;
+
+    Want want;
+    want.SetElementName("com.ohos.test", "MainAbility");
+    want.SetParam(AAFwk::Want::DESTINATION_PLUGIN_ABILITY, true);
+
+    int32_t windowId = 1;
+    int32_t validUserId = abilityMs_->GetValidUserId(DEFAULT_INVAL_VALUE);
+    int32_t appIndex = 0;
+    sptr<IRemoteObject> callerToken = MockToken(AbilityType::EXTENSION);
+
+    EXPECT_EQ(abilityMs_->CheckWantForSplitMode(want, callerToken, validUserId, appIndex),
+        START_UI_ABILITIES_NOT_SUPPORT_START_PLUGIN);
+ 
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest CheckWantForSplitMode_001 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Name: CheckWantForSplitMode_003
+ * Function: CheckWantForSplitMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService CheckWantForSplitMode dlp failed with dlp
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, CheckWantForSplitMode_002, TestSize.Level1)
+{
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+    auto mockSubManagersHelper = std::make_shared<SubManagersHelper>(nullptr, nullptr);
+    EXPECT_NE(mockSubManagersHelper, nullptr);
+    auto mockCurrentUIAbilityManager = std::make_shared<UIAbilityLifecycleManager>(0);
+    EXPECT_NE(mockCurrentUIAbilityManager, nullptr);
+    abilityMs_->subManagersHelper_ = mockSubManagersHelper;
+    abilityMs_->subManagersHelper_->currentUIAbilityManager_ = mockCurrentUIAbilityManager;
+
+    Want want;
+    want.SetElementName("com.ohos.test", "MainAbility");
+    want.SetParam(DLP_PARAMS_SANDBOX, true);
+    int32_t windowId = 1;
+    int32_t validUserId = abilityMs_->GetValidUserId(DEFAULT_INVAL_VALUE);
+    int32_t appIndex = 0;
+    sptr<IRemoteObject> callerToken = MockToken(AbilityType::EXTENSION);
+
+    EXPECT_EQ(abilityMs_->CheckWantForSplitMode(want, callerToken, validUserId, appIndex),
+        START_UI_ABILITIES_NOT_SUPPORT_DLP);
+ 
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest CheckWantForSplitMode_002 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Name: CheckWantForSplitMode_003
+ * Function: CheckWantForSplitMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService CheckWantForSplitMode appCloneIndexError
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, CheckWantForSplitMode_003, TestSize.Level1)
+{
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+
+    Want want;
+    AbilityRequest abilityRequest;
+    std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
+    EXPECT_NE(abilityRecord, nullptr);
+    sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
+    int32_t windowId = 1;
+    int32_t validUserId = abilityMs_->GetValidUserId(DEFAULT_INVAL_VALUE);
+    int32_t appIndex = 0;
+
+    want.SetParam(Want::PARAM_APP_CLONE_INDEX_KEY, -5);
+
+    EXPECT_EQ(abilityMs_->CheckWantForSplitMode(want, callerToken, validUserId, appIndex),
+        ERR_APP_CLONE_INDEX_INVALID);
+ 
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest CheckWantForSplitMode_003 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Name: CheckWantForSplitMode_004
+ * Function: CheckWantForSplitMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService CheckWantForSplitMode ImplicitStartError
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, CheckWantForSplitMode_004, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest CheckWantForSplitMode_004 start");
+
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+
+    Want want;
+    AbilityRequest abilityRequest;
+    std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
+    EXPECT_NE(abilityRecord, nullptr);
+    sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
+    int32_t windowId = 1;
+    int32_t validUserId = abilityMs_->GetValidUserId(DEFAULT_INVAL_VALUE);
+    int32_t appIndex = 0;
+
+    EXPECT_EQ(abilityMs_->CheckWantForSplitMode(want, callerToken, validUserId, appIndex),
+        START_UI_ABILITIES_NOT_SUPPORT_IMPLICIT_START);
+
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest CheckWantForSplitMode_004 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Name: CheckWantForSplitMode_005
+ * Function: CheckWantForSplitMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService CheckWantForSplitMode createInstance
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, CheckWantForSplitMode_005, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest CheckWantForSplitMode_005 start");
+
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+
+    Want want;
+    AbilityRequest abilityRequest;
+    std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
+    EXPECT_NE(abilityRecord, nullptr);
+    sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
+    int32_t windowId = 1;
+    int32_t validUserId = abilityMs_->GetValidUserId(DEFAULT_INVAL_VALUE);
+    int32_t appIndex = 0;
+
+    want.SetParam(AAFwk::Want::CREATE_APP_INSTANCE_KEY, true);
+    EXPECT_EQ(abilityMs_->CheckWantForSplitMode(want, callerToken, validUserId, appIndex),
+        START_UI_ABILITIES_NOT_SUPPORT_CREATE_APP_INSTANCE_KEY);
+
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest CheckWantForSplitMode_005 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Name: CheckWantForSplitMode_006
+ * Function: CheckWantForSplitMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService CheckWantForSplitMode multiInstanceError
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, CheckWantForSplitMode_006, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest CheckWantForSplitMode_006 start");
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+
+    Want want;
+    want.SetElementName("com.ohos.test", "MainAbility");
+    AbilityRequest abilityRequest;
+    std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
+    EXPECT_NE(abilityRecord, nullptr);
+    sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
+    MyStatus::GetInstance().isSupportMultiInstance_ = false;
+    std::string instanceKey = "MainAbility";
+    want.SetParam(AAFwk::Want::APP_INSTANCE_KEY, instanceKey);
+    int32_t windowId = 1;
+    int32_t validUserId = abilityMs_->GetValidUserId(DEFAULT_INVAL_VALUE);
+    int32_t appIndex = 0;
+    EXPECT_NE(abilityMs_->CheckWantForSplitMode(want, callerToken, validUserId, appIndex),
+        ERR_OK);
+    MyStatus::GetInstance().isSupportMultiInstance_ = true;
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest CheckWantForSplitMode_006 end");
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Name: CheckWantForSplitMode_007
+ * Function: CheckWantForSplitMode
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService CheckWantForSplitMode return ok
+ */
+HWTEST_F(AbilityManagerServiceThirteenthTest, CheckWantForSplitMode_007, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest CheckWantForSplitMode_007 start");
+
+    auto abilityMs_ = std::make_shared<AbilityManagerService>();
+    EXPECT_NE(abilityMs_, nullptr);
+
+    Want want;
+    want.SetElementName("com.ohos.test", "MainAbility");
+    AbilityRequest abilityRequest;
+    std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
+    EXPECT_NE(abilityRecord, nullptr);
+    sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
+    int32_t windowId = 1;
+    int32_t validUserId = abilityMs_->GetValidUserId(DEFAULT_INVAL_VALUE);
+    int32_t appIndex = 0;
+
+    EXPECT_EQ(abilityMs_->CheckWantForSplitMode(want, callerToken, validUserId, appIndex),
+        ERR_OK);
+
+    TAG_LOGI(AAFwkTag::TEST, "AbilityManagerServiceThirteenthTest CheckWantForSplitMode_007 end");
+}
+
 /*
  * Feature: AbilityManagerService
  * Name: StartUIAbilities_001
diff --git a/test/unittest/ability_manager_service_thirteenth_test/mock/include/mock_my_status.h b/test/unittest/ability_manager_service_thirteenth_test/mock/include/mock_my_status.h
index 2e70cea8687d20d9c763747e591ce879ded6c9f4..43e3191e0516219299ac48212b5c4333fbbac70b 100644
--- a/test/unittest/ability_manager_service_thirteenth_test/mock/include/mock_my_status.h
+++ b/test/unittest/ability_manager_service_thirteenth_test/mock/include/mock_my_status.h
@@ -54,6 +54,7 @@ public:
     std::shared_ptr<AbilityRecord> acmGetUIExtensionBySessionFromServiceMap_ = nullptr;
     bool isSupportStartAbilities_ = true;
     bool isSupportMultiInstance_ = true;
+    bool isSystemAppCall_ = true;
 };
 } // namespace AAFwk
 } // namespace OHOS
diff --git a/test/unittest/ability_manager_service_thirteenth_test/mock/src/mock_permission_verification.cpp b/test/unittest/ability_manager_service_thirteenth_test/mock/src/mock_permission_verification.cpp
index 21662cabbbfe6607033edfe59756d5e5912fdb02..eea78805160ccf4e1f25ff886eb9b9299a7359b2 100644
--- a/test/unittest/ability_manager_service_thirteenth_test/mock/src/mock_permission_verification.cpp
+++ b/test/unittest/ability_manager_service_thirteenth_test/mock/src/mock_permission_verification.cpp
@@ -125,7 +125,7 @@ bool PermissionVerification::JudgeCallerIsAllowedToUseSystemAPI() const
 }
 bool PermissionVerification::IsSystemAppCall() const
 {
-    return true;
+    return MyStatus::GetInstance().isSystemAppCall_;
 }
 } // 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 dffa05068834bdee467a94a98c80f4e42a67f7d9..99064270dccdf2959c0f28e6264c1126f04f373d 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
@@ -559,7 +559,8 @@ HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerFourteenth_0100, Test
         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_UI_EXTENSION_ROOT_HOST_INFO),
         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_UI_EXTENSION_SESSION_INFO),
         static_cast<uint32_t>(AbilityManagerInterfaceCode::PRELOAD_UIEXTENSION_ABILITY),
-        static_cast<uint32_t>(AbilityManagerInterfaceCode::TERMINATE_UI_SERVICE_EXTENSION_ABILITY)
+        static_cast<uint32_t>(AbilityManagerInterfaceCode::TERMINATE_UI_SERVICE_EXTENSION_ABILITY),
+        static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_ABILITIES_IN_SPLIT_WINDOW_MODE)
     };
 
     int i = 0;
diff --git a/test/unittest/ability_manager_stub_test/ability_manager_stub_test.cpp b/test/unittest/ability_manager_stub_test/ability_manager_stub_test.cpp
index 9dacee755f43bfb246cf4b091289f632d6713a64..5f48915f8fad5246ade9729d004e30c9c8450498 100644
--- a/test/unittest/ability_manager_stub_test/ability_manager_stub_test.cpp
+++ b/test/unittest/ability_manager_stub_test/ability_manager_stub_test.cpp
@@ -3722,6 +3722,97 @@ HWTEST_F(AbilityManagerStubTest, ChangeUIAbilityVisibilityBySCB_0100, TestSize.L
     TAG_LOGI(AAFwkTag::TEST, "end");
 }
 
+/*
+ * Feature: AbilityManagerService
+ * Function: StartUIAbilitiesInSplitWindowModeInner
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService StartUIAbilitiesInSplitWindowModeInner
+ * EnvConditions: NA
+ * CaseDescription: want is nullptr
+ */
+HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUIAbilitiesInSplitWindowModeInner_001, TestSize.Level1)
+{
+MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+
+    WriteInterfaceToken(data);
+    int32_t primaryWindowId = 1;
+    data.WriteInt32(primaryWindowId);
+
+    Want want = nullptr;
+    data.WriteParcelable(&want);
+
+     sptr<IRemoteObject> token =
+        sptr<AppExecFwk::MockAbilityToken>(new (std::nothrow) AppExecFwk::MockAbilityToken());
+    data.WriteRemoteObject(token);
+
+    int res = stub_->OnRemoteRequest(
+        static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_ABILITIES_IN_SPLIT_WINDOW_MODE), data, reply,
+        option);
+    EXPECT_EQ(res, ERR_INVALID_VALUE);
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Function: StartUIAbilitiesInSplitWindowModeInner
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService StartUIAbilitiesInSplitWindowModeInner
+ * EnvConditions: NA
+ * CaseDescription: callToken is nullptr
+ */
+HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUIAbilitiesInSplitWindowModeInner_001, TestSize.Level1)
+{
+MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+
+    WriteInterfaceToken(data);
+    int32_t primaryWindowId = 1;
+    data.WriteInt32(primaryWindowId);
+
+    Want want;
+    data.WriteParcelable(&want);
+
+    sptr<IRemoteObject> token = nullptr;
+    data.WriteRemoteObject(token);
+
+    int res = stub_->OnRemoteRequest(
+        static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_ABILITIES_IN_SPLIT_WINDOW_MODE), data, reply,
+        option);
+    EXPECT_EQ(res, INVALID_CALLER_TOKEN);
+}
+
+/*
+ * Feature: AbilityManagerService
+ * Function: StartUIAbilitiesInSplitWindowModeInner
+ * SubFunction: NA
+ * FunctionPoints: AbilityManagerService StartUIAbilitiesInSplitWindowModeInner
+ * EnvConditions: NA
+ * CaseDescription: NO_ERROR
+ */
+HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUIAbilitiesInSplitWindowModeInner_001, TestSize.Level1)
+{
+MessageParcel data;
+    MessageParcel reply;
+    MessageOption option;
+
+    WriteInterfaceToken(data);
+    int32_t primaryWindowId = 1;
+    data.WriteInt32(primaryWindowId);
+
+    Want want;
+    data.WriteParcelable(&want);
+
+     sptr<IRemoteObject> token =
+        sptr<AppExecFwk::MockAbilityToken>(new (std::nothrow) AppExecFwk::MockAbilityToken());
+    data.WriteRemoteObject(token);
+
+    int res = stub_->OnRemoteRequest(
+        static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_ABILITIES_IN_SPLIT_WINDOW_MODE), data, reply,
+        option);
+    EXPECT_EQ(res, NO_ERROR);
+}
 /*
  * Feature: AbilityManagerService
  * Function: StartUIAbilitiesInner
diff --git a/test/unittest/ui_ability_lifecycle_manager_test/ui_ability_lifecycle_manager_test.cpp b/test/unittest/ui_ability_lifecycle_manager_test/ui_ability_lifecycle_manager_test.cpp
index ff84703e081d7e25da4dca4caca3097ac31e8cc0..bd47454688d84be1d182709eedeb6e546906d582 100644
--- a/test/unittest/ui_ability_lifecycle_manager_test/ui_ability_lifecycle_manager_test.cpp
+++ b/test/unittest/ui_ability_lifecycle_manager_test/ui_ability_lifecycle_manager_test.cpp
@@ -1993,6 +1993,77 @@ HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBPendingActivation_001, TestSize
     EXPECT_NE(uiAbilityLifecycleManager, nullptr);
 }
 
+/**
+ * @tc.name: UIAbilityLifecycleManager_NotifySCBPendingActivation_0200
+ * @tc.desc: NotifySCBPendingActivation
+ * @tc.type: FUNC
+ */
+HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBPendingActivation_002, TestSize.Level1)
+{
+    auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
+    EXPECT_NE(uiAbilityLifecycleManager, nullptr);
+    AbilityRequest abilityRequest;
+    Rosen::SessionInfo info;
+    sptr<SessionInfo> sessionInfo(new SessionInfo());
+    sessionInfo->sessionToken = new Rosen::Session(info);
+    sessionInfo->persistentId = 1;
+    abilityRequest.sessionInfo = sessionInfo;
+    auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
+    uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
+    auto token = abilityRecord->GetToken();
+    EXPECT_NE(token, nullptr);
+    abilityRequest.callerToken = token->AsObject();
+    abilityRequest.isStartInSplitMode = true;
+    std::string errMsg;
+    uiAbilityLifecycleManager->NotifySCBPendingActivation(sessionInfo, abilityRequest, errMsg);
+    EXPECT_NE(uiAbilityLifecycleManager, nullptr);
+}
+
+/**
+ * @tc.name: UIAbilityLifecycleManager_NotifySCBPendingActivationInSplitMode_0100
+ * @tc.desc: NotifySCBPendingActivationInSplitMode
+ * @tc.type: FUNC
+ */
+HWTEST_F(UIAbilityLifecycleManagerTest, NotifySCBPendingActivationInSplitMode_001, TestSize.Level1)
+{
+    auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
+    EXPECT_NE(uiAbilityLifecycleManager, nullptr);
+    AbilityRequest abilityRequest;
+    Rosen::SessionInfo info;
+    sptr<SessionInfo> sessionInfo(new SessionInfo());
+    sessionInfo->sessionToken = new Rosen::Session(info);
+    sessionInfo->persistentId = 1;
+    abilityRequest.sessionInfo = sessionInfo;
+    auto abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
+    uiAbilityLifecycleManager->sessionAbilityMap_.emplace(sessionInfo->persistentId, abilityRecord);
+    auto token = abilityRecord->GetToken();
+    EXPECT_NE(token, nullptr);
+    abilityRequest.callerToken = token->AsObject();
+    std::string errMsg;
+    uiAbilityLifecycleManager->NotifySCBPendingActivationInSplitMode(sessionInfo, abilityRequest);
+    EXPECT_NE(uiAbilityLifecycleManager, nullptr);
+
+}
+/**
+ * @tc.name: UIAbilityLifecycleManager_CreateSessionConfigurations_0100
+ * @tc.desc: CreateSessionConfigurations
+ * @tc.type: FUNC
+ */
+HWTEST_F(UIAbilityLifecycleManagerTest, CreateSessionConfigurations_001, TestSize.Level1)
+{
+    auto uiAbilityLifecycleManager = std::make_unique<UIAbilityLifecycleManager>();
+    EXPECT_NE(uiAbilityLifecycleManager, nullptr);
+    AbilityRequest abilityRequest;
+    Rosen::SessionInfo info;
+    sptr<SessionInfo> sessionInfo(new SessionInfo());
+    sessionInfo->sessionToken = new Rosen::Session(info);
+    sessionInfo->persistentId = 1;
+    std::vector<sptr<SessionInfo>> sessionInfoList;
+    std::vector<Rosen::PendingSessionActivationConfig> configList;
+    int32_t primaryWindowId = 1;
+    uiAbilityLifecycleManager->CreateSessionConfigurations(sessionInfoList, primaryWindowId, configList, sessionInfo);
+    EXPECT_NE(uiAbilityLifecycleManager, nullptr);
+}
 /**
  * @tc.name: UIAbilityLifecycleManager_ResolveLocked_0100
  * @tc.desc: ResolveLocked
@@ -2633,6 +2704,30 @@ HWTEST_F(UIAbilityLifecycleManagerTest, MoveAbilityToFront_001, TestSize.Level1)
     uiAbilityLifecycleManager.reset();
 }
 
+/**
+ * @tc.name: UIAbilityLifecycleManager_MoveAbilityToFront_0200
+ * @tc.desc: MoveAbilityToFront
+ * @tc.type: FUNC
+ */
+HWTEST_F(UIAbilityLifecycleManagerTest, MoveAbilityToFront_002, TestSize.Level1)
+{
+    auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
+    AbilityRequest abilityRequest;
+    SpecifiedRequest specifiedRequest(0, abilityRequest);
+    int res = uiAbilityLifecycleManager->MoveAbilityToFront(specifiedRequest, nullptr, nullptr);
+    EXPECT_EQ(res, ERR_INVALID_VALUE);
+
+    specifiedRequest.abilityRequest.sessionInfo = new SessionInfo();
+    specifiedRequest.abilityRequest.appInfo.bundleName = "com.example.unittest";
+    specifiedRequest.abilityRequest.abilityInfo.name = "MainAbility";
+    specifiedRequest.abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
+    specifiedRequest.abilityRequest.isStartInSplitMode = true;
+    std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(specifiedRequest.abilityRequest);
+    res = uiAbilityLifecycleManager->MoveAbilityToFront(specifiedRequest, abilityRecord, nullptr);
+    EXPECT_EQ(res, ERR_OK);
+
+    uiAbilityLifecycleManager.reset();
+}
 /**
  * @tc.name: UIAbilityLifecycleManager_SendSessionInfoToSCB_0100
  * @tc.desc: SendSessionInfoToSCB
@@ -2731,6 +2826,34 @@ HWTEST_F(UIAbilityLifecycleManagerTest, SendSessionInfoToSCB_0300, TestSize.Leve
     uiAbilityLifecycleManager.reset();
 }
 
+/**
+ * @tc.name: UIAbilityLifecycleManager_SendSessionInfoToSCBInSplitMode_0100
+ * @tc.desc: SendSessionInfoToSCBInSplitMode
+ * @tc.type: FUNC
+ */
+HWTEST_F(UIAbilityLifecycleManagerTest, SendSessionInfoToSCBInSplitMode_0100, TestSize.Level1)
+{
+    auto uiAbilityLifecycleManager = std::make_shared<UIAbilityLifecycleManager>();
+    EXPECT_NE(uiAbilityLifecycleManager, nullptr);
+    Rosen::SessionInfo info;
+    uiAbilityLifecycleManager->rootSceneSession_ = new Rosen::Session(info);
+    sptr<SessionInfo> sessionInfo(new SessionInfo());
+    AbilityRequest abilityRequest;
+    sessionInfo->sessionToken = new Rosen::Session(info);
+    sessionInfo->want.SetParam(KEY_REQUEST_ID, std::string("123456"));
+    abilityRequest.sessionInfo = sessionInfo;
+    abilityRequest.appInfo.bundleName = "com.example.unittest";
+    abilityRequest.abilityInfo.name = "MainAbility";
+    abilityRequest.abilityInfo.type = AppExecFwk::AbilityType::PAGE;
+    std::shared_ptr<AbilityRecord> callerAbility = AbilityRecord::CreateAbilityRecord(abilityRequest);
+    abilityRequest.primaryWindowId = 1;
+    int res = uiAbilityLifecycleManager->SendSessionInfoToSCBInSplitMode(abilityRequest.primaryWindowId, callerAbility,
+        sessionInfo);
+    EXPECT_EQ(res, ERR_OK);
+
+    uiAbilityLifecycleManager.reset();
+}
+
 /**
  * @tc.name: UIAbilityLifecycleManager_StartAbilityBySpecifed_0100
  * @tc.desc: StartAbilityBySpecifed
diff --git a/test/unittest/ui_extension_context_test/ui_extension_context_test.cpp b/test/unittest/ui_extension_context_test/ui_extension_context_test.cpp
index b75fa40c09346916442ae4be57635672000a401b..9d163374b46ea1b73193a27762acc3b6199d9ebc 100644
--- a/test/unittest/ui_extension_context_test/ui_extension_context_test.cpp
+++ b/test/unittest/ui_extension_context_test/ui_extension_context_test.cpp
@@ -183,6 +183,24 @@ HWTEST_F(UIExtensionContextTest, StartAbilityForResult_0200, TestSize.Level1)
     TAG_LOGI(AAFwkTag::TEST, "StartAbilityForResult_0200 end");
 }
 
+/**
+ * @tc.number: StartUIAbilitiesInSplitWindowMode_0100
+ * @tc.name: StartUIAbilitiesInSplitWindowMode
+ * @tc.desc: StartUIAbilitiesInSplitWindowMode.
+ */
+HWTEST_F(UIExtensionContextTest, StartUIAbilitiesInSplitWindowMode_0100, TestSize.Level1)
+{
+    TAG_LOGI(AAFwkTag::TEST, "StartUIAbilitiesInSplitWindowMode_0100 start");
+
+    auto context = std::make_shared<UIExtensionContext>();
+    int32_t primaryWindowId = 1;
+    AAFwk::Want want;
+    auto ret = context->StartUIAbilitiesInSplitWindowMode(primaryWindowId, want);
+    EXPECT_NE(ret, ERR_OK);
+
+    TAG_LOGI(AAFwkTag::TEST, "StartUIAbilitiesInSplitWindowMode_0100 end");
+}
+
 /**
  * @tc.number: StartUIAbilities_0100
  * @tc.name: StartUIAbilities