1 /*
2  * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include <memory>
18 
19 #define private public
20 #define protected public
21 #include "ability_connect_manager.h"
22 #undef private
23 #undef protected
24 
25 #include "ability_config.h"
26 #include "ability_manager_errors.h"
27 #include "ability_scheduler.h"
28 #include "ability_util.h"
29 #include "bundlemgr/mock_bundle_manager.h"
30 #include "hilog_tag_wrapper.h"
31 #include "mock_ability_connect_callback.h"
32 #include "mock_sa_call.h"
33 #include "sa_mgr_client.h"
34 #include "system_ability_definition.h"
35 
36 using namespace testing::ext;
37 using namespace OHOS::AppExecFwk;
38 
39 namespace OHOS {
40 namespace AAFwk {
41 template<typename F>
WaitUntilTaskCalled(const F & f,const std::shared_ptr<TaskHandlerWrap> & handler,std::atomic<bool> & taskCalled)42 static void WaitUntilTaskCalled(const F& f, const std::shared_ptr<TaskHandlerWrap>& handler,
43     std::atomic<bool>& taskCalled)
44 {
45     const uint32_t maxRetryCount = 1000;
46     const uint32_t sleepTime = 1000;
47     uint32_t count = 0;
48     if (handler->SubmitTask(f)) {
49         while (!taskCalled.load()) {
50             ++count;
51             // if delay more than 1 second, break
52             if (count >= maxRetryCount) {
53                 break;
54             }
55             usleep(sleepTime);
56         }
57     }
58 }
59 
WaitUntilTaskDone(const std::shared_ptr<TaskHandlerWrap> & handler)60 static void WaitUntilTaskDone(const std::shared_ptr<TaskHandlerWrap>& handler)
61 {
62     std::atomic<bool> taskCalled(false);
63     auto f = [&taskCalled]() { taskCalled.store(true); };
64     WaitUntilTaskCalled(f, handler, taskCalled);
65 }
66 
67 class AbilityConnectManagerTest : public testing::Test {
68 public:
69     static void SetUpTestCase(void);
70     static void TearDownTestCase(void);
71     void SetUp();
72     void TearDown();
73 
74     AbilityConnectManager* ConnectManager() const;
75     std::shared_ptr<TaskHandlerWrap> TaskHandler() const;
76     std::shared_ptr<EventHandlerWrap> EventHandler() const;
77 
78     AbilityRequest GenerateAbilityRequest(const std::string& deviceName, const std::string& abilityName,
79         const std::string& appName, const std::string& bundleName, const std::string& moduleName);
80 
81     static constexpr int TEST_WAIT_TIME = 1000000;
82 
83     sptr<SessionInfo> MockSessionInfo(int32_t persistentId);
84     std::shared_ptr<AbilityRecord> InitAbilityRecord();
85 
86 protected:
87     AbilityRequest abilityRequest_{};
88     AbilityRequest abilityRequest1_{};
89     AbilityRequest abilityRequest2_{};
90     std::shared_ptr<AbilityRecord> serviceRecord_{ nullptr };
91     std::shared_ptr<AbilityRecord> serviceRecord1_{ nullptr };
92     std::shared_ptr<AbilityRecord> serviceRecord2_{ nullptr };
93     OHOS::sptr<Token> serviceToken_{ nullptr };
94     OHOS::sptr<Token> serviceToken1_{ nullptr };
95     OHOS::sptr<Token> serviceToken2_{ nullptr };
96     OHOS::sptr<IAbilityConnection> callbackA_{ nullptr };
97     OHOS::sptr<IAbilityConnection> callbackB_{ nullptr };
98 
99 private:
100     std::shared_ptr<AbilityConnectManager> connectManager_;
101     std::shared_ptr<TaskHandlerWrap> taskHandler_;
102     std::shared_ptr<EventHandlerWrap> eventHandler_;
103 };
104 
GenerateAbilityRequest(const std::string & deviceName,const std::string & abilityName,const std::string & appName,const std::string & bundleName,const std::string & moduleName)105 AbilityRequest AbilityConnectManagerTest::GenerateAbilityRequest(const std::string& deviceName,
106     const std::string& abilityName, const std::string& appName, const std::string& bundleName,
107     const std::string& moduleName)
108 {
109     ElementName element(deviceName, bundleName, abilityName, moduleName);
110     Want want;
111     want.SetElement(element);
112 
113     AbilityInfo abilityInfo;
114     abilityInfo.visible = true;
115     abilityInfo.applicationName = appName;
116     abilityInfo.type = AbilityType::SERVICE;
117     abilityInfo.name = abilityName;
118     abilityInfo.bundleName = bundleName;
119     abilityInfo.moduleName = moduleName;
120     abilityInfo.deviceId = deviceName;
121     ApplicationInfo appinfo;
122     appinfo.name = appName;
123     abilityInfo.applicationInfo = appinfo;
124     AbilityRequest abilityRequest;
125     abilityRequest.want = want;
126     abilityRequest.abilityInfo = abilityInfo;
127     abilityRequest.appInfo = appinfo;
128     abilityInfo.process = bundleName;
129 
130     return abilityRequest;
131 }
132 
MockSessionInfo(int32_t persistentId)133 sptr<SessionInfo> AbilityConnectManagerTest::MockSessionInfo(int32_t persistentId)
134 {
135     sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
136     if (!sessionInfo) {
137         TAG_LOGE(AAFwkTag::TEST, "sessionInfo is nullptr");
138         return nullptr;
139     }
140     sessionInfo->persistentId = persistentId;
141     return sessionInfo;
142 }
143 
InitAbilityRecord()144 std::shared_ptr<AbilityRecord> AbilityConnectManagerTest::InitAbilityRecord()
145 {
146     AbilityRequest abilityRequest;
147     abilityRequest.appInfo.bundleName = "com.example.unittest";
148     abilityRequest.abilityInfo.name = "MainAbility";
149     abilityRequest.abilityInfo.type = AbilityType::PAGE;
150     std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
151     return abilityRecord;
152 }
153 
SetUpTestCase(void)154 void AbilityConnectManagerTest::SetUpTestCase(void)
155 {}
TearDownTestCase(void)156 void AbilityConnectManagerTest::TearDownTestCase(void)
157 {}
158 
SetUp(void)159 void AbilityConnectManagerTest::SetUp(void)
160 {
161     connectManager_ = std::make_unique<AbilityConnectManager>(0);
162     taskHandler_ = TaskHandlerWrap::CreateQueueHandler("AbilityConnectManagerTest");
163     eventHandler_ = std::make_shared<EventHandlerWrap>(taskHandler_);
164     // generate ability request
165     std::string deviceName = "device";
166     std::string abilityName = "ServiceAbility";
167     std::string appName = "hiservcie";
168     std::string bundleName = "com.ix.hiservcie";
169     std::string moduleName = "entry";
170     abilityRequest_ = GenerateAbilityRequest(deviceName, abilityName, appName, bundleName, moduleName);
171     serviceRecord_ = AbilityRecord::CreateAbilityRecord(abilityRequest_);
172     serviceToken_ = serviceRecord_->GetToken();
173     std::string deviceName1 = "device";
174     std::string abilityName1 = "musicServiceAbility";
175     std::string appName1 = "musicservcie";
176     std::string bundleName1 = "com.ix.musicservcie";
177     std::string moduleName1 = "entry";
178     abilityRequest1_ = GenerateAbilityRequest(deviceName1, abilityName1, appName1, bundleName1, moduleName1);
179     serviceRecord1_ = AbilityRecord::CreateAbilityRecord(abilityRequest1_);
180     std::string deviceName2 = "device";
181     std::string abilityName2 = "residentServiceAbility";
182     std::string appName2 = "residentservcie";
183     std::string bundleName2 = "com.ix.residentservcie";
184     std::string moduleName2 = "entry";
185     abilityRequest2_ = GenerateAbilityRequest(deviceName2, abilityName2, appName2, bundleName2, moduleName2);
186     serviceRecord2_ = AbilityRecord::CreateAbilityRecord(abilityRequest2_);
187     serviceToken2_ = serviceRecord_->GetToken();
188     serviceToken1_ = serviceRecord_->GetToken();
189     callbackA_ = new AbilityConnectCallback();
190     callbackB_ = new AbilityConnectCallback();
191     // mock bms
192     OHOS::DelayedSingleton<SaMgrClient>::GetInstance()->RegisterSystemAbility(
193         OHOS::BUNDLE_MGR_SERVICE_SYS_ABILITY_ID, new BundleMgrService());
194 }
195 
TearDown(void)196 void AbilityConnectManagerTest::TearDown(void)
197 {
198     // reset the callback count
199     AbilityConnectCallback::onAbilityConnectDoneCount = 0;
200     AbilityConnectCallback::onAbilityDisconnectDoneCount = 0;
201     serviceRecord_ = nullptr;
202 }
203 
ConnectManager() const204 AbilityConnectManager* AbilityConnectManagerTest::ConnectManager() const
205 {
206     return connectManager_.get();
207 }
208 
TaskHandler() const209 std::shared_ptr<TaskHandlerWrap> AbilityConnectManagerTest::TaskHandler() const
210 {
211     return taskHandler_;
212 }
213 
EventHandler() const214 std::shared_ptr<EventHandlerWrap> AbilityConnectManagerTest::EventHandler() const
215 {
216     return eventHandler_;
217 }
218 
219 /*
220  * Feature: AbilityConnectManager
221  * Function: StartAbility
222  * SubFunction: NA
223  * FunctionPoints: StartAbility
224  * EnvConditions:NA
225  * CaseDescription: Verify the normal process of startability
226  */
227 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_001, TestSize.Level1)
228 {
229     ConnectManager()->SetTaskHandler(TaskHandler());
230     ConnectManager()->SetEventHandler(EventHandler());
231 
232     auto result = ConnectManager()->StartAbility(abilityRequest_);
233     EXPECT_EQ(OHOS::ERR_OK, result);
234     WaitUntilTaskDone(TaskHandler());
235 
236     auto elementName = abilityRequest_.want.GetElement().GetURI();
237     auto service = ConnectManager()->GetServiceRecordByElementName(elementName);
238     EXPECT_NE(service, nullptr);
239     EXPECT_EQ(static_cast<int>(ConnectManager()->GetServiceMap().size()), 1);
240 
241     service->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
242 
243     auto result1 = ConnectManager()->StartAbility(abilityRequest_);
244     WaitUntilTaskDone(TaskHandler());
245     EXPECT_EQ(OHOS::ERR_OK, result1);
246     EXPECT_EQ(static_cast<int>(ConnectManager()->GetServiceMap().size()), 1);
247 
248     service->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVATING);
249     auto result2 = ConnectManager()->StartAbility(abilityRequest_);
250     WaitUntilTaskDone(TaskHandler());
251     EXPECT_EQ(OHOS::ERR_OK, result2);
252     EXPECT_EQ(static_cast<int>(ConnectManager()->GetServiceMap().size()), 1);
253 }
254 
255 /*
256  * Feature: AbilityConnectManager
257  * Function: TerminateAbility
258  * SubFunction: NA
259  * FunctionPoints: StartAbility and TerminateAbility
260  * EnvConditions:NA
261  * CaseDescription: Verify the following:
262  * 1.token is nullptr, terminate ability failed
263  * 2.token is not nullptr, terminate ability success, and verify the status
264  */
265 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_002, TestSize.Level1)
266 {
267     ConnectManager()->SetTaskHandler(TaskHandler());
268     ConnectManager()->SetEventHandler(EventHandler());
269 
270     auto result = ConnectManager()->StartAbility(abilityRequest_);
271     EXPECT_EQ(OHOS::ERR_OK, result);
272     WaitUntilTaskDone(TaskHandler());
273 
274     OHOS::sptr<OHOS::IRemoteObject> nullToken = nullptr;
275     auto result1 = ConnectManager()->TerminateAbility(nullToken);
276     EXPECT_EQ(OHOS::ERR_INVALID_VALUE, result1);
277 
278     auto elementName = abilityRequest_.want.GetElement().GetURI();
279     auto service = ConnectManager()->GetServiceRecordByElementName(elementName);
280     EXPECT_NE(service, nullptr);
281 
282     auto result2 = ConnectManager()->TerminateAbility(service->GetToken());
283     WaitUntilTaskDone(TaskHandler());
284     EXPECT_EQ(OHOS::ERR_OK, result2);
285     EXPECT_EQ(service->GetAbilityState(), TERMINATING);
286 }
287 
288 /*
289  * Feature: AbilityConnectManager
290  * Function: TerminateAbility
291  * SubFunction: NA
292  * FunctionPoints: StartAbility and TerminateAbility
293  * EnvConditions:NA
294  * CaseDescription: Verify ability is terminating, terminate ability success
295  */
296 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_003, TestSize.Level1)
297 {
298     ConnectManager()->SetTaskHandler(TaskHandler());
299     ConnectManager()->SetEventHandler(EventHandler());
300 
301     auto result = ConnectManager()->StartAbility(abilityRequest_);
302     EXPECT_EQ(OHOS::ERR_OK, result);
303     WaitUntilTaskDone(TaskHandler());
304 
305     auto elementName = abilityRequest_.want.GetElement().GetURI();
306     auto service = ConnectManager()->GetServiceRecordByElementName(elementName);
307     EXPECT_NE(service, nullptr);
308 
309     service->SetTerminatingState();
310     auto result1 = ConnectManager()->TerminateAbility(service->GetToken());
311     WaitUntilTaskDone(TaskHandler());
312     EXPECT_EQ(OHOS::ERR_OK, result1);
313     EXPECT_NE(service->GetAbilityState(), TERMINATING);
314 }
315 
316 /*
317  * Feature: AbilityConnectManager
318  * Function: TerminateAbility
319  * SubFunction: NA
320  * FunctionPoints: StartAbility and TerminateAbility
321  * EnvConditions: NA
322  * CaseDescription: Verify service is connected, terminate ability failed
323  */
324 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_004, TestSize.Level1)
325 {
326     ConnectManager()->SetTaskHandler(TaskHandler());
327     ConnectManager()->SetEventHandler(EventHandler());
328 
329     auto result = ConnectManager()->StartAbility(abilityRequest_);
330     EXPECT_EQ(OHOS::ERR_OK, result);
331     WaitUntilTaskDone(TaskHandler());
332 
333     auto result1 = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
334     EXPECT_EQ(0, result1);
335 
336     auto elementName = abilityRequest_.want.GetElement().GetURI();
337     auto service = ConnectManager()->GetServiceRecordByElementName(elementName);
338     EXPECT_NE(service, nullptr);
339 
340     auto result2 = ConnectManager()->TerminateAbility(service->GetToken());
341     WaitUntilTaskDone(TaskHandler());
342     EXPECT_EQ(0, result2);
343     EXPECT_EQ(service->GetAbilityState(), TERMINATING);
344 }
345 
346 /*
347  * Feature: AbilityConnectManager
348  * Function: StopServiceAbility
349  * SubFunction: NA
350  * FunctionPoints: StartAbility and StopServiceAbility
351  * EnvConditions: NA
352  * CaseDescription: Verify the following:
353  * 1.token is nullptr, stop service ability failed
354  * 2.token is not nullptr, stop service ability success, and verify the status
355  */
356 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_005, TestSize.Level1)
357 {
358     ConnectManager()->SetTaskHandler(TaskHandler());
359     ConnectManager()->SetEventHandler(EventHandler());
360 
361     auto result = ConnectManager()->StartAbility(abilityRequest_);
362     EXPECT_EQ(OHOS::ERR_OK, result);
363     WaitUntilTaskDone(TaskHandler());
364 
365     auto elementName = abilityRequest_.want.GetElement().GetURI();
366     auto service = ConnectManager()->GetServiceRecordByElementName(elementName);
367     EXPECT_NE(service, nullptr);
368 
369     AbilityRequest otherRequest;
370     auto result1 = ConnectManager()->StopServiceAbility(otherRequest);
371     WaitUntilTaskDone(TaskHandler());
372     EXPECT_EQ(OHOS::ERR_INVALID_VALUE, result1);
373 
374     auto result2 = ConnectManager()->StopServiceAbility(abilityRequest_);
375     WaitUntilTaskDone(TaskHandler());
376     EXPECT_EQ(OHOS::ERR_OK, result2);
377     EXPECT_EQ(service->GetAbilityState(), TERMINATING);
378 }
379 
380 /*
381  * Feature: AbilityConnectManager
382  * Function: StopServiceAbility
383  * SubFunction: NA
384  * FunctionPoints: StartAbility and StopServiceAbility
385  * EnvConditions:NA
386  * CaseDescription: Verify ability is terminating, stop service ability success
387  */
388 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_006, TestSize.Level1)
389 {
390     ConnectManager()->SetTaskHandler(TaskHandler());
391     ConnectManager()->SetEventHandler(EventHandler());
392 
393     auto result = ConnectManager()->StartAbility(abilityRequest_);
394     EXPECT_EQ(OHOS::ERR_OK, result);
395     WaitUntilTaskDone(TaskHandler());
396 
397     auto elementName = abilityRequest_.want.GetElement().GetURI();
398     auto service = ConnectManager()->GetServiceRecordByElementName(elementName);
399     EXPECT_NE(service, nullptr);
400 
401     service->SetTerminatingState();
402     auto result1 = ConnectManager()->StopServiceAbility(abilityRequest_);
403     WaitUntilTaskDone(TaskHandler());
404     EXPECT_EQ(OHOS::ERR_OK, result1);
405     EXPECT_NE(service->GetAbilityState(), TERMINATING);
406 }
407 
408 /*
409  * Feature: AbilityConnectManager
410  * Function: StopServiceAbility
411  * SubFunction: NA
412  * FunctionPoints: StartAbility and StopServiceAbility
413  * EnvConditions: NA
414  * CaseDescription: Verify service is connected, stop service ability failed
415  */
416 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_007, TestSize.Level1)
417 {
418     ConnectManager()->SetTaskHandler(TaskHandler());
419     ConnectManager()->SetEventHandler(EventHandler());
420 
421     auto result = ConnectManager()->StartAbility(abilityRequest_);
422     EXPECT_EQ(OHOS::ERR_OK, result);
423     WaitUntilTaskDone(TaskHandler());
424 
425     auto result1 = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
426     EXPECT_EQ(0, result1);
427 
428     auto elementName = abilityRequest_.want.GetElement().GetURI();
429     auto service = ConnectManager()->GetServiceRecordByElementName(elementName);
430     EXPECT_NE(service, nullptr);
431 
432     auto result2 = ConnectManager()->StopServiceAbility(abilityRequest_);
433     WaitUntilTaskDone(TaskHandler());
434     EXPECT_EQ(0, result2);
435     EXPECT_EQ(service->GetAbilityState(), TERMINATING);
436 }
437 
438 /*
439  * Feature: AbilityConnectManager
440  * Function: ConnectAbilityLocked
441  * SubFunction: NA
442  * FunctionPoints: NA
443  * EnvConditions:NA
444  * CaseDescription: verify the scene of service not loaded and callback not bound.
445  */
446 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_008, TestSize.Level1)
447 {
448     int result = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
449     EXPECT_EQ(0, result);
450 
451     auto connectMap = ConnectManager()->connectMap_;
452     auto connectRecordList = connectMap.at(callbackA_->AsObject());
453     EXPECT_EQ(1, static_cast<int>(connectRecordList.size()));
454 
455     auto elementName = abilityRequest_.want.GetElement();
456     auto elementNameUri = elementName.GetURI();
457     auto serviceMap = ConnectManager()->GetServiceMap();
458     auto abilityRecord = serviceMap.at(elementNameUri);
459     connectRecordList = abilityRecord->GetConnectRecordList();
460     EXPECT_EQ(1, static_cast<int>(connectRecordList.size()));
461 }
462 
463 /*
464  * Feature: AbilityConnectManager
465  * Function: ConnectAbilityLocked
466  * SubFunction: NA
467  * FunctionPoints: NA
468  * EnvConditions:NA
469  * CaseDescription: verify the scene of service load ability's timeout.
470  */
471 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_009, TestSize.Level1)
472 {
473     ConnectManager()->SetTaskHandler(TaskHandler());
474     ConnectManager()->SetEventHandler(EventHandler());
475     int result = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
476     EXPECT_EQ(0, result);
477 
478     auto connectMap = ConnectManager()->connectMap_;
479     EXPECT_EQ(1, static_cast<int>(connectMap.size()));
480     WaitUntilTaskDone(TaskHandler());
481     usleep(TEST_WAIT_TIME);
482 
483     connectMap = ConnectManager()->connectMap_;
484     EXPECT_EQ(1, static_cast<int>(connectMap.size()));
485 }
486 
487 /*
488  * Feature: AbilityConnectManager
489  * Function: ConnectAbilityLocked
490  * SubFunction: NA
491  * FunctionPoints: NA
492  * EnvConditions:NA
493  * CaseDescription: verify the scene of service loaded and callback not bound.
494  */
495 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_010, TestSize.Level1)
496 {
497     auto result = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
498     EXPECT_EQ(0, result);
499 
500     result = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackB_, nullptr);
501     EXPECT_EQ(0, result);
502 
503     auto connectMap = ConnectManager()->connectMap_;
504     auto connectRecordList = connectMap.at(callbackA_->AsObject());
505     EXPECT_EQ(1, static_cast<int>(connectRecordList.size()));
506 
507     connectRecordList = connectMap.at(callbackB_->AsObject());
508     EXPECT_EQ(1, static_cast<int>(connectRecordList.size()));
509 
510     auto elementName = abilityRequest_.want.GetElement();
511     std::string elementNameUri = elementName.GetURI();
512     auto serviceMap = ConnectManager()->GetServiceMap();
513     auto abilityRecord = serviceMap.at(elementNameUri);
514     connectRecordList = abilityRecord->GetConnectRecordList();
515     EXPECT_EQ(2, static_cast<int>(connectRecordList.size()));
516 }
517 
518 /*
519  * Feature: AbilityConnectManager
520  * Function: ConnectAbilityLocked
521  * SubFunction: NA
522  * FunctionPoints: NA
523  * EnvConditions:NA
524  * CaseDescription: verify the scene of service connect ability's timeout.
525  */
526 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_011, TestSize.Level1)
527 {
528     ConnectManager()->SetTaskHandler(TaskHandler());
529     ConnectManager()->SetEventHandler(EventHandler());
530 
531     int result = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
532     auto elementName = abilityRequest_.want.GetElement();
533     std::string elementNameUri = elementName.GetURI();
534     auto serviceMap = ConnectManager()->GetServiceMap();
535     auto abilityRecord = serviceMap.at(elementNameUri);
536     auto token = abilityRecord->GetToken();
537 
538     auto connectMap = ConnectManager()->connectMap_;
539     EXPECT_EQ(1, static_cast<int>(connectMap.size()));
540 
541     auto scheduler = new AbilityScheduler();
542     ConnectManager()->AttachAbilityThreadLocked(scheduler, token->AsObject());
543     ConnectManager()->AbilityTransitionDone(token->AsObject(), OHOS::AAFwk::AbilityState::INACTIVE);
544 
545     WaitUntilTaskDone(TaskHandler());
546     usleep(TEST_WAIT_TIME);
547     connectMap = ConnectManager()->connectMap_;
548     EXPECT_EQ(0, result);
549     EXPECT_EQ(1, static_cast<int>(connectMap.size()));
550 }
551 
552 /*
553  * Feature: AbilityConnectManager
554  * Function: ConnectAbilityLocked
555  * SubFunction: NA
556  * FunctionPoints: NA
557  * EnvConditions:NA
558  * CaseDescription: verify the scene of service loaded and callback bound.
559  */
560 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_012, TestSize.Level1)
561 {
562     auto result = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
563     EXPECT_EQ(0, result);
564 
565     result = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
566     EXPECT_EQ(0, result);
567 
568     auto connectMap = ConnectManager()->connectMap_;
569     auto connectRecordList = connectMap.at(callbackA_->AsObject());
570     EXPECT_EQ(1, static_cast<int>(connectRecordList.size()));
571 
572     auto elementName = abilityRequest_.want.GetElement();
573     std::string elementNameUri = elementName.GetURI();
574     auto serviceMap = ConnectManager()->GetServiceMap();
575     auto abilityRecord = serviceMap.at(elementNameUri);
576     connectRecordList = abilityRecord->GetConnectRecordList();
577     EXPECT_EQ(1, static_cast<int>(connectRecordList.size()));
578 }
579 
580 /*
581  * Feature: AbilityConnectManager
582  * Function: ConnectAbilityLocked
583  * SubFunction: NA
584  * FunctionPoints: NA
585  * EnvConditions:NA
586  * CaseDescription: verify the scene of service not loaded and callback bound.
587  */
588 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_013, TestSize.Level1)
589 {
590     int result = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
591     EXPECT_EQ(0, result);
592 
593     std::string deviceNameB = "device";
594     std::string abilityNameB = "ServiceAbilityB";
595     std::string appNameB = "hiservcieB";
596     std::string bundleNameB = "com.ix.hiservcieB";
597     std::string moduleNameB = "entry";
598     auto abilityRequestB = GenerateAbilityRequest(deviceNameB, abilityNameB, appNameB, bundleNameB, moduleNameB);
599     result = ConnectManager()->ConnectAbilityLocked(abilityRequestB, callbackA_, nullptr);
600     EXPECT_EQ(0, result);
601 
602     auto connectMap = ConnectManager()->connectMap_;
603     auto connectRecordList = connectMap.at(callbackA_->AsObject());
604     EXPECT_EQ(2, static_cast<int>(connectRecordList.size()));
605 
606     auto elementName = abilityRequest_.want.GetElement();
607     std::string elementNameUri = elementName.GetURI();
608     auto serviceMap = ConnectManager()->GetServiceMap();
609     auto abilityRecord = serviceMap.at(elementNameUri);
610     connectRecordList = abilityRecord->GetConnectRecordList();
611     EXPECT_EQ(1, static_cast<int>(connectRecordList.size()));
612 
613     auto elementNameB = abilityRequest_.want.GetElement();
614     std::string elementNameUriB = elementNameB.GetURI();
615     abilityRecord = serviceMap.at(elementNameUriB);
616     connectRecordList = abilityRecord->GetConnectRecordList();
617     EXPECT_EQ(1, static_cast<int>(connectRecordList.size()));
618 }
619 
620 /*
621  * Feature: AbilityConnectManager
622  * Function: ConnectAbilityLocked
623  * SubFunction: NA
624  * FunctionPoints: NA
625  * EnvConditions:NA
626  * CaseDescription: verify the scene of service loaded and callback bound, but service and callback was not associated.
627  */
628 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_014, TestSize.Level1)
629 {
630     auto result = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
631     EXPECT_EQ(0, result);
632 
633     std::string deviceNameB = "device";
634     std::string abilityNameB = "ServiceAbilityB";
635     std::string appNameB = "hiservcieB";
636     std::string bundleNameB = "com.ix.hiservcieB";
637     std::string moduleNameB = "entry";
638     auto abilityRequestB = GenerateAbilityRequest(deviceNameB, abilityNameB, appNameB, bundleNameB, moduleNameB);
639     result = ConnectManager()->ConnectAbilityLocked(abilityRequestB, callbackB_, nullptr);
640     EXPECT_EQ(0, result);
641 
642     ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackB_, nullptr);
643     auto connectMap = ConnectManager()->connectMap_;
644     auto connectRecordList = connectMap.at(callbackB_->AsObject());
645     EXPECT_EQ(2, static_cast<int>(connectRecordList.size()));
646 
647     connectRecordList = connectMap.at(callbackA_->AsObject());
648     EXPECT_EQ(1, static_cast<int>(connectRecordList.size()));
649 
650     auto elementName = abilityRequest_.want.GetElement();
651     std::string elementNameUri = elementName.GetURI();
652     auto serviceMap = ConnectManager()->GetServiceMap();
653     auto abilityRecord = serviceMap.at(elementNameUri);
654     connectRecordList = abilityRecord->GetConnectRecordList();
655     EXPECT_EQ(2, static_cast<int>(connectRecordList.size()));
656 }
657 
658 /*
659  * Feature: AbilityConnectManager
660  * Function: AttachAbilityThreadLocked
661  * SubFunction: NA
662  * FunctionPoints: NA
663  * EnvConditions:NA
664  * CaseDescription: verify the AttachAbilityThreadLocked function when the parameter is null.
665  */
666 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_015, TestSize.Level1)
667 {
668     auto result = ConnectManager()->AttachAbilityThreadLocked(nullptr, nullptr);
669     EXPECT_EQ(OHOS::ERR_INVALID_VALUE, result);
670 }
671 
672 /*
673  * Feature: AbilityConnectManager
674  * Function: ScheduleConnectAbilityDoneLocked
675  * SubFunction: NA
676  * FunctionPoints: NA
677  * EnvConditions:NA
678  * CaseDescription: verify the ScheduleConnectAbilityDoneLocked function when the parameter is null.
679  */
680 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_016, TestSize.Level1)
681 {
682     auto callback = new AbilityConnectCallback();
683     auto result = ConnectManager()->ScheduleConnectAbilityDoneLocked(nullptr, callback);
684     EXPECT_EQ(OHOS::ERR_INVALID_VALUE, result);
685 }
686 
687 /*
688  * Feature: AbilityConnectManager
689  * Function: ScheduleConnectAbilityDoneLocked
690  * SubFunction: NA
691  * FunctionPoints: NA
692  * EnvConditions:NA
693  * CaseDescription: verify the ScheduleConnectAbilityDoneLocked function when the state is CONNECTED.
694  */
695 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_017, TestSize.Level1)
696 {
697     auto callback = new AbilityConnectCallback();
698     ConnectManager()->ConnectAbilityLocked(abilityRequest_, callback, nullptr);
699 
700     auto elementName = abilityRequest_.want.GetElement();
701     std::string elementNameUri = elementName.GetURI();
702     auto serviceMap = ConnectManager()->GetServiceMap();
703     auto abilityRecord = serviceMap.at(elementNameUri);
704     auto token = abilityRecord->GetToken();
705 
706     abilityRecord->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
707     ConnectManager()->ScheduleConnectAbilityDoneLocked(token, callback);
708     auto abilityRecordB = Token::GetAbilityRecordByToken(token);
709     EXPECT_TRUE(abilityRecordB);
710     auto connectRecordList = abilityRecordB->GetConnectRecordList();
711     int size = connectRecordList.size();
712     EXPECT_EQ(1, size);
713     if (size != 0) {
714         auto connState = (*(connectRecordList.begin()))->GetConnectState();
715         EXPECT_EQ(ConnectionState::CONNECTED, connState);
716     }
717 }
718 
719 /*
720  * Feature: AbilityConnectManager
721  * Function: GetActiveUIExtensionList
722  * SubFunction: NA
723  * FunctionPoints: NA
724  * EnvConditions:NA
725  * CaseDescription: verify the GetActiveUIExtensionList function.
726  */
727 HWTEST_F(AbilityConnectManagerTest, GetActiveUIExtensionList_01, TestSize.Level1)
728 {
729     int32_t pid = 1;
730     std::vector<std::string> extensionList;
731     auto result = ConnectManager()->GetActiveUIExtensionList(pid, extensionList);
732     EXPECT_EQ(result, ERR_OK);
733 
734     std::string bundleName = "com.test.demo";
735     result = ConnectManager()->GetActiveUIExtensionList(bundleName, extensionList);
736     EXPECT_EQ(result, ERR_OK);
737 }
738 
739 /*
740  * Feature: AbilityConnectManager
741  * Function: ScheduleConnectAbilityDoneLocked
742  * SubFunction: NA
743  * FunctionPoints: NA
744  * EnvConditions:NA
745  * CaseDescription: verify the input parameters.
746  */
747 HWTEST_F(AbilityConnectManagerTest, AAFWK_Kit_Connect_001, TestSize.Level1)
748 {
749     // start test
750     // test1 for serviceToken is null but remoteObject is valid
751     OHOS::sptr<OHOS::IRemoteObject> object = new AbilityConnectCallback();
752     int ret = ConnectManager()->ScheduleConnectAbilityDoneLocked(nullptr, object);
753     EXPECT_EQ(OHOS::ERR_INVALID_VALUE, ret);
754 
755     // test2 for both of serviceToken and remoteObject are null
756     ret = ConnectManager()->ScheduleConnectAbilityDoneLocked(nullptr, nullptr);
757     EXPECT_EQ(OHOS::ERR_INVALID_VALUE, ret);
758 }
759 
760 /*
761  * Feature: AbilityConnectManager
762  * Function: ScheduleConnectAbilityDoneLocked
763  * SubFunction: NA
764  * FunctionPoints: NA
765  * EnvConditions:NA
766  * CaseDescription: verify the input serviceToken which corresponding ability record doesn't exist.
767  */
768 HWTEST_F(AbilityConnectManagerTest, AAFWK_Kit_Connect_002, TestSize.Level1)
769 {
770     // test for serviceToken's abilityRecord is null
771     serviceRecord_ = nullptr;
772     int ret = ConnectManager()->ScheduleConnectAbilityDoneLocked(serviceToken_, nullptr);
773     EXPECT_EQ(OHOS::ERR_INVALID_VALUE, ret);
774 }
775 
776 /*
777  * Feature: AbilityConnectManager
778  * Function: ScheduleConnectAbilityDoneLocked
779  * SubFunction: OnAbilityConnectDone
780  * FunctionPoints: NA
781  * EnvConditions:NA
782  * CaseDescription: verify the input serviceToken which corresponding connection list is empty.
783  */
784 HWTEST_F(AbilityConnectManagerTest, AAFWK_Kit_Connect_003, TestSize.Level1)
785 {
786     // test for serviceToken's connection list is null
787     // start test
788     auto callback = new AbilityConnectCallback();
789     int ret = ConnectManager()->ScheduleConnectAbilityDoneLocked(serviceToken_, callback);
790     EXPECT_EQ(OHOS::AAFwk::INVALID_CONNECTION_STATE, ret);
791     auto connList = serviceRecord_->GetConnectRecordList();
792     EXPECT_EQ(true, connList.empty());  // the connection list size should be empty
793 }
794 
795 /*
796  * Feature: AbilityConnectManager
797  * Function: ScheduleConnectAbilityDoneLocked
798  * SubFunction: OnAbilityConnectDone
799  * FunctionPoints: NA
800  * EnvConditions:NA
801  * CaseDescription: verify the input serviceToken which corresponding connection list members' state
802  * is not CONNECTING or CONNECTED.
803  */
804 HWTEST_F(AbilityConnectManagerTest, AAFWK_Kit_Connect_004, TestSize.Level1)
805 {
806     // test for schedule the service connected done but the corresponding connection state is not CONNECTING
807     // generate the first connection record of callbackA_
808     auto newConnRecord1 = ConnectionRecord::CreateConnectionRecord(
809         serviceToken_, serviceRecord_, callbackA_);  // newConnRecord1's default state is INIT
810     serviceRecord_->AddConnectRecordToList(newConnRecord1);
811     // generate the second connection record of callbackB_
812     auto newConnRecord2 = ConnectionRecord::CreateConnectionRecord(serviceToken_, serviceRecord_, callbackB_);
813     newConnRecord2->SetConnectState(ConnectionState::DISCONNECTING);  // newConnRecord2's state is DISCONNECTING
814     serviceRecord_->AddConnectRecordToList(newConnRecord2);
815     auto connList = serviceRecord_->GetConnectRecordList();
816     EXPECT_EQ(2, static_cast<int>(connList.size()));  // the connection list members should be two
817     // start test
818     auto callback = new AbilityConnectCallback();
819     serviceRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
820     int ret = ConnectManager()->ScheduleConnectAbilityDoneLocked(serviceToken_, callback);
821     EXPECT_EQ(OHOS::ERR_OK, ret);  // the result should be OK
822     // connection callback should not be called, so check the count
823     EXPECT_EQ(0, AbilityConnectCallback::onAbilityConnectDoneCount);
824     EXPECT_EQ(0, AbilityConnectCallback::onAbilityDisconnectDoneCount);
825 }
826 
827 /*
828  * Feature: AbilityConnectManager
829  * Function: ScheduleConnectAbilityDoneLocked
830  * SubFunction: OnAbilityConnectDone
831  * FunctionPoints: NA
832  * EnvConditions:NA
833  * CaseDescription: verify the scene : 1.serviceToken's corresponding connection list member's state is CONNECTING.
834  * 2.But the connection callback is null.
835  */
836 HWTEST_F(AbilityConnectManagerTest, AAFWK_Kit_Connect_005, TestSize.Level1)
837 {
838     // test for schedule the service connected done but the corresponding connection state is not CONNECTING
839     // generate the first connection record of null
840     auto newConnRecord1 = ConnectionRecord::CreateConnectionRecord(
841         serviceToken_, serviceRecord_, nullptr);  // newConnRecord1's default state is INIT
842     serviceRecord_->AddConnectRecordToList(newConnRecord1);
843     newConnRecord1->SetConnectState(ConnectionState::CONNECTING);  // newConnRecord1's state is CONNECTING
844     auto connList = serviceRecord_->GetConnectRecordList();
845     EXPECT_EQ(1, static_cast<int>(connList.size()));  // the connection list members should be zero
846     // start test
847     auto callback = new AbilityConnectCallback();
848     serviceRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
849     int ret = ConnectManager()->ScheduleConnectAbilityDoneLocked(serviceToken_, callback);
850     EXPECT_EQ(OHOS::ERR_OK, ret);  // the result should be OK
851     // connection callback should not be called, so check the count
852     EXPECT_EQ(0, AbilityConnectCallback::onAbilityConnectDoneCount);
853 }
854 
855 /*
856  * Feature: AbilityConnectManager
857  * Function: ScheduleConnectAbilityDoneLocked
858  * SubFunction: OnAbilityConnectDone
859  * FunctionPoints: NA
860  * EnvConditions:NA
861  * CaseDescription: verify the scene : 1.serviceToken's corresponding connection list member's state is CONNECTED.
862  * 2.But the connection callback is null.
863  */
864 HWTEST_F(AbilityConnectManagerTest, AAFWK_Kit_Connect_006, TestSize.Level1)
865 {
866     // test for schedule the service connected done but the corresponding connection state is not CONNECTING
867     // generate the first connection record of null
868     auto newConnRecord1 = ConnectionRecord::CreateConnectionRecord(
869         serviceToken_, serviceRecord_, nullptr);  // newConnRecord1's default state is INIT
870     serviceRecord_->AddConnectRecordToList(newConnRecord1);
871     newConnRecord1->SetConnectState(ConnectionState::CONNECTED);  // newConnRecord1's state is CONNECTED
872     auto connList = serviceRecord_->GetConnectRecordList();
873     EXPECT_EQ(1, static_cast<int>(connList.size()));  // the connection list members should be zero
874     // start test
875     auto callback = new AbilityConnectCallback();
876     serviceRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
877     int ret = ConnectManager()->ScheduleConnectAbilityDoneLocked(serviceToken_, callback);
878     EXPECT_EQ(OHOS::ERR_OK, ret);  // the result should be OK
879     // connection callback should not be called, so check the count
880     EXPECT_EQ(0, AbilityConnectCallback::onAbilityConnectDoneCount);
881 }
882 
883 /*
884  * Feature: AbilityConnectManager
885  * Function: ScheduleConnectAbilityDoneLocked
886  * SubFunction: OnAbilityConnectDone
887  * FunctionPoints: NA
888  * EnvConditions:NA
889  * CaseDescription: verify the scene : 1.serviceToken's corresponding connection list member's state is CONNECTING.
890  * 2.But the connection callback is valid.
891  */
892 HWTEST_F(AbilityConnectManagerTest, AAFWK_Kit_Connect_007, TestSize.Level1)
893 {
894     // test for schedule the service connected done but the corresponding connection state is not CONNECTING
895     // generate the first connection record of callbackA_
896     auto newConnRecord1 = ConnectionRecord::CreateConnectionRecord(
897         serviceToken_, serviceRecord_, callbackA_);  // newConnRecord1's default state is INIT
898     serviceRecord_->AddConnectRecordToList(newConnRecord1);
899     // generate the second connection record of callbackB_
900     auto newConnRecord2 = ConnectionRecord::CreateConnectionRecord(serviceToken_, serviceRecord_, callbackB_);
901     newConnRecord2->SetConnectState(ConnectionState::CONNECTING);  // newConnRecord2's state is CONNECTING
902     serviceRecord_->AddConnectRecordToList(newConnRecord2);
903     auto connList = serviceRecord_->GetConnectRecordList();
904     EXPECT_EQ(2, static_cast<int>(connList.size()));  // the connection list members should be two
905     // start test
906     auto callback = new AbilityConnectCallback();
907     serviceRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
908     int ret = ConnectManager()->ScheduleConnectAbilityDoneLocked(serviceToken_, callback);
909     EXPECT_EQ(OHOS::ERR_OK, ret);  // the result should be OK
910     // connection callback should not be called, so check the count
911     EXPECT_EQ(0, AbilityConnectCallback::onAbilityConnectDoneCount);
912     EXPECT_EQ(0, AbilityConnectCallback::onAbilityDisconnectDoneCount);
913 }
914 
915 /*
916  * Feature: AbilityConnectManager
917  * Function: ScheduleConnectAbilityDoneLocked
918  * SubFunction: OnAbilityConnectDone
919  * FunctionPoints: NA
920  * EnvConditions:NA
921  * CaseDescription: verify the scene : 1.serviceToken's corresponding connection list member's state is CONNECTED.
922  * 2.But the connection callback is valid.
923  */
924 HWTEST_F(AbilityConnectManagerTest, AAFWK_Kit_Connect_008, TestSize.Level1)
925 {
926     // test for schedule the service connected done but the corresponding connection state is not CONNECTING
927     // generate the first connection record of callbackA_
928     auto newConnRecord1 = ConnectionRecord::CreateConnectionRecord(
929         serviceToken_, serviceRecord_, callbackA_);               // newConnRecord1's default state is INIT
930     newConnRecord1->SetConnectState(ConnectionState::CONNECTED);  // newConnRecord1's state is CONNECTED
931     serviceRecord_->AddConnectRecordToList(newConnRecord1);
932     // generate the second connection record of callbackB_
933     auto newConnRecord2 = ConnectionRecord::CreateConnectionRecord(serviceToken_, serviceRecord_, callbackB_);
934     newConnRecord2->SetConnectState(ConnectionState::CONNECTING);  // newConnRecord2's state is CONNECTING
935     serviceRecord_->AddConnectRecordToList(newConnRecord2);
936     // generate the third connection record of callbackC
937     auto callbackC = new AbilityConnectCallback();
938     auto newConnRecord3 = ConnectionRecord::CreateConnectionRecord(serviceToken_, serviceRecord_, callbackC);
939     newConnRecord3->SetConnectState(ConnectionState::CONNECTING);  // newConnRecord3's state is CONNECTING
940     serviceRecord_->AddConnectRecordToList(newConnRecord3);
941     auto connList = serviceRecord_->GetConnectRecordList();
942     EXPECT_EQ(3, static_cast<int>(connList.size()));  // the connection list members should be three
943     // start test
944     auto callback = new AbilityConnectCallback();
945     serviceRecord_->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
946     int ret = ConnectManager()->ScheduleConnectAbilityDoneLocked(serviceToken_, callback);
947     EXPECT_EQ(OHOS::ERR_OK, ret);  // the result should be OK
948     // connection callback should not be called, so check the count
949     EXPECT_EQ(0, AbilityConnectCallback::onAbilityConnectDoneCount);
950     EXPECT_EQ(0, AbilityConnectCallback::onAbilityDisconnectDoneCount);
951 }
952 
953 /*
954  * Feature: AbilityConnectManager
955  * Function: DisconnectAbilityLocked
956  * SubFunction:
957  * FunctionPoints: DisconnectAbilityLocked and ConnectAbilityLocked
958  * EnvConditions:NA
959  * CaseDescription:Verify the following:
960  * 1. Disconnect ability a nonexistent connect, disconnect failed
961  * 2. If the current connect ability state is not connected, disconnect fails
962  * 3. Verify the success of disconnect ability
963  */
964 HWTEST_F(AbilityConnectManagerTest, AAFWK_Kit_Disconnect_001, TestSize.Level1)
965 {
966     ConnectManager()->SetTaskHandler(TaskHandler());
967     ConnectManager()->SetEventHandler(EventHandler());
968 
969     auto callback = new AbilityConnectCallback();
970     auto result = ConnectManager()->DisconnectAbilityLocked(callback);
971     EXPECT_EQ(result, OHOS::AAFwk::CONNECTION_NOT_EXIST);
972 
973     auto result1 = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
974     EXPECT_EQ(0, result1);
975 
976     auto result2 = ConnectManager()->DisconnectAbilityLocked(callbackA_);
977     EXPECT_EQ(result2, OHOS::AAFwk::INVALID_CONNECTION_STATE);
978 
979     auto list = ConnectManager()->GetConnectRecordListByCallback(callbackA_);
980     EXPECT_EQ(static_cast<int>(list.size()), 1);
981 
982     for (auto& it : list) {
983         it->SetConnectState(ConnectionState::CONNECTED);
984     }
985 
986     auto result3 = ConnectManager()->DisconnectAbilityLocked(callbackA_);
987     EXPECT_EQ(result3, OHOS::ERR_OK);
988 }
989 
990 /*
991  * Feature: AbilityConnectManager
992  * Function: DisconnectAbilityLocked
993  * SubFunction:
994  * FunctionPoints: DisconnectAbilityLocked and ConnectAbilityLocked
995  * EnvConditions:NA
996  * CaseDescription: Results after verifying the disconnect ability
997  */
998 HWTEST_F(AbilityConnectManagerTest, AAFWK_Kit_Disconnect_002, TestSize.Level1)
999 {
1000     ConnectManager()->SetTaskHandler(TaskHandler());
1001     ConnectManager()->SetEventHandler(EventHandler());
1002 
1003     auto result = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
1004     EXPECT_EQ(0, result);
1005 
1006     auto result1 = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackB_, nullptr);
1007     EXPECT_EQ(0, result1);
1008 
1009     auto result2 = ConnectManager()->ConnectAbilityLocked(abilityRequest1_, callbackA_, nullptr);
1010     EXPECT_EQ(0, result2);
1011 
1012     auto result3 = ConnectManager()->ConnectAbilityLocked(abilityRequest1_, callbackB_, nullptr);
1013     EXPECT_EQ(0, result3);
1014 
1015     auto listA = ConnectManager()->GetConnectRecordListByCallback(callbackA_);
1016     EXPECT_EQ(static_cast<int>(listA.size()), 2);
1017 
1018     for (auto& it : listA) {
1019         it->SetConnectState(ConnectionState::CONNECTED);
1020     }
1021 
1022     auto listB = ConnectManager()->GetConnectRecordListByCallback(callbackB_);
1023     EXPECT_EQ(static_cast<int>(listB.size()), 2);
1024 
1025     for (auto& it : listB) {
1026         it->SetConnectState(ConnectionState::CONNECTED);
1027     }
1028 
1029     auto result5 = ConnectManager()->DisconnectAbilityLocked(callbackA_);
1030     WaitUntilTaskDone(TaskHandler());
1031     EXPECT_EQ(result5, OHOS::ERR_OK);
1032     auto serviceMap = ConnectManager()->GetServiceMap();
1033     EXPECT_EQ(static_cast<int>(serviceMap.size()), 2);
1034 
1035     auto connectMap = ConnectManager()->connectMap_;
1036     EXPECT_EQ(static_cast<int>(connectMap.size()), 1);
1037     for (auto& it : connectMap) {
1038         EXPECT_EQ(static_cast<int>(it.second.size()), 2);
1039     }
1040 }
1041 
1042 /*
1043  * Feature: AbilityConnectManager
1044  * Function: AbilityTransitionDone
1045  * SubFunction: NA
1046  * FunctionPoints: AbilityTransitionDone
1047  * EnvConditions:NA
1048  * CaseDescription: Verify the abilitytransitiondone process
1049  */
1050 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_019, TestSize.Level1)
1051 {
1052     OHOS::sptr<OHOS::IRemoteObject> nullToken = nullptr;
1053     auto result = ConnectManager()->AbilityTransitionDone(nullToken, OHOS::AAFwk::AbilityState::INACTIVE);
1054     EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1055 
1056     ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
1057     auto elementName = abilityRequest_.want.GetElement();
1058     std::string elementNameUri = elementName.GetURI();
1059     auto serviceMap = ConnectManager()->GetServiceMap();
1060     auto abilityRecord = serviceMap.at(elementNameUri);
1061     auto token = abilityRecord->GetToken();
1062 
1063     auto result1 = ConnectManager()->AbilityTransitionDone(token, OHOS::AAFwk::AbilityState::INACTIVE);
1064     EXPECT_EQ(result1, OHOS::ERR_INVALID_VALUE);
1065 
1066     ConnectManager()->MoveToTerminatingMap(abilityRecord);
1067     auto result2 = ConnectManager()->AbilityTransitionDone(token, OHOS::AAFwk::AbilityState::INITIAL);
1068     EXPECT_EQ(result2, OHOS::ERR_OK);
1069 
1070     auto result3 = ConnectManager()->AbilityTransitionDone(token, OHOS::AAFwk::AbilityState::TERMINATING);
1071     EXPECT_EQ(result3, OHOS::ERR_INVALID_VALUE);
1072 }
1073 
1074 /*
1075  * Feature: AbilityConnectManager
1076  * Function: ScheduleDisconnectAbilityDoneLocked
1077  * SubFunction: NA
1078  * FunctionPoints: ScheduleDisconnectAbilityDoneLocked
1079  * EnvConditions:NA
1080  * CaseDescription: Verify the ScheduleDisconnectAbilityDoneLocked process
1081  */
1082 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_020, TestSize.Level1)
1083 {
1084     ConnectManager()->SetTaskHandler(TaskHandler());
1085     ConnectManager()->SetEventHandler(EventHandler());
1086 
1087     OHOS::sptr<OHOS::IRemoteObject> nullToken = nullptr;
1088     auto result = ConnectManager()->ScheduleDisconnectAbilityDoneLocked(nullToken);
1089     EXPECT_EQ(result, OHOS::AAFwk::CONNECTION_NOT_EXIST);
1090 
1091     std::shared_ptr<AbilityRecord> ability = nullptr;
1092     OHOS::sptr<OHOS::IRemoteObject> token1 = new OHOS::AAFwk::Token(ability);
1093     auto result1 = ConnectManager()->ScheduleDisconnectAbilityDoneLocked(token1);
1094     EXPECT_EQ(result1, OHOS::AAFwk::CONNECTION_NOT_EXIST);
1095 
1096     ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
1097     auto elementName = abilityRequest_.want.GetElement();
1098     std::string elementNameUri = elementName.GetURI();
1099     auto serviceMap = ConnectManager()->GetServiceMap();
1100     auto abilityRecord = serviceMap.at(elementNameUri);
1101     auto token = abilityRecord->GetToken();
1102 
1103     auto listA = ConnectManager()->GetConnectRecordListByCallback(callbackA_);
1104     for (auto& it : listA) {
1105         it->SetConnectState(ConnectionState::CONNECTED);
1106     }
1107 
1108     auto result2 = ConnectManager()->DisconnectAbilityLocked(callbackA_);
1109     WaitUntilTaskDone(TaskHandler());
1110     EXPECT_EQ(result2, OHOS::ERR_OK);
1111 
1112     auto result3 = ConnectManager()->ScheduleDisconnectAbilityDoneLocked(token);
1113     EXPECT_EQ(result3, OHOS::AAFwk::INVALID_CONNECTION_STATE);
1114 
1115     abilityRecord->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
1116 
1117     auto result4 = ConnectManager()->ScheduleDisconnectAbilityDoneLocked(token);
1118     EXPECT_EQ(result4, OHOS::ERR_OK);
1119 }
1120 
1121 /*
1122  * Feature: AbilityConnectManager
1123  * Function: ScheduleCommandAbilityDoneLocked
1124  * SubFunction: NA
1125  * FunctionPoints: ScheduleCommandAbilityDoneLocked
1126  * EnvConditions:NA
1127  * CaseDescription: Verify the ScheduleCommandAbilityDoneLocked process
1128  */
1129 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_021, TestSize.Level1)
1130 {
1131     ConnectManager()->SetTaskHandler(TaskHandler());
1132     ConnectManager()->SetEventHandler(EventHandler());
1133 
1134     OHOS::sptr<OHOS::IRemoteObject> nullToken = nullptr;
1135     auto result = ConnectManager()->ScheduleCommandAbilityDoneLocked(nullToken);
1136     EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1137 
1138     std::shared_ptr<AbilityRecord> ability = nullptr;
1139     OHOS::sptr<OHOS::IRemoteObject> token1 = new OHOS::AAFwk::Token(ability);
1140     auto result1 = ConnectManager()->ScheduleCommandAbilityDoneLocked(token1);
1141     EXPECT_EQ(result1, OHOS::ERR_INVALID_VALUE);
1142 
1143     ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
1144     auto elementName = abilityRequest_.want.GetElement();
1145     std::string elementNameUri = elementName.GetURI();
1146     auto serviceMap = ConnectManager()->GetServiceMap();
1147     auto abilityRecord = serviceMap.at(elementNameUri);
1148     auto token = abilityRecord->GetToken();
1149 
1150     auto result2 = ConnectManager()->ScheduleCommandAbilityDoneLocked(token);
1151     EXPECT_EQ(result2, OHOS::AAFwk::INVALID_CONNECTION_STATE);
1152 
1153     abilityRecord->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
1154     auto result3 = ConnectManager()->ScheduleCommandAbilityDoneLocked(token);
1155     EXPECT_EQ(result3, OHOS::ERR_OK);
1156 }
1157 
1158 /*
1159  * Feature: AbilityConnectManager
1160  * Function: GetExtensionByTokenFromServiceMap
1161  * SubFunction: NA
1162  * FunctionPoints: GetExtensionByTokenFromServiceMap
1163  * EnvConditions:NA
1164  * CaseDescription: Verify the GetExtensionByTokenFromServiceMap process
1165  */
1166 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_022, TestSize.Level1)
1167 {
1168     ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
1169     auto elementName = abilityRequest_.want.GetElement();
1170     std::string elementNameUri = elementName.GetURI();
1171     auto serviceMap = ConnectManager()->GetServiceMap();
1172     auto abilityRecord = serviceMap.at(elementNameUri);
1173     auto token = abilityRecord->GetToken();
1174 
1175     auto ability = ConnectManager()->GetExtensionByTokenFromServiceMap(token);
1176     EXPECT_EQ(abilityRecord, ability);
1177 
1178     OHOS::sptr<OHOS::IRemoteObject> nullToken = nullptr;
1179     auto ability1 = ConnectManager()->GetExtensionByTokenFromServiceMap(nullToken);
1180     EXPECT_EQ(nullptr, ability1);
1181 
1182     auto recordId = abilityRecord->GetAbilityRecordId();
1183     EXPECT_EQ(ConnectManager()->GetExtensionByIdFromServiceMap(recordId), abilityRecord);
1184     EXPECT_EQ(ConnectManager()->GetExtensionByIdFromServiceMap(0), nullptr);
1185 }
1186 
1187 /*
1188  * Feature: AbilityConnectManager
1189  * Function: OnAbilityDied
1190  * SubFunction:
1191  * FunctionPoints: OnAbilityDied
1192  * EnvConditions:NA
1193  * CaseDescription: Verify the OnAbilityDied process
1194  */
1195 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_024, TestSize.Level1)
1196 {
1197     ConnectManager()->SetTaskHandler(TaskHandler());
1198     ConnectManager()->SetEventHandler(EventHandler());
1199 
1200     auto result = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
1201     EXPECT_EQ(0, result);
1202 
1203     auto result1 = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackB_, nullptr);
1204     EXPECT_EQ(0, result1);
1205 
1206     auto result2 = ConnectManager()->ConnectAbilityLocked(abilityRequest1_, callbackA_, nullptr);
1207     EXPECT_EQ(0, result2);
1208 
1209     auto result3 = ConnectManager()->ConnectAbilityLocked(abilityRequest1_, callbackB_, nullptr);
1210     EXPECT_EQ(0, result3);
1211 
1212     auto listA = ConnectManager()->GetConnectRecordListByCallback(callbackA_);
1213     EXPECT_EQ(static_cast<int>(listA.size()), 2);
1214 
1215     for (auto& it : listA) {
1216         it->SetConnectState(ConnectionState::CONNECTED);
1217     }
1218 
1219     auto listB = ConnectManager()->GetConnectRecordListByCallback(callbackB_);
1220     EXPECT_EQ(static_cast<int>(listB.size()), 2);
1221 
1222     for (auto& it : listB) {
1223         it->SetConnectState(ConnectionState::CONNECTED);
1224     }
1225 
1226     auto elementName = abilityRequest_.want.GetElement();
1227     std::string elementNameUri = elementName.GetURI();
1228     auto serviceMap = ConnectManager()->GetServiceMap();
1229     auto abilityRecord = serviceMap.at(elementNameUri);
1230     auto token = abilityRecord->GetToken();
1231 
1232     ConnectManager()->OnAbilityDied(abilityRecord, 0);
1233     WaitUntilTaskDone(TaskHandler());
1234     auto list = abilityRecord->GetConnectRecordList();
1235     EXPECT_EQ(static_cast<int>(list.size()), 0);
1236 
1237     auto elementName1 = abilityRequest1_.want.GetElement();
1238     std::string elementNameUri1 = elementName1.GetURI();
1239     serviceMap = ConnectManager()->GetServiceMap();
1240     auto abilityRecord1 = serviceMap.at(elementNameUri1);
1241     auto token1 = abilityRecord1->GetToken();
1242 
1243     ConnectManager()->OnAbilityDied(abilityRecord1, 0);
1244     WaitUntilTaskDone(TaskHandler());
1245     auto list1 = abilityRecord1->GetConnectRecordList();
1246     EXPECT_EQ(static_cast<int>(list1.size()), 0);
1247 }
1248 
1249 /*
1250  * Feature: AbilityConnectManager
1251  * Function: DispatchInactive
1252  * SubFunction:
1253  * FunctionPoints: DispatchInactive
1254  * EnvConditions:NA
1255  * CaseDescription: Verify the DispatchInactive process
1256  */
1257 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_025, TestSize.Level1)
1258 {
1259     std::shared_ptr<AbilityRecord> ability = nullptr;
1260     auto result = ConnectManager()->DispatchInactive(ability, OHOS::AAFwk::AbilityState::INACTIVATING);
1261     EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1262 
1263     ConnectManager()->SetTaskHandler(TaskHandler());
1264     ConnectManager()->SetEventHandler(EventHandler());
1265 
1266     auto result3 = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
1267     EXPECT_EQ(0, result3);
1268 
1269     auto elementName = abilityRequest_.want.GetElement();
1270     std::string elementNameUri = elementName.GetURI();
1271     auto serviceMap = ConnectManager()->GetServiceMap();
1272     auto abilityRecord = serviceMap.at(elementNameUri);
1273     auto token = abilityRecord->GetToken();
1274 
1275     abilityRecord->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
1276     auto result1 = ConnectManager()->DispatchInactive(abilityRecord, OHOS::AAFwk::AbilityState::INACTIVATING);
1277     EXPECT_EQ(result1, OHOS::ERR_INVALID_VALUE);
1278 
1279     abilityRecord->SetAbilityState(OHOS::AAFwk::AbilityState::INACTIVATING);
1280     auto result2 = ConnectManager()->DispatchInactive(abilityRecord, OHOS::AAFwk::AbilityState::INACTIVATING);
1281     EXPECT_EQ(result2, OHOS::ERR_OK);
1282     EXPECT_EQ(abilityRecord->GetAbilityState(), OHOS::AAFwk::AbilityState::INACTIVE);
1283 }
1284 
1285 /*
1286  * Feature: AbilityConnectManager
1287  * Function: DispatchInactive
1288  * SubFunction:
1289  * FunctionPoints: DispatchInactive
1290  * EnvConditions:NA
1291  * CaseDescription: Verify the DispatchInactive process
1292  */
1293 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_026, TestSize.Level1)
1294 {
1295     std::shared_ptr<AbilityRecord> ability = nullptr;
1296     auto result = ConnectManager()->DispatchInactive(ability, OHOS::AAFwk::AbilityState::INACTIVATING);
1297     EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
1298 
1299     ConnectManager()->SetTaskHandler(TaskHandler());
1300     ConnectManager()->SetEventHandler(EventHandler());
1301 
1302     auto result3 = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
1303     EXPECT_EQ(0, result3);
1304 
1305     auto elementName = abilityRequest_.want.GetElement();
1306     std::string elementNameUri = elementName.GetURI();
1307     auto serviceMap = ConnectManager()->GetServiceMap();
1308     auto abilityRecord = serviceMap.at(elementNameUri);
1309     auto token = abilityRecord->GetToken();
1310 
1311     abilityRecord->SetAbilityState(OHOS::AAFwk::AbilityState::ACTIVE);
1312     auto result1 = ConnectManager()->DispatchInactive(abilityRecord, OHOS::AAFwk::AbilityState::INACTIVATING);
1313     EXPECT_EQ(result1, OHOS::ERR_INVALID_VALUE);
1314 
1315     abilityRecord->SetAbilityState(OHOS::AAFwk::AbilityState::INACTIVATING);
1316     auto result2 = ConnectManager()->DispatchInactive(abilityRecord, OHOS::AAFwk::AbilityState::INACTIVATING);
1317     EXPECT_EQ(result2, OHOS::ERR_OK);
1318     EXPECT_EQ(abilityRecord->GetAbilityState(), OHOS::AAFwk::AbilityState::INACTIVE);
1319 }
1320 
1321 /*
1322  * Feature: AbilityConnectManager
1323  * Function: AddConnectDeathRecipient
1324  * SubFunction:
1325  * FunctionPoints: AddConnectDeathRecipient
1326  * EnvConditions:NA
1327  * CaseDescription: Verify the AddConnectDeathRecipient process
1328  */
1329 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_027, TestSize.Level1)
1330 {
1331     ConnectManager()->SetTaskHandler(TaskHandler());
1332     ConnectManager()->SetEventHandler(EventHandler());
1333 
1334     ConnectManager()->AddConnectDeathRecipient(nullptr);
1335     EXPECT_TRUE(ConnectManager()->recipientMap_.empty());
1336 }
1337 
1338 /*
1339  * Feature: AbilityConnectManager
1340  * Function: RemoveConnectDeathRecipient
1341  * SubFunction:
1342  * FunctionPoints: RemoveConnectDeathRecipient
1343  * EnvConditions:NA
1344  * CaseDescription: Verify the RemoveConnectDeathRecipient process
1345  */
1346 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_028, TestSize.Level1)
1347 {
1348     ConnectManager()->SetTaskHandler(TaskHandler());
1349     ConnectManager()->SetEventHandler(EventHandler());
1350 
1351     ConnectManager()->AddConnectDeathRecipient(nullptr);
1352     EXPECT_TRUE(ConnectManager()->recipientMap_.empty());
1353 
1354     ConnectManager()->RemoveConnectDeathRecipient(nullptr);
1355     EXPECT_TRUE(ConnectManager()->recipientMap_.empty());
1356 }
1357 
1358 /*
1359  * Feature: AbilityConnectManager
1360  * Function: OnCallBackDied
1361  * SubFunction:
1362  * FunctionPoints: OnCallBackDied
1363  * EnvConditions:NA
1364  * CaseDescription: Verify the OnCallBackDied process
1365  */
1366 HWTEST_F(AbilityConnectManagerTest, AAFWK_Connect_Service_029, TestSize.Level1)
1367 {
1368     ConnectManager()->SetTaskHandler(TaskHandler());
1369     ConnectManager()->SetEventHandler(EventHandler());
1370 
1371     auto result = ConnectManager()->ConnectAbilityLocked(abilityRequest_, callbackA_, nullptr);
1372     WaitUntilTaskDone(TaskHandler());
1373     EXPECT_EQ(0, result);
1374 
1375     ConnectManager()->OnCallBackDied(nullptr);
1376     WaitUntilTaskDone(TaskHandler());
1377     auto connectMap = ConnectManager()->connectMap_;
1378     auto connectRecordList = connectMap.at(callbackA_->AsObject());
1379     EXPECT_EQ(1, static_cast<int>(connectRecordList.size()));
1380     for (auto& it : connectRecordList) {
1381         EXPECT_NE(it->GetAbilityConnectCallback(), nullptr);
1382     }
1383 
1384     ConnectManager()->OnCallBackDied(callbackA_->AsObject());
1385     WaitUntilTaskDone(TaskHandler());
1386     connectRecordList = connectMap.at(callbackA_->AsObject());
1387     EXPECT_EQ(1, static_cast<int>(connectMap.size()));
1388     for (auto& it : connectRecordList) {
1389         EXPECT_EQ(it->GetAbilityConnectCallback(), nullptr);
1390     }
1391 }
1392 
1393 /*
1394  * Feature: AbilityConnectManager
1395  * Function: StartAbilityLocked
1396  * SubFunction: StartAbilityLocked
1397  * FunctionPoints: NA
1398  * EnvConditions: NA
1399  * CaseDescription: Verify AbilityConnectManager StartAbilityLocked
1400  */
1401 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_StartAbilityLocked_001, TestSize.Level1)
1402 {
1403     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1404     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1405     AbilityRequest abilityRequest;
1406     abilityRequest.abilityInfo.deviceId = "id";
1407     abilityRequest.abilityInfo.bundleName = "bundle";
1408     abilityRequest.abilityInfo.name = "name";
1409     abilityRequest.abilityInfo.moduleName = "module";
1410     std::string stringUri = "id/bundle/module/name";
1411     AppExecFwk::ElementName element(abilityRequest.abilityInfo.deviceId, abilityRequest.abilityInfo.bundleName,
1412         abilityRequest.abilityInfo.name, abilityRequest.abilityInfo.moduleName);
1413     EXPECT_EQ(element.GetURI(), stringUri);
1414     abilityRecord->currentState_ = AbilityState::ACTIVE;
1415     abilityRecord->SetPreAbilityRecord(serviceRecord1_);
1416     connectManager->serviceMap_.emplace(stringUri, abilityRecord);
1417     int res = connectManager->StartAbilityLocked(abilityRequest);
1418     EXPECT_EQ(res, ERR_OK);
1419 }
1420 
1421 /*
1422  * Feature: AbilityConnectManager
1423  * Function: GetOrCreateServiceRecord
1424  * SubFunction: GetOrCreateServiceRecord
1425  * FunctionPoints: NA
1426  * EnvConditions: NA
1427  * CaseDescription: Verify AbilityConnectManager GetOrCreateServiceRecord
1428  */
1429 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_GetOrCreateServiceRecord_001, TestSize.Level1)
1430 {
1431     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1432     ASSERT_NE(connectManager, nullptr);
1433     AbilityRequest abilityRequest;
1434     bool isCreatedByConnect = false;
1435     std::shared_ptr<AbilityRecord> targetService = nullptr;
1436     bool isLoadedAbility = false;
1437     abilityRequest.abilityInfo.name = AbilityConfig::LAUNCHER_ABILITY_NAME;
1438     connectManager->serviceMap_.clear();
1439     connectManager->GetOrCreateServiceRecord(abilityRequest, isCreatedByConnect, targetService, isLoadedAbility);
1440 }
1441 
1442 /*
1443  * Feature: AbilityConnectManager
1444  * Function: ConnectAbilityLocked
1445  * SubFunction: ConnectAbilityLocked
1446  * FunctionPoints: NA
1447  * EnvConditions: NA
1448  * CaseDescription: Verify AbilityConnectManager ConnectAbilityLocked
1449  */
1450 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_ConnectAbilityLocked_001, TestSize.Level1)
1451 {
1452     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1453     ASSERT_NE(connectManager, nullptr);
1454     ConnectManager()->SetTaskHandler(TaskHandler());
1455     ConnectManager()->SetEventHandler(EventHandler());
1456     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1457     AbilityRequest abilityRequest;
1458     sptr<IRemoteObject> callerToken = abilityRecord->GetToken();
1459     OHOS::sptr<IAbilityConnection> connect = new AbilityConnectCallback();
1460     OHOS::sptr<IAbilityConnection> callback1 = new AbilityConnectCallback();
1461     OHOS::sptr<IAbilityConnection> callback2 = new AbilityConnectCallback();
1462     std::shared_ptr<ConnectionRecord> connection1 =
1463         std::make_shared<ConnectionRecord>(callerToken, abilityRecord, callback1);
1464     std::shared_ptr<ConnectionRecord> connection2 =
1465         std::make_shared<ConnectionRecord>(callerToken, abilityRecord, callback2);
1466     abilityRequest.abilityInfo.deviceId = "id";
1467     abilityRequest.abilityInfo.bundleName = "bundle";
1468     abilityRequest.abilityInfo.name = "name";
1469     abilityRequest.abilityInfo.moduleName = "module";
1470     std::string stringUri = "id/bundle/name/module";
1471     abilityRecord->currentState_ = AbilityState::ACTIVE;
1472     abilityRecord->AddConnectRecordToList(connection1);
1473     connectManager->serviceMap_.emplace(stringUri, abilityRecord);
1474     connectManager->connectMap_.clear();
1475     connectManager->ConnectAbilityLocked(abilityRequest, connect, callerToken);
1476     abilityRecord->AddConnectRecordToList(connection2);
1477     connectManager->ConnectAbilityLocked(abilityRequest, connect, callerToken);
1478     connectManager->SetEventHandler(nullptr);
1479     connectManager->ConnectAbilityLocked(abilityRequest, connect, callerToken);
1480 }
1481 
1482 /*
1483  * Feature: AbilityConnectManager
1484  * Function: AttachAbilityThreadLocked
1485  * SubFunction: AttachAbilityThreadLocked
1486  * FunctionPoints: NA
1487  * EnvConditions: NA
1488  * CaseDescription: Verify AbilityConnectManager AttachAbilityThreadLocked
1489  */
1490 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_AttachAbilityThreadLocked_001, TestSize.Level1)
1491 {
1492     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1493     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1494     sptr<IAbilityScheduler> scheduler = nullptr;
1495     sptr<IRemoteObject> token = abilityRecord->GetToken();
1496     connectManager->serviceMap_.emplace("first", abilityRecord);
1497     connectManager->eventHandler_ = nullptr;
1498     connectManager->taskHandler_ = nullptr;
1499     int res = connectManager->AttachAbilityThreadLocked(scheduler, token);
1500     EXPECT_EQ(res, ERR_OK);
1501 }
1502 
1503 /*
1504  * Feature: AbilityConnectManager
1505  * Function: OnAppStateChanged
1506  * SubFunction: OnAppStateChanged
1507  * FunctionPoints: NA
1508  * EnvConditions: NA
1509  * CaseDescription: Verify AbilityConnectManager OnAppStateChanged
1510  */
1511 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_OnAppStateChanged_001, TestSize.Level1)
1512 {
1513     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1514     ASSERT_NE(connectManager, nullptr);
1515     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1516     AppInfo info;
1517     std::string bundleName = "bundleName";
1518     std::string name = "name";
1519     int32_t uid = 0;
1520     info.processName = bundleName;
1521     abilityRecord->applicationInfo_.bundleName = bundleName;
1522     abilityRecord->applicationInfo_.name = name;
1523     abilityRecord->abilityInfo_.uid = uid;
1524     info.appData.push_back({name, uid});
1525     connectManager->serviceMap_.emplace("first", abilityRecord);
1526     connectManager->OnAppStateChanged(info);
1527 }
1528 
1529 /*
1530  * Feature: AbilityConnectManager
1531  * Function: OnAppStateChanged
1532  * SubFunction: OnAppStateChanged
1533  * FunctionPoints: NA
1534  * EnvConditions: NA
1535  * CaseDescription: Verify AbilityConnectManager OnAppStateChanged
1536  */
1537 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_OnAppStateChanged_002, TestSize.Level1)
1538 {
1539     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1540     ASSERT_NE(connectManager, nullptr);
1541     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1542     AppInfo info;
1543     std::string bundleName = "bundleName";
1544     std::string name = "name";
1545     int32_t uid = 0;
1546     info.processName = "";
1547     abilityRecord->applicationInfo_.bundleName = bundleName;
1548     abilityRecord->applicationInfo_.name = name;
1549     abilityRecord->abilityInfo_.uid = uid;
1550     info.appData.push_back({name, uid});
1551     connectManager->serviceMap_.emplace("first", abilityRecord);
1552     connectManager->serviceMap_.emplace("first", nullptr);
1553     connectManager->OnAppStateChanged(info);
1554 }
1555 
1556 /*
1557  * Feature: AbilityConnectManager
1558  * Function: AbilityTransitionDone
1559  * SubFunction: AbilityTransitionDone
1560  * FunctionPoints: NA
1561  * EnvConditions: NA
1562  * CaseDescription: Verify AbilityConnectManager AbilityTransitionDone
1563  */
1564 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_AbilityTransitionDone_001, TestSize.Level1)
1565 {
1566     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1567     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1568     sptr<IRemoteObject> token = abilityRecord->GetToken();
1569     int state = AbilityState::INACTIVE;
1570     abilityRecord->abilityInfo_.type = AbilityType::PAGE;
1571     abilityRecord->SetAbilityState(AbilityState::ACTIVE);
1572     connectManager->serviceMap_.emplace("first", abilityRecord);
1573     int res1 = connectManager->AbilityTransitionDone(token, state);
1574     EXPECT_EQ(res1, ERR_INVALID_VALUE);
1575     state = AbilityState::INITIAL;
1576     connectManager->MoveToTerminatingMap(abilityRecord);
1577     int res2 = connectManager->AbilityTransitionDone(token, state);
1578     EXPECT_EQ(res2, ERR_OK);
1579 }
1580 
1581 /*
1582  * Feature: AbilityConnectManager
1583  * Function: ScheduleConnectAbilityDoneLocked
1584  * SubFunction: ScheduleConnectAbilityDoneLocked
1585  * FunctionPoints: NA
1586  * EnvConditions: NA
1587  * CaseDescription: Verify AbilityConnectManager ScheduleConnectAbilityDoneLocked
1588  */
1589 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_ScheduleConnectAbilityDoneLocked_001, TestSize.Level1)
1590 {
1591     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1592     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1593     sptr<IRemoteObject> token = abilityRecord->GetToken();
1594     sptr<IRemoteObject> remoteObject = nullptr;
1595     abilityRecord->abilityInfo_.type = AbilityType::PAGE;
1596     abilityRecord->SetAbilityState(AbilityState::INACTIVE);
1597     connectManager->serviceMap_.emplace("first", abilityRecord);
1598     int res = connectManager->ScheduleConnectAbilityDoneLocked(token, remoteObject);
1599     EXPECT_EQ(res, ERR_OK);
1600 }
1601 
1602 /*
1603  * Feature: AbilityConnectManager
1604  * Function: ScheduleDisconnectAbilityDoneLocked
1605  * SubFunction: ScheduleDisconnectAbilityDoneLocked
1606  * FunctionPoints: NA
1607  * EnvConditions: NA
1608  * CaseDescription: Verify AbilityConnectManager ScheduleDisconnectAbilityDoneLocked
1609  */
1610 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_ScheduleDisconnectAbilityDoneLocked_001, TestSize.Level1)
1611 {
1612     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1613     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1614     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
1615     std::shared_ptr<ConnectionRecord> connection =
1616         std::make_shared<ConnectionRecord>(abilityRecord->GetToken(), abilityRecord, callback);
1617     sptr<IRemoteObject> token = abilityRecord->GetToken();
1618     connection->SetConnectState(ConnectionState::DISCONNECTING);
1619     abilityRecord->abilityInfo_.type = AbilityType::PAGE;
1620     abilityRecord->SetAbilityState(AbilityState::INACTIVE);
1621     abilityRecord->connRecordList_.push_back(connection);
1622     connectManager->serviceMap_.emplace("first", abilityRecord);
1623     int res = connectManager->ScheduleDisconnectAbilityDoneLocked(token);
1624     EXPECT_EQ(res, INVALID_CONNECTION_STATE);
1625     abilityRecord->AddStartId();
1626     abilityRecord->SetAbilityState(AbilityState::ACTIVE);
1627     connectManager->serviceMap_.emplace("first", abilityRecord);
1628     res = connectManager->ScheduleDisconnectAbilityDoneLocked(token);
1629     EXPECT_EQ(res, ERR_OK);
1630 }
1631 
1632 /*
1633  * Feature: AbilityConnectManager
1634  * Function: ScheduleCommandAbilityDoneLocked
1635  * SubFunction: ScheduleCommandAbilityDoneLocked
1636  * FunctionPoints: NA
1637  * EnvConditions: NA
1638  * CaseDescription: Verify AbilityConnectManager ScheduleCommandAbilityDoneLocked
1639  */
1640 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_ScheduleCommandAbilityDoneLocked_001, TestSize.Level1)
1641 {
1642     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1643     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1644     sptr<IRemoteObject> token = abilityRecord->GetToken();
1645     abilityRecord->abilityInfo_.type = AbilityType::PAGE;
1646     abilityRecord->SetAbilityState(AbilityState::INACTIVE);
1647     abilityRecord->connRecordList_.clear();
1648     connectManager->serviceMap_.emplace("first", abilityRecord);
1649     int res = connectManager->ScheduleCommandAbilityDoneLocked(token);
1650     EXPECT_EQ(res, ERR_OK);
1651 }
1652 
1653 /*
1654  * Feature: AbilityConnectManager
1655  * Function: CompleteCommandAbility
1656  * SubFunction: CompleteCommandAbility
1657  * FunctionPoints: NA
1658  * EnvConditions: NA
1659  * CaseDescription: Verify AbilityConnectManager CompleteCommandAbility
1660  */
1661 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_CompleteCommandAbility_001, TestSize.Level1)
1662 {
1663     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1664     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1665     connectManager->taskHandler_ = nullptr;
1666     connectManager->CompleteCommandAbility(abilityRecord);
1667     EXPECT_TRUE(abilityRecord->IsAbilityState(AbilityState::ACTIVE));
1668 }
1669 
1670 /*
1671  * Feature: AbilityConnectManager
1672  * Function: GetServiceRecordByElementName
1673  * SubFunction: GetServiceRecordByElementName
1674  * FunctionPoints: NA
1675  * EnvConditions: NA
1676  * CaseDescription: Verify AbilityConnectManager GetServiceRecordByElementName
1677  */
1678 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_GetServiceRecordByElementName_001, TestSize.Level1)
1679 {
1680     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1681     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1682     std::string element = "first";
1683     connectManager->serviceMap_.emplace(element, abilityRecord);
1684     auto res = connectManager->GetServiceRecordByElementName(element);
1685     EXPECT_NE(res, nullptr);
1686 }
1687 
1688 /*
1689  * Feature: AbilityConnectManager
1690  * Function: GetExtensionByTokenFromServiceMap
1691  * SubFunction: GetExtensionByTokenFromServiceMap
1692  * FunctionPoints: NA
1693  * EnvConditions: NA
1694  * CaseDescription: Verify AbilityConnectManager GetExtensionByTokenFromServiceMap
1695  */
1696 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_GetExtensionByTokenFromServiceMap_001, TestSize.Level1)
1697 {
1698     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1699     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1700     sptr<IRemoteObject> token = abilityRecord->GetToken();
1701     connectManager->serviceMap_.emplace("first", nullptr);
1702     auto res = connectManager->GetExtensionByTokenFromServiceMap(token);
1703     EXPECT_EQ(res, nullptr);
1704 }
1705 
1706 /*
1707  * Feature: AbilityConnectManager
1708  * Function: GetConnectRecordListByCallback
1709  * SubFunction: GetConnectRecordListByCallback
1710  * FunctionPoints: NA
1711  * EnvConditions: NA
1712  * CaseDescription: Verify AbilityConnectManager GetConnectRecordListByCallback
1713  */
1714 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_GetConnectRecordListByCallback_001, TestSize.Level1)
1715 {
1716     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1717     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1718     sptr<IAbilityConnection> callback = new AbilityConnectCallback();
1719     connectManager->connectMap_.clear();
1720     auto res = connectManager->GetConnectRecordListByCallback(callback);
1721     EXPECT_EQ(res.size(), 0u);
1722 }
1723 
1724 /*
1725  * Feature: AbilityConnectManager
1726  * Function: GetExtensionByIdFromServiceMap
1727  * SubFunction: GetExtensionByIdFromServiceMap
1728  * FunctionPoints: NA
1729  * EnvConditions: NA
1730  * CaseDescription: Verify AbilityConnectManager GetExtensionByIdFromServiceMap
1731  */
1732 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_GetAbilityRecordById_001, TestSize.Level1)
1733 {
1734     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1735     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1736     int64_t abilityRecordId = abilityRecord->GetRecordId();
1737     connectManager->serviceMap_.emplace("first", abilityRecord);
1738     connectManager->serviceMap_.emplace("second", nullptr);
1739     auto res = connectManager->GetExtensionByIdFromServiceMap(abilityRecordId);
1740     EXPECT_NE(res, nullptr);
1741 }
1742 
1743 /*
1744  * Feature: AbilityConnectManager
1745  * Function: LoadAbility
1746  * SubFunction: LoadAbility
1747  * FunctionPoints: NA
1748  * EnvConditions: NA
1749  * CaseDescription: Verify AbilityConnectManager LoadAbility
1750  */
1751 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_LoadAbility_001, TestSize.Level1)
1752 {
1753     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1754     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1755     abilityRecord->isLauncherRoot_ = true;
1756     abilityRecord->isRestarting_ = true;
1757     abilityRecord->isLauncherAbility_ = true;
1758     abilityRecord->restartCount_ = -1;
1759     EXPECT_FALSE(abilityRecord->CanRestartRootLauncher());
1760     connectManager->LoadAbility(abilityRecord);
1761 }
1762 
1763 /*
1764  * Feature: AbilityConnectManager
1765  * Function: LoadAbility
1766  * SubFunction: LoadAbility
1767  * FunctionPoints: NA
1768  * EnvConditions: NA
1769  * CaseDescription: Verify AbilityConnectManager LoadAbility
1770  */
1771 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_LoadAbility_002, TestSize.Level1)
1772 {
1773     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1774     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1775     std::shared_ptr<CallerRecord> caller1 = std::make_shared<CallerRecord>(0, abilityRecord);
1776     std::shared_ptr<CallerRecord> caller2 = std::make_shared<CallerRecord>();
1777     abilityRecord->isLauncherRoot_ = false;
1778     abilityRecord->isCreateByConnect_ = false;
1779     abilityRecord->callerList_.push_back(caller1);
1780     EXPECT_TRUE(abilityRecord->CanRestartRootLauncher());
1781     connectManager->LoadAbility(abilityRecord);
1782     abilityRecord->callerList_.push_back(caller2);
1783     connectManager->LoadAbility(abilityRecord);
1784     abilityRecord->callerList_.push_back(nullptr);
1785     connectManager->LoadAbility(abilityRecord);
1786 }
1787 
1788 /*
1789  * Feature: AbilityConnectManager
1790  * Function: PostTimeOutTask
1791  * SubFunction: PostTimeOutTask
1792  * FunctionPoints: NA
1793  * EnvConditions: NA
1794  * CaseDescription: Verify AbilityConnectManager PostTimeOutTask
1795  */
1796 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_PostTimeOutTask_001, TestSize.Level1)
1797 {
1798     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1799     ASSERT_NE(connectManager, nullptr);
1800     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1801     uint32_t messageId = 2;
1802     connectManager->PostTimeOutTask(abilityRecord, messageId);
1803 }
1804 
1805 /*
1806  * Feature: AbilityConnectManager
1807  * Function: HandleStartTimeoutTask
1808  * SubFunction: HandleStartTimeoutTask
1809  * FunctionPoints: NA
1810  * EnvConditions: NA
1811  * CaseDescription: Verify AbilityConnectManager HandleStartTimeoutTask
1812  */
1813 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_HandleStartTimeoutTask_001, TestSize.Level1)
1814 {
1815     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1816     ASSERT_NE(connectManager, nullptr);
1817     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1818     abilityRecord->abilityInfo_.name = "abilityName";
1819     connectManager->HandleStartTimeoutTask(abilityRecord);
1820 }
1821 
1822 /*
1823  * Feature: AbilityConnectManager
1824  * Function: HandleStartTimeoutTask
1825  * SubFunction: HandleStartTimeoutTask
1826  * FunctionPoints: NA
1827  * EnvConditions: NA
1828  * CaseDescription: Verify AbilityConnectManager HandleStartTimeoutTask
1829  */
1830 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_HandleStartTimeoutTask_002, TestSize.Level1)
1831 {
1832     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1833     ASSERT_NE(connectManager, nullptr);
1834     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1835     abilityRecord->abilityInfo_.name = AbilityConfig::LAUNCHER_ABILITY_NAME;
1836     connectManager->HandleStartTimeoutTask(abilityRecord);
1837 }
1838 
1839 /*
1840  * Feature: AbilityConnectManager
1841  * Function: HandleConnectTimeoutTask
1842  * SubFunction: HandleConnectTimeoutTask
1843  * FunctionPoints: NA
1844  * EnvConditions: NA
1845  * CaseDescription: Verify AbilityConnectManager HandleConnectTimeoutTask
1846  */
1847 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_HandleConnectTimeoutTask_001, TestSize.Level1)
1848 {
1849     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1850     ASSERT_NE(connectManager, nullptr);
1851     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1852     abilityRecord->abilityInfo_.name = AbilityConfig::LAUNCHER_ABILITY_NAME;
1853     connectManager->HandleConnectTimeoutTask(abilityRecord);
1854 }
1855 
1856 /*
1857  * Feature: AbilityConnectManager
1858  * Function: HandleCommandTimeoutTask
1859  * SubFunction: HandleCommandTimeoutTask
1860  * FunctionPoints: NA
1861  * EnvConditions: NA
1862  * CaseDescription: Verify AbilityConnectManager HandleCommandTimeoutTask
1863  */
1864 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_HandleCommandTimeoutTask_001, TestSize.Level1)
1865 {
1866     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1867     ASSERT_NE(connectManager, nullptr);
1868     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1869     abilityRecord->abilityInfo_.name = AbilityConfig::LAUNCHER_ABILITY_NAME;
1870     connectManager->HandleCommandTimeoutTask(abilityRecord);
1871     abilityRecord->abilityInfo_.name = "abilityName";
1872     connectManager->HandleCommandTimeoutTask(abilityRecord);
1873 }
1874 
1875 /*
1876  * Feature: AbilityConnectManager
1877  * Function: HandleTerminateDisconnectTask
1878  * SubFunction: HandleTerminateDisconnectTask
1879  * FunctionPoints: NA
1880  * EnvConditions: NA
1881  * CaseDescription: Verify AbilityConnectManager HandleTerminateDisconnectTask
1882  */
1883 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_HandleTerminateDisconnectTask_001, TestSize.Level1)
1884 {
1885     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1886     ASSERT_NE(connectManager, nullptr);
1887     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
1888     std::shared_ptr<ConnectionRecord> connection =
1889         std::make_shared<ConnectionRecord>(nullptr, nullptr, callback);
1890     AbilityConnectManager::ConnectListType connectlist;
1891     connectlist.push_back(nullptr);
1892     connectlist.push_back(connection);
1893     connectManager->HandleTerminateDisconnectTask(connectlist);
1894 }
1895 
1896 /*
1897  * Feature: AbilityConnectManager
1898  * Function: DispatchInactive
1899  * SubFunction: DispatchInactive
1900  * FunctionPoints: NA
1901  * EnvConditions: NA
1902  * CaseDescription: Verify AbilityConnectManager DispatchInactive
1903  */
1904 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_DispatchInactive_001, TestSize.Level1)
1905 {
1906     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1907     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1908     int state = 0;
1909     abilityRecord->SetAbilityState(AbilityState::INACTIVATING);
1910     abilityRecord->isCreateByConnect_ = false;
1911     connectManager->SetTaskHandler(TaskHandler());
1912     connectManager->SetEventHandler(EventHandler());
1913     int res = connectManager->DispatchInactive(abilityRecord, state);
1914     EXPECT_EQ(res, ERR_OK);
1915 }
1916 
1917 /*
1918  * Feature: AbilityConnectManager
1919  * Function: DispatchTerminate
1920  * SubFunction: DispatchTerminate
1921  * FunctionPoints: NA
1922  * EnvConditions: NA
1923  * CaseDescription: Verify AbilityConnectManager DispatchTerminate
1924  */
1925 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_DispatchTerminate_001, TestSize.Level1)
1926 {
1927     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1928     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1929     connectManager->SetTaskHandler(TaskHandler());
1930     connectManager->SetEventHandler(EventHandler());
1931     int res = connectManager->DispatchTerminate(abilityRecord);
1932     EXPECT_EQ(res, ERR_OK);
1933 }
1934 
1935 /*
1936  * Feature: AbilityConnectManager
1937  * Function: CommandAbility
1938  * SubFunction: CommandAbility
1939  * FunctionPoints: NA
1940  * EnvConditions: NA
1941  * CaseDescription: Verify AbilityConnectManager CommandAbility
1942  */
1943 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_CommandAbility_001, TestSize.Level1)
1944 {
1945     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1946     ASSERT_NE(connectManager, nullptr);
1947     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1948     connectManager->SetEventHandler(nullptr);
1949     connectManager->CommandAbility(abilityRecord);
1950 }
1951 
1952 /*
1953  * Feature: AbilityConnectManager
1954  * Function: TerminateDone
1955  * SubFunction: TerminateDone
1956  * FunctionPoints: NA
1957  * EnvConditions: NA
1958  * CaseDescription: Verify AbilityConnectManager TerminateDone
1959  */
1960 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_TerminateDone_001, TestSize.Level1)
1961 {
1962     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1963     ASSERT_NE(connectManager, nullptr);
1964     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1965     abilityRecord->SetAbilityState(AbilityState::TERMINATING);
1966     connectManager->TerminateDone(abilityRecord);
1967 }
1968 
1969 /*
1970  * Feature: AbilityConnectManager
1971  * Function: IsAbilityConnected
1972  * SubFunction: IsAbilityConnected
1973  * FunctionPoints: NA
1974  * EnvConditions: NA
1975  * CaseDescription: Verify AbilityConnectManager IsAbilityConnected
1976  */
1977 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_IsAbilityConnected_001, TestSize.Level1)
1978 {
1979     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
1980     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
1981     std::list<std::shared_ptr<ConnectionRecord>> connectRecordList;
1982     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
1983     std::shared_ptr<ConnectionRecord> connection =
1984         std::make_shared<ConnectionRecord>(abilityRecord->GetToken(), abilityRecord, callback);
1985     connectRecordList.push_back(connection);
1986     bool res1 = connectManager->IsAbilityConnected(nullptr, connectRecordList);
1987     EXPECT_FALSE(res1);
1988     connectRecordList.push_back(nullptr);
1989     bool res2 = connectManager->IsAbilityConnected(abilityRecord, connectRecordList);
1990     EXPECT_TRUE(res2);
1991 }
1992 
1993 /*
1994  * Feature: AbilityConnectManager
1995  * Function: RemoveServiceAbility
1996  * SubFunction: RemoveServiceAbility
1997  * FunctionPoints: NA
1998  * EnvConditions: NA
1999  * CaseDescription: Verify AbilityConnectManager RemoveServiceAbility
2000  */
2001 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_RemoveServiceAbility_001, TestSize.Level1)
2002 {
2003     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2004     ASSERT_NE(connectManager, nullptr);
2005     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2006     AbilityInfo abilityInfo;
2007     abilityRecord->abilityInfo_ = abilityInfo;
2008     connectManager->serviceMap_.clear();
2009     connectManager->RemoveServiceAbility(abilityRecord);
2010 }
2011 
2012 /*
2013  * Feature: AbilityConnectManager
2014  * Function: OnCallBackDied
2015  * SubFunction: OnCallBackDied
2016  * FunctionPoints: NA
2017  * EnvConditions: NA
2018  * CaseDescription: Verify AbilityConnectManager OnCallBackDied
2019  */
2020 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_OnCallBackDied_001, TestSize.Level1)
2021 {
2022     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2023     ASSERT_NE(connectManager, nullptr);
2024     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2025     wptr<IRemoteObject> remote{ abilityRecord->GetToken() };
2026     connectManager->SetEventHandler(nullptr);
2027     connectManager->OnCallBackDied(remote);
2028 }
2029 
2030 /*
2031  * Feature: AbilityConnectManager
2032  * Function: HandleCallBackDiedTask
2033  * SubFunction: HandleCallBackDiedTask
2034  * FunctionPoints: NA
2035  * EnvConditions: NA
2036  * CaseDescription: Verify AbilityConnectManager HandleCallBackDiedTask
2037  */
2038 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_HandleCallBackDiedTask_001, TestSize.Level1)
2039 {
2040     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2041     ASSERT_NE(connectManager, nullptr);
2042     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2043     sptr<IRemoteObject> connect = abilityRecord->GetToken();
2044     connectManager->connectMap_.clear();
2045     connectManager->HandleCallBackDiedTask(connect);
2046 }
2047 
2048 /*
2049  * Feature: AbilityConnectManager
2050  * Function: OnAbilityDied
2051  * SubFunction: OnAbilityDied
2052  * FunctionPoints: NA
2053  * EnvConditions: NA
2054  * CaseDescription: Verify AbilityConnectManager OnAbilityDied
2055  */
2056 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_OnAbilityDied_001, TestSize.Level1)
2057 {
2058     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2059     ASSERT_NE(connectManager, nullptr);
2060     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2061     int32_t currentUserId = 0;
2062     abilityRecord->abilityInfo_.type = AbilityType::PAGE;
2063     connectManager->SetEventHandler(nullptr);
2064     connectManager->OnAbilityDied(abilityRecord, currentUserId);
2065     abilityRecord->abilityInfo_.type = AbilityType::EXTENSION;
2066     connectManager->OnAbilityDied(abilityRecord, currentUserId);
2067 }
2068 
2069 /*
2070  * Feature: AbilityConnectManager
2071  * Function: OnTimeOut
2072  * SubFunction: OnTimeOut
2073  * FunctionPoints: NA
2074  * EnvConditions: NA
2075  * CaseDescription: Verify AbilityConnectManager OnTimeOut
2076  */
2077 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_OnTimeOut_001, TestSize.Level1)
2078 {
2079     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2080     ASSERT_NE(connectManager, nullptr);
2081     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2082     uint32_t msgId = 2;
2083     connectManager->serviceMap_.emplace("first", abilityRecord);
2084     int64_t abilityRecordId = 1;
2085     connectManager->OnTimeOut(msgId, abilityRecordId);
2086     msgId = 0;
2087     connectManager->OnTimeOut(msgId, abilityRecordId);
2088 }
2089 
2090 /*
2091  * Feature: AbilityConnectManager
2092  * Function: HandleInactiveTimeout
2093  * SubFunction: HandleInactiveTimeout
2094  * FunctionPoints: NA
2095  * EnvConditions: NA
2096  * CaseDescription: Verify AbilityConnectManager HandleInactiveTimeout
2097  */
2098 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_HandleInactiveTimeout_001, TestSize.Level1)
2099 {
2100     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2101     ASSERT_NE(connectManager, nullptr);
2102     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2103     abilityRecord->abilityInfo_.name = AbilityConfig::LAUNCHER_ABILITY_NAME;
2104     connectManager->HandleInactiveTimeout(abilityRecord);
2105     abilityRecord->abilityInfo_.name = "abilityName";
2106     connectManager->HandleInactiveTimeout(abilityRecord);
2107 }
2108 
2109 /*
2110  * Feature: AbilityConnectManager
2111  * Function: HandleAbilityDiedTask
2112  * SubFunction: HandleAbilityDiedTask
2113  * FunctionPoints: NA
2114  * EnvConditions: NA
2115  * CaseDescription: Verify AbilityConnectManager HandleAbilityDiedTask
2116  */
2117 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_HandleAbilityDiedTask_001, TestSize.Level1)
2118 {
2119     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2120     ASSERT_NE(connectManager, nullptr);
2121     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2122     int32_t currentUserId = 0;
2123     connectManager->serviceMap_.clear();
2124     connectManager->HandleAbilityDiedTask(abilityRecord, currentUserId);
2125 }
2126 
2127 /*
2128  * Feature: AbilityConnectManager
2129  * Function: RestartAbility
2130  * SubFunction: RestartAbility
2131  * FunctionPoints: NA
2132  * EnvConditions: NA
2133  * CaseDescription: Verify AbilityConnectManager RestartAbility
2134  */
2135 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_RestartAbility_001, TestSize.Level1)
2136 {
2137     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2138     ASSERT_NE(connectManager, nullptr);
2139     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2140     int32_t currentUserId = 0;
2141     connectManager->userId_ = 1;
2142     abilityRecord->abilityInfo_.name = AbilityConfig::LAUNCHER_ABILITY_NAME;
2143     connectManager->RestartAbility(abilityRecord, currentUserId);
2144     connectManager->userId_ = currentUserId;
2145     connectManager->RestartAbility(abilityRecord, currentUserId);
2146 }
2147 
2148 /*
2149  * Feature: AbilityConnectManager
2150  * Function: RestartAbility
2151  * SubFunction: RestartAbility
2152  * FunctionPoints: NA
2153  * EnvConditions: NA
2154  * CaseDescription: Verify AbilityConnectManager RestartAbility
2155  */
2156 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_RestartAbility_002, TestSize.Level1)
2157 {
2158     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2159     ASSERT_NE(connectManager, nullptr);
2160     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2161     int32_t currentUserId = 0;
2162     connectManager->userId_ = currentUserId;
2163     abilityRecord->abilityInfo_.name = "abilityName";
2164     abilityRecord->SetRestartCount(-1);
2165     connectManager->RestartAbility(abilityRecord, currentUserId);
2166 }
2167 
2168 /*
2169  * Feature: AbilityConnectManager
2170  * Function: DumpState
2171  * SubFunction: DumpState
2172  * FunctionPoints: NA
2173  * EnvConditions: NA
2174  * CaseDescription: Verify AbilityConnectManager DumpState
2175  */
2176 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_DumpState_001, TestSize.Level1)
2177 {
2178     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2179     ASSERT_NE(connectManager, nullptr);
2180     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2181     std::vector<std::string> info;
2182     bool isClient = false;
2183     std::string args = "args";
2184     connectManager->serviceMap_.emplace(args, abilityRecord);
2185     connectManager->DumpState(info, isClient, args);
2186     connectManager->serviceMap_.clear();
2187     connectManager->DumpState(info, isClient, args);
2188     args = "";
2189     connectManager->DumpState(info, isClient, args);
2190 }
2191 
2192 /*
2193  * Feature: AbilityConnectManager
2194  * Function: DumpStateByUri
2195  * SubFunction: DumpStateByUri
2196  * FunctionPoints: NA
2197  * EnvConditions: NA
2198  * CaseDescription: Verify AbilityConnectManager DumpStateByUri
2199  */
2200 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_DumpStateByUri_001, TestSize.Level1)
2201 {
2202     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2203     ASSERT_NE(connectManager, nullptr);
2204     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2205     std::vector<std::string> info;
2206     bool isClient = false;
2207     std::string args = "args";
2208     std::vector<std::string> params;
2209     connectManager->serviceMap_.emplace(args, abilityRecord);
2210     connectManager->DumpStateByUri(info, isClient, args, params);
2211     connectManager->serviceMap_.clear();
2212     connectManager->DumpStateByUri(info, isClient, args, params);
2213 }
2214 
2215 /*
2216  * Feature: AbilityConnectManager
2217  * Function: GetExtensionRunningInfos
2218  * SubFunction: GetExtensionRunningInfos
2219  * FunctionPoints: NA
2220  * EnvConditions: NA
2221  * CaseDescription: Verify AbilityConnectManager GetExtensionRunningInfos
2222  */
2223 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_GetExtensionRunningInfos_001, TestSize.Level1)
2224 {
2225     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2226     ASSERT_NE(connectManager, nullptr);
2227     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2228     int upperLimit = 1;
2229     std::vector<ExtensionRunningInfo> info;
2230     int32_t userId = 0;
2231     bool isPerm = false;
2232     ExtensionRunningInfo extensionInfo;
2233     info.push_back(extensionInfo);
2234     connectManager->serviceMap_.emplace("first", abilityRecord);
2235     connectManager->GetExtensionRunningInfos(upperLimit, info, userId, isPerm);
2236 }
2237 
2238 /*
2239  * Feature: AbilityConnectManager
2240  * Function: GetExtensionRunningInfo
2241  * SubFunction: GetExtensionRunningInfo
2242  * FunctionPoints: NA
2243  * EnvConditions: NA
2244  * CaseDescription: Verify AbilityConnectManager GetExtensionRunningInfo
2245  */
2246 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_GetExtensionRunningInfo_001, TestSize.Level1)
2247 {
2248     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2249     ASSERT_NE(connectManager, nullptr);
2250     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2251     OHOS::sptr<IAbilityConnection> callback = new AbilityConnectCallback();
2252     std::shared_ptr<ConnectionRecord> connection =
2253         std::make_shared<ConnectionRecord>(abilityRecord->GetToken(), abilityRecord, callback);
2254     int32_t userId = 0;
2255     std::vector<ExtensionRunningInfo> info;
2256     Want want;
2257     AbilityInfo abilityInfo;
2258     ApplicationInfo applicationInfo;
2259     want.SetElementName("device", "bundle", "ability", "module");
2260     abilityRecord->SetWant(want);
2261     abilityRecord->connRecordList_.push_back(nullptr);
2262     abilityRecord->connRecordList_.push_back(connection);
2263     connectManager->GetExtensionRunningInfo(abilityRecord, userId, info);
2264 }
2265 
2266 /*
2267  * Feature: AbilityConnectManager
2268  * Function: IsAbilityNeedKeepAlive
2269  * SubFunction:
2270  * FunctionPoints: IsAbilityNeedKeepAlive
2271  * EnvConditions:NA
2272  * CaseDescription: Verify the IsAbilityNeedKeepAlive need keep alive.
2273  * @tc.require: issueI6588V
2274  */
2275 HWTEST_F(AbilityConnectManagerTest, AAFWK_IsAbilityNeedKeepAlive_001, TestSize.Level1)
2276 {
2277     ConnectManager()->SetTaskHandler(TaskHandler());
2278     ConnectManager()->SetEventHandler(EventHandler());
2279 
2280     serviceRecord2_->SetKeepAliveBundle(true);
2281     // mock bms return
2282     EXPECT_TRUE(ConnectManager()->IsAbilityNeedKeepAlive(serviceRecord2_));
2283 }
2284 
2285 /*
2286  * Feature: AbilityConnectManager
2287  * Function: RestartAbility
2288  * SubFunction:
2289  * FunctionPoints: RestartAbility
2290  * EnvConditions:NA
2291  * CaseDescription: Verify ability not restart the normal ability died.
2292  * @tc.require: issueI6588V
2293  */
2294 HWTEST_F(AbilityConnectManagerTest, AAFWK_RestartAbility_001, TestSize.Level1)
2295 {
2296     ConnectManager()->SetTaskHandler(TaskHandler());
2297     ConnectManager()->SetEventHandler(EventHandler());
2298 
2299     int userId = 0;
2300 
2301     auto result = ConnectManager()->StartAbility(abilityRequest_);
2302     EXPECT_EQ(OHOS::ERR_OK, result);
2303     WaitUntilTaskDone(TaskHandler());
2304 
2305     auto elementName = abilityRequest_.want.GetElement().GetURI();
2306     std::shared_ptr<AbilityRecord> service = ConnectManager()->GetServiceRecordByElementName(elementName);
2307     EXPECT_NE(service, nullptr);
2308     EXPECT_EQ(static_cast<int>(ConnectManager()->GetServiceMap().size()), 1);
2309 
2310     // HandleTerminate
2311     ConnectManager()->OnAbilityDied(service, userId);
2312     WaitUntilTaskDone(TaskHandler());
2313     EXPECT_EQ(static_cast<int>(ConnectManager()->GetServiceMap().size()), 0);
2314 }
2315 
2316 /*
2317  * Feature: AbilityConnectManager
2318  * Function: RestartAbility
2319  * SubFunction:
2320  * FunctionPoints: RestartAbility
2321  * EnvConditions:NA
2322  * CaseDescription: Verify ability restart when the resident ability died.
2323  * @tc.require: issueI6588V
2324  */
2325 HWTEST_F(AbilityConnectManagerTest, AAFWK_RestartAbility_002, TestSize.Level1)
2326 {
2327     ConnectManager()->SetTaskHandler(TaskHandler());
2328     ConnectManager()->SetEventHandler(EventHandler());
2329 
2330     int userId = 0;
2331 
2332     auto result = ConnectManager()->StartAbility(abilityRequest2_);
2333     EXPECT_EQ(OHOS::ERR_OK, result);
2334     WaitUntilTaskDone(TaskHandler());
2335 
2336     auto elementName = abilityRequest2_.want.GetElement().GetURI();
2337     auto service = ConnectManager()->GetServiceRecordByElementName(elementName);
2338     EXPECT_NE(service, nullptr);
2339     EXPECT_EQ(static_cast<int>(ConnectManager()->GetServiceMap().size()), 1);
2340 
2341     // HandleTerminate
2342     ConnectManager()->HandleAbilityDiedTask(service, userId);
2343     EXPECT_EQ(static_cast<int>(ConnectManager()->GetServiceMap().size()), 0);
2344 }
2345 
2346 /*
2347  * Feature: AbilityConnectManager
2348  * Function: RestartAbility
2349  * SubFunction:
2350  * FunctionPoints: RestartAbility
2351  * EnvConditions:NA
2352  * CaseDescription: Verify ability restart when the resident ability died and restart out of max times.
2353  * @tc.require: issueI6588V
2354  */
2355 HWTEST_F(AbilityConnectManagerTest, AAFWK_RestartAbility_003, TestSize.Level1)
2356 {
2357     ConnectManager()->SetTaskHandler(TaskHandler());
2358     ConnectManager()->SetEventHandler(EventHandler());
2359 
2360     int userId = 0;
2361 
2362     auto result = ConnectManager()->StartAbility(abilityRequest2_);
2363     EXPECT_EQ(OHOS::ERR_OK, result);
2364     WaitUntilTaskDone(TaskHandler());
2365 
2366     auto elementName = abilityRequest2_.want.GetElement().GetURI();
2367     std::shared_ptr<AbilityRecord> service = ConnectManager()->GetServiceRecordByElementName(elementName);
2368     EXPECT_NE(service, nullptr);
2369     EXPECT_EQ(static_cast<int>(ConnectManager()->GetServiceMap().size()), 1);
2370     // set the over interval time according the config; without init config, the interval time is 0.
2371     // ensure now - restartTime < intervalTime
2372     service->SetRestartTime(AbilityUtil::SystemTimeMillis() + 1000);
2373 
2374     // HandleTerminate
2375     ConnectManager()->HandleAbilityDiedTask(service, userId);
2376     EXPECT_EQ(static_cast<int>(ConnectManager()->GetServiceMap().size()), 0);
2377 }
2378 
2379 /*
2380  * Feature: AbilityConnectManager
2381  * Function: PostRestartResidentTask
2382  * SubFunction:
2383  * FunctionPoints: PostRestartResidentTask
2384  * EnvConditions:NA
2385  * CaseDescription: Verify the PostRestartResidentTask process.
2386  * @tc.require: issueI6588V
2387  */
2388 HWTEST_F(AbilityConnectManagerTest, AAFWK_PostRestartResidentTask_001, TestSize.Level1)
2389 {
2390     ConnectManager()->SetTaskHandler(TaskHandler());
2391     ConnectManager()->SetEventHandler(EventHandler());
2392 
2393     ConnectManager()->PostRestartResidentTask(abilityRequest2_);
2394     WaitUntilTaskDone(TaskHandler());
2395     EXPECT_EQ(static_cast<int>(ConnectManager()->GetServiceMap().size()), 0);
2396 }
2397 
2398 /*
2399  * Feature: AbilityConnectManager
2400  * Function: StartAbility
2401  * SubFunction: NA
2402  * FunctionPoints: StartAbility
2403  * EnvConditions:NA
2404  * CaseDescription: Verify the normal process of startability with session info
2405  */
2406 HWTEST_F(AbilityConnectManagerTest, AAFWK_Start_Service_With_SessionInfo_001, TestSize.Level1)
2407 {
2408     ConnectManager()->SetTaskHandler(TaskHandler());
2409     ConnectManager()->SetEventHandler(EventHandler());
2410 
2411     auto sessionInfo = MockSessionInfo(0);
2412     abilityRequest_.sessionInfo = sessionInfo;
2413     auto result = ConnectManager()->StartAbility(abilityRequest_);
2414     EXPECT_EQ(OHOS::ERR_OK, result);
2415     abilityRequest_.sessionInfo = nullptr;
2416     WaitUntilTaskDone(TaskHandler());
2417 
2418     auto service = ConnectManager()->GetUIExtensioBySessionInfo(sessionInfo);
2419     EXPECT_EQ(static_cast<int>(ConnectManager()->GetServiceMap().size()), 1);
2420 }
2421 
2422 /*
2423  * Feature: AbilityConnectManager
2424  * Function: StartAbilityLocked
2425  * SubFunction: StartAbilityLocked
2426  * FunctionPoints: NA
2427  * EnvConditions: NA
2428  * CaseDescription: Verify AbilityConnectManager StartAbilityLocked with session info
2429  */
2430 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_StartAbilityLocked_With_SessionInfo_001, TestSize.Level1)
2431 {
2432     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2433     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2434     AbilityRequest abilityRequest;
2435     abilityRequest.abilityInfo.deviceId = "id";
2436     abilityRequest.abilityInfo.bundleName = "bundle";
2437     abilityRequest.abilityInfo.name = "name";
2438     abilityRequest.abilityInfo.moduleName = "module";
2439     std::string stringUri = "id/bundle/module/name";
2440     AppExecFwk::ElementName element(abilityRequest.abilityInfo.deviceId, abilityRequest.abilityInfo.bundleName,
2441         abilityRequest.abilityInfo.name, abilityRequest.abilityInfo.moduleName);
2442     EXPECT_EQ(element.GetURI(), stringUri);
2443     abilityRecord->currentState_ = AbilityState::ACTIVE;
2444     abilityRecord->SetPreAbilityRecord(serviceRecord1_);
2445     connectManager->serviceMap_.emplace(stringUri, abilityRecord);
2446     abilityRequest.sessionInfo = MockSessionInfo(0);
2447     int res = connectManager->StartAbilityLocked(abilityRequest);
2448     EXPECT_EQ(res, ERR_OK);
2449 }
2450 
2451 /*
2452  * Feature: MissionListManager
2453  * Function: MoveToBackground
2454  * SubFunction: NA
2455  * FunctionPoints: MissionListManager MoveToBackground
2456  * EnvConditions: NA
2457  * CaseDescription: Verify MoveToBackground
2458  */
2459 HWTEST_F(AbilityConnectManagerTest, MoveToBackground_001, TestSize.Level1)
2460 {
2461     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2462     ASSERT_NE(connectManager, nullptr);
2463     std::shared_ptr<AbilityRecord> abilityRecord;
2464     connectManager->MoveToBackground(abilityRecord);
2465     connectManager.reset();
2466 }
2467 
2468 /*
2469  * Feature: MissionListManager
2470  * Function: MoveToBackground
2471  * SubFunction: NA
2472  * FunctionPoints: MissionListManager MoveToBackground
2473  * EnvConditions: NA
2474  * CaseDescription: Verify MoveToBackground
2475  */
2476 HWTEST_F(AbilityConnectManagerTest, MoveToBackground_002, TestSize.Level1)
2477 {
2478     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2479     ASSERT_NE(connectManager, nullptr);
2480     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2481     abilityRecord->lifeCycleStateInfo_.sceneFlag = 1;
2482     connectManager->MoveToBackground(abilityRecord);
2483     connectManager.reset();
2484 }
2485 
2486 /*
2487  * Feature: MissionListManager
2488  * Function: MoveToBackground
2489  * SubFunction: NA
2490  * FunctionPoints: MissionListManager MoveToBackground
2491  * EnvConditions: NA
2492  * CaseDescription: Verify MoveToBackground
2493  */
2494 HWTEST_F(AbilityConnectManagerTest, MoveToBackground_003, TestSize.Level1)
2495 {
2496     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2497     ASSERT_NE(connectManager, nullptr);
2498     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2499     abilityRecord->lifeCycleStateInfo_.sceneFlag = 2;
2500     abilityRecord->SetClearMissionFlag(true);
2501     connectManager->MoveToBackground(abilityRecord);
2502     connectManager.reset();
2503 }
2504 
2505 
2506 /*
2507  * Feature: MissionListManager
2508  * Function: CompleteBackground
2509  * SubFunction: NA
2510  * FunctionPoints: MissionListManager CompleteBackground
2511  * EnvConditions: NA
2512  * CaseDescription: Verify CompleteBackground
2513  */
2514 HWTEST_F(AbilityConnectManagerTest, CompleteBackground_001, TestSize.Level1)
2515 {
2516     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2517     ASSERT_NE(connectManager, nullptr);
2518     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2519     abilityRecord->currentState_ = AbilityState::FOREGROUND;
2520     connectManager->CompleteBackground(abilityRecord);
2521     connectManager.reset();
2522 }
2523 
2524 /*
2525  * Feature: MissionListManager
2526  * Function: CompleteBackground
2527  * SubFunction: NA
2528  * FunctionPoints: MissionListManager CompleteBackground
2529  * EnvConditions: NA
2530  * CaseDescription: Verify CompleteBackground
2531  */
2532 HWTEST_F(AbilityConnectManagerTest, CompleteBackground_002, TestSize.Level1)
2533 {
2534     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2535     ASSERT_NE(connectManager, nullptr);
2536     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2537     abilityRecord->currentState_ = AbilityState::BACKGROUNDING;
2538     abilityRecord->SetPendingState(AbilityState::FOREGROUND);
2539     abilityRecord->SetSwitchingPause(true);
2540     connectManager->CompleteBackground(abilityRecord);
2541     connectManager.reset();
2542 }
2543 
2544 /*
2545  * Feature: MissionListManager
2546  * Function: CompleteBackground
2547  * SubFunction: NA
2548  * FunctionPoints: MissionListManager CompleteBackground
2549  * EnvConditions: NA
2550  * CaseDescription: Verify CompleteBackground
2551  */
2552 HWTEST_F(AbilityConnectManagerTest, CompleteBackground_003, TestSize.Level1)
2553 {
2554     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2555     ASSERT_NE(connectManager, nullptr);
2556     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2557     abilityRecord->currentState_ = AbilityState::BACKGROUNDING;
2558     abilityRecord->SetPendingState(AbilityState::BACKGROUND);
2559     abilityRecord->SetSwitchingPause(false);
2560     abilityRecord->SetStartedByCall(true);
2561     abilityRecord->SetStartToBackground(true);
2562     abilityRecord->isReady_ = true;
2563     connectManager->CompleteBackground(abilityRecord);
2564     connectManager.reset();
2565 }
2566 
2567 /*
2568  * Feature: MissionListManager
2569  * Function: CompleteBackground
2570  * SubFunction: NA
2571  * FunctionPoints: MissionListManager CompleteBackground
2572  * EnvConditions: NA
2573  * CaseDescription: Verify CompleteBackground
2574  */
2575 HWTEST_F(AbilityConnectManagerTest, CompleteBackground_004, TestSize.Level1)
2576 {
2577     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2578     ASSERT_NE(connectManager, nullptr);
2579     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2580     std::shared_ptr<AbilityRecord> abilityRecord2 = InitAbilityRecord();
2581     abilityRecord->currentState_ = AbilityState::BACKGROUNDING;
2582     abilityRecord->SetPendingState(AbilityState::BACKGROUND);
2583     abilityRecord->SetSwitchingPause(false);
2584     abilityRecord->SetStartedByCall(false);
2585     abilityRecord->SetStartToBackground(true);
2586     abilityRecord->isReady_ = true;
2587     abilityRecord2->currentState_ = AbilityState::BACKGROUND;
2588     connectManager->CompleteBackground(abilityRecord);
2589     connectManager.reset();
2590 }
2591 
2592 /*
2593  * Feature: MissionListManager
2594  * Function: CompleteBackground
2595  * SubFunction: NA
2596  * FunctionPoints: MissionListManager CompleteBackground
2597  * EnvConditions: NA
2598  * CaseDescription: Verify CompleteBackground
2599  */
2600 HWTEST_F(AbilityConnectManagerTest, CompleteBackground_005, TestSize.Level1)
2601 {
2602     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2603     ASSERT_NE(connectManager, nullptr);
2604     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2605     std::shared_ptr<AbilityRecord> abilityRecord2 = InitAbilityRecord();
2606     abilityRecord->currentState_ = AbilityState::BACKGROUNDING;
2607     abilityRecord->SetPendingState(AbilityState::BACKGROUND);
2608     abilityRecord->SetSwitchingPause(false);
2609     abilityRecord->SetStartedByCall(true);
2610     abilityRecord->SetStartToBackground(false);
2611     abilityRecord->isReady_ = true;
2612     abilityRecord2->currentState_ = AbilityState::BACKGROUND;
2613     connectManager->CompleteBackground(abilityRecord);
2614     connectManager.reset();
2615 }
2616 
2617 /*
2618  * Feature: MissionListManager
2619  * Function: CompleteBackground
2620  * SubFunction: NA
2621  * FunctionPoints: MissionListManager CompleteBackground
2622  * EnvConditions: NA
2623  * CaseDescription: Verify CompleteBackground
2624  */
2625 HWTEST_F(AbilityConnectManagerTest, CompleteBackground_006, TestSize.Level1)
2626 {
2627     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2628     ASSERT_NE(connectManager, nullptr);
2629     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2630     std::shared_ptr<AbilityRecord> abilityRecord2 = InitAbilityRecord();
2631     abilityRecord->currentState_ = AbilityState::BACKGROUNDING;
2632     abilityRecord->SetPendingState(AbilityState::BACKGROUND);
2633     abilityRecord->SetSwitchingPause(false);
2634     abilityRecord->SetStartedByCall(true);
2635     abilityRecord->SetStartToBackground(true);
2636     abilityRecord->isReady_ = false;
2637     abilityRecord2->currentState_ = AbilityState::FOREGROUND;
2638     connectManager->CompleteBackground(abilityRecord);
2639     connectManager.reset();
2640 }
2641 
2642 /*
2643  * Feature: MissionListManager
2644  * Function: PrintTimeOutLog
2645  * SubFunction: NA
2646  * FunctionPoints: MissionListManager PrintTimeOutLog
2647  * EnvConditions: NA
2648  * CaseDescription: Verify PrintTimeOutLog
2649  */
2650 HWTEST_F(AbilityConnectManagerTest, PrintTimeOutLog_001, TestSize.Level1)
2651 {
2652     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2653     ASSERT_NE(connectManager, nullptr);
2654     uint32_t msgId = 0;
2655     connectManager->PrintTimeOutLog(nullptr, msgId);
2656     connectManager.reset();
2657 }
2658 
2659 /*
2660  * Feature: MissionListManager
2661  * Function: PrintTimeOutLog
2662  * SubFunction: NA
2663  * FunctionPoints: MissionListManager PrintTimeOutLog
2664  * EnvConditions: NA
2665  * CaseDescription: Verify PrintTimeOutLog
2666  */
2667 HWTEST_F(AbilityConnectManagerTest, PrintTimeOutLog_002, TestSize.Level1)
2668 {
2669     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2670     ASSERT_NE(connectManager, nullptr);
2671     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2672     uint32_t msgId = 0;
2673     connectManager->PrintTimeOutLog(abilityRecord, msgId);
2674     connectManager.reset();
2675 }
2676 
2677 /*
2678  * Feature: MissionListManager
2679  * Function: PrintTimeOutLog
2680  * SubFunction: NA
2681  * FunctionPoints: MissionListManager PrintTimeOutLog
2682  * EnvConditions: NA
2683  * CaseDescription: Verify PrintTimeOutLog
2684  */
2685 HWTEST_F(AbilityConnectManagerTest, PrintTimeOutLog_003, TestSize.Level1)
2686 {
2687     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2688     ASSERT_NE(connectManager, nullptr);
2689     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2690     uint32_t msgId = 1;
2691     connectManager->PrintTimeOutLog(abilityRecord, msgId);
2692     connectManager.reset();
2693 }
2694 
2695 /*
2696  * Feature: MissionListManager
2697  * Function: PrintTimeOutLog
2698  * SubFunction: NA
2699  * FunctionPoints: MissionListManager PrintTimeOutLog
2700  * EnvConditions: NA
2701  * CaseDescription: Verify PrintTimeOutLog
2702  */
2703 HWTEST_F(AbilityConnectManagerTest, PrintTimeOutLog_004, TestSize.Level1)
2704 {
2705     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2706     ASSERT_NE(connectManager, nullptr);
2707     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2708     uint32_t msgId = 2;
2709     connectManager->PrintTimeOutLog(abilityRecord, msgId);
2710     connectManager.reset();
2711 }
2712 
2713 /*
2714  * Feature: MissionListManager
2715  * Function: PrintTimeOutLog
2716  * SubFunction: NA
2717  * FunctionPoints: MissionListManager PrintTimeOutLog
2718  * EnvConditions: NA
2719  * CaseDescription: Verify PrintTimeOutLog
2720  */
2721 HWTEST_F(AbilityConnectManagerTest, PrintTimeOutLog_005, TestSize.Level1)
2722 {
2723     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2724     ASSERT_NE(connectManager, nullptr);
2725     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2726     uint32_t msgId = 4;
2727     connectManager->PrintTimeOutLog(abilityRecord, msgId);
2728     connectManager.reset();
2729 }
2730 
2731 /*
2732  * Feature: MissionListManager
2733  * Function: PrintTimeOutLog
2734  * SubFunction: NA
2735  * FunctionPoints: MissionListManager PrintTimeOutLog
2736  * EnvConditions: NA
2737  * CaseDescription: Verify PrintTimeOutLog
2738  */
2739 HWTEST_F(AbilityConnectManagerTest, PrintTimeOutLog_006, TestSize.Level1)
2740 {
2741     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2742     ASSERT_NE(connectManager, nullptr);
2743     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2744     uint32_t msgId = 5;
2745     connectManager->PrintTimeOutLog(abilityRecord, msgId);
2746     connectManager.reset();
2747 }
2748 
2749 /*
2750  * Feature: MissionListManager
2751  * Function: PrintTimeOutLog
2752  * SubFunction: NA
2753  * FunctionPoints: MissionListManager PrintTimeOutLog
2754  * EnvConditions: NA
2755  * CaseDescription: Verify PrintTimeOutLog
2756  */
2757 HWTEST_F(AbilityConnectManagerTest, PrintTimeOutLog_007, TestSize.Level1)
2758 {
2759     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2760     ASSERT_NE(connectManager, nullptr);
2761     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2762     uint32_t msgId = 6;
2763     connectManager->PrintTimeOutLog(abilityRecord, msgId);
2764     connectManager.reset();
2765 }
2766 
2767 /*
2768  * Feature: MissionListManager
2769  * Function: PrintTimeOutLog
2770  * SubFunction: NA
2771  * FunctionPoints: MissionListManager PrintTimeOutLog
2772  * EnvConditions: NA
2773  * CaseDescription: Verify PrintTimeOutLog
2774  */
2775 HWTEST_F(AbilityConnectManagerTest, PrintTimeOutLog_008, TestSize.Level1)
2776 {
2777     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2778     ASSERT_NE(connectManager, nullptr);
2779     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2780     uint32_t msgId = 3;
2781     connectManager->PrintTimeOutLog(abilityRecord, msgId);
2782     connectManager.reset();
2783 }
2784 
2785 /*
2786  * Feature: AbilityConnectManager
2787  * Function: OnAbilityRequestDone
2788  * SubFunction: NA
2789  * FunctionPoints: AbilityConnectManager OnAbilityRequestDone
2790  * EnvConditions: NA
2791  * CaseDescription: Verify OnAbilityRequestDone
2792  * @tc.require: AR000I8B26
2793  */
2794 HWTEST_F(AbilityConnectManagerTest, OnAbilityRequestDone_001, TestSize.Level1)
2795 {
2796     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2797     std::shared_ptr<AbilityRecord> abilityRecord = serviceRecord_;
2798     sptr<IRemoteObject> token = abilityRecord->GetToken();
2799     abilityRecord->abilityInfo_.extensionAbilityType = ExtensionAbilityType::UI;
2800     abilityRecord->SetAbilityState(AbilityState::INACTIVE);
2801     connectManager->serviceMap_.emplace("first", abilityRecord);
2802     connectManager->OnAbilityRequestDone(token, 2);
2803     EXPECT_EQ(abilityRecord->GetAbilityState(), AbilityState::FOREGROUNDING);
2804     connectManager->serviceMap_.erase("first");
2805     abilityRecord->abilityInfo_.extensionAbilityType = ExtensionAbilityType::UNSPECIFIED;
2806     abilityRecord->SetAbilityState(AbilityState::INITIAL);
2807 }
2808 
2809 /*
2810  * Feature: AbilityConnectManager
2811  * Function: ScheduleCommandAbilityWindowDone
2812  * SubFunction: NA
2813  * FunctionPoints: AbilityConnectManager ScheduleCommandAbilityWindowDone
2814  * EnvConditions: NA
2815  * CaseDescription: Verify ScheduleCommandAbilityWindowDone
2816  * @tc.require: AR000I8B26
2817  */
2818 HWTEST_F(AbilityConnectManagerTest, ScheduleCommandAbilityWindowDone_001, TestSize.Level1)
2819 {
2820     ConnectManager()->SetTaskHandler(TaskHandler());
2821     ConnectManager()->SetEventHandler(EventHandler());
2822     auto sessionInfo = MockSessionInfo(0);
2823 
2824     sptr<IRemoteObject> nullToken = nullptr;
2825     auto result = ConnectManager()->ScheduleCommandAbilityWindowDone(
2826         nullToken, sessionInfo, WIN_CMD_FOREGROUND, ABILITY_CMD_FOREGROUND);
2827     EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2828 
2829     std::shared_ptr<AbilityRecord> ability = nullptr;
2830     OHOS::sptr<OHOS::IRemoteObject> token1 = new OHOS::AAFwk::Token(ability);
2831     auto result1 = ConnectManager()->ScheduleCommandAbilityWindowDone(
2832         token1, sessionInfo, WIN_CMD_FOREGROUND, ABILITY_CMD_FOREGROUND);
2833     EXPECT_EQ(result1, OHOS::ERR_INVALID_VALUE);
2834 
2835     sptr<SessionInfo> nullSession = nullptr;
2836     auto result2 = ConnectManager()->ScheduleCommandAbilityWindowDone(
2837         serviceToken_, nullSession, WIN_CMD_FOREGROUND, ABILITY_CMD_FOREGROUND);
2838     EXPECT_EQ(result2, OHOS::ERR_INVALID_VALUE);
2839 
2840     auto result3 = ConnectManager()->ScheduleCommandAbilityWindowDone(
2841         serviceToken_, sessionInfo, WIN_CMD_FOREGROUND, ABILITY_CMD_FOREGROUND);
2842     EXPECT_EQ(result3, OHOS::ERR_OK);
2843 }
2844 
2845 /*
2846  * Feature: AbilityConnectManager
2847  * Function: ForegroundUIExtensionAbility
2848  * SubFunction: NA
2849  * FunctionPoints: MissionListManager ForegroundUIExtensionAbility
2850  * EnvConditions: NA
2851  * CaseDescription: Verify ForegroundUIExtensionAbility
2852  * @tc.require: AR000I8B26
2853  */
2854 HWTEST_F(AbilityConnectManagerTest, MoveToForeground_001, TestSize.Level1)
2855 {
2856     serviceRecord_->ForegroundUIExtensionAbility();
2857     EXPECT_EQ(serviceRecord_->GetAbilityState(), AbilityState::FOREGROUNDING);
2858     serviceRecord_->SetAbilityState(AbilityState::INITIAL);
2859 }
2860 
2861 /*
2862  * Feature: AbilityConnectManager
2863  * Function: DispatchForeground
2864  * SubFunction:
2865  * FunctionPoints: DispatchForeground
2866  * EnvConditions:NA
2867  * CaseDescription: Verify the DispatchForeground process
2868  * @tc.require: AR000I8B26
2869  */
2870 HWTEST_F(AbilityConnectManagerTest, DispatchForeground_001, TestSize.Level1)
2871 {
2872     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2873     ASSERT_NE(connectManager, nullptr);
2874     std::shared_ptr<AbilityRecord> ability = nullptr;
2875     auto result = connectManager->DispatchForeground(ability);
2876     EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2877 
2878     result = connectManager->DispatchForeground(serviceRecord_);
2879     EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2880 
2881     connectManager->SetTaskHandler(TaskHandler());
2882     connectManager->SetEventHandler(EventHandler());
2883     result = connectManager->DispatchForeground(serviceRecord_);
2884     EXPECT_EQ(result, OHOS::ERR_OK);
2885 }
2886 
2887 /*
2888  * Feature: AbilityConnectManager
2889  * Function: DispatchBackground
2890  * SubFunction:
2891  * FunctionPoints: DispatchBackground
2892  * EnvConditions:NA
2893  * CaseDescription: Verify the DispatchBackground process
2894  * @tc.require: AR000I8B26
2895  */
2896 HWTEST_F(AbilityConnectManagerTest, DispatchBackground_001, TestSize.Level1)
2897 {
2898     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2899     ASSERT_NE(connectManager, nullptr);
2900     std::shared_ptr<AbilityRecord> ability = nullptr;
2901     auto result = connectManager->DispatchBackground(ability);
2902     EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2903 
2904     result = connectManager->DispatchBackground(serviceRecord_);
2905     EXPECT_EQ(result, OHOS::ERR_INVALID_VALUE);
2906 
2907     connectManager->SetTaskHandler(TaskHandler());
2908     connectManager->SetEventHandler(EventHandler());
2909     result = connectManager->DispatchBackground(serviceRecord_);
2910     EXPECT_EQ(result, OHOS::ERR_OK);
2911 }
2912 
2913 /*
2914  * Feature: AbilityConnectManager
2915  * Function: HandleCommandWindowTimeoutTask
2916  * SubFunction: HandleCommandWindowTimeoutTask
2917  * FunctionPoints: NA
2918  * EnvConditions: NA
2919  * CaseDescription: Verify AbilityConnectManager HandleCommandWindowTimeoutTask
2920  * @tc.require: AR000I8B26
2921  */
2922 HWTEST_F(AbilityConnectManagerTest, HandleCommandWindowTimeoutTask_001, TestSize.Level1)
2923 {
2924     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2925     ASSERT_NE(connectManager, nullptr);
2926     connectManager->HandleCommandWindowTimeoutTask(serviceRecord_, MockSessionInfo(0), WIN_CMD_FOREGROUND);
2927 }
2928 
2929 /*
2930  * Feature: AbilityConnectManager
2931  * Function: CommandAbilityWindow
2932  * SubFunction: CommandAbilityWindow
2933  * FunctionPoints: NA
2934  * EnvConditions: NA
2935  * CaseDescription: Verify AbilityConnectManager CommandAbilityWindow
2936  * @tc.require: AR000I8B26
2937  */
2938 HWTEST_F(AbilityConnectManagerTest, CommandAbilityWindow_001, TestSize.Level1)
2939 {
2940     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
2941     ASSERT_NE(connectManager, nullptr);
2942     connectManager->SetTaskHandler(TaskHandler());
2943     connectManager->SetEventHandler(EventHandler());
2944     connectManager->CommandAbilityWindow(serviceRecord_, MockSessionInfo(0), WIN_CMD_FOREGROUND);
2945 }
2946 
2947 /*
2948  * Feature: AbilityConnectManager
2949  * Function: CompleteForeground
2950  * SubFunction: CompleteForeground
2951  * FunctionPoints: NA
2952  * EnvConditions: NA
2953  * CaseDescription: Verify AbilityConnectManager CompleteForeground
2954  * @tc.require: AR000I8B26
2955  */
2956 HWTEST_F(AbilityConnectManagerTest, CompleteForeground_001, TestSize.Level1)
2957 {
2958     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
2959     ASSERT_NE(connectManager, nullptr);
2960     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
2961     abilityRecord->currentState_ = AbilityState::BACKGROUND;
2962     connectManager->CompleteForeground(abilityRecord);
2963     EXPECT_EQ(abilityRecord->GetAbilityState(), AbilityState::BACKGROUND);
2964 
2965     abilityRecord->currentState_ = AbilityState::FOREGROUNDING;
2966     connectManager->CompleteForeground(abilityRecord);
2967     EXPECT_EQ(abilityRecord->GetAbilityState(), AbilityState::FOREGROUND);
2968     connectManager.reset();
2969 }
2970 
2971 /*
2972  * Feature: AbilityConnectManager
2973  * Function: AddUIExtWindowDeathRecipient
2974  * SubFunction: AddUIExtWindowDeathRecipient
2975  * FunctionPoints: NA
2976  * EnvConditions: NA
2977  * CaseDescription: Verify AbilityConnectManager AddUIExtWindowDeathRecipient
2978  * @tc.require: AR000I8B26
2979  */
2980 HWTEST_F(AbilityConnectManagerTest, AddUIExtWindowDeathRecipient_001, TestSize.Level1)
2981 {
2982     ConnectManager()->SetTaskHandler(TaskHandler());
2983     ConnectManager()->SetEventHandler(EventHandler());
2984     ConnectManager()->uiExtRecipientMap_.clear();
2985 
2986     ConnectManager()->AddUIExtWindowDeathRecipient(nullptr);
2987     EXPECT_TRUE(ConnectManager()->uiExtRecipientMap_.empty());
2988 
2989     ConnectManager()->AddUIExtWindowDeathRecipient(callbackA_->AsObject());
2990     EXPECT_EQ(static_cast<int>(ConnectManager()->uiExtRecipientMap_.size()), 1);
2991 
2992     // Add twice, do not add repeatedly
2993     ConnectManager()->AddUIExtWindowDeathRecipient(callbackA_->AsObject());
2994     EXPECT_EQ(static_cast<int>(ConnectManager()->uiExtRecipientMap_.size()), 1);
2995     ConnectManager()->uiExtRecipientMap_.clear();
2996 }
2997 
2998 /*
2999  * Feature: AbilityConnectManager
3000  * Function: RemoveUIExtWindowDeathRecipient
3001  * SubFunction:
3002  * FunctionPoints: RemoveUIExtWindowDeathRecipient
3003  * EnvConditions:NA
3004  * CaseDescription: Verify the RemoveUIExtWindowDeathRecipient process
3005  * @tc.require: AR000I8B26
3006  */
3007 HWTEST_F(AbilityConnectManagerTest, RemoveUIExtWindowDeathRecipient_001, TestSize.Level1)
3008 {
3009     ConnectManager()->SetTaskHandler(TaskHandler());
3010     ConnectManager()->SetEventHandler(EventHandler());
3011     ConnectManager()->uiExtRecipientMap_.clear();
3012 
3013     ConnectManager()->AddUIExtWindowDeathRecipient(callbackA_->AsObject());
3014     EXPECT_EQ(static_cast<int>(ConnectManager()->uiExtRecipientMap_.size()), 1);
3015 
3016     ConnectManager()->RemoveUIExtWindowDeathRecipient(nullptr);
3017     EXPECT_FALSE(ConnectManager()->uiExtRecipientMap_.empty());
3018 
3019     ConnectManager()->RemoveUIExtWindowDeathRecipient(callbackA_->AsObject());
3020     EXPECT_TRUE(ConnectManager()->uiExtRecipientMap_.empty());
3021 }
3022 
3023 /*
3024  * Feature: AbilityConnectManager
3025  * Function: OnUIExtWindowDied
3026  * SubFunction:
3027  * FunctionPoints: OnUIExtWindowDied
3028  * EnvConditions:NA
3029  * CaseDescription: Verify the OnUIExtWindowDied process
3030  * @tc.require: AR000I8B26
3031  */
3032 HWTEST_F(AbilityConnectManagerTest, OnUIExtWindowDied_001, TestSize.Level1)
3033 {
3034     ConnectManager()->SetTaskHandler(TaskHandler());
3035     ConnectManager()->SetEventHandler(EventHandler());
3036     ConnectManager()->uiExtRecipientMap_.clear();
3037     ConnectManager()->uiExtensionMap_.clear();
3038 
3039     ConnectManager()->uiExtensionMap_.emplace(
3040         callbackA_->AsObject(), AbilityConnectManager::UIExtWindowMapValType(serviceRecord_, MockSessionInfo(0)));
3041     ConnectManager()->AddUIExtWindowDeathRecipient(callbackA_->AsObject());
3042     ConnectManager()->OnUIExtWindowDied(nullptr);
3043     EXPECT_EQ(static_cast<int>(ConnectManager()->uiExtRecipientMap_.size()), 1);
3044     EXPECT_EQ(static_cast<int>(ConnectManager()->uiExtensionMap_.size()), 1);
3045 }
3046 
3047 /*
3048  * Feature: AbilityConnectManager
3049  * Function: HandleUIExtWindowDiedTask
3050  * SubFunction: HandleUIExtWindowDiedTask
3051  * FunctionPoints: NA
3052  * EnvConditions: NA
3053  * CaseDescription: Verify AbilityConnectManager HandleUIExtWindowDiedTask
3054  * @tc.require: AR000I8B26
3055  */
3056 HWTEST_F(AbilityConnectManagerTest, HandleUIExtWindowDiedTask_001, TestSize.Level1)
3057 {
3058     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
3059     ASSERT_NE(connectManager, nullptr);
3060     connectManager->uiExtRecipientMap_.clear();
3061     connectManager->uiExtensionMap_.clear();
3062 
3063     connectManager->uiExtensionMap_.emplace(
3064         callbackA_->AsObject(), AbilityConnectManager::UIExtWindowMapValType(serviceRecord_, MockSessionInfo(0)));
3065     connectManager->AddUIExtWindowDeathRecipient(callbackA_->AsObject());
3066     connectManager->HandleUIExtWindowDiedTask(nullptr);
3067     EXPECT_EQ(static_cast<int>(connectManager->uiExtRecipientMap_.size()), 1);
3068     EXPECT_EQ(static_cast<int>(connectManager->uiExtensionMap_.size()), 1);
3069 
3070     connectManager->HandleUIExtWindowDiedTask(callbackA_->AsObject());
3071     EXPECT_TRUE(connectManager->uiExtRecipientMap_.empty());
3072     EXPECT_TRUE(connectManager->uiExtensionMap_.empty());
3073 }
3074 
3075 /*
3076  * Feature: AbilityConnectManager
3077  * Function: IsUIExtensionFocused
3078  * SubFunction: IsUIExtensionFocused
3079  * FunctionPoints: NA
3080  * EnvConditions: NA
3081  * CaseDescription: Verify AbilityConnectManager IsUIExtensionFocused
3082  */
3083 HWTEST_F(AbilityConnectManagerTest, IsUIExtensionFocused_001, TestSize.Level1)
3084 {
3085     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
3086     ASSERT_NE(connectManager, nullptr);
3087     connectManager->uiExtensionMap_.clear();
3088     bool isFocused = connectManager->IsUIExtensionFocused(
3089         serviceRecord_->GetApplicationInfo().accessTokenId, serviceRecord1_->GetToken());
3090     EXPECT_EQ(isFocused, false);
3091     connectManager.reset();
3092 }
3093 
3094 /*
3095  * Feature: AbilityConnectManager
3096  * Function: IsUIExtensionFocused
3097  * SubFunction: IsUIExtensionFocused
3098  * FunctionPoints: NA
3099  * EnvConditions: NA
3100  * CaseDescription: Verify AbilityConnectManager IsUIExtensionFocused
3101  */
3102 HWTEST_F(AbilityConnectManagerTest, IsUIExtensionFocused_002, TestSize.Level1)
3103 {
3104     AAFwk::IsMockSaCall::IsMockSaCallWithPermission();
3105     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(3);
3106     ASSERT_NE(connectManager, nullptr);
3107     connectManager->uiExtensionMap_.clear();
3108 
3109     std::string device = "device";
3110     std::string abilityName = "uiExtensionUserAbility";
3111     std::string appName = "uiExtensionUser";
3112     std::string bundleName = "com.ix.uiExtensionUser";
3113     std::string moduleName = "entry";
3114     auto request = GenerateAbilityRequest(device, abilityName, appName, bundleName, moduleName);
3115     auto uiExtensionUser = AbilityRecord::CreateAbilityRecord(request);
3116     EXPECT_NE(uiExtensionUser, nullptr);
3117 
3118     std::string abilityName1 = "uiExtensionAbility1";
3119     std::string appName1 = "uiExtensionProvider1";
3120     std::string bundleName1 = "com.ix.uiExtensionProvider1";
3121     std::string moduleName1 = "entry";
3122     auto request1 = GenerateAbilityRequest(device, abilityName1, appName1, bundleName1, moduleName1);
3123     auto uiExtension1 = AbilityRecord::CreateAbilityRecord(request1);
3124     EXPECT_NE(uiExtension1, nullptr);
3125     uiExtension1->abilityInfo_.extensionAbilityType = ExtensionAbilityType::SYS_COMMON_UI;
3126     sptr<SessionInfo> sessionInfo1 = new (std::nothrow) SessionInfo();
3127     sessionInfo1->callerToken = uiExtensionUser->GetToken();
3128     uiExtension1->sessionInfo_ = sessionInfo1;
3129     connectManager->uiExtensionMap_.emplace(
3130         callbackA_->AsObject(), AbilityConnectManager::UIExtWindowMapValType(uiExtension1, sessionInfo1));
3131     bool isFocused1 = connectManager->IsUIExtensionFocused(
3132         uiExtension1->GetApplicationInfo().accessTokenId, uiExtensionUser->GetToken());
3133     EXPECT_EQ(isFocused1, true);
3134     std::string abilityName2 = "uiExtensionAbility2";
3135     std::string appName2 = "uiExtensionProvider2";
3136     std::string bundleName2 = "com.ix.uiExtensionProvider2";
3137     std::string moduleName2 = "entry";
3138     auto request2 = GenerateAbilityRequest(device, abilityName2, appName2, bundleName2, moduleName2);
3139     auto uiExtension2 = AbilityRecord::CreateAbilityRecord(request2);
3140     EXPECT_NE(uiExtension2, nullptr);
3141     uiExtension2->abilityInfo_.extensionAbilityType = ExtensionAbilityType::SYS_COMMON_UI;
3142     sptr<SessionInfo> sessionInfo2 = new (std::nothrow) SessionInfo();
3143     sessionInfo2->callerToken = uiExtension1->GetToken();
3144     uiExtension2->sessionInfo_ = sessionInfo2;
3145     connectManager->uiExtensionMap_.emplace(
3146         callbackA_->AsObject(), AbilityConnectManager::UIExtWindowMapValType(uiExtension2, sessionInfo2));
3147     bool isFocused2 = connectManager->IsUIExtensionFocused(
3148         uiExtension2->GetApplicationInfo().accessTokenId, uiExtensionUser->GetToken());
3149     EXPECT_EQ(isFocused2, true);
3150     connectManager.reset();
3151 }
3152 
3153 /*
3154  * Feature: AbilityConnectManager
3155  * Function: PauseExtensions
3156  * SubFunction: PauseExtensions
3157  * FunctionPoints: NA
3158  * EnvConditions: NA
3159  * CaseDescription: Verify AbilityConnectManager PauseExtensions
3160  */
3161 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_PauseExtensions_001, TestSize.Level1)
3162 {
3163     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
3164     ASSERT_NE(connectManager, nullptr);
3165     std::shared_ptr<AbilityRecord> abilityRecord1 = serviceRecord_;
3166     abilityRecord1->abilityInfo_.type = AbilityType::PAGE;
3167     connectManager->serviceMap_.emplace("first", abilityRecord1);
3168     std::shared_ptr<AbilityRecord> abilityRecord2 = AbilityRecord::CreateAbilityRecord(abilityRequest_);
3169     abilityRecord2->abilityInfo_.type = AbilityType::EXTENSION;
3170     abilityRecord2->abilityInfo_.name = AbilityConfig::LAUNCHER_ABILITY_NAME;
3171     abilityRecord2->abilityInfo_.bundleName = AbilityConfig::LAUNCHER_BUNDLE_NAME;
3172     connectManager->serviceMap_.emplace("second", abilityRecord2);
3173     connectManager->PauseExtensions();
3174 }
3175 
3176 /*
3177  * Feature: AbilityConnectManager
3178  * Function: SignRestartAppFlag
3179  * CaseDescription: Verify AbilityConnectManager SignRestartAppFlag
3180  */
3181 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_SignRestartAppFlag_001, TestSize.Level1)
3182 {
3183     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
3184     ASSERT_NE(connectManager, nullptr);
3185 
3186     std::string bundleName = "testBundleName";
3187     std::shared_ptr<AbilityRecord> abilityRecord1 = serviceRecord_;
3188     abilityRecord1->abilityInfo_.bundleName = bundleName;
3189     connectManager->serviceMap_.emplace("first", abilityRecord1);
3190     std::shared_ptr<AbilityRecord> abilityRecord2 = AbilityRecord::CreateAbilityRecord(abilityRequest_);
3191     abilityRecord2->abilityInfo_.bundleName = "errTestBundleName";
3192     connectManager->serviceMap_.emplace("second", abilityRecord2);
3193     int32_t uid = 100;
3194     connectManager->SignRestartAppFlag(uid);
3195 }
3196 
3197 /*
3198  * Feature: AbilityConnectManager
3199  * Function: BuildEventInfo
3200  * CaseDescription: Verify AbilityConnectManager BuildEventInfo
3201  */
3202 HWTEST_F(AbilityConnectManagerTest, AAFwk_AbilityMS_BuildEventInfo_001, TestSize.Level1)
3203 {
3204     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
3205     ASSERT_NE(connectManager, nullptr);
3206 
3207     connectManager->BuildEventInfo(nullptr);
3208     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
3209     connectManager->BuildEventInfo(abilityRecord);
3210     abilityRecord->SetCreateByConnectMode(true);
3211     connectManager->BuildEventInfo(abilityRecord);
3212 }
3213 
3214 /**
3215  * @tc.name: UpdateUIExtensionInfo_0100
3216  * @tc.desc: Update want params of ui extension.
3217  * @tc.type: FUNC
3218  */
3219 HWTEST_F(AbilityConnectManagerTest, UpdateUIExtensionInfo_0100, TestSize.Level1)
3220 {
3221     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
3222     ASSERT_NE(connectManager, nullptr);
3223 
3224     Want want;
3225     AppExecFwk::AbilityInfo abilityInfo;
3226     abilityInfo.extensionAbilityType = ExtensionAbilityType::SYS_COMMON_UI;
3227     AppExecFwk::ApplicationInfo applicationInfo;
3228     auto abilityRecord = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
3229     abilityRecord->SetUIExtensionAbilityId(1000);
3230     connectManager->UpdateUIExtensionInfo(abilityRecord);
3231     EXPECT_EQ(abilityRecord->GetWant().HasParameter("ability.want.params.uiExtensionAbilityId"), true);
3232     EXPECT_EQ(abilityRecord->GetWant().GetIntParam("ability.want.params.uiExtensionAbilityId", -1), 1000);
3233 }
3234 
3235 /**
3236  * @tc.name: PreloadUIExtensionAbilityLocked_0100
3237  * @tc.desc: preload uiextension ability
3238  * @tc.type: FUNC
3239  */
3240 HWTEST_F(AbilityConnectManagerTest, PreloadUIExtensionAbilityLocked_0100, TestSize.Level1)
3241 {
3242     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
3243     ASSERT_NE(connectManager, nullptr);
3244 
3245     AbilityRequest abilityRequest;
3246     AppExecFwk::ElementName providerElement("0", "com.ohos.uiextensionprovider", "UIExtensionProvider", "entry");
3247     abilityRequest.want.SetElement(providerElement);
3248     abilityRequest.abilityInfo.type = AbilityType::EXTENSION;
3249     std::string hostBundleName = "com.ohos.uiextensionuser";
3250     auto ret = connectManager->PreloadUIExtensionAbilityLocked(abilityRequest, hostBundleName);
3251     EXPECT_NE(ret, ERR_OK);
3252 }
3253 
3254 /**
3255  * @tc.name: UnloadUIExtensionAbility_0100
3256  * @tc.desc: UnloadUIExtensionAbility
3257  * @tc.type: FUNC
3258  */
3259 HWTEST_F(AbilityConnectManagerTest, UnloadUIExtensionAbility_0100, TestSize.Level1)
3260 {
3261     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
3262     ASSERT_NE(connectManager, nullptr);
3263 
3264     AbilityRequest abilityRequest;
3265     AppExecFwk::ElementName providerElement("0", "com.ohos.uiextensionprovider", "UIExtensionProvider", "entry");
3266     abilityRequest.want.SetElement(providerElement);
3267     std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
3268     std::string hostBundleName = "com.ohos.uiextensionuser";
3269     auto ret = connectManager->UnloadUIExtensionAbility(abilityRecord, hostBundleName);
3270     EXPECT_EQ(ret, ERR_INVALID_VALUE);
3271 }
3272 
3273 /**
3274  * @tc.name: UpdateKeepAliveEnableState_0100
3275  * @tc.desc: UpdateKeepAliveEnableState
3276  * @tc.type: FUNC
3277  */
3278 HWTEST_F(AbilityConnectManagerTest, UpdateKeepAliveEnableState_0100, TestSize.Level1)
3279 {
3280     std::shared_ptr<AbilityConnectManager> connectManager = std::make_shared<AbilityConnectManager>(0);
3281     ASSERT_NE(connectManager, nullptr);
3282 
3283     auto ret = connectManager->UpdateKeepAliveEnableState("bundle", "entry", "mainAbility", true);
3284     EXPECT_EQ(ret, ERR_OK);
3285 }
3286 }  // namespace AAFwk
3287 }  // namespace OHOS
3288