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