1 /*
2 * Copyright (c) 2023-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17
18 #include "ability_manager_errors.h"
19 #define private public
20 #define protected public
21 #include "ability_record.h"
22 #include "ability_start_setting.h"
23 #include "app_scheduler.h"
24 #include "app_utils.h"
25 #include "scene_board/ui_ability_lifecycle_manager.h"
26 #include "scene_board/status_bar_delegate_manager.h"
27
28 #undef protected
29 #undef private
30 #include "app_mgr_client.h"
31 #include "process_options.h"
32 #include "session/host/include/session.h"
33 #include "session_info.h"
34 #include "startup_util.h"
35 #include "ability_manager_service.h"
36
37 using namespace testing;
38 using namespace testing::ext;
39
40 namespace OHOS {
41 namespace AAFwk {
42 class MockIStatusBarDelegate : public AbilityRuntime::IStatusBarDelegate {
43 public:
44 MockIStatusBarDelegate() = default;
45 virtual ~MockIStatusBarDelegate() = default;
46
CheckIfStatusBarItemExists(uint32_t accessTokenId,const std::string & instanceKey,bool & isExist)47 int32_t CheckIfStatusBarItemExists(uint32_t accessTokenId, const std::string &instanceKey,
48 bool& isExist) override
49 {
50 if (returnValue_ == ERR_OK) {
51 isExist = itemExists_;
52 }
53 return returnValue_;
54 }
55
AttachPidToStatusBarItem(uint32_t accessTokenId,int32_t pid,const std::string & instanceKey)56 int32_t AttachPidToStatusBarItem(uint32_t accessTokenId, int32_t pid,
57 const std::string &instanceKey) override
58 {
59 return returnValue_;
60 }
61
DetachPidToStatusBarItem(uint32_t accessTokenId,int32_t pid,const std::string & instanceKey)62 int32_t DetachPidToStatusBarItem(uint32_t accessTokenId, int32_t pid,
63 const std::string &instanceKey) override
64 {
65 return returnValue_;
66 }
67
AsObject()68 sptr<IRemoteObject> AsObject() override
69 {
70 return nullptr;
71 }
72
SetReturnValue(int32_t value)73 void SetReturnValue(int32_t value)
74 {
75 returnValue_ = value;
76 }
77
SetItemExists(bool exists)78 void SetItemExists(bool exists)
79 {
80 itemExists_ = exists;
81 }
82
83 private:
84 int32_t returnValue_ = ERR_OK;
85 bool itemExists_ = false;
86 };
87
88 class StatusBarDelegateManagerTest : public testing::Test {
89 public:
90 static void SetUpTestCase();
91 static void TearDownTestCase();
92 void SetUp() override;
93 void TearDown() override;
94
CreateMockAbilityRecord()95 std::shared_ptr<AbilityRecord> CreateMockAbilityRecord()
96 {
97 Want want;
98 AppExecFwk::AbilityInfo abilityInfo;
99 AppExecFwk::ApplicationInfo applicationInfo;
100 return std::make_shared<AbilityRecord>(want, abilityInfo, applicationInfo);
101 }
102 };
103
SetUpTestCase()104 void StatusBarDelegateManagerTest::SetUpTestCase() {}
105
TearDownTestCase()106 void StatusBarDelegateManagerTest::TearDownTestCase() {}
107
SetUp()108 void StatusBarDelegateManagerTest::SetUp() {}
109
TearDown()110 void StatusBarDelegateManagerTest::TearDown() {}
111
112
113 /**
114 * @tc.name: StatusBarDelegateManager_IsCallerInStatusBar_0100
115 * @tc.desc: IsCallerInStatusBar
116 * @tc.type: FUNC
117 */
118 HWTEST_F(StatusBarDelegateManagerTest, IsCallerInStatusBar_0100, TestSize.Level1)
119 {
120 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
121 EXPECT_NE(statusBarDelegate, nullptr);
122 statusBarDelegate->RegisterStatusBarDelegate(nullptr);
123 statusBarDelegate->GetStatusBarDelegate();
124 bool ret = statusBarDelegate->IsCallerInStatusBar("");
125 EXPECT_EQ(ret, false);
126 }
127
128 /**
129 * @tc.name: StatusBarDelegateManager_IsCallerInStatusBar_0200
130 * @tc.desc: Test IsCallerInStatusBar when CheckIfStatusBarItemExists returns ERR_OK and item exists
131 * @tc.type: FUNC
132 */
133 HWTEST_F(StatusBarDelegateManagerTest, IsCallerInStatusBar_0200, TestSize.Level1)
134 {
135 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
136 EXPECT_NE(statusBarDelegate, nullptr);
137 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
138 mockDelegate->SetReturnValue(ERR_OK);
139 mockDelegate->SetItemExists(true);
140 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
141 bool ret = statusBarDelegate->IsCallerInStatusBar("test_instance_key");
142 EXPECT_EQ(ret, true);
143 }
144
145 /**
146 * @tc.name: StatusBarDelegateManager_IsCallerInStatusBar_0300
147 * @tc.desc: Test IsCallerInStatusBar when CheckIfStatusBarItemExists returns error
148 * @tc.type: FUNC
149 */
150 HWTEST_F(StatusBarDelegateManagerTest, IsCallerInStatusBar_0300, TestSize.Level1)
151 {
152 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
153 EXPECT_NE(statusBarDelegate, nullptr);
154 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
155 mockDelegate->SetReturnValue(ERR_INVALID_VALUE);
156 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
157 bool ret = statusBarDelegate->IsCallerInStatusBar("test_instance_key");
158 EXPECT_EQ(ret, false);
159 }
160
161 /**
162 * @tc.name: StatusBarDelegateManager_IsCallerInStatusBar_0400
163 * @tc.desc: Test IsCallerInStatusBar when CheckIfStatusBarItemExists returns error
164 * @tc.type: FUNC
165 */
166 HWTEST_F(StatusBarDelegateManagerTest, IsCallerInStatusBar_0400, TestSize.Level1)
167 {
168 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
169 EXPECT_NE(statusBarDelegate, nullptr);
170 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
171 mockDelegate->SetReturnValue(ERR_OK);
172 mockDelegate->SetItemExists(false);
173 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
174 bool result = statusBarDelegate->IsCallerInStatusBar("test_instance_key");
175 EXPECT_EQ(result, false);
176 }
177
178 /**
179 * @tc.name: StatusBarDelegateManager_IsCallerInStatusBar_0500
180 * @tc.desc: Test IsCallerInStatusBar when CheckIfStatusBarItemExists returns error
181 * @tc.type: FUNC
182 */
183 HWTEST_F(StatusBarDelegateManagerTest, IsCallerInStatusBar_0500, TestSize.Level1)
184 {
185 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
186 EXPECT_NE(statusBarDelegate, nullptr);
187 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
188 mockDelegate->SetReturnValue(ERR_INVALID_VALUE);
189 mockDelegate->SetItemExists(true);
190 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
191 bool result = statusBarDelegate->IsCallerInStatusBar("test_instance_key");
192 EXPECT_EQ(result, false);
193 }
194
195 /**
196 * @tc.name: StatusBarDelegateManager_DoProcessAttachment_0100
197 * @tc.desc: DoProcessAttachment
198 * @tc.type: FUNC
199 */
200 HWTEST_F(StatusBarDelegateManagerTest, DoProcessAttachment_0100, TestSize.Level1)
201 {
202 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
203 EXPECT_NE(statusBarDelegate, nullptr);
204 statusBarDelegate->RegisterStatusBarDelegate(nullptr);
205 statusBarDelegate->GetStatusBarDelegate();
206 bool ret = statusBarDelegate->IsCallerInStatusBar("");
207 EXPECT_EQ(ret, false);
208 std::shared_ptr<AbilityRecord> abilityRecord;
209 int32_t attach_ret = statusBarDelegate->DoProcessAttachment(abilityRecord);
210 EXPECT_NE(attach_ret, ERR_OK);
211 }
212
213 /**
214 * @tc.name: StatusBarDelegateManager_DoProcessAttachment_0200
215 * @tc.desc: DoProcessAttachment
216 * @tc.type: FUNC
217 */
218 HWTEST_F(StatusBarDelegateManagerTest, DoProcessAttachment_0200, TestSize.Level1)
219 {
220 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
221 EXPECT_NE(statusBarDelegate, nullptr);
222 std::shared_ptr<AbilityRecord> abilityRecord = CreateMockAbilityRecord();
223 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
224 EXPECT_NE(sessionInfo, nullptr);
225 abilityRecord->SetSessionInfo(sessionInfo);
226 int32_t attach_ret = statusBarDelegate->DoProcessAttachment(abilityRecord);
227 EXPECT_EQ(attach_ret, ERR_OK);
228 }
229
230 /**
231 * @tc.name: StatusBarDelegateManager_DoProcessAttachment_0300
232 * @tc.desc: DoProcessAttachment
233 * @tc.type: FUNC
234 */
235 HWTEST_F(StatusBarDelegateManagerTest, DoProcessAttachment_0300, TestSize.Level1)
236 {
237 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
238 EXPECT_NE(statusBarDelegate, nullptr);
239 std::shared_ptr<AbilityRecord> abilityRecord = CreateMockAbilityRecord();
240 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
241 EXPECT_NE(sessionInfo, nullptr);
242 std::shared_ptr<ProcessOptions> processOptions = std::make_shared<ProcessOptions>();
243 EXPECT_NE(processOptions, nullptr);
244 processOptions->processMode = ProcessMode::NEW_PROCESS_ATTACH_TO_PARENT;
245 sessionInfo->processOptions = processOptions;
246 abilityRecord->SetSessionInfo(sessionInfo);
247 int32_t attach_ret = statusBarDelegate->DoProcessAttachment(abilityRecord);
248 EXPECT_EQ(attach_ret, ERR_INVALID_VALUE);
249 }
250
251 /**
252 * @tc.name: StatusBarDelegateManager_DoProcessAttachment_0400
253 * @tc.desc: DoProcessAttachment
254 * @tc.type: FUNC
255 */
256 HWTEST_F(StatusBarDelegateManagerTest, DoProcessAttachment_0400, TestSize.Level1)
257 {
258 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
259 EXPECT_NE(statusBarDelegate, nullptr);
260 std::shared_ptr<AbilityRecord> abilityRecord = CreateMockAbilityRecord();
261 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
262 EXPECT_NE(sessionInfo, nullptr);
263 std::shared_ptr<ProcessOptions> processOptions = std::make_shared<ProcessOptions>();
264 EXPECT_NE(processOptions, nullptr);
265 processOptions->processMode = ProcessMode::NEW_PROCESS_ATTACH_TO_STATUS_BAR_ITEM;
266 sessionInfo->processOptions = processOptions;
267 abilityRecord->SetSessionInfo(sessionInfo);
268 int32_t attach_ret = statusBarDelegate->DoProcessAttachment(abilityRecord);
269 EXPECT_EQ(attach_ret, ERR_INVALID_VALUE);
270 }
271
272 /**
273 * @tc.name: StatusBarDelegateManager_DoCallerProcessAttachment_0100
274 * @tc.desc: DoCallerProcessAttachment
275 * @tc.type: FUNC
276 */
277 HWTEST_F(StatusBarDelegateManagerTest, DoCallerProcessAttachment_0100, TestSize.Level1)
278 {
279 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
280 EXPECT_NE(statusBarDelegate, nullptr);
281 statusBarDelegate->RegisterStatusBarDelegate(nullptr);
282 statusBarDelegate->GetStatusBarDelegate();
283 bool ret = statusBarDelegate->IsCallerInStatusBar("");
284 EXPECT_EQ(ret, false);
285 std::shared_ptr<AbilityRecord> abilityRecord;
286 int32_t attach_ret = statusBarDelegate->DoProcessAttachment(abilityRecord);
287 EXPECT_NE(attach_ret, ERR_OK);
288 }
289
290 /**
291 * @tc.name: StatusBarDelegateManager_IsInStatusBar_0100
292 * @tc.desc: Test IsInStatusBar when statusBarDelegate is null
293 * @tc.type: FUNC
294 */
295 HWTEST_F(StatusBarDelegateManagerTest, IsInStatusBar_0100, TestSize.Level1)
296 {
297 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
298 EXPECT_NE(statusBarDelegate, nullptr);
299 bool ret = statusBarDelegate->IsInStatusBar(1000, false);
300 EXPECT_EQ(ret, false);
301 }
302
303 /**
304 * @tc.name: StatusBarDelegateManager_IsInStatusBar_0200
305 * @tc.desc: Test IsInStatusBar when CheckIfStatusBarItemExists returns ERR_OK and item exists
306 * @tc.type: FUNC
307 */
308 HWTEST_F(StatusBarDelegateManagerTest, IsInStatusBar_0200, TestSize.Level1)
309 {
310 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
311 EXPECT_NE(statusBarDelegate, nullptr);
312 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
313 mockDelegate->SetReturnValue(ERR_OK);
314 mockDelegate->SetItemExists(true);
315 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
316 bool ret = statusBarDelegate->IsInStatusBar(1000, false);
317 EXPECT_EQ(ret, true);
318 }
319
320 /**
321 * @tc.name: StatusBarDelegateManager_IsInStatusBar_0300
322 * @tc.desc: Test IsInStatusBar when CheckIfStatusBarItemExists returns error
323 * @tc.type: FUNC
324 */
325 HWTEST_F(StatusBarDelegateManagerTest, IsInStatusBar_0300, TestSize.Level1)
326 {
327 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
328 EXPECT_NE(statusBarDelegate, nullptr);
329 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
330 mockDelegate->SetReturnValue(ERR_INVALID_VALUE);
331 mockDelegate->SetItemExists(true);
332 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
333 bool ret = statusBarDelegate->IsInStatusBar(1000, false);
334 EXPECT_EQ(ret, false);
335 }
336
337 /**
338 * @tc.name: StatusBarDelegateManager_IsInStatusBar_0400
339 * @tc.desc: Test IsInStatusBar when CheckIfStatusBarItemExists returns error
340 * @tc.type: FUNC
341 */
342 HWTEST_F(StatusBarDelegateManagerTest, IsInStatusBar_0400, TestSize.Level1)
343 {
344 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
345 EXPECT_NE(statusBarDelegate, nullptr);
346 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
347 mockDelegate->SetReturnValue(ERR_OK);
348 mockDelegate->SetItemExists(false);
349 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
350 bool ret = statusBarDelegate->IsInStatusBar(1000, false);
351 EXPECT_EQ(ret, false);
352 }
353
354 /**
355 * @tc.name: StatusBarDelegateManager_IsInStatusBar_0500
356 * @tc.desc: Test IsInStatusBar when CheckIfStatusBarItemExists returns error
357 * @tc.type: FUNC
358 */
359 HWTEST_F(StatusBarDelegateManagerTest, IsInStatusBar_0500, TestSize.Level1)
360 {
361 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
362 EXPECT_NE(statusBarDelegate, nullptr);
363 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
364 mockDelegate->SetReturnValue(ERR_INVALID_DATA);
365 mockDelegate->SetItemExists(false);
366 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
367 bool ret = statusBarDelegate->IsInStatusBar(1000, false);
368 EXPECT_EQ(ret, false);
369 }
370
371 /**
372 * @tc.name: StatusBarDelegateManager_DoCallerProcessAttachment_0200
373 * @tc.desc: Test DoCallerProcessAttachment when abilityRecord is null
374 * @tc.type: FUNC
375 */
376 HWTEST_F(StatusBarDelegateManagerTest, DoCallerProcessAttachment_0200, TestSize.Level1)
377 {
378 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
379 EXPECT_NE(statusBarDelegate, nullptr);
380 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
381 int32_t ret = statusBarDelegate->DoCallerProcessAttachment(abilityRecord);
382 EXPECT_EQ(ret, ERR_INVALID_VALUE);
383 }
384
385 /**
386 * @tc.name: StatusBarDelegateManager_DoCallerProcessAttachment_0300
387 * @tc.desc: Test DoCallerProcessAttachment when AttachPidToStatusBarItem returns ERR_OK
388 * @tc.type: FUNC
389 */
390 HWTEST_F(StatusBarDelegateManagerTest, DoCallerProcessAttachment_0300, TestSize.Level1)
391 {
392 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
393 EXPECT_NE(statusBarDelegate, nullptr);
394 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
395 mockDelegate->SetReturnValue(ERR_OK);
396 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
397 std::shared_ptr<AbilityRecord> abilityRecord = CreateMockAbilityRecord();
398 EXPECT_NE(abilityRecord, nullptr);
399 int32_t ret = statusBarDelegate->DoCallerProcessAttachment(abilityRecord);
400 EXPECT_EQ(ret, ERR_OK);
401 }
402
403 /**
404 * @tc.name: StatusBarDelegateManager_DoCallerProcessAttachment_0400
405 * @tc.desc: Test DoCallerProcessAttachment when AttachPidToStatusBarItem returns error
406 * @tc.type: FUNC
407 */
408 HWTEST_F(StatusBarDelegateManagerTest, DoCallerProcessAttachment_0400, TestSize.Level1)
409 {
410 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
411 EXPECT_NE(statusBarDelegate, nullptr);
412 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
413 mockDelegate->SetReturnValue(ERR_INVALID_VALUE);
414 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
415 std::shared_ptr<AbilityRecord> abilityRecord = CreateMockAbilityRecord();
416 EXPECT_NE(abilityRecord, nullptr);
417 int32_t ret = statusBarDelegate->DoCallerProcessAttachment(abilityRecord);
418 EXPECT_EQ(ret, ERR_INVALID_VALUE);
419 }
420
421 /**
422 * @tc.name: StatusBarDelegateManager_DoCallerProcessAttachment_0500
423 * @tc.desc: Test DoCallerProcessAttachment when AttachPidToStatusBarItem returns error
424 * @tc.type: FUNC
425 */
426 HWTEST_F(StatusBarDelegateManagerTest, DoCallerProcessAttachment_0500, TestSize.Level1)
427 {
428 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
429 EXPECT_NE(statusBarDelegate, nullptr);
430 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
431 mockDelegate->SetReturnValue(ERR_OK);
432 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
433 std::shared_ptr<AbilityRecord> abilityRecord = CreateMockAbilityRecord();
434 EXPECT_NE(abilityRecord, nullptr);
435 uint32_t accessTokenId = 12;
436 abilityRecord->SetPid(10);
437 abilityRecord->SetInstanceKey("123");
438 int32_t ret = statusBarDelegate->DoCallerProcessAttachment(abilityRecord);
439 EXPECT_EQ(ret, ERR_OK);
440 }
441
442 /**
443 * @tc.name: StatusBarDelegateManager_DoCallerProcessAttachment_0600
444 * @tc.desc: Test DoCallerProcessAttachment when AttachPidToStatusBarItem returns error
445 * @tc.type: FUNC
446 */
447 HWTEST_F(StatusBarDelegateManagerTest, DoCallerProcessAttachment_0600, TestSize.Level1)
448 {
449 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
450 EXPECT_NE(statusBarDelegate, nullptr);
451 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
452 mockDelegate->SetReturnValue(ERR_INVALID_VALUE);
453 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
454 std::shared_ptr<AbilityRecord> abilityRecord = CreateMockAbilityRecord();
455 EXPECT_NE(abilityRecord, nullptr);
456 uint32_t accessTokenId = 12;
457 abilityRecord->SetPid(10);
458 abilityRecord->SetInstanceKey("123");
459 int32_t ret = statusBarDelegate->DoCallerProcessAttachment(abilityRecord);
460 EXPECT_EQ(ret, ERR_INVALID_VALUE);
461 }
462
463 /**
464 * @tc.name: StatusBarDelegateManager_DoCallerProcessDetachment_0100
465 * @tc.desc: Test DoCallerProcessDetachment when abilityRecord is null
466 * @tc.type: FUNC
467 */
468 HWTEST_F(StatusBarDelegateManagerTest, DoCallerProcessDetachment_0100, TestSize.Level1)
469 {
470 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
471 EXPECT_NE(statusBarDelegate, nullptr);
472 std::shared_ptr<AbilityRecord> abilityRecord = nullptr;
473 int32_t ret = statusBarDelegate->DoCallerProcessDetachment(abilityRecord);
474 EXPECT_EQ(ret, ERR_INVALID_VALUE);
475 }
476
477 /**
478 * @tc.name: StatusBarDelegateManager_DoCallerProcessDetachment_0200
479 * @tc.desc: Test DoCallerProcessDetachment when statusBarDelegate is null
480 * @tc.type: FUNC
481 */
482 HWTEST_F(StatusBarDelegateManagerTest, DoCallerProcessDetachment_0200, TestSize.Level1)
483 {
484 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
485 EXPECT_NE(statusBarDelegate, nullptr);
486 std::shared_ptr<AbilityRecord> abilityRecord = CreateMockAbilityRecord();
487 EXPECT_NE(abilityRecord, nullptr);
488 int32_t ret = statusBarDelegate->DoCallerProcessDetachment(abilityRecord);
489 EXPECT_EQ(ret, ERR_INVALID_VALUE);
490 }
491
492 /**
493 * @tc.name: StatusBarDelegateManager_DoCallerProcessDetachment_0300
494 * @tc.desc: Test DoCallerProcessDetachment when DetachPidToStatusBarItem returns ERR_OK
495 * @tc.type: FUNC
496 */
497 HWTEST_F(StatusBarDelegateManagerTest, DoCallerProcessDetachment_0300, TestSize.Level1)
498 {
499 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
500 EXPECT_NE(statusBarDelegate, nullptr);
501 // Create a mock delegate that will return ERR_OK
502 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
503 mockDelegate->SetReturnValue(ERR_OK);
504 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
505 std::shared_ptr<AbilityRecord> abilityRecord = CreateMockAbilityRecord();
506 EXPECT_NE(abilityRecord, nullptr);
507 int32_t ret = statusBarDelegate->DoCallerProcessDetachment(abilityRecord);
508 EXPECT_EQ(ret, ERR_OK);
509 }
510
511 /**
512 * @tc.name: StatusBarDelegateManager_DoCallerProcessDetachment_0104
513 * @tc.desc: Test DoCallerProcessDetachment when DetachPidToStatusBarItem returns error
514 * @tc.type: FUNC
515 */
516 HWTEST_F(StatusBarDelegateManagerTest, DoCallerProcessDetachment_0400, TestSize.Level1)
517 {
518 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
519 EXPECT_NE(statusBarDelegate, nullptr);
520 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
521 mockDelegate->SetReturnValue(ERR_INVALID_VALUE);
522 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
523 std::shared_ptr<AbilityRecord> abilityRecord = CreateMockAbilityRecord();
524 EXPECT_NE(abilityRecord, nullptr);
525 int32_t ret = statusBarDelegate->DoCallerProcessDetachment(abilityRecord);
526 EXPECT_EQ(ret, ERR_INVALID_VALUE);
527 }
528
529 /**
530 * @tc.name: StatusBarDelegateManager_IsSupportStatusBar_0100
531 * @tc.desc: Test IsSupportStatusBar
532 * @tc.type: FUNC
533 */
534 HWTEST_F(StatusBarDelegateManagerTest, IsSupportStatusBar_0100, TestSize.Level1)
535 {
536 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
537 EXPECT_NE(statusBarDelegate, nullptr);
538 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
539 statusBarDelegate->RegisterStatusBarDelegate(nullptr);
540 auto ret = statusBarDelegate->IsSupportStatusBar();
541 EXPECT_EQ(ret, false);
542 }
543
544 /**
545 * @tc.name: StatusBarDelegateManager_IsSupportStatusBar_0200
546 * @tc.desc: Test IsSupportStatusBar
547 * @tc.type: FUNC
548 */
549 HWTEST_F(StatusBarDelegateManagerTest, IsSupportStatusBar_0200, TestSize.Level1)
550 {
551 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
552 EXPECT_NE(statusBarDelegate, nullptr);
553 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
554 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
555 auto ret = statusBarDelegate->IsSupportStatusBar();
556 EXPECT_EQ(ret, true);
557 }
558
559 /**
560 * @tc.name: StatusBarDelegateManager_IsSupportStatusBar_0300
561 * @tc.desc: Test IsSupportStatusBar
562 * @tc.type: FUNC
563 */
564 HWTEST_F(StatusBarDelegateManagerTest, IsSupportStatusBar_0300, TestSize.Level1)
565 {
566 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
567 EXPECT_NE(statusBarDelegate, nullptr);
568 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
569 mockDelegate->SetReturnValue(ERR_OK);
570 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
571 bool ret = statusBarDelegate->IsSupportStatusBar();
572 EXPECT_EQ(ret, true);
573 }
574
575 /**
576 * @tc.name: StatusBarDelegateManager_IsSupportStatusBar_0400
577 * @tc.desc: Test IsSupportStatusBar
578 * @tc.type: FUNC
579 */
580 HWTEST_F(StatusBarDelegateManagerTest, IsSupportStatusBar_0500, TestSize.Level1)
581 {
582 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
583 EXPECT_NE(statusBarDelegate, nullptr);
584 bool ret = statusBarDelegate->IsSupportStatusBar();
585 EXPECT_EQ(ret, false);
586 }
587
588 /**
589 * @tc.name: StatusBarDelegateManager_DoCallerProcessDetachment_0500
590 * @tc.desc: Test DoCallerProcessDetachment when DetachPidToStatusBarItem returns error
591 * @tc.type: FUNC
592 */
593 HWTEST_F(StatusBarDelegateManagerTest, DoCallerProcessDetachment_0500, TestSize.Level1)
594 {
595 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
596 EXPECT_NE(statusBarDelegate, nullptr);
597 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
598 mockDelegate->SetReturnValue(ERR_OK);
599 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
600 std::shared_ptr<AbilityRecord> abilityRecord = CreateMockAbilityRecord();
601 EXPECT_NE(abilityRecord, nullptr);
602 uint32_t accessTokenId = 12;
603 abilityRecord->SetPid(10);
604 abilityRecord->SetInstanceKey("123");
605 int32_t ret = statusBarDelegate->DoCallerProcessDetachment(abilityRecord);
606 EXPECT_EQ(ret, ERR_OK);
607 }
608
609 /**
610 * @tc.name: StatusBarDelegateManager_DoCallerProcessDetachment_0600
611 * @tc.desc: Test DoCallerProcessDetachment when DetachPidToStatusBarItem returns error
612 * @tc.type: FUNC
613 */
614 HWTEST_F(StatusBarDelegateManagerTest, DoCallerProcessDetachment_0600, TestSize.Level1)
615 {
616 std::shared_ptr<StatusBarDelegateManager> statusBarDelegate = std::make_shared<StatusBarDelegateManager>();
617 EXPECT_NE(statusBarDelegate, nullptr);
618 sptr<MockIStatusBarDelegate> mockDelegate = new MockIStatusBarDelegate();
619 mockDelegate->SetReturnValue(ERR_INVALID_VALUE);
620 statusBarDelegate->RegisterStatusBarDelegate(mockDelegate);
621 std::shared_ptr<AbilityRecord> abilityRecord = CreateMockAbilityRecord();
622 EXPECT_NE(abilityRecord, nullptr);
623 uint32_t accessTokenId = 12;
624 abilityRecord->SetPid(10);
625 abilityRecord->SetInstanceKey("123");
626 int32_t ret = statusBarDelegate->DoCallerProcessDetachment(abilityRecord);
627 EXPECT_EQ(ret, ERR_INVALID_VALUE);
628 }
629 } // namespace AAFwk
630 } // namespace OHOS
631