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 
18 #define private public
19 #include "ability_record.h"
20 #include "connection_state_item.h"
21 #include "connection_record.h"
22 #undef private
23 #include "connection_observer_errors.h"
24 #include "ability_connect_callback_interface.h"
25 #include "ability_connect_callback_stub.h"
26 
27 using namespace testing::ext;
28 using namespace OHOS::AbilityRuntime;
29 using namespace OHOS::AppExecFwk;
30 
31 namespace OHOS {
32 namespace AAFwk {
33 class MyAbilityConnection : public AbilityConnectionStub {
34 public:
35     MyAbilityConnection() = default;
36     virtual ~MyAbilityConnection() = default;
OnAbilityConnectDone(const AppExecFwk::ElementName & element,const sptr<IRemoteObject> & remoteObject,int resultCode)37     void OnAbilityConnectDone(
38         const AppExecFwk::ElementName& element, const sptr<IRemoteObject>& remoteObject, int resultCode) override
39     {}
OnAbilityDisconnectDone(const AppExecFwk::ElementName & element,int resultCode)40     void OnAbilityDisconnectDone(const AppExecFwk::ElementName& element, int resultCode) override
41     {}
42 };
43 class ConnectionStateItemTest : public testing::Test {
44 public:
45     static void SetUpTestCase(void);
46     static void TearDownTestCase(void);
47     void SetUp();
48     void TearDown();
49     std::shared_ptr<ConnectionStateItem> Init();
50     std::shared_ptr<AbilityRecord> InitAbilityRecord();
51     std::shared_ptr<DataAbilityRecord> InitDataAbilityRecord();
52 };
53 
SetUpTestCase(void)54 void ConnectionStateItemTest::SetUpTestCase(void)
55 {}
TearDownTestCase(void)56 void ConnectionStateItemTest::TearDownTestCase(void)
57 {}
SetUp(void)58 void ConnectionStateItemTest::SetUp(void)
59 {}
TearDown(void)60 void ConnectionStateItemTest::TearDown(void)
61 {}
Init()62 std::shared_ptr<ConnectionStateItem> ConnectionStateItemTest::Init()
63 {
64     int32_t callerUid = 0;
65     int32_t callerPid = 0;
66     std::string callerName = "callerName";
67     return std::make_shared<ConnectionStateItem>(callerUid, callerPid, callerName);
68 }
InitAbilityRecord()69 std::shared_ptr<AbilityRecord> ConnectionStateItemTest::InitAbilityRecord()
70 {
71     AbilityRequest abilityRequest;
72     abilityRequest.appInfo.bundleName = "com.example.unittest";
73     abilityRequest.abilityInfo.name = "MainAbility";
74     abilityRequest.abilityInfo.type = AbilityType::PAGE;
75     return AbilityRecord::CreateAbilityRecord(abilityRequest);
76 }
InitDataAbilityRecord()77 std::shared_ptr<DataAbilityRecord> ConnectionStateItemTest::InitDataAbilityRecord()
78 {
79     AbilityRequest abilityRequest;
80     abilityRequest.appInfo.bundleName = "com.example.unittest";
81     abilityRequest.abilityInfo.name = "MainAbility";
82     abilityRequest.abilityInfo.type = AbilityType::DATA;
83     return std::make_shared<DataAbilityRecord>(abilityRequest);
84 }
85 
86 /*
87  * Feature: ConnectionStateItem
88  * Function: CreateConnectionStateItem
89  * SubFunction: NA
90  * FunctionPoints: ConnectionStateItem CreateConnectionStateItem
91  * EnvConditions: NA
92  * CaseDescription: Verify CreateConnectionStateItem
93  */
94 HWTEST_F(ConnectionStateItemTest, CreateConnectionStateItem_001, TestSize.Level1)
95 {
96     auto connectionStateItem = Init();
97     std::shared_ptr<ConnectionRecord> record = nullptr;
98     auto res = connectionStateItem->CreateConnectionStateItem(record);
99     EXPECT_EQ(res, nullptr);
100 }
101 
102 /*
103  * Feature: ConnectionStateItem
104  * Function: CreateConnectionStateItem
105  * SubFunction: NA
106  * FunctionPoints: ConnectionStateItem CreateConnectionStateItem
107  * EnvConditions: NA
108  * CaseDescription: Verify CreateConnectionStateItem
109  */
110 HWTEST_F(ConnectionStateItemTest, CreateConnectionStateItem_002, TestSize.Level1)
111 {
112     auto connectionStateItem = Init();
113     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
114     sptr<IAbilityConnection> connCallback;
115     std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
116         abilityRecord->GetToken(), abilityRecord, connCallback);
117     auto res = connectionStateItem->CreateConnectionStateItem(record);
118     EXPECT_NE(res, nullptr);
119 }
120 
121 /*
122  * Feature: ConnectionStateItem
123  * Function: CreateConnectionStateItem
124  * SubFunction: NA
125  * FunctionPoints: ConnectionStateItem CreateConnectionStateItem
126  * EnvConditions: NA
127  * CaseDescription: Verify CreateConnectionStateItem
128  */
129 HWTEST_F(ConnectionStateItemTest, CreateConnectionStateItem_003, TestSize.Level1)
130 {
131     auto connectionStateItem = Init();
132     DataAbilityCaller dataCaller;
133     auto res = connectionStateItem->CreateConnectionStateItem(dataCaller);
134     EXPECT_NE(res, nullptr);
135 }
136 
137 /*
138  * Feature: ConnectionStateItem
139  * Function: AddConnection
140  * SubFunction: NA
141  * FunctionPoints: ConnectionStateItem AddConnection
142  * EnvConditions: NA
143  * CaseDescription: Verify AddConnection
144  */
145 HWTEST_F(ConnectionStateItemTest, AddConnection_001, TestSize.Level1)
146 {
147     auto connectionStateItem = Init();
148     std::shared_ptr<ConnectionRecord> record = nullptr;
149     ConnectionData data;
150     auto res = connectionStateItem->AddConnection(record, data);
151     EXPECT_FALSE(res);
152 }
153 
154 /*
155  * Feature: ConnectionStateItem
156  * Function: AddConnection
157  * SubFunction: NA
158  * FunctionPoints: ConnectionStateItem AddConnection
159  * EnvConditions: NA
160  * CaseDescription: Verify AddConnection
161  */
162 HWTEST_F(ConnectionStateItemTest, AddConnection_002, TestSize.Level1)
163 {
164     auto connectionStateItem = Init();
165     sptr<IRemoteObject> callerToken;
166     std::shared_ptr<AbilityRecord> abilityRecord;
167     sptr<IAbilityConnection> connCallback;
168     std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
169         callerToken, abilityRecord, connCallback);
170     ConnectionData data;
171     auto res = connectionStateItem->AddConnection(record, data);
172     EXPECT_FALSE(res);
173 }
174 
175 /*
176  * Feature: ConnectionStateItem
177  * Function: AddConnection
178  * SubFunction: NA
179  * FunctionPoints: ConnectionStateItem AddConnection
180  * EnvConditions: NA
181  * CaseDescription: Verify AddConnection
182  */
183 HWTEST_F(ConnectionStateItemTest, AddConnection_003, TestSize.Level1)
184 {
185     auto connectionStateItem = Init();
186     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
187     sptr<IAbilityConnection> connCallback;
188     std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
189         abilityRecord->GetToken(), abilityRecord, connCallback);
190     ConnectionData data;
191     auto res = connectionStateItem->AddConnection(record, data);
192     EXPECT_FALSE(res);
193 }
194 
195 /*
196  * Feature: ConnectionStateItem
197  * Function: AddConnection
198  * SubFunction: NA
199  * FunctionPoints: ConnectionStateItem AddConnection
200  * EnvConditions: NA
201  * CaseDescription: Verify AddConnection
202  */
203 HWTEST_F(ConnectionStateItemTest, AddConnection_004, TestSize.Level1)
204 {
205     auto connectionStateItem = Init();
206     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
207     sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
208     std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
209         abilityRecord->GetToken(), abilityRecord, connCallback);
210     ConnectionData data;
211     auto res = connectionStateItem->AddConnection(record, data);
212     EXPECT_TRUE(res);
213 }
214 
215 /*
216  * Feature: ConnectionStateItem
217  * Function: AddConnection
218  * SubFunction: NA
219  * FunctionPoints: ConnectionStateItem AddConnection
220  * EnvConditions: NA
221  * CaseDescription: Verify AddConnection
222  */
223 HWTEST_F(ConnectionStateItemTest, AddConnection_005, TestSize.Level1)
224 {
225     auto connectionStateItem = Init();
226     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
227     sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
228     std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
229         abilityRecord->GetToken(), abilityRecord, connCallback);
230     ConnectionData data;
231     connectionStateItem->connectionMap_[abilityRecord->GetToken()] = nullptr;
232     auto res = connectionStateItem->AddConnection(record, data);
233     EXPECT_FALSE(res);
234 }
235 
236 /*
237  * Feature: ConnectionStateItem
238  * Function: RemoveConnection
239  * SubFunction: NA
240  * FunctionPoints: ConnectionStateItem RemoveConnection
241  * EnvConditions: NA
242  * CaseDescription: Verify RemoveConnection
243  */
244 HWTEST_F(ConnectionStateItemTest, RemoveConnection_001, TestSize.Level1)
245 {
246     auto connectionStateItem = Init();
247     std::shared_ptr<ConnectionRecord> record = nullptr;
248     ConnectionData data;
249     auto res = connectionStateItem->RemoveConnection(record, data);
250     EXPECT_FALSE(res);
251 }
252 
253 /*
254  * Feature: ConnectionStateItem
255  * Function: RemoveConnection
256  * SubFunction: NA
257  * FunctionPoints: ConnectionStateItem RemoveConnection
258  * EnvConditions: NA
259  * CaseDescription: Verify RemoveConnection
260  */
261 HWTEST_F(ConnectionStateItemTest, RemoveConnection_002, TestSize.Level1)
262 {
263     auto connectionStateItem = Init();
264     sptr<IRemoteObject> callerToken;
265     std::shared_ptr<AbilityRecord> abilityRecord;
266     sptr<IAbilityConnection> connCallback;
267     std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
268         callerToken, abilityRecord, connCallback);
269     ConnectionData data;
270     auto res = connectionStateItem->RemoveConnection(record, data);
271     EXPECT_FALSE(res);
272 }
273 
274 /*
275  * Feature: ConnectionStateItem
276  * Function: RemoveConnection
277  * SubFunction: NA
278  * FunctionPoints: ConnectionStateItem RemoveConnection
279  * EnvConditions: NA
280  * CaseDescription: Verify RemoveConnection
281  */
282 HWTEST_F(ConnectionStateItemTest, RemoveConnection_003, TestSize.Level1)
283 {
284     auto connectionStateItem = Init();
285     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
286     sptr<IAbilityConnection> connCallback;
287     std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
288         abilityRecord->GetToken(), abilityRecord, connCallback);
289     ConnectionData data;
290     auto res = connectionStateItem->RemoveConnection(record, data);
291     EXPECT_FALSE(res);
292 }
293 
294 /*
295  * Feature: ConnectionStateItem
296  * Function: RemoveConnection
297  * SubFunction: NA
298  * FunctionPoints: ConnectionStateItem RemoveConnection
299  * EnvConditions: NA
300  * CaseDescription: Verify RemoveConnection
301  */
302 HWTEST_F(ConnectionStateItemTest, RemoveConnection_004, TestSize.Level1)
303 {
304     auto connectionStateItem = Init();
305     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
306     sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
307     std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
308         abilityRecord->GetToken(), abilityRecord, connCallback);
309     ConnectionData data;
310     auto res = connectionStateItem->RemoveConnection(record, data);
311     EXPECT_FALSE(res);
312 }
313 
314 /*
315  * Feature: ConnectionStateItem
316  * Function: RemoveConnection
317  * SubFunction: NA
318  * FunctionPoints: ConnectionStateItem RemoveConnection
319  * EnvConditions: NA
320  * CaseDescription: Verify RemoveConnection
321  */
322 HWTEST_F(ConnectionStateItemTest, RemoveConnection_005, TestSize.Level1)
323 {
324     auto connectionStateItem = Init();
325     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
326     sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
327     std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
328         abilityRecord->GetToken(), abilityRecord, connCallback);
329     ConnectionData data;
330     connectionStateItem->connectionMap_[abilityRecord->GetToken()] = nullptr;
331     auto res = connectionStateItem->RemoveConnection(record, data);
332     EXPECT_FALSE(res);
333 }
334 
335 /*
336  * Feature: ConnectionStateItem
337  * Function: RemoveConnection
338  * SubFunction: NA
339  * FunctionPoints: ConnectionStateItem RemoveConnection
340  * EnvConditions: NA
341  * CaseDescription: Verify RemoveConnection
342  */
343 HWTEST_F(ConnectionStateItemTest, RemoveConnection_006, TestSize.Level1)
344 {
345     auto connectionStateItem = Init();
346     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
347     sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
348     std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
349         abilityRecord->GetToken(), abilityRecord, connCallback);
350     ConnectionData data;
351     connectionStateItem->AddConnection(record, data);
352     auto res = connectionStateItem->RemoveConnection(record, data);
353     EXPECT_TRUE(res);
354 }
355 
356 /*
357  * Feature: ConnectionStateItem
358  * Function: AddDataAbilityConnection
359  * SubFunction: NA
360  * FunctionPoints: ConnectionStateItem AddDataAbilityConnection
361  * EnvConditions: NA
362  * CaseDescription: Verify AddDataAbilityConnection
363  */
364 HWTEST_F(ConnectionStateItemTest, AddDataAbilityConnection_001, TestSize.Level1)
365 {
366     auto connectionStateItem = Init();
367     DataAbilityCaller caller;
368     std::shared_ptr<DataAbilityRecord> dataAbility;
369     ConnectionData data;
370     auto res = connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
371     EXPECT_FALSE(res);
372 }
373 
374 /*
375  * Feature: ConnectionStateItem
376  * Function: AddDataAbilityConnection
377  * SubFunction: NA
378  * FunctionPoints: ConnectionStateItem AddDataAbilityConnection
379  * EnvConditions: NA
380  * CaseDescription: Verify AddDataAbilityConnection
381  */
382 HWTEST_F(ConnectionStateItemTest, AddDataAbilityConnection_002, TestSize.Level1)
383 {
384     auto connectionStateItem = Init();
385     DataAbilityCaller caller;
386     std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
387     ConnectionData data;
388     auto res = connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
389     EXPECT_FALSE(res);
390 }
391 
392 /*
393  * Feature: ConnectionStateItem
394  * Function: AddDataAbilityConnection
395  * SubFunction: NA
396  * FunctionPoints: ConnectionStateItem AddDataAbilityConnection
397  * EnvConditions: NA
398  * CaseDescription: Verify AddDataAbilityConnection
399  */
400 HWTEST_F(ConnectionStateItemTest, AddDataAbilityConnection_003, TestSize.Level1)
401 {
402     auto connectionStateItem = Init();
403     DataAbilityCaller caller;
404     std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
405     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
406     caller.isNotHap = true;
407     caller.callerToken = abilityRecord->GetToken();
408     dataAbility->ability_ = abilityRecord;
409     ConnectionData data;
410     auto res = connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
411     EXPECT_TRUE(res);
412 }
413 
414 /*
415  * Feature: ConnectionStateItem
416  * Function: AddDataAbilityConnection
417  * SubFunction: NA
418  * FunctionPoints: ConnectionStateItem AddDataAbilityConnection
419  * EnvConditions: NA
420  * CaseDescription: Verify AddDataAbilityConnection
421  */
422 HWTEST_F(ConnectionStateItemTest, AddDataAbilityConnection_004, TestSize.Level1)
423 {
424     auto connectionStateItem = Init();
425     DataAbilityCaller caller;
426     std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
427     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
428     dataAbility->ability_ = abilityRecord;
429     connectionStateItem->dataAbilityMap_.emplace(abilityRecord->GetToken(), nullptr);
430     ConnectionData data;
431     auto res = connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
432     EXPECT_FALSE(res);
433 }
434 
435 /*
436  * Feature: ConnectionStateItem
437  * Function: AddDataAbilityConnection
438  * SubFunction: NA
439  * FunctionPoints: ConnectionStateItem AddDataAbilityConnection
440  * EnvConditions: NA
441  * CaseDescription: Verify AddDataAbilityConnection
442  */
443 HWTEST_F(ConnectionStateItemTest, AddDataAbilityConnection_005, TestSize.Level1)
444 {
445     auto connectionStateItem = Init();
446     DataAbilityCaller caller;
447     std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
448     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
449     caller.isNotHap = true;
450     caller.callerToken = abilityRecord->GetToken();
451     dataAbility->ability_ = abilityRecord;
452     ConnectionData data;
453     connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
454     caller.isNotHap = false;
455     auto res1 = connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
456     EXPECT_FALSE(res1);
457     caller.callerToken = nullptr;
458     auto res2 = connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
459     EXPECT_FALSE(res2);
460 }
461 
462 /*
463  * Feature: ConnectionStateItem
464  * Function: RemoveDataAbilityConnection
465  * SubFunction: NA
466  * FunctionPoints: ConnectionStateItem RemoveDataAbilityConnection
467  * EnvConditions: NA
468  * CaseDescription: Verify RemoveDataAbilityConnection
469  */
470 HWTEST_F(ConnectionStateItemTest, RemoveDataAbilityConnection_001, TestSize.Level1)
471 {
472     auto connectionStateItem = Init();
473     DataAbilityCaller caller;
474     std::shared_ptr<DataAbilityRecord> dataAbility;
475     ConnectionData data;
476     auto res = connectionStateItem->RemoveDataAbilityConnection(caller, dataAbility, data);
477     EXPECT_FALSE(res);
478 }
479 
480 /*
481  * Feature: ConnectionStateItem
482  * Function: RemoveDataAbilityConnection
483  * SubFunction: NA
484  * FunctionPoints: ConnectionStateItem RemoveDataAbilityConnection
485  * EnvConditions: NA
486  * CaseDescription: Verify RemoveDataAbilityConnection
487  */
488 HWTEST_F(ConnectionStateItemTest, RemoveDataAbilityConnection_002, TestSize.Level1)
489 {
490     auto connectionStateItem = Init();
491     DataAbilityCaller caller;
492     std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
493     ConnectionData data;
494     auto res = connectionStateItem->RemoveDataAbilityConnection(caller, dataAbility, data);
495     EXPECT_FALSE(res);
496 }
497 
498 /*
499  * Feature: ConnectionStateItem
500  * Function: RemoveDataAbilityConnection
501  * SubFunction: NA
502  * FunctionPoints: ConnectionStateItem RemoveDataAbilityConnection
503  * EnvConditions: NA
504  * CaseDescription: Verify RemoveDataAbilityConnection
505  */
506 HWTEST_F(ConnectionStateItemTest, RemoveDataAbilityConnection_003, TestSize.Level1)
507 {
508     auto connectionStateItem = Init();
509     DataAbilityCaller caller;
510     std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
511     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
512     dataAbility->ability_ = abilityRecord;
513     ConnectionData data;
514     auto res = connectionStateItem->RemoveDataAbilityConnection(caller, dataAbility, data);
515     EXPECT_FALSE(res);
516 }
517 
518 /*
519  * Feature: ConnectionStateItem
520  * Function: RemoveDataAbilityConnection
521  * SubFunction: NA
522  * FunctionPoints: ConnectionStateItem RemoveDataAbilityConnection
523  * EnvConditions: NA
524  * CaseDescription: Verify RemoveDataAbilityConnection
525  */
526 HWTEST_F(ConnectionStateItemTest, RemoveDataAbilityConnection_004, TestSize.Level1)
527 {
528     auto connectionStateItem = Init();
529     DataAbilityCaller caller;
530     std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
531     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
532     dataAbility->ability_ = abilityRecord;
533     connectionStateItem->dataAbilityMap_.emplace(abilityRecord->GetToken(), nullptr);
534     ConnectionData data;
535     auto res = connectionStateItem->RemoveDataAbilityConnection(caller, dataAbility, data);
536     EXPECT_FALSE(res);
537 }
538 
539 /*
540  * Feature: ConnectionStateItem
541  * Function: RemoveDataAbilityConnection
542  * SubFunction: NA
543  * FunctionPoints: ConnectionStateItem RemoveDataAbilityConnection
544  * EnvConditions: NA
545  * CaseDescription: Verify RemoveDataAbilityConnection
546  */
547 HWTEST_F(ConnectionStateItemTest, RemoveDataAbilityConnection_005, TestSize.Level1)
548 {
549     auto connectionStateItem = Init();
550     DataAbilityCaller caller;
551     std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
552     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
553     caller.isNotHap = false;
554     caller.callerToken = nullptr;
555     dataAbility->ability_ = abilityRecord;
556     ConnectionData data;
557     connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
558     auto res = connectionStateItem->RemoveDataAbilityConnection(caller, dataAbility, data);
559     EXPECT_FALSE(res);
560 }
561 
562 /*
563  * Feature: ConnectionStateItem
564  * Function: RemoveDataAbilityConnection
565  * SubFunction: NA
566  * FunctionPoints: ConnectionStateItem RemoveDataAbilityConnection
567  * EnvConditions: NA
568  * CaseDescription: Verify RemoveDataAbilityConnection
569  */
570 HWTEST_F(ConnectionStateItemTest, RemoveDataAbilityConnection_006, TestSize.Level1)
571 {
572     auto connectionStateItem = Init();
573     DataAbilityCaller caller;
574     std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
575     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
576     caller.isNotHap = true;
577     caller.callerToken = abilityRecord->GetToken();
578     dataAbility->ability_ = abilityRecord;
579     ConnectionData data;
580     connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
581     auto res = connectionStateItem->RemoveDataAbilityConnection(caller, dataAbility, data);
582     EXPECT_TRUE(res);
583 }
584 
585 /*
586  * Feature: ConnectionStateItem
587  * Function: HandleDataAbilityDied
588  * SubFunction: NA
589  * FunctionPoints: ConnectionStateItem HandleDataAbilityDied
590  * EnvConditions: NA
591  * CaseDescription: Verify HandleDataAbilityDied
592  */
593 HWTEST_F(ConnectionStateItemTest, HandleDataAbilityDied_001, TestSize.Level1)
594 {
595     auto connectionStateItem = Init();
596     sptr<IRemoteObject> token;
597     ConnectionData data;
598     auto res = connectionStateItem->HandleDataAbilityDied(token, data);
599     EXPECT_FALSE(res);
600 }
601 
602 /*
603  * Feature: ConnectionStateItem
604  * Function: HandleDataAbilityDied
605  * SubFunction: NA
606  * FunctionPoints: ConnectionStateItem HandleDataAbilityDied
607  * EnvConditions: NA
608  * CaseDescription: Verify HandleDataAbilityDied
609  */
610 HWTEST_F(ConnectionStateItemTest, HandleDataAbilityDied_002, TestSize.Level1)
611 {
612     auto connectionStateItem = Init();
613     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
614     sptr<IRemoteObject> token = abilityRecord->GetToken();
615     ConnectionData data;
616     auto res = connectionStateItem->HandleDataAbilityDied(token, data);
617     EXPECT_FALSE(res);
618 }
619 
620 /*
621  * Feature: ConnectionStateItem
622  * Function: HandleDataAbilityDied
623  * SubFunction: NA
624  * FunctionPoints: ConnectionStateItem HandleDataAbilityDied
625  * EnvConditions: NA
626  * CaseDescription: Verify HandleDataAbilityDied
627  */
628 HWTEST_F(ConnectionStateItemTest, HandleDataAbilityDied_003, TestSize.Level1)
629 {
630     auto connectionStateItem = Init();
631     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
632     sptr<IRemoteObject> token = abilityRecord->GetToken();
633     connectionStateItem->dataAbilityMap_.emplace(abilityRecord->GetToken(), nullptr);
634     ConnectionData data;
635     auto res = connectionStateItem->HandleDataAbilityDied(token, data);
636     EXPECT_FALSE(res);
637 }
638 
639 /*
640  * Feature: ConnectionStateItem
641  * Function: HandleDataAbilityDied
642  * SubFunction: NA
643  * FunctionPoints: ConnectionStateItem HandleDataAbilityDied
644  * EnvConditions: NA
645  * CaseDescription: Verify HandleDataAbilityDied
646  */
647 HWTEST_F(ConnectionStateItemTest, HandleDataAbilityDied_004, TestSize.Level1)
648 {
649     auto connectionStateItem = Init();
650     DataAbilityCaller caller;
651     ConnectionData data;
652     std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
653     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
654     dataAbility->ability_ = abilityRecord;
655     connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
656     sptr<IRemoteObject> token = abilityRecord->GetToken();
657     auto res = connectionStateItem->HandleDataAbilityDied(token, data);
658     EXPECT_TRUE(res);
659 }
660 
661 /*
662  * Feature: ConnectionStateItem
663  * Function: IsEmpty
664  * SubFunction: NA
665  * FunctionPoints: ConnectionStateItem IsEmpty
666  * EnvConditions: NA
667  * CaseDescription: Verify IsEmpty
668  */
669 HWTEST_F(ConnectionStateItemTest, IsEmpty_001, TestSize.Level1)
670 {
671     auto connectionStateItem = Init();
672     auto res = connectionStateItem->IsEmpty();
673     EXPECT_TRUE(res);
674 }
675 
676 /*
677  * Feature: ConnectionStateItem
678  * Function: GenerateAllConnectionData
679  * SubFunction: NA
680  * FunctionPoints: ConnectionStateItem GenerateAllConnectionData
681  * EnvConditions: NA
682  * CaseDescription: Verify GenerateAllConnectionData
683  */
684 HWTEST_F(ConnectionStateItemTest, GenerateAllConnectionData_001, TestSize.Level1)
685 {
686     auto connectionStateItem = Init();
687     std::vector<AbilityRuntime::ConnectionData> datas;
688     std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
689     sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
690     std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
691         abilityRecord->GetToken(), abilityRecord, connCallback);
692     ConnectionData data;
693     DataAbilityCaller caller;
694     std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
695     caller.isNotHap = true;
696     caller.callerToken = abilityRecord->GetToken();
697     dataAbility->ability_ = abilityRecord;
698     connectionStateItem->AddConnection(record, data);
699     connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
700     connectionStateItem->GenerateAllConnectionData(datas);
701 }
702 }  // namespace AAFwk
703 }  // namespace OHOS
704