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