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