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 std::shared_ptr<AbilityRecord> InitAbilityRecord1();
53 };
54
SetUpTestCase(void)55 void ConnectionStateItemTest::SetUpTestCase(void)
56 {}
TearDownTestCase(void)57 void ConnectionStateItemTest::TearDownTestCase(void)
58 {}
SetUp(void)59 void ConnectionStateItemTest::SetUp(void)
60 {}
TearDown(void)61 void ConnectionStateItemTest::TearDown(void)
62 {}
Init()63 std::shared_ptr<ConnectionStateItem> ConnectionStateItemTest::Init()
64 {
65 int32_t callerUid = 0;
66 int32_t callerPid = 0;
67 std::string callerName = "callerName";
68 return std::make_shared<ConnectionStateItem>(callerUid, callerPid, callerName);
69 }
InitAbilityRecord()70 std::shared_ptr<AbilityRecord> ConnectionStateItemTest::InitAbilityRecord()
71 {
72 AbilityRequest abilityRequest;
73 abilityRequest.appInfo.bundleName = "com.example.unittest";
74 abilityRequest.abilityInfo.name = "MainAbility";
75 abilityRequest.abilityInfo.type = AbilityType::PAGE;
76 return AbilityRecord::CreateAbilityRecord(abilityRequest);
77 }
78
InitAbilityRecord1()79 std::shared_ptr<AbilityRecord> ConnectionStateItemTest::InitAbilityRecord1()
80 {
81 AbilityRequest abilityRequest;
82 abilityRequest.appInfo.bundleName = "com.example.unittest1";
83 abilityRequest.abilityInfo.name = "MainAbility1";
84 abilityRequest.abilityInfo.type = AbilityType::PAGE;
85 return AbilityRecord::CreateAbilityRecord(abilityRequest);
86 }
87
InitDataAbilityRecord()88 std::shared_ptr<DataAbilityRecord> ConnectionStateItemTest::InitDataAbilityRecord()
89 {
90 AbilityRequest abilityRequest;
91 abilityRequest.appInfo.bundleName = "com.example.unittest";
92 abilityRequest.abilityInfo.name = "MainAbility";
93 abilityRequest.abilityInfo.type = AbilityType::DATA;
94 return std::make_shared<DataAbilityRecord>(abilityRequest);
95 }
96
97 /*
98 * Feature: ConnectionStateItem
99 * Function: CreateConnectionStateItem
100 * SubFunction: NA
101 * FunctionPoints: ConnectionStateItem CreateConnectionStateItem
102 * EnvConditions: NA
103 * CaseDescription: Verify CreateConnectionStateItem
104 */
105 HWTEST_F(ConnectionStateItemTest, CreateConnectionStateItem_001, TestSize.Level1)
106 {
107 auto connectionStateItem = Init();
108 std::shared_ptr<ConnectionRecord> record = nullptr;
109 auto res = connectionStateItem->CreateConnectionStateItem(record);
110 EXPECT_EQ(res, nullptr);
111 }
112
113 /*
114 * Feature: ConnectionStateItem
115 * Function: CreateConnectionStateItem
116 * SubFunction: NA
117 * FunctionPoints: ConnectionStateItem CreateConnectionStateItem
118 * EnvConditions: NA
119 * CaseDescription: Verify CreateConnectionStateItem
120 */
121 HWTEST_F(ConnectionStateItemTest, CreateConnectionStateItem_002, TestSize.Level1)
122 {
123 auto connectionStateItem = Init();
124 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
125 sptr<IAbilityConnection> connCallback;
126 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
127 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
128 auto res = connectionStateItem->CreateConnectionStateItem(record);
129 EXPECT_NE(res, nullptr);
130 }
131
132 /*
133 * Feature: ConnectionStateItem
134 * Function: CreateConnectionStateItem
135 * SubFunction: NA
136 * FunctionPoints: ConnectionStateItem CreateConnectionStateItem
137 * EnvConditions: NA
138 * CaseDescription: Verify CreateConnectionStateItem
139 */
140 HWTEST_F(ConnectionStateItemTest, CreateConnectionStateItem_003, TestSize.Level1)
141 {
142 auto connectionStateItem = Init();
143 DataAbilityCaller dataCaller;
144 auto res = connectionStateItem->CreateConnectionStateItem(dataCaller);
145 EXPECT_NE(res, nullptr);
146 }
147
148 /*
149 * Feature: ConnectionStateItem
150 * Function: AddConnection
151 * SubFunction: NA
152 * FunctionPoints: ConnectionStateItem AddConnection
153 * EnvConditions: NA
154 * CaseDescription: Verify AddConnection
155 */
156 HWTEST_F(ConnectionStateItemTest, AddConnection_001, TestSize.Level1)
157 {
158 auto connectionStateItem = Init();
159 std::shared_ptr<ConnectionRecord> record = nullptr;
160 ConnectionData data;
161 ConnectionEvent event;
162 auto res = connectionStateItem->AddConnection(record, data, event);
163 EXPECT_FALSE(res);
164 }
165
166 /*
167 * Feature: ConnectionStateItem
168 * Function: AddConnection
169 * SubFunction: NA
170 * FunctionPoints: ConnectionStateItem AddConnection
171 * EnvConditions: NA
172 * CaseDescription: Verify AddConnection
173 */
174 HWTEST_F(ConnectionStateItemTest, AddConnection_002, TestSize.Level1)
175 {
176 auto connectionStateItem = Init();
177 sptr<IRemoteObject> callerToken;
178 std::shared_ptr<AbilityRecord> abilityRecord;
179 sptr<IAbilityConnection> connCallback;
180 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
181 callerToken, abilityRecord, connCallback, nullptr);
182 ConnectionData data;
183 ConnectionEvent event;
184 auto res = connectionStateItem->AddConnection(record, data, event);
185 EXPECT_FALSE(res);
186 }
187
188 /*
189 * Feature: ConnectionStateItem
190 * Function: AddConnection
191 * SubFunction: NA
192 * FunctionPoints: ConnectionStateItem AddConnection
193 * EnvConditions: NA
194 * CaseDescription: Verify AddConnection
195 */
196 HWTEST_F(ConnectionStateItemTest, AddConnection_003, TestSize.Level1)
197 {
198 auto connectionStateItem = Init();
199 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
200 sptr<IAbilityConnection> connCallback;
201 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
202 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
203 ConnectionData data;
204 ConnectionEvent event;
205 auto res = connectionStateItem->AddConnection(record, data, event);
206 EXPECT_FALSE(res);
207 }
208
209 /*
210 * Feature: ConnectionStateItem
211 * Function: AddConnection
212 * SubFunction: NA
213 * FunctionPoints: ConnectionStateItem AddConnection
214 * EnvConditions: NA
215 * CaseDescription: Verify AddConnection
216 */
217 HWTEST_F(ConnectionStateItemTest, AddConnection_004, TestSize.Level1)
218 {
219 auto connectionStateItem = Init();
220 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
221 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
222 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
223 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
224 ConnectionData data;
225 ConnectionEvent event;
226 auto res = connectionStateItem->AddConnection(record, data, event);
227 EXPECT_TRUE(res);
228 }
229
230 /*
231 * Feature: ConnectionStateItem
232 * Function: AddConnection
233 * SubFunction: NA
234 * FunctionPoints: ConnectionStateItem AddConnection
235 * EnvConditions: NA
236 * CaseDescription: Verify AddConnection
237 */
238 HWTEST_F(ConnectionStateItemTest, AddConnection_005, TestSize.Level1)
239 {
240 auto connectionStateItem = Init();
241 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
242 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
243 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
244 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
245 ConnectionData data;
246 ConnectionEvent event;
247 connectionStateItem->connectionMap_[abilityRecord->GetToken()] = nullptr;
248 auto res = connectionStateItem->AddConnection(record, data, event);
249 EXPECT_FALSE(res);
250 }
251
252 /*
253 * Feature: ConnectionStateItem
254 * Function: RemoveConnection
255 * SubFunction: NA
256 * FunctionPoints: ConnectionStateItem RemoveConnection
257 * EnvConditions: NA
258 * CaseDescription: Verify RemoveConnection
259 */
260 HWTEST_F(ConnectionStateItemTest, RemoveConnection_001, TestSize.Level1)
261 {
262 auto connectionStateItem = Init();
263 std::shared_ptr<ConnectionRecord> record = nullptr;
264 ConnectionData data;
265 ConnectionEvent event;
266 auto res = connectionStateItem->RemoveConnection(record, data, event);
267 EXPECT_FALSE(res);
268 }
269
270 /*
271 * Feature: ConnectionStateItem
272 * Function: RemoveConnection
273 * SubFunction: NA
274 * FunctionPoints: ConnectionStateItem RemoveConnection
275 * EnvConditions: NA
276 * CaseDescription: Verify RemoveConnection
277 */
278 HWTEST_F(ConnectionStateItemTest, RemoveConnection_002, TestSize.Level1)
279 {
280 auto connectionStateItem = Init();
281 sptr<IRemoteObject> callerToken;
282 std::shared_ptr<AbilityRecord> abilityRecord;
283 sptr<IAbilityConnection> connCallback;
284 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
285 callerToken, abilityRecord, connCallback, nullptr);
286 ConnectionData data;
287 ConnectionEvent event;
288 auto res = connectionStateItem->RemoveConnection(record, data, event);
289 EXPECT_FALSE(res);
290 }
291
292 /*
293 * Feature: ConnectionStateItem
294 * Function: RemoveConnection
295 * SubFunction: NA
296 * FunctionPoints: ConnectionStateItem RemoveConnection
297 * EnvConditions: NA
298 * CaseDescription: Verify RemoveConnection
299 */
300 HWTEST_F(ConnectionStateItemTest, RemoveConnection_003, TestSize.Level1)
301 {
302 auto connectionStateItem = Init();
303 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
304 sptr<IAbilityConnection> connCallback;
305 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
306 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
307 ConnectionData data;
308 ConnectionEvent event;
309 auto res = connectionStateItem->RemoveConnection(record, data, event);
310 EXPECT_FALSE(res);
311 }
312
313 /*
314 * Feature: ConnectionStateItem
315 * Function: RemoveConnection
316 * SubFunction: NA
317 * FunctionPoints: ConnectionStateItem RemoveConnection
318 * EnvConditions: NA
319 * CaseDescription: Verify RemoveConnection
320 */
321 HWTEST_F(ConnectionStateItemTest, RemoveConnection_004, TestSize.Level1)
322 {
323 auto connectionStateItem = Init();
324 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
325 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
326 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
327 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
328 ConnectionData data;
329 ConnectionEvent event;
330 auto res = connectionStateItem->RemoveConnection(record, data, event);
331 EXPECT_FALSE(res);
332 }
333
334 /*
335 * Feature: ConnectionStateItem
336 * Function: RemoveConnection
337 * SubFunction: NA
338 * FunctionPoints: ConnectionStateItem RemoveConnection
339 * EnvConditions: NA
340 * CaseDescription: Verify RemoveConnection
341 */
342 HWTEST_F(ConnectionStateItemTest, RemoveConnection_005, TestSize.Level1)
343 {
344 auto connectionStateItem = Init();
345 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
346 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
347 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
348 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
349 ConnectionData data;
350 ConnectionEvent event;
351 connectionStateItem->connectionMap_[abilityRecord->GetToken()] = nullptr;
352 auto res = connectionStateItem->RemoveConnection(record, data, event);
353 EXPECT_FALSE(res);
354 }
355
356 /*
357 * Feature: ConnectionStateItem
358 * Function: RemoveConnection
359 * SubFunction: NA
360 * FunctionPoints: ConnectionStateItem RemoveConnection
361 * EnvConditions: NA
362 * CaseDescription: Verify RemoveConnection
363 */
364 HWTEST_F(ConnectionStateItemTest, RemoveConnection_006, TestSize.Level1)
365 {
366 auto connectionStateItem = Init();
367 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
368 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
369 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
370 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
371 ConnectionData data;
372 ConnectionEvent event;
373 connectionStateItem->AddConnection(record, data, event);
374 auto res = connectionStateItem->RemoveConnection(record, data, event);
375 EXPECT_TRUE(res);
376 }
377
378 /*
379 * Feature: ConnectionStateItem
380 * Function: RemoveConnection
381 * SubFunction: NA
382 * FunctionPoints: ConnectionStateItem RemoveConnection
383 * EnvConditions: NA
384 * CaseDescription: Verify RemoveConnection
385 */
386 HWTEST_F(ConnectionStateItemTest, RemoveConnection_007, TestSize.Level1)
387 {
388 auto connectionStateItem = Init();
389 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
390 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
391 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
392 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
393 ConnectionData data;
394 ConnectionEvent event;
395 connectionStateItem->AddConnection(record, data, event);
396 connectionStateItem->SuspendConnection(record, data);
397 connectionStateItem->AddConnection(record, data, event);
398 auto res = connectionStateItem->RemoveConnection(record, data, event);
399 EXPECT_TRUE(res);
400 }
401
402 /*
403 * Feature: ConnectionStateItem
404 * Function: RemoveConnection
405 * SubFunction: NA
406 * FunctionPoints: ConnectionStateItem RemoveConnection
407 * EnvConditions: NA
408 * CaseDescription: Verify RemoveConnection
409 */
410 HWTEST_F(ConnectionStateItemTest, RemoveConnection_008, TestSize.Level1)
411 {
412 auto connectionStateItem = Init();
413 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
414 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
415 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
416 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
417 ConnectionData data;
418 ConnectionEvent event;
419 connectionStateItem->AddConnection(record, data, event);
420 sptr<IAbilityConnection> connCallback1 = new MyAbilityConnection();
421 std::shared_ptr<ConnectionRecord> record1 = std::make_shared<ConnectionRecord>(
422 abilityRecord->GetToken(), abilityRecord, connCallback1, nullptr);
423 connectionStateItem->AddConnection(record, data, event);
424 connectionStateItem->SuspendConnection(record, data);
425 connectionStateItem->SuspendConnection(record, data);
426 auto res = connectionStateItem->RemoveConnection(record, data, event);
427 EXPECT_TRUE(res);
428 }
429
430 /*
431 * Feature: ConnectionStateItem
432 * Function: RemoveConnection
433 * SubFunction: NA
434 * FunctionPoints: ConnectionStateItem RemoveConnection
435 * EnvConditions: NA
436 * CaseDescription: Verify RemoveConnection
437 */
438 HWTEST_F(ConnectionStateItemTest, RemoveConnection_009, TestSize.Level1)
439 {
440 auto connectionStateItem = Init();
441 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
442 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
443 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
444 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
445 ConnectionData data;
446 ConnectionEvent event;
447 connectionStateItem->AddConnection(record, data, event);
448 sptr<IAbilityConnection> connCallback1 = new MyAbilityConnection();
449 std::shared_ptr<ConnectionRecord> record1 = std::make_shared<ConnectionRecord>(
450 abilityRecord->GetToken(), abilityRecord, connCallback1, nullptr);
451 connectionStateItem->AddConnection(record1, data, event);
452 connectionStateItem->SuspendConnection(record, data);
453 auto res = connectionStateItem->RemoveConnection(record1, data, event);
454 EXPECT_TRUE(res);
455 }
456
457 /*
458 * Feature: ConnectionStateItem
459 * Function: RemoveConnection
460 * SubFunction: NA
461 * FunctionPoints: ConnectionStateItem RemoveConnection
462 * EnvConditions: NA
463 * CaseDescription: Verify RemoveConnection
464 */
465 HWTEST_F(ConnectionStateItemTest, RemoveConnection_010, TestSize.Level1)
466 {
467 auto connectionStateItem = Init();
468 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
469 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
470 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
471 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
472 ConnectionData data;
473 ConnectionEvent event;
474 connectionStateItem->AddConnection(record, data, event);
475 sptr<IAbilityConnection> connCallback1 = new MyAbilityConnection();
476 std::shared_ptr<ConnectionRecord> record1 = std::make_shared<ConnectionRecord>(
477 abilityRecord->GetToken(), abilityRecord, connCallback1, nullptr);
478 connectionStateItem->AddConnection(record1, data, event);
479 auto res = connectionStateItem->RemoveConnection(record1, data, event);
480 EXPECT_FALSE(res);
481 }
482
483 /*
484 * Feature: ConnectionStateItem
485 * Function: RemoveConnection
486 * SubFunction: NA
487 * FunctionPoints: ConnectionStateItem RemoveConnection
488 * EnvConditions: NA
489 * CaseDescription: Verify RemoveConnection
490 */
491 HWTEST_F(ConnectionStateItemTest, RemoveConnection_011, TestSize.Level1)
492 {
493 auto connectionStateItem = Init();
494 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
495 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
496 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
497 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
498 ConnectionData data;
499 ConnectionEvent event;
500 connectionStateItem->AddConnection(record, data, event);
501 sptr<IAbilityConnection> connCallback1 = new MyAbilityConnection();
502 std::shared_ptr<ConnectionRecord> record1 = std::make_shared<ConnectionRecord>(
503 abilityRecord->GetToken(), abilityRecord, connCallback1, nullptr);
504 connectionStateItem->AddConnection(record1, data, event);
505 connectionStateItem->SuspendConnection(record, data);
506 auto res = connectionStateItem->RemoveConnection(record, data, event);
507 EXPECT_FALSE(res);
508 }
509
510 /*
511 * Feature: ConnectionStateItem
512 * Function: RemoveConnection
513 * SubFunction: NA
514 * FunctionPoints: ConnectionStateItem RemoveConnection
515 * EnvConditions: NA
516 * CaseDescription: Verify RemoveConnection
517 */
518 HWTEST_F(ConnectionStateItemTest, RemoveConnection_012, TestSize.Level1)
519 {
520 auto connectionStateItem = Init();
521 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
522 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
523 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
524 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
525 ConnectionData data;
526 ConnectionEvent event;
527 connectionStateItem->AddConnection(record, data, event);
528 sptr<IAbilityConnection> connCallback1 = new MyAbilityConnection();
529 std::shared_ptr<ConnectionRecord> record1 = std::make_shared<ConnectionRecord>(
530 abilityRecord->GetToken(), abilityRecord, connCallback1, nullptr);
531 connectionStateItem->AddConnection(record1, data, event);
532 connectionStateItem->SuspendConnection(record, data);
533 auto res = connectionStateItem->RemoveConnection(record1, data, event);
534 EXPECT_TRUE(res);
535 }
536
537 /*
538 * Feature: ConnectionStateItem
539 * Function: SuspendConnection
540 * SubFunction: NA
541 * FunctionPoints: ConnectionStateItem SuspendConnection
542 * EnvConditions: NA
543 * CaseDescription: Verify SuspendConnection
544 */
545 HWTEST_F(ConnectionStateItemTest, SuspendConnection_001, TestSize.Level1)
546 {
547 auto connectionStateItem = Init();
548 std::shared_ptr<ConnectionRecord> record = nullptr;
549 ConnectionData data;
550 auto res = connectionStateItem->SuspendConnection(record, data);
551 EXPECT_FALSE(res);
552 }
553
554 /*
555 * Feature: ConnectionStateItem
556 * Function: SuspendConnection
557 * SubFunction: NA
558 * FunctionPoints: ConnectionStateItem SuspendConnection
559 * EnvConditions: NA
560 * CaseDescription: Verify SuspendConnection
561 */
562 HWTEST_F(ConnectionStateItemTest, SuspendConnection_002, TestSize.Level1)
563 {
564 auto connectionStateItem = Init();
565 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
566 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
567 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
568 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
569 ConnectionData data;
570 ConnectionEvent event;
571 connectionStateItem->AddConnection(record, data, event);
572 auto res = connectionStateItem->SuspendConnection(record, data);
573 EXPECT_TRUE(res);
574 }
575
576 /*
577 * Feature: ConnectionStateItem
578 * Function: SuspendConnection
579 * SubFunction: NA
580 * FunctionPoints: ConnectionStateItem SuspendConnection
581 * EnvConditions: NA
582 * CaseDescription: Verify SuspendConnection
583 */
584 HWTEST_F(ConnectionStateItemTest, SuspendConnection_003, TestSize.Level1)
585 {
586 auto connectionStateItem = Init();
587 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
588 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
589 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
590 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
591 ConnectionData data;
592 ConnectionEvent event;
593 connectionStateItem->AddConnection(record, data, event);
594 connectionStateItem->SuspendConnection(record, data);
595 auto res = connectionStateItem->SuspendConnection(record, data);
596 EXPECT_FALSE(res);
597 }
598
599 /*
600 * Feature: ConnectionStateItem
601 * Function: SuspendConnection
602 * SubFunction: NA
603 * FunctionPoints: ConnectionStateItem SuspendConnection
604 * EnvConditions: NA
605 * CaseDescription: Verify SuspendConnection
606 */
607 HWTEST_F(ConnectionStateItemTest, SuspendConnection_004, TestSize.Level1)
608 {
609 auto connectionStateItem = Init();
610 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
611 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
612 abilityRecord->GetToken(), abilityRecord, nullptr, nullptr);
613 ConnectionData data;
614 auto res = connectionStateItem->SuspendConnection(record, data);
615 EXPECT_FALSE(res);
616 }
617
618 /*
619 * Feature: ConnectionStateItem
620 * Function: SuspendConnection
621 * SubFunction: NA
622 * FunctionPoints: ConnectionStateItem SuspendConnection
623 * EnvConditions: NA
624 * CaseDescription: Verify SuspendConnection
625 */
626 HWTEST_F(ConnectionStateItemTest, SuspendConnection_005, TestSize.Level1)
627 {
628 auto connectionStateItem = Init();
629 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
630 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
631 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
632 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
633 ConnectionData data;
634 auto res = connectionStateItem->SuspendConnection(record, data);
635 EXPECT_FALSE(res);
636 }
637
638 /*
639 * Feature: ConnectionStateItem
640 * Function: SuspendConnection
641 * SubFunction: NA
642 * FunctionPoints: ConnectionStateItem SuspendConnection
643 * EnvConditions: NA
644 * CaseDescription: Verify SuspendConnection
645 */
646 HWTEST_F(ConnectionStateItemTest, SuspendConnection_006, TestSize.Level1)
647 {
648 auto connectionStateItem = Init();
649 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
650 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
651 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
652 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
653 ConnectionData data;
654 ConnectionEvent event;
655 connectionStateItem->AddConnection(record, data, event);
656 connectionStateItem->connectionMap_[abilityRecord->GetToken()] = nullptr;
657 auto res = connectionStateItem->SuspendConnection(record, data);
658 EXPECT_FALSE(res);
659 }
660
661 /*
662 * Feature: ConnectionStateItem
663 * Function: ResumeConnection
664 * SubFunction: NA
665 * FunctionPoints: ConnectionStateItem ResumeConnection
666 * EnvConditions: NA
667 * CaseDescription: Verify ResumeConnection
668 */
669 HWTEST_F(ConnectionStateItemTest, ResumeConnection_001, TestSize.Level1)
670 {
671 auto connectionStateItem = Init();
672 std::shared_ptr<ConnectionRecord> record = nullptr;
673 ConnectionData data;
674 auto res = connectionStateItem->ResumeConnection(record, data);
675 EXPECT_FALSE(res);
676 }
677
678 /*
679 * Feature: ConnectionStateItem
680 * Function: ResumeConnection
681 * SubFunction: NA
682 * FunctionPoints: ConnectionStateItem ResumeConnection
683 * EnvConditions: NA
684 * CaseDescription: Verify ResumeConnection
685 */
686 HWTEST_F(ConnectionStateItemTest, ResumeConnection_002, TestSize.Level1)
687 {
688 auto connectionStateItem = Init();
689 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
690 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
691 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
692 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
693 ConnectionData data;
694 ConnectionEvent event;
695 connectionStateItem->AddConnection(record, data, event);
696 auto res = connectionStateItem->ResumeConnection(record, data);
697 EXPECT_FALSE(res);
698 }
699
700 /*
701 * Feature: ConnectionStateItem
702 * Function: ResumeConnection
703 * SubFunction: NA
704 * FunctionPoints: ConnectionStateItem ResumeConnection
705 * EnvConditions: NA
706 * CaseDescription: Verify ResumeConnection
707 */
708 HWTEST_F(ConnectionStateItemTest, ResumeConnection_003, TestSize.Level1)
709 {
710 auto connectionStateItem = Init();
711 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
712 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
713 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
714 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
715 ConnectionData data;
716 ConnectionEvent event;
717 connectionStateItem->AddConnection(record, data, event);
718 connectionStateItem->SuspendConnection(record, data);
719 auto res = connectionStateItem->ResumeConnection(record, data);
720 EXPECT_TRUE(res);
721 }
722
723 /*
724 * Feature: ConnectionStateItem
725 * Function: ResumeConnection
726 * SubFunction: NA
727 * FunctionPoints: ConnectionStateItem ResumeConnection
728 * EnvConditions: NA
729 * CaseDescription: Verify ResumeConnection
730 */
731 HWTEST_F(ConnectionStateItemTest, ResumeConnection_004, TestSize.Level1)
732 {
733 auto connectionStateItem = Init();
734 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
735 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
736 abilityRecord->GetToken(), abilityRecord, nullptr, nullptr);
737 ConnectionData data;
738 auto res = connectionStateItem->ResumeConnection(record, data);
739 EXPECT_FALSE(res);
740 }
741
742 /*
743 * Feature: ConnectionStateItem
744 * Function: ResumeConnection
745 * SubFunction: NA
746 * FunctionPoints: ConnectionStateItem ResumeConnection
747 * EnvConditions: NA
748 * CaseDescription: Verify ResumeConnection
749 */
750 HWTEST_F(ConnectionStateItemTest, ResumeConnection_005, TestSize.Level1)
751 {
752 auto connectionStateItem = Init();
753 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
754 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
755 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
756 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
757 ConnectionData data;
758 ConnectionEvent event;
759 connectionStateItem->AddConnection(record, data, event);
760 connectionStateItem->SuspendConnection(record, data);
761 connectionStateItem->ResumeConnection(record, data);
762 auto res = connectionStateItem->ResumeConnection(record, data);
763 EXPECT_FALSE(res);
764 }
765
766 /*
767 * Feature: ConnectionStateItem
768 * Function: ResumeConnection
769 * SubFunction: NA
770 * FunctionPoints: ConnectionStateItem ResumeConnection
771 * EnvConditions: NA
772 * CaseDescription: Verify ResumeConnection
773 */
774 HWTEST_F(ConnectionStateItemTest, ResumeConnection_006, TestSize.Level1)
775 {
776 auto connectionStateItem = Init();
777 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
778 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
779 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
780 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
781 ConnectionData data;
782 auto res = connectionStateItem->ResumeConnection(record, data);
783 EXPECT_FALSE(res);
784 }
785
786 /*
787 * Feature: ConnectionStateItem
788 * Function: ResumeConnection
789 * SubFunction: NA
790 * FunctionPoints: ConnectionStateItem ResumeConnection
791 * EnvConditions: NA
792 * CaseDescription: Verify ResumeConnection
793 */
794 HWTEST_F(ConnectionStateItemTest, ResumeConnection_007, TestSize.Level1)
795 {
796 auto connectionStateItem = Init();
797 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
798 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
799 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
800 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
801 ConnectionData data;
802 ConnectionEvent event;
803 connectionStateItem->AddConnection(record, data, event);
804 connectionStateItem->connectionMap_[abilityRecord->GetToken()] = nullptr;
805 auto res = connectionStateItem->ResumeConnection(record, data);
806 EXPECT_FALSE(res);
807 }
808
809 /*
810 * Feature: ConnectionStateItem
811 * Function: ResumeConnection
812 * SubFunction: NA
813 * FunctionPoints: ConnectionStateItem ResumeConnection
814 * EnvConditions: NA
815 * CaseDescription: Verify ResumeConnection
816 */
817 HWTEST_F(ConnectionStateItemTest, ResumeConnection_008, TestSize.Level1)
818 {
819 auto connectionStateItem = Init();
820 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
821 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
822 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
823 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
824 ConnectionData data;
825 ConnectionEvent event;
826 connectionStateItem->AddConnection(record, data, event);
827 connectionStateItem->SuspendConnection(record, data);
828 connectionStateItem->ResumeConnection(record, data);
829 auto res = connectionStateItem->ResumeConnection(record, data);
830 EXPECT_FALSE(res);
831 }
832
833 /*
834 * Feature: ConnectionStateItem
835 * Function: AddDataAbilityConnection
836 * SubFunction: NA
837 * FunctionPoints: ConnectionStateItem AddDataAbilityConnection
838 * EnvConditions: NA
839 * CaseDescription: Verify AddDataAbilityConnection
840 */
841 HWTEST_F(ConnectionStateItemTest, AddDataAbilityConnection_001, TestSize.Level1)
842 {
843 auto connectionStateItem = Init();
844 DataAbilityCaller caller;
845 std::shared_ptr<DataAbilityRecord> dataAbility;
846 ConnectionData data;
847 auto res = connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
848 EXPECT_FALSE(res);
849 }
850
851 /*
852 * Feature: ConnectionStateItem
853 * Function: AddDataAbilityConnection
854 * SubFunction: NA
855 * FunctionPoints: ConnectionStateItem AddDataAbilityConnection
856 * EnvConditions: NA
857 * CaseDescription: Verify AddDataAbilityConnection
858 */
859 HWTEST_F(ConnectionStateItemTest, AddDataAbilityConnection_002, TestSize.Level1)
860 {
861 auto connectionStateItem = Init();
862 DataAbilityCaller caller;
863 std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
864 ConnectionData data;
865 auto res = connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
866 EXPECT_FALSE(res);
867 }
868
869 /*
870 * Feature: ConnectionStateItem
871 * Function: AddDataAbilityConnection
872 * SubFunction: NA
873 * FunctionPoints: ConnectionStateItem AddDataAbilityConnection
874 * EnvConditions: NA
875 * CaseDescription: Verify AddDataAbilityConnection
876 */
877 HWTEST_F(ConnectionStateItemTest, AddDataAbilityConnection_003, TestSize.Level1)
878 {
879 auto connectionStateItem = Init();
880 DataAbilityCaller caller;
881 std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
882 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
883 caller.isNotHap = true;
884 caller.callerToken = abilityRecord->GetToken();
885 dataAbility->ability_ = abilityRecord;
886 ConnectionData data;
887 auto res = connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
888 EXPECT_TRUE(res);
889 }
890
891 /*
892 * Feature: ConnectionStateItem
893 * Function: AddDataAbilityConnection
894 * SubFunction: NA
895 * FunctionPoints: ConnectionStateItem AddDataAbilityConnection
896 * EnvConditions: NA
897 * CaseDescription: Verify AddDataAbilityConnection
898 */
899 HWTEST_F(ConnectionStateItemTest, AddDataAbilityConnection_004, TestSize.Level1)
900 {
901 auto connectionStateItem = Init();
902 DataAbilityCaller caller;
903 std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
904 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
905 dataAbility->ability_ = abilityRecord;
906 connectionStateItem->dataAbilityMap_.emplace(abilityRecord->GetToken(), nullptr);
907 ConnectionData data;
908 auto res = connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
909 EXPECT_FALSE(res);
910 }
911
912 /*
913 * Feature: ConnectionStateItem
914 * Function: AddDataAbilityConnection
915 * SubFunction: NA
916 * FunctionPoints: ConnectionStateItem AddDataAbilityConnection
917 * EnvConditions: NA
918 * CaseDescription: Verify AddDataAbilityConnection
919 */
920 HWTEST_F(ConnectionStateItemTest, AddDataAbilityConnection_005, TestSize.Level1)
921 {
922 auto connectionStateItem = Init();
923 DataAbilityCaller caller;
924 std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
925 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
926 caller.isNotHap = true;
927 caller.callerToken = abilityRecord->GetToken();
928 dataAbility->ability_ = abilityRecord;
929 ConnectionData data;
930 connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
931 caller.isNotHap = false;
932 auto res1 = connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
933 EXPECT_FALSE(res1);
934 caller.callerToken = nullptr;
935 auto res2 = connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
936 EXPECT_FALSE(res2);
937 }
938
939 /*
940 * Feature: ConnectionStateItem
941 * Function: RemoveDataAbilityConnection
942 * SubFunction: NA
943 * FunctionPoints: ConnectionStateItem RemoveDataAbilityConnection
944 * EnvConditions: NA
945 * CaseDescription: Verify RemoveDataAbilityConnection
946 */
947 HWTEST_F(ConnectionStateItemTest, RemoveDataAbilityConnection_001, TestSize.Level1)
948 {
949 auto connectionStateItem = Init();
950 DataAbilityCaller caller;
951 std::shared_ptr<DataAbilityRecord> dataAbility;
952 ConnectionData data;
953 auto res = connectionStateItem->RemoveDataAbilityConnection(caller, dataAbility, data);
954 EXPECT_FALSE(res);
955 }
956
957 /*
958 * Feature: ConnectionStateItem
959 * Function: RemoveDataAbilityConnection
960 * SubFunction: NA
961 * FunctionPoints: ConnectionStateItem RemoveDataAbilityConnection
962 * EnvConditions: NA
963 * CaseDescription: Verify RemoveDataAbilityConnection
964 */
965 HWTEST_F(ConnectionStateItemTest, RemoveDataAbilityConnection_002, TestSize.Level1)
966 {
967 auto connectionStateItem = Init();
968 DataAbilityCaller caller;
969 std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
970 ConnectionData data;
971 auto res = connectionStateItem->RemoveDataAbilityConnection(caller, dataAbility, data);
972 EXPECT_FALSE(res);
973 }
974
975 /*
976 * Feature: ConnectionStateItem
977 * Function: RemoveDataAbilityConnection
978 * SubFunction: NA
979 * FunctionPoints: ConnectionStateItem RemoveDataAbilityConnection
980 * EnvConditions: NA
981 * CaseDescription: Verify RemoveDataAbilityConnection
982 */
983 HWTEST_F(ConnectionStateItemTest, RemoveDataAbilityConnection_003, TestSize.Level1)
984 {
985 auto connectionStateItem = Init();
986 DataAbilityCaller caller;
987 std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
988 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
989 dataAbility->ability_ = abilityRecord;
990 ConnectionData data;
991 auto res = connectionStateItem->RemoveDataAbilityConnection(caller, dataAbility, data);
992 EXPECT_FALSE(res);
993 }
994
995 /*
996 * Feature: ConnectionStateItem
997 * Function: RemoveDataAbilityConnection
998 * SubFunction: NA
999 * FunctionPoints: ConnectionStateItem RemoveDataAbilityConnection
1000 * EnvConditions: NA
1001 * CaseDescription: Verify RemoveDataAbilityConnection
1002 */
1003 HWTEST_F(ConnectionStateItemTest, RemoveDataAbilityConnection_004, TestSize.Level1)
1004 {
1005 auto connectionStateItem = Init();
1006 DataAbilityCaller caller;
1007 std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
1008 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1009 dataAbility->ability_ = abilityRecord;
1010 connectionStateItem->dataAbilityMap_.emplace(abilityRecord->GetToken(), nullptr);
1011 ConnectionData data;
1012 auto res = connectionStateItem->RemoveDataAbilityConnection(caller, dataAbility, data);
1013 EXPECT_FALSE(res);
1014 }
1015
1016 /*
1017 * Feature: ConnectionStateItem
1018 * Function: RemoveDataAbilityConnection
1019 * SubFunction: NA
1020 * FunctionPoints: ConnectionStateItem RemoveDataAbilityConnection
1021 * EnvConditions: NA
1022 * CaseDescription: Verify RemoveDataAbilityConnection
1023 */
1024 HWTEST_F(ConnectionStateItemTest, RemoveDataAbilityConnection_005, TestSize.Level1)
1025 {
1026 auto connectionStateItem = Init();
1027 DataAbilityCaller caller;
1028 std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
1029 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1030 caller.isNotHap = false;
1031 caller.callerToken = nullptr;
1032 dataAbility->ability_ = abilityRecord;
1033 ConnectionData data;
1034 connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
1035 auto res = connectionStateItem->RemoveDataAbilityConnection(caller, dataAbility, data);
1036 EXPECT_FALSE(res);
1037 }
1038
1039 /*
1040 * Feature: ConnectionStateItem
1041 * Function: RemoveDataAbilityConnection
1042 * SubFunction: NA
1043 * FunctionPoints: ConnectionStateItem RemoveDataAbilityConnection
1044 * EnvConditions: NA
1045 * CaseDescription: Verify RemoveDataAbilityConnection
1046 */
1047 HWTEST_F(ConnectionStateItemTest, RemoveDataAbilityConnection_006, TestSize.Level1)
1048 {
1049 auto connectionStateItem = Init();
1050 DataAbilityCaller caller;
1051 std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
1052 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1053 caller.isNotHap = true;
1054 caller.callerToken = abilityRecord->GetToken();
1055 dataAbility->ability_ = abilityRecord;
1056 ConnectionData data;
1057 connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
1058 auto res = connectionStateItem->RemoveDataAbilityConnection(caller, dataAbility, data);
1059 EXPECT_TRUE(res);
1060 }
1061
1062 /*
1063 * Feature: ConnectionStateItem
1064 * Function: HandleDataAbilityDied
1065 * SubFunction: NA
1066 * FunctionPoints: ConnectionStateItem HandleDataAbilityDied
1067 * EnvConditions: NA
1068 * CaseDescription: Verify HandleDataAbilityDied
1069 */
1070 HWTEST_F(ConnectionStateItemTest, HandleDataAbilityDied_001, TestSize.Level1)
1071 {
1072 auto connectionStateItem = Init();
1073 sptr<IRemoteObject> token;
1074 ConnectionData data;
1075 auto res = connectionStateItem->HandleDataAbilityDied(token, data);
1076 EXPECT_FALSE(res);
1077 }
1078
1079 /*
1080 * Feature: ConnectionStateItem
1081 * Function: HandleDataAbilityDied
1082 * SubFunction: NA
1083 * FunctionPoints: ConnectionStateItem HandleDataAbilityDied
1084 * EnvConditions: NA
1085 * CaseDescription: Verify HandleDataAbilityDied
1086 */
1087 HWTEST_F(ConnectionStateItemTest, HandleDataAbilityDied_002, TestSize.Level1)
1088 {
1089 auto connectionStateItem = Init();
1090 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1091 sptr<IRemoteObject> token = abilityRecord->GetToken();
1092 ConnectionData data;
1093 auto res = connectionStateItem->HandleDataAbilityDied(token, data);
1094 EXPECT_FALSE(res);
1095 }
1096
1097 /*
1098 * Feature: ConnectionStateItem
1099 * Function: HandleDataAbilityDied
1100 * SubFunction: NA
1101 * FunctionPoints: ConnectionStateItem HandleDataAbilityDied
1102 * EnvConditions: NA
1103 * CaseDescription: Verify HandleDataAbilityDied
1104 */
1105 HWTEST_F(ConnectionStateItemTest, HandleDataAbilityDied_003, TestSize.Level1)
1106 {
1107 auto connectionStateItem = Init();
1108 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1109 sptr<IRemoteObject> token = abilityRecord->GetToken();
1110 connectionStateItem->dataAbilityMap_.emplace(abilityRecord->GetToken(), nullptr);
1111 ConnectionData data;
1112 auto res = connectionStateItem->HandleDataAbilityDied(token, data);
1113 EXPECT_FALSE(res);
1114 }
1115
1116 /*
1117 * Feature: ConnectionStateItem
1118 * Function: HandleDataAbilityDied
1119 * SubFunction: NA
1120 * FunctionPoints: ConnectionStateItem HandleDataAbilityDied
1121 * EnvConditions: NA
1122 * CaseDescription: Verify HandleDataAbilityDied
1123 */
1124 HWTEST_F(ConnectionStateItemTest, HandleDataAbilityDied_004, TestSize.Level1)
1125 {
1126 auto connectionStateItem = Init();
1127 DataAbilityCaller caller;
1128 ConnectionData data;
1129 std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
1130 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1131 dataAbility->ability_ = abilityRecord;
1132 connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
1133 sptr<IRemoteObject> token = abilityRecord->GetToken();
1134 auto res = connectionStateItem->HandleDataAbilityDied(token, data);
1135 EXPECT_TRUE(res);
1136 }
1137
1138 /*
1139 * Feature: ConnectionStateItem
1140 * Function: IsEmpty
1141 * SubFunction: NA
1142 * FunctionPoints: ConnectionStateItem IsEmpty
1143 * EnvConditions: NA
1144 * CaseDescription: Verify IsEmpty
1145 */
1146 HWTEST_F(ConnectionStateItemTest, IsEmpty_001, TestSize.Level1)
1147 {
1148 auto connectionStateItem = Init();
1149 auto res = connectionStateItem->IsEmpty();
1150 EXPECT_TRUE(res);
1151 }
1152
1153 /*
1154 * Feature: ConnectionStateItem
1155 * Function: GenerateAllConnectionData
1156 * SubFunction: NA
1157 * FunctionPoints: ConnectionStateItem GenerateAllConnectionData
1158 * EnvConditions: NA
1159 * CaseDescription: Verify GenerateAllConnectionData
1160 */
1161 HWTEST_F(ConnectionStateItemTest, GenerateAllConnectionData_001, TestSize.Level1)
1162 {
1163 auto connectionStateItem = Init();
1164 std::vector<AbilityRuntime::ConnectionData> datas;
1165 std::shared_ptr<AbilityRecord> abilityRecord = InitAbilityRecord();
1166 sptr<IAbilityConnection> connCallback = new MyAbilityConnection();
1167 std::shared_ptr<ConnectionRecord> record = std::make_shared<ConnectionRecord>(
1168 abilityRecord->GetToken(), abilityRecord, connCallback, nullptr);
1169 ConnectionData data;
1170 ConnectionEvent event;
1171 DataAbilityCaller caller;
1172 std::shared_ptr<DataAbilityRecord> dataAbility = InitDataAbilityRecord();
1173 caller.isNotHap = true;
1174 caller.callerToken = abilityRecord->GetToken();
1175 dataAbility->ability_ = abilityRecord;
1176 connectionStateItem->AddConnection(record, data, event);
1177 connectionStateItem->AddDataAbilityConnection(caller, dataAbility, data);
1178 connectionStateItem->GenerateAllConnectionData(datas);
1179 EXPECT_TRUE(connectionStateItem != nullptr);
1180 }
1181 } // namespace AAFwk
1182 } // namespace OHOS
1183