1 /*
2 * Copyright (c) 2021-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 #define private public
18 #define protected public
19 #include "ability_manager_client.h"
20 #include "ability_manager_stub_mock_test.h"
21 #include "ability_connect_manager.h"
22 #include "ability_manager_interface.h"
23 #undef private
24 #undef protected
25
26 #include "hilog_tag_wrapper.h"
27 #include "mock_ability_connect_callback.h"
28 #include "mock_ability_manager_collaborator.h"
29 #include "session/host/include/session.h"
30 #include "scene_board_judgement.h"
31 #include "status_bar_delegate_interface.h"
32 #include "mission_listener_interface.h"
33 #include "mission_snapshot.h"
34 #include "snapshot.h"
35
36 using namespace testing::ext;
37 using namespace testing;
38 using namespace OHOS::AppExecFwk;
39
40 namespace OHOS {
41 namespace AAFwk {
42 namespace {
43 const int USER_ID = 100;
44 const size_t SIZE_ZERO = 0;
45 const std::string BUNDLE_NAME = "BUNDLE_NAME";
46 const std::string EMPTY_STRING = "";
47 } // namespace
48
49 class AbilityManagerClientBranchTest : public testing::Test {
50 public:
51 static void SetUpTestCase(void);
52 static void TearDownTestCase(void);
53 void SetUp();
54 void TearDown();
55
56 std::shared_ptr<AbilityManagerClient> client_{ nullptr };
57 sptr<AbilityManagerStubTestMock> mock_{ nullptr };
58 sptr<SessionInfo> MockSessionInfo(int32_t persistentId);
59 };
60
MockSessionInfo(int32_t persistentId)61 sptr<SessionInfo> AbilityManagerClientBranchTest::MockSessionInfo(int32_t persistentId)
62 {
63 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
64 if (!sessionInfo) {
65 TAG_LOGE(AAFwkTag::TEST, "sessionInfo is nullptr");
66 return nullptr;
67 }
68 sessionInfo->persistentId = persistentId;
69 return sessionInfo;
70 }
71
SetUpTestCase(void)72 void AbilityManagerClientBranchTest::SetUpTestCase(void)
73 {}
TearDownTestCase(void)74 void AbilityManagerClientBranchTest::TearDownTestCase(void)
75 {}
TearDown()76 void AbilityManagerClientBranchTest::TearDown()
77 {}
78
SetUp()79 void AbilityManagerClientBranchTest::SetUp()
80 {
81 client_ = std::make_shared<AbilityManagerClient>();
82 mock_ = new AbilityManagerStubTestMock();
83 client_->proxy_ = mock_;
84 }
85
86 /*
87 * Feature: AbilityManagerClient
88 * Function: SendResultToAbility
89 * SubFunction: NA
90 * FunctionPoints: AbilityManagerClient SendResultToAbility
91 * EnvConditions: NA
92 * CaseDescription: Verify the SendResultToAbility call normal
93 */
94 HWTEST_F(AbilityManagerClientBranchTest, SendResultToAbility_001, TestSize.Level1)
95 {
96 Want want;
97 EXPECT_EQ(client_->SendResultToAbility(-1, -1, want), 0);
98 }
99
100 /*
101 * Feature: AbilityManagerClient
102 * Function: StartAbilityByCall
103 * SubFunction: NA
104 * FunctionPoints: AbilityManagerClient StartAbility
105 * EnvConditions: NA
106 * CaseDescription: Verify the StartAbilityByCall call normal
107 */
108 HWTEST_F(AbilityManagerClientBranchTest, StartAbilityByCall_001, TestSize.Level1)
109 {
110 Want want;
111 EXPECT_EQ(client_->StartAbilityByCall(want, nullptr, nullptr), 0);
112 }
113
114 /*
115 * Feature: AbilityManagerClient
116 * Function: StartAbilityByCall
117 * SubFunction: NA
118 * FunctionPoints: AbilityManagerClient StartAbility
119 * EnvConditions: NA
120 * CaseDescription: Verify the ReleaseCall call normal
121 */
122 HWTEST_F(AbilityManagerClientBranchTest, ReleaseCall_001, TestSize.Level1)
123 {
124 ElementName element;
125 sptr<IAbilityConnection> connect = nullptr;
126 EXPECT_EQ(client_->ReleaseCall(connect, element), 0);
127 }
128
129 /**
130 * @tc.name: AbilityManagerClient_DumpSysState_0100
131 * @tc.desc: DumpSysState
132 * @tc.type: FUNC
133 * @tc.require: SR000GH1GO
134 */
135 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_DumpSysState_0100, TestSize.Level1)
136 {
137 std::string args = "-a";
138 std::vector<std::string> state;
139 bool isClient = false;
140 bool isUserID = true;
141
142 auto result = client_->DumpSysState(args, state, isClient, isUserID, USER_ID);
143 EXPECT_EQ(result, ERR_OK);
144 EXPECT_EQ(state.size(), SIZE_ZERO);
145 }
146
147 /**
148 * @tc.name: AbilityManagerClient_SetMissionIcon_0100
149 * @tc.desc: SetMissionIcon
150 * @tc.type: FUNC
151 * @tc.require: SR000GVIJQ
152 */
153 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_SetMissionIcon_0100, TestSize.Level1)
154 {
155 sptr<IRemoteObject> abilityToken = nullptr;
156 std::shared_ptr<OHOS::Media::PixelMap> icon = nullptr;
157
158 auto result = client_->SetMissionIcon(abilityToken, icon);
159 EXPECT_NE(result, ERR_OK);
160 }
161
162 /**
163 * @tc.name: AbilityManagerClient_SetMissionIcon_0200
164 * @tc.desc: SetMissionIcon
165 * @tc.type: FUNC
166 * @tc.require: SR000GVIJQ
167 */
168 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_SetMissionIcon_0200, TestSize.Level1)
169 {
170 sptr<IRemoteObject> abilityToken = new AbilityManagerStubTestMock();
171 std::shared_ptr<OHOS::Media::PixelMap> icon = nullptr;
172
173 EXPECT_TRUE(client_ != nullptr);
174 auto result = client_->SetMissionIcon(abilityToken, icon);
175 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
176 EXPECT_NE(result, ERR_OK);
177 }
178 }
179
180 /**
181 * @tc.name: AbilityManagerClient_ScheduleConnectAbilityDone_0100
182 * @tc.desc: ScheduleConnectAbilityDone
183 * @tc.type: FUNC
184 * @tc.require: issueI5NRWT
185 */
186 HWTEST_F(AbilityManagerClientBranchTest, ScheduleConnectAbilityDone_0100, TestSize.Level1)
187 {
188 sptr<IRemoteObject> token = nullptr;
189 sptr<IRemoteObject> remoteObject = nullptr;
190 auto result = client_->ScheduleConnectAbilityDone(token, remoteObject);
191 EXPECT_EQ(ERR_OK, result);
192 }
193
194 /**
195 * @tc.name: AbilityManagerClient_ScheduleDisconnectAbilityDone_0100
196 * @tc.desc: ScheduleDisconnectAbilityDone
197 * @tc.type: FUNC
198 * @tc.require: issueI5NRWT
199 */
200 HWTEST_F(AbilityManagerClientBranchTest, ScheduleDisconnectAbilityDone_0100, TestSize.Level1)
201 {
202 sptr<IRemoteObject> token = nullptr;
203 auto result = client_->ScheduleDisconnectAbilityDone(token);
204 EXPECT_EQ(ERR_OK, result);
205 }
206
207 /**
208 * @tc.name: AbilityManagerClient_StartExtensionAbility_0100
209 * @tc.desc: StartExtensionAbility
210 * @tc.type: FUNC
211 * @tc.require: issueI5NRWT
212 */
213 HWTEST_F(AbilityManagerClientBranchTest, StartExtensionAbility_0100, TestSize.Level1)
214 {
215 Want want;
216 sptr<IRemoteObject> callerToken = nullptr;
217 int32_t userId = DEFAULT_INVAL_VALUE;
218 AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::UNSPECIFIED;
219 auto result = client_->StartExtensionAbility(want, callerToken, userId, extensionType);
220 EXPECT_EQ(ERR_OK, result);
221 }
222
223 /**
224 * @tc.name: AbilityManagerClient_StopExtensionAbility_0100
225 * @tc.desc: StopExtensionAbility
226 * @tc.type: FUNC
227 * @tc.require: issueI5NRWT
228 */
229 HWTEST_F(AbilityManagerClientBranchTest, StopExtensionAbility_0100, TestSize.Level1)
230 {
231 Want want;
232 sptr<IRemoteObject> callerToken = nullptr;
233 int32_t userId = DEFAULT_INVAL_VALUE;
234 AppExecFwk::ExtensionAbilityType extensionType = AppExecFwk::ExtensionAbilityType::UNSPECIFIED;
235 auto result = client_->StopExtensionAbility(want, callerToken, userId, extensionType);
236 EXPECT_EQ(ERR_OK, result);
237 }
238
239 /**
240 * @tc.name: AbilityManagerClient_MinimizeAbility_0100
241 * @tc.desc: MinimizeAbility
242 * @tc.type: FUNC
243 * @tc.require: issueI5NRWT
244 */
245 HWTEST_F(AbilityManagerClientBranchTest, MinimizeAbility_0100, TestSize.Level1)
246 {
247 sptr<IRemoteObject> token = nullptr;
248 bool fromUser = false;
249 auto result = client_->MinimizeAbility(token, fromUser);
250 EXPECT_EQ(ERR_OK, result);
251 }
252
253 /**
254 * @tc.name: AbilityManagerClient_DumpState_0100
255 * @tc.desc: DumpState
256 * @tc.type: FUNC
257 * @tc.require: issueI5NRWT
258 */
259 HWTEST_F(AbilityManagerClientBranchTest, DumpState_0100, TestSize.Level1)
260 {
261 std::string myString = "-a";
262 std::vector<std::string> state;
263 auto result = client_->DumpState(myString, state);
264 EXPECT_EQ(ERR_OK, result);
265 }
266
267 #ifdef ABILITY_COMMAND_FOR_TEST
268 /**
269 * @tc.name: AbilityManagerClient_ForceTimeoutForTest_0100
270 * @tc.desc: ForceTimeoutForTest
271 * @tc.type: FUNC
272 * @tc.require: issueI5NRWT
273 */
274 HWTEST_F(AbilityManagerClientBranchTest, ForceTimeoutForTest_0100, TestSize.Level1)
275 {
276 std::string abilityName = "abilityName_test";
277 std::string state = "state_test";
278 auto result = client_->ForceTimeoutForTest(abilityName, state);
279 EXPECT_EQ(ERR_OK, result);
280 }
281 #endif
282
283 /**
284 * @tc.name: AbilityManagerClient_StartContinuation_0100
285 * @tc.desc: StartContinuation
286 * @tc.type: FUNC
287 * @tc.require: issueI5NRWT
288 */
289 HWTEST_F(AbilityManagerClientBranchTest, StartContinuation_0100, TestSize.Level1)
290 {
291 Want want;
292 sptr<IRemoteObject> abilityToken = nullptr;
293 auto result = client_->StartContinuation(want, abilityToken, 1);
294 EXPECT_EQ(ERR_OK, result);
295 }
296
297 /**
298 * @tc.name: AbilityManagerClient_NotifyContinuationResult_0100
299 * @tc.desc: NotifyContinuationResult
300 * @tc.type: FUNC
301 * @tc.require: issueI5NRWT
302 */
303 HWTEST_F(AbilityManagerClientBranchTest, NotifyContinuationResult_0100, TestSize.Level1)
304 {
305 auto result = client_->NotifyContinuationResult(1, 1);
306 EXPECT_EQ(ERR_OK, result);
307 }
308
309 /**
310 * @tc.name: AbilityManagerClient_LockMissionForCleanup_0100
311 * @tc.desc: LockMissionForCleanup
312 * @tc.type: FUNC
313 * @tc.require: issueI5NRWT
314 */
315 HWTEST_F(AbilityManagerClientBranchTest, LockMissionForCleanup_0100, TestSize.Level1)
316 {
317 EXPECT_TRUE(client_ != nullptr);
318 auto result = client_->LockMissionForCleanup(1);
319 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
320 EXPECT_EQ(ERR_OK, result);
321 }
322 }
323
324 /**
325 * @tc.name: AbilityManagerClient_LockMissionForCleanup_0200
326 * @tc.desc: LockMissionForCleanup
327 * @tc.type: FUNC
328 * @tc.require: issueI5NRWT
329 */
330 HWTEST_F(AbilityManagerClientBranchTest, LockMissionForCleanup_0200, TestSize.Level1)
331 {
332 EXPECT_TRUE(client_ != nullptr);
333 auto result = client_->LockMissionForCleanup(1);
334 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
335 EXPECT_EQ(result, ERR_OK);
336 }
337 }
338
339 /**
340 * @tc.name: AbilityManagerClient_UnlockMissionForCleanup_0100
341 * @tc.desc: UnlockMissionForCleanup
342 * @tc.type: FUNC
343 * @tc.require: issue
344 */
345 HWTEST_F(AbilityManagerClientBranchTest, UnlockMissionForCleanup_0100, TestSize.Level1)
346 {
347 EXPECT_TRUE(client_ != nullptr);
348 auto result = client_->UnlockMissionForCleanup(5);
349 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
350 EXPECT_EQ(result, ERR_OK);
351 }
352 }
353
354 /**
355 * @tc.name: AbilityManagerClient_UnlockMissionForCleanup_0200
356 * @tc.desc: UnlockMissionForCleanup
357 * @tc.type: FUNC
358 * @tc.require: issue
359 */
360 HWTEST_F(AbilityManagerClientBranchTest, UnlockMissionForCleanup_0200, TestSize.Level1)
361 {
362 EXPECT_TRUE(client_ != nullptr);
363 auto result = client_->UnlockMissionForCleanup(5);
364 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
365 EXPECT_EQ(result, ERR_OK);
366 }
367 }
368
369 /**
370 * @tc.name: AbilityManagerClient_RegisterMissionListener_0100
371 * @tc.desc: RegisterMissionListener
372 * @tc.type: FUNC
373 * @tc.require: issue
374 */
375 HWTEST_F(AbilityManagerClientBranchTest, RegisterMissionListener_0100, TestSize.Level1)
376 {
377 EXPECT_TRUE(client_ != nullptr);
378 sptr<IMissionListener> listener = nullptr;
379 auto result = client_->RegisterMissionListener(listener);
380 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
381 EXPECT_EQ(result, ERR_OK);
382 }
383 }
384
385 /**
386 * @tc.name: AbilityManagerClient_RegisterMissionListener_0200
387 * @tc.desc: RegisterMissionListener
388 * @tc.type: FUNC
389 * @tc.require: issue
390 */
391 HWTEST_F(AbilityManagerClientBranchTest, RegisterMissionListener_0200, TestSize.Level1)
392 {
393 std::string deviceId = "123";
394 sptr<IRemoteMissionListener> listener = nullptr;
395 auto result = client_->RegisterMissionListener(deviceId, listener);
396 EXPECT_EQ(result, ERR_OK);
397 }
398
399 /**
400 * @tc.name: AbilityManagerClient_UnRegisterMissionListener_0100
401 * @tc.desc: UnRegisterMissionListener
402 * @tc.type: FUNC
403 * @tc.require: issue
404 */
405 HWTEST_F(AbilityManagerClientBranchTest, UnRegisterMissionListener_0100, TestSize.Level1)
406 {
407 EXPECT_TRUE(client_ != nullptr);
408 sptr<IMissionListener> listener = nullptr;
409 auto result = client_->UnRegisterMissionListener(listener);
410 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
411 EXPECT_EQ(result, ERR_OK);
412 }
413 }
414
415 /**
416 * @tc.name: AbilityManagerClient_UnRegisterMissionListener_0200
417 * @tc.desc: UnRegisterMissionListener
418 * @tc.type: FUNC
419 * @tc.require: issue
420 */
421 HWTEST_F(AbilityManagerClientBranchTest, UnRegisterMissionListener_0200, TestSize.Level1)
422 {
423 std::string deviceId = "123";
424 sptr<IRemoteMissionListener> listener = nullptr;
425 auto result = client_->UnRegisterMissionListener(deviceId, listener);
426 EXPECT_EQ(result, ERR_OK);
427 }
428
429 /**
430 * @tc.name: AbilityManagerClient_GetAbilityManagerCollaborator_0100
431 * @tc.desc: GetAbilityManagerCollaborator
432 * @tc.type: FUNC
433 */
434 HWTEST_F(AbilityManagerClientBranchTest, GetAbilityManagerCollaborator_0100, TestSize.Level1)
435 {
436 auto result = client_->GetAbilityManagerCollaborator();
437 EXPECT_EQ(result, nullptr);
438 }
439
440 /**
441 * @tc.name: AbilityManagerClient_GetMissionInfos_0100
442 * @tc.desc: GetMissionInfos
443 * @tc.type: FUNC
444 * @tc.require: issue
445 */
446 HWTEST_F(AbilityManagerClientBranchTest, GetMissionInfos_0100, TestSize.Level1)
447 {
448 EXPECT_TRUE(client_ != nullptr);
449 std::string deviceId = "123";
450 std::vector<MissionInfo> missionInfos;
451 auto result = client_->GetMissionInfos(deviceId, 10, missionInfos);
452 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
453 EXPECT_EQ(result, ERR_OK);
454 }
455 }
456
457 /**
458 * @tc.name: AbilityManagerClient_GetMissionSnapshot_0100
459 * @tc.desc: GetMissionSnapshot
460 * @tc.type: FUNC
461 * @tc.require: issue
462 */
463 HWTEST_F(AbilityManagerClientBranchTest, GetMissionSnapshot_0100, TestSize.Level1)
464 {
465 EXPECT_TRUE(client_ != nullptr);
466 std::string deviceId = "123";
467 MissionSnapshot snapshot;
468 bool isLowResolution = false;
469 auto result = client_->GetMissionSnapshot(deviceId, 10, snapshot, isLowResolution);
470 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
471 EXPECT_EQ(result, ERR_OK);
472 }
473 }
474
475 /**
476 * @tc.name: AbilityManagerClient_CleanMission_0100
477 * @tc.desc: CleanMission
478 * @tc.type: FUNC
479 * @tc.require: issue
480 */
481 HWTEST_F(AbilityManagerClientBranchTest, CleanMission_0100, TestSize.Level1)
482 {
483 EXPECT_TRUE(client_ != nullptr);
484 auto result = client_->CleanMission(10);
485 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
486 EXPECT_EQ(result, ERR_OK);
487 }
488 }
489
490 /**
491 * @tc.name: AbilityManagerClient_CleanAllMissions_0100
492 * @tc.desc: CleanAllMissions
493 * @tc.type: FUNC
494 * @tc.require: issue
495 */
496 HWTEST_F(AbilityManagerClientBranchTest, CleanAllMissions_0100, TestSize.Level1)
497 {
498 EXPECT_TRUE(client_ != nullptr);
499 auto result = client_->CleanAllMissions();
500 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
501 EXPECT_EQ(result, ERR_OK);
502 }
503 }
504
505 /**
506 * @tc.name: AbilityManagerClient_MoveMissionToFront_0100
507 * @tc.desc: MoveMissionToFront
508 * @tc.type: FUNC
509 * @tc.require: issue
510 */
511 HWTEST_F(AbilityManagerClientBranchTest, MoveMissionToFront_0100, TestSize.Level1)
512 {
513 auto result = client_->MoveMissionToFront(10);
514 EXPECT_EQ(result, ERR_OK);
515 }
516
517 /**
518 * @tc.name: AbilityManagerClient_MoveMissionToFront_0200
519 * @tc.desc: MoveMissionToFront
520 * @tc.type: FUNC
521 * @tc.require: issue
522 */
523 HWTEST_F(AbilityManagerClientBranchTest, MoveMissionToFront_0200, TestSize.Level1)
524 {
525 StartOptions startOptions;
526 auto result = client_->MoveMissionToFront(1, startOptions);
527 EXPECT_EQ(result, ERR_OK);
528 }
529
530
531 /**
532 * @tc.name: AbilityManagerClient_MoveMissionsToForeground_0100
533 * @tc.desc: MoveMissionsToForeground
534 * @tc.type: FUNC
535 * @tc.require: issue
536 */
537 HWTEST_F(AbilityManagerClientBranchTest, MoveMissionsToForeground_0100, TestSize.Level1)
538 {
539 EXPECT_TRUE(client_ != nullptr);
540 auto result = client_->MoveMissionsToForeground({1, 2, 3}, 1);
541 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
542 EXPECT_EQ(result, ERR_OK);
543 }
544 }
545
546 /**
547 * @tc.name: AbilityManagerClient_MoveMissionsToForeground_0200
548 * @tc.desc: MoveMissionsToForeground
549 * @tc.type: FUNC
550 * @tc.require: issue
551 */
552 HWTEST_F(AbilityManagerClientBranchTest, MoveMissionsToForeground_0200, TestSize.Level1)
553 {
554 EXPECT_TRUE(client_ != nullptr);
555 auto result = client_->MoveMissionsToForeground({1, 2, 3}, 1);
556 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
557 EXPECT_EQ(result, ERR_OK);
558 }
559 }
560
561 /**
562 * @tc.name: AbilityManagerClient_MoveMissionsToBackground_0100
563 * @tc.desc: MoveMissionsToBackground
564 * @tc.type: FUNC
565 * @tc.require: issue
566 */
567 HWTEST_F(AbilityManagerClientBranchTest, MoveMissionsToBackground_0100, TestSize.Level1)
568 {
569 EXPECT_TRUE(client_ != nullptr);
570 std::vector<int32_t> rs;
571 auto result = client_->MoveMissionsToBackground({1, 2, 3}, rs);
572 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
573 EXPECT_EQ(result, ERR_OK);
574 }
575 }
576
577 /**
578 * @tc.name: AbilityManagerClient_MoveMissionsToBackground_0100
579 * @tc.desc: MoveMissionsToBackground
580 * @tc.type: FUNC
581 * @tc.require: issue
582 */
583 HWTEST_F(AbilityManagerClientBranchTest, MoveMissionsToBackground_0200, TestSize.Level1)
584 {
585 std::vector<int32_t> rs;
586 EXPECT_TRUE(client_ != nullptr);
587 auto result = client_->MoveMissionsToBackground({1, 2, 3}, rs);
588 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
589 EXPECT_EQ(result, ERR_OK);
590 }
591 }
592
593 /**
594 * @tc.name: AbilityManagerClient_GetAbilityRunningInfos_0100
595 * @tc.desc: GetAbilityRunningInfos
596 * @tc.type: FUNC
597 * @tc.require: issue
598 */
599 HWTEST_F(AbilityManagerClientBranchTest, GetAbilityRunningInfos_0100, TestSize.Level1)
600 {
601 std::vector<AbilityRunningInfo> myInfo;
602 auto result = client_->GetAbilityRunningInfos(myInfo);
603 EXPECT_EQ(result, ERR_OK);
604 }
605
606 /**
607 * @tc.name: AbilityManagerClient_ScheduleCommandAbilityDone_0100
608 * @tc.desc: ScheduleCommandAbilityDone
609 * @tc.type: FUNC
610 */
611 HWTEST_F(AbilityManagerClientBranchTest, ScheduleCommandAbilityDone_0100, TestSize.Level1)
612 {
613 sptr<IRemoteObject> token = nullptr;
614 auto result = client_->ScheduleCommandAbilityDone(token);
615 EXPECT_EQ(ERR_OK, result);
616 }
617
618 /**
619 * @tc.name: AbilityManagerClient_ScheduleCommandAbilityWindowDone_0100
620 * @tc.desc: ScheduleCommandAbilityWindowDone
621 * @tc.type: FUNC
622 */
623 HWTEST_F(AbilityManagerClientBranchTest, ScheduleCommandAbilityWindowDone_0100, TestSize.Level1)
624 {
625 sptr<IRemoteObject> token = nullptr;
626 sptr<SessionInfo> sessionInfo(new SessionInfo());
627 auto result = client_->ScheduleCommandAbilityWindowDone(
628 token, sessionInfo, WIN_CMD_FOREGROUND, ABILITY_CMD_FOREGROUND);
629 EXPECT_EQ(ERR_OK, result);
630 }
631
632 /**
633 * @tc.name: AbilityManagerClient_MoveAbilityToBackground_0100
634 * @tc.desc: MoveAbilityToBackground
635 * @tc.type: FUNC
636 */
637 HWTEST_F(AbilityManagerClientBranchTest, MoveAbilityToBackground_0100, TestSize.Level1)
638 {
639 sptr<IRemoteObject> token = nullptr;
640 auto result = client_->MoveAbilityToBackground(token);
641 EXPECT_EQ(ERR_OK, result);
642 }
643
644 /**
645 * @tc.name: AbilityManagerClient_MoveUIAbilityToBackground_0100
646 * @tc.desc: MoveUIAbilityToBackground
647 * @tc.type: FUNC
648 */
649 HWTEST_F(AbilityManagerClientBranchTest, MoveUIAbilityToBackground_0100, TestSize.Level1)
650 {
651 sptr<IRemoteObject> token = nullptr;
652 auto result = client_->MoveUIAbilityToBackground(token);
653 EXPECT_EQ(ERR_OK, result);
654 }
655
656 /**
657 * @tc.name: AbilityManagerClient_CloseAbility_0100
658 * @tc.desc: CloseAbility
659 * @tc.type: FUNC
660 */
661 HWTEST_F(AbilityManagerClientBranchTest, CloseAbility_0100, TestSize.Level1)
662 {
663 sptr<IRemoteObject> token = nullptr;
664 Want resultWant;
665 auto result = client_->CloseAbility(token, DEFAULT_INVAL_VALUE, &resultWant);
666 EXPECT_EQ(ERR_OK, result);
667 }
668
669 /**
670 * @tc.name: AbilityManagerClient_ConnectDataShareExtensionAbility_0100
671 * @tc.desc: ConnectDataShareExtensionAbility
672 * @tc.type: FUNC
673 */
674 HWTEST_F(AbilityManagerClientBranchTest, ConnectDataShareExtensionAbility_0100, TestSize.Level1)
675 {
676 sptr<IAbilityConnection> connect = nullptr;
677 Want want;
678 auto result = client_->ConnectDataShareExtensionAbility(want, connect, DEFAULT_INVAL_VALUE);
679 EXPECT_EQ(ERR_OK, result);
680 }
681
682 /**
683 * @tc.name: AbilityManagerClient_ConnectExtensionAbility_0100
684 * @tc.desc: ConnectExtensionAbility
685 * @tc.type: FUNC
686 */
687 HWTEST_F(AbilityManagerClientBranchTest, ConnectExtensionAbility_0100, TestSize.Level1)
688 {
689 sptr<IAbilityConnection> connect = nullptr;
690 Want want;
691 auto result = client_->ConnectExtensionAbility(want, connect, DEFAULT_INVAL_VALUE);
692 EXPECT_EQ(ERR_OK, result);
693 }
694
695 /**
696 * @tc.name: AbilityManagerClient_ReleaseDataAbility_0100
697 * @tc.desc: ReleaseDataAbility
698 * @tc.type: FUNC
699 */
700 HWTEST_F(AbilityManagerClientBranchTest, ReleaseDataAbility_0100, TestSize.Level1)
701 {
702 sptr<IAbilityScheduler> dataAbilityScheduler = nullptr;
703 sptr<IRemoteObject> callerToken = nullptr;
704 auto result = client_->ReleaseDataAbility(dataAbilityScheduler, callerToken);
705 EXPECT_EQ(ERR_OK, result);
706 }
707
708 /**
709 * @tc.name: AbilityManagerClient_KillProcess_0100
710 * @tc.desc: KillProcess
711 * @tc.type: FUNC
712 */
713 HWTEST_F(AbilityManagerClientBranchTest, KillProcess_0100, TestSize.Level1)
714 {
715 auto result = client_->KillProcess(BUNDLE_NAME);
716 EXPECT_EQ(ERR_OK, result);
717 }
718
719 /**
720 * @tc.name: AbilityManagerClient_ContinueMission_0100
721 * @tc.desc: ContinueMission
722 * @tc.type: FUNC
723 */
724 HWTEST_F(AbilityManagerClientBranchTest, ContinueMission_0100, TestSize.Level1)
725 {
726 GTEST_LOG_(INFO) << "ContinueMission_0100 start";
727 std::string srcDeviceId = "123";
728 std::string dstDeviceId = "ABC";
729 int32_t missionId = 5;
730 sptr<IRemoteObject> callback = nullptr;
731 WantParams wantParams;
732 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
733
734 EXPECT_EQ(result, ERR_INVALID_VALUE);
735 GTEST_LOG_(INFO) << "ContinueMission_0100 end";
736 }
737
738 /**
739 * @tc.name: AbilityManagerClient_ContinueMission_0200
740 * @tc.desc: ContinueMission
741 * @tc.type: FUNC
742 */
743 HWTEST_F(AbilityManagerClientBranchTest, ContinueMission_0200, TestSize.Level1)
744 {
745 GTEST_LOG_(INFO) << "ContinueMission_0200 start";
746 std::string srcDeviceId = "";
747 std::string dstDeviceId = "ABC";
748 int32_t missionId = 5;
749 sptr<IRemoteObject> callback = nullptr;
750 WantParams wantParams;
751 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
752
753 EXPECT_EQ(result, ERR_INVALID_VALUE);
754 GTEST_LOG_(INFO) << "ContinueMission_0200 end";
755 }
756
757 /**
758 * @tc.name: AbilityManagerClient_ContinueMission_0300
759 * @tc.desc: ContinueMission
760 * @tc.type: FUNC
761 */
762 HWTEST_F(AbilityManagerClientBranchTest, ContinueMission_0300, TestSize.Level1)
763 {
764 GTEST_LOG_(INFO) << "ContinueMission_0300 start";
765 std::string srcDeviceId = "123";
766 std::string dstDeviceId = "";
767 int32_t missionId = 5;
768 sptr<IRemoteObject> callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback();
769 WantParams wantParams;
770 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
771
772 EXPECT_EQ(result, ERR_INVALID_VALUE);
773 GTEST_LOG_(INFO) << "ContinueMission_0300 end";
774 }
775
776 /**
777 * @tc.name: AbilityManagerClient_ContinueMission_0400
778 * @tc.desc: ContinueMission
779 * @tc.type: FUNC
780 */
781 HWTEST_F(AbilityManagerClientBranchTest, ContinueMission_0400, TestSize.Level1)
782 {
783 GTEST_LOG_(INFO) << "ContinueMission_0400 start";
784 std::string srcDeviceId = "";
785 std::string dstDeviceId = "ABC";
786 int32_t missionId = 5;
787 sptr<IRemoteObject> callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback();
788 WantParams wantParams;
789 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
790
791 EXPECT_EQ(result, ERR_INVALID_VALUE);
792 GTEST_LOG_(INFO) << "ContinueMission_0400 end";
793 }
794
795 /**
796 * @tc.name: AbilityManagerClient_ContinueMission_0500
797 * @tc.desc: ContinueMission
798 * @tc.type: FUNC
799 */
800 HWTEST_F(AbilityManagerClientBranchTest, ContinueMission_0500, TestSize.Level1)
801 {
802 GTEST_LOG_(INFO) << "ContinueMission_0500 start";
803 std::string srcDeviceId = "";
804 std::string dstDeviceId = "";
805 int32_t missionId = 5;
806 sptr<IRemoteObject> callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback();
807 WantParams wantParams;
808 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
809
810 EXPECT_EQ(result, ERR_INVALID_VALUE);
811 GTEST_LOG_(INFO) << "ContinueMission_0500 end";
812 }
813
814 /**
815 * @tc.name: AbilityManagerClient_ContinueMission_0600
816 * @tc.desc: ContinueMission
817 * @tc.type: FUNC
818 */
819 HWTEST_F(AbilityManagerClientBranchTest, ContinueMission_0600, TestSize.Level1)
820 {
821 GTEST_LOG_(INFO) << "ContinueMission_0600 start";
822 std::string srcDeviceId = "123";
823 std::string dstDeviceId = "";
824 int32_t missionId = 5;
825 sptr<IRemoteObject> callback = nullptr;
826 WantParams wantParams;
827 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
828
829 EXPECT_EQ(result, ERR_INVALID_VALUE);
830 GTEST_LOG_(INFO) << "ContinueMission_0600 end";
831 }
832
833 /**
834 * @tc.name: AbilityManagerClient_ContinueMission_0700
835 * @tc.desc: ContinueMission
836 * @tc.type: FUNC
837 */
838 HWTEST_F(AbilityManagerClientBranchTest, ContinueMission_0700, TestSize.Level1)
839 {
840 GTEST_LOG_(INFO) << "ContinueMission_0700 start";
841 std::string srcDeviceId = "123";
842 std::string dstDeviceId = "ABC";
843 int32_t missionId = 5;
844 sptr<IRemoteObject> callback = new (std::nothrow) OHOS::AAFwk::AbilityConnectCallback();
845 WantParams wantParams;
846 auto result = client_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callback, wantParams);
847
848 EXPECT_EQ(result, ERR_OK);
849 GTEST_LOG_(INFO) << "ContinueMission_0700 end";
850 }
851
852 /**
853 * @tc.name: AbilityManagerClient_NotifyCompleteContinuation_0100
854 * @tc.desc: NotifyCompleteContinuation
855 * @tc.type: FUNC
856 */
857 HWTEST_F(AbilityManagerClientBranchTest, NotifyCompleteContinuation_0100, TestSize.Level1)
858 {
859 GTEST_LOG_(INFO) << "NotifyCompleteContinuation_0100 start";
860 std::string deviceId = BUNDLE_NAME;
861 int32_t sessionId = 1;
862 bool isSuccess = true;
863 client_->NotifyCompleteContinuation(deviceId, sessionId, isSuccess);
864
865 EXPECT_TRUE(client_ != nullptr);
866 GTEST_LOG_(INFO) << "NotifyCompleteContinuation_0100 end";
867 }
868
869 /**
870 * @tc.name: AbilityManagerClient_GetMissionIdByToken_0100
871 * @tc.desc: GetMissionIdByToken
872 * @tc.type: FUNC
873 */
874 HWTEST_F(AbilityManagerClientBranchTest, GetMissionIdByToken_0100, TestSize.Level1)
875 {
876 GTEST_LOG_(INFO) << "GetMissionIdByToken_0100 start";
877 sptr<IRemoteObject> token = nullptr;
878 int32_t missionId = 1;
879 auto result = client_->GetMissionIdByToken(token, missionId);
880
881 EXPECT_EQ(result, MISSION_NOT_FOUND);
882 GTEST_LOG_(INFO) << "GetMissionIdByToken_0100 end";
883 }
884
885 /**
886 * @tc.name: AbilityManagerClient_GetExtensionRunningInfos_0100
887 * @tc.desc: GetExtensionRunningInfos
888 * @tc.type: FUNC
889 */
890 HWTEST_F(AbilityManagerClientBranchTest, GetExtensionRunningInfos_0100, TestSize.Level1)
891 {
892 GTEST_LOG_(INFO) << "GetExtensionRunningInfos_0100 start";
893 EXPECT_CALL(*mock_, GetExtensionRunningInfos(_, _))
894 .Times(1)
895 .WillOnce(Return(0));
896 int upperLimit = 1;
897 std::vector<ExtensionRunningInfo> info;
898 auto result = client_->GetExtensionRunningInfos(upperLimit, info);
899
900 EXPECT_EQ(result, ERR_OK);
901 GTEST_LOG_(INFO) << "GetExtensionRunningInfos_0100 end";
902 }
903
904 /**
905 * @tc.name: AbilityManagerClient_GetProcessRunningInfos_0100
906 * @tc.desc: GetProcessRunningInfos
907 * @tc.type: FUNC
908 */
909 HWTEST_F(AbilityManagerClientBranchTest, GetProcessRunningInfos_0100, TestSize.Level1)
910 {
911 GTEST_LOG_(INFO) << "GetProcessRunningInfos_0100 start";
912 EXPECT_CALL(*mock_, GetProcessRunningInfos(_))
913 .Times(1)
914 .WillOnce(Return(0));
915 std::vector<RunningProcessInfo> info;
916 auto result = client_->GetProcessRunningInfos(info);
917
918 EXPECT_EQ(result, ERR_OK);
919 GTEST_LOG_(INFO) << "GetProcessRunningInfos_0100 end";
920 }
921
922 /**
923 * @tc.name: AbilityManagerClient_StartSyncRemoteMissions_0100
924 * @tc.desc: StartSyncRemoteMissions
925 * @tc.type: FUNC
926 */
927 HWTEST_F(AbilityManagerClientBranchTest, StartSyncRemoteMissions_0100, TestSize.Level1)
928 {
929 GTEST_LOG_(INFO) << "StartSyncRemoteMissions_0100 start";
930 std::string devId = BUNDLE_NAME;
931 bool fixConflict = true;
932 int64_t tag = 1;
933 auto result = client_->StartSyncRemoteMissions(devId, fixConflict, tag);
934
935 EXPECT_EQ(result, ERR_OK);
936 GTEST_LOG_(INFO) << "StartSyncRemoteMissions_0100 end";
937 }
938
939 /**
940 * @tc.name: AbilityManagerClient_StopSyncRemoteMissions_0100
941 * @tc.desc: StopSyncRemoteMissions
942 * @tc.type: FUNC
943 */
944 HWTEST_F(AbilityManagerClientBranchTest, StopSyncRemoteMissions_0100, TestSize.Level1)
945 {
946 GTEST_LOG_(INFO) << "StopSyncRemoteMissions_0100 start";
947 std::string devId = BUNDLE_NAME;
948 auto result = client_->StopSyncRemoteMissions(devId);
949
950 EXPECT_EQ(result, ERR_OK);
951 GTEST_LOG_(INFO) << "StopSyncRemoteMissions_0100 end";
952 }
953
954 /**
955 * @tc.name: AbilityManagerClient_StartUser_0100
956 * @tc.desc: StartUser
957 * @tc.type: FUNC
958 */
959 HWTEST_F(AbilityManagerClientBranchTest, StartUser_0100, TestSize.Level1)
960 {
961 GTEST_LOG_(INFO) << "StartUser_0100 start";
962 int userId = 1;
963 auto result = client_->StartUser(userId, nullptr);
964
965 EXPECT_EQ(result, ERR_OK);
966 GTEST_LOG_(INFO) << "StartUser_0100 end";
967 }
968
969 /**
970 * @tc.name: AbilityManagerClient_StopUser_0100
971 * @tc.desc: StopUser
972 * @tc.type: FUNC
973 */
974 HWTEST_F(AbilityManagerClientBranchTest, StopUser_0100, TestSize.Level1)
975 {
976 GTEST_LOG_(INFO) << "StopUser_0100 start";
977 int userId = 1;
978 sptr<IUserCallback> callback = nullptr;
979 auto result = client_->StopUser(userId, callback);
980
981 EXPECT_EQ(result, ERR_OK);
982 GTEST_LOG_(INFO) << "StopUser_0100 end";
983 }
984
985 /**
986 * @tc.name: AbilityManagerClient_RegisterSnapshotHandler_0100
987 * @tc.desc: RegisterSnapshotHandler
988 * @tc.type: FUNC
989 */
990 HWTEST_F(AbilityManagerClientBranchTest, RegisterSnapshotHandler_0100, TestSize.Level1)
991 {
992 GTEST_LOG_(INFO) << "RegisterSnapshotHandler_0100 start";
993 sptr<ISnapshotHandler> handler = nullptr;
994 auto result = client_->RegisterSnapshotHandler(handler);
995
996 EXPECT_EQ(result, ERR_OK);
997 GTEST_LOG_(INFO) << "RegisterSnapshotHandler_0100 end";
998 }
999
1000 /**
1001 * @tc.name: AbilityManagerClient_RegisterWindowManagerServiceHandler_0100
1002 * @tc.desc: RegisterWindowManagerServiceHandler
1003 * @tc.type: FUNC
1004 */
1005 HWTEST_F(AbilityManagerClientBranchTest, RegisterWindowManagerServiceHandler_0100, TestSize.Level1)
1006 {
1007 GTEST_LOG_(INFO) << "RegisterWindowManagerServiceHandler_0100 start";
1008 sptr<IWindowManagerServiceHandler> handler = nullptr;
1009 auto result = client_->RegisterWindowManagerServiceHandler(handler);
1010
1011 EXPECT_EQ(result, ERR_OK);
1012 GTEST_LOG_(INFO) << "RegisterWindowManagerServiceHandler_0100 end";
1013 }
1014
1015 /**
1016 * @tc.name: AbilityManagerClient_CompleteFirstFrameDrawing_0100
1017 * @tc.desc: CompleteFirstFrameDrawing
1018 * @tc.type: FUNC
1019 */
1020 HWTEST_F(AbilityManagerClientBranchTest, CompleteFirstFrameDrawing_0100, TestSize.Level1)
1021 {
1022 GTEST_LOG_(INFO) << "CompleteFirstFrameDrawing_0100 start";
1023 sptr<IRemoteObject> abilityToken = nullptr;
1024 client_->CompleteFirstFrameDrawing(abilityToken);
1025
1026 EXPECT_TRUE(client_ != nullptr);
1027 GTEST_LOG_(INFO) << "CompleteFirstFrameDrawing_0100 end";
1028 }
1029
1030 /**
1031 * @tc.name: AbilityManagerClient_StartUserTest_0100
1032 * @tc.desc: StartUserTest
1033 * @tc.type: FUNC
1034 */
1035 HWTEST_F(AbilityManagerClientBranchTest, StartUserTest_0100, TestSize.Level1)
1036 {
1037 GTEST_LOG_(INFO) << "StartUserTest_0100 start";
1038 Want want;
1039 sptr<IRemoteObject> observer = nullptr;
1040 auto result = client_->StartUserTest(want, observer);
1041
1042 EXPECT_EQ(result, ERR_OK);
1043 GTEST_LOG_(INFO) << "StartUserTest_0100 end";
1044 }
1045
1046 /**
1047 * @tc.name: AbilityManagerClient_FinishUserTest_0100
1048 * @tc.desc: FinishUserTest
1049 * @tc.type: FUNC
1050 */
1051 HWTEST_F(AbilityManagerClientBranchTest, FinishUserTest_0100, TestSize.Level1)
1052 {
1053 GTEST_LOG_(INFO) << "FinishUserTest_0100 start";
1054 std::string msg = "msg";
1055 int64_t resultCode = 0;
1056 std::string bundleName = "bundleName_test";
1057 auto result = client_->FinishUserTest(msg, resultCode, bundleName);
1058
1059 EXPECT_EQ(result, ERR_OK);
1060 GTEST_LOG_(INFO) << "FinishUserTest_0100 end";
1061 }
1062
1063 /**
1064 * @tc.name: AbilityManagerClient_DoAbilityForeground_0100
1065 * @tc.desc: DoAbilityForeground
1066 * @tc.type: FUNC
1067 */
1068 HWTEST_F(AbilityManagerClientBranchTest, DoAbilityForeground_0100, TestSize.Level1)
1069 {
1070 GTEST_LOG_(INFO) << "DoAbilityForeground_0100 start";
1071 sptr<IRemoteObject> token = nullptr;
1072 uint32_t flag = 1;
1073 auto result = client_->DoAbilityForeground(token, flag);
1074
1075 EXPECT_EQ(result, ERR_OK);
1076 GTEST_LOG_(INFO) << "DoAbilityForeground_0100 end";
1077 }
1078
1079 /**
1080 * @tc.name: AbilityManagerClient_DoAbilityBackground_0100
1081 * @tc.desc: DoAbilityBackground
1082 * @tc.type: FUNC
1083 */
1084 HWTEST_F(AbilityManagerClientBranchTest, DoAbilityBackground_0100, TestSize.Level1)
1085 {
1086 GTEST_LOG_(INFO) << "DoAbilityBackground_0100 start";
1087 sptr<IRemoteObject> token = nullptr;
1088 uint32_t flag = 1;
1089 auto result = client_->DoAbilityBackground(token, flag);
1090
1091 EXPECT_EQ(result, ERR_OK);
1092 GTEST_LOG_(INFO) << "DoAbilityBackground_0100 end";
1093 }
1094
1095 /**
1096 *
1097 * @tc.name: AbilityManagerClient_SetAbilityController_0100
1098 * @tc.desc: SetAbilityController
1099 * @tc.type: FUNC
1100 */
1101 HWTEST_F(AbilityManagerClientBranchTest, SetAbilityController_0100, TestSize.Level1)
1102 {
1103 GTEST_LOG_(INFO) << "SetAbilityController_0100 start";
1104 sptr<IAbilityController> abilityController = nullptr;
1105 bool imAStabilityTest = 0;
1106 auto result = client_->SetAbilityController(abilityController, imAStabilityTest);
1107
1108 EXPECT_EQ(result, ERR_OK);
1109 GTEST_LOG_(INFO) << "SetAbilityController_0100 end";
1110 }
1111
1112 /**
1113 * @tc.name: AbilityManagerClient_DumpAbilityInfoDone_0100
1114 * @tc.desc: DumpAbilityInfoDone
1115 * @tc.type: FUNC
1116 */
1117 HWTEST_F(AbilityManagerClientBranchTest, DumpAbilityInfoDone_0100, TestSize.Level1)
1118 {
1119 GTEST_LOG_(INFO) << "DumpAbilityInfoDone_0100 start";
1120 std::vector<std::string> infos;
1121 infos.emplace_back("DumpAbilityInfoDone");
1122 sptr<IRemoteObject> callerToken = nullptr;
1123 auto result = client_->DumpAbilityInfoDone(infos, callerToken);
1124
1125 EXPECT_EQ(ERR_OK, result);
1126 GTEST_LOG_(INFO) << "DumpAbilityInfoDone_0100 end";
1127 }
1128
1129 /**
1130 * @tc.name: AbilityManagerClient_FreeInstallAbilityFromRemote_0100
1131 * @tc.desc: FreeInstallAbilityFromRemote
1132 * @tc.type: FUNC
1133 */
1134 HWTEST_F(AbilityManagerClientBranchTest, FreeInstallAbilityFromRemote_0100, TestSize.Level1)
1135 {
1136 GTEST_LOG_(INFO) << "FreeInstallAbilityFromRemote_0100 start";
1137 Want want;
1138 sptr<IRemoteObject> callback = nullptr;
1139 int32_t userId = 0;
1140 auto result = client_->FreeInstallAbilityFromRemote(want, callback, userId);
1141
1142 EXPECT_EQ(ERR_OK, result);
1143 GTEST_LOG_(INFO) << "FreeInstallAbilityFromRemote_0100 end";
1144 }
1145
1146 /**
1147 * @tc.name: AbilityManagerClient_OnRemoteDied_0100
1148 * @tc.desc: OnRemoteDied
1149 * @tc.type: FUNC
1150 */
1151 HWTEST_F(AbilityManagerClientBranchTest, OnRemoteDied_0100, TestSize.Level1)
1152 {
1153 GTEST_LOG_(INFO) << "OnRemoteDied_0100 start";
1154 AbilityManagerClient::AbilityMgrDeathRecipient recipient;
1155 wptr<IRemoteObject> remote = nullptr;
1156 recipient.OnRemoteDied(remote);
1157
1158 EXPECT_TRUE(client_ != nullptr);
1159 GTEST_LOG_(INFO) << "OnRemoteDied_0100 end";
1160 }
1161
1162 /**
1163 * @tc.name: AbilityManagerClient_CallRequestDone_0100
1164 * @tc.desc: CallRequestDone
1165 * @tc.type: FUNC
1166 */
1167 HWTEST_F(AbilityManagerClientBranchTest, CallRequestDone_0100, TestSize.Level1)
1168 {
1169 GTEST_LOG_(INFO) << "CallRequestDone_0100 start";
1170 sptr<IRemoteObject> token = nullptr;
1171 sptr<IRemoteObject> callStub = nullptr;
1172 client_->CallRequestDone(token, callStub);
1173
1174 EXPECT_TRUE(client_ != nullptr);
1175 GTEST_LOG_(INFO) << "CallRequestDone_0100 end";
1176 }
1177
1178
1179 /**
1180 * @tc.name: AbilityManagerClient_IsValidMissionIds_0100
1181 * @tc.desc: CallRequestDone
1182 * @tc.type: FUNC
1183 */
1184 HWTEST_F(AbilityManagerClientBranchTest, IsValidMissionIds_0100, TestSize.Level1)
1185 {
1186 GTEST_LOG_(INFO) << "IsValidMissionIds_0100 start";
1187 EXPECT_TRUE(client_ != nullptr);
1188 std::vector<int32_t> missionIds;
1189 std::vector<MissionValidResult> results;
1190 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1191 EXPECT_CALL(*mock_, IsValidMissionIds(_, _)).Times(1).WillOnce(Return(ERR_OK));
1192 EXPECT_EQ(client_->IsValidMissionIds(missionIds, results), ERR_OK);
1193 EXPECT_CALL(*mock_, IsValidMissionIds(_, _)).Times(1).WillOnce(Return(ERR_OK));
1194 EXPECT_EQ(client_->IsValidMissionIds(missionIds, results), ERR_OK);
1195 }
1196 GTEST_LOG_(INFO) << "IsValidMissionIds_0100 end";
1197 }
1198
1199 /**
1200 * @tc.name: AbilityManagerClient_StartAbilityAsCaller_0100
1201 * @tc.desc: StartAbilityAsCaller
1202 * @tc.type: FUNC
1203 */
1204 HWTEST_F(AbilityManagerClientBranchTest, StartAbilityAsCaller_0100, TestSize.Level1)
1205 {
1206 GTEST_LOG_(INFO) << "StartAbilityAsCaller_0100 start";
1207 Want want;
1208 sptr<IRemoteObject> callerToken = nullptr;
1209 int requestCode = 1;
1210 int32_t userId = 2;
1211 EXPECT_EQ(client_->StartAbilityAsCaller(want, callerToken, nullptr, requestCode, userId), ERR_OK);
1212 GTEST_LOG_(INFO) << "StartAbilityAsCaller_0100 end";
1213 }
1214
1215 /**
1216 * @tc.name: AbilityManagerClient_StartAbilityAsCaller_0200
1217 * @tc.desc: StartAbilityAsCaller
1218 * @tc.type: FUNC
1219 */
1220 HWTEST_F(AbilityManagerClientBranchTest, StartAbilityAsCaller_0200, TestSize.Level1)
1221 {
1222 GTEST_LOG_(INFO) << "StartAbilityAsCaller_0200 start";
1223 Want want;
1224 StartOptions startOptions;
1225 sptr<IRemoteObject> callerToken = nullptr;
1226 int requestCode = 1;
1227 int32_t userId = 2;
1228 EXPECT_EQ(client_->StartAbilityAsCaller(want, startOptions, callerToken, nullptr, requestCode, userId), ERR_OK);
1229 GTEST_LOG_(INFO) << "StartAbilityAsCaller_0200 end";
1230 }
1231
1232 /**
1233 * @tc.name: AbilityManagerClient_StartAbilityForResultAsCaller_0100
1234 * @tc.desc: StartAbilityForResultAsCaller
1235 * @tc.type: FUNC
1236 */
1237 HWTEST_F(AbilityManagerClientBranchTest, StartAbilityForResultAsCaller_0100, TestSize.Level1)
1238 {
1239 GTEST_LOG_(INFO) << "StartAbilityForResultAsCaller_0100 start";
1240 Want want;
1241 sptr<IRemoteObject> callerToken = nullptr;
1242 int requestCode = 1;
1243 int32_t userId = 2;
1244 EXPECT_EQ(client_->StartAbilityForResultAsCaller(want, callerToken, requestCode, userId), ERR_OK);
1245 GTEST_LOG_(INFO) << "StartAbilityForResultAsCaller_0100 end";
1246 }
1247
1248 /**
1249 * @tc.name: AbilityManagerClient_StartAbilityForResultAsCaller_0200
1250 * @tc.desc: StartAbilityForResultAsCaller
1251 * @tc.type: FUNC
1252 */
1253 HWTEST_F(AbilityManagerClientBranchTest, StartAbilityForResultAsCaller_0200, TestSize.Level1)
1254 {
1255 GTEST_LOG_(INFO) << "StartAbilityForResultAsCaller_0200 start";
1256 Want want;
1257 StartOptions startOptions;
1258 sptr<IRemoteObject> callerToken = nullptr;
1259 int requestCode = 1;
1260 int32_t userId = 2;
1261 EXPECT_EQ(
1262 client_->StartAbilityForResultAsCaller(want, startOptions, callerToken, requestCode, userId), ERR_OK);
1263 GTEST_LOG_(INFO) << "StartAbilityForResultAsCaller_0200 end";
1264 }
1265
1266 /**
1267 * @tc.name: AbilityManagerClient_StartUIExtensionAbility_0100
1268 * @tc.desc: StartUIExtensionAbility
1269 * @tc.type: FUNC
1270 */
1271 HWTEST_F(AbilityManagerClientBranchTest, StartUIExtensionAbility_0100, TestSize.Level1)
1272 {
1273 GTEST_LOG_(INFO) << "StartUIExtensionAbility_0100 start";
1274 Want want;
1275 EXPECT_EQ(client_->StartUIExtensionAbility(nullptr, 100), ERR_INVALID_VALUE);
1276 GTEST_LOG_(INFO) << "StartUIExtensionAbility_0100 end";
1277 }
1278
1279 /**
1280 * @tc.name: AbilityManagerClient_TerminateUIExtensionAbility_0100
1281 * @tc.desc: TerminateUIExtensionAbility
1282 * @tc.type: FUNC
1283 */
1284 HWTEST_F(AbilityManagerClientBranchTest, TerminateUIExtensionAbility_0100, TestSize.Level1)
1285 {
1286 GTEST_LOG_(INFO) << "TerminateUIExtensionAbility_0100 start";
1287 Want* resultWant = nullptr;
1288 EXPECT_EQ(client_->TerminateUIExtensionAbility(nullptr, 1, resultWant), ERR_INVALID_VALUE);
1289 GTEST_LOG_(INFO) << "TerminateUIExtensionAbility_0100 end";
1290 }
1291
1292 /**
1293 * @tc.name: AbilityManagerClient_MinimizeUIExtensionAbility_0100
1294 * @tc.desc: MinimizeUIExtensionAbility
1295 * @tc.type: FUNC
1296 */
1297 HWTEST_F(AbilityManagerClientBranchTest, MinimizeUIExtensionAbility_0100, TestSize.Level1)
1298 {
1299 GTEST_LOG_(INFO) << "MinimizeUIExtensionAbility_0100 start";
1300 EXPECT_EQ(client_->MinimizeUIExtensionAbility(nullptr, true), ERR_INVALID_VALUE);
1301 GTEST_LOG_(INFO) << "MinimizeUIExtensionAbility_0100 end";
1302 }
1303
1304 /**
1305 * @tc.name: AbilityManagerClient_CheckUIExtensionIsFocused_0100
1306 * @tc.desc: CheckUIExtensionIsFocused
1307 * @tc.type: FUNC
1308 */
1309 HWTEST_F(AbilityManagerClientBranchTest, CheckUIExtensionIsFocused_0100, TestSize.Level1)
1310 {
1311 GTEST_LOG_(INFO) << "CheckUIExtensionIsFocused_0100 start";
1312 bool isFocused = false;
1313 EXPECT_EQ(client_->CheckUIExtensionIsFocused(0, isFocused), ERR_OK);
1314 GTEST_LOG_(INFO) << "CheckUIExtensionIsFocused_0100 end";
1315 }
1316
1317 #ifdef ABILITY_COMMAND_FOR_TEST
1318 /**
1319 * @tc.name: AbilityManagerClient_ForceTimeoutForTest_0100
1320 * @tc.desc: ForceTimeoutForTest
1321 * @tc.type: FUNC
1322 */
1323 HWTEST_F(AbilityManagerClientBranchTest, ForceTimeoutForTest_001, TestSize.Level1)
1324 {
1325 EXPECT_TRUE(client_->ForceTimeoutForTest("clean", ""), ERR_OK);
1326 }
1327 #endif
1328
1329 /**
1330 * @tc.name: AbilityManagerClient_StartAbilityByCall_0200
1331 * @tc.desc: StartAbilityByCall
1332 * @tc.type: FUNC
1333 */
1334 HWTEST_F(AbilityManagerClientBranchTest, StartAbilityByCall_002, TestSize.Level1)
1335 {
1336 Want want;
1337 EXPECT_EQ(client_->StartAbilityByCall(want, nullptr), ERR_OK);
1338 client_->EnableRecoverAbility(nullptr);
1339 EXPECT_EQ(client_->AddFreeInstallObserver(nullptr, nullptr), ERR_OK);
1340 }
1341
1342 /**
1343 * @tc.name: AbilityManagerClient_StartUIAbilityBySCB_0100
1344 * @tc.desc: StartUIAbilityBySCB
1345 * @tc.type: FUNC
1346 */
1347 HWTEST_F(AbilityManagerClientBranchTest, StartUIAbilityBySCB_001, TestSize.Level1)
1348 {
1349 bool isColdStart = false;
1350 EXPECT_EQ(client_->StartUIAbilityBySCB(nullptr, isColdStart), ERR_INVALID_VALUE);
1351 }
1352
1353 /**
1354 * @tc.name: AbilityManagerClient_StartUIAbilityBySCB_0200
1355 * @tc.desc: StartUIAbilityBySCB
1356 * @tc.type: FUNC
1357 */
1358 HWTEST_F(AbilityManagerClientBranchTest, StartUIAbilityBySCB_002, TestSize.Level1)
1359 {
1360 sptr<SessionInfo> sessionInfo(new SessionInfo());
1361 bool isColdStart = false;
1362 EXPECT_EQ(client_->StartUIAbilityBySCB(sessionInfo, isColdStart), ERR_OK);
1363 }
1364
1365 /**
1366 * @tc.name: AbilityManagerClient_StartUIAbilityBySCB_0300
1367 * @tc.desc: StartUIAbilityBySCB
1368 * @tc.type: FUNC
1369 */
1370 HWTEST_F(AbilityManagerClientBranchTest, StartUIAbilityBySCB_003, TestSize.Level1)
1371 {
1372 Rosen::SessionInfo info;
1373 sptr<SessionInfo> sessionInfo(new SessionInfo());
1374 sessionInfo->sessionToken = new Rosen::Session(info);
1375 bool isColdStart = false;
1376 EXPECT_EQ(client_->StartUIAbilityBySCB(sessionInfo, isColdStart), ERR_OK);
1377 }
1378
1379 /**
1380 * @tc.name: AbilityManagerClient_MinimizeUIAbilityBySCB_0100
1381 * @tc.desc: MinimizeUIAbilityBySCB
1382 * @tc.type: FUNC
1383 */
1384 HWTEST_F(AbilityManagerClientBranchTest, MinimizeUIAbilityBySCB_001, TestSize.Level1)
1385 {
1386 EXPECT_EQ(client_->MinimizeUIAbilityBySCB(nullptr), ERR_INVALID_VALUE);
1387 }
1388
1389 /**
1390 * @tc.name: AbilityManagerClient_MinimizeUIAbilityBySCB_0200
1391 * @tc.desc: MinimizeUIAbilityBySCB
1392 * @tc.type: FUNC
1393 */
1394 HWTEST_F(AbilityManagerClientBranchTest, MinimizeUIAbilityBySCB_002, TestSize.Level1)
1395 {
1396 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
1397 EXPECT_EQ(client_->MinimizeUIAbilityBySCB(sessionInfo), ERR_OK);
1398 }
1399
1400 /**
1401 * @tc.name: AbilityManagerClient_MinimizeUIAbilityBySCB_0300
1402 * @tc.desc: MinimizeUIAbilityBySCB
1403 * @tc.type: FUNC
1404 */
1405 HWTEST_F(AbilityManagerClientBranchTest, MinimizeUIAbilityBySCB_003, TestSize.Level1)
1406 {
1407 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
1408 Rosen::SessionInfo info;
1409 sessionInfo->sessionToken = new (std::nothrow) Rosen::Session(info);
1410 EXPECT_EQ(client_->MinimizeUIAbilityBySCB(sessionInfo), ERR_OK);
1411 }
1412
1413 /**
1414 * @tc.name: AbilityManagerClient_CloseUIAbilityBySCB_0100
1415 * @tc.desc: CloseUIAbilityBySCB
1416 * @tc.type: FUNC
1417 */
1418 HWTEST_F(AbilityManagerClientBranchTest, CloseUIAbilityBySCB_001, TestSize.Level1)
1419 {
1420 EXPECT_EQ(client_->CloseUIAbilityBySCB(nullptr), ERR_INVALID_VALUE);
1421 }
1422
1423 /**
1424 * @tc.name: AbilityManagerClient_CloseUIAbilityBySCB_0200
1425 * @tc.desc: CloseUIAbilityBySCB
1426 * @tc.type: FUNC
1427 */
1428 HWTEST_F(AbilityManagerClientBranchTest, CloseUIAbilityBySCB_002, TestSize.Level1)
1429 {
1430 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
1431 EXPECT_EQ(client_->CloseUIAbilityBySCB(sessionInfo), ERR_OK);
1432 }
1433
1434 /**
1435 * @tc.name: AbilityManagerClient_CloseUIAbilityBySCB_0300
1436 * @tc.desc: CloseUIAbilityBySCB
1437 * @tc.type: FUNC
1438 */
1439 HWTEST_F(AbilityManagerClientBranchTest, CloseUIAbilityBySCB_003, TestSize.Level1)
1440 {
1441 sptr<SessionInfo> sessionInfo = new (std::nothrow) SessionInfo();
1442 Rosen::SessionInfo info;
1443 sessionInfo->sessionToken = new (std::nothrow) Rosen::Session(info);
1444 EXPECT_EQ(client_->CloseUIAbilityBySCB(sessionInfo), ERR_OK);
1445 }
1446
1447 /**
1448 * @tc.name: AbilityManagerClient_SetRootSceneSession_0100
1449 * @tc.desc: SetRootSceneSession
1450 * @tc.type: FUNC
1451 */
1452 HWTEST_F(AbilityManagerClientBranchTest, SetRootSceneSession_001, TestSize.Level1)
1453 {
1454 Rosen::SessionInfo info;
1455 sptr<Rosen::ISession> session = new Rosen::Session(info);
1456 EXPECT_NE(session, nullptr);
1457 sptr<IRemoteObject> rootSceneSession = session->AsObject();
1458 AbilityManagerClient::GetInstance()->SetRootSceneSession(rootSceneSession);
1459 EXPECT_NE(session, nullptr);
1460 }
1461
1462 /**
1463 * @tc.name: AbilityManagerClient_CallUIAbilityBySCB_0100
1464 * @tc.desc: CallUIAbilityBySCB
1465 * @tc.type: FUNC
1466 */
1467 HWTEST_F(AbilityManagerClientBranchTest, CallUIAbilityBySCB_001, TestSize.Level1)
1468 {
1469 sptr<SessionInfo> sessionInfo = new SessionInfo();
1470 bool isColdStart = false;
1471 AbilityManagerClient::GetInstance()->CallUIAbilityBySCB(sessionInfo, isColdStart);
1472 EXPECT_NE(sessionInfo, nullptr);
1473 }
1474
1475 /**
1476 * @tc.name: AbilityManagerClient_CallUIAbilityBySCB_0200
1477 * @tc.desc: CallUIAbilityBySCB
1478 * @tc.type: FUNC
1479 */
1480 HWTEST_F(AbilityManagerClientBranchTest, CallUIAbilityBySCB_002, TestSize.Level1)
1481 {
1482 sptr<SessionInfo> sessionInfo = new SessionInfo();
1483 EXPECT_NE(sessionInfo, nullptr);
1484 bool isColdStart = false;
1485 AbilityManagerClient::GetInstance()->CallUIAbilityBySCB(sessionInfo, isColdStart);
1486 EXPECT_NE(sessionInfo, nullptr);
1487 }
1488
1489 /**
1490 * @tc.name: AbilityManagerClient_ConnectAbility_0100
1491 * @tc.desc: ConnectAbility
1492 * @tc.type: FUNC
1493 */
1494 HWTEST_F(AbilityManagerClientBranchTest, ConnectAbility_0100, TestSize.Level1)
1495 {
1496 Want want;
1497 sptr<IAbilityConnection> connect = nullptr;
1498 int32_t userId = 1;
1499 EXPECT_EQ(client_->ConnectAbility(want, connect, userId), ERR_OK);
1500 }
1501
1502 /**
1503 * @tc.name: AbilityManagerClient_ConnectUIExtensionAbility_0100
1504 * @tc.desc: ConnectUIExtensionAbility
1505 * @tc.type: FUNC
1506 */
1507 HWTEST_F(AbilityManagerClientBranchTest, ConnectUIExtensionAbility_0100, TestSize.Level1)
1508 {
1509 Want want;
1510 sptr<IAbilityConnection> connect = nullptr;
1511 sptr<SessionInfo> sessionInfo = nullptr;
1512 int32_t userId = 1;
1513 EXPECT_EQ(client_->ConnectUIExtensionAbility(want, connect, sessionInfo, userId), ERR_OK);
1514 }
1515
1516 /**
1517 * @tc.name: AbilityManagerClient_GetMissionInfo_0100
1518 * @tc.desc: GetMissionInfo
1519 * @tc.type: FUNC
1520 */
1521 HWTEST_F(AbilityManagerClientBranchTest, GetMissionInfo_0100, TestSize.Level1)
1522 {
1523 EXPECT_TRUE(client_ != nullptr);
1524 std::string deviceId = "123";
1525 int32_t missionId = 1;
1526 MissionInfo missionInfo;
1527 auto result = client_->GetMissionInfo(deviceId, missionId, missionInfo);
1528 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
1529 EXPECT_EQ(result, ERR_OK);
1530 }
1531 }
1532
1533 /**
1534 * @tc.name: AbilityManagerClient_AcquireShareData_0100
1535 * @tc.desc: AcquireShareData
1536 * @tc.type: FUNC
1537 */
1538 HWTEST_F(AbilityManagerClientBranchTest, AcquireShareData_0100, TestSize.Level1)
1539 {
1540 int32_t missionId = 1;
1541 sptr<IAcquireShareDataCallback> shareData = nullptr;
1542 EXPECT_EQ(client_->AcquireShareData(missionId, shareData), ERR_OK);
1543 }
1544
1545 /**
1546 * @tc.name: AbilityManagerClient_ShareDataDone_0100
1547 * @tc.desc: ShareDataDone
1548 * @tc.type: FUNC
1549 */
1550 HWTEST_F(AbilityManagerClientBranchTest, ShareDataDone_0100, TestSize.Level1)
1551 {
1552 sptr<IRemoteObject> token = nullptr;
1553 int32_t resultCode = 1;
1554 int32_t uniqueId = 1;
1555 WantParams wantParam;
1556 EXPECT_EQ(client_->ShareDataDone(token, resultCode, uniqueId, wantParam), ERR_OK);
1557 }
1558
1559 /**
1560 * @tc.name: AbilityManagerClient_GetAbilityTokenByCalleeObj_0100
1561 * @tc.desc: GetAbilityTokenByCalleeObj
1562 * @tc.type: FUNC
1563 */
1564 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_GetAbilityTokenByCalleeObj_0100, TestSize.Level1)
1565 {
1566 sptr<IRemoteObject> callStub = nullptr;
1567 sptr<IRemoteObject> token = nullptr;
1568 client_->GetAbilityTokenByCalleeObj(callStub, token);
1569 EXPECT_TRUE(client_ != nullptr);
1570 }
1571
1572 /**
1573 * @tc.name: AbilityManagerClient_RegisterOnListener_0100
1574 * @tc.desc: RegisterOnListener
1575 * @tc.type: FUNC
1576 * @tc.require: issue
1577 */
1578 HWTEST_F(AbilityManagerClientBranchTest, RegisterOnListener_0100, TestSize.Level1)
1579 {
1580 std::string type = "";
1581 sptr<IRemoteOnListener> listener = nullptr;
1582 auto result = client_->RegisterOnListener(type, listener);
1583 EXPECT_EQ(result, ERR_OK);
1584 }
1585
1586 /**
1587 * @tc.name: AbilityManagerClient_RegisterOffListener_0100
1588 * @tc.desc: RegisterOffListener
1589 * @tc.type: FUNC
1590 * @tc.require: issue
1591 */
1592 HWTEST_F(AbilityManagerClientBranchTest, RegisterOffListener_0100, TestSize.Level1)
1593 {
1594 std::string type = "";
1595 sptr<IRemoteOnListener> listener = nullptr;
1596 auto result = client_->RegisterOffListener(type, listener);
1597 EXPECT_EQ(result, ERR_OK);
1598 }
1599
1600 /**
1601 * @tc.name: AbilityManagerClient_RegisterOffListener_0200
1602 * @tc.desc: RegisterOffListener
1603 * @tc.type: FUNC
1604 * @tc.require: issue
1605 */
1606 HWTEST_F(AbilityManagerClientBranchTest, RegisterOffListener_0200, TestSize.Level1)
1607 {
1608 std::string type = "continueStateChange";
1609 sptr<IRemoteOnListener> listener = nullptr;
1610 auto result = client_->RegisterOffListener(type, listener);
1611 EXPECT_EQ(result, ERR_OK);
1612 }
1613
1614 /**
1615 * @tc.name: AbilityManagerClient_RequestDialogService_0100
1616 * @tc.desc: RequestDialogService
1617 * @tc.type: FUNC
1618 * @tc.require: issue
1619 */
1620 HWTEST_F(AbilityManagerClientBranchTest, RequestDialogService_0100, TestSize.Level1)
1621 {
1622 Want want;
1623 sptr<IRemoteObject> callerToken = nullptr;
1624 auto result = client_->RequestDialogService(want, callerToken);
1625 EXPECT_EQ(result, ERR_OK);
1626 }
1627
1628 /**
1629 * @tc.name: AbilityManagerClient_SetSessionManagerService_0100
1630 * @tc.desc: SetSessionManagerService
1631 * @tc.type: FUNC
1632 */
1633 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_SetSessionManagerService_0100, TestSize.Level1)
1634 {
1635 sptr<IRemoteObject> sessionManagerService = nullptr;
1636 auto result = client_->SetSessionManagerService(sessionManagerService);
1637 EXPECT_TRUE(result = ERR_WRONG_INTERFACE_CALL);
1638 }
1639
1640 /**
1641 * @tc.number: ReportDrawnCompleted_0100
1642 * @tc.name: ReportDrawnCompleted
1643 * @tc.desc: After passing in a callerToken with parameter nullptr, INNER_ERR is returned
1644 */
1645 HWTEST_F(AbilityManagerClientBranchTest, ReportDrawnCompleted_0100, TestSize.Level1)
1646 {
1647 sptr<IRemoteObject> callerToken = nullptr;
1648 auto result = client_->ReportDrawnCompleted(callerToken);
1649 EXPECT_EQ(result, ERR_OK);
1650 }
1651
1652 /**
1653 * @tc.number: ReportDrawnCompleted_0200
1654 * @tc.name: ReportDrawnCompleted
1655 * @tc.desc: After passing in the parameter callerToken, ERR_OK is returned
1656 */
1657 HWTEST_F(AbilityManagerClientBranchTest, ReportDrawnCompleted_0200, TestSize.Level1)
1658 {
1659 sptr<IRemoteObject> callerToken = new AbilityManagerStubTestMock();
1660 EXPECT_NE(callerToken, nullptr);
1661 auto result = client_->ReportDrawnCompleted(callerToken);
1662 EXPECT_EQ(result, ERR_OK);
1663 }
1664
1665 /**
1666 * @tc.number: GetElementNameByToken_0100
1667 * @tc.name: GetElementNameByToken
1668 * @tc.desc: Token is nullptr, empty element name is returned
1669 */
1670 HWTEST_F(AbilityManagerClientBranchTest, GetElementNameByToken_0100, TestSize.Level1)
1671 {
1672 sptr<IRemoteObject> token = nullptr;
1673 ElementName element = {};
1674 auto result = AbilityManagerClient::GetInstance()->GetElementNameByToken(token);
1675 EXPECT_EQ(result, element);
1676 }
1677
1678 /**
1679 * @tc.name: AbilityManagerClient_StartAbilityByUIContentSession_0100
1680 * @tc.desc: StartAbilityByUIContentSession
1681 * @tc.type: FUNC
1682 */
1683 HWTEST_F(AbilityManagerClientBranchTest, StartAbilityByUIContentSession_0100, TestSize.Level1)
1684 {
1685 GTEST_LOG_(INFO) << "StartAbilityByUIContentSession_0100 start";
1686 Want want;
1687 sptr<IRemoteObject> callerToken = nullptr;
1688 const sptr<AAFwk::SessionInfo> sessionInfo = nullptr;
1689 EXPECT_EQ(client_->StartAbilityByUIContentSession(want, callerToken, sessionInfo),
1690 ERR_OK);
1691 GTEST_LOG_(INFO) << "StartUIExtensionAbility_0100 end";
1692 }
1693
1694 /**
1695 * @tc.name: AbilityManagerClient_StartAbilityByUIContentSession_0100
1696 * @tc.desc: StartAbilityByUIContentSession
1697 * @tc.type: FUNC
1698 */
1699 HWTEST_F(AbilityManagerClientBranchTest, StartAbilityByUIContentSession_0200, TestSize.Level1)
1700 {
1701 GTEST_LOG_(INFO) << "StartAbilityByUIContentSession_0200 start";
1702 Want want;
1703 sptr<IRemoteObject> callerToken = nullptr;
1704 const sptr<AAFwk::SessionInfo> sessionInfo = nullptr;
1705 StartOptions startOptions;
1706 EXPECT_EQ(client_->StartAbilityByUIContentSession(want, startOptions, callerToken, sessionInfo),
1707 ERR_OK);
1708 GTEST_LOG_(INFO) << "StartUIExtensionAbility_0200 end";
1709 }
1710
1711 #ifdef WITH_DLP
1712 /**
1713 * @tc.number: NotifySaveAsResult_0100
1714 * @tc.name: NotifySaveAsResult
1715 * @tc.desc: The caller is expected to be dlp manager.
1716 */
1717 HWTEST_F(AbilityManagerClientBranchTest, NotifySaveAsResult_0100, TestSize.Level1)
1718 {
1719 Want want;
1720 auto result = client_->NotifySaveAsResult(want, 0, 0);
1721 EXPECT_EQ(result, ERR_OK);
1722 }
1723 #endif // WITH_DLP
1724
1725 /**
1726 * @tc.number: PrepareTerminateAbility_0100
1727 * @tc.name: PrepareTerminateAbility_0100
1728 * @tc.desc: callback is nullptr, ERR_INVALID_VALUE is returned.
1729 */
1730 HWTEST_F(AbilityManagerClientBranchTest, PrepareTerminateAbility_0100, TestSize.Level1)
1731 {
1732 sptr<IRemoteObject> token = nullptr;
1733 sptr<IPrepareTerminateCallback> callback = nullptr;
1734 auto result = client_->PrepareTerminateAbility(token, callback);
1735 EXPECT_EQ(result, ERR_INVALID_VALUE);
1736 }
1737
1738 /**
1739 * @tc.number: PrepareTerminateAbilityBySCB_0100
1740 * @tc.name: PrepareTerminateAbilityBySCB_0100
1741 * @tc.desc: sessionInfo is nullptr, INNER_ERR is returned.
1742 */
1743 HWTEST_F(AbilityManagerClientBranchTest, PrepareTerminateAbilityBySCB_0100, TestSize.Level1)
1744 {
1745 sptr<SessionInfo> sessionInfo = nullptr;
1746 bool isPrepareTerminate = false;
1747 auto result = client_->PrepareTerminateAbilityBySCB(sessionInfo, isPrepareTerminate);
1748 EXPECT_EQ(result, ERR_OK);
1749 }
1750
1751 #ifdef WITH_DLP
1752 /**
1753 * @tc.number: UpdateMissionSnapShot_0100
1754 * @tc.name: UpdateMissionSnapShot
1755 * @tc.desc: The caller is expected to be dlp manager.
1756 */
1757 HWTEST_F(AbilityManagerClientBranchTest, UpdateMissionSnapShot_0100, TestSize.Level1)
1758 {
1759 sptr<IRemoteObject> token = nullptr;
1760 auto pixelMap = std::shared_ptr<Media::PixelMap>();
1761 client_->UpdateMissionSnapShot(token, pixelMap);
1762 EXPECT_TRUE(client_ != nullptr);
1763 }
1764 #endif // WITH_DLP
1765
1766 /**
1767 * @tc.name: AbilityManagerClient_RegisterSessionHandler_0100
1768 * @tc.desc: RegisterSessionHandler
1769 * @tc.type: FUNC
1770 */
1771 HWTEST_F(AbilityManagerClientBranchTest, RegisterSessionHandler_0100, TestSize.Level1)
1772 {
1773 sptr<IRemoteObject> token = nullptr;
1774 auto result = client_->RegisterSessionHandler(token);
1775 EXPECT_EQ(ERR_OK, result);
1776 }
1777
1778 /**
1779 * @tc.name: AbilityManagerClient_SetLockedState_0100
1780 * @tc.desc: SetLockedState
1781 * @tc.type: FUNC
1782 */
1783 HWTEST_F(AbilityManagerClientBranchTest, SetLockedState_0100, TestSize.Level1)
1784 {
1785 int32_t sessionId = 1;
1786 bool lockedState = true;
1787 client_->SetLockedState(sessionId, lockedState);
1788 EXPECT_TRUE(client_ != nullptr);
1789 }
1790
1791 /**
1792 * @tc.name: AbilityManagerClient_StartSpecifiedAbilityBySCB_0100
1793 * @tc.desc: StartSpecifiedAbilityBySCB
1794 * @tc.type: FUNC
1795 */
1796 HWTEST_F(AbilityManagerClientBranchTest, StartSpecifiedAbilityBySCB_0100, TestSize.Level1)
1797 {
1798 Want want;
1799 client_->StartSpecifiedAbilityBySCB(want);
1800 EXPECT_TRUE(client_ != nullptr);
1801 }
1802
1803 /**
1804 * @tc.name: AbilityManagerClient_IsAbilityControllerStart_0100
1805 * @tc.desc: IsAbilityControllerStart
1806 * @tc.type: FUNC
1807 */
1808 HWTEST_F(AbilityManagerClientBranchTest, IsAbilityControllerStart_0100, TestSize.Level1)
1809 {
1810 Want want;
1811 bool result = client_->IsAbilityControllerStart(want);
1812 EXPECT_TRUE(result);
1813 }
1814
1815 /**
1816 * @tc.name: AbilityManagerClient_RegisterAutoStartupSystemCallback_0100
1817 * @tc.desc: RegisterAutoStartupSystemCallback
1818 * @tc.type: FUNC
1819 */
1820 HWTEST_F(AbilityManagerClientBranchTest, RegisterAutoStartupSystemCallback_0100, TestSize.Level1)
1821 {
1822 sptr<IRemoteObject> callback = nullptr;
1823 auto result = client_->RegisterAutoStartupSystemCallback(callback);
1824 EXPECT_EQ(result, ERR_OK);
1825 }
1826
1827 /**
1828 * @tc.name: AbilityManagerClient_UnregisterAutoStartupSystemCallback_0100
1829 * @tc.desc: UnregisterAutoStartupSystemCallback
1830 * @tc.type: FUNC
1831 */
1832 HWTEST_F(AbilityManagerClientBranchTest, UnregisterAutoStartupSystemCallback_0100, TestSize.Level1)
1833 {
1834 sptr<IRemoteObject> callback = nullptr;
1835 auto result = client_->UnregisterAutoStartupSystemCallback(callback);
1836 EXPECT_EQ(result, ERR_OK);
1837 }
1838
1839 /**
1840 * @tc.name: AbilityManagerClient_SetApplicationAutoStartup_0100
1841 * @tc.desc: SetApplicationAutoStartup
1842 * @tc.type: FUNC
1843 */
1844 HWTEST_F(AbilityManagerClientBranchTest, SetApplicationAutoStartup_0100, TestSize.Level1)
1845 {
1846 AutoStartupInfo info;
1847 auto result = client_->SetApplicationAutoStartup(info);
1848 EXPECT_EQ(result, ERR_OK);
1849 }
1850
1851 /**
1852 * @tc.name: AbilityManagerClient_CancelApplicationAutoStartup_0100
1853 * @tc.desc: CancelApplicationAutoStartup
1854 * @tc.type: FUNC
1855 */
1856 HWTEST_F(AbilityManagerClientBranchTest, CancelApplicationAutoStartup_0100, TestSize.Level1)
1857 {
1858 AutoStartupInfo info;
1859 auto result = client_->CancelApplicationAutoStartup(info);
1860 EXPECT_EQ(result, ERR_OK);
1861 }
1862
1863 /**
1864 * @tc.name: AbilityManagerClient_QueryAllAutoStartupApplications_0100
1865 * @tc.desc: QueryAllAutoStartupApplications
1866 * @tc.type: FUNC
1867 */
1868 HWTEST_F(AbilityManagerClientBranchTest, QueryAllAutoStartupApplications_0100, TestSize.Level1)
1869 {
1870 std::vector<AutoStartupInfo> infoList;
1871 auto result = client_->QueryAllAutoStartupApplications(infoList);
1872 EXPECT_EQ(result, ERR_OK);
1873 }
1874
1875 /**
1876 * @tc.name: AbilityManagerClient_RegisterIAbilityManagerCollaborator_0100
1877 * @tc.desc: RegisterIAbilityManagerCollaborator
1878 * @tc.type: FUNC
1879 */
1880 HWTEST_F(AbilityManagerClientBranchTest, RegisterIAbilityManagerCollaborator_0100, TestSize.Level1)
1881 {
1882 int32_t type = CollaboratorType::RESERVE_TYPE;
1883 sptr<IAbilityManagerCollaborator> impl = new (std::nothrow) MockAbilityManagerCollaborator();
1884 auto result = client_->RegisterIAbilityManagerCollaborator(type, impl);
1885 EXPECT_EQ(result, ERR_OK);
1886 }
1887
1888 /**
1889 * @tc.name: AbilityManagerClient_UnregisterIAbilityManagerCollaborator_0100
1890 * @tc.desc: UnregisterIAbilityManagerCollaborator
1891 * @tc.type: FUNC
1892 */
1893 HWTEST_F(AbilityManagerClientBranchTest, UnregisterIAbilityManagerCollaborator_0100, TestSize.Level1)
1894 {
1895 int32_t type = CollaboratorType::RESERVE_TYPE;
1896 auto result = client_->UnregisterIAbilityManagerCollaborator(type);
1897 EXPECT_EQ(result, ERR_OK);
1898 }
1899
1900 /**
1901 * @tc.name: AbilityManagerClient_StartAbilityByInsightIntent_0100
1902 * @tc.desc: StartAbilityByInsightIntent
1903 * @tc.type: FUNC
1904 */
1905 HWTEST_F(AbilityManagerClientBranchTest, StartAbilityByInsightIntent_0100, TestSize.Level1)
1906 {
1907 GTEST_LOG_(INFO) << "StartAbilityByInsightIntent_0100 start";
1908 Want want;
1909 sptr<IRemoteObject> callerToken = nullptr;
1910 uint64_t intentId = 1;
1911 int32_t userId = 2;
1912 EXPECT_EQ(client_->StartAbilityByInsightIntent(want, callerToken, intentId, userId), ERR_OK);
1913 GTEST_LOG_(INFO) << "StartAbilityByInsightIntent_0100 end";
1914 }
1915
1916 /**
1917 * @tc.name: AbilityManagerClient_LogoutUser_0100
1918 * @tc.desc: LogoutUser
1919 * @tc.type: FUNC
1920 */
1921 HWTEST_F(AbilityManagerClientBranchTest, LogoutUser_0100, TestSize.Level1)
1922 {
1923 GTEST_LOG_(INFO) << "LogoutUser_0100 start";
1924 int userId = 1;
1925 auto result = client_->LogoutUser(userId, nullptr);
1926
1927 EXPECT_EQ(result, ERR_OK);
1928 GTEST_LOG_(INFO) << "LogoutUser_0100 end";
1929 }
1930
1931 /**
1932 * @tc.name: AbilityManagerClient_RegisterAppDebugListener_0100
1933 * @tc.desc: RegisterAppDebugListener
1934 * @tc.type: FUNC
1935 */
1936 HWTEST_F(AbilityManagerClientBranchTest, RegisterAppDebugListener_0100, TestSize.Level1)
1937 {
1938 GTEST_LOG_(INFO) << "RegisterAppDebugListener_0100 start";
1939 sptr<AppExecFwk::IAppDebugListener> listener = nullptr;
1940 auto result = client_->RegisterAppDebugListener(listener);
1941 EXPECT_EQ(ERR_OK, result);
1942 GTEST_LOG_(INFO) << "RegisterAppDebugListener_0100 end";
1943 }
1944
1945 /**
1946 * @tc.name: AbilityManagerClient_UnregisterAppDebugListener_0100
1947 * @tc.desc: UnregisterAppDebugListener
1948 * @tc.type: FUNC
1949 */
1950 HWTEST_F(AbilityManagerClientBranchTest, UnregisterAppDebugListener_0100, TestSize.Level1)
1951 {
1952 GTEST_LOG_(INFO) << "UnregisterAppDebugListener_0100 start";
1953 sptr<AppExecFwk::IAppDebugListener> listener = nullptr;
1954 auto result = client_->UnregisterAppDebugListener(listener);
1955 EXPECT_EQ(ERR_OK, result);
1956 GTEST_LOG_(INFO) << "UnregisterAppDebugListener_0100 end";
1957 }
1958
1959 /**
1960 * @tc.name: AbilityManagerClient_AttachAppDebug_0100
1961 * @tc.desc: AttachAppDebug
1962 * @tc.type: FUNC
1963 */
1964 HWTEST_F(AbilityManagerClientBranchTest, AttachAppDebug_0100, TestSize.Level1)
1965 {
1966 GTEST_LOG_(INFO) << "AttachAppDebug_0100 start";
1967 std::string bundleName = "bundleName_test";
1968 auto result = client_->AttachAppDebug(bundleName);
1969 EXPECT_EQ(ERR_OK, result);
1970 GTEST_LOG_(INFO) << "AttachAppDebug_0100 end";
1971 }
1972
1973 /**
1974 * @tc.name: AbilityManagerClient_DetachAppDebug_0100
1975 * @tc.desc: DetachAppDebug
1976 * @tc.type: FUNC
1977 */
1978 HWTEST_F(AbilityManagerClientBranchTest, DetachAppDebug_0100, TestSize.Level1)
1979 {
1980 GTEST_LOG_(INFO) << "DetachAppDebug_0100 start";
1981 std::string bundleName = "bundleName_test";
1982 auto result = client_->DetachAppDebug(bundleName);
1983 EXPECT_EQ(ERR_OK, result);
1984 GTEST_LOG_(INFO) << "DetachAppDebug_0100 end";
1985 }
1986
1987 /**
1988 * @tc.name: AbilityManagerClient_ExecuteIntent_0100
1989 * @tc.desc: ExecuteIntent
1990 * @tc.type: FUNC
1991 */
1992 HWTEST_F(AbilityManagerClientBranchTest, ExecuteIntent_0100, TestSize.Level1)
1993 {
1994 GTEST_LOG_(INFO) << "ExecuteIntent_0100 start";
1995 uint64_t key = 1;
1996 sptr<IRemoteObject> callerToken = nullptr;
1997 const InsightIntentExecuteParam param;
1998 auto result = client_->ExecuteIntent(key, callerToken, param);
1999 EXPECT_EQ(ERR_OK, result);
2000 GTEST_LOG_(INFO) << "ExecuteIntent_0100 end";
2001 }
2002
2003 /**
2004 * @tc.name: AbilityManagerClient_ExecuteInsightIntentDone_0100
2005 * @tc.desc: ExecuteInsightIntentDone
2006 * @tc.type: FUNC
2007 */
2008 HWTEST_F(AbilityManagerClientBranchTest, ExecuteInsightIntentDone_0100, TestSize.Level1)
2009 {
2010 GTEST_LOG_(INFO) << "ExecuteInsightIntentDone_0100 start";
2011 sptr<IRemoteObject> token;
2012 uint64_t intentId = 1;
2013 const InsightIntentExecuteResult executeResult;
2014 auto result = client_->ExecuteInsightIntentDone(token, intentId, executeResult);
2015 EXPECT_EQ(ERR_OK, result);
2016 GTEST_LOG_(INFO) << "ExecuteInsightIntentDone_0100 end";
2017 }
2018
2019 /**
2020 * @tc.name: AbilityManagerClient_GetForegroundUIAbilities_0100
2021 * @tc.desc: GetForegroundUIAbilities
2022 * @tc.type: FUNC
2023 */
2024 HWTEST_F(AbilityManagerClientBranchTest, GetForegroundUIAbilities_0100, TestSize.Level1)
2025 {
2026 GTEST_LOG_(INFO) << "GetForegroundUIAbilities_0100 start";
2027 std::vector<AppExecFwk::AbilityStateData> list;
2028 auto result = client_->GetForegroundUIAbilities(list);
2029 EXPECT_EQ(ERR_OK, result);
2030 GTEST_LOG_(INFO) << "GetForegroundUIAbilities_0100 end";
2031 }
2032
2033 /**
2034 * @tc.name: AbilityManagerClient_OpenFile_0100
2035 * @tc.desc: OpenFile
2036 * @tc.type: FUNC
2037 */
2038 HWTEST_F(AbilityManagerClientBranchTest, OpenFile_0100, TestSize.Level1)
2039 {
2040 GTEST_LOG_(INFO) << "OpenFile_0100 start";
2041 const Uri uri("test_open_file");
2042 uint32_t flag = 1;
2043 auto result = client_->OpenFile(uri, flag);
2044 EXPECT_EQ(result, 0);
2045 GTEST_LOG_(INFO) << "OpenFile_0100 end";
2046 }
2047
2048 /**
2049 * @tc.name: AbilityManagerClient_GetDialogSessionInfo_0100
2050 * @tc.desc: GetDialogSessionInfo
2051 * @tc.type: FUNC
2052 */
2053 HWTEST_F(AbilityManagerClientBranchTest, GetDialogSessionInfo_0100, TestSize.Level1)
2054 {
2055 GTEST_LOG_(INFO) << "GetDialogSessionInfo_0100 start";
2056 EXPECT_TRUE(client_ != nullptr);
2057 std::string dialogSessionId;
2058 sptr<DialogSessionInfo> info;
2059 auto result = client_->GetDialogSessionInfo(dialogSessionId, info);
2060 EXPECT_EQ(result, ERR_OK);
2061 GTEST_LOG_(INFO) << "GetDialogSessionInfo_0100 end";
2062 }
2063
2064 /**
2065 * @tc.name: AbilityManagerClient_SendDialogResult_0100
2066 * @tc.desc: SendDialogResult
2067 * @tc.type: FUNC
2068 */
2069 HWTEST_F(AbilityManagerClientBranchTest, SendDialogResult_0100, TestSize.Level1)
2070 {
2071 GTEST_LOG_(INFO) << "SendDialogResult_0100 start";
2072 EXPECT_TRUE(client_ != nullptr);
2073 Want want;
2074 std::string dialogSessionId;
2075 bool isAllow = true;
2076 auto result = client_->SendDialogResult(want, dialogSessionId, isAllow);
2077 EXPECT_EQ(result, ERR_OK);
2078 GTEST_LOG_(INFO) << "SendDialogResult_0100 end";
2079 }
2080
2081 /**
2082 * @tc.name: AbilityManagerClient_RequestModalUIExtension_0100
2083 * @tc.desc: RequestModalUIExtension
2084 * @tc.type: FUNC
2085 */
2086 HWTEST_F(AbilityManagerClientBranchTest, RequestModalUIExtension_0100, TestSize.Level1)
2087 {
2088 GTEST_LOG_(INFO) << "RequestModalUIExtension_0100 start";
2089 EXPECT_TRUE(client_ != nullptr);
2090 Want want;
2091 auto result = client_->RequestModalUIExtension(want);
2092 EXPECT_EQ(result, ERR_OK);
2093 GTEST_LOG_(INFO) << "RequestModalUIExtension_0100 end";
2094 }
2095
2096 /**
2097 * @tc.name: AbilityManagerClient_UpdateSessionInfoBySCB_0100
2098 * @tc.desc: UpdateSessionInfoBySCB
2099 * @tc.type: FUNC
2100 */
2101 HWTEST_F(AbilityManagerClientBranchTest, UpdateSessionInfoBySCB_0100, TestSize.Level1)
2102 {
2103 GTEST_LOG_(INFO) << "UpdateSessionInfoBySCB_0100 start";
2104 std::list<SessionInfo> sessionInfos;
2105 int32_t userId = 1;
2106 std::vector<int32_t> sessionIds;
2107 client_->UpdateSessionInfoBySCB(sessionInfos, userId, sessionIds);
2108 EXPECT_NE(client_, nullptr);
2109 GTEST_LOG_(INFO) << "UpdateSessionInfoBySCB_0100 end";
2110 }
2111
2112 /**
2113 * @tc.name: AbilityManagerClient_OpenAtomicService_0100
2114 * @tc.desc: OpenAtomicService
2115 * @tc.type: FUNC
2116 */
2117 HWTEST_F(AbilityManagerClientBranchTest, OpenAtomicService_0100, TestSize.Level1)
2118 {
2119 GTEST_LOG_(INFO) << "OpenAtomicService_0100 start";
2120 Want want;
2121 int32_t userId = 100;
2122 StartOptions startOptions;
2123 client_->OpenAtomicService(want, startOptions, nullptr, 1, userId);
2124 EXPECT_TRUE(client_ != nullptr);
2125 GTEST_LOG_(INFO) << "OpenAtomicService_0100 end";
2126 }
2127
2128 /**
2129 * @tc.name: AbilityManagerClient_IsEmbeddedOpenAllowed_0100
2130 * @tc.desc: IsEmbeddedOpenAllowed
2131 * @tc.type: FUNC
2132 */
2133 HWTEST_F(AbilityManagerClientBranchTest, IsEmbeddedOpenAllowed_0100, TestSize.Level1)
2134 {
2135 GTEST_LOG_(INFO) << "IsEmbeddedOpenAllowed_0100 start";
2136 std::string appId = "";
2137 client_->IsEmbeddedOpenAllowed(nullptr, appId);
2138 EXPECT_TRUE(client_ != nullptr);
2139 GTEST_LOG_(INFO) << "IsEmbeddedOpenAllowed_0100 end";
2140 }
2141
2142 /**
2143 * @tc.name: AbilityManagerClient_AttachAbilityThread_0100
2144 * @tc.desc: AttachAbilityThread
2145 * @tc.type: FUNC
2146 */
2147 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_AttachAbilityThread_0100, TestSize.Level1)
2148 {
2149 GTEST_LOG_(INFO) << "AttachAbilityThread_0100 start";
2150 sptr<IAbilityScheduler> scheduler = nullptr;
2151 sptr<IRemoteObject> token = nullptr;
2152 auto result = client_->AttachAbilityThread(scheduler, token);
2153 EXPECT_EQ(ERR_OK, result);
2154 GTEST_LOG_(INFO) << "AttachAbilityThread_0100 end";
2155 }
2156
2157 /**
2158 * @tc.name: AbilityManagerClient_AbilityTransitionDone_0100
2159 * @tc.desc: AbilityTransitionDone
2160 * @tc.type: FUNC
2161 */
2162 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_AbilityTransitionDone_0100, TestSize.Level1)
2163 {
2164 GTEST_LOG_(INFO) << "AbilityTransitionDone_0100 start";
2165 sptr<IRemoteObject> token = nullptr;
2166 int state = 1;
2167 PacMap saveData;
2168 auto result = client_->AbilityTransitionDone(token, state, saveData);
2169 EXPECT_EQ(ERR_OK, result);
2170 GTEST_LOG_(INFO) << "AbilityTransitionDone_0100 end";
2171 }
2172
2173 /**
2174 * @tc.name: AbilityManagerClient_ChangeAbilityVisibility_0100
2175 * @tc.desc: ChangeAbilityVisibility
2176 * @tc.type: FUNC
2177 */
2178 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_ChangeAbilityVisibility_0100, TestSize.Level1)
2179 {
2180 GTEST_LOG_(INFO) << "ChangeAbilityVisibility_0100 start";
2181 sptr<IRemoteObject> token = nullptr;
2182 bool isShow = true;
2183 auto result = client_->ChangeAbilityVisibility(token, isShow);
2184 EXPECT_EQ(ERR_OK, result);
2185 GTEST_LOG_(INFO) << "ChangeAbilityVisibility_0100 end";
2186 }
2187
2188 /**
2189 * @tc.name: AbilityManagerClient_ChangeUIAbilityVisibilityBySCB_0100
2190 * @tc.desc: ChangeUIAbilityVisibilityBySCB
2191 * @tc.type: FUNC
2192 */
2193 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_ChangeUIAbilityVisibilityBySCB_0100, TestSize.Level1)
2194 {
2195 GTEST_LOG_(INFO) << "ChangeUIAbilityVisibilityBySCB_0100 start";
2196 sptr<SessionInfo> sessionInfo = nullptr;
2197 bool isShow = true;
2198 auto result = client_->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow);
2199 EXPECT_EQ(result, ERR_INVALID_VALUE);
2200 GTEST_LOG_(INFO) << "ChangeUIAbilityVisibilityBySCB_0100 end";
2201 }
2202
2203 /**
2204 * @tc.name: AbilityManagerClient_ChangeUIAbilityVisibilityBySCB_0200
2205 * @tc.desc: ChangeUIAbilityVisibilityBySCB
2206 * @tc.type: FUNC
2207 */
2208 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_ChangeUIAbilityVisibilityBySCB_0200, TestSize.Level1)
2209 {
2210 GTEST_LOG_(INFO) << "ChangeUIAbilityVisibilityBySCB_0200 start";
2211 sptr<SessionInfo> sessionInfo(new SessionInfo());
2212 bool isShow = true;
2213 auto result = client_->ChangeUIAbilityVisibilityBySCB(sessionInfo, isShow);
2214 EXPECT_EQ(result, ERR_OK);
2215 GTEST_LOG_(INFO) << "ChangeUIAbilityVisibilityBySCB_0200 end";
2216 }
2217
2218 /**
2219 * @tc.name: AbilityManagerClient_TerminateAbility_0100
2220 * @tc.desc: TerminateAbility
2221 * @tc.type: FUNC
2222 */
2223 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_TerminateAbility_0100, TestSize.Level1)
2224 {
2225 GTEST_LOG_(INFO) << "TerminateAbility_0100 start";
2226 sptr<IRemoteObject> token = nullptr;
2227 int resultCode = 1;
2228 Want resultWant;
2229 auto result = client_->TerminateAbility(token, resultCode, &resultWant);
2230 EXPECT_EQ(ERR_OK, result);
2231 GTEST_LOG_(INFO) << "TerminateAbility_0100 end";
2232 }
2233
2234 /**
2235 * @tc.name: AbilityManagerClient_GetAbilityManager_0100
2236 * @tc.desc: GetAbilityManager
2237 * @tc.type: FUNC
2238 */
2239 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_GetAbilityManager_0100, TestSize.Level1)
2240 {
2241 GTEST_LOG_(INFO) << "GetAbilityManager_0100 start";
2242 client_->GetAbilityManager();
2243 EXPECT_NE(client_, nullptr);
2244 GTEST_LOG_(INFO) << "GetAbilityManager_0100 end";
2245 }
2246
2247 /**
2248 * @tc.name: AbilityManagerClient_ResetProxy_0100
2249 * @tc.desc: ResetProxy
2250 * @tc.type: FUNC
2251 */
2252 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_ResetProxy_0100, TestSize.Level1)
2253 {
2254 GTEST_LOG_(INFO) << "ResetProxy_0100 start";
2255 wptr<IRemoteObject> remote = nullptr;
2256 client_->ResetProxy(remote);
2257 EXPECT_NE(client_, nullptr);
2258 GTEST_LOG_(INFO) << "ResetProxy_0100 end";
2259 }
2260
2261 /**
2262 * @tc.name: AbilityManagerClient_AcquireDataAbility_0100
2263 * @tc.desc: AcquireDataAbility
2264 * @tc.type: FUNC
2265 */
2266 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_AcquireDataAbility_0100, TestSize.Level1)
2267 {
2268 GTEST_LOG_(INFO) << "AcquireDataAbility_0100 start";
2269 const Uri uri("acquire data ability");
2270 bool tryBind = true;
2271 sptr<IRemoteObject> callerToken = nullptr;
2272 auto result = client_->AcquireDataAbility(uri, tryBind, callerToken);
2273 EXPECT_EQ(result, nullptr);
2274 GTEST_LOG_(INFO) << "AcquireDataAbility_0100 end";
2275 }
2276
2277 /**
2278 * @tc.name: AbilityManagerClient_ScheduleRecoverAbility_0100
2279 * @tc.desc: ScheduleRecoverAbility
2280 * @tc.type: FUNC
2281 */
2282 HWTEST_F(AbilityManagerClientBranchTest, ScheduleRecoverAbility_0100, TestSize.Level1)
2283 {
2284 GTEST_LOG_(INFO) << "ScheduleRecoverAbility_0100 start";
2285 sptr<IRemoteObject> token = nullptr;
2286 int32_t reason = 1;
2287 Want want;
2288 client_->ScheduleRecoverAbility(token, reason, &want);
2289 EXPECT_NE(client_, nullptr);
2290 GTEST_LOG_(INFO) << "ScheduleRecoverAbility_0100 end";
2291 }
2292
2293 /**
2294 * @tc.name: AbilityManagerClient_RemoveDeathRecipient_0100
2295 * @tc.desc: RemoveDeathRecipient
2296 * @tc.type: FUNC
2297 */
2298 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_RemoveDeathRecipient_0100, TestSize.Level1)
2299 {
2300 GTEST_LOG_(INFO) << "RemoveDeathRecipient_0100 start";
2301 client_->RemoveDeathRecipient();
2302 EXPECT_NE(client_, nullptr);
2303 GTEST_LOG_(INFO) << "RemoveDeathRecipient_0100 end";
2304 }
2305
2306 /**
2307 * @tc.name: AbilityManagerClient_GetTopAbility_0100
2308 * @tc.desc: GetTopAbility
2309 * @tc.type: FUNC
2310 */
2311 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_GetTopAbility_0100, TestSize.Level1)
2312 {
2313 GTEST_LOG_(INFO) << "GetTopAbility_0100 start";
2314 EXPECT_NE(client_, nullptr);
2315 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
2316 sptr<IRemoteObject> token;
2317 auto result = client_->GetTopAbility(token);
2318 EXPECT_EQ(ERR_OK, result);
2319 }
2320 GTEST_LOG_(INFO) << "GetTopAbility_0100 end";
2321 }
2322
2323 /**
2324 * @tc.name: AbilityManagerClient_GetTopAbility_0200
2325 * @tc.desc: GetTopAbility
2326 * @tc.type: FUNC
2327 */
2328 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_GetTopAbility_0200, TestSize.Level1)
2329 {
2330 GTEST_LOG_(INFO) << "GetTopAbility_0200 start";
2331 EXPECT_NE(client_, nullptr);
2332 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
2333 bool isNeedLocalDeviceId = true;
2334 auto result = client_->GetTopAbility(isNeedLocalDeviceId);
2335 EXPECT_NE(client_, nullptr);
2336 }
2337 GTEST_LOG_(INFO) << "GetTopAbility_0200 end";
2338 }
2339
2340 /**
2341 * @tc.name: AbilityManagerClient_ContinueAbility_0100
2342 * @tc.desc: ContinueAbility
2343 * @tc.type: FUNC
2344 */
2345 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_ContinueAbility_0100, TestSize.Level1)
2346 {
2347 GTEST_LOG_(INFO) << "ContinueAbility_0100 start";
2348 std::string deviceId = "123";
2349 int32_t missionId = 1;
2350 uint32_t versionCode = 1;
2351 auto result = client_->ContinueAbility(deviceId, missionId, versionCode);
2352 EXPECT_EQ(ERR_OK, result);
2353 GTEST_LOG_(INFO) << "ContinueAbility_0100 end";
2354 }
2355
2356 /**
2357 * @tc.name: AbilityManagerClient_StopServiceAbility_0100
2358 * @tc.desc: StopServiceAbility
2359 * @tc.type: FUNC
2360 */
2361 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_StopServiceAbility_0100, TestSize.Level1)
2362 {
2363 GTEST_LOG_(INFO) << "StopServiceAbility_0100 start";
2364 Want want;
2365 sptr<IRemoteObject> token = nullptr;
2366 auto result = client_->StopServiceAbility(want, token);
2367 EXPECT_EQ(ERR_OK, result);
2368 GTEST_LOG_(INFO) << "StopServiceAbility_0100 end";
2369 }
2370
2371 /**
2372 * @tc.name: AbilityManagerClient_DelegatorDoAbilityForeground_0100
2373 * @tc.desc: DelegatorDoAbilityForeground
2374 * @tc.type: FUNC
2375 */
2376 HWTEST_F(AbilityManagerClientBranchTest, DelegatorDoAbilityForeground_0100, TestSize.Level1)
2377 {
2378 GTEST_LOG_(INFO) << "DelegatorDoAbilityForeground_0100 start";
2379 EXPECT_NE(client_, nullptr);
2380 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
2381 sptr<IRemoteObject> token = nullptr;
2382 auto result = client_->DelegatorDoAbilityForeground(token);
2383 EXPECT_EQ(ERR_OK, result);
2384 }
2385 GTEST_LOG_(INFO) << "DelegatorDoAbilityForeground_0100 end";
2386 }
2387
2388 /**
2389 * @tc.name: AbilityManagerClient_DelegatorDoAbilityBackground_0100
2390 * @tc.desc: DelegatorDoAbilityBackground
2391 * @tc.type: FUNC
2392 */
2393 HWTEST_F(AbilityManagerClientBranchTest, DelegatorDoAbilityBackground_0100, TestSize.Level1)
2394 {
2395 GTEST_LOG_(INFO) << "DelegatorDoAbilityBackground_0100 start";
2396 EXPECT_NE(client_, nullptr);
2397 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
2398 sptr<IRemoteObject> token = nullptr;
2399 auto result = client_->DelegatorDoAbilityBackground(token);
2400 EXPECT_EQ(ERR_OK, result);
2401 }
2402 GTEST_LOG_(INFO) << "DelegatorDoAbilityBackground_0100 end";
2403 }
2404
2405 /**
2406 * @tc.name: AbilityManagerClient_SetMissionContinueState_0100
2407 * @tc.desc: SetMissionContinueState
2408 * @tc.type: FUNC
2409 */
2410 HWTEST_F(AbilityManagerClientBranchTest, SetMissionContinueState_0100, TestSize.Level1)
2411 {
2412 GTEST_LOG_(INFO) << "SetMissionContinueState_0100 start";
2413 EXPECT_NE(client_, nullptr);
2414 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
2415 sptr<IRemoteObject> token = nullptr;
2416 sptr<IRemoteObject> sessionToken = nullptr;
2417 AAFwk::ContinueState state = AAFwk::ContinueState::CONTINUESTATE_ACTIVE;
2418 auto result = client_->SetMissionContinueState(token, state, sessionToken);
2419 EXPECT_EQ(ERR_OK, result);
2420 }
2421 GTEST_LOG_(INFO) << "SetMissionContinueState_0100 end";
2422 }
2423
2424 /**
2425 * @tc.name: AbilityManagerClient_SetMissionContinueState_0200
2426 * @tc.desc: SetMissionContinueState
2427 * @tc.type: FUNC
2428 */
2429 HWTEST_F(AbilityManagerClientBranchTest, SetMissionContinueState_0200, TestSize.Level1)
2430 {
2431 GTEST_LOG_(INFO) << "SetMissionContinueState_0200 start";
2432 EXPECT_NE(client_, nullptr);
2433 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
2434 sptr<IRemoteObject> token = nullptr;
2435 sptr<IRemoteObject> sessionToken = nullptr;
2436 AAFwk::ContinueState state = AAFwk::ContinueState::CONTINUESTATE_INACTIVE;
2437 auto result = client_->SetMissionContinueState(token, state, sessionToken);
2438 EXPECT_EQ(ERR_OK, result);
2439 }
2440 GTEST_LOG_(INFO) << "SetMissionContinueState_0200 end";
2441 }
2442
2443 /**
2444 * @tc.name: AbilityManagerClient_VerifyPermission_0100
2445 * @tc.desc: VerifyPermission
2446 * @tc.type: FUNC
2447 */
2448 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_VerifyPermission_0100, TestSize.Level1)
2449 {
2450 GTEST_LOG_(INFO) << "VerifyPermission_0100 start";
2451 std::string permission = "";
2452 int pid = 1;
2453 int uid = 1;
2454 auto result = client_->VerifyPermission(permission, pid, uid);
2455 EXPECT_EQ(result, ERR_OK);
2456 GTEST_LOG_(INFO) << "VerifyPermission_0100 end";
2457 }
2458
2459 /**
2460 * @tc.name: AbilityManagerClient_GetUIExtensionRootHostInfo_0100
2461 * @tc.desc: GetUIExtensionRootHostInfo
2462 * @tc.type: FUNC
2463 */
2464 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_GetUIExtensionRootHostInfo_0100, TestSize.Level1)
2465 {
2466 GTEST_LOG_(INFO) << "GetUIExtensionRootHostInfo_0100 start";
2467 sptr<IRemoteObject> token = nullptr;
2468 UIExtensionHostInfo hostInfo;
2469 int32_t userId = 1;
2470 auto result = client_->GetUIExtensionRootHostInfo(token, hostInfo, userId);
2471 EXPECT_EQ(result, ERR_OK);
2472 GTEST_LOG_(INFO) << "GetUIExtensionRootHostInfo_0100 end";
2473 }
2474
2475 /**
2476 * @tc.name: AbilityManagerClient_RestartApp_0100
2477 * @tc.desc: RestartApp
2478 * @tc.type: FUNC
2479 */
2480 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_RestartApp_0100, TestSize.Level1)
2481 {
2482 GTEST_LOG_(INFO) << "RestartApp_0100 start";
2483 AAFwk::Want want;
2484 client_->RestartApp(want);
2485 EXPECT_NE(client_, nullptr);
2486 GTEST_LOG_(INFO) << "RestartApp_0100 end";
2487 }
2488
2489 /**
2490 * @tc.name: RestartSelfAtomicService_0100
2491 * @tc.desc: RestartSelfAtomicService
2492 * @tc.type: FUNC
2493 */
2494 HWTEST_F(AbilityManagerClientBranchTest, RestartSelfAtomicService_0100, TestSize.Level1)
2495 {
2496 GTEST_LOG_(INFO) << "RestartSelfAtomicService_0100 start";
2497 client_->RestartSelfAtomicService(nullptr);
2498 EXPECT_NE(client_, nullptr);
2499 GTEST_LOG_(INFO) << "RestartSelfAtomicService_0100 end";
2500 }
2501
2502 /**
2503 * @tc.name: RestartSelfAtomicService_0200
2504 * @tc.desc: RestartSelfAtomicService
2505 * @tc.type: FUNC
2506 */
2507 HWTEST_F(AbilityManagerClientBranchTest, RestartSelfAtomicService_0200, TestSize.Level1)
2508 {
2509 GTEST_LOG_(INFO) << "RestartSelfAtomicService_0200 start";
2510 sptr<IRemoteObject> callerToken = new AbilityManagerStubTestMock();
2511 client_->RestartSelfAtomicService(callerToken);
2512 EXPECT_NE(client_, nullptr);
2513 GTEST_LOG_(INFO) << "RestartSelfAtomicService_0200 end";
2514 }
2515
2516 /**
2517 * @tc.name: AbilityManagerClient_KillProcessWithPrepareTerminate_0100
2518 * @tc.desc: KillProcessWithPrepareTerminate
2519 * @tc.type: FUNC
2520 */
2521 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_KillProcessWithPrepareTerminate_0100, TestSize.Level1)
2522 {
2523 GTEST_LOG_(INFO) << "AbilityManagerClient_KillProcessWithPrepareTerminate_0100 start";
2524 std::vector<int32_t> pids;
2525 client_->KillProcessWithPrepareTerminate(pids);
2526 EXPECT_NE(client_, nullptr);
2527 GTEST_LOG_(INFO) << "AbilityManagerClient_KillProcessWithPrepareTerminate_0100 end";
2528 }
2529
2530 /**
2531 * @tc.name: AbilityManagerClient_RequestAssertFaultDialog_0100
2532 * @tc.desc: RequestAssertFaultDialog
2533 * @tc.type: FUNC
2534 */
2535 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_RequestAssertFaultDialog_0100, TestSize.Level1)
2536 {
2537 GTEST_LOG_(INFO) << "AbilityManagerClient_RequestAssertFaultDialog_0100 start";
2538 sptr<IRemoteObject> callback;
2539 AAFwk::WantParams wantParams;
2540 client_->RequestAssertFaultDialog(callback, wantParams);
2541 EXPECT_NE(client_, nullptr);
2542 GTEST_LOG_(INFO) << "AbilityManagerClient_RequestAssertFaultDialog_0100 end";
2543 }
2544
2545 /**
2546 * @tc.name: AbilityManagerClient_NotifyDebugAssertResult_0100
2547 * @tc.desc: NotifyDebugAssertResult
2548 * @tc.type: FUNC
2549 */
2550 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_NotifyDebugAssertResult_0100, TestSize.Level1)
2551 {
2552 GTEST_LOG_(INFO) << "AbilityManagerClient_NotifyDebugAssertResult_0100 start";
2553 uint64_t assertFaultSessionId = 1;
2554 AAFwk::UserStatus userStatus = ASSERT_TERMINATE;
2555 client_->NotifyDebugAssertResult(assertFaultSessionId, userStatus);
2556 EXPECT_NE(client_, nullptr);
2557 GTEST_LOG_(INFO) << "AbilityManagerClient_NotifyDebugAssertResult_0100 end";
2558 }
2559
2560 /**
2561 * @tc.name: AbilityManagerClient_StartShortcut_0100
2562 * @tc.desc: StartShortcut
2563 * @tc.type: FUNC
2564 */
2565 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_StartShortcut_0100, TestSize.Level1)
2566 {
2567 GTEST_LOG_(INFO) << "AbilityManagerClient_StartShortcut_0100 start";
2568 Want want;
2569 StartOptions startOptions;
2570 client_->StartShortcut(want, startOptions);
2571 EXPECT_NE(client_, nullptr);
2572 GTEST_LOG_(INFO) << "AbilityManagerClient_StartShortcut_0100 end";
2573 }
2574
2575 /**
2576 * @tc.name: AbilityManagerClient_GetAbilityStateByPersistentId_0100
2577 * @tc.desc: GetAbilityStateByPersistentId
2578 * @tc.type: FUNC
2579 */
2580 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_GetAbilityStateByPersistentId_0100, TestSize.Level1)
2581 {
2582 GTEST_LOG_(INFO) << "AbilityManagerClient_GetAbilityStateByPersistentId_0100 start";
2583 int32_t persistentId = 100;
2584 bool state;
2585 client_->GetAbilityStateByPersistentId(persistentId, state);
2586 EXPECT_NE(client_, nullptr);
2587 GTEST_LOG_(INFO) << "AbilityManagerClient_GetAbilityStateByPersistentId_0100 end";
2588 }
2589
2590 /**
2591 * @tc.name: AbilityManagerClient_TransferAbilityResultForExtension_0100
2592 * @tc.desc: TransferAbilityResult
2593 * @tc.type: FUNC
2594 */
2595 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_TransferAbilityResultForExtension_0100, TestSize.Level1)
2596 {
2597 GTEST_LOG_(INFO) << "AbilityManagerClient_TransferAbilityResultForExtension_0100 start";
2598 sptr<IRemoteObject> callerToken = new AbilityManagerStubTestMock();
2599 int resultCode = 0;
2600 Want resultWant;
2601 auto result = client_->TransferAbilityResultForExtension(callerToken, resultCode, resultWant);
2602 EXPECT_EQ(result, NO_ERROR);
2603 GTEST_LOG_(INFO) << "AbilityManagerClient_TransferAbilityResultForExtension_0100 end";
2604 }
2605
2606 /**
2607 * @tc.name: AbilityManagerClient_SetResidentProcessEnabled_0100
2608 * @tc.desc: SetResidentProcessEnabled
2609 * @tc.type: FUNC
2610 */
2611 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_SetResidentProcessEnabled_0100, TestSize.Level1)
2612 {
2613 GTEST_LOG_(INFO) << "AbilityManagerClient_SetResidentProcessEnabled_0100 start";
2614 bool enable = false;
2615 auto result = client_->SetResidentProcessEnabled(BUNDLE_NAME, enable);
2616 EXPECT_TRUE(client_ != nullptr);
2617 GTEST_LOG_(INFO) << "AbilityManagerClient_SetResidentProcessEnabled_0100 end";
2618 }
2619
2620 /**
2621 * @tc.name: AbilityManagerClient_RegisterStatusBarDelegate_0100
2622 * @tc.desc: RegisterStatusBarDelegate
2623 * @tc.type: FUNC
2624 */
2625 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_RegisterStatusBarDelegate_0100, TestSize.Level1)
2626 {
2627 GTEST_LOG_(INFO) << "AbilityManagerClient_RegisterStatusBarDelegate_0100 start";
2628 ErrCode ret = client_->RegisterStatusBarDelegate(nullptr);
2629 EXPECT_EQ(ret, ERR_OK);
2630 GTEST_LOG_(INFO) << "AbilityManagerClient_RegisterStatusBarDelegate_0100 end";
2631 }
2632
2633 #ifdef SUPPORT_GRAPHICS
2634 /**
2635 * @tc.name: AbilityManagerClient_SetMissionLabel_0100
2636 * @tc.desc: SetMissionLabel
2637 * @tc.type: FUNC
2638 */
2639 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_SetMissionLabel_0100, TestSize.Level1)
2640 {
2641 GTEST_LOG_(INFO) << "AbilityManagerClient_SetMissionLabel_0100 start";
2642 sptr<IRemoteObject> token = nullptr;
2643 std::string label = "label";
2644 ErrCode ret = client_->SetMissionLabel(token, label);
2645 if (!Rosen::SceneBoardJudgement::IsSceneBoardEnabled()) {
2646 EXPECT_EQ(ret, ERR_OK);
2647 }
2648 EXPECT_TRUE(client_ != nullptr);
2649 GTEST_LOG_(INFO) << "AbilityManagerClient_SetMissionLabel_0100 end";
2650 }
2651 #endif
2652
2653 /**
2654 * @tc.name: AbilityManagerClient_UpdateKioskApplicationList
2655 * @tc.desc: UpdateKioskApplicationList
2656 * @tc.type: FUNC
2657 */
2658 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_UpdateKioskApplicationList, TestSize.Level1)
2659 {
2660 std::vector<std::string> appList = {"com.ohos.test1"};
2661 EXPECT_EQ(client_->UpdateKioskApplicationList(appList), ERR_OK);
2662 }
2663
2664 /**
2665 * @tc.name: AbilityManagerClient_EnterKioskMode
2666 * @tc.desc: EnterKioskMode
2667 * @tc.type: FUNC
2668 */
2669 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_EnterKioskMode, TestSize.Level1)
2670 {
2671 sptr<IRemoteObject> callerToken = new AbilityManagerStubTestMock();
2672 EXPECT_EQ(client_->EnterKioskMode(callerToken), ERR_OK);
2673 }
2674
2675 /**
2676 * @tc.name: AbilityManagerClient_ExitKioskMode
2677 * @tc.desc: ExitKioskMode
2678 * @tc.type: FUNC
2679 */
2680 HWTEST_F(AbilityManagerClientBranchTest, AbilityManagerClient_ExitKioskMode, TestSize.Level1)
2681 {
2682 sptr<IRemoteObject> callerToken = new AbilityManagerStubTestMock();
2683 EXPECT_EQ(client_->ExitKioskMode(callerToken), ERR_OK);
2684 }
2685
2686 /**
2687 * @tc.name: GetKioskStatus
2688 * @tc.desc: GetKioskStatus
2689 * @tc.type: FUNC
2690 */
2691 HWTEST_F(AbilityManagerClientBranchTest, GetKioskStatus, TestSize.Level1)
2692 {
2693 KioskStatus kioskStatus;
2694 EXPECT_EQ(client_->GetKioskStatus(kioskStatus), ERR_OK);
2695 }
2696
2697 /**
2698 * @tc.name: RegisterSAInterceptor
2699 * @tc.desc: RegisterSAInterceptor
2700 * @tc.type: FUNC
2701 */
2702 HWTEST_F(AbilityManagerClientBranchTest, RegisterSAInterceptor, TestSize.Level1)
2703 {
2704 EXPECT_EQ(client_->RegisterSAInterceptor(nullptr), ERR_OK);
2705 }
2706
2707 /**
2708 * @tc.name: SuspendExtensionAbility
2709 * @tc.desc: SuspendExtensionAbility
2710 * @tc.type: FUNC
2711 */
2712 HWTEST_F(AbilityManagerClientBranchTest, SuspendExtensionAbility, TestSize.Level1)
2713 {
2714 EXPECT_EQ(client_->SuspendExtensionAbility(nullptr), ERR_OK);
2715 }
2716
2717 /**
2718 * @tc.name: ResumeExtensionAbility
2719 * @tc.desc: ResumeExtensionAbility
2720 * @tc.type: FUNC
2721 */
2722 HWTEST_F(AbilityManagerClientBranchTest, ResumeExtensionAbility, TestSize.Level1)
2723 {
2724 EXPECT_EQ(client_->ResumeExtensionAbility(nullptr), ERR_OK);
2725 }
2726
2727 /**
2728 * @tc.name: RegisterSAInterceptor_0100
2729 * @tc.desc: RegisterSAInterceptor
2730 * @tc.type: FUNC
2731 */
2732 HWTEST_F(AbilityManagerClientBranchTest, RegisterSAInterceptor_0100, TestSize.Level1)
2733 {
2734 EXPECT_EQ(client_->RegisterSAInterceptor(nullptr), ERR_OK);
2735 }
2736 } // namespace AAFwk
2737 } // namespace OHOS
2738