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
18 #define private public
19 #include "ability_manager_proxy.h"
20 #undef private
21
22 #include "ability_manager_errors.h"
23 #include "ability_manager_stub_mock.h"
24 #include "mock_ability_connect_callback.h"
25 #include "mock_ability_token.h"
26 #include "ability_scheduler_mock.h"
27 #include "ability_record.h"
28 #include "app_debug_listener_stub_mock.h"
29 #include "ability_scheduler.h"
30 #include "hilog_tag_wrapper.h"
31 #include "mission_snapshot.h"
32 #include "want_sender_info.h"
33 #include "mission_listener_interface.h"
34 #include "mission_snapshot.h"
35 #include "snapshot.h"
36
37 using namespace testing::ext;
38 using namespace testing;
39 using namespace OHOS::AppExecFwk;
40
41 namespace OHOS {
42 namespace AAFwk {
43 namespace {
44 const int USER_ID = 100;
45 constexpr int32_t REPLY_RESULT = 1;
46 } // namespace
47
48 class AbilityManagerProxyTest : public testing::Test {
49 public:
50 static void SetUpTestCase(void);
51 static void TearDownTestCase(void);
52 void SetUp();
53 void TearDown();
54
55 std::shared_ptr<AbilityManagerProxy> proxy_{ nullptr };
56 sptr<AbilityManagerStubMock> mock_{ nullptr };
57 };
58
SetUpTestCase(void)59 void AbilityManagerProxyTest::SetUpTestCase(void)
60 {}
TearDownTestCase(void)61 void AbilityManagerProxyTest::TearDownTestCase(void)
62 {}
TearDown()63 void AbilityManagerProxyTest::TearDown()
64 {}
65
SetUp()66 void AbilityManagerProxyTest::SetUp()
67 {
68 mock_ = new AbilityManagerStubMock();
69 proxy_ = std::make_shared<AbilityManagerProxy>(mock_);
70 }
71
72 /**
73 * @tc.name: AbilityManagerProxy_DumpSysState_0100
74 * @tc.desc: DumpSysState
75 * @tc.type: FUNC
76 * @tc.require: SR000GH1GO
77 */
78 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DumpSysState_0100, TestSize.Level1)
79 {
80 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_DumpSysState_0100 start");
81
82 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
83 .Times(1)
84 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
85
86 std::string args;
87 std::vector<std::string> info;
88 bool isClient = false;
89 bool isUserID = true;
90
91 proxy_->DumpSysState(args, info, isClient, isUserID, USER_ID);
92 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::DUMPSYS_STATE), mock_->code_);
93
94 TAG_LOGI(AAFwkTag::TEST, "AbilityManagerProxy_DumpSysState_0100 end");
95 }
96
97 /*
98 * Feature: AbilityManagerService
99 * Function: StartAbility
100 * SubFunction: NA
101 * FunctionPoints: AbilityManagerService StartAbility
102 * EnvConditions: NA
103 * CaseDescription: Verify the normal process of startability
104 */
105 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_001, TestSize.Level1)
106 {
107 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
108 .Times(1)
109 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
110 const Want want;
111 auto res = proxy_->StartAbility(want, 9);
112
113 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY), mock_->code_);
114 EXPECT_EQ(res, NO_ERROR);
115 }
116
117 /*
118 * Feature: AbilityManagerService
119 * Function: StartAbility
120 * SubFunction: NA
121 * FunctionPoints: AbilityManagerService StartAbility
122 * EnvConditions: NA
123 * CaseDescription: Verify that the return value of startability is abnormal
124 */
125 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_002, TestSize.Level1)
126 {
127 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
128 .Times(1)
129 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
130 const Want want;
131 auto res = proxy_->StartAbility(want, 9);
132
133 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY), mock_->code_);
134 EXPECT_NE(res, NO_ERROR);
135 }
136
137 /*
138 * Feature: AbilityManagerService
139 * Function: TerminateAbility
140 * SubFunction: NA
141 * FunctionPoints: AbilityManagerService TerminateAbility
142 * EnvConditions: NA
143 * CaseDescription: Verify the normal process of TerminateAbility
144 */
145 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_003, TestSize.Level1)
146 {
147 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
148 .Times(1)
149 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
150 const Want want;
151 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
152 auto res = proxy_->TerminateAbility(token, -1, &want);
153
154 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::TERMINATE_ABILITY), mock_->code_);
155 EXPECT_EQ(res, NO_ERROR);
156 }
157
158 /*
159 * Feature: AbilityManagerService
160 * Function: TerminateAbility
161 * SubFunction: NA
162 * FunctionPoints: AbilityManagerService TerminateAbility
163 * EnvConditions: NA
164 * CaseDescription: Verify that the return value of TerminateAbility is abnormal
165 */
166 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_004, TestSize.Level1)
167 {
168 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
169 .Times(1)
170 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
171 const Want want;
172 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
173 auto res = proxy_->TerminateAbility(token, -1, &want);
174
175 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::TERMINATE_ABILITY), mock_->code_);
176 EXPECT_NE(res, NO_ERROR);
177 }
178
179 /*
180 * Feature: AbilityManagerService
181 * Function: SendResultToAbility
182 * SubFunction: NA
183 * FunctionPoints: AbilityManagerService SendResultToAbility
184 * EnvConditions: NA
185 * CaseDescription: Verify the normal conditions of SendResultToAbility
186 */
187 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_SendResultToAbility_001, TestSize.Level1)
188 {
189 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
190 .Times(1)
191 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
192 Want want;
193 int res1 = proxy_->SendResultToAbility(-1, -1, want);
194 EXPECT_EQ(res1, NO_ERROR);
195 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::SEND_RESULT_TO_ABILITY), mock_->code_);
196 }
197
198 /*
199 * Feature: AbilityManagerService
200 * Function: SendResultToAbility
201 * SubFunction: NA
202 * FunctionPoints: AbilityManagerService SendResultToAbility
203 * EnvConditions: NA
204 * CaseDescription: Verify the abnormal conditions of SendResultToAbility
205 */
206 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_SendResult_002, TestSize.Level1)
207 {
208 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
209 .Times(1)
210 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
211 Want want;
212 int res = proxy_->SendResultToAbility(-1, -1, want);
213
214 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::SEND_RESULT_TO_ABILITY), mock_->code_);
215 EXPECT_NE(res, NO_ERROR);
216 }
217
218 /*
219 * Feature: AbilityManagerService
220 * Function: ConnectAbility
221 * SubFunction: NA
222 * FunctionPoints: AbilityManagerService ConnectAbility
223 * EnvConditions: NA
224 * CaseDescription: Verify the normal conditions of connectability
225 */
226 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_005, TestSize.Level1)
227 {
228 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
229 .Times(1)
230 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
231 Want want;
232 want.SetFlags(10);
233 sptr<IAbilityConnection> nullConnect = nullptr;
234 sptr<IRemoteObject> callerToken = nullptr;
235 int res = proxy_->ConnectAbility(want, nullConnect, callerToken);
236 EXPECT_NE(res, NO_ERROR);
237 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
238 int res1 = proxy_->ConnectAbility(want, connect, callerToken);
239 EXPECT_EQ(res1, NO_ERROR);
240 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY_WITH_TYPE), mock_->code_);
241 }
242
243 /*
244 * Feature: AbilityManagerService
245 * Function: ConnectAbility
246 * SubFunction: NA
247 * FunctionPoints: AbilityManagerService ConnectAbility
248 * EnvConditions: NA
249 * CaseDescription: Verify the abnormal conditions of connectability
250 */
251 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_006, TestSize.Level1)
252 {
253 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
254 .Times(1)
255 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
256 const Want want;
257 sptr<IRemoteObject> callerToken = nullptr;
258 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
259 int res = proxy_->ConnectAbility(want, connect, callerToken);
260
261 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY_WITH_TYPE), mock_->code_);
262 EXPECT_NE(res, NO_ERROR);
263 }
264
265 /*
266 * Feature: AbilityManagerService
267 * Function: DisconnectAbility
268 * SubFunction: NA
269 * FunctionPoints: AbilityManagerService DisconnectAbility
270 * EnvConditions: NA
271 * CaseDescription: Verify the normal conditions of disconnectAbility
272 */
273 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_007, TestSize.Level1)
274 {
275 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
276 .Times(1)
277 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
278 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
279 int res = proxy_->DisconnectAbility(connect);
280
281 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::DISCONNECT_ABILITY), mock_->code_);
282 EXPECT_EQ(res, NO_ERROR);
283 }
284
285 /*
286 * Feature: AbilityManagerService
287 * Function: DisconnectAbility
288 * SubFunction: NA
289 * FunctionPoints: AbilityManagerService DisconnectAbility
290 * EnvConditions: NA
291 * CaseDescription: Verify the abnormal conditions of disconnectAbility
292 */
293 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_008, TestSize.Level1)
294 {
295 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
296 .Times(1)
297 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
298 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
299 int res = proxy_->DisconnectAbility(connect);
300
301 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::DISCONNECT_ABILITY), mock_->code_);
302 EXPECT_NE(res, NO_ERROR);
303 }
304
305 /*
306 * Feature: AbilityManagerService
307 * Function: AttachAbilityThread
308 * SubFunction: NA
309 * FunctionPoints: AbilityManagerService AttachAbilityThread
310 * EnvConditions: NA
311 * CaseDescription: Verify the normal conditions of attachAbilityThread
312 */
313 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_009, TestSize.Level1)
314 {
315 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
316 .Times(1)
317 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
318 sptr<IAbilityScheduler> scheduler = new AbilitySchedulerMock();
319 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
320 auto res = proxy_->AttachAbilityThread(scheduler, token);
321
322 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::ATTACH_ABILITY_THREAD), mock_->code_);
323 EXPECT_EQ(res, NO_ERROR);
324 }
325
326 /*
327 * Feature: AbilityManagerService
328 * Function: AttachAbilityThread
329 * SubFunction: NA
330 * FunctionPoints: AbilityManagerService AttachAbilityThread
331 * EnvConditions: NA
332 * CaseDescription: Verify the abnormal conditions of attachAbilityThread
333 */
334 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_010, TestSize.Level1)
335 {
336 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
337 .Times(1)
338 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
339 sptr<IAbilityScheduler> scheduler = new AbilitySchedulerMock();
340 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
341 auto res = proxy_->AttachAbilityThread(scheduler, token);
342
343 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::ATTACH_ABILITY_THREAD), mock_->code_);
344 EXPECT_NE(res, NO_ERROR);
345
346 sptr<IAbilityScheduler> nullScheduler = nullptr;
347 auto res1 = proxy_->AttachAbilityThread(nullScheduler, token);
348 EXPECT_NE(res1, NO_ERROR);
349 }
350
351 /*
352 * Feature: AbilityManagerService
353 * Function: AbilityTransitionDone
354 * SubFunction: NA
355 * FunctionPoints: AbilityManagerService AbilityTransitionDone
356 * EnvConditions: NA
357 * CaseDescription: Verify the normal conditions of abilityTransitionDone
358 */
359 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_0011, TestSize.Level1)
360 {
361 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
362 .Times(1)
363 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
364 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
365 PacMap saveData;
366 auto res = proxy_->AbilityTransitionDone(token, 1, saveData);
367
368 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::ABILITY_TRANSITION_DONE), mock_->code_);
369 EXPECT_EQ(res, NO_ERROR);
370 }
371
372 /*
373 * Feature: AbilityManagerService
374 * Function: AbilityTransitionDone
375 * SubFunction: NA
376 * FunctionPoints: AbilityManagerService AbilityTransitionDone
377 * EnvConditions: NA
378 * CaseDescription: Verify the abnormal conditions of abilityTransitionDone
379 */
380 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_012, TestSize.Level1)
381 {
382 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
383 .Times(1)
384 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
385 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
386 PacMap saveData;
387 auto res = proxy_->AbilityTransitionDone(token, 1, saveData);
388
389 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::ABILITY_TRANSITION_DONE), mock_->code_);
390 EXPECT_NE(res, NO_ERROR);
391 }
392
393 /*
394 * Feature: AbilityManagerService
395 * Function: ScheduleConnectAbilityDone
396 * SubFunction: NA
397 * FunctionPoints: AbilityManagerService ScheduleConnectAbilityDone
398 * EnvConditions: NA
399 * CaseDescription: Verify the normal conditions of scheduleConnectAbilityDone
400 */
401 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_0013, TestSize.Level1)
402 {
403 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
404 .Times(1)
405 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
406 sptr<IRemoteObject> token = nullptr;
407 sptr<IRemoteObject> remoteObject = nullptr;
408 auto res = proxy_->ScheduleConnectAbilityDone(token, remoteObject);
409
410 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY_DONE), mock_->code_);
411 EXPECT_EQ(res, NO_ERROR);
412 }
413
414 /*
415 * Feature: AbilityManagerService
416 * Function: ScheduleConnectAbilityDone
417 * SubFunction: NA
418 * FunctionPoints: AbilityManagerService ScheduleConnectAbilityDone
419 * EnvConditions: NA
420 * CaseDescription: Verify the abnormal conditions of scheduleConnectAbilityDone
421 */
422 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_014, TestSize.Level1)
423 {
424 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
425 .Times(1)
426 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
427 sptr<IRemoteObject> token = nullptr;
428 sptr<IRemoteObject> remoteObject = nullptr;
429 auto res = proxy_->ScheduleConnectAbilityDone(token, remoteObject);
430
431 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY_DONE), mock_->code_);
432 EXPECT_NE(res, NO_ERROR);
433 }
434
435 /*
436 * Feature: AbilityManagerService
437 * Function: ScheduleDisconnectAbilityDone
438 * SubFunction: NA
439 * FunctionPoints: AbilityManagerService ScheduleDisconnectAbilityDone
440 * EnvConditions: NA
441 * CaseDescription: Verify the normal conditions of scheduleDisconnectAbilityDone
442 */
443 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_0015, TestSize.Level1)
444 {
445 sptr<IRemoteObject> token = nullptr;
446 auto res = proxy_->ScheduleDisconnectAbilityDone(token);
447 EXPECT_EQ(res, ERR_INVALID_VALUE);
448 }
449
450 /*
451 * Feature: AbilityManagerService
452 * Function: DumpState
453 * SubFunction: NA
454 * FunctionPoints: AbilityManagerService DumpState
455 * EnvConditions: NA
456 * CaseDescription: Verify the normal conditions of dumpState
457 */
458 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_0017, TestSize.Level1)
459 {
460 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
461 .Times(1)
462 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
463 std::string args = "aaa";
464 std::vector<std::string> info;
465 proxy_->DumpState(args, info);
466
467 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::DUMP_STATE), mock_->code_);
468 }
469
470 /*
471 * Feature: AbilityManagerService
472 * Function: ScheduleCommandAbilityDone
473 * SubFunction: NA
474 * FunctionPoints: AbilityManagerService ScheduleCommandAbilityDone
475 * EnvConditions: NA
476 * CaseDescription: Verify the abnormal conditions of ScheduleCommandAbilityDone
477 */
478 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_026, TestSize.Level1)
479 {
480 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
481 .Times(1)
482 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
483 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
484 auto res = proxy_->ScheduleCommandAbilityDone(token);
485
486 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::COMMAND_ABILITY_DONE), mock_->code_);
487 EXPECT_NE(res, NO_ERROR);
488 }
489
490 /*
491 * Feature: AbilityManagerService
492 * Function: StopServiceAbility
493 * SubFunction: NA
494 * FunctionPoints: AbilityManagerService StopServiceAbility
495 * EnvConditions: NA
496 * CaseDescription: Verify the normal process of StopServiceAbility
497 */
498 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_027, TestSize.Level1)
499 {
500 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
501 .Times(1)
502 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
503 const Want want;
504 auto res = proxy_->StopServiceAbility(want, -1, nullptr);
505
506 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::STOP_SERVICE_ABILITY), mock_->code_);
507 EXPECT_EQ(res, NO_ERROR);
508 }
509
510 /**
511 * @tc.name: AbilityManagerProxy_028
512 * @tc.desc: test StartContinuation send request succeeded
513 * @tc.type: FUNC
514 * @tc.require: AR000GI8IL
515 */
516 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_028, TestSize.Level0)
517 {
518 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
519 .Times(1)
520 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
521 Want want;
522 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
523 int res = proxy_->StartContinuation(want, abilityToken, 0);
524 EXPECT_EQ(res, NO_ERROR);
525 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_CONTINUATION), mock_->code_);
526 }
527
528 /**
529 * @tc.name: AbilityManagerProxy_029
530 * @tc.desc: test StartContinuation send request failed
531 * @tc.type: FUNC
532 * @tc.require: AR000GI8IL
533 */
534 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_029, TestSize.Level0)
535 {
536 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
537 .Times(1)
538 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
539 const Want want;
540 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
541 int res = proxy_->StartContinuation(want, abilityToken, 0);
542
543 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_CONTINUATION), mock_->code_);
544 EXPECT_NE(res, NO_ERROR);
545 }
546
547 /**
548 * @tc.name: AbilityManagerProxy_030
549 * @tc.desc: test NotifyContinuationResult send request succeeded
550 * @tc.type: FUNC
551 * @tc.require: AR000GI8IH
552 */
553 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_030, TestSize.Level0)
554 {
555 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
556 .Times(1)
557 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
558 int32_t result = 0;
559 int res = proxy_->NotifyContinuationResult(0, result);
560 EXPECT_EQ(res, NO_ERROR);
561 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::NOTIFY_CONTINUATION_RESULT), mock_->code_);
562 }
563
564 /**
565 * @tc.name: AbilityManagerProxy_031
566 * @tc.desc: test NotifyContinuationResult send request failed
567 * @tc.type: FUNC
568 * @tc.require: AR000GI8IH
569 */
570 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_031, TestSize.Level0)
571 {
572 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
573 .Times(1)
574 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
575 int32_t result = 0;
576 int res = proxy_->NotifyContinuationResult(0, result);
577
578 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::NOTIFY_CONTINUATION_RESULT), mock_->code_);
579 EXPECT_NE(res, NO_ERROR);
580 }
581
582 /*
583 * Feature: AbilityManagerService
584 * Function: ScheduleCommandAbilityWindowDone
585 * SubFunction: NA
586 * FunctionPoints: AbilityManagerService ScheduleCommandAbilityWindowDone
587 * EnvConditions: NA
588 * CaseDescription: Verify the abnormal conditions of ScheduleCommandAbilityWindowDone
589 */
590 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_032, TestSize.Level1)
591 {
592 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
593 .Times(1)
594 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
595 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
596 sptr<SessionInfo> session = new (std::nothrow) SessionInfo();
597 auto res = proxy_->ScheduleCommandAbilityWindowDone(token, session, WIN_CMD_FOREGROUND, ABILITY_CMD_FOREGROUND);
598
599 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::COMMAND_ABILITY_WINDOW_DONE), mock_->code_);
600 EXPECT_NE(res, NO_ERROR);
601 }
602
603 /**
604 * @tc.name: AbilityManagerProxy_033
605 * @tc.desc: test StartContinuation send async request succeeded
606 * @tc.type: FUNC
607 * @tc.require: AR000GI8IL
608 */
609 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_033, TestSize.Level0)
610 {
611 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
612 .Times(1)
613 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
614 Want want;
615 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
616 int res = proxy_->StartContinuation(want, abilityToken, 0);
617 EXPECT_EQ(res, NO_ERROR);
618 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_CONTINUATION), mock_->code_);
619 }
620
621 /*
622 * Feature: AbilityManagerService
623 * Function: AcquireDataAbility
624 * SubFunction: NA
625 * FunctionPoints: AbilityManagerService AcquireDataAbility
626 * EnvConditions: NA
627 * CaseDescription: Verify the function AcquireDataAbility normal flow.
628 */
629 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_AcquireDataAbility_001, TestSize.Level1)
630 {
631 OHOS::Uri dataAbilityUri("dataability:///data.bundle.DataAbility");
632 AbilityRequest abilityRequest;
633 abilityRequest.appInfo.bundleName = "data.client.bundle";
634 abilityRequest.abilityInfo.name = "ClientAbility";
635 abilityRequest.abilityInfo.type = AbilityType::DATA;
636 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
637
638 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
639 EXPECT_EQ(proxy_->AcquireDataAbility(dataAbilityUri, true, abilityRecord->GetToken()), nullptr);
640 }
641
642 /*
643 * Feature: AbilityManagerService
644 * Function: AcquireDataAbility
645 * SubFunction: NA
646 * FunctionPoints: AbilityManagerService AcquireDataAbility
647 * EnvConditions: NA
648 * CaseDescription: Verify the function AcquireDataAbility callerToken is nullptr.
649 */
650 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_AcquireDataAbility_002, TestSize.Level1)
651 {
652 OHOS::Uri dataAbilityUri("dataability:///data.bundle.DataAbility");
653
654 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(0);
655 EXPECT_EQ(proxy_->AcquireDataAbility(dataAbilityUri, true, nullptr), nullptr);
656 }
657
658 /*
659 * Feature: AbilityManagerService
660 * Function: AcquireDataAbility
661 * SubFunction: NA
662 * FunctionPoints: AbilityManagerService AcquireDataAbility
663 * EnvConditions: NA
664 * CaseDescription: Verify the function AcquireDataAbility SendRequest return error.
665 */
666 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_AcquireDataAbility_003, TestSize.Level1)
667 {
668 OHOS::Uri dataAbilityUri("dataability:///data.bundle.DataAbility");
669 AbilityRequest abilityRequest;
670 abilityRequest.appInfo.bundleName = "data.client.bundle";
671 abilityRequest.abilityInfo.name = "ClientAbility";
672 abilityRequest.abilityInfo.type = AbilityType::DATA;
673 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
674
675 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(TRANSACTION_ERR));
676 EXPECT_EQ(proxy_->AcquireDataAbility(dataAbilityUri, true, abilityRecord->GetToken()), nullptr);
677 }
678
679 /*
680 * Feature: AbilityManagerService
681 * Function: ReleaseDataAbility
682 * SubFunction: NA
683 * FunctionPoints: AbilityManagerService ReleaseDataAbility
684 * EnvConditions: NA
685 * CaseDescription: Verify the function ReleaseDataAbility normal flow.
686 */
687 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseDataAbility_001, TestSize.Level1)
688 {
689 OHOS::sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
690 AbilityRequest abilityRequest;
691 abilityRequest.appInfo.bundleName = "data.client.bundle";
692 abilityRequest.abilityInfo.name = "ClientAbility";
693 abilityRequest.abilityInfo.type = AbilityType::DATA;
694 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
695
696 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
697 EXPECT_EQ(proxy_->ReleaseDataAbility(scheduler, abilityRecord->GetToken()), 0);
698 }
699
700 /*
701 * Feature: AbilityManagerService
702 * Function: ReleaseDataAbility
703 * SubFunction: NA
704 * FunctionPoints: AbilityManagerService ReleaseDataAbility
705 * EnvConditions: NA
706 * CaseDescription: Verify the function ReleaseDataAbility dataAbilityScheduler is nullptr.
707 */
708 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseDataAbility_002, TestSize.Level1)
709 {
710 AbilityRequest abilityRequest;
711 abilityRequest.appInfo.bundleName = "data.client.bundle";
712 abilityRequest.abilityInfo.name = "ClientAbility";
713 abilityRequest.abilityInfo.type = AbilityType::DATA;
714 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
715
716 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(0);
717 EXPECT_EQ(proxy_->ReleaseDataAbility(nullptr, abilityRecord->GetToken()), ERR_INVALID_VALUE);
718 }
719
720 /*
721 * Feature: AbilityManagerService
722 * Function: ReleaseDataAbility
723 * SubFunction: NA
724 * FunctionPoints: AbilityManagerService ReleaseDataAbility
725 * EnvConditions: NA
726 * CaseDescription: Verify the function ReleaseDataAbility callerToken is nullptr.
727 */
728 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseDataAbility_003, TestSize.Level1)
729 {
730 OHOS::sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
731
732 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(0);
733 EXPECT_EQ(proxy_->ReleaseDataAbility(scheduler, nullptr), ERR_INVALID_VALUE);
734 }
735
736 /*
737 * Feature: AbilityManagerService
738 * Function: ReleaseDataAbility
739 * SubFunction: NA
740 * FunctionPoints: AbilityManagerService ReleaseDataAbility
741 * EnvConditions: NA
742 * CaseDescription: Verify the function ReleaseDataAbility SendRequest error.
743 */
744 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseDataAbility_004, TestSize.Level1)
745 {
746 OHOS::sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
747 AbilityRequest abilityRequest;
748 abilityRequest.appInfo.bundleName = "data.client.bundle";
749 abilityRequest.abilityInfo.name = "ClientAbility";
750 abilityRequest.abilityInfo.type = AbilityType::DATA;
751 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
752
753 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(TRANSACTION_ERR));
754 EXPECT_EQ(proxy_->ReleaseDataAbility(scheduler, abilityRecord->GetToken()), TRANSACTION_ERR);
755 }
756
757 /*
758 * Feature: AbilityManagerService
759 * Function: StartAbilityByCall
760 * SubFunction: NA
761 * FunctionPoints: AbilityManagerService StartAbilityByCall
762 * EnvConditions: NA
763 * CaseDescription: Verify the function StartAbilityByCall connect is nullptr.
764 */
765 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbilityByCall_001, TestSize.Level1)
766 {
767 Want want;
768 sptr<IRemoteObject> callerToken = nullptr;
769 sptr<IAbilityConnection> connect = nullptr;
770 EXPECT_EQ(proxy_->StartAbilityByCall(want, connect, callerToken), ERR_INVALID_VALUE);
771 }
772
773 /*
774 * Feature: AbilityManagerService
775 * Function: StartAbilityByCall
776 * SubFunction: NA
777 * FunctionPoints: AbilityManagerService StartAbilityByCall
778 * EnvConditions: NA
779 * CaseDescription: Verify the function StartAbilityByCall is normal flow.
780 */
781 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbilityByCall_002, TestSize.Level1)
782 {
783 Want want;
784 sptr<IRemoteObject> callerToken = nullptr;
785 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
786 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
787 .Times(1)
788 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
789 EXPECT_EQ(proxy_->StartAbilityByCall(want, connect, callerToken), ERR_OK);
790 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_CALL_ABILITY), mock_->code_);
791 }
792
793 /*
794 * Feature: AbilityManagerService
795 * Function: ReleaseCall
796 * SubFunction: NA
797 * FunctionPoints: AbilityManagerService ReleaseCall
798 * EnvConditions: NA
799 * CaseDescription: Verify the function ReleaseCall connect is nullptr.
800 */
801 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseCall_001, TestSize.Level1)
802 {
803 AppExecFwk::ElementName element;
804 sptr<IAbilityConnection> connect = nullptr;
805 EXPECT_EQ(proxy_->ReleaseCall(connect, element), ERR_INVALID_VALUE);
806 }
807
808 /*
809 * Feature: AbilityManagerService
810 * Function: ReleaseCall
811 * SubFunction: NA
812 * FunctionPoints: AbilityManagerService ReleaseCall
813 * EnvConditions: NA
814 * CaseDescription: Verify the function ReleaseCall is normal flow.
815 */
816 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseCall_002, TestSize.Level1)
817 {
818 AppExecFwk::ElementName element;
819 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
820 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
821 .Times(1)
822 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
823 EXPECT_EQ(proxy_->ReleaseCall(connect, element), ERR_OK);
824 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::RELEASE_CALL_ABILITY), mock_->code_);
825 }
826
827 /*
828 * Feature: AbilityManagerService
829 * Function: GetTopAbility
830 * SubFunction: NA
831 * FunctionPoints: AbilityManagerService GetTopAbility
832 * EnvConditions: NA
833 * CaseDescription: Verify the function GetTopAbility is normal flow.
834 */
835 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetTopAbility_001, TestSize.Level1)
836 {
837 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
838 .Times(1)
839 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
840 proxy_->GetTopAbility();
841 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_TOP_ABILITY), mock_->code_);
842 }
843
844 /*
845 * Feature: AbilityManagerService
846 * Function: GetTopAbility
847 * SubFunction: NA
848 * FunctionPoints: AbilityManagerService GetTopAbility
849 * EnvConditions: NA
850 * CaseDescription: Verify the function GetTopAbility is normal flow.
851 */
852 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetTopAbility_002, TestSize.Level1)
853 {
854 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
855 .Times(1)
856 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
857 sptr<IRemoteObject> token = nullptr;
858 proxy_->GetTopAbility(token);
859 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_TOP_ABILITY_TOKEN), mock_->code_);
860 }
861
862 /*
863 * Feature: AbilityManagerProxy
864 * Function: CheckUIExtensionIsFocused
865 * SubFunction: NA
866 * FunctionPoints: AbilityManagerProxy CheckUIExtensionIsFocused
867 * EnvConditions: NA
868 * CaseDescription: Verify the function CheckUIExtensionIsFocused is normal flow.
869 */
870 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_CheckUIExtensionIsFocused_001, TestSize.Level1)
871 {
872 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
873 .Times(1)
874 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
875 bool isFocused = false;
876 proxy_->CheckUIExtensionIsFocused(0, isFocused);
877 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CHECK_UI_EXTENSION_IS_FOCUSED), mock_->code_);
878 }
879
880 /*
881 * Feature: AbilityManagerService
882 * Function: StartExtensionAbility
883 * SubFunction: NA
884 * FunctionPoints: AbilityManagerService StartExtensionAbility
885 * EnvConditions: NA
886 * CaseDescription: Verify the normal process of StartExtensionAbility
887 */
888 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartExtensionAbility_001, TestSize.Level1)
889 {
890 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
891 .Times(1)
892 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
893 Want want;
894 sptr<IRemoteObject> callerToken = nullptr;
895 auto res = proxy_->StartExtensionAbility(want, callerToken);
896 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_EXTENSION_ABILITY), mock_->code_);
897 EXPECT_EQ(res, NO_ERROR);
898 }
899
900 /*
901 * Feature: AbilityManagerService
902 * Function: StopExtensionAbility
903 * SubFunction: NA
904 * FunctionPoints: AbilityManagerService StopExtensionAbility
905 * EnvConditions: NA
906 * CaseDescription: Verify the normal process of StopExtensionAbility
907 */
908 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StopExtensionAbility_001, TestSize.Level1)
909 {
910 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
911 .Times(1)
912 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
913 Want want;
914 sptr<IRemoteObject> callerToken = nullptr;
915 auto res = proxy_->StopExtensionAbility(want, callerToken);
916 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::STOP_EXTENSION_ABILITY), mock_->code_);
917 EXPECT_EQ(res, NO_ERROR);
918 }
919
920 /*
921 * Feature: AbilityManagerService
922 * Function: MinimizeAbility
923 * SubFunction: NA
924 * FunctionPoints: AbilityManagerService MinimizeAbility
925 * EnvConditions: NA
926 * CaseDescription: Verify the normal process of MinimizeAbility
927 */
928 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_MinimizeAbility_001, TestSize.Level1)
929 {
930 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
931 .Times(1)
932 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
933 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
934 auto res = proxy_->MinimizeAbility(token);
935 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::MINIMIZE_ABILITY), mock_->code_);
936 EXPECT_EQ(res, NO_ERROR);
937 }
938
939 /*
940 * Feature: AbilityManagerService
941 * Function: GetMissionSnapshot
942 * SubFunction: NA
943 * FunctionPoints: AbilityManagerService GetMissionSnapshot
944 * EnvConditions: NA
945 * CaseDescription: Verify the normal process of GetMissionSnapshot
946 */
947 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetMissionSnapshot_001, TestSize.Level1)
948 {
949 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
950 .Times(1)
951 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
952 std::string deviceId = "";
953 int32_t missionId = 1;
954 MissionSnapshot snapshot;
955 bool isLowResolution = true;
956 proxy_->GetMissionSnapshot(deviceId, missionId, snapshot, isLowResolution);
957 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_MISSION_SNAPSHOT_INFO), mock_->code_);
958 }
959
960 /*
961 * Feature: AbilityManagerService
962 * Function: EnableRecoverAbility
963 * SubFunction: NA
964 * FunctionPoints: AbilityManagerService EnableRecoverAbility
965 * EnvConditions: NA
966 * CaseDescription: Verify the normal process of EnableRecoverAbility
967 */
968 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_EnableRecoverAbility_001, TestSize.Level1)
969 {
970 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
971 .Times(1)
972 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
973 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
974 proxy_->EnableRecoverAbility(token);
975 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::ABILITY_RECOVERY_ENABLE), mock_->code_);
976 }
977
978 /*
979 * Feature: AbilityManagerService
980 * Function: ScheduleRecoverAbility
981 * SubFunction: NA
982 * FunctionPoints: AbilityManagerService ScheduleRecoverAbility
983 * EnvConditions: NA
984 * CaseDescription: Verify the normal process of ScheduleRecoverAbility
985 */
986 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ScheduleRecoverAbility_001, TestSize.Level1)
987 {
988 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
989 .Times(1)
990 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
991 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
992 int32_t reason = 0;
993 proxy_->ScheduleRecoverAbility(token, reason);
994 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::ABILITY_RECOVERY), mock_->code_);
995 }
996
997 /*
998 * Feature: AbilityManagerService
999 * Function: KillProcess
1000 * SubFunction: NA
1001 * FunctionPoints: AbilityManagerService KillProcess
1002 * EnvConditions: NA
1003 * CaseDescription: Verify the normal process of KillProcess
1004 */
1005 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_KillProcess_001, TestSize.Level1)
1006 {
1007 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1008 .Times(1)
1009 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1010 std::string bundleName = "";
1011 auto res = proxy_->KillProcess(bundleName);
1012 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::KILL_PROCESS), mock_->code_);
1013 EXPECT_EQ(res, NO_ERROR);
1014 }
1015
1016 #ifdef ABILITY_COMMAND_FOR_TEST
1017 /*
1018 * Feature: AbilityManagerService
1019 * Function: ForceTimeoutForTest
1020 * SubFunction: NA
1021 * FunctionPoints: AbilityManagerService ForceTimeoutForTest
1022 * EnvConditions: NA
1023 * CaseDescription: Verify the normal process of ForceTimeoutForTest
1024 */
1025 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ForceTimeoutForTest_001, TestSize.Level1)
1026 {
1027 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1028 .Times(1)
1029 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1030 std::string abilityName = "";
1031 std::string state = "";
1032 auto res = proxy_->ForceTimeoutForTest(abilityName, state);
1033 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::FORCE_TIMEOUT), mock_->code_);
1034 EXPECT_EQ(res, NO_ERROR);
1035 }
1036 #endif
1037
1038 /*
1039 * Feature: AbilityManagerService
1040 * Function: UninstallApp
1041 * SubFunction: NA
1042 * FunctionPoints: AbilityManagerService UninstallApp
1043 * EnvConditions: NA
1044 * CaseDescription: Verify the normal process of UninstallApp
1045 */
1046 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_UninstallApp_001, TestSize.Level1)
1047 {
1048 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1049 .Times(1)
1050 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1051 std::string bundleName = "";
1052 int32_t uid = 1;
1053 auto res = proxy_->UninstallApp(bundleName, uid);
1054 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::UNINSTALL_APP), mock_->code_);
1055 EXPECT_EQ(res, NO_ERROR);
1056 }
1057
1058 /*
1059 * Feature: AbilityManagerService
1060 * Function: UninstallApp
1061 * SubFunction: NA
1062 * FunctionPoints: AbilityManagerService UninstallApp
1063 * EnvConditions: NA
1064 * CaseDescription: Verify the normal process of UninstallApp
1065 */
1066 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_UninstallApp_002, TestSize.Level1)
1067 {
1068 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1069 .Times(1)
1070 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1071 std::string bundleName = "";
1072 int32_t uid = 1;
1073 int32_t appIndex = 0;
1074 auto res = proxy_->UninstallApp(bundleName, uid, appIndex);
1075 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::UNINSTALL_APP), mock_->code_);
1076 EXPECT_EQ(res, NO_ERROR);
1077 }
1078
1079 /*
1080 * Feature: AbilityManagerService
1081 * Function: UpgradeApp
1082 * SubFunction: NA
1083 * FunctionPoints: AbilityManagerService UpgradeApp
1084 * EnvConditions: NA
1085 * CaseDescription: Verify the normal process of UpgradeApp
1086 */
1087 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_UpgradeApp_001, TestSize.Level1)
1088 {
1089 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1090 .Times(1)
1091 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1092 std::string bundleName = "";
1093 int32_t uid = 1;
1094 std::string exitMsg = "App upgrade.";
1095 int32_t appIndex = 0;
1096 auto res = proxy_->UpgradeApp(bundleName, uid, exitMsg, appIndex);
1097 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::UPGRADE_APP), mock_->code_);
1098 EXPECT_EQ(res, NO_ERROR);
1099 }
1100
1101 /*
1102 * Feature: AbilityManagerService
1103 * Function: GetWantSender
1104 * SubFunction: NA
1105 * FunctionPoints: AbilityManagerService GetWantSender
1106 * EnvConditions: NA
1107 * CaseDescription: Verify the normal process of GetWantSender
1108 */
1109 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetWantSender_001, TestSize.Level1)
1110 {
1111 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1112 .Times(1)
1113 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1114 WantSenderInfo wantSenderInfo;
1115 sptr<IRemoteObject> callerToken = nullptr;
1116 auto res = proxy_->GetWantSender(wantSenderInfo, callerToken);
1117 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_SENDER), mock_->code_);
1118 EXPECT_TRUE(res == nullptr);
1119 }
1120
1121 /*
1122 * Feature: AbilityManagerService
1123 * Function: SendWantSender
1124 * SubFunction: NA
1125 * FunctionPoints: AbilityManagerService SendWantSender
1126 * EnvConditions: NA
1127 * CaseDescription: Verify the normal process of SendWantSender
1128 */
1129 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_SendWantSender_001, TestSize.Level1)
1130 {
1131 sptr<IWantSender> target = nullptr;
1132 SenderInfo senderInfo;
1133 auto res = proxy_->SendWantSender(target, senderInfo);
1134 EXPECT_EQ(res, INNER_ERR);
1135 }
1136
1137 /*
1138 * Feature: AbilityManagerService
1139 * Function: GetPendingWantUid
1140 * SubFunction: NA
1141 * FunctionPoints: AbilityManagerService GetPendingWantUid
1142 * EnvConditions: NA
1143 * CaseDescription: Verify the normal process of GetPendingWantUid
1144 */
1145 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetPendingWantUid_001, TestSize.Level1)
1146 {
1147 sptr<IWantSender> target = nullptr;
1148 auto res = proxy_->GetPendingWantUid(target);
1149 EXPECT_EQ(res, ERR_INVALID_VALUE);
1150 }
1151
1152 /*
1153 * Feature: AbilityManagerService
1154 * Function: GetPendingWantUserId
1155 * SubFunction: NA
1156 * FunctionPoints: AbilityManagerService GetPendingWantUserId
1157 * EnvConditions: NA
1158 * CaseDescription: Verify the normal process of GetPendingWantUserId
1159 */
1160 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetPendingWantUserId_001, TestSize.Level1)
1161 {
1162 sptr<IWantSender> target = nullptr;
1163 auto res = proxy_->GetPendingWantUserId(target);
1164 EXPECT_EQ(res, ERR_INVALID_VALUE);
1165 }
1166
1167 /*
1168 * Feature: AbilityManagerService
1169 * Function: GetPendingWantBundleName
1170 * SubFunction: NA
1171 * FunctionPoints: AbilityManagerService GetPendingWantBundleName
1172 * EnvConditions: NA
1173 * CaseDescription: Verify the normal process of GetPendingWantBundleName
1174 */
1175 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetPendingWantBundleName_001, TestSize.Level1)
1176 {
1177 sptr<IWantSender> target = nullptr;
1178 auto res = proxy_->GetPendingWantBundleName(target);
1179 EXPECT_EQ(res, "");
1180 }
1181
1182 /*
1183 * Feature: AbilityManagerService
1184 * Function: GetPendingWantCode
1185 * SubFunction: NA
1186 * FunctionPoints: AbilityManagerService GetPendingWantCode
1187 * EnvConditions: NA
1188 * CaseDescription: Verify the normal process of GetPendingWantCode
1189 */
1190 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetPendingWantCode_001, TestSize.Level1)
1191 {
1192 sptr<IWantSender> target = nullptr;
1193 auto res = proxy_->GetPendingWantCode(target);
1194 EXPECT_EQ(res, ERR_INVALID_VALUE);
1195 }
1196
1197 /*
1198 * Feature: AbilityManagerService
1199 * Function: GetPendingWantType
1200 * SubFunction: NA
1201 * FunctionPoints: AbilityManagerService GetPendingWantType
1202 * EnvConditions: NA
1203 * CaseDescription: Verify the normal process of GetPendingWantType
1204 */
1205 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetPendingWantType_001, TestSize.Level1)
1206 {
1207 sptr<IWantSender> target = nullptr;
1208 auto res = proxy_->GetPendingWantType(target);
1209 EXPECT_EQ(res, ERR_INVALID_VALUE);
1210 }
1211
1212 /*
1213 * Feature: AbilityManagerService
1214 * Function: GetPendingRequestWant
1215 * SubFunction: NA
1216 * FunctionPoints: AbilityManagerService GetPendingRequestWant
1217 * EnvConditions: NA
1218 * CaseDescription: Verify the normal process of GetPendingRequestWant
1219 */
1220 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetPendingRequestWant_001, TestSize.Level1)
1221 {
1222 sptr<IWantSender> target = nullptr;
1223 auto want = std::make_shared<Want>();
1224 auto res = proxy_->GetPendingRequestWant(target, want);
1225 EXPECT_EQ(res, INNER_ERR);
1226 }
1227
1228 /*
1229 * Feature: AbilityManagerService
1230 * Function: GetWantSenderInfo
1231 * SubFunction: NA
1232 * FunctionPoints: AbilityManagerService GetWantSenderInfo
1233 * EnvConditions: NA
1234 * CaseDescription: Verify the normal process of GetWantSenderInfo
1235 */
1236 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetWantSenderInfo_001, TestSize.Level1)
1237 {
1238 sptr<IWantSender> target = nullptr;
1239 auto info = std::make_shared<WantSenderInfo>();
1240 auto res = proxy_->GetWantSenderInfo(target, info);
1241 EXPECT_EQ(res, INNER_ERR);
1242 }
1243
1244 /*
1245 * Feature: AbilityManagerService
1246 * Function: GetAppMemorySize
1247 * SubFunction: NA
1248 * FunctionPoints: AbilityManagerService GetAppMemorySize
1249 * EnvConditions: NA
1250 * CaseDescription: Verify the normal process of GetAppMemorySize
1251 */
1252 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetAppMemorySize_001, TestSize.Level1)
1253 {
1254 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1255 .Times(1)
1256 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1257 auto res = proxy_->GetAppMemorySize();
1258 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_APP_MEMORY_SIZE), mock_->code_);
1259 EXPECT_EQ(res, NO_ERROR);
1260 }
1261
1262 /*
1263 * Feature: AbilityManagerService
1264 * Function: IsRamConstrainedDevice
1265 * SubFunction: NA
1266 * FunctionPoints: AbilityManagerService IsRamConstrainedDevice
1267 * EnvConditions: NA
1268 * CaseDescription: Verify the normal process of IsRamConstrainedDevice
1269 */
1270 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_IsRamConstrainedDevice_001, TestSize.Level1)
1271 {
1272 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1273 .Times(1)
1274 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1275 auto res = proxy_->IsRamConstrainedDevice();
1276 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::IS_RAM_CONSTRAINED_DEVICE), mock_->code_);
1277 EXPECT_EQ(res, NO_ERROR);
1278 }
1279
1280 /*
1281 * Feature: AbilityManagerService
1282 * Function: ContinueMission
1283 * SubFunction: NA
1284 * FunctionPoints: AbilityManagerService ContinueMission
1285 * EnvConditions: NA
1286 * CaseDescription: Verify the normal process of ContinueMission
1287 */
1288 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ContinueMission_001, TestSize.Level1)
1289 {
1290 std::string srcDeviceId = "";
1291 std::string dstDeviceId = "";
1292 int32_t missionId = 1;
1293 const sptr<IRemoteObject> callBack = nullptr;
1294 AAFwk::WantParams wantParams;
1295 auto res = proxy_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callBack, wantParams);
1296 EXPECT_EQ(res, INNER_ERR);
1297 }
1298
1299 /*
1300 * Feature: AbilityManagerService
1301 * Function: ContinueMissionBundleName
1302 * SubFunction: NA
1303 * FunctionPoints: AbilityManagerService ContinueMissionBundleName
1304 * EnvConditions: NA
1305 * CaseDescription: Verify the normal process of ContinueMissionBundleName
1306 */
1307 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ContinueMissionBundleName_001, TestSize.Level1)
1308 {
1309 std::string srcDeviceId = "";
1310 std::string dstDeviceId = "";
1311 const sptr<IRemoteObject> callback = nullptr;
1312 AAFwk::WantParams wantParams;
1313 ContinueMissionInfo continueMissionInfo;
1314 continueMissionInfo.dstDeviceId = dstDeviceId;
1315 continueMissionInfo.srcDeviceId = srcDeviceId;
1316 continueMissionInfo.bundleName = "bundleName";
1317 continueMissionInfo.wantParams = wantParams;
1318 auto res = proxy_->ContinueMission(continueMissionInfo, callback);
1319 EXPECT_EQ(res, INNER_ERR);
1320 }
1321
1322 /*
1323 * Feature: AbilityManagerService
1324 * Function: ContinueAbility
1325 * SubFunction: NA
1326 * FunctionPoints: AbilityManagerService ContinueAbility
1327 * EnvConditions: NA
1328 * CaseDescription: Verify the normal process of ContinueAbility
1329 */
1330 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ContinueAbility_001, TestSize.Level1)
1331 {
1332 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1333 .Times(1)
1334 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1335 std::string deviceId = "";
1336 int32_t missionId = 1;
1337 uint32_t versionCode = 1;
1338 auto res = proxy_->ContinueAbility(deviceId, missionId, versionCode);
1339 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CONTINUE_ABILITY), mock_->code_);
1340 EXPECT_EQ(res, NO_ERROR);
1341 }
1342
1343 /*
1344 * Feature: AbilityManagerService
1345 * Function: NotifyCompleteContinuation
1346 * SubFunction: NA
1347 * FunctionPoints: AbilityManagerService NotifyCompleteContinuation
1348 * EnvConditions: NA
1349 * CaseDescription: Verify the normal process of NotifyCompleteContinuation
1350 */
1351 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_NotifyCompleteContinuation_001, TestSize.Level1)
1352 {
1353 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1354 .Times(1)
1355 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1356 std::string deviceId = "";
1357 int32_t sessionId = 1;
1358 bool isSuccess = true;
1359 proxy_->NotifyCompleteContinuation(deviceId, sessionId, isSuccess);
1360 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::NOTIFY_COMPLETE_CONTINUATION), mock_->code_);
1361 }
1362
1363 /*
1364 * Feature: AbilityManagerService
1365 * Function: NotifyContinuationResult
1366 * SubFunction: NA
1367 * FunctionPoints: AbilityManagerService NotifyContinuationResult
1368 * EnvConditions: NA
1369 * CaseDescription: Verify the normal process of NotifyContinuationResult
1370 */
1371 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_NotifyContinuationResult_001, TestSize.Level1)
1372 {
1373 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1374 .Times(1)
1375 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1376 int32_t missionId = 1;
1377 int32_t result = 1;
1378 auto res = proxy_->NotifyContinuationResult(missionId, result);
1379 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::NOTIFY_CONTINUATION_RESULT), mock_->code_);
1380 EXPECT_EQ(res, NO_ERROR);
1381 }
1382
1383 /*
1384 * Feature: AbilityManagerService
1385 * Function: LockMissionForCleanup
1386 * SubFunction: NA
1387 * FunctionPoints: AbilityManagerService LockMissionForCleanup
1388 * EnvConditions: NA
1389 * CaseDescription: Verify the normal process of LockMissionForCleanup
1390 */
1391 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_LockMissionForCleanup_001, TestSize.Level1)
1392 {
1393 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1394 .Times(1)
1395 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1396 int32_t missionId = 1;
1397 auto res = proxy_->LockMissionForCleanup(missionId);
1398 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::LOCK_MISSION_FOR_CLEANUP), mock_->code_);
1399 EXPECT_EQ(res, NO_ERROR);
1400 }
1401
1402 /*
1403 * Feature: AbilityManagerService
1404 * Function: UnlockMissionForCleanup
1405 * SubFunction: NA
1406 * FunctionPoints: AbilityManagerService UnlockMissionForCleanup
1407 * EnvConditions: NA
1408 * CaseDescription: Verify the normal process of UnlockMissionForCleanup
1409 */
1410 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_UnlockMissionForCleanup_001, TestSize.Level1)
1411 {
1412 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1413 .Times(1)
1414 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1415 int32_t missionId = 1;
1416 auto res = proxy_->UnlockMissionForCleanup(missionId);
1417 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::UNLOCK_MISSION_FOR_CLEANUP), mock_->code_);
1418 EXPECT_EQ(res, NO_ERROR);
1419 }
1420
1421 /*
1422 * Feature: AbilityManagerService
1423 * Function: RegisterMissionListener
1424 * SubFunction: NA
1425 * FunctionPoints: AbilityManagerService RegisterMissionListener
1426 * EnvConditions: NA
1427 * CaseDescription: Verify the normal process of RegisterMissionListener
1428 */
1429 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_RegisterMissionListener_001, TestSize.Level1)
1430 {
1431 sptr<IMissionListener> listener = nullptr;
1432 auto res = proxy_->RegisterMissionListener(listener);
1433 EXPECT_EQ(res, ERR_INVALID_VALUE);
1434 }
1435
1436 /*
1437 * Feature: AbilityManagerService
1438 * Function: UnRegisterMissionListener
1439 * SubFunction: NA
1440 * FunctionPoints: AbilityManagerService UnRegisterMissionListener
1441 * EnvConditions: NA
1442 * CaseDescription: Verify the normal process of UnRegisterMissionListener
1443 */
1444 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_UnRegisterMissionListener_001, TestSize.Level1)
1445 {
1446 sptr<IMissionListener> listener = nullptr;
1447 auto res = proxy_->UnRegisterMissionListener(listener);
1448 EXPECT_EQ(res, ERR_INVALID_VALUE);
1449 }
1450
1451 /*
1452 * Feature: AbilityManagerService
1453 * Function: CleanMission
1454 * SubFunction: NA
1455 * FunctionPoints: AbilityManagerService CleanMission
1456 * EnvConditions: NA
1457 * CaseDescription: Verify the normal process of CleanMission
1458 */
1459 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_CleanMission_001, TestSize.Level1)
1460 {
1461 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1462 .Times(1)
1463 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1464 int32_t missionId = 1;
1465 auto res = proxy_->CleanMission(missionId);
1466 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CLEAN_MISSION), mock_->code_);
1467 EXPECT_EQ(res, NO_ERROR);
1468 }
1469
1470 /*
1471 * Feature: AbilityManagerService
1472 * Function: CleanAllMissions
1473 * SubFunction: NA
1474 * FunctionPoints: AbilityManagerService CleanAllMissions
1475 * EnvConditions: NA
1476 * CaseDescription: Verify the normal process of CleanAllMissions
1477 */
1478 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_CleanAllMissions_001, TestSize.Level1)
1479 {
1480 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1481 .Times(1)
1482 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1483 auto res = proxy_->CleanAllMissions();
1484 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CLEAN_ALL_MISSIONS), mock_->code_);
1485 EXPECT_EQ(res, NO_ERROR);
1486 }
1487
1488 /*
1489 * Feature: AbilityManagerService
1490 * Function: MoveMissionToFront
1491 * SubFunction: NA
1492 * FunctionPoints: AbilityManagerService MoveMissionToFront
1493 * EnvConditions: NA
1494 * CaseDescription: Verify the normal process of MoveMissionToFront
1495 */
1496 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_MoveMissionToFront_001, TestSize.Level1)
1497 {
1498 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1499 .Times(1)
1500 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1501 int32_t missionId = 1;
1502 auto res = proxy_->MoveMissionToFront(missionId);
1503 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSION_TO_FRONT), mock_->code_);
1504 EXPECT_EQ(res, NO_ERROR);
1505 }
1506
1507 /*
1508 * Feature: AbilityManagerService
1509 * Function: MoveMissionsToForeground
1510 * SubFunction: NA
1511 * FunctionPoints: AbilityManagerService MoveMissionsToForeground
1512 * EnvConditions: NA
1513 * CaseDescription: Verify the normal process of MoveMissionsToForeground
1514 */
1515 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_MoveMissionsToForeground_001, TestSize.Level1)
1516 {
1517 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1518 .Times(1)
1519 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1520 auto res = proxy_->MoveMissionsToForeground({1, 2, 3}, 1);
1521 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSIONS_TO_FOREGROUND), mock_->code_);
1522 EXPECT_EQ(res, NO_ERROR);
1523 }
1524
1525 /*
1526 * Feature: AbilityManagerService
1527 * Function: MoveMissionsToBackground
1528 * SubFunction: NA
1529 * FunctionPoints: AbilityManagerService MoveMissionsToBackground
1530 * EnvConditions: NA
1531 * CaseDescription: Verify the normal process of MoveMissionsToBackground
1532 */
1533 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_MoveMissionsToBackground_001, TestSize.Level1)
1534 {
1535 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1536 .Times(1)
1537 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1538 std::vector<int32_t> rs;
1539 auto res = proxy_->MoveMissionsToBackground({1, 2, 3}, rs);
1540 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSIONS_TO_BACKGROUND), mock_->code_);
1541 EXPECT_EQ(res, NO_ERROR);
1542 }
1543
1544 /*
1545 * Feature: AbilityManagerService
1546 * Function: StartUser
1547 * SubFunction: NA
1548 * FunctionPoints: AbilityManagerService StartUser
1549 * EnvConditions: NA
1550 * CaseDescription: Verify the normal process of StartUser
1551 */
1552 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartUser_001, TestSize.Level1)
1553 {
1554 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1555 .Times(1)
1556 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1557 int userId = 1;
1558 auto res = proxy_->StartUser(userId, nullptr);
1559 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_USER), mock_->code_);
1560 EXPECT_EQ(res, NO_ERROR);
1561 }
1562
1563 /*
1564 * Feature: AbilityManagerService
1565 * Function: StopUser
1566 * SubFunction: NA
1567 * FunctionPoints: AbilityManagerService StopUser
1568 * EnvConditions: NA
1569 * CaseDescription: Verify the normal process of StopUser
1570 */
1571 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StopUser_001, TestSize.Level1)
1572 {
1573 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1574 .Times(1)
1575 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1576 int userId = 1;
1577 sptr<IUserCallback> callback = nullptr;
1578 auto res = proxy_->StopUser(userId, callback);
1579 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::STOP_USER), mock_->code_);
1580 EXPECT_EQ(res, NO_ERROR);
1581 }
1582
1583 /*
1584 * Feature: AbilityManagerService
1585 * Function: SetMissionContinueState
1586 * SubFunction: NA
1587 * FunctionPoints: AbilityManagerService SetMissionContinueState
1588 * EnvConditions: NA
1589 * CaseDescription: Verify the normal process of SetMissionContinueState
1590 */
1591 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_SetMissionContinueState_001, TestSize.Level1)
1592 {
1593 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1594 .Times(1)
1595 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1596 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1597 AAFwk::ContinueState state = AAFwk::ContinueState::CONTINUESTATE_ACTIVE;
1598 auto res = proxy_->SetMissionContinueState(token, state);
1599 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_MISSION_CONTINUE_STATE), mock_->code_);
1600 EXPECT_EQ(res, NO_ERROR);
1601 }
1602
1603 /*
1604 * Feature: AbilityManagerService
1605 * Function: SetMissionContinueState
1606 * SubFunction: NA
1607 * FunctionPoints: AbilityManagerService SetMissionContinueState
1608 * EnvConditions: NA
1609 * CaseDescription: Verify the normal process of SetMissionContinueState
1610 */
1611 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_SetMissionContinueState_002, TestSize.Level1)
1612 {
1613 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1614 .Times(1)
1615 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1616 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1617 AAFwk::ContinueState state = AAFwk::ContinueState::CONTINUESTATE_INACTIVE;
1618 auto res = proxy_->SetMissionContinueState(token, state);
1619 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_MISSION_CONTINUE_STATE), mock_->code_);
1620 EXPECT_EQ(res, NO_ERROR);
1621 }
1622
1623 /*
1624 * Feature: AbilityManagerService
1625 * Function: SetMissionLabel
1626 * SubFunction: NA
1627 * FunctionPoints: AbilityManagerService SetMissionLabel
1628 * EnvConditions: NA
1629 * CaseDescription: Verify the normal process of SetMissionLabel
1630 */
1631 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_SetMissionLabel_001, TestSize.Level1)
1632 {
1633 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1634 .Times(1)
1635 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1636 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1637 std::string label = "";
1638 auto res = proxy_->SetMissionLabel(token, label);
1639 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_MISSION_LABEL), mock_->code_);
1640 EXPECT_EQ(res, NO_ERROR);
1641 }
1642
1643 /*
1644 * Feature: AbilityManagerService
1645 * Function: RegisterWindowManagerServiceHandler
1646 * SubFunction: NA
1647 * FunctionPoints: AbilityManagerService RegisterWindowManagerServiceHandler
1648 * EnvConditions: NA
1649 * CaseDescription: Verify the normal process of RegisterWindowManagerServiceHandler
1650 */
1651 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_RegisterWindowManagerServiceHandler_001, TestSize.Level1)
1652 {
1653 sptr<IWindowManagerServiceHandler> handler = nullptr;
1654 auto res = proxy_->RegisterWindowManagerServiceHandler(handler, true);
1655 EXPECT_EQ(res, INNER_ERR);
1656 }
1657
1658 /*
1659 * Feature: AbilityManagerService
1660 * Function: CompleteFirstFrameDrawing
1661 * SubFunction: NA
1662 * FunctionPoints: AbilityManagerService CompleteFirstFrameDrawing
1663 * EnvConditions: NA
1664 * CaseDescription: Verify the normal process of CompleteFirstFrameDrawing
1665 */
1666 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_CompleteFirstFrameDrawing_001, TestSize.Level1)
1667 {
1668 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1669 .Times(1)
1670 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1671 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1672 proxy_->CompleteFirstFrameDrawing(abilityToken);
1673 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::COMPLETEFIRSTFRAMEDRAWING), mock_->code_);
1674 }
1675
1676 /*
1677 * Feature: AbilityManagerService
1678 * Function: GetAbilityRunningInfos
1679 * SubFunction: NA
1680 * FunctionPoints: AbilityManagerService GetAbilityRunningInfos
1681 * EnvConditions: NA
1682 * CaseDescription: Verify the normal process of GetAbilityRunningInfos
1683 */
1684 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetAbilityRunningInfos_001, TestSize.Level1)
1685 {
1686 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1687 .Times(1)
1688 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1689 std::vector<AbilityRunningInfo> info;
1690 auto res = proxy_->GetAbilityRunningInfos(info);
1691 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_ABILITY_RUNNING_INFO), mock_->code_);
1692 EXPECT_EQ(res, NO_ERROR);
1693 }
1694
1695 /*
1696 * Feature: AbilityManagerService
1697 * Function: GetExtensionRunningInfos
1698 * SubFunction: NA
1699 * FunctionPoints: AbilityManagerService GetExtensionRunningInfos
1700 * EnvConditions: NA
1701 * CaseDescription: Verify the normal process of GetExtensionRunningInfos
1702 */
1703 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetExtensionRunningInfos_001, TestSize.Level1)
1704 {
1705 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1706 .Times(1)
1707 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1708 int upperLimit = 0;
1709 std::vector<ExtensionRunningInfo> info;
1710 auto res = proxy_->GetExtensionRunningInfos(upperLimit, info);
1711 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_EXTENSION_RUNNING_INFO), mock_->code_);
1712 EXPECT_EQ(res, NO_ERROR);
1713 }
1714
1715 /*
1716 * Feature: AbilityManagerService
1717 * Function: GetProcessRunningInfos
1718 * SubFunction: NA
1719 * FunctionPoints: AbilityManagerService GetProcessRunningInfos
1720 * EnvConditions: NA
1721 * CaseDescription: Verify the normal process of GetProcessRunningInfos
1722 */
1723 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetProcessRunningInfos_001, TestSize.Level1)
1724 {
1725 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1726 .Times(1)
1727 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1728 std::vector<AppExecFwk::RunningProcessInfo> info;
1729 auto res = proxy_->GetProcessRunningInfos(info);
1730 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PROCESS_RUNNING_INFO), mock_->code_);
1731 EXPECT_EQ(res, NO_ERROR);
1732 }
1733
1734 /*
1735 * Feature: AbilityManagerService
1736 * Function: StartSyncRemoteMissions
1737 * SubFunction: NA
1738 * FunctionPoints: AbilityManagerService StartSyncRemoteMissions
1739 * EnvConditions: NA
1740 * CaseDescription: Verify the normal process of StartSyncRemoteMissions
1741 */
1742 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartSyncRemoteMissions_001, TestSize.Level1)
1743 {
1744 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1745 .Times(1)
1746 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1747 std::string devId = "";
1748 bool fixConflict = true;
1749 int64_t tag = 0;
1750 auto res = proxy_->StartSyncRemoteMissions(devId, fixConflict, tag);
1751 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_SYNC_MISSIONS), mock_->code_);
1752 EXPECT_EQ(res, NO_ERROR);
1753 }
1754
1755 /*
1756 * Feature: AbilityManagerService
1757 * Function: StopSyncRemoteMissions
1758 * SubFunction: NA
1759 * FunctionPoints: AbilityManagerService StopSyncRemoteMissions
1760 * EnvConditions: NA
1761 * CaseDescription: Verify the normal process of StopSyncRemoteMissions
1762 */
1763 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StopSyncRemoteMissions_001, TestSize.Level1)
1764 {
1765 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1766 .Times(1)
1767 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1768 std::string devId = "";
1769 auto res = proxy_->StopSyncRemoteMissions(devId);
1770 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::STOP_SYNC_MISSIONS), mock_->code_);
1771 EXPECT_EQ(res, NO_ERROR);
1772 }
1773
1774 /*
1775 * Feature: AbilityManagerService
1776 * Function: SetAbilityController
1777 * SubFunction: NA
1778 * FunctionPoints: AbilityManagerService SetAbilityController
1779 * EnvConditions: NA
1780 * CaseDescription: Verify the normal process of SetAbilityController
1781 */
1782 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_SetAbilityController_001, TestSize.Level1)
1783 {
1784 sptr<AppExecFwk::IAbilityController> abilityController = nullptr;
1785 bool imAStabilityTest = true;
1786 auto res = proxy_->SetAbilityController(abilityController, imAStabilityTest);
1787 EXPECT_EQ(res, ERR_INVALID_VALUE);
1788 }
1789
1790 /*
1791 * Feature: AbilityManagerService
1792 * Function: IsRunningInStabilityTest
1793 * SubFunction: NA
1794 * FunctionPoints: AbilityManagerService IsRunningInStabilityTest
1795 * EnvConditions: NA
1796 * CaseDescription: Verify the normal process of IsRunningInStabilityTest
1797 */
1798 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_IsRunningInStabilityTest_001, TestSize.Level1)
1799 {
1800 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1801 .Times(1)
1802 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1803 auto res = proxy_->IsRunningInStabilityTest();
1804 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::IS_USER_A_STABILITY_TEST), mock_->code_);
1805 EXPECT_EQ(res, NO_ERROR);
1806 }
1807
1808 /*
1809 * Feature: AbilityManagerService
1810 * Function: StartUserTest
1811 * SubFunction: NA
1812 * FunctionPoints: AbilityManagerService StartUserTest
1813 * EnvConditions: NA
1814 * CaseDescription: Verify the normal process of StartUserTest
1815 */
1816 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartUserTest_001, TestSize.Level1)
1817 {
1818 Want want;
1819 sptr<IRemoteObject> observer = nullptr;
1820 auto res = proxy_->StartUserTest(want, observer);
1821 EXPECT_EQ(res, INNER_ERR);
1822 }
1823
1824 /*
1825 * Feature: AbilityManagerService
1826 * Function: FinishUserTest
1827 * SubFunction: NA
1828 * FunctionPoints: AbilityManagerService FinishUserTest
1829 * EnvConditions: NA
1830 * CaseDescription: Verify the normal process of FinishUserTest
1831 */
1832 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_FinishUserTest_001, TestSize.Level1)
1833 {
1834 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1835 .Times(1)
1836 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1837 std::string msg = "";
1838 int64_t resultCode = 0;
1839 std::string bundleName = "";
1840 auto res = proxy_->FinishUserTest(msg, resultCode, bundleName);
1841 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::FINISH_USER_TEST), mock_->code_);
1842 EXPECT_EQ(res, NO_ERROR);
1843 }
1844
1845 /*
1846 * Feature: AbilityManagerService
1847 * Function: DelegatorDoAbilityForeground
1848 * SubFunction: NA
1849 * FunctionPoints: AbilityManagerService DelegatorDoAbilityForeground
1850 * EnvConditions: NA
1851 * CaseDescription: Verify the normal process of DelegatorDoAbilityForeground
1852 */
1853 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DelegatorDoAbilityForeground_001, TestSize.Level1)
1854 {
1855 sptr<IRemoteObject> token = nullptr;
1856 auto res = proxy_->DelegatorDoAbilityForeground(token);
1857 EXPECT_EQ(res, ERR_INVALID_VALUE);
1858 }
1859
1860 /*
1861 * Feature: AbilityManagerService
1862 * Function: DelegatorDoAbilityBackground
1863 * SubFunction: NA
1864 * FunctionPoints: AbilityManagerService DelegatorDoAbilityBackground
1865 * EnvConditions: NA
1866 * CaseDescription: Verify the normal process of DelegatorDoAbilityBackground
1867 */
1868 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DelegatorDoAbilityBackground_001, TestSize.Level1)
1869 {
1870 sptr<IRemoteObject> token = nullptr;
1871 auto res = proxy_->DelegatorDoAbilityBackground(token);
1872 EXPECT_EQ(res, ERR_INVALID_VALUE);
1873 }
1874
1875 /*
1876 * Feature: AbilityManagerService
1877 * Function: DoAbilityForeground
1878 * SubFunction: NA
1879 * FunctionPoints: AbilityManagerService DoAbilityForeground
1880 * EnvConditions: NA
1881 * CaseDescription: Verify the normal process of DoAbilityForeground
1882 */
1883 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DoAbilityForeground_001, TestSize.Level1)
1884 {
1885 sptr<IRemoteObject> token = nullptr;
1886 uint32_t flag = 0;
1887 auto res = proxy_->DoAbilityForeground(token, flag);
1888 EXPECT_EQ(res, ERR_INVALID_VALUE);
1889 }
1890
1891 /*
1892 * Feature: AbilityManagerService
1893 * Function: DoAbilityBackground
1894 * SubFunction: NA
1895 * FunctionPoints: AbilityManagerService DoAbilityBackground
1896 * EnvConditions: NA
1897 * CaseDescription: Verify the normal process of DoAbilityBackground
1898 */
1899 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DoAbilityBackground_001, TestSize.Level1)
1900 {
1901 sptr<IRemoteObject> token = nullptr;
1902 uint32_t flag = 0;
1903 auto res = proxy_->DoAbilityBackground(token, flag);
1904 EXPECT_EQ(res, ERR_INVALID_VALUE);
1905 }
1906
1907 /**
1908 * @tc.name: AbilityManagerProxyTest_MoveUIAbilityToBackground_0100
1909 * @tc.desc: Test the state of MoveUIAbilityToBackground
1910 * @tc.type: FUNC
1911 */
1912 HWTEST_F(AbilityManagerProxyTest, MoveUIAbilityToBackground_0100, TestSize.Level1)
1913 {
1914 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1915 .Times(1)
1916 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1917 auto token = sptr<MockAbilityToken>::MakeSptr();
1918 auto res = proxy_->MoveUIAbilityToBackground(token);
1919 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_UI_ABILITY_TO_BACKGROUND), mock_->code_);
1920 EXPECT_EQ(res, NO_ERROR);
1921 }
1922
1923 /**
1924 * @tc.number: ReportDrawnCompleted_001
1925 * @tc.name: ReportDrawnCompleted
1926 * @tc.desc: After passing in a callerToken with parameter nullptr, INNER_ERR is returned
1927 */
1928 HWTEST_F(AbilityManagerProxyTest, ReportDrawnCompleted_001, TestSize.Level1)
1929 {
1930 sptr<IRemoteObject> callerToken = nullptr;
1931 auto res = proxy_->ReportDrawnCompleted(callerToken);
1932 EXPECT_EQ(res, INNER_ERR);
1933 }
1934
1935 /**
1936 * @tc.number: ReportDrawnCompleted_002
1937 * @tc.name: ReportDrawnCompleted
1938 * @tc.desc: After passing in the parameter callerToken, NO_ERROR is returned
1939 */
1940 HWTEST_F(AbilityManagerProxyTest, ReportDrawnCompleted_002, TestSize.Level1)
1941 {
1942 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1943 .Times(1)
1944 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1945 OHOS::sptr<IRemoteObject> callerToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1946 auto res = proxy_->ReportDrawnCompleted(callerToken);
1947 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::REPORT_DRAWN_COMPLETED), mock_->code_);
1948 EXPECT_EQ(res, NO_ERROR);
1949 }
1950
1951 /*
1952 * Feature: AbilityManagerService
1953 * Function: GetMissionIdByToken
1954 * SubFunction: NA
1955 * FunctionPoints: AbilityManagerService GetMissionIdByToken
1956 * EnvConditions: NA
1957 * CaseDescription: Verify the normal process of GetMissionIdByToken
1958 */
1959 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetMissionIdByToken_001, TestSize.Level1)
1960 {
1961 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1962 .Times(1)
1963 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1964 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1965 auto res = proxy_->GetMissionIdByToken(token);
1966 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_MISSION_ID_BY_ABILITY_TOKEN), mock_->code_);
1967 EXPECT_EQ(res, NO_ERROR);
1968 }
1969
1970 /*
1971 * Feature: AbilityManagerService
1972 * Function: FreeInstallAbilityFromRemote
1973 * SubFunction: NA
1974 * FunctionPoints: AbilityManagerService FreeInstallAbilityFromRemote
1975 * EnvConditions: NA
1976 * CaseDescription: Verify the normal process of FreeInstallAbilityFromRemote
1977 */
1978 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_FreeInstallAbilityFromRemote_001, TestSize.Level1)
1979 {
1980 Want want;
1981 sptr<IRemoteObject> callback = nullptr;
1982 int32_t userId = 0;
1983 int requestCode = 0;
1984 auto res = proxy_->FreeInstallAbilityFromRemote(want, callback, userId, requestCode);
1985 EXPECT_EQ(res, INNER_ERR);
1986 }
1987
1988 /*
1989 * Feature: AbilityManagerService
1990 * Function: DumpAbilityInfoDone
1991 * SubFunction: NA
1992 * FunctionPoints: AbilityManagerService DumpAbilityInfoDone
1993 * EnvConditions: NA
1994 * CaseDescription: Verify the normal process of DumpAbilityInfoDone
1995 */
1996 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DumpAbilityInfoDone_001, TestSize.Level1)
1997 {
1998 std::vector<std::string> infos;
1999 sptr<IRemoteObject> callerToken = nullptr;
2000 auto res = proxy_->DumpAbilityInfoDone(infos, callerToken);
2001 EXPECT_EQ(res, INNER_ERR);
2002 }
2003
2004 /*
2005 * Feature: AbilityManagerService
2006 * Function: StartAbility
2007 * SubFunction: NA
2008 * FunctionPoints: AbilityManagerService StartAbility
2009 * EnvConditions: NA
2010 * CaseDescription: Verify the normal process of startability
2011 */
2012 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbility_001, TestSize.Level1)
2013 {
2014 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2015 .Times(1)
2016 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2017 const Want want;
2018 sptr<IRemoteObject> callerToken = nullptr;
2019 auto res = proxy_->StartAbility(want, callerToken);
2020 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_ADD_CALLER), mock_->code_);
2021 EXPECT_EQ(res, NO_ERROR);
2022 }
2023
2024 /*
2025 * Feature: AbilityManagerService
2026 * Function: StartAbilityWithSpecifyTokenId
2027 * SubFunction: NA
2028 * FunctionPoints: AbilityManagerService StartAbilityWithSpecifyTokenId
2029 * EnvConditions: NA
2030 * CaseDescription: Verify the normal process of startability with specify token id
2031 */
2032 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbilityWithSpecifyTokenId_001, TestSize.Level1)
2033 {
2034 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2035 .Times(1)
2036 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2037 const Want want;
2038 sptr<IRemoteObject> callerToken = nullptr;
2039 uint32_t specifyTokenId = 0;
2040 auto res = proxy_->StartAbilityWithSpecifyTokenId(want, callerToken, specifyTokenId);
2041 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_WITH_SPECIFY_TOKENID), mock_->code_);
2042 EXPECT_EQ(res, NO_ERROR);
2043 }
2044
2045 /*
2046 * Feature: AbilityManagerService
2047 * Function: StartAbilityAsCaller
2048 * SubFunction: NA
2049 * FunctionPoints: AbilityManagerService StartAbilityAsCaller
2050 * EnvConditions: NA
2051 * CaseDescription: Verify the normal process of StartAbilityAsCaller
2052 */
2053 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbilityAsCaller_001, TestSize.Level1)
2054 {
2055 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2056 .Times(1)
2057 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2058 const Want want;
2059 sptr<IRemoteObject> callerToken = nullptr;
2060 auto res = proxy_->StartAbilityAsCaller(want, callerToken, nullptr);
2061 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_AS_CALLER_BY_TOKEN), mock_->code_);
2062 EXPECT_EQ(res, NO_ERROR);
2063 }
2064
2065 /*
2066 * Feature: AbilityManagerService
2067 * Function: StartAbilityAsCaller
2068 * SubFunction: NA
2069 * FunctionPoints: AbilityManagerService StartAbilityAsCaller
2070 * EnvConditions: NA
2071 * CaseDescription: Verify the normal process of StartAbilityAsCaller
2072 */
2073 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbilityAsCaller_002, TestSize.Level1)
2074 {
2075 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2076 .Times(1)
2077 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2078 const Want want;
2079 sptr<IRemoteObject> callerToken = nullptr;
2080 StartOptions startOptions;
2081 auto res = proxy_->StartAbilityAsCaller(want, startOptions, callerToken, nullptr);
2082 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_AS_CALLER_FOR_OPTIONS), mock_->code_);
2083 EXPECT_EQ(res, NO_ERROR);
2084 }
2085
2086 /*
2087 * Feature: AbilityManagerService
2088 * Function: StartAbilityForResultAsCaller
2089 * SubFunction: NA
2090 * FunctionPoints: AbilityManagerService StartAbilityForResultAsCaller
2091 * EnvConditions: NA
2092 * CaseDescription: Verify the normal process of StartAbilityForResultAsCaller
2093 */
2094 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbilityForResultAsCaller_001, TestSize.Level1)
2095 {
2096 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2097 .Times(1)
2098 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2099 const Want want;
2100 sptr<IRemoteObject> callerToken = nullptr;
2101 int requestCode = 1;
2102 int32_t userId = 2;
2103 auto res = proxy_->StartAbilityForResultAsCaller(want, callerToken, requestCode, userId);
2104 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_FOR_RESULT_AS_CALLER), mock_->code_);
2105 EXPECT_EQ(res, NO_ERROR);
2106 }
2107
2108 /*
2109 * Feature: AbilityManagerService
2110 * Function: StartAbilityForResultAsCaller
2111 * SubFunction: NA
2112 * FunctionPoints: AbilityManagerService StartAbilityForResultAsCaller
2113 * EnvConditions: NA
2114 * CaseDescription: Verify the normal process of StartAbilityForResultAsCaller
2115 */
2116 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbilityForResultAsCaller_002, TestSize.Level1)
2117 {
2118 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2119 .Times(1)
2120 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2121 const Want want;
2122 sptr<IRemoteObject> callerToken = nullptr;
2123 StartOptions startOptions;
2124 int requestCode = 1;
2125 int32_t userId = 2;
2126 auto res = proxy_->StartAbilityForResultAsCaller(want, startOptions, callerToken, requestCode, userId);
2127 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_FOR_RESULT_AS_CALLER_FOR_OPTIONS),
2128 mock_->code_);
2129 EXPECT_EQ(res, NO_ERROR);
2130 }
2131
2132 /*
2133 * Feature: AbilityManagerService
2134 * Function: CallRequestDone
2135 * SubFunction: NA
2136 * FunctionPoints: AbilityManagerService CallRequestDone
2137 * EnvConditions: NA
2138 * CaseDescription: Verify the normal process of CallRequestDone
2139 */
2140 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_CallRequestDone_001, TestSize.Level1)
2141 {
2142 sptr<IRemoteObject> token = nullptr;
2143 sptr<IRemoteObject> callStub = nullptr;
2144 proxy_->CallRequestDone(token, callStub);
2145 EXPECT_TRUE(proxy_ != nullptr);
2146 }
2147
2148 /*
2149 * Feature: AbilityManagerService
2150 * Function: IsValidMissionIds
2151 * SubFunction: NA
2152 * FunctionPoints: AbilityManagerService IsValidMissionIds
2153 * EnvConditions: NA
2154 * CaseDescription: Verify the normal process of IsValidMissionIds
2155 */
2156 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_IsValidMissionIds_001, TestSize.Level1)
2157 {
2158 std::vector<int32_t> missionIds;
2159 std::vector<MissionValidResult> results;
__anon49fd87da0202(uint32_t id, MessageParcel &data, MessageParcel &reply, MessageOption &o) 2160 auto isValidMissionIdsTask = [&](uint32_t id, MessageParcel &data, MessageParcel &reply, MessageOption &o) {
2161 constexpr int32_t size = 10;
2162 constexpr int32_t errorCode = ERR_OK;
2163 reply.WriteInt32(errorCode);
2164 reply.WriteInt32(size);
2165 for (auto i = 0; i < size; ++i) {
2166 MissionValidResult results;
2167 results.missionId = i;
2168 reply.WriteParcelable(&results);
2169 }
2170 return NO_ERROR;
2171 };
2172 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(testing::Invoke(isValidMissionIdsTask));
2173 EXPECT_EQ(proxy_->IsValidMissionIds(missionIds, results), ERR_OK);
2174 }
2175
2176 /*
2177 * Feature: AbilityManagerService
2178 * Function: IsValidMissionIds
2179 * SubFunction: NA
2180 * FunctionPoints: AbilityManagerService IsValidMissionIds
2181 * EnvConditions: NA
2182 * CaseDescription: Verify the normal process of IsValidMissionIds
2183 */
2184 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_IsValidMissionIds_002, TestSize.Level1)
2185 {
2186 std::vector<int32_t> missionIds;
2187 std::vector<MissionValidResult> results;
__anon49fd87da0302(uint32_t id, MessageParcel &data, MessageParcel &reply, MessageOption &o) 2188 auto isValidMissionIdsTask = [&](uint32_t id, MessageParcel &data, MessageParcel &reply, MessageOption &o) {
2189 constexpr int32_t size = 30;
2190 constexpr int32_t errorCode = ERR_OK;
2191 MissionValidResult results;
2192 reply.WriteInt32(errorCode);
2193 reply.WriteInt32(size);
2194 for (auto i = 0; i < size; ++i) {
2195 MissionValidResult results;
2196 results.missionId = i;
2197 reply.WriteParcelable(&results);
2198 }
2199 return NO_ERROR;
2200 };
2201 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(testing::Invoke(isValidMissionIdsTask));
2202 EXPECT_EQ(proxy_->IsValidMissionIds(missionIds, results), ERR_OK);
2203 }
2204
2205 /*
2206 * Feature: AbilityManagerService
2207 * Function: IsValidMissionIds
2208 * SubFunction: NA
2209 * FunctionPoints: AbilityManagerService IsValidMissionIds
2210 * EnvConditions: NA
2211 * CaseDescription: Verify the normal process of IsValidMissionIds
2212 */
2213 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_IsValidMissionIds_003, TestSize.Level1)
2214 {
2215 std::vector<int32_t> missionIds;
2216 std::vector<MissionValidResult> results;
__anon49fd87da0402(uint32_t id, MessageParcel &data, MessageParcel &reply, MessageOption &o) 2217 auto isValidMissionIdsTask = [&](uint32_t id, MessageParcel &data, MessageParcel &reply, MessageOption &o) {
2218 constexpr int32_t size = 1;
2219 constexpr int32_t errorCode = ERR_OK;
2220 reply.WriteInt32(errorCode);
2221 reply.WriteInt32(size);
2222 return NO_ERROR;
2223 };
2224 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(testing::Invoke(isValidMissionIdsTask));
2225 EXPECT_EQ(proxy_->IsValidMissionIds(missionIds, results), INNER_ERR);
2226 }
2227
2228 /*
2229 * Feature: AbilityManagerService
2230 * Function: IsValidMissionIds
2231 * SubFunction: NA
2232 * FunctionPoints: AbilityManagerService IsValidMissionIds
2233 * EnvConditions: NA
2234 * CaseDescription: Verify the normal process of IsValidMissionIds
2235 */
2236 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_IsValidMissionIds_004, TestSize.Level1)
2237 {
2238 std::vector<int32_t> missionIds;
2239 std::vector<MissionValidResult> results;
__anon49fd87da0502(uint32_t id, MessageParcel &data, MessageParcel &reply, MessageOption &o) 2240 auto isValidMissionIdsTask = [&](uint32_t id, MessageParcel &data, MessageParcel &reply, MessageOption &o) {
2241 constexpr int32_t size = 0;
2242 constexpr int32_t errorCode = ERR_OK;
2243 reply.WriteInt32(errorCode);
2244 reply.WriteInt32(size);
2245 return NO_ERROR;
2246 };
2247 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(testing::Invoke(isValidMissionIdsTask));
2248 EXPECT_EQ(proxy_->IsValidMissionIds(missionIds, results), NO_ERROR);
2249 }
2250
2251 /*
2252 * Feature: AbilityManagerService
2253 * Function: IsValidMissionIds
2254 * SubFunction: NA
2255 * FunctionPoints: AbilityManagerService IsValidMissionIds
2256 * EnvConditions: NA
2257 * CaseDescription: Verify the normal process of IsValidMissionIds
2258 */
2259 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_IsValidMissionIds_005, TestSize.Level1)
2260 {
2261 std::vector<int32_t> missionIds;
2262 std::vector<MissionValidResult> results;
2263 for (auto i = 0; i < 30; ++i) {
2264 missionIds.push_back(i);
2265 }
2266 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(ERR_INVALID_VALUE));
2267 EXPECT_EQ(proxy_->IsValidMissionIds(missionIds, results), ERR_INVALID_VALUE);
2268 }
2269
2270 /*
2271 * Feature: AbilityManagerService
2272 * Function: IsValidMissionIds
2273 * SubFunction: NA
2274 * FunctionPoints: AbilityManagerService IsValidMissionIds
2275 * EnvConditions: NA
2276 * CaseDescription: Verify the normal process of IsValidMissionIds
2277 */
2278 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_IsValidMissionIds_006, TestSize.Level1)
2279 {
2280 std::vector<int32_t> missionIds;
2281 std::vector<MissionValidResult> results;
2282 for (auto i = 0; i < 10; ++i) {
2283 missionIds.push_back(i);
2284 }
2285 proxy_ = std::make_shared<AbilityManagerProxy>(nullptr);
2286 EXPECT_EQ(proxy_->IsValidMissionIds(missionIds, results), INNER_ERR);
2287 }
2288
2289 /*
2290 * Feature: AbilityManagerService
2291 * Function: ForceExitApp
2292 * SubFunction: NA
2293 * FunctionPoints: AbilityManagerService ForceExitApp
2294 * EnvConditions: NA
2295 * CaseDescription: Verify the normal process of ForceExitApp
2296 */
2297 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ForceExitApp_001, TestSize.Level1)
2298 {
2299 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2300 .Times(1)
2301 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2302 int32_t pid = 0;
2303 ExitReason exitReason = { REASON_JS_ERROR, "Js Error." };
2304 auto res = proxy_->ForceExitApp(pid, exitReason);
2305 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::FORCE_EXIT_APP), mock_->code_);
2306 EXPECT_EQ(res, NO_ERROR);
2307 }
2308
2309 /*
2310 * Feature: AbilityManagerService
2311 * Function: RecordAppExitReason
2312 * SubFunction: NA
2313 * FunctionPoints: AbilityManagerService RecordAppExitReason
2314 * EnvConditions: NA
2315 * CaseDescription: Verify the normal process of RecordAppExitReason
2316 */
2317 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_RecordAppExitReason_001, TestSize.Level1)
2318 {
2319 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2320 .Times(1)
2321 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2322 ExitReason exitReason = { REASON_JS_ERROR, "Js Error." };
2323 auto res = proxy_->RecordAppExitReason(exitReason);
2324 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::RECORD_APP_EXIT_REASON), mock_->code_);
2325 EXPECT_EQ(res, NO_ERROR);
2326 }
2327
2328 /*
2329 * Feature: AbilityManagerService
2330 * Function: RecordProcessExitReason
2331 * SubFunction: NA
2332 * FunctionPoints: AbilityManagerService RecordProcessExitReason
2333 * EnvConditions: NA
2334 * CaseDescription: Verify the normal process of RecordProcessExitReason
2335 */
2336 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_RecordProcessExitReason_001, TestSize.Level1)
2337 {
2338 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2339 .Times(1)
2340 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2341 int32_t pid = 1;
2342 ExitReason exitReason = { REASON_JS_ERROR, "Js Error." };
2343 auto res = proxy_->RecordProcessExitReason(pid, exitReason);
2344 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::RECORD_PROCESS_EXIT_REASON), mock_->code_);
2345 EXPECT_EQ(res, NO_ERROR);
2346 }
2347
2348 /*
2349 * Feature: AbilityManagerService
2350 * Function: PrepareTerminateAbilityBySCB
2351 * SubFunction: NA
2352 * FunctionPoints: AbilityManagerService PrepareTerminateAbilityBySCB
2353 * EnvConditions: NA
2354 * CaseDescription: Verify the normal process of PrepareTerminateAbilityBySCB
2355 */
2356 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_PrepareTerminateAbilityBySCB_001, TestSize.Level1)
2357 {
2358 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2359 .Times(1)
2360 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2361 sptr<SessionInfo> sessionInfo = nullptr;
2362 bool isPrepareTerminate = false;
2363 auto res = proxy_->PrepareTerminateAbilityBySCB(sessionInfo, isPrepareTerminate);
2364 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::PREPARE_TERMINATE_ABILITY_BY_SCB), mock_->code_);
2365 EXPECT_EQ(res, NO_ERROR);
2366 }
2367
2368 /*
2369 * Feature: AbilityManagerService
2370 * Function: StartAbilityByUIContentSession
2371 * SubFunction: NA
2372 * FunctionPoints: AbilityManagerService StartExtensionAbility
2373 * EnvConditions: NA
2374 * CaseDescription: Verify the normal process of StartExtensionAbility
2375 */
2376 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbilityByUIContentSession_001, TestSize.Level1)
2377 {
2378 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2379 .Times(1)
2380 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2381 Want want;
2382 sptr<IRemoteObject> callerToken = nullptr;
2383 const sptr<AAFwk::SessionInfo> sessionInfo = nullptr;
2384 StartOptions startOptions;
2385 auto res = proxy_->StartAbilityByUIContentSession(want, startOptions, callerToken, sessionInfo);
2386 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_SESSION_ABILITY_FOR_OPTIONS), mock_->code_);
2387 EXPECT_EQ(res, NO_ERROR);
2388 }
2389
2390 /*
2391 * Feature: AbilityManagerService
2392 * Function: StartAbilityByUIContentSession
2393 * SubFunction: NA
2394 * FunctionPoints: AbilityManagerService StopExtensionAbility
2395 * EnvConditions: NA
2396 * CaseDescription: Verify the normal process of StopExtensionAbility
2397 */
2398 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbilityByUIContentSession_002, TestSize.Level1)
2399 {
2400 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2401 .Times(1)
2402 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2403 Want want;
2404 sptr<IRemoteObject> callerToken = nullptr;
2405 const sptr<AAFwk::SessionInfo> sessionInfo = nullptr;
2406 auto res = proxy_->StartAbilityByUIContentSession(want, callerToken, sessionInfo);
2407 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_SESSION_ABILITY_ADD_CALLER), mock_->code_);
2408 EXPECT_EQ(res, NO_ERROR);
2409 }
2410
2411 /*
2412 * Feature: AbilityManagerService
2413 * Function: RegisterSessionHandler
2414 * SubFunction: NA
2415 * FunctionPoints: AbilityManagerService RegisterSessionHandler
2416 * EnvConditions: NA
2417 * CaseDescription: Verify the normal process of RegisterSessionHandler
2418 */
2419 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_RegisterSessionHandler_001, TestSize.Level1)
2420 {
2421 sptr<IRemoteObject> token = nullptr;
2422 auto res = proxy_->RegisterSessionHandler(token);
2423 EXPECT_EQ(res, ERR_INVALID_VALUE);
2424 }
2425
2426 /*
2427 * Feature: AbilityManagerService
2428 * Function: RegisterSessionHandler
2429 * SubFunction: NA
2430 * FunctionPoints: AbilityManagerService RegisterSessionHandler
2431 * EnvConditions: NA
2432 * CaseDescription: Verify the normal process of RegisterSessionHandler
2433 */
2434 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_RegisterSessionHandler_002, TestSize.Level1)
2435 {
2436 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2437 .Times(1)
2438 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2439 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
2440 auto res = proxy_->RegisterSessionHandler(token);
2441 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_SESSION_HANDLER), mock_->code_);
2442 EXPECT_EQ(res, NO_ERROR);
2443 }
2444
2445 /*
2446 * Feature: AbilityManagerService
2447 * Function: StartSpecifiedAbilityBySCB
2448 * SubFunction: NA
2449 * FunctionPoints: AbilityManagerService StartSpecifiedAbilityBySCB
2450 * EnvConditions: NA
2451 * CaseDescription: Verify the normal process of StartSpecifiedAbilityBySCB
2452 */
2453 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartSpecifiedAbilityBySCB_001, TestSize.Level1)
2454 {
2455 proxy_ = std::make_shared<AbilityManagerProxy>(nullptr);
2456 Want want;
2457 proxy_->StartSpecifiedAbilityBySCB(want);
2458 EXPECT_TRUE(proxy_ != nullptr);
2459 }
2460
2461 /*
2462 * Feature: AbilityManagerService
2463 * Function: StartSpecifiedAbilityBySCB
2464 * SubFunction: NA
2465 * FunctionPoints: AbilityManagerService StartSpecifiedAbilityBySCB
2466 * EnvConditions: NA
2467 * CaseDescription: Verify the normal process of StartSpecifiedAbilityBySCB
2468 */
2469 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartSpecifiedAbilityBySCB_002, TestSize.Level1)
2470 {
2471 proxy_ = std::make_shared<AbilityManagerProxy>(mock_);
2472 EXPECT_TRUE(proxy_ != nullptr);
2473 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(NO_ERROR));
2474 Want want;
2475 proxy_->StartSpecifiedAbilityBySCB(want);
2476 }
2477
2478 /*
2479 * Feature: AbilityManagerService
2480 * Function: IsAbilityControllerStart
2481 * SubFunction: NA
2482 * FunctionPoints: AbilityManagerService IsAbilityControllerStart
2483 * EnvConditions: NA
2484 * CaseDescription: Verify the normal process of IsAbilityControllerStart
2485 */
2486 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_IsAbilityControllerStart_001, TestSize.Level1)
2487 {
2488 proxy_ = std::make_shared<AbilityManagerProxy>(mock_);
2489 EXPECT_TRUE(proxy_ != nullptr);
2490 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(1).WillOnce(Return(NO_ERROR));
2491 Want want;
2492 proxy_->IsAbilityControllerStart(want);
2493 }
2494
2495 /**
2496 * @tc.name: AbilityManagerProxy_RegisterAppDebugListener_0100
2497 * @tc.desc: Test the status of RegisterAppDebugListener.
2498 * @tc.type: FUNC
2499 */
2500 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_RegisterAppDebugListener_0100, TestSize.Level1)
2501 {
2502 EXPECT_NE(proxy_, nullptr);
2503 sptr<AppExecFwk::AppDebugListenerStubMock> listener = new AppDebugListenerStubMock();
2504 auto result = proxy_->RegisterAppDebugListener(listener);
2505 EXPECT_EQ(result, NO_ERROR);
2506 }
2507
2508 /**
2509 * @tc.name: AbilityManagerProxy_RegisterAppDebugListener_0200
2510 * @tc.desc: Test the status of RegisterAppDebugListener, check nullptr listener.
2511 * @tc.type: FUNC
2512 */
2513 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_RegisterAppDebugListener_0200, TestSize.Level1)
2514 {
2515 EXPECT_NE(proxy_, nullptr);
2516 sptr<AppExecFwk::AppDebugListenerStubMock> listener = nullptr;
2517 auto result = proxy_->RegisterAppDebugListener(listener);
2518 EXPECT_EQ(result, INNER_ERR);
2519 }
2520
2521 /**
2522 * @tc.name: AbilityManagerProxy_UnregisterAppDebugListener_0100
2523 * @tc.desc: Test the status of UnregisterAppDebugListener.
2524 * @tc.type: FUNC
2525 */
2526 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_UnregisterAppDebugListener_0100, TestSize.Level1)
2527 {
2528 EXPECT_NE(proxy_, nullptr);
2529 sptr<AppExecFwk::AppDebugListenerStubMock> listener = new AppDebugListenerStubMock();
2530 auto result = proxy_->UnregisterAppDebugListener(listener);
2531 EXPECT_EQ(result, NO_ERROR);
2532 }
2533
2534 /**
2535 * @tc.name: AbilityManagerProxy_UnregisterAppDebugListener_0200
2536 * @tc.desc: Test the status of UnregisterAppDebugListener, check nullptr listener.
2537 * @tc.type: FUNC
2538 */
2539 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_UnregisterAppDebugListener_0200, TestSize.Level1)
2540 {
2541 EXPECT_NE(proxy_, nullptr);
2542 sptr<AppExecFwk::AppDebugListenerStubMock> listener = nullptr;
2543 auto result = proxy_->UnregisterAppDebugListener(listener);
2544 EXPECT_EQ(result, INNER_ERR);
2545 }
2546
2547 /**
2548 * @tc.name: AbilityManagerProxy_AttachAppDebug_0100
2549 * @tc.desc: Test the state of AttachAppDebug
2550 * @tc.type: FUNC
2551 */
2552 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_AttachAppDebug_0100, TestSize.Level1)
2553 {
2554 EXPECT_NE(proxy_, nullptr);
2555 std::string bundleName = "bundleName";
2556 auto result = proxy_->AttachAppDebug(bundleName, false);
2557 EXPECT_EQ(result, NO_ERROR);
2558 }
2559
2560 /**
2561 * @tc.name: AbilityManagerProxy_DetachAppDebug_0100
2562 * @tc.desc: Test the state of DetachAppDebug
2563 * @tc.type: FUNC
2564 */
2565 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DetachAppDebug_0100, TestSize.Level1)
2566 {
2567 EXPECT_NE(proxy_, nullptr);
2568 std::string bundleName = "bundleName";
2569 auto result = proxy_->DetachAppDebug(bundleName, false);
2570 EXPECT_EQ(result, NO_ERROR);
2571 }
2572
2573 /**
2574 * @tc.name: AbilityManagerProxy_GetForegroundUIAbilities_001
2575 * @tc.desc: Test function GetForegroundUIAbilities when normally.
2576 * @tc.type: FUNC
2577 */
2578 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetForegroundUIAbilities_001, TestSize.Level1)
2579 {
2580 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2581 .Times(1)
2582 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2583 std::vector<AppExecFwk::AbilityStateData> abilityStateDataList;
2584 auto res = proxy_->GetForegroundUIAbilities(abilityStateDataList);
2585 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_FOREGROUND_UI_ABILITIES), mock_->code_);
2586 EXPECT_EQ(res, NO_ERROR);
2587 }
2588
2589 /**
2590 * @tc.name: AbilityManagerProxyTest_RegisterAutoStartupSystemCallback_0100
2591 * @tc.desc: Test the state of RegisterAutoStartupSystemCallback
2592 * @tc.type: FUNC
2593 */
2594 HWTEST_F(AbilityManagerProxyTest, RegisterAutoStartupSystemCallback_0100, TestSize.Level1)
2595 {
2596 OHOS::sptr<IRemoteObject> callback = nullptr;
2597 auto res = proxy_->RegisterAutoStartupSystemCallback(callback);
2598 EXPECT_EQ(res, INNER_ERR);
2599 }
2600
2601 /**
2602 * @tc.name: AbilityManagerProxyTest_RegisterAutoStartupSystemCallback_0200
2603 * @tc.desc: Test the state of RegisterAutoStartupSystemCallback
2604 * @tc.type: FUNC
2605 */
2606 HWTEST_F(AbilityManagerProxyTest, RegisterAutoStartupSystemCallback_0200, TestSize.Level1)
2607 {
2608 OHOS::sptr<IRemoteObject> callback = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
2609 EXPECT_NE(callback, nullptr);
2610 auto res = proxy_->RegisterAutoStartupSystemCallback(callback);
2611 EXPECT_EQ(res, NO_ERROR);
2612 }
2613
2614 /**
2615 * @tc.name: AbilityManagerProxyTest_UnregisterAutoStartupSystemCallback_0100
2616 * @tc.desc: Test the state of UnregisterAutoStartupSystemCallback
2617 * @tc.type: FUNC
2618 */
2619 HWTEST_F(AbilityManagerProxyTest, UnregisterAutoStartupSystemCallback_0100, TestSize.Level1)
2620 {
2621 OHOS::sptr<IRemoteObject> callback = nullptr;
2622 auto res = proxy_->UnregisterAutoStartupSystemCallback(callback);
2623 EXPECT_EQ(res, INNER_ERR);
2624 }
2625
2626 /**
2627 * @tc.name: AbilityManagerProxyTest_UnregisterAutoStartupSystemCallback_0200
2628 * @tc.desc: Test the state of UnregisterAutoStartupSystemCallback
2629 * @tc.type: FUNC
2630 */
2631 HWTEST_F(AbilityManagerProxyTest, UnregisterAutoStartupSystemCallback_0200, TestSize.Level1)
2632 {
2633 OHOS::sptr<IRemoteObject> callback = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
2634 EXPECT_NE(callback, nullptr);
2635 auto res = proxy_->UnregisterAutoStartupSystemCallback(callback);
2636 EXPECT_EQ(res, NO_ERROR);
2637 }
2638
2639 /**
2640 * @tc.name: AbilityManagerProxyTest_SetApplicationAutoStartup_0100
2641 * @tc.desc: Test the state of SetApplicationAutoStartup
2642 * @tc.type: FUNC
2643 */
2644 HWTEST_F(AbilityManagerProxyTest, SetApplicationAutoStartup_0100, TestSize.Level1)
2645 {
2646 AutoStartupInfo info;
2647 auto res = proxy_->SetApplicationAutoStartup(info);
2648 EXPECT_EQ(res, NO_ERROR);
2649 }
2650
2651 /**
2652 * @tc.name: AbilityManagerProxyTest_CancelApplicationAutoStartup_0100
2653 * @tc.desc: Test the state of CancelApplicationAutoStartup
2654 * @tc.type: FUNC
2655 */
2656 HWTEST_F(AbilityManagerProxyTest, CancelApplicationAutoStartup_0100, TestSize.Level1)
2657 {
2658 AutoStartupInfo info;
2659 auto res = proxy_->CancelApplicationAutoStartup(info);
2660 EXPECT_EQ(res, NO_ERROR);
2661 }
2662
2663 /**
2664 * @tc.name: AbilityManagerProxyTest_QueryAllAutoStartupApplications_0100
2665 * @tc.desc: Test the state of QueryAllAutoStartupApplications
2666 * @tc.type: FUNC
2667 */
2668 HWTEST_F(AbilityManagerProxyTest, QueryAllAutoStartupApplications_0100, TestSize.Level1)
2669 {
2670 std::vector<AutoStartupInfo> infoList;
2671 auto res = proxy_->QueryAllAutoStartupApplications(infoList);
2672 EXPECT_EQ(res, ERR_OK);
2673 }
2674
2675 /**
2676 * @tc.name: AbilityManagerProxy_SetResidentProcessEnable_0100
2677 * @tc.desc: RestartApp
2678 * @tc.type: FUNC
2679 */
2680 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_SetResidentProcessEnable_0100, TestSize.Level1)
2681 {
2682 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2683 .Times(1)
2684 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2685
2686 std::string bundleName = "ability.manager.proxy.test";
2687 bool enable = true;
2688 proxy_->SetResidentProcessEnabled(bundleName, enable);
2689 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_RESIDENT_PROCESS_ENABLE), mock_->code_);
2690 }
2691
2692 /**
2693 * @tc.name: AbilityManagerProxy_GetUIExtensionRootHostInfo_0100
2694 * @tc.desc: GetUIExtensionRootHostInfo
2695 * @tc.type: FUNC
2696 * @tc.require: issueI92G6Z
2697 */
2698 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetUIExtensionRootHostInfo_0100, TestSize.Level1)
2699 {
2700 TAG_LOGI(AAFwkTag::TEST, "begin");
2701
2702 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2703 .Times(1)
2704 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2705
2706 auto token = sptr<MockAbilityToken>::MakeSptr();
2707 UIExtensionHostInfo hostInfo;
2708 proxy_->GetUIExtensionRootHostInfo(token, hostInfo, USER_ID);
2709 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_UI_EXTENSION_ROOT_HOST_INFO), mock_->code_);
2710
2711 TAG_LOGI(AAFwkTag::TEST, "end");
2712 }
2713
2714 /**
2715 * @tc.name: AbilityManagerProxy_RestartApp_0100
2716 * @tc.desc: RestartApp
2717 * @tc.type: FUNC
2718 */
2719 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_RestartApp_0100, TestSize.Level1)
2720 {
2721 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2722 .Times(1)
2723 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2724
2725 AAFwk::Want want;
2726 proxy_->RestartApp(want);
2727 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::RESTART_APP), mock_->code_);
2728 }
2729
2730 /**
2731 * @tc.name: AbilityManagerProxy_ChangeAbilityVisibility_0100
2732 * @tc.desc: ChangeAbilityVisibility
2733 * @tc.type: FUNC
2734 */
2735 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ChangeAbilityVisibility_0100, TestSize.Level1)
2736 {
2737 TAG_LOGI(AAFwkTag::TEST, "begin");
2738
2739 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2740 .Times(1)
2741 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2742
2743 auto token = sptr<MockAbilityToken>::MakeSptr();
2744 proxy_->ChangeAbilityVisibility(token, true);
2745 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CHANGE_ABILITY_VISIBILITY), mock_->code_);
2746
2747 TAG_LOGI(AAFwkTag::TEST, "end");
2748 }
2749
2750 /**
2751 * @tc.name: AbilityManagerProxy_ChangeUIAbilityVisibilityBySCB_0100
2752 * @tc.desc: ChangeUIAbilityVisibilityBySCB
2753 * @tc.type: FUNC
2754 */
2755 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ChangeUIAbilityVisibilityBySCB_0100, TestSize.Level1)
2756 {
2757 TAG_LOGI(AAFwkTag::TEST, "begin");
2758
2759 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2760 .Times(1)
2761 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2762
2763 sptr<SessionInfo> session = new (std::nothrow) SessionInfo();
2764 proxy_->ChangeUIAbilityVisibilityBySCB(session, true);
2765 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::CHANGE_UI_ABILITY_VISIBILITY_BY_SCB), mock_->code_);
2766
2767 TAG_LOGI(AAFwkTag::TEST, "end");
2768 }
2769
2770 /*
2771 * Feature: AbilityManagerService
2772 * Function: TerminateMission
2773 * SubFunction: NA
2774 * FunctionPoints: AbilityManagerService TerminateMission
2775 * EnvConditions: NA
2776 * CaseDescription: Verify the normal process of TerminateMission
2777 */
2778 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_TerminateMission_001, TestSize.Level1)
2779 {
2780 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
2781 .Times(1)
2782 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
2783 int32_t missionId = 1;
2784 auto res = proxy_->TerminateMission(missionId);
2785 EXPECT_EQ(static_cast<uint32_t>(AbilityManagerInterfaceCode::TERMINATE_MISSION), mock_->code_);
2786 EXPECT_EQ(res, NO_ERROR);
2787 }
2788 } // namespace AAFwk
2789 } // namespace OHOS
2790