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