Modify resume mission timer

Signed-off-by: zhaoyuan17 <zhaoyuan17@huawei.com>

services/abilitymgr/include/ability_manager_service.h

@@ -522,6 +522,8 @@ public:
 
     int CheckPermission(const std::string &bundleName, const std::string &permission);
 
+    int GetMissionSaveTime() const;
+
     // MSG 0 - 20 represents timeout message
     static constexpr uint32_t LOAD_TIMEOUT_MSG = 0;
     static constexpr uint32_t ACTIVE_TIMEOUT_MSG = 1;

services/abilitymgr/include/ams_configuration_parameter.h

@@ -28,6 +28,7 @@ const std::string STARTUP_LAUNCHER {"startup_launcher"};
 const std::string STARTUP_STATUS_BAR {"startup_system_ui_status_bar"};
 const std::string STARTUP_NAVIGATION_BAR {"startup_system_ui_navigation_bar"};
 const std::string STARTUP_PHONE_SERVICE {"startup_phone_service"};
+const std::string MISSION_SAVE_TIME {"mission_save_time"};
 }  // namespace AmsConfig
 
 enum class SatrtUiMode { STATUSBAR = 1, NAVIGATIONBAR = 2, STARTUIBOTH = 3 };
@@ -66,6 +67,8 @@ public:
      */
     void Parse();
 
+    int GetMissionSaveTime() const;
+
     enum { READ_OK = 0, READ_FAIL = 1, READ_JSON_FAIL = 2 };
 
 private:
@@ -76,11 +79,12 @@ private:
     int LoadAmsConfiguration(const std::string &filePath);
 
 private:
-    bool nonConfigFile {false};
-    bool canStartLauncher {false};
-    bool canStartUiStatusBar {false};
-    bool canStartUiNavigationBar {false};
-    bool canStartPhoneService {false};
+    bool nonConfigFile_ {false};
+    bool canStartLauncher_ {false};
+    bool canStartUiStatusBar_ {false};
+    bool canStartUiNavigationBar_ {false};
+    bool canStartPhoneService_ {false};
+    int missionSaveTime_ {12 * 60 * 60 * 1000};
 };
 }  // namespace AAFwk
 }  // namespace OHOS

services/abilitymgr/include/resume_mission_container.h

@@ -33,7 +33,6 @@ public:
 
 private:
     const std::string taskName_ = "ResumeMission#";
-    static constexpr int64_t recordSaveTime_ = 24 * 60 * 60 * 1000;
     std::map<int, std::shared_ptr<MissionRecord>> missionMaps_;
     std::shared_ptr<AbilityEventHandler> handler_;
 };

services/abilitymgr/resource/ams_service_config.json

@@ -3,7 +3,7 @@
         "startup_launcher":true,
         "startup_system_ui_status_bar" : true,
         "startup_system_ui_navigation_bar" : true,
-        "startup_phone_service" : true
-    } 
-      
+        "startup_phone_service" : true,
+        "mission_save_time" : 43200000
+    }
 }

services/abilitymgr/src/ability_manager_service.cpp

@@ -1643,5 +1643,14 @@ bool AbilityManagerService::CheckCallerIsSystemAppByIpc()
     HILOG_ERROR("callerUid %{public}d", callerUid);
     return bms->CheckIsSystemAppByUid(callerUid);
 }
+
+int AbilityManagerService::GetMissionSaveTime() const
+{
+    if (!amsConfigResolver_) {
+        return 0;
+    }
+
+    return amsConfigResolver_->GetMissionSaveTime();
+}
 }  // namespace AAFwk
 }  // namespace OHOS

services/abilitymgr/src/ams_configuration_parameter.cpp

@@ -28,27 +28,32 @@ void AmsConfigurationParameter::Parse()
 
 bool AmsConfigurationParameter::GetStartLauncherState() const
 {
-    return canStartLauncher;
+    return canStartLauncher_;
 }
 
 bool AmsConfigurationParameter::GetStatusBarState() const
 {
-    return canStartUiStatusBar;
+    return canStartUiStatusBar_;
 }
 
 bool AmsConfigurationParameter::GetNavigationBarState() const
 {
-    return canStartUiNavigationBar;
+    return canStartUiNavigationBar_;
 }
 
 bool AmsConfigurationParameter::GetPhoneServiceState() const
 {
-    return canStartPhoneService;
+    return canStartPhoneService_;
 }
 
 bool AmsConfigurationParameter::NonConfigFile() const
 {
-    return nonConfigFile;
+    return nonConfigFile_;
+}
+
+int AmsConfigurationParameter::GetMissionSaveTime() const
+{
+    return missionSaveTime_;
 }
 
 int AmsConfigurationParameter::LoadAmsConfiguration(const std::string &filePath)
@@ -59,7 +64,7 @@ int AmsConfigurationParameter::LoadAmsConfiguration(const std::string &filePath)
     inFile.open(filePath, std::ios::in);
     if (!inFile.is_open()) {
         HILOG_INFO("read ams config error ...");
-        nonConfigFile = true;
+        nonConfigFile_ = true;
         return READ_FAIL;
     }
 
@@ -67,21 +72,23 @@ int AmsConfigurationParameter::LoadAmsConfiguration(const std::string &filePath)
     inFile >> amsJson;
     if (amsJson.is_discarded()) {
         HILOG_INFO("json discarded error ...");
-        nonConfigFile = true;
+        nonConfigFile_ = true;
         inFile.close();
         return READ_JSON_FAIL;
     }
 
     if (amsJson.contains(AmsConfig::SERVICE_ITEM_AMS)) {
-        canStartLauncher = amsJson.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::STARTUP_LAUNCHER).get<bool>();
-        canStartUiStatusBar = amsJson.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::STARTUP_STATUS_BAR).get<bool>();
-        canStartUiNavigationBar =
+        canStartLauncher_ = amsJson.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::STARTUP_LAUNCHER).get<bool>();
+        canStartUiStatusBar_ = amsJson.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::STARTUP_STATUS_BAR).get<bool>();
+        canStartUiNavigationBar_ =
             amsJson.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::STARTUP_NAVIGATION_BAR).get<bool>();
-        canStartPhoneService = amsJson.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::STARTUP_PHONE_SERVICE).get<bool>();
+        canStartPhoneService_ =
+            amsJson.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::STARTUP_PHONE_SERVICE).get<bool>();
+        missionSaveTime_ = amsJson.at(AmsConfig::SERVICE_ITEM_AMS).at(AmsConfig::MISSION_SAVE_TIME).get<int>();
         HILOG_INFO("get ams service config succes!");
     } else {
         HILOG_INFO("json no have service item ...");
-        nonConfigFile = true;
+        nonConfigFile_ = true;
         amsJson.clear();
         inFile.close();
         return READ_JSON_FAIL;

services/abilitymgr/src/resume_mission_container.cpp

@@ -16,6 +16,7 @@
 #include "resume_mission_container.h"
 #include "hilog_wrapper.h"
 #include "ability_util.h"
+#include "ability_manager_service.h"
 
 namespace OHOS {
 namespace AAFwk {
@@ -36,10 +37,12 @@ void ResumeMissionContainer::Save(const std::shared_ptr<MissionRecord> &mission)
         missionMaps_.emplace(missionId, backup);
     }
 
+    auto missionSaveTime = DelayedSingleton<AbilityManagerService>::GetInstance()->GetMissionSaveTime();
+    HILOG_INFO("mission save time : %{public}d", missionSaveTime);
     if (backup) {
         HILOG_INFO("start save time...");
         handler_->PostTask(
-            [this, missionId]() { Remove(missionId); }, taskName_ + std::to_string(missionId), recordSaveTime_);
+            [this, missionId]() { Remove(missionId); }, taskName_ + std::to_string(missionId), missionSaveTime);
     }
 }
 

services/abilitymgr/test/unittest/phone/ability_manager_test/ability_manager_stub_mock.h

@@ -1,103 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef ABILITY_UNITTEST_ABILITY_MANAGER_STUB_MOCK_H
-#define ABILITY_UNITTEST_ABILITY_MANAGER_STUB_MOCK_H
-#include <gmock/gmock.h>
-#include <iremote_object.h>
-#include <iremote_stub.h>
-#include "hilog_wrapper.h"
-#include "ability_manager_interface.h"
-
-namespace OHOS {
-namespace AAFwk {
-class AbilityManagerStubMock : public IRemoteStub<IAbilityManager> {
-public:
-    DECLARE_INTERFACE_DESCRIPTOR(u"IAbilityManagerMock");
-
-    AbilityManagerStubMock()
-    {}
-    virtual ~AbilityManagerStubMock()
-    {}
-
-    MOCK_METHOD4(SendRequest, int(uint32_t, MessageParcel &, MessageParcel &, MessageOption &));
-    MOCK_METHOD2(StartAbility, int(const Want &, int));
-    MOCK_METHOD3(TerminateAbility, int(const sptr<IRemoteObject> &, int, const Want *));
-    MOCK_METHOD3(ConnectAbility, int(const Want &, const sptr<IAbilityConnection> &, const sptr<IRemoteObject> &));
-
-    MOCK_METHOD1(DisconnectAbility, int(const sptr<IAbilityConnection> &));
-    MOCK_METHOD3(AcquireDataAbility, sptr<IAbilityScheduler>(const Uri &, bool, const sptr<IRemoteObject> &));
-    MOCK_METHOD2(ReleaseDataAbility, int(sptr<IAbilityScheduler>, const sptr<IRemoteObject> &));
-    MOCK_METHOD2(AddWindowInfo, void(const sptr<IRemoteObject> &, int32_t));
-    MOCK_METHOD2(AttachAbilityThread, int(const sptr<IAbilityScheduler> &, const sptr<IRemoteObject> &));
-    MOCK_METHOD3(AbilityTransitionDone, int(const sptr<IRemoteObject> &, int, const PacMap &));
-    MOCK_METHOD2(ScheduleConnectAbilityDone, int(const sptr<IRemoteObject> &, const sptr<IRemoteObject> &));
-    MOCK_METHOD1(ScheduleDisconnectAbilityDone, int(const sptr<IRemoteObject> &));
-    MOCK_METHOD1(ScheduleCommandAbilityDone, int(const sptr<IRemoteObject> &));
-    MOCK_METHOD2(DumpState, void(const std::string &, std::vector<std::string> &));
-    MOCK_METHOD2(TerminateAbilityResult, int(const sptr<IRemoteObject> &, int));
-    MOCK_METHOD1(StopServiceAbility, int(const Want &));
-    MOCK_METHOD1(GetAllStackInfo, int(StackInfo &));
-    MOCK_METHOD3(GetRecentMissions, int(const int32_t, const int32_t, std::vector<AbilityMissionInfo> &));
-    MOCK_METHOD2(GetMissionSnapshot, int(const int32_t, MissionSnapshotInfo &));
-    MOCK_METHOD1(RemoveMission, int(int));
-    MOCK_METHOD1(RemoveStack, int(int));
-    MOCK_METHOD1(MoveMissionToTop, int(int32_t));
-    MOCK_METHOD1(KillProcess, int(const std::string &));
-    MOCK_METHOD1(UninstallApp, int(const std::string &));
-    MOCK_METHOD2(TerminateAbilityByCaller, int(const sptr<IRemoteObject> &callerToken, int requestCode));
-    MOCK_METHOD3(StartAbility, int(const Want &want, const sptr<IRemoteObject> &callerToken, int requestCode));
-    MOCK_METHOD2(MoveMissionToEnd, int(const sptr<IRemoteObject> &token, const bool nonFirst));
-    MOCK_METHOD1(IsFirstInMission, bool(const sptr<IRemoteObject> &token));
-    MOCK_METHOD4(CompelVerifyPermission, int(const std::string &permission, int pid, int uid, std::string &message));
-    MOCK_METHOD0(PowerOff, int());
-    MOCK_METHOD0(PowerOn, int());
-    MOCK_METHOD1(LockMission, int(int));
-    MOCK_METHOD1(UnlockMission, int(int));
-    MOCK_METHOD2(SetMissionDescriptionInfo, int(const sptr<IRemoteObject> &token, const MissionDescriptionInfo &info));
-    MOCK_METHOD0(GetMissionLockModeState, int());
-    MOCK_METHOD1(UpdateConfiguration, int(const DummyConfiguration &));
-    MOCK_METHOD2(
-        GetWantSender, sptr<IWantSender>(const WantSenderInfo &wantSenderInfo, const sptr<IRemoteObject> &callerToken));
-    MOCK_METHOD2(SendWantSender, int(const sptr<IWantSender> &target, const SenderInfo &senderInfo));
-    MOCK_METHOD1(CancelWantSender, void(const sptr<IWantSender> &sender));
-    MOCK_METHOD1(GetPendingWantUid, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantUserId, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantBundleName, std::string(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantCode, int(const sptr<IWantSender> &target));
-    MOCK_METHOD1(GetPendingWantType, int(const sptr<IWantSender> &target));
-    MOCK_METHOD2(RegisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(UnregisterCancelListener, void(const sptr<IWantSender> &sender, const sptr<IWantReceiver> &receiver));
-    MOCK_METHOD2(GetPendingRequestWant, int(const sptr<IWantSender> &target, std::shared_ptr<Want> &want));
-
-    MOCK_METHOD4(StartAbility, int(const Want &want, const AbilityStartSetting &abilityStartSetting,
-                                   const sptr<IRemoteObject> &callerToken, int requestCode));
-    MOCK_METHOD1(MoveMissionToFloatingStack, int(const MissionOption &missionOption));
-    MOCK_METHOD2(MoveMissionToSplitScreenStack, int(const MissionOption &primary, const MissionOption &secondary));
-    MOCK_METHOD2(
-        ChangeFocusAbility, int(const sptr<IRemoteObject> &lostFocusToken, const sptr<IRemoteObject> &getFocusToken));
-    MOCK_METHOD1(MinimizeMultiWindow, int(int missionId));
-    MOCK_METHOD1(GetFloatingMissions, int(std::vector<AbilityMissionInfo> &list));
-    MOCK_METHOD1(CloseMultiWindow, int(int missionId));
-    MOCK_METHOD1(SetMissionStackSetting, int(const StackSetting &stackSetting));
-    MOCK_METHOD1(MaximizeMultiWindow, int(int missionId));
-    MOCK_METHOD1(ChangeFocusTest, void(const std::vector<int> missionId));
-    MOCK_METHOD1(TerminateAbilityTest, void(int id));
-    MOCK_METHOD1(MoveMissionToEnd, int(int id));
-};
-}  // namespace AAFwk
-}  // namespace OHOS
-
-#endif

services/abilitymgr/test/unittest/phone/ability_manager_test/ability_manager_test.cpp

@@ -1,331 +0,0 @@
-/*
- * Copyright (c) 2021 Huawei Device Co., Ltd.
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gtest/gtest.h>
-
-#define private public
-#define protected public
-#include "system_ability_definition.h"
-#include "ability_manager_client.h"
-#undef private
-#undef protected
-
-#include "ability_manager_stub_mock.h"
-#include "ability_scheduler_mock.h"
-#include "ability_manager_service.h"
-#include "iservice_registry.h"
-#include "ability_record.h"
-#include "ability_scheduler.h"
-#include "mock_ability_connect_callback.h"
-#include "mock_bundle_manager.h"
-#include "sa_mgr_client.h"
-
-using namespace testing::ext;
-using namespace OHOS::AppExecFwk;
-
-namespace OHOS {
-namespace AAFwk {
-namespace {
-const std::string LAUNCHER_ABILITY = "MainAbility";
-const std::string LAUNCHER_BUNDLE = "com.ohos.hiworld";
-const std::string NAME_BUNDLE_MGR_SERVICE = "BundleMgrService";
-const std::string NAME_ABILITY_MGR_SERVICE = "AbilityManagerService";
-const std::string SERVICE_ABILITY = "ServiceAbility";
-const std::string SERVICE_BUNDLE = "com.ohos.hiservcie";
-}  // namespace
-
-class AbilityManagerTest : public testing::Test {
-public:
-    static void SetUpTestCase(void);
-    static void TearDownTestCase(void);
-    void SetUp();
-    void TearDown();
-
-public:
-    static constexpr int TEST_WAIT_TIME = 100000;
-    std::shared_ptr<AbilityManagerClient> abilityClient_ = nullptr;
-    sptr<AbilityManagerStubMock> mock_ {nullptr};
-    Want want_ {};
-};
-
-void AbilityManagerTest::SetUpTestCase(void)
-{}
-void AbilityManagerTest::TearDownTestCase(void)
-{}
-void AbilityManagerTest::TearDown(void)
-{}
-
-void AbilityManagerTest::SetUp(void)
-{
-    abilityClient_ = std::make_shared<AbilityManagerClient>();
-    mock_ = new AbilityManagerStubMock();
-}
-
-/*
- * Feature: AbilityManagerClient
- * Function: StartAbility
- * SubFunction: NA
- * FunctionPoints: AbilityManagerClient StartAbility
- * EnvConditions: NA
- * CaseDescription: Verify the normal and abnormal cases of startability
- */
-HWTEST_F(AbilityManagerTest, AAFWK_AbilityMS_AbilityManager_test_001, TestSize.Level2)
-{
-    abilityClient_->remoteObject_ = mock_;
-    EXPECT_CALL(*mock_, StartAbility(::testing::_, ::testing::_)).Times(1);
-    EXPECT_EQ(abilityClient_->StartAbility(want_), 0);
-
-    abilityClient_->remoteObject_ = nullptr;
-    EXPECT_EQ(abilityClient_->StartAbility(want_), ABILITY_SERVICE_NOT_CONNECTED);
-}
-
-/*
- * Feature: AbilityManagerClient
- * Function: AttachAbilityThread
- * SubFunction: NA
- * FunctionPoints: AbilityManagerClient AttachAbilityThread
- * EnvConditions: NA
- * CaseDescription: Verify the normal and abnormal cases of attachAbilityThread
- */
-HWTEST_F(AbilityManagerTest, AAFWK_AbilityMS_AbilityManager_test_002, TestSize.Level2)
-{
-    abilityClient_->remoteObject_ = mock_;
-    EXPECT_CALL(*mock_, AttachAbilityThread(::testing::_, ::testing::_)).Times(1);
-
-    sptr<IAbilityScheduler> scheduler = new AbilitySchedulerMock();
-    sptr<IRemoteObject> token = nullptr;
-    EXPECT_EQ(abilityClient_->AttachAbilityThread(scheduler, token), 0);
-
-    abilityClient_->remoteObject_ = nullptr;
-    EXPECT_EQ(abilityClient_->AttachAbilityThread(scheduler, token), ABILITY_SERVICE_NOT_CONNECTED);
-}
-
-/*
- * Feature: AbilityManagerClient
- * Function: AbilityTransitionDone
- * SubFunction: NA
- * FunctionPoints: AbilityManagerClient AbilityTransitionDone
- * EnvConditions: NA
- * CaseDescription: Verify the normal and abnormal cases of abilityTransitionDone
- */
-HWTEST_F(AbilityManagerTest, AAFWK_AbilityMS_AbilityManager_test_003, TestSize.Level2)
-{
-    abilityClient_->remoteObject_ = mock_;
-    EXPECT_CALL(*mock_, AbilityTransitionDone(::testing::_, ::testing::_, ::testing::_)).Times(1);
-
-    sptr<IAbilityScheduler> scheduler = new AbilitySchedulerMock();
-    sptr<IRemoteObject> token = nullptr;
-    PacMap saveData;
-    EXPECT_EQ(abilityClient_->AbilityTransitionDone(token, 1, saveData), 0);
-
-    abilityClient_->remoteObject_ = nullptr;
-    EXPECT_EQ(abilityClient_->AbilityTransitionDone(token, 1, saveData), ABILITY_SERVICE_NOT_CONNECTED);
-}
-
-/*
- * Feature: AbilityManagerClient
- * Function: ScheduleConnectAbilityDone
- * SubFunction: NA
- * FunctionPoints: AbilityManagerClient ScheduleConnectAbilityDone
- * EnvConditions: NA
- * CaseDescription: Verify the normal and abnormal cases of scheduleConnectAbilityDone
- */
-HWTEST_F(AbilityManagerTest, AAFWK_AbilityMS_AbilityManager_test_004, TestSize.Level2)
-{
-    abilityClient_->remoteObject_ = mock_;
-    EXPECT_CALL(*mock_, ScheduleConnectAbilityDone(::testing::_, ::testing::_)).Times(1);
-
-    sptr<IAbilityScheduler> scheduler = new AbilitySchedulerMock();
-    sptr<IRemoteObject> token = nullptr;
-    sptr<IRemoteObject> remoteObject = nullptr;
-    EXPECT_EQ(abilityClient_->ScheduleConnectAbilityDone(token, remoteObject), 0);
-
-    abilityClient_->remoteObject_ = nullptr;
-    EXPECT_EQ(abilityClient_->ScheduleConnectAbilityDone(token, remoteObject), ABILITY_SERVICE_NOT_CONNECTED);
-}
-
-/*
- * Feature: AbilityManagerClient
- * Function: ScheduleDisconnectAbilityDone
- * SubFunction: NA
- * FunctionPoints: AbilityManagerClient ScheduleDisconnectAbilityDone
- * EnvConditions: NA
- * CaseDescription: Verify the normal and abnormal cases of scheduleDisconnectAbilityDone
- */
-HWTEST_F(AbilityManagerTest, AAFWK_AbilityMS_AbilityManager_test_005, TestSize.Level2)
-{
-    abilityClient_->remoteObject_ = mock_;
-    EXPECT_CALL(*mock_, ScheduleDisconnectAbilityDone(::testing::_)).Times(1);
-
-    sptr<IAbilityScheduler> scheduler = new AbilitySchedulerMock();
-    sptr<IRemoteObject> token = nullptr;
-    sptr<IRemoteObject> remoteObject = nullptr;
-    EXPECT_EQ(abilityClient_->ScheduleDisconnectAbilityDone(token), 0);
-
-    abilityClient_->remoteObject_ = nullptr;
-    EXPECT_EQ(abilityClient_->ScheduleDisconnectAbilityDone(token), ABILITY_SERVICE_NOT_CONNECTED);
-}
-
-/*
- * Feature: AbilityManagerClient
- * Function: AddWindowInfo
- * SubFunction: NA
- * FunctionPoints: AbilityManagerClient AddWindowInfo
- * EnvConditions: NA
- * CaseDescription: Verify the normal and abnormal cases of addWindowInfo
- */
-HWTEST_F(AbilityManagerTest, AAFWK_AbilityMS_AbilityManager_test_006, TestSize.Level2)
-{
-    std::string args;
-    abilityClient_->remoteObject_ = mock_;
-    EXPECT_CALL(*mock_, AddWindowInfo(::testing::_, ::testing::_)).Times(1);
-
-    sptr<IAbilityScheduler> scheduler = new AbilitySchedulerMock();
-    sptr<IRemoteObject> token = nullptr;
-    int32_t t = 1;
-    abilityClient_->AddWindowInfo(token, t);
-    abilityClient_->remoteObject_ = nullptr;
-    abilityClient_->AddWindowInfo(token, 1);
-}
-
-/*
- * Feature: AbilityManagerClient
- * Function: TerminateAbility
- * SubFunction: NA
- * FunctionPoints: AbilityManagerClient TerminateAbility
- * EnvConditions: NA
- * CaseDescription: Verify the normal and abnormal cases of terminateAbility
- */
-HWTEST_F(AbilityManagerTest, AAFWK_AbilityMS_AbilityManager_test_007, TestSize.Level2)
-{
-    abilityClient_->remoteObject_ = mock_;
-    EXPECT_CALL(*mock_, TerminateAbility(::testing::_, ::testing::_, ::testing::_)).Times(1);
-
-    sptr<IAbilityScheduler> scheduler = new AbilitySchedulerMock();
-    sptr<IRemoteObject> token = nullptr;
-    EXPECT_EQ(abilityClient_->TerminateAbility(token, 1, &want_), 0);
-
-    abilityClient_->remoteObject_ = nullptr;
-    EXPECT_EQ(abilityClient_->TerminateAbility(token, 1, &want_), ABILITY_SERVICE_NOT_CONNECTED);
-}
-
-/*
- * Feature: AbilityManagerClient
- * Function: ConnectAbility
- * SubFunction: NA
- * FunctionPoints: AbilityManagerClient ConnectAbility
- * EnvConditions: NA
- * CaseDescription: Verify the normal and abnormal cases of ConnectAbility
- */
-HWTEST_F(AbilityManagerTest, AAFWK_AbilityMS_AbilityManager_test_008, TestSize.Level2)
-{
-    abilityClient_->remoteObject_ = mock_;
-    EXPECT_CALL(*mock_, ConnectAbility(::testing::_, ::testing::_, ::testing::_)).Times(1);
-
-    sptr<IAbilityConnection> connect = nullptr;
-    sptr<IRemoteObject> callerToken = nullptr;
-    EXPECT_EQ(abilityClient_->ConnectAbility(want_, connect, callerToken), 0);
-
-    abilityClient_->remoteObject_ = nullptr;
-    EXPECT_EQ(abilityClient_->ConnectAbility(want_, connect, callerToken), ABILITY_SERVICE_NOT_CONNECTED);
-}
-
-/*
- * Feature: AbilityManagerClient
- * Function: DisconnectAbility
- * SubFunction: NA
- * FunctionPoints: AbilityManagerClient DisconnectAbility
- * EnvConditions: NA
- * CaseDescription: Verify the normal and abnormal cases of DisconnectAbility
- */
-HWTEST_F(AbilityManagerTest, AAFWK_AbilityMS_AbilityManager_test_009, TestSize.Level2)
-{
-    abilityClient_->remoteObject_ = mock_;
-    EXPECT_CALL(*mock_, DisconnectAbility(::testing::_)).Times(1);
-
-    sptr<IAbilityConnection> connect = nullptr;
-    EXPECT_EQ(abilityClient_->DisconnectAbility(connect), 0);
-
-    abilityClient_->remoteObject_ = nullptr;
-    EXPECT_EQ(abilityClient_->DisconnectAbility(connect), ABILITY_SERVICE_NOT_CONNECTED);
-}
-
-/*
- * Feature: AbilityManagerClient
- * Function: DumpState
- * SubFunction: NA
- * FunctionPoints: AbilityManagerClient DumpState
- * EnvConditions: NA
- * CaseDescription: Verify the normal and abnormal cases of DumpState
- */
-HWTEST_F(AbilityManagerTest, AAFWK_AbilityMS_AbilityManager_test_010, TestSize.Level2)
-{
-    std::string args;
-    std::vector<std::string> vec;
-    abilityClient_->remoteObject_ = mock_;
-    EXPECT_CALL(*mock_, DumpState(::testing::_, ::testing::_)).Times(1);
-
-    sptr<IAbilityConnection> connect = nullptr;
-    EXPECT_EQ(abilityClient_->DumpState(args, vec), 0);
-
-    abilityClient_->remoteObject_ = nullptr;
-    EXPECT_EQ(abilityClient_->DumpState(args, vec), ABILITY_SERVICE_NOT_CONNECTED);
-}
-
-/*
- * Feature: AbilityManagerClient
- * Function: GetAllStackInfo
- * SubFunction: NA
- * FunctionPoints: AbilityManagerClient GetAllStackInfo
- * EnvConditions: NA
- * CaseDescription: Verify the normal and abnormal cases of GetAllStackInfo
- */
-HWTEST_F(AbilityManagerTest, AAFWK_AbilityMS_AbilityManager_test_011, TestSize.Level2)
-{
-    std::string args;
-    std::vector<std::string> vec;
-    abilityClient_->remoteObject_ = mock_;
-    EXPECT_CALL(*mock_, GetAllStackInfo(::testing::_)).Times(1);
-
-    StackInfo info;
-    EXPECT_EQ(abilityClient_->GetAllStackInfo(info), 0);
-
-    abilityClient_->remoteObject_ = nullptr;
-    EXPECT_EQ(abilityClient_->GetAllStackInfo(info), ABILITY_SERVICE_NOT_CONNECTED);
-}
-
-/*
- * Feature: AbilityManagerClient
- * Function: Connect
- * SubFunction: NA
- * FunctionPoints: AbilityManagerClient Connect
- * EnvConditions: NA
- * CaseDescription: Verify Connect operation
- */
-HWTEST_F(AbilityManagerTest, AAFWK_AbilityMS_AbilityManager_test_012, TestSize.Level2)
-{
-    abilityClient_->remoteObject_ = mock_;
-    EXPECT_EQ(abilityClient_->Connect(), 0);
-
-    sptr<ISystemAbilityManager> manager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
-    ISystemAbilityManager::SAExtraProp prop;
-    manager->AddSystemAbility(ABILITY_MGR_SERVICE_ID, mock_, prop);
-
-    abilityClient_->remoteObject_ = nullptr;
-
-    EXPECT_EQ(abilityClient_->Connect(), 0);
-}
-}  // namespace AAFwk
-}  // namespace OHOS