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