1 /*
2  * Copyright (c) 2022 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 #define private public
18 #include "connection_state_manager.h"
19 #undef private
20 #include "ability_connection.h"
21 #include "ability_record.h"
22 #include "connection_observer_errors.h"
23 #include "data_ability_record.h"
24 #ifdef WITH_DLP
25 #include "dlp_state_item.h"
26 #endif // WITH_DLP
27 
28 using namespace testing::ext;
29 using namespace OHOS::AbilityRuntime;
30 using namespace OHOS::AppExecFwk;
31 
32 namespace OHOS {
33 namespace AAFwk {
34 class ConnectionStateManagerTest : public testing::Test {
35 public:
36     static void SetUpTestCase(void);
37     static void TearDownTestCase(void);
38     void SetUp();
39     void TearDown();
40     std::shared_ptr<ConnectionStateManager> manager_ {nullptr};
41     std::shared_ptr<AbilityRecord> abilityRecord_ {nullptr};
42     std::shared_ptr<DataAbilityRecord> dataAbilityRecord_ {nullptr};
43     sptr<IAbilityConnection> callback_ {nullptr};
44 
45     class AbilityConnectionMock : public IAbilityConnection {
46     public:
47         AbilityConnectionMock() = default;
48         virtual ~AbilityConnectionMock() = default;
OnAbilityConnectDone(const AppExecFwk::ElementName & element,const sptr<IRemoteObject> & remoteObject,int resultCode)49         void OnAbilityConnectDone(
50             const AppExecFwk::ElementName& element, const sptr<IRemoteObject>& remoteObject, int resultCode) override
51         {}
OnAbilityDisconnectDone(const AppExecFwk::ElementName & element,int resultCode)52         void OnAbilityDisconnectDone(const AppExecFwk::ElementName& element, int resultCode) override
53         {}
AsObject()54         sptr<IRemoteObject> AsObject() override
55         {
56             return {};
57         }
58     };
59 };
60 
SetUpTestCase(void)61 void ConnectionStateManagerTest::SetUpTestCase(void)
62 {}
TearDownTestCase(void)63 void ConnectionStateManagerTest::TearDownTestCase(void)
64 {}
TearDown(void)65 void ConnectionStateManagerTest::TearDown(void)
66 {}
SetUp()67 void ConnectionStateManagerTest::SetUp()
68 {
69     Want want;
70     AbilityInfo abilityInfo;
71     ApplicationInfo applicationInfo;
72     AbilityRequest abilityRequest;
73     abilityRecord_ = std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
74     dataAbilityRecord_ = std::make_shared<DataAbilityRecord>(abilityRequest);
75     manager_ = std::make_shared<ConnectionStateManager>();
76     callback_ = new AbilityConnectionMock();
77 }
78 
79 /*
80  * Feature: ConnectionStateManager
81  * Function: RegisterObserver
82  * SubFunction: NA
83  * FunctionPoints: ConnectionStateManager RegisterObserver
84  * EnvConditions: NA
85  * CaseDescription: Verify RegisterObserver
86  */
87 HWTEST_F(ConnectionStateManagerTest, RegisterObserver_001, TestSize.Level1)
88 {
89     sptr<IConnectionObserver> observer = nullptr;
90     int res = manager_->RegisterObserver(observer);
91     EXPECT_EQ(res, ERR_SERVICE_NOT_INIT);
92 }
93 
94 /*
95  * Feature: ConnectionStateManager
96  * Function: RegisterObserver
97  * SubFunction: NA
98  * FunctionPoints: ConnectionStateManager RegisterObserver
99  * EnvConditions: NA
100  * CaseDescription: Verify RegisterObserver
101  */
102 HWTEST_F(ConnectionStateManagerTest, RegisterObserver_002, TestSize.Level1)
103 {
104     sptr<IConnectionObserver> observer = nullptr;
105     manager_->Init();
106     int res = manager_->RegisterObserver(observer);
107     EXPECT_EQ(res, ERR_INVALID_OBSERVER);
108 }
109 
110 /*
111  * Feature: ConnectionStateManager
112  * Function: UnregisterObserver
113  * SubFunction: NA
114  * FunctionPoints: ConnectionStateManager UnregisterObserver
115  * EnvConditions: NA
116  * CaseDescription: Verify UnregisterObserver
117  */
118 HWTEST_F(ConnectionStateManagerTest, UnregisterObserver_001, TestSize.Level1)
119 {
120     sptr<IConnectionObserver> observer = nullptr;
121     int res = manager_->UnregisterObserver(observer);
122     EXPECT_EQ(res, ERR_SERVICE_NOT_INIT);
123 }
124 
125 /*
126  * Feature: ConnectionStateManager
127  * Function: UnregisterObserver
128  * SubFunction: NA
129  * FunctionPoints: ConnectionStateManager UnregisterObserver
130  * EnvConditions: NA
131  * CaseDescription: Verify UnregisterObserver
132  */
133 HWTEST_F(ConnectionStateManagerTest, UnregisterObserver_002, TestSize.Level1)
134 {
135     sptr<IConnectionObserver> observer = nullptr;
136     manager_->Init();
137     int res = manager_->UnregisterObserver(observer);
138     EXPECT_EQ(res, 0);
139 }
140 
141 /*
142  * Feature: ConnectionStateManager
143  * Function: AddConnection
144  * SubFunction: NA
145  * FunctionPoints: ConnectionStateManager AddConnection
146  * EnvConditions: NA
147  * CaseDescription: Verify AddConnection
148  */
149 HWTEST_F(ConnectionStateManagerTest, AddConnection_001, TestSize.Level1)
150 {
151     std::shared_ptr<ConnectionRecord> connectionRecord = nullptr;
152     manager_->Init();
153     manager_->AddConnection(connectionRecord);
154 }
155 
156 /*
157  * Feature: ConnectionStateManager
158  * Function: AddConnection
159  * SubFunction: NA
160  * FunctionPoints: ConnectionStateManager AddConnection
161  * EnvConditions: NA
162  * CaseDescription: Verify AddConnection
163  */
164 HWTEST_F(ConnectionStateManagerTest, AddConnection_002, TestSize.Level1)
165 {
166     auto connectionRecord =
167         ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_);
168     manager_->Init();
169     manager_->AddConnection(connectionRecord);
170 }
171 
172 /*
173  * Feature: ConnectionStateManager
174  * Function: RemoveConnection
175  * SubFunction: NA
176  * FunctionPoints: ConnectionStateManager RemoveConnection
177  * EnvConditions: NA
178  * CaseDescription: Verify RemoveConnection
179  */
180 HWTEST_F(ConnectionStateManagerTest, RemoveConnection_001, TestSize.Level1)
181 {
182     std::shared_ptr<ConnectionRecord> connectionRecord = nullptr;
183     bool isCallerDied = false;
184     manager_->RemoveConnection(connectionRecord, isCallerDied);
185 }
186 
187 /*
188  * Feature: ConnectionStateManager
189  * Function: RemoveConnection
190  * SubFunction: NA
191  * FunctionPoints: ConnectionStateManager RemoveConnection
192  * EnvConditions: NA
193  * CaseDescription: Verify RemoveConnection
194  */
195 HWTEST_F(ConnectionStateManagerTest, RemoveConnection_002, TestSize.Level1)
196 {
197     std::shared_ptr<ConnectionRecord> connectionRecord = nullptr;
198     bool isCallerDied = false;
199     manager_->Init();
200     manager_->RemoveConnection(connectionRecord, isCallerDied);
201 }
202 
203 /*
204  * Feature: ConnectionStateManager
205  * Function: RemoveConnection
206  * SubFunction: NA
207  * FunctionPoints: ConnectionStateManager RemoveConnection
208  * EnvConditions: NA
209  * CaseDescription: Verify RemoveConnection
210  */
211 HWTEST_F(ConnectionStateManagerTest, RemoveConnection_003, TestSize.Level1)
212 {
213     auto connectionRecord =
214         ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_);
215     bool isCallerDied = true;
216     manager_->Init();
217     manager_->RemoveConnection(connectionRecord, isCallerDied);
218 }
219 
220 /*
221  * Feature: ConnectionStateManager
222  * Function: RemoveConnection
223  * SubFunction: NA
224  * FunctionPoints: ConnectionStateManager RemoveConnection
225  * EnvConditions: NA
226  * CaseDescription: Verify RemoveConnection
227  */
228 HWTEST_F(ConnectionStateManagerTest, RemoveConnection_004, TestSize.Level1)
229 {
230     auto connectionRecord =
231         ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_);
232     bool isCallerDied = false;
233     manager_->Init();
234     manager_->RemoveConnection(connectionRecord, isCallerDied);
235 }
236 
237 /*
238  * Feature: ConnectionStateManager
239  * Function: AddDataAbilityConnection
240  * SubFunction: NA
241  * FunctionPoints: ConnectionStateManager AddDataAbilityConnection
242  * EnvConditions: NA
243  * CaseDescription: Verify AddDataAbilityConnection
244  */
245 HWTEST_F(ConnectionStateManagerTest, AddDataAbilityConnection_001, TestSize.Level1)
246 {
247     DataAbilityCaller caller;
248     caller.callerPid = 1;
249     manager_->Init();
250     manager_->AddDataAbilityConnection(caller, dataAbilityRecord_);
251 }
252 
253 /*
254  * Feature: ConnectionStateManager
255  * Function: RemoveDataAbilityConnection
256  * SubFunction: NA
257  * FunctionPoints: ConnectionStateManager RemoveDataAbilityConnection
258  * EnvConditions: NA
259  * CaseDescription: Verify RemoveDataAbilityConnection
260  */
261 HWTEST_F(ConnectionStateManagerTest, RemoveDataAbilityConnection_001, TestSize.Level1)
262 {
263     DataAbilityCaller caller;
264     caller.callerPid = 1;
265     manager_->Init();
266     manager_->RemoveDataAbilityConnection(caller, dataAbilityRecord_);
267 }
268 
269 /*
270  * Feature: ConnectionStateManager
271  * Function: CheckDataAbilityConnectionParams
272  * SubFunction: NA
273  * FunctionPoints: ConnectionStateManager CheckDataAbilityConnectionParams
274  * EnvConditions: NA
275  * CaseDescription: Verify CheckDataAbilityConnectionParams
276  */
277 HWTEST_F(ConnectionStateManagerTest, CheckDataAbilityConnectionParams_001, TestSize.Level1)
278 {
279     DataAbilityCaller caller;
280     bool res = manager_->CheckDataAbilityConnectionParams(caller, dataAbilityRecord_);
281     EXPECT_FALSE(res);
282 }
283 
284 /*
285  * Feature: ConnectionStateManager
286  * Function: CheckDataAbilityConnectionParams
287  * SubFunction: NA
288  * FunctionPoints: ConnectionStateManager CheckDataAbilityConnectionParams
289  * EnvConditions: NA
290  * CaseDescription: Verify CheckDataAbilityConnectionParams
291  */
292 HWTEST_F(ConnectionStateManagerTest, CheckDataAbilityConnectionParams_002, TestSize.Level1)
293 {
294     DataAbilityCaller caller;
295     std::shared_ptr<DataAbilityRecord> dataAbilityRecord = nullptr;
296     manager_->Init();
297     bool res = manager_->CheckDataAbilityConnectionParams(caller, dataAbilityRecord);
298     EXPECT_FALSE(res);
299 }
300 
301 /*
302  * Feature: ConnectionStateManager
303  * Function: CheckDataAbilityConnectionParams
304  * SubFunction: NA
305  * FunctionPoints: ConnectionStateManager CheckDataAbilityConnectionParams
306  * EnvConditions: NA
307  * CaseDescription: Verify CheckDataAbilityConnectionParams
308  */
309 HWTEST_F(ConnectionStateManagerTest, CheckDataAbilityConnectionParams_003, TestSize.Level1)
310 {
311     DataAbilityCaller caller;
312     caller.callerPid = 0;
313     manager_->Init();
314     bool res = manager_->CheckDataAbilityConnectionParams(caller, dataAbilityRecord_);
315     EXPECT_FALSE(res);
316 }
317 
318 /*
319  * Feature: ConnectionStateManager
320  * Function: CheckDataAbilityConnectionParams
321  * SubFunction: NA
322  * FunctionPoints: ConnectionStateManager CheckDataAbilityConnectionParams
323  * EnvConditions: NA
324  * CaseDescription: Verify CheckDataAbilityConnectionParams
325  */
326 HWTEST_F(ConnectionStateManagerTest, CheckDataAbilityConnectionParams_004, TestSize.Level1)
327 {
328     DataAbilityCaller caller;
329     caller.callerPid = 1;
330     manager_->Init();
331     bool res = manager_->CheckDataAbilityConnectionParams(caller, dataAbilityRecord_);
332     EXPECT_TRUE(res);
333 }
334 
335 /*
336  * Feature: ConnectionStateManager
337  * Function: HandleDataAbilityDied
338  * SubFunction: NA
339  * FunctionPoints: ConnectionStateManager HandleDataAbilityDied
340  * EnvConditions: NA
341  * CaseDescription: Verify HandleDataAbilityDied
342  */
343 HWTEST_F(ConnectionStateManagerTest, HandleDataAbilityDied_001, TestSize.Level1)
344 {
345     std::shared_ptr<DataAbilityRecord> dataAbilityRecord = nullptr;
346     manager_->Init();
347     manager_->HandleDataAbilityDied(dataAbilityRecord);
348 }
349 
350 /*
351  * Feature: ConnectionStateManager
352  * Function: HandleDataAbilityDied
353  * SubFunction: NA
354  * FunctionPoints: ConnectionStateManager HandleDataAbilityDied
355  * EnvConditions: NA
356  * CaseDescription: Verify HandleDataAbilityDied
357  */
358 HWTEST_F(ConnectionStateManagerTest, HandleDataAbilityDied_002, TestSize.Level1)
359 {
360     AbilityRequest abilityRequest;
361     std::shared_ptr<DataAbilityRecord> dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
362     dataAbilityRecord->ability_ = nullptr;
363     manager_->Init();
364     manager_->HandleDataAbilityDied(dataAbilityRecord);
365 }
366 
367 /*
368  * Feature: ConnectionStateManager
369  * Function: HandleDataAbilityDied
370  * SubFunction: NA
371  * FunctionPoints: ConnectionStateManager HandleDataAbilityDied
372  * EnvConditions: NA
373  * CaseDescription: Verify HandleDataAbilityDied
374  */
375 HWTEST_F(ConnectionStateManagerTest, HandleDataAbilityDied_003, TestSize.Level1)
376 {
377     AbilityRequest abilityRequest;
378     std::shared_ptr<DataAbilityRecord> dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
379     dataAbilityRecord->ability_ = abilityRecord_;
380     manager_->Init();
381     manager_->HandleDataAbilityDied(dataAbilityRecord);
382 }
383 
384 /*
385  * Feature: ConnectionStateManager
386  * Function: HandleDataAbilityCallerDied
387  * SubFunction: NA
388  * FunctionPoints: ConnectionStateManager HandleDataAbilityCallerDied
389  * EnvConditions: NA
390  * CaseDescription: Verify HandleDataAbilityCallerDied
391  */
392 HWTEST_F(ConnectionStateManagerTest, HandleDataAbilityCallerDied_001, TestSize.Level1)
393 {
394     EXPECT_NE(manager_, nullptr);
395     int32_t callerPid = 0;
396     manager_->HandleDataAbilityCallerDied(callerPid);
397 }
398 
399 /*
400  * Feature: ConnectionStateManager
401  * Function: HandleDataAbilityCallerDied
402  * SubFunction: NA
403  * FunctionPoints: ConnectionStateManager HandleDataAbilityCallerDied
404  * EnvConditions: NA
405  * CaseDescription: Verify HandleDataAbilityCallerDied
406  */
407 HWTEST_F(ConnectionStateManagerTest, HandleDataAbilityCallerDied_002, TestSize.Level1)
408 {
409     EXPECT_NE(manager_, nullptr);
410     int32_t callerPid = 1;
411     manager_->HandleDataAbilityCallerDied(callerPid);
412 }
413 
414 #ifdef WITH_DLP
415 /*
416  * Feature: ConnectionStateManager
417  * Function: AddDlpManager
418  * SubFunction: NA
419  * FunctionPoints: ConnectionStateManager AddDlpManager
420  * EnvConditions: NA
421  * CaseDescription: Verify AddDlpManager
422  */
423 HWTEST_F(ConnectionStateManagerTest, AddDlpManager_001, TestSize.Level1)
424 {
425     EXPECT_NE(manager_, nullptr);
426     std::shared_ptr<AbilityRecord> dlpManger = nullptr;
427     manager_->AddDlpManager(dlpManger);
428 }
429 
430 /*
431  * Feature: ConnectionStateManager
432  * Function: AddDlpManager
433  * SubFunction: NA
434  * FunctionPoints: ConnectionStateManager AddDlpManager
435  * EnvConditions: NA
436  * CaseDescription: Verify AddDlpManager
437  */
438 HWTEST_F(ConnectionStateManagerTest, AddDlpManager_002, TestSize.Level1)
439 {
440     EXPECT_NE(manager_, nullptr);
441     manager_->AddDlpManager(abilityRecord_);
442 }
443 
444 /*
445  * Feature: ConnectionStateManager
446  * Function: AddDlpManager
447  * SubFunction: NA
448  * FunctionPoints: ConnectionStateManager AddDlpManager
449  * EnvConditions: NA
450  * CaseDescription: Verify AddDlpManager
451  */
452 HWTEST_F(ConnectionStateManagerTest, AddDlpManager_003, TestSize.Level1)
453 {
454     EXPECT_NE(manager_, nullptr);
455     auto abilityRecord = abilityRecord_;
456     abilityRecord->ownerMissionUserId_ = 1;
457     manager_->dlpItems_[abilityRecord->ownerMissionUserId_] = nullptr;
458     manager_->AddDlpManager(abilityRecord);
459 }
460 
461 /*
462  * Feature: ConnectionStateManager
463  * Function: RemoveDlpManager
464  * SubFunction: NA
465  * FunctionPoints: ConnectionStateManager RemoveDlpManager
466  * EnvConditions: NA
467  * CaseDescription: Verify RemoveDlpManager
468  */
469 HWTEST_F(ConnectionStateManagerTest, RemoveDlpManager_001, TestSize.Level1)
470 {
471     EXPECT_NE(manager_, nullptr);
472     std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
473     manager_->RemoveDlpManager(abilityRecord);
474 }
475 
476 /*
477  * Feature: ConnectionStateManager
478  * Function: RemoveDlpManager
479  * SubFunction: NA
480  * FunctionPoints: ConnectionStateManager RemoveDlpManager
481  * EnvConditions: NA
482  * CaseDescription: Verify RemoveDlpManager
483  */
484 HWTEST_F(ConnectionStateManagerTest, RemoveDlpManager_002, TestSize.Level1)
485 {
486     EXPECT_NE(manager_, nullptr);
487     manager_->RemoveDlpManager(abilityRecord_);
488 }
489 
490 /*
491  * Feature: ConnectionStateManager
492  * Function: AddDlpAbility
493  * SubFunction: NA
494  * FunctionPoints: ConnectionStateManager AddDlpAbility
495  * EnvConditions: NA
496  * CaseDescription: Verify AddDlpAbility
497  */
498 HWTEST_F(ConnectionStateManagerTest, AddDlpAbility_001, TestSize.Level1)
499 {
500     EXPECT_NE(manager_, nullptr);
501     std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
502     manager_->AddDlpAbility(abilityRecord);
503 }
504 
505 /*
506  * Feature: ConnectionStateManager
507  * Function: AddDlpAbility
508  * SubFunction: NA
509  * FunctionPoints: ConnectionStateManager AddDlpAbility
510  * EnvConditions: NA
511  * CaseDescription: Verify AddDlpAbility
512  */
513 HWTEST_F(ConnectionStateManagerTest, AddDlpAbility_002, TestSize.Level1)
514 {
515     std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
516     manager_->Init();
517     manager_->AddDlpAbility(abilityRecord);
518 }
519 
520 /*
521  * Feature: ConnectionStateManager
522  * Function: RemoveDlpAbility
523  * SubFunction: NA
524  * FunctionPoints: ConnectionStateManager RemoveDlpAbility
525  * EnvConditions: NA
526  * CaseDescription: Verify RemoveDlpAbility
527  */
528 HWTEST_F(ConnectionStateManagerTest, RemoveDlpAbility_001, TestSize.Level1)
529 {
530     EXPECT_NE(manager_, nullptr);
531     std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
532     manager_->RemoveDlpAbility(abilityRecord);
533 }
534 
535 /*
536  * Feature: ConnectionStateManager
537  * Function: RemoveDlpAbility
538  * SubFunction: NA
539  * FunctionPoints: ConnectionStateManager RemoveDlpAbility
540  * EnvConditions: NA
541  * CaseDescription: Verify RemoveDlpAbility
542  */
543 HWTEST_F(ConnectionStateManagerTest, RemoveDlpAbility_002, TestSize.Level1)
544 {
545     EXPECT_NE(manager_, nullptr);
546     std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
547     manager_->Init();
548     manager_->RemoveDlpAbility(abilityRecord);
549 }
550 #endif // WITH_DLP
551 
552 /*
553  * Feature: ConnectionStateManager
554  * Function: HandleAppDied
555  * SubFunction: NA
556  * FunctionPoints: ConnectionStateManager HandleAppDied
557  * EnvConditions: NA
558  * CaseDescription: Verify HandleAppDied
559  */
560 HWTEST_F(ConnectionStateManagerTest, HandleAppDied_001, TestSize.Level1)
561 {
562     EXPECT_NE(manager_, nullptr);
563     int32_t pid = 0;
564     manager_->HandleAppDied(pid);
565 }
566 
567 #ifdef WITH_DLP
568 /*
569  * Feature: ConnectionStateManager
570  * Function: GetDlpConnectionInfos
571  * SubFunction: NA
572  * FunctionPoints: ConnectionStateManager GetDlpConnectionInfos
573  * EnvConditions: NA
574  * CaseDescription: Verify GetDlpConnectionInfos
575  */
576 HWTEST_F(ConnectionStateManagerTest, GetDlpConnectionInfos_001, TestSize.Level1)
577 {
578     EXPECT_NE(manager_, nullptr);
579     std::vector<DlpConnectionInfo> infos;
580     manager_->dlpItems_[0] = nullptr;
581     manager_->dlpItems_[1] = nullptr;
582     manager_->GetDlpConnectionInfos(infos);
583 }
584 #endif // WITH_DLP
585 
586 /*
587  * Feature: ConnectionStateManager
588  * Function: GetConnectionData
589  * SubFunction: NA
590  * FunctionPoints: ConnectionStateManager GetConnectionData
591  * EnvConditions: NA
592  * CaseDescription: Verify GetConnectionData
593  */
594 HWTEST_F(ConnectionStateManagerTest, GetConnectionData_001, TestSize.Level1)
595 {
596     EXPECT_NE(manager_, nullptr);
597     std::vector<ConnectionData> connectionData;
598     manager_->connectionStates_[0] = nullptr;
599     manager_->connectionStates_[1] = nullptr;
600     manager_->GetConnectionData(connectionData);
601 }
602 
603 /*
604  * Feature: ConnectionStateManager
605  * Function: AddConnectionInner
606  * SubFunction: NA
607  * FunctionPoints: ConnectionStateManager AddConnectionInner
608  * EnvConditions: NA
609  * CaseDescription: Verify AddConnectionInner
610  */
611 HWTEST_F(ConnectionStateManagerTest, AddConnectionInner_001, TestSize.Level1)
612 {
613     std::shared_ptr<ConnectionRecord> connectionRecord =
614         ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_);
615     ConnectionData data;
616     connectionRecord->callerPid_ = 0;
617     manager_->connectionStates_[0] = nullptr;
618     bool res = manager_->AddConnectionInner(connectionRecord, data);
619     EXPECT_FALSE(res);
620 }
621 
622 /*
623  * Feature: ConnectionStateManager
624  * Function: RemoveConnectionInner
625  * SubFunction: NA
626  * FunctionPoints: ConnectionStateManager RemoveConnectionInner
627  * EnvConditions: NA
628  * CaseDescription: Verify RemoveConnectionInner
629  */
630 HWTEST_F(ConnectionStateManagerTest, RemoveConnectionInner_001, TestSize.Level1)
631 {
632     std::shared_ptr<ConnectionRecord> connectionRecord =
633         ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_);
634     ConnectionData data;
635     connectionRecord->callerPid_ = 0;
636     manager_->connectionStates_[0] = nullptr;
637     bool res = manager_->RemoveConnectionInner(connectionRecord, data);
638     EXPECT_FALSE(res);
639 }
640 
641 /*
642  * Feature: ConnectionStateManager
643  * Function: HandleCallerDied
644  * SubFunction: NA
645  * FunctionPoints: ConnectionStateManager HandleCallerDied
646  * EnvConditions: NA
647  * CaseDescription: Verify HandleCallerDied
648  */
649 HWTEST_F(ConnectionStateManagerTest, HandleCallerDied_001, TestSize.Level1)
650 {
651     EXPECT_NE(manager_, nullptr);
652     std::shared_ptr<ConnectionRecord> connectionRecord =
653         ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_);
654     EXPECT_NE(connectionRecord, nullptr);
655     int32_t callerUid = 0;
656     int32_t callerPid = 0;
657     std::string callerName = "callerName";
658     manager_->connectionStates_[0] = std::make_shared<ConnectionStateItem>(callerUid, callerPid, callerName);
659     manager_->HandleCallerDied(callerPid);
660 }
661 
662 /*
663  * Feature: ConnectionStateManager
664  * Function: AddDataAbilityConnectionInner
665  * SubFunction: NA
666  * FunctionPoints: ConnectionStateManager AddDataAbilityConnectionInner
667  * EnvConditions: NA
668  * CaseDescription: Verify AddDataAbilityConnectionInner
669  */
670 HWTEST_F(ConnectionStateManagerTest, AddDataAbilityConnectionInner_001, TestSize.Level1)
671 {
672     DataAbilityCaller caller;
673     ConnectionData data;
674     caller.callerPid = 0;
675     manager_->connectionStates_[0] = nullptr;
676     bool res = manager_->AddDataAbilityConnectionInner(caller, dataAbilityRecord_, data);
677     EXPECT_FALSE(res);
678 }
679 
680 /*
681  * Feature: ConnectionStateManager
682  * Function: RemoveDataAbilityConnectionInner
683  * SubFunction: NA
684  * FunctionPoints: ConnectionStateManager RemoveDataAbilityConnectionInner
685  * EnvConditions: NA
686  * CaseDescription: Verify RemoveDataAbilityConnectionInner
687  */
688 HWTEST_F(ConnectionStateManagerTest, RemoveDataAbilityConnectionInner_001, TestSize.Level1)
689 {
690     DataAbilityCaller caller;
691     ConnectionData data;
692     caller.callerPid = 0;
693     manager_->connectionStates_[0] = nullptr;
694     bool res = manager_->RemoveDataAbilityConnectionInner(caller, dataAbilityRecord_, data);
695     EXPECT_FALSE(res);
696 }
697 
698 /*
699  * Feature: ConnectionStateManager
700  * Function: HandleDataAbilityDiedInner
701  * SubFunction: NA
702  * FunctionPoints: ConnectionStateManager HandleDataAbilityDiedInner
703  * EnvConditions: NA
704  * CaseDescription: Verify HandleDataAbilityDiedInner
705  */
706 HWTEST_F(ConnectionStateManagerTest, HandleDataAbilityDiedInner_001, TestSize.Level1)
707 {
708     EXPECT_NE(manager_, nullptr);
709     sptr<IRemoteObject> abilityToken;
710     std::vector<AbilityRuntime::ConnectionData> allData;
711     manager_->connectionStates_[0] = nullptr;
712     manager_->HandleDataAbilityDiedInner(abilityToken, allData);
713 }
714 
715 #ifdef WITH_DLP
716 /*
717  * Feature: ConnectionStateManager
718  * Function: HandleDlpAbilityInner
719  * SubFunction: NA
720  * FunctionPoints: ConnectionStateManager HandleDlpAbilityInner
721  * EnvConditions: NA
722  * CaseDescription: Verify HandleDlpAbilityInner
723  */
724 HWTEST_F(ConnectionStateManagerTest, HandleDlpAbilityInner_001, TestSize.Level1)
725 {
726     std::shared_ptr<AbilityRecord> dlpAbility = nullptr;
727     bool isAdd = true;
728     DlpStateData dlpData;
729     bool res = manager_->HandleDlpAbilityInner(dlpAbility, isAdd, dlpData);
730     EXPECT_FALSE(res);
731 }
732 
733 /*
734  * Feature: ConnectionStateManager
735  * Function: HandleDlpAbilityInner
736  * SubFunction: NA
737  * FunctionPoints: ConnectionStateManager HandleDlpAbilityInner
738  * EnvConditions: NA
739  * CaseDescription: Verify HandleDlpAbilityInner
740  */
741 HWTEST_F(ConnectionStateManagerTest, HandleDlpAbilityInner_002, TestSize.Level1)
742 {
743     std::shared_ptr<AbilityRecord> dlpAbility = abilityRecord_;
744     bool isAdd = true;
745     DlpStateData dlpData;
746     dlpAbility->appIndex_ = 0;
747     bool res = manager_->HandleDlpAbilityInner(dlpAbility, isAdd, dlpData);
748     EXPECT_FALSE(res);
749 }
750 
751 /*
752  * Feature: ConnectionStateManager
753  * Function: HandleDlpAbilityInner
754  * SubFunction: NA
755  * FunctionPoints: ConnectionStateManager HandleDlpAbilityInner
756  * EnvConditions: NA
757  * CaseDescription: Verify HandleDlpAbilityInner
758  */
759 HWTEST_F(ConnectionStateManagerTest, HandleDlpAbilityInner_003, TestSize.Level1)
760 {
761     std::shared_ptr<AbilityRecord> dlpAbility = abilityRecord_;
762     bool isAdd = true;
763     DlpStateData dlpData;
764     dlpAbility->appIndex_ = 1;
765     bool res = manager_->HandleDlpAbilityInner(dlpAbility, isAdd, dlpData);
766     EXPECT_FALSE(res);
767 }
768 
769 /*
770  * Feature: ConnectionStateManager
771  * Function: HandleDlpAbilityInner
772  * SubFunction: NA
773  * FunctionPoints: ConnectionStateManager HandleDlpAbilityInner
774  * EnvConditions: NA
775  * CaseDescription: Verify HandleDlpAbilityInner
776  */
777 HWTEST_F(ConnectionStateManagerTest, HandleDlpAbilityInner_004, TestSize.Level1)
778 {
779     std::shared_ptr<AbilityRecord> dlpAbility = abilityRecord_;
780     bool isAdd = true;
781     DlpStateData dlpData;
782     dlpAbility->appIndex_ = 1;
783     manager_->dlpItems_[1] = nullptr;
784     bool res = manager_->HandleDlpAbilityInner(dlpAbility, isAdd, dlpData);
785     EXPECT_FALSE(res);
786 }
787 
788 /*
789  * Feature: ConnectionStateManager
790  * Function: HandleDlpAbilityInner
791  * SubFunction: NA
792  * FunctionPoints: ConnectionStateManager HandleDlpAbilityInner
793  * EnvConditions: NA
794  * CaseDescription: Verify HandleDlpAbilityInner
795  */
796 HWTEST_F(ConnectionStateManagerTest, HandleDlpAbilityInner_005, TestSize.Level1)
797 {
798     std::shared_ptr<AbilityRecord> dlpAbility = abilityRecord_;
799     bool isAdd = false;
800     DlpStateData dlpData;
801     int32_t dlpUid = 0;
802     int32_t dlpPid = 0;
803     std::shared_ptr<DlpStateItem> item = std::make_shared<DlpStateItem>(dlpUid, dlpPid);
804     dlpAbility->appIndex_ = 1;
805     manager_->dlpItems_[1] = item;
806     bool res = manager_->HandleDlpAbilityInner(dlpAbility, isAdd, dlpData);
807     EXPECT_FALSE(res);
808 }
809 
810 /*
811  * Feature: ConnectionStateManager
812  * Function: HandleDlpAbilityInner
813  * SubFunction: NA
814  * FunctionPoints: ConnectionStateManager HandleDlpAbilityInner
815  * EnvConditions: NA
816  * CaseDescription: Verify HandleDlpAbilityInner
817  */
818 HWTEST_F(ConnectionStateManagerTest, HandleDlpAbilityInner_006, TestSize.Level1)
819 {
820     std::shared_ptr<AbilityRecord> dlpAbility = abilityRecord_;
821     bool isAdd = true;
822     DlpStateData dlpData;
823     int32_t dlpUid = 0;
824     int32_t dlpPid = 0;
825     std::shared_ptr<DlpStateItem> item = std::make_shared<DlpStateItem>(dlpUid, dlpPid);
826     dlpAbility->appIndex_ = 1;
827     manager_->dlpItems_[1] = item;
828     bool res = manager_->HandleDlpAbilityInner(dlpAbility, isAdd, dlpData);
829     EXPECT_FALSE(res);
830 }
831 #endif // WITH_DLP
832 }  // namespace AAFwk
833 }  // namespace OHOS
834