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: AddConnection
177 * SubFunction: NA
178 * FunctionPoints: ConnectionStateManager AddConnection
179 * EnvConditions: NA
180 * CaseDescription: Verify AddConnection
181 */
182 HWTEST_F(ConnectionStateManagerTest, AddConnection_003, TestSize.Level1)
183 {
184 auto connectionRecord =
185 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
186 manager_->Init();
187 connectionRecord->callerPid_ = 0;
188 int32_t callerUid = 0;
189 int32_t callerPid = 0;
190 std::string callerName = "callerName";
191 manager_->connectionStates_[0] = std::make_shared<ConnectionStateItem>(callerUid, callerPid, callerName);
192 manager_->AddConnection(connectionRecord);
193 EXPECT_TRUE(manager_ != nullptr);
194 }
195
196 /*
197 * Feature: ConnectionStateManager
198 * Function: SuspendConnection
199 * SubFunction: NA
200 * FunctionPoints: ConnectionStateManager SuspendConnection
201 * EnvConditions: NA
202 * CaseDescription: Verify SuspendConnection
203 */
204 HWTEST_F(ConnectionStateManagerTest, SuspendConnection_001, TestSize.Level1)
205 {
206 std::shared_ptr<ConnectionRecord> connectionRecord = nullptr;
207 manager_->Init();
208 manager_->SuspendConnection(connectionRecord);
209 EXPECT_TRUE(manager_ != nullptr);
210 }
211
212 /*
213 * Feature: ConnectionStateManager
214 * Function: SuspendConnection
215 * SubFunction: NA
216 * FunctionPoints: ConnectionStateManager SuspendConnection
217 * EnvConditions: NA
218 * CaseDescription: Verify SuspendConnection
219 */
220 HWTEST_F(ConnectionStateManagerTest, SuspendConnection_002, TestSize.Level1)
221 {
222 auto connectionRecord =
223 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
224 manager_->Init();
225 connectionRecord->callerPid_ = 0;
226 int32_t callerUid = 0;
227 int32_t callerPid = 0;
228 std::string callerName = "callerName";
229 manager_->connectionStates_[0] = std::make_shared<ConnectionStateItem>(callerUid, callerPid, callerName);
230 manager_->AddConnection(connectionRecord);
231 manager_->SuspendConnection(connectionRecord);
232 EXPECT_TRUE(manager_ != nullptr);
233 }
234
235 /*
236 * Feature: ConnectionStateManager
237 * Function: SuspendConnection
238 * SubFunction: NA
239 * FunctionPoints: ConnectionStateManager SuspendConnection
240 * EnvConditions: NA
241 * CaseDescription: Verify SuspendConnection
242 */
243 HWTEST_F(ConnectionStateManagerTest, SuspendConnection_003, TestSize.Level1)
244 {
245 auto connectionRecord =
246 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
247 manager_->Init();
248 connectionRecord->callerPid_ = 0;
249 manager_->connectionStates_[0] = nullptr;
250 manager_->SuspendConnection(connectionRecord);
251 EXPECT_TRUE(manager_->connectionStates_[0] == nullptr);
252 }
253
254 /*
255 * Feature: ConnectionStateManager
256 * Function: SuspendConnection
257 * SubFunction: NA
258 * FunctionPoints: ConnectionStateManager SuspendConnection
259 * EnvConditions: NA
260 * CaseDescription: Verify SuspendConnection
261 */
262 HWTEST_F(ConnectionStateManagerTest, SuspendConnection_004, TestSize.Level1)
263 {
264 auto connectionRecord =
265 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
266 manager_->Init();
267 connectionRecord->callerPid_ = 0;
268 manager_->SuspendConnection(connectionRecord);
269 EXPECT_TRUE(manager_->connectionStates_.empty());
270 }
271
272 /*
273 * Feature: ConnectionStateManager
274 * Function: ResumeConnection
275 * SubFunction: NA
276 * FunctionPoints: ConnectionStateManager ResumeConnection
277 * EnvConditions: NA
278 * CaseDescription: Verify ResumeConnection
279 */
280 HWTEST_F(ConnectionStateManagerTest, ResumeConnection_001, TestSize.Level1)
281 {
282 std::shared_ptr<ConnectionRecord> connectionRecord = nullptr;
283 manager_->Init();
284 manager_->ResumeConnection(connectionRecord);
285 EXPECT_TRUE(manager_ != nullptr);
286 }
287
288 /*
289 * Feature: ConnectionStateManager
290 * Function: ResumeConnection
291 * SubFunction: NA
292 * FunctionPoints: ConnectionStateManager ResumeConnection
293 * EnvConditions: NA
294 * CaseDescription: Verify ResumeConnection
295 */
296 HWTEST_F(ConnectionStateManagerTest, ResumeConnection_002, TestSize.Level1)
297 {
298 auto connectionRecord =
299 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
300 manager_->Init();
301 connectionRecord->callerPid_ = 0;
302 int32_t callerUid = 0;
303 int32_t callerPid = 0;
304 std::string callerName = "callerName";
305 manager_->connectionStates_[0] = std::make_shared<ConnectionStateItem>(callerUid, callerPid, callerName);
306 manager_->ResumeConnection(connectionRecord);
307 manager_->AddConnection(connectionRecord);
308 manager_->ResumeConnection(connectionRecord);
309 manager_->SuspendConnection(connectionRecord);
310 manager_->ResumeConnection(connectionRecord);
311 EXPECT_TRUE(manager_ != nullptr);
312 }
313
314 /*
315 * Feature: ConnectionStateManager
316 * Function: ResumeConnection
317 * SubFunction: NA
318 * FunctionPoints: ConnectionStateManager ResumeConnection
319 * EnvConditions: NA
320 * CaseDescription: Verify ResumeConnection
321 */
322 HWTEST_F(ConnectionStateManagerTest, ResumeConnection_003, TestSize.Level1)
323 {
324 std::shared_ptr<ConnectionRecord> connectionRecord =
325 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
326 manager_->Init();
327 connectionRecord->callerPid_ = 0;
328 manager_->ResumeConnection(connectionRecord);
329 EXPECT_TRUE(manager_->connectionStates_.empty());
330 }
331
332 /*
333 * Feature: ConnectionStateManager
334 * Function: ResumeConnection
335 * SubFunction: NA
336 * FunctionPoints: ConnectionStateManager ResumeConnection
337 * EnvConditions: NA
338 * CaseDescription: Verify ResumeConnection
339 */
340 HWTEST_F(ConnectionStateManagerTest, ResumeConnection_004, TestSize.Level1)
341 {
342 std::shared_ptr<ConnectionRecord> connectionRecord =
343 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
344 manager_->Init();
345 connectionRecord->callerPid_ = 0;
346 manager_->connectionStates_[0] = nullptr;
347 manager_->ResumeConnection(connectionRecord);
348 EXPECT_TRUE(manager_->connectionStates_[0] == nullptr);
349 }
350
351 /*
352 * Feature: ConnectionStateManager
353 * Function: RemoveConnection
354 * SubFunction: NA
355 * FunctionPoints: ConnectionStateManager RemoveConnection
356 * EnvConditions: NA
357 * CaseDescription: Verify RemoveConnection
358 */
359 HWTEST_F(ConnectionStateManagerTest, RemoveConnection_001, TestSize.Level1)
360 {
361 std::shared_ptr<ConnectionRecord> connectionRecord = nullptr;
362 bool isCallerDied = false;
363 manager_->RemoveConnection(connectionRecord, isCallerDied);
364 EXPECT_TRUE(manager_ != nullptr);
365 }
366
367 /*
368 * Feature: ConnectionStateManager
369 * Function: RemoveConnection
370 * SubFunction: NA
371 * FunctionPoints: ConnectionStateManager RemoveConnection
372 * EnvConditions: NA
373 * CaseDescription: Verify RemoveConnection
374 */
375 HWTEST_F(ConnectionStateManagerTest, RemoveConnection_002, TestSize.Level1)
376 {
377 std::shared_ptr<ConnectionRecord> connectionRecord = nullptr;
378 bool isCallerDied = false;
379 manager_->Init();
380 manager_->RemoveConnection(connectionRecord, isCallerDied);
381 EXPECT_TRUE(manager_ != nullptr);
382 }
383
384 /*
385 * Feature: ConnectionStateManager
386 * Function: RemoveConnection
387 * SubFunction: NA
388 * FunctionPoints: ConnectionStateManager RemoveConnection
389 * EnvConditions: NA
390 * CaseDescription: Verify RemoveConnection
391 */
392 HWTEST_F(ConnectionStateManagerTest, RemoveConnection_003, TestSize.Level1)
393 {
394 auto connectionRecord =
395 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
396 bool isCallerDied = true;
397 manager_->Init();
398 manager_->RemoveConnection(connectionRecord, isCallerDied);
399 EXPECT_TRUE(manager_ != nullptr);
400 }
401
402 /*
403 * Feature: ConnectionStateManager
404 * Function: RemoveConnection
405 * SubFunction: NA
406 * FunctionPoints: ConnectionStateManager RemoveConnection
407 * EnvConditions: NA
408 * CaseDescription: Verify RemoveConnection
409 */
410 HWTEST_F(ConnectionStateManagerTest, RemoveConnection_004, TestSize.Level1)
411 {
412 auto connectionRecord =
413 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
414 bool isCallerDied = false;
415 manager_->Init();
416 manager_->RemoveConnection(connectionRecord, isCallerDied);
417 EXPECT_TRUE(manager_ != nullptr);
418 }
419
420 /*
421 * Feature: ConnectionStateManager
422 * Function: RemoveConnection
423 * SubFunction: NA
424 * FunctionPoints: ConnectionStateManager RemoveConnection
425 * EnvConditions: NA
426 * CaseDescription: Verify RemoveConnection
427 */
428 HWTEST_F(ConnectionStateManagerTest, RemoveConnection_005, TestSize.Level1)
429 {
430 std::shared_ptr<ConnectionRecord> connectionRecord =
431 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
432 bool isCallerDied = false;
433 manager_->Init();
434 manager_->AddConnection(connectionRecord);
435 manager_->RemoveConnection(connectionRecord, isCallerDied);
436 EXPECT_FALSE(manager_->connectionStates_.empty());
437 }
438
439 /*
440 * Feature: ConnectionStateManager
441 * Function: AddDataAbilityConnection
442 * SubFunction: NA
443 * FunctionPoints: ConnectionStateManager AddDataAbilityConnection
444 * EnvConditions: NA
445 * CaseDescription: Verify AddDataAbilityConnection
446 */
447 HWTEST_F(ConnectionStateManagerTest, AddDataAbilityConnection_001, TestSize.Level1)
448 {
449 DataAbilityCaller caller;
450 caller.callerPid = 1;
451 manager_->Init();
452 manager_->AddDataAbilityConnection(caller, dataAbilityRecord_);
453 EXPECT_TRUE(manager_ != nullptr);
454 }
455
456 /*
457 * Feature: ConnectionStateManager
458 * Function: RemoveDataAbilityConnection
459 * SubFunction: NA
460 * FunctionPoints: ConnectionStateManager RemoveDataAbilityConnection
461 * EnvConditions: NA
462 * CaseDescription: Verify RemoveDataAbilityConnection
463 */
464 HWTEST_F(ConnectionStateManagerTest, RemoveDataAbilityConnection_001, TestSize.Level1)
465 {
466 DataAbilityCaller caller;
467 caller.callerPid = 1;
468 manager_->Init();
469 manager_->RemoveDataAbilityConnection(caller, dataAbilityRecord_);
470 EXPECT_TRUE(manager_ != nullptr);
471 }
472
473 /*
474 * Feature: ConnectionStateManager
475 * Function: CheckDataAbilityConnectionParams
476 * SubFunction: NA
477 * FunctionPoints: ConnectionStateManager CheckDataAbilityConnectionParams
478 * EnvConditions: NA
479 * CaseDescription: Verify CheckDataAbilityConnectionParams
480 */
481 HWTEST_F(ConnectionStateManagerTest, CheckDataAbilityConnectionParams_001, TestSize.Level1)
482 {
483 DataAbilityCaller caller;
484 bool res = manager_->CheckDataAbilityConnectionParams(caller, dataAbilityRecord_);
485 EXPECT_FALSE(res);
486 }
487
488 /*
489 * Feature: ConnectionStateManager
490 * Function: CheckDataAbilityConnectionParams
491 * SubFunction: NA
492 * FunctionPoints: ConnectionStateManager CheckDataAbilityConnectionParams
493 * EnvConditions: NA
494 * CaseDescription: Verify CheckDataAbilityConnectionParams
495 */
496 HWTEST_F(ConnectionStateManagerTest, CheckDataAbilityConnectionParams_002, TestSize.Level1)
497 {
498 DataAbilityCaller caller;
499 std::shared_ptr<DataAbilityRecord> dataAbilityRecord = nullptr;
500 manager_->Init();
501 bool res = manager_->CheckDataAbilityConnectionParams(caller, dataAbilityRecord);
502 EXPECT_FALSE(res);
503 }
504
505 /*
506 * Feature: ConnectionStateManager
507 * Function: CheckDataAbilityConnectionParams
508 * SubFunction: NA
509 * FunctionPoints: ConnectionStateManager CheckDataAbilityConnectionParams
510 * EnvConditions: NA
511 * CaseDescription: Verify CheckDataAbilityConnectionParams
512 */
513 HWTEST_F(ConnectionStateManagerTest, CheckDataAbilityConnectionParams_003, TestSize.Level1)
514 {
515 DataAbilityCaller caller;
516 caller.callerPid = 0;
517 manager_->Init();
518 bool res = manager_->CheckDataAbilityConnectionParams(caller, dataAbilityRecord_);
519 EXPECT_FALSE(res);
520 }
521
522 /*
523 * Feature: ConnectionStateManager
524 * Function: CheckDataAbilityConnectionParams
525 * SubFunction: NA
526 * FunctionPoints: ConnectionStateManager CheckDataAbilityConnectionParams
527 * EnvConditions: NA
528 * CaseDescription: Verify CheckDataAbilityConnectionParams
529 */
530 HWTEST_F(ConnectionStateManagerTest, CheckDataAbilityConnectionParams_004, TestSize.Level1)
531 {
532 DataAbilityCaller caller;
533 caller.callerPid = 1;
534 manager_->Init();
535 bool res = manager_->CheckDataAbilityConnectionParams(caller, dataAbilityRecord_);
536 EXPECT_TRUE(res);
537 }
538
539 /*
540 * Feature: ConnectionStateManager
541 * Function: HandleDataAbilityDied
542 * SubFunction: NA
543 * FunctionPoints: ConnectionStateManager HandleDataAbilityDied
544 * EnvConditions: NA
545 * CaseDescription: Verify HandleDataAbilityDied
546 */
547 HWTEST_F(ConnectionStateManagerTest, HandleDataAbilityDied_001, TestSize.Level1)
548 {
549 std::shared_ptr<DataAbilityRecord> dataAbilityRecord = nullptr;
550 manager_->Init();
551 manager_->HandleDataAbilityDied(dataAbilityRecord);
552 EXPECT_TRUE(manager_ != nullptr);
553 }
554
555 /*
556 * Feature: ConnectionStateManager
557 * Function: HandleDataAbilityDied
558 * SubFunction: NA
559 * FunctionPoints: ConnectionStateManager HandleDataAbilityDied
560 * EnvConditions: NA
561 * CaseDescription: Verify HandleDataAbilityDied
562 */
563 HWTEST_F(ConnectionStateManagerTest, HandleDataAbilityDied_002, TestSize.Level1)
564 {
565 AbilityRequest abilityRequest;
566 std::shared_ptr<DataAbilityRecord> dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
567 dataAbilityRecord->ability_ = nullptr;
568 manager_->Init();
569 manager_->HandleDataAbilityDied(dataAbilityRecord);
570 EXPECT_TRUE(manager_ != nullptr);
571 }
572
573 /*
574 * Feature: ConnectionStateManager
575 * Function: HandleDataAbilityDied
576 * SubFunction: NA
577 * FunctionPoints: ConnectionStateManager HandleDataAbilityDied
578 * EnvConditions: NA
579 * CaseDescription: Verify HandleDataAbilityDied
580 */
581 HWTEST_F(ConnectionStateManagerTest, HandleDataAbilityDied_003, TestSize.Level1)
582 {
583 AbilityRequest abilityRequest;
584 std::shared_ptr<DataAbilityRecord> dataAbilityRecord = std::make_shared<DataAbilityRecord>(abilityRequest);
585 dataAbilityRecord->ability_ = abilityRecord_;
586 manager_->Init();
587 manager_->HandleDataAbilityDied(dataAbilityRecord);
588 EXPECT_TRUE(manager_ != nullptr);
589 }
590
591 /*
592 * Feature: ConnectionStateManager
593 * Function: HandleDataAbilityCallerDied
594 * SubFunction: NA
595 * FunctionPoints: ConnectionStateManager HandleDataAbilityCallerDied
596 * EnvConditions: NA
597 * CaseDescription: Verify HandleDataAbilityCallerDied
598 */
599 HWTEST_F(ConnectionStateManagerTest, HandleDataAbilityCallerDied_001, TestSize.Level1)
600 {
601 EXPECT_NE(manager_, nullptr);
602 int32_t callerPid = 0;
603 manager_->HandleDataAbilityCallerDied(callerPid);
604 }
605
606 /*
607 * Feature: ConnectionStateManager
608 * Function: HandleDataAbilityCallerDied
609 * SubFunction: NA
610 * FunctionPoints: ConnectionStateManager HandleDataAbilityCallerDied
611 * EnvConditions: NA
612 * CaseDescription: Verify HandleDataAbilityCallerDied
613 */
614 HWTEST_F(ConnectionStateManagerTest, HandleDataAbilityCallerDied_002, TestSize.Level1)
615 {
616 EXPECT_NE(manager_, nullptr);
617 int32_t callerPid = 1;
618 manager_->HandleDataAbilityCallerDied(callerPid);
619 }
620
621 #ifdef WITH_DLP
622 /*
623 * Feature: ConnectionStateManager
624 * Function: AddDlpManager
625 * SubFunction: NA
626 * FunctionPoints: ConnectionStateManager AddDlpManager
627 * EnvConditions: NA
628 * CaseDescription: Verify AddDlpManager
629 */
630 HWTEST_F(ConnectionStateManagerTest, AddDlpManager_001, TestSize.Level1)
631 {
632 EXPECT_NE(manager_, nullptr);
633 std::shared_ptr<AbilityRecord> dlpManger = nullptr;
634 manager_->AddDlpManager(dlpManger);
635 }
636
637 /*
638 * Feature: ConnectionStateManager
639 * Function: AddDlpManager
640 * SubFunction: NA
641 * FunctionPoints: ConnectionStateManager AddDlpManager
642 * EnvConditions: NA
643 * CaseDescription: Verify AddDlpManager
644 */
645 HWTEST_F(ConnectionStateManagerTest, AddDlpManager_002, TestSize.Level1)
646 {
647 EXPECT_NE(manager_, nullptr);
648 manager_->AddDlpManager(abilityRecord_);
649 }
650
651 /*
652 * Feature: ConnectionStateManager
653 * Function: AddDlpManager
654 * SubFunction: NA
655 * FunctionPoints: ConnectionStateManager AddDlpManager
656 * EnvConditions: NA
657 * CaseDescription: Verify AddDlpManager
658 */
659 HWTEST_F(ConnectionStateManagerTest, AddDlpManager_003, TestSize.Level1)
660 {
661 EXPECT_NE(manager_, nullptr);
662 auto abilityRecord = abilityRecord_;
663 abilityRecord->ownerMissionUserId_ = 1;
664 manager_->dlpItems_[abilityRecord->ownerMissionUserId_] = nullptr;
665 manager_->AddDlpManager(abilityRecord);
666 }
667
668 /*
669 * Feature: ConnectionStateManager
670 * Function: RemoveDlpManager
671 * SubFunction: NA
672 * FunctionPoints: ConnectionStateManager RemoveDlpManager
673 * EnvConditions: NA
674 * CaseDescription: Verify RemoveDlpManager
675 */
676 HWTEST_F(ConnectionStateManagerTest, RemoveDlpManager_001, TestSize.Level1)
677 {
678 EXPECT_NE(manager_, nullptr);
679 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
680 manager_->RemoveDlpManager(abilityRecord);
681 }
682
683 /*
684 * Feature: ConnectionStateManager
685 * Function: RemoveDlpManager
686 * SubFunction: NA
687 * FunctionPoints: ConnectionStateManager RemoveDlpManager
688 * EnvConditions: NA
689 * CaseDescription: Verify RemoveDlpManager
690 */
691 HWTEST_F(ConnectionStateManagerTest, RemoveDlpManager_002, TestSize.Level1)
692 {
693 EXPECT_NE(manager_, nullptr);
694 manager_->RemoveDlpManager(abilityRecord_);
695 }
696
697 /*
698 * Feature: ConnectionStateManager
699 * Function: AddDlpAbility
700 * SubFunction: NA
701 * FunctionPoints: ConnectionStateManager AddDlpAbility
702 * EnvConditions: NA
703 * CaseDescription: Verify AddDlpAbility
704 */
705 HWTEST_F(ConnectionStateManagerTest, AddDlpAbility_001, TestSize.Level1)
706 {
707 EXPECT_NE(manager_, nullptr);
708 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
709 manager_->AddDlpAbility(abilityRecord);
710 }
711
712 /*
713 * Feature: ConnectionStateManager
714 * Function: AddDlpAbility
715 * SubFunction: NA
716 * FunctionPoints: ConnectionStateManager AddDlpAbility
717 * EnvConditions: NA
718 * CaseDescription: Verify AddDlpAbility
719 */
720 HWTEST_F(ConnectionStateManagerTest, AddDlpAbility_002, TestSize.Level1)
721 {
722 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
723 manager_->Init();
724 manager_->AddDlpAbility(abilityRecord);
725 EXPECT_TRUE(manager_ != nullptr);
726 }
727
728 /*
729 * Feature: ConnectionStateManager
730 * Function: RemoveDlpAbility
731 * SubFunction: NA
732 * FunctionPoints: ConnectionStateManager RemoveDlpAbility
733 * EnvConditions: NA
734 * CaseDescription: Verify RemoveDlpAbility
735 */
736 HWTEST_F(ConnectionStateManagerTest, RemoveDlpAbility_001, TestSize.Level1)
737 {
738 EXPECT_NE(manager_, nullptr);
739 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
740 manager_->RemoveDlpAbility(abilityRecord);
741 }
742
743 /*
744 * Feature: ConnectionStateManager
745 * Function: RemoveDlpAbility
746 * SubFunction: NA
747 * FunctionPoints: ConnectionStateManager RemoveDlpAbility
748 * EnvConditions: NA
749 * CaseDescription: Verify RemoveDlpAbility
750 */
751 HWTEST_F(ConnectionStateManagerTest, RemoveDlpAbility_002, TestSize.Level1)
752 {
753 EXPECT_NE(manager_, nullptr);
754 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
755 manager_->Init();
756 manager_->RemoveDlpAbility(abilityRecord);
757 }
758 #endif // WITH_DLP
759
760 /*
761 * Feature: ConnectionStateManager
762 * Function: HandleAppDied
763 * SubFunction: NA
764 * FunctionPoints: ConnectionStateManager HandleAppDied
765 * EnvConditions: NA
766 * CaseDescription: Verify HandleAppDied
767 */
768 HWTEST_F(ConnectionStateManagerTest, HandleAppDied_001, TestSize.Level1)
769 {
770 EXPECT_NE(manager_, nullptr);
771 int32_t pid = 0;
772 manager_->HandleAppDied(pid);
773 }
774
775 #ifdef WITH_DLP
776 /*
777 * Feature: ConnectionStateManager
778 * Function: GetDlpConnectionInfos
779 * SubFunction: NA
780 * FunctionPoints: ConnectionStateManager GetDlpConnectionInfos
781 * EnvConditions: NA
782 * CaseDescription: Verify GetDlpConnectionInfos
783 */
784 HWTEST_F(ConnectionStateManagerTest, GetDlpConnectionInfos_001, TestSize.Level1)
785 {
786 EXPECT_NE(manager_, nullptr);
787 std::vector<DlpConnectionInfo> infos;
788 manager_->dlpItems_[0] = nullptr;
789 manager_->dlpItems_[1] = nullptr;
790 manager_->GetDlpConnectionInfos(infos);
791 }
792 #endif // WITH_DLP
793
794 /*
795 * Feature: ConnectionStateManager
796 * Function: GetConnectionData
797 * SubFunction: NA
798 * FunctionPoints: ConnectionStateManager GetConnectionData
799 * EnvConditions: NA
800 * CaseDescription: Verify GetConnectionData
801 */
802 HWTEST_F(ConnectionStateManagerTest, GetConnectionData_001, TestSize.Level1)
803 {
804 EXPECT_NE(manager_, nullptr);
805 std::vector<ConnectionData> connectionData;
806 manager_->connectionStates_[0] = nullptr;
807 manager_->connectionStates_[1] = nullptr;
808 manager_->GetConnectionData(connectionData);
809 }
810
811 /*
812 * Feature: ConnectionStateManager
813 * Function: AddConnectionInner
814 * SubFunction: NA
815 * FunctionPoints: ConnectionStateManager AddConnectionInner
816 * EnvConditions: NA
817 * CaseDescription: Verify AddConnectionInner
818 */
819 HWTEST_F(ConnectionStateManagerTest, AddConnectionInner_001, TestSize.Level1)
820 {
821 std::shared_ptr<ConnectionRecord> connectionRecord =
822 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
823 ConnectionData data;
824 ConnectionEvent event;
825 connectionRecord->callerPid_ = 0;
826 manager_->connectionStates_[0] = nullptr;
827 bool res = manager_->AddConnectionInner(connectionRecord, data, event);
828 EXPECT_FALSE(res);
829 }
830
831 /*
832 * Feature: ConnectionStateManager
833 * Function: AddConnectionInner
834 * SubFunction: NA
835 * FunctionPoints: ConnectionStateManager AddConnectionInner
836 * EnvConditions: NA
837 * CaseDescription: Verify AddConnectionInner
838 */
839 HWTEST_F(ConnectionStateManagerTest, AddConnectionInner_002, TestSize.Level1)
840 {
841 std::shared_ptr<ConnectionRecord> connectionRecord =
842 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
843 ConnectionData data;
844 ConnectionEvent event;
845 connectionRecord->callerPid_ = 0;
846 int32_t callerUid = 0;
847 int32_t callerPid = 0;
848 std::string callerName = "callerName";
849 manager_->connectionStates_[0] = std::make_shared<ConnectionStateItem>(callerUid, callerPid, callerName);;
850 bool res = manager_->AddConnectionInner(connectionRecord, data, event);
851 EXPECT_FALSE(res);
852 }
853
854 /*
855 * Feature: ConnectionStateManager
856 * Function: RemoveConnectionInner
857 * SubFunction: NA
858 * FunctionPoints: ConnectionStateManager RemoveConnectionInner
859 * EnvConditions: NA
860 * CaseDescription: Verify RemoveConnectionInner
861 */
862 HWTEST_F(ConnectionStateManagerTest, RemoveConnectionInner_001, TestSize.Level1)
863 {
864 std::shared_ptr<ConnectionRecord> connectionRecord =
865 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
866 ConnectionData data;
867 ConnectionEvent event;
868 connectionRecord->callerPid_ = 0;
869 manager_->connectionStates_[0] = nullptr;
870 bool res = manager_->RemoveConnectionInner(connectionRecord, data, event);
871 EXPECT_FALSE(res);
872 }
873
874 /*
875 * Feature: ConnectionStateManager
876 * Function: HandleCallerDied
877 * SubFunction: NA
878 * FunctionPoints: ConnectionStateManager HandleCallerDied
879 * EnvConditions: NA
880 * CaseDescription: Verify HandleCallerDied
881 */
882 HWTEST_F(ConnectionStateManagerTest, HandleCallerDied_001, TestSize.Level1)
883 {
884 EXPECT_NE(manager_, nullptr);
885 std::shared_ptr<ConnectionRecord> connectionRecord =
886 ConnectionRecord::CreateConnectionRecord(abilityRecord_->GetToken(), abilityRecord_, callback_, nullptr);
887 EXPECT_NE(connectionRecord, nullptr);
888 int32_t callerUid = 0;
889 int32_t callerPid = 0;
890 std::string callerName = "callerName";
891 manager_->connectionStates_[0] = std::make_shared<ConnectionStateItem>(callerUid, callerPid, callerName);
892 manager_->HandleCallerDied(callerPid);
893 }
894
895 /*
896 * Feature: ConnectionStateManager
897 * Function: AddDataAbilityConnectionInner
898 * SubFunction: NA
899 * FunctionPoints: ConnectionStateManager AddDataAbilityConnectionInner
900 * EnvConditions: NA
901 * CaseDescription: Verify AddDataAbilityConnectionInner
902 */
903 HWTEST_F(ConnectionStateManagerTest, AddDataAbilityConnectionInner_001, TestSize.Level1)
904 {
905 DataAbilityCaller caller;
906 ConnectionData data;
907 caller.callerPid = 0;
908 manager_->connectionStates_[0] = nullptr;
909 bool res = manager_->AddDataAbilityConnectionInner(caller, dataAbilityRecord_, data);
910 EXPECT_FALSE(res);
911 }
912
913 /*
914 * Feature: ConnectionStateManager
915 * Function: RemoveDataAbilityConnectionInner
916 * SubFunction: NA
917 * FunctionPoints: ConnectionStateManager RemoveDataAbilityConnectionInner
918 * EnvConditions: NA
919 * CaseDescription: Verify RemoveDataAbilityConnectionInner
920 */
921 HWTEST_F(ConnectionStateManagerTest, RemoveDataAbilityConnectionInner_001, TestSize.Level1)
922 {
923 DataAbilityCaller caller;
924 ConnectionData data;
925 caller.callerPid = 0;
926 manager_->connectionStates_[0] = nullptr;
927 bool res = manager_->RemoveDataAbilityConnectionInner(caller, dataAbilityRecord_, data);
928 EXPECT_FALSE(res);
929 }
930
931 /*
932 * Feature: ConnectionStateManager
933 * Function: HandleDataAbilityDiedInner
934 * SubFunction: NA
935 * FunctionPoints: ConnectionStateManager HandleDataAbilityDiedInner
936 * EnvConditions: NA
937 * CaseDescription: Verify HandleDataAbilityDiedInner
938 */
939 HWTEST_F(ConnectionStateManagerTest, HandleDataAbilityDiedInner_001, TestSize.Level1)
940 {
941 EXPECT_NE(manager_, nullptr);
942 sptr<IRemoteObject> abilityToken;
943 std::vector<AbilityRuntime::ConnectionData> allData;
944 manager_->connectionStates_[0] = nullptr;
945 manager_->HandleDataAbilityDiedInner(abilityToken, allData);
946 }
947
948 #ifdef WITH_DLP
949 /*
950 * Feature: ConnectionStateManager
951 * Function: HandleDlpAbilityInner
952 * SubFunction: NA
953 * FunctionPoints: ConnectionStateManager HandleDlpAbilityInner
954 * EnvConditions: NA
955 * CaseDescription: Verify HandleDlpAbilityInner
956 */
957 HWTEST_F(ConnectionStateManagerTest, HandleDlpAbilityInner_001, TestSize.Level1)
958 {
959 std::shared_ptr<AbilityRecord> dlpAbility = nullptr;
960 bool isAdd = true;
961 DlpStateData dlpData;
962 bool res = manager_->HandleDlpAbilityInner(dlpAbility, isAdd, dlpData);
963 EXPECT_FALSE(res);
964 }
965
966 /*
967 * Feature: ConnectionStateManager
968 * Function: HandleDlpAbilityInner
969 * SubFunction: NA
970 * FunctionPoints: ConnectionStateManager HandleDlpAbilityInner
971 * EnvConditions: NA
972 * CaseDescription: Verify HandleDlpAbilityInner
973 */
974 HWTEST_F(ConnectionStateManagerTest, HandleDlpAbilityInner_002, TestSize.Level1)
975 {
976 std::shared_ptr<AbilityRecord> dlpAbility = abilityRecord_;
977 bool isAdd = true;
978 DlpStateData dlpData;
979 dlpAbility->appIndex_ = 0;
980 bool res = manager_->HandleDlpAbilityInner(dlpAbility, isAdd, dlpData);
981 EXPECT_FALSE(res);
982 }
983
984 /*
985 * Feature: ConnectionStateManager
986 * Function: HandleDlpAbilityInner
987 * SubFunction: NA
988 * FunctionPoints: ConnectionStateManager HandleDlpAbilityInner
989 * EnvConditions: NA
990 * CaseDescription: Verify HandleDlpAbilityInner
991 */
992 HWTEST_F(ConnectionStateManagerTest, HandleDlpAbilityInner_003, TestSize.Level1)
993 {
994 std::shared_ptr<AbilityRecord> dlpAbility = abilityRecord_;
995 bool isAdd = true;
996 DlpStateData dlpData;
997 dlpAbility->appIndex_ = 1;
998 bool res = manager_->HandleDlpAbilityInner(dlpAbility, isAdd, dlpData);
999 EXPECT_FALSE(res);
1000 }
1001
1002 /*
1003 * Feature: ConnectionStateManager
1004 * Function: HandleDlpAbilityInner
1005 * SubFunction: NA
1006 * FunctionPoints: ConnectionStateManager HandleDlpAbilityInner
1007 * EnvConditions: NA
1008 * CaseDescription: Verify HandleDlpAbilityInner
1009 */
1010 HWTEST_F(ConnectionStateManagerTest, HandleDlpAbilityInner_004, TestSize.Level1)
1011 {
1012 std::shared_ptr<AbilityRecord> dlpAbility = abilityRecord_;
1013 bool isAdd = true;
1014 DlpStateData dlpData;
1015 dlpAbility->appIndex_ = 1;
1016 manager_->dlpItems_[1] = nullptr;
1017 bool res = manager_->HandleDlpAbilityInner(dlpAbility, isAdd, dlpData);
1018 EXPECT_FALSE(res);
1019 }
1020
1021 /*
1022 * Feature: ConnectionStateManager
1023 * Function: HandleDlpAbilityInner
1024 * SubFunction: NA
1025 * FunctionPoints: ConnectionStateManager HandleDlpAbilityInner
1026 * EnvConditions: NA
1027 * CaseDescription: Verify HandleDlpAbilityInner
1028 */
1029 HWTEST_F(ConnectionStateManagerTest, HandleDlpAbilityInner_005, TestSize.Level1)
1030 {
1031 std::shared_ptr<AbilityRecord> dlpAbility = abilityRecord_;
1032 bool isAdd = false;
1033 DlpStateData dlpData;
1034 int32_t dlpUid = 0;
1035 int32_t dlpPid = 0;
1036 std::shared_ptr<DlpStateItem> item = std::make_shared<DlpStateItem>(dlpUid, dlpPid);
1037 dlpAbility->appIndex_ = 1;
1038 manager_->dlpItems_[1] = item;
1039 bool res = manager_->HandleDlpAbilityInner(dlpAbility, isAdd, dlpData);
1040 EXPECT_FALSE(res);
1041 }
1042
1043 /*
1044 * Feature: ConnectionStateManager
1045 * Function: HandleDlpAbilityInner
1046 * SubFunction: NA
1047 * FunctionPoints: ConnectionStateManager HandleDlpAbilityInner
1048 * EnvConditions: NA
1049 * CaseDescription: Verify HandleDlpAbilityInner
1050 */
1051 HWTEST_F(ConnectionStateManagerTest, HandleDlpAbilityInner_006, TestSize.Level1)
1052 {
1053 std::shared_ptr<AbilityRecord> dlpAbility = abilityRecord_;
1054 bool isAdd = true;
1055 DlpStateData dlpData;
1056 int32_t dlpUid = 0;
1057 int32_t dlpPid = 0;
1058 std::shared_ptr<DlpStateItem> item = std::make_shared<DlpStateItem>(dlpUid, dlpPid);
1059 dlpAbility->appIndex_ = 1;
1060 manager_->dlpItems_[1] = item;
1061 bool res = manager_->HandleDlpAbilityInner(dlpAbility, isAdd, dlpData);
1062 EXPECT_FALSE(res);
1063 }
1064 #endif // WITH_DLP
1065 } // namespace AAFwk
1066 } // namespace OHOS
1067