1 /*
2 * Copyright (c) 2021-2022 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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::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(IAbilityManager::DUMP_STATE, mock_->code_);
462 }
463
464 /*
465 * Feature: AbilityManagerService
466 * Function: TerminateAbilityResult
467 * SubFunction: NA
468 * FunctionPoints: AbilityManagerService TerminateAbilityResult
469 * EnvConditions: NA
470 * CaseDescription: Verify the normal conditions of terminateAbilityResult
471 */
472 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_0018, TestSize.Level1)
473 {
474 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
475 .Times(1)
476 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
477 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
478 auto res = proxy_->TerminateAbilityResult(token, 1);
479
480 EXPECT_EQ(IAbilityManager::TERMINATE_ABILITY_RESULT, mock_->code_);
481 EXPECT_EQ(res, NO_ERROR);
482 }
483
484 /*
485 * Feature: AbilityManagerService
486 * Function: TerminateAbilityResult
487 * SubFunction: NA
488 * FunctionPoints: AbilityManagerService TerminateAbilityResult
489 * EnvConditions: NA
490 * CaseDescription: Verify the abnormal conditions of terminateAbilityResult
491 */
492 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_019, TestSize.Level1)
493 {
494 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
495 .Times(1)
496 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
497 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
498 auto res = proxy_->TerminateAbilityResult(token, 1);
499
500 EXPECT_EQ(IAbilityManager::TERMINATE_ABILITY_RESULT, mock_->code_);
501 EXPECT_NE(res, NO_ERROR);
502 }
503
504 /*
505 * Feature: AbilityManagerService
506 * Function: ScheduleCommandAbilityDone
507 * SubFunction: NA
508 * FunctionPoints: AbilityManagerService ScheduleCommandAbilityDone
509 * EnvConditions: NA
510 * CaseDescription: Verify the abnormal conditions of ScheduleCommandAbilityDone
511 */
512 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_026, TestSize.Level1)
513 {
514 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
515 .Times(1)
516 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
517 sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
518 auto res = proxy_->ScheduleCommandAbilityDone(token);
519
520 EXPECT_EQ(IAbilityManager::COMMAND_ABILITY_DONE, mock_->code_);
521 EXPECT_NE(res, NO_ERROR);
522 }
523
524 /*
525 * Feature: AbilityManagerService
526 * Function: StopServiceAbility
527 * SubFunction: NA
528 * FunctionPoints: AbilityManagerService StopServiceAbility
529 * EnvConditions: NA
530 * CaseDescription: Verify the normal process of StopServiceAbility
531 */
532 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_027, TestSize.Level1)
533 {
534 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
535 .Times(1)
536 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
537 const Want want;
538 auto res = proxy_->StopServiceAbility(want);
539
540 EXPECT_EQ(IAbilityManager::STOP_SERVICE_ABILITY, mock_->code_);
541 EXPECT_EQ(res, NO_ERROR);
542 }
543
544 /**
545 * @tc.name: AbilityManagerProxy_028
546 * @tc.desc: test StartContinuation send request succeeded
547 * @tc.type: FUNC
548 * @tc.require: AR000GI8IL
549 */
550 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_028, TestSize.Level0)
551 {
552 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
553 .Times(1)
554 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
555 Want want;
556 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
557 int res = proxy_->StartContinuation(want, abilityToken, 0);
558 EXPECT_EQ(res, NO_ERROR);
559 EXPECT_EQ(IAbilityManager::START_CONTINUATION, mock_->code_);
560 }
561
562 /**
563 * @tc.name: AbilityManagerProxy_029
564 * @tc.desc: test StartContinuation send request failed
565 * @tc.type: FUNC
566 * @tc.require: AR000GI8IL
567 */
568 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_029, TestSize.Level0)
569 {
570 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
571 .Times(1)
572 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
573 const Want want;
574 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
575 int res = proxy_->StartContinuation(want, abilityToken, 0);
576
577 EXPECT_EQ(IAbilityManager::START_CONTINUATION, mock_->code_);
578 EXPECT_NE(res, NO_ERROR);
579 }
580
581 /**
582 * @tc.name: AbilityManagerProxy_030
583 * @tc.desc: test NotifyContinuationResult send request succeeded
584 * @tc.type: FUNC
585 * @tc.require: AR000GI8IH
586 */
587 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_030, TestSize.Level0)
588 {
589 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
590 .Times(1)
591 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
592 int32_t result = 0;
593 int res = proxy_->NotifyContinuationResult(0, result);
594 EXPECT_EQ(res, NO_ERROR);
595 EXPECT_EQ(IAbilityManager::NOTIFY_CONTINUATION_RESULT, mock_->code_);
596 }
597
598 /**
599 * @tc.name: AbilityManagerProxy_031
600 * @tc.desc: test NotifyContinuationResult send request failed
601 * @tc.type: FUNC
602 * @tc.require: AR000GI8IH
603 */
604 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_031, TestSize.Level0)
605 {
606 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
607 .Times(1)
608 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeErrorSendRequest));
609 int32_t result = 0;
610 int res = proxy_->NotifyContinuationResult(0, result);
611
612 EXPECT_EQ(IAbilityManager::NOTIFY_CONTINUATION_RESULT, mock_->code_);
613 EXPECT_NE(res, NO_ERROR);
614 }
615
616 /*
617 * Feature: AbilityManagerService
618 * Function: AcquireDataAbility
619 * SubFunction: NA
620 * FunctionPoints: AbilityManagerService AcquireDataAbility
621 * EnvConditions: NA
622 * CaseDescription: Verify the function AcquireDataAbility normal flow.
623 */
624 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_AcquireDataAbility_001, TestSize.Level1)
625 {
626 OHOS::Uri dataAbilityUri("dataability:///data.bundle.DataAbility");
627 AbilityRequest abilityRequest;
628 abilityRequest.appInfo.bundleName = "data.client.bundle";
629 abilityRequest.abilityInfo.name = "ClientAbility";
630 abilityRequest.abilityInfo.type = AbilityType::DATA;
631 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
632
633 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
634 EXPECT_EQ(proxy_->AcquireDataAbility(dataAbilityUri, true, abilityRecord->GetToken()), nullptr);
635 }
636
637 /*
638 * Feature: AbilityManagerService
639 * Function: AcquireDataAbility
640 * SubFunction: NA
641 * FunctionPoints: AbilityManagerService AcquireDataAbility
642 * EnvConditions: NA
643 * CaseDescription: Verify the function AcquireDataAbility callerToken is nullptr.
644 */
645 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_AcquireDataAbility_002, TestSize.Level1)
646 {
647 OHOS::Uri dataAbilityUri("dataability:///data.bundle.DataAbility");
648
649 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(0);
650 EXPECT_EQ(proxy_->AcquireDataAbility(dataAbilityUri, true, nullptr), nullptr);
651 }
652
653 /*
654 * Feature: AbilityManagerService
655 * Function: AcquireDataAbility
656 * SubFunction: NA
657 * FunctionPoints: AbilityManagerService AcquireDataAbility
658 * EnvConditions: NA
659 * CaseDescription: Verify the function AcquireDataAbility SendRequest return error.
660 */
661 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_AcquireDataAbility_003, TestSize.Level1)
662 {
663 OHOS::Uri dataAbilityUri("dataability:///data.bundle.DataAbility");
664 AbilityRequest abilityRequest;
665 abilityRequest.appInfo.bundleName = "data.client.bundle";
666 abilityRequest.abilityInfo.name = "ClientAbility";
667 abilityRequest.abilityInfo.type = AbilityType::DATA;
668 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
669
670 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(TRANSACTION_ERR));
671 EXPECT_EQ(proxy_->AcquireDataAbility(dataAbilityUri, true, abilityRecord->GetToken()), nullptr);
672 }
673
674 /*
675 * Feature: AbilityManagerService
676 * Function: ReleaseDataAbility
677 * SubFunction: NA
678 * FunctionPoints: AbilityManagerService ReleaseDataAbility
679 * EnvConditions: NA
680 * CaseDescription: Verify the function ReleaseDataAbility normal flow.
681 */
682 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseDataAbility_001, TestSize.Level1)
683 {
684 OHOS::sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
685 AbilityRequest abilityRequest;
686 abilityRequest.appInfo.bundleName = "data.client.bundle";
687 abilityRequest.abilityInfo.name = "ClientAbility";
688 abilityRequest.abilityInfo.type = AbilityType::DATA;
689 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
690
691 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(NO_ERROR));
692 EXPECT_EQ(proxy_->ReleaseDataAbility(scheduler, abilityRecord->GetToken()), 0);
693 }
694
695 /*
696 * Feature: AbilityManagerService
697 * Function: ReleaseDataAbility
698 * SubFunction: NA
699 * FunctionPoints: AbilityManagerService ReleaseDataAbility
700 * EnvConditions: NA
701 * CaseDescription: Verify the function ReleaseDataAbility dataAbilityScheduler is nullptr.
702 */
703 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseDataAbility_002, TestSize.Level1)
704 {
705 AbilityRequest abilityRequest;
706 abilityRequest.appInfo.bundleName = "data.client.bundle";
707 abilityRequest.abilityInfo.name = "ClientAbility";
708 abilityRequest.abilityInfo.type = AbilityType::DATA;
709 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
710
711 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(0);
712 EXPECT_EQ(proxy_->ReleaseDataAbility(nullptr, abilityRecord->GetToken()), ERR_INVALID_VALUE);
713 }
714
715 /*
716 * Feature: AbilityManagerService
717 * Function: ReleaseDataAbility
718 * SubFunction: NA
719 * FunctionPoints: AbilityManagerService ReleaseDataAbility
720 * EnvConditions: NA
721 * CaseDescription: Verify the function ReleaseDataAbility callerToken is nullptr.
722 */
723 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseDataAbility_003, TestSize.Level1)
724 {
725 OHOS::sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
726
727 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).Times(0);
728 EXPECT_EQ(proxy_->ReleaseDataAbility(scheduler, nullptr), ERR_INVALID_VALUE);
729 }
730
731 /*
732 * Feature: AbilityManagerService
733 * Function: ReleaseDataAbility
734 * SubFunction: NA
735 * FunctionPoints: AbilityManagerService ReleaseDataAbility
736 * EnvConditions: NA
737 * CaseDescription: Verify the function ReleaseDataAbility SendRequest error.
738 */
739 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseDataAbility_004, TestSize.Level1)
740 {
741 OHOS::sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
742 AbilityRequest abilityRequest;
743 abilityRequest.appInfo.bundleName = "data.client.bundle";
744 abilityRequest.abilityInfo.name = "ClientAbility";
745 abilityRequest.abilityInfo.type = AbilityType::DATA;
746 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
747
748 EXPECT_CALL(*mock_, SendRequest(_, _, _, _)).WillOnce(Return(TRANSACTION_ERR));
749 EXPECT_EQ(proxy_->ReleaseDataAbility(scheduler, abilityRecord->GetToken()), TRANSACTION_ERR);
750 }
751
752 /*
753 * Feature: AbilityManagerService
754 * Function: StartAbilityByCall
755 * SubFunction: NA
756 * FunctionPoints: AbilityManagerService StartAbilityByCall
757 * EnvConditions: NA
758 * CaseDescription: Verify the function StartAbilityByCall connect is nullptr.
759 */
760 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbilityByCall_001, TestSize.Level1)
761 {
762 Want want;
763 sptr<IRemoteObject> callerToken = nullptr;
764 sptr<IAbilityConnection> connect = nullptr;
765 EXPECT_EQ(proxy_->StartAbilityByCall(want, connect, callerToken), ERR_INVALID_VALUE);
766 }
767
768 /*
769 * Feature: AbilityManagerService
770 * Function: StartAbilityByCall
771 * SubFunction: NA
772 * FunctionPoints: AbilityManagerService StartAbilityByCall
773 * EnvConditions: NA
774 * CaseDescription: Verify the function StartAbilityByCall is normal flow.
775 */
776 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbilityByCall_002, TestSize.Level1)
777 {
778 Want want;
779 sptr<IRemoteObject> callerToken = nullptr;
780 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
781 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
782 .Times(1)
783 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
784 EXPECT_EQ(proxy_->StartAbilityByCall(want, connect, callerToken), ERR_OK);
785 EXPECT_EQ(IAbilityManager::START_CALL_ABILITY, mock_->code_);
786 }
787
788 /*
789 * Feature: AbilityManagerService
790 * Function: ReleaseCall
791 * SubFunction: NA
792 * FunctionPoints: AbilityManagerService ReleaseCall
793 * EnvConditions: NA
794 * CaseDescription: Verify the function ReleaseCall connect is nullptr.
795 */
796 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseCall_001, TestSize.Level1)
797 {
798 AppExecFwk::ElementName element;
799 sptr<IAbilityConnection> connect = nullptr;
800 EXPECT_EQ(proxy_->ReleaseCall(connect, element), ERR_INVALID_VALUE);
801 }
802
803 /*
804 * Feature: AbilityManagerService
805 * Function: ReleaseCall
806 * SubFunction: NA
807 * FunctionPoints: AbilityManagerService ReleaseCall
808 * EnvConditions: NA
809 * CaseDescription: Verify the function ReleaseCall is normal flow.
810 */
811 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ReleaseCall_002, TestSize.Level1)
812 {
813 AppExecFwk::ElementName element;
814 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
815 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
816 .Times(1)
817 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
818 EXPECT_EQ(proxy_->ReleaseCall(connect, element), ERR_OK);
819 EXPECT_EQ(IAbilityManager::RELEASE_CALL_ABILITY, mock_->code_);
820 }
821
822 /*
823 * Feature: AbilityManagerService
824 * Function: GetTopAbility
825 * SubFunction: NA
826 * FunctionPoints: AbilityManagerService GetTopAbility
827 * EnvConditions: NA
828 * CaseDescription: Verify the function GetTopAbility is normal flow.
829 */
830 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetTopAbility_001, TestSize.Level1)
831 {
832 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
833 .Times(1)
834 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
835 proxy_->GetTopAbility();
836 EXPECT_EQ(IAbilityManager::GET_TOP_ABILITY, mock_->code_);
837 }
838
839 /*
840 * Feature: AbilityManagerService
841 * Function: GetTopAbility
842 * SubFunction: NA
843 * FunctionPoints: AbilityManagerService GetTopAbility
844 * EnvConditions: NA
845 * CaseDescription: Verify the function GetTopAbility is normal flow.
846 */
847 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetTopAbility_002, TestSize.Level1)
848 {
849 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
850 .Times(1)
851 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
852 sptr<IRemoteObject> token = nullptr;
853 proxy_->GetTopAbility(token);
854 EXPECT_EQ(IAbilityManager::GET_TOP_ABILITY_TOKEN, mock_->code_);
855 }
856
857 /*
858 * Feature: AbilityManagerService
859 * Function: StartExtensionAbility
860 * SubFunction: NA
861 * FunctionPoints: AbilityManagerService StartExtensionAbility
862 * EnvConditions: NA
863 * CaseDescription: Verify the normal process of StartExtensionAbility
864 */
865 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartExtensionAbility_001, TestSize.Level1)
866 {
867 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
868 .Times(1)
869 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
870 Want want;
871 sptr<IRemoteObject> callerToken = nullptr;
872 auto res = proxy_->StartExtensionAbility(want, callerToken);
873 EXPECT_EQ(IAbilityManager::START_EXTENSION_ABILITY, mock_->code_);
874 EXPECT_EQ(res, NO_ERROR);
875 }
876
877 /*
878 * Feature: AbilityManagerService
879 * Function: StopExtensionAbility
880 * SubFunction: NA
881 * FunctionPoints: AbilityManagerService StopExtensionAbility
882 * EnvConditions: NA
883 * CaseDescription: Verify the normal process of StopExtensionAbility
884 */
885 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StopExtensionAbility_001, TestSize.Level1)
886 {
887 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
888 .Times(1)
889 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
890 Want want;
891 sptr<IRemoteObject> callerToken = nullptr;
892 auto res = proxy_->StopExtensionAbility(want, callerToken);
893 EXPECT_EQ(IAbilityManager::STOP_EXTENSION_ABILITY, mock_->code_);
894 EXPECT_EQ(res, NO_ERROR);
895 }
896
897 /*
898 * Feature: AbilityManagerService
899 * Function: TerminateAbilityByCaller
900 * SubFunction: NA
901 * FunctionPoints: AbilityManagerService TerminateAbilityByCaller
902 * EnvConditions: NA
903 * CaseDescription: Verify the normal process of TerminateAbilityByCaller
904 */
905 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_TerminateAbilityByCaller_001, TestSize.Level1)
906 {
907 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
908 .Times(1)
909 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
910 sptr<IRemoteObject> callerToken = nullptr;
911 auto res = proxy_->TerminateAbilityByCaller(callerToken, -1);
912 EXPECT_EQ(IAbilityManager::TERMINATE_ABILITY_BY_CALLER, mock_->code_);
913 EXPECT_EQ(res, NO_ERROR);
914 }
915
916 /*
917 * Feature: AbilityManagerService
918 * Function: MinimizeAbility
919 * SubFunction: NA
920 * FunctionPoints: AbilityManagerService MinimizeAbility
921 * EnvConditions: NA
922 * CaseDescription: Verify the normal process of MinimizeAbility
923 */
924 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_MinimizeAbility_001, TestSize.Level1)
925 {
926 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
927 .Times(1)
928 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
929 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
930 auto res = proxy_->MinimizeAbility(token);
931 EXPECT_EQ(IAbilityManager::MINIMIZE_ABILITY, mock_->code_);
932 EXPECT_EQ(res, NO_ERROR);
933 }
934
935 /*
936 * Feature: AbilityManagerService
937 * Function: GetMissionSnapshot
938 * SubFunction: NA
939 * FunctionPoints: AbilityManagerService GetMissionSnapshot
940 * EnvConditions: NA
941 * CaseDescription: Verify the normal process of GetMissionSnapshot
942 */
943 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetMissionSnapshot_001, TestSize.Level1)
944 {
945 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
946 .Times(1)
947 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
948 std::string deviceId = "";
949 int32_t missionId = 1;
950 MissionSnapshot snapshot;
951 bool isLowResolution = true;
952 proxy_->GetMissionSnapshot(deviceId, missionId, snapshot, isLowResolution);
953 EXPECT_EQ(IAbilityManager::GET_MISSION_SNAPSHOT_INFO, mock_->code_);
954 }
955
956 /*
957 * Feature: AbilityManagerService
958 * Function: UpdateMissionSnapShot
959 * SubFunction: NA
960 * FunctionPoints: AbilityManagerService UpdateMissionSnapShot
961 * EnvConditions: NA
962 * CaseDescription: Verify the normal process of UpdateMissionSnapShot
963 */
964 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_UpdateMissionSnapShot_001, TestSize.Level1)
965 {
966 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
967 .Times(1)
968 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
969 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
970 proxy_->UpdateMissionSnapShot(token);
971 EXPECT_EQ(IAbilityManager::UPDATE_MISSION_SNAPSHOT, mock_->code_);
972 }
973
974 /*
975 * Feature: AbilityManagerService
976 * Function: EnableRecoverAbility
977 * SubFunction: NA
978 * FunctionPoints: AbilityManagerService EnableRecoverAbility
979 * EnvConditions: NA
980 * CaseDescription: Verify the normal process of EnableRecoverAbility
981 */
982 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_EnableRecoverAbility_001, TestSize.Level1)
983 {
984 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
985 .Times(1)
986 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
987 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
988 proxy_->EnableRecoverAbility(token);
989 EXPECT_EQ(IAbilityManager::ABILITY_RECOVERY_ENABLE, mock_->code_);
990 }
991
992 /*
993 * Feature: AbilityManagerService
994 * Function: ScheduleRecoverAbility
995 * SubFunction: NA
996 * FunctionPoints: AbilityManagerService ScheduleRecoverAbility
997 * EnvConditions: NA
998 * CaseDescription: Verify the normal process of ScheduleRecoverAbility
999 */
1000 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ScheduleRecoverAbility_001, TestSize.Level1)
1001 {
1002 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1003 .Times(1)
1004 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1005 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1006 int32_t reason = 0;
1007 proxy_->ScheduleRecoverAbility(token, reason);
1008 EXPECT_EQ(IAbilityManager::ABILITY_RECOVERY, mock_->code_);
1009 }
1010
1011 /*
1012 * Feature: AbilityManagerService
1013 * Function: KillProcess
1014 * SubFunction: NA
1015 * FunctionPoints: AbilityManagerService KillProcess
1016 * EnvConditions: NA
1017 * CaseDescription: Verify the normal process of KillProcess
1018 */
1019 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_KillProcess_001, TestSize.Level1)
1020 {
1021 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1022 .Times(1)
1023 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1024 std::string bundleName = "";
1025 auto res = proxy_->KillProcess(bundleName);
1026 EXPECT_EQ(IAbilityManager::KILL_PROCESS, mock_->code_);
1027 EXPECT_EQ(res, NO_ERROR);
1028 }
1029
1030 #ifdef ABILITY_COMMAND_FOR_TEST
1031 /*
1032 * Feature: AbilityManagerService
1033 * Function: ForceTimeoutForTest
1034 * SubFunction: NA
1035 * FunctionPoints: AbilityManagerService ForceTimeoutForTest
1036 * EnvConditions: NA
1037 * CaseDescription: Verify the normal process of ForceTimeoutForTest
1038 */
1039 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ForceTimeoutForTest_001, TestSize.Level1)
1040 {
1041 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1042 .Times(1)
1043 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1044 std::string abilityName = "";
1045 std::string state = "";
1046 auto res = proxy_->ForceTimeoutForTest(abilityName, state);
1047 EXPECT_EQ(IAbilityManager::FORCE_TIMEOUT, mock_->code_);
1048 EXPECT_EQ(res, NO_ERROR);
1049 }
1050 #endif
1051
1052 /*
1053 * Feature: AbilityManagerService
1054 * Function: ClearUpApplicationData
1055 * SubFunction: NA
1056 * FunctionPoints: AbilityManagerService ClearUpApplicationData
1057 * EnvConditions: NA
1058 * CaseDescription: Verify the normal process of ClearUpApplicationData
1059 */
1060 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ClearUpApplicationData_001, TestSize.Level1)
1061 {
1062 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1063 .Times(1)
1064 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1065 std::string bundleName = "";
1066 auto res = proxy_->ClearUpApplicationData(bundleName);
1067 EXPECT_EQ(IAbilityManager::CLEAR_UP_APPLICATION_DATA, mock_->code_);
1068 EXPECT_EQ(res, NO_ERROR);
1069 }
1070
1071 /*
1072 * Feature: AbilityManagerService
1073 * Function: UninstallApp
1074 * SubFunction: NA
1075 * FunctionPoints: AbilityManagerService UninstallApp
1076 * EnvConditions: NA
1077 * CaseDescription: Verify the normal process of UninstallApp
1078 */
1079 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_UninstallApp_001, TestSize.Level1)
1080 {
1081 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1082 .Times(1)
1083 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1084 std::string bundleName = "";
1085 int32_t uid = 1;
1086 auto res = proxy_->UninstallApp(bundleName, uid);
1087 EXPECT_EQ(IAbilityManager::UNINSTALL_APP, mock_->code_);
1088 EXPECT_EQ(res, NO_ERROR);
1089 }
1090
1091 /*
1092 * Feature: AbilityManagerService
1093 * Function: GetWantSender
1094 * SubFunction: NA
1095 * FunctionPoints: AbilityManagerService GetWantSender
1096 * EnvConditions: NA
1097 * CaseDescription: Verify the normal process of GetWantSender
1098 */
1099 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetWantSender_001, TestSize.Level1)
1100 {
1101 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1102 .Times(1)
1103 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1104 WantSenderInfo wantSenderInfo;
1105 sptr<IRemoteObject> callerToken = nullptr;
1106 auto res = proxy_->GetWantSender(wantSenderInfo, callerToken);
1107 EXPECT_EQ(IAbilityManager::GET_PENDING_WANT_SENDER, mock_->code_);
1108 EXPECT_TRUE(res == nullptr);
1109 }
1110
1111 /*
1112 * Feature: AbilityManagerService
1113 * Function: SendWantSender
1114 * SubFunction: NA
1115 * FunctionPoints: AbilityManagerService SendWantSender
1116 * EnvConditions: NA
1117 * CaseDescription: Verify the normal process of SendWantSender
1118 */
1119 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_SendWantSender_001, TestSize.Level1)
1120 {
1121 sptr<IWantSender> target = nullptr;
1122 SenderInfo senderInfo;
1123 auto res = proxy_->SendWantSender(target, senderInfo);
1124 EXPECT_EQ(res, INNER_ERR);
1125 }
1126
1127 /*
1128 * Feature: AbilityManagerService
1129 * Function: GetPendingWantUid
1130 * SubFunction: NA
1131 * FunctionPoints: AbilityManagerService GetPendingWantUid
1132 * EnvConditions: NA
1133 * CaseDescription: Verify the normal process of GetPendingWantUid
1134 */
1135 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetPendingWantUid_001, TestSize.Level1)
1136 {
1137 sptr<IWantSender> target = nullptr;
1138 auto res = proxy_->GetPendingWantUid(target);
1139 EXPECT_EQ(res, ERR_INVALID_VALUE);
1140 }
1141
1142 /*
1143 * Feature: AbilityManagerService
1144 * Function: GetPendingWantUserId
1145 * SubFunction: NA
1146 * FunctionPoints: AbilityManagerService GetPendingWantUserId
1147 * EnvConditions: NA
1148 * CaseDescription: Verify the normal process of GetPendingWantUserId
1149 */
1150 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetPendingWantUserId_001, TestSize.Level1)
1151 {
1152 sptr<IWantSender> target = nullptr;
1153 auto res = proxy_->GetPendingWantUserId(target);
1154 EXPECT_EQ(res, ERR_INVALID_VALUE);
1155 }
1156
1157 /*
1158 * Feature: AbilityManagerService
1159 * Function: GetPendingWantBundleName
1160 * SubFunction: NA
1161 * FunctionPoints: AbilityManagerService GetPendingWantBundleName
1162 * EnvConditions: NA
1163 * CaseDescription: Verify the normal process of GetPendingWantBundleName
1164 */
1165 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetPendingWantBundleName_001, TestSize.Level1)
1166 {
1167 sptr<IWantSender> target = nullptr;
1168 auto res = proxy_->GetPendingWantBundleName(target);
1169 EXPECT_EQ(res, "");
1170 }
1171
1172 /*
1173 * Feature: AbilityManagerService
1174 * Function: GetPendingWantCode
1175 * SubFunction: NA
1176 * FunctionPoints: AbilityManagerService GetPendingWantCode
1177 * EnvConditions: NA
1178 * CaseDescription: Verify the normal process of GetPendingWantCode
1179 */
1180 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetPendingWantCode_001, TestSize.Level1)
1181 {
1182 sptr<IWantSender> target = nullptr;
1183 auto res = proxy_->GetPendingWantCode(target);
1184 EXPECT_EQ(res, ERR_INVALID_VALUE);
1185 }
1186
1187 /*
1188 * Feature: AbilityManagerService
1189 * Function: GetPendingWantType
1190 * SubFunction: NA
1191 * FunctionPoints: AbilityManagerService GetPendingWantType
1192 * EnvConditions: NA
1193 * CaseDescription: Verify the normal process of GetPendingWantType
1194 */
1195 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetPendingWantType_001, TestSize.Level1)
1196 {
1197 sptr<IWantSender> target = nullptr;
1198 auto res = proxy_->GetPendingWantType(target);
1199 EXPECT_EQ(res, ERR_INVALID_VALUE);
1200 }
1201
1202 /*
1203 * Feature: AbilityManagerService
1204 * Function: GetPendingRequestWant
1205 * SubFunction: NA
1206 * FunctionPoints: AbilityManagerService GetPendingRequestWant
1207 * EnvConditions: NA
1208 * CaseDescription: Verify the normal process of GetPendingRequestWant
1209 */
1210 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetPendingRequestWant_001, TestSize.Level1)
1211 {
1212 sptr<IWantSender> target = nullptr;
1213 auto want = std::make_shared<Want>();
1214 auto res = proxy_->GetPendingRequestWant(target, want);
1215 EXPECT_EQ(res, INNER_ERR);
1216 }
1217
1218 /*
1219 * Feature: AbilityManagerService
1220 * Function: GetWantSenderInfo
1221 * SubFunction: NA
1222 * FunctionPoints: AbilityManagerService GetWantSenderInfo
1223 * EnvConditions: NA
1224 * CaseDescription: Verify the normal process of GetWantSenderInfo
1225 */
1226 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetWantSenderInfo_001, TestSize.Level1)
1227 {
1228 sptr<IWantSender> target = nullptr;
1229 auto info = std::make_shared<WantSenderInfo>();
1230 auto res = proxy_->GetWantSenderInfo(target, info);
1231 EXPECT_EQ(res, INNER_ERR);
1232 }
1233
1234 /*
1235 * Feature: AbilityManagerService
1236 * Function: GetAppMemorySize
1237 * SubFunction: NA
1238 * FunctionPoints: AbilityManagerService GetAppMemorySize
1239 * EnvConditions: NA
1240 * CaseDescription: Verify the normal process of GetAppMemorySize
1241 */
1242 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetAppMemorySize_001, TestSize.Level1)
1243 {
1244 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1245 .Times(1)
1246 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1247 auto res = proxy_->GetAppMemorySize();
1248 EXPECT_EQ(IAbilityManager::GET_APP_MEMORY_SIZE, mock_->code_);
1249 EXPECT_EQ(res, NO_ERROR);
1250 }
1251
1252 /*
1253 * Feature: AbilityManagerService
1254 * Function: IsRamConstrainedDevice
1255 * SubFunction: NA
1256 * FunctionPoints: AbilityManagerService IsRamConstrainedDevice
1257 * EnvConditions: NA
1258 * CaseDescription: Verify the normal process of IsRamConstrainedDevice
1259 */
1260 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_IsRamConstrainedDevice_001, TestSize.Level1)
1261 {
1262 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1263 .Times(1)
1264 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1265 auto res = proxy_->IsRamConstrainedDevice();
1266 EXPECT_EQ(IAbilityManager::IS_RAM_CONSTRAINED_DEVICE, mock_->code_);
1267 EXPECT_EQ(res, NO_ERROR);
1268 }
1269
1270 /*
1271 * Feature: AbilityManagerService
1272 * Function: ContinueMission
1273 * SubFunction: NA
1274 * FunctionPoints: AbilityManagerService ContinueMission
1275 * EnvConditions: NA
1276 * CaseDescription: Verify the normal process of ContinueMission
1277 */
1278 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ContinueMission_001, TestSize.Level1)
1279 {
1280 std::string srcDeviceId = "";
1281 std::string dstDeviceId = "";
1282 int32_t missionId = 1;
1283 const sptr<IRemoteObject> &callBack = nullptr;
1284 AAFwk::WantParams wantParams;
1285 auto res = proxy_->ContinueMission(srcDeviceId, dstDeviceId, missionId, callBack, wantParams);
1286 EXPECT_EQ(res, INNER_ERR);
1287 }
1288
1289 /*
1290 * Feature: AbilityManagerService
1291 * Function: ContinueAbility
1292 * SubFunction: NA
1293 * FunctionPoints: AbilityManagerService ContinueAbility
1294 * EnvConditions: NA
1295 * CaseDescription: Verify the normal process of ContinueAbility
1296 */
1297 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_ContinueAbility_001, TestSize.Level1)
1298 {
1299 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1300 .Times(1)
1301 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1302 std::string deviceId = "";
1303 int32_t missionId = 1;
1304 uint32_t versionCode = 1;
1305 auto res = proxy_->ContinueAbility(deviceId, missionId, versionCode);
1306 EXPECT_EQ(IAbilityManager::CONTINUE_ABILITY, mock_->code_);
1307 EXPECT_EQ(res, NO_ERROR);
1308 }
1309
1310 /*
1311 * Feature: AbilityManagerService
1312 * Function: NotifyCompleteContinuation
1313 * SubFunction: NA
1314 * FunctionPoints: AbilityManagerService NotifyCompleteContinuation
1315 * EnvConditions: NA
1316 * CaseDescription: Verify the normal process of NotifyCompleteContinuation
1317 */
1318 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_NotifyCompleteContinuation_001, TestSize.Level1)
1319 {
1320 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1321 .Times(1)
1322 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1323 std::string deviceId = "";
1324 int32_t sessionId = 1;
1325 bool isSuccess = true;
1326 proxy_->NotifyCompleteContinuation(deviceId, sessionId, isSuccess);
1327 EXPECT_EQ(IAbilityManager::NOTIFY_COMPLETE_CONTINUATION, mock_->code_);
1328 }
1329
1330 /*
1331 * Feature: AbilityManagerService
1332 * Function: NotifyContinuationResult
1333 * SubFunction: NA
1334 * FunctionPoints: AbilityManagerService NotifyContinuationResult
1335 * EnvConditions: NA
1336 * CaseDescription: Verify the normal process of NotifyContinuationResult
1337 */
1338 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_NotifyContinuationResult_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 int32_t result = 1;
1345 auto res = proxy_->NotifyContinuationResult(missionId, result);
1346 EXPECT_EQ(IAbilityManager::NOTIFY_CONTINUATION_RESULT, mock_->code_);
1347 EXPECT_EQ(res, NO_ERROR);
1348 }
1349
1350 /*
1351 * Feature: AbilityManagerService
1352 * Function: LockMissionForCleanup
1353 * SubFunction: NA
1354 * FunctionPoints: AbilityManagerService LockMissionForCleanup
1355 * EnvConditions: NA
1356 * CaseDescription: Verify the normal process of LockMissionForCleanup
1357 */
1358 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_LockMissionForCleanup_001, TestSize.Level1)
1359 {
1360 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1361 .Times(1)
1362 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1363 int32_t missionId = 1;
1364 auto res = proxy_->LockMissionForCleanup(missionId);
1365 EXPECT_EQ(IAbilityManager::LOCK_MISSION_FOR_CLEANUP, mock_->code_);
1366 EXPECT_EQ(res, NO_ERROR);
1367 }
1368
1369 /*
1370 * Feature: AbilityManagerService
1371 * Function: UnlockMissionForCleanup
1372 * SubFunction: NA
1373 * FunctionPoints: AbilityManagerService UnlockMissionForCleanup
1374 * EnvConditions: NA
1375 * CaseDescription: Verify the normal process of UnlockMissionForCleanup
1376 */
1377 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_UnlockMissionForCleanup_001, TestSize.Level1)
1378 {
1379 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1380 .Times(1)
1381 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1382 int32_t missionId = 1;
1383 auto res = proxy_->UnlockMissionForCleanup(missionId);
1384 EXPECT_EQ(IAbilityManager::UNLOCK_MISSION_FOR_CLEANUP, mock_->code_);
1385 EXPECT_EQ(res, NO_ERROR);
1386 }
1387
1388 /*
1389 * Feature: AbilityManagerService
1390 * Function: RegisterMissionListener
1391 * SubFunction: NA
1392 * FunctionPoints: AbilityManagerService RegisterMissionListener
1393 * EnvConditions: NA
1394 * CaseDescription: Verify the normal process of RegisterMissionListener
1395 */
1396 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_RegisterMissionListener_001, TestSize.Level1)
1397 {
1398 sptr<IMissionListener> listener = nullptr;
1399 auto res = proxy_->RegisterMissionListener(listener);
1400 EXPECT_EQ(res, ERR_INVALID_VALUE);
1401 }
1402
1403 /*
1404 * Feature: AbilityManagerService
1405 * Function: UnRegisterMissionListener
1406 * SubFunction: NA
1407 * FunctionPoints: AbilityManagerService UnRegisterMissionListener
1408 * EnvConditions: NA
1409 * CaseDescription: Verify the normal process of UnRegisterMissionListener
1410 */
1411 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_UnRegisterMissionListener_001, TestSize.Level1)
1412 {
1413 sptr<IMissionListener> listener = nullptr;
1414 auto res = proxy_->UnRegisterMissionListener(listener);
1415 EXPECT_EQ(res, ERR_INVALID_VALUE);
1416 }
1417
1418 /*
1419 * Feature: AbilityManagerService
1420 * Function: CleanMission
1421 * SubFunction: NA
1422 * FunctionPoints: AbilityManagerService CleanMission
1423 * EnvConditions: NA
1424 * CaseDescription: Verify the normal process of CleanMission
1425 */
1426 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_CleanMission_001, TestSize.Level1)
1427 {
1428 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1429 .Times(1)
1430 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1431 int32_t missionId = 1;
1432 auto res = proxy_->CleanMission(missionId);
1433 EXPECT_EQ(IAbilityManager::CLEAN_MISSION, mock_->code_);
1434 EXPECT_EQ(res, NO_ERROR);
1435 }
1436
1437 /*
1438 * Feature: AbilityManagerService
1439 * Function: CleanAllMissions
1440 * SubFunction: NA
1441 * FunctionPoints: AbilityManagerService CleanAllMissions
1442 * EnvConditions: NA
1443 * CaseDescription: Verify the normal process of CleanAllMissions
1444 */
1445 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_CleanAllMissions_001, TestSize.Level1)
1446 {
1447 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1448 .Times(1)
1449 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1450 auto res = proxy_->CleanAllMissions();
1451 EXPECT_EQ(IAbilityManager::CLEAN_ALL_MISSIONS, mock_->code_);
1452 EXPECT_EQ(res, NO_ERROR);
1453 }
1454
1455 /*
1456 * Feature: AbilityManagerService
1457 * Function: MoveMissionToFront
1458 * SubFunction: NA
1459 * FunctionPoints: AbilityManagerService MoveMissionToFront
1460 * EnvConditions: NA
1461 * CaseDescription: Verify the normal process of MoveMissionToFront
1462 */
1463 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_MoveMissionToFront_001, TestSize.Level1)
1464 {
1465 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1466 .Times(1)
1467 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1468 int32_t missionId = 1;
1469 auto res = proxy_->MoveMissionToFront(missionId);
1470 EXPECT_EQ(IAbilityManager::MOVE_MISSION_TO_FRONT, mock_->code_);
1471 EXPECT_EQ(res, NO_ERROR);
1472 }
1473
1474 /*
1475 * Feature: AbilityManagerService
1476 * Function: StartUser
1477 * SubFunction: NA
1478 * FunctionPoints: AbilityManagerService StartUser
1479 * EnvConditions: NA
1480 * CaseDescription: Verify the normal process of StartUser
1481 */
1482 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartUser_001, TestSize.Level1)
1483 {
1484 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1485 .Times(1)
1486 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1487 int userId = 1;
1488 auto res = proxy_->StartUser(userId);
1489 EXPECT_EQ(IAbilityManager::START_USER, mock_->code_);
1490 EXPECT_EQ(res, NO_ERROR);
1491 }
1492
1493 /*
1494 * Feature: AbilityManagerService
1495 * Function: StopUser
1496 * SubFunction: NA
1497 * FunctionPoints: AbilityManagerService StopUser
1498 * EnvConditions: NA
1499 * CaseDescription: Verify the normal process of StopUser
1500 */
1501 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StopUser_001, TestSize.Level1)
1502 {
1503 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1504 .Times(1)
1505 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1506 int userId = 1;
1507 sptr<IStopUserCallback> callback = nullptr;
1508 auto res = proxy_->StopUser(userId, callback);
1509 EXPECT_EQ(IAbilityManager::STOP_USER, mock_->code_);
1510 EXPECT_EQ(res, NO_ERROR);
1511 }
1512
1513 /*
1514 * Feature: AbilityManagerService
1515 * Function: SetMissionLabel
1516 * SubFunction: NA
1517 * FunctionPoints: AbilityManagerService SetMissionLabel
1518 * EnvConditions: NA
1519 * CaseDescription: Verify the normal process of SetMissionLabel
1520 */
1521 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_SetMissionLabel_001, TestSize.Level1)
1522 {
1523 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1524 .Times(1)
1525 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1526 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1527 std::string label = "";
1528 auto res = proxy_->SetMissionLabel(token, label);
1529 EXPECT_EQ(IAbilityManager::SET_MISSION_LABEL, mock_->code_);
1530 EXPECT_EQ(res, NO_ERROR);
1531 }
1532
1533 /*
1534 * Feature: AbilityManagerService
1535 * Function: RegisterWindowManagerServiceHandler
1536 * SubFunction: NA
1537 * FunctionPoints: AbilityManagerService RegisterWindowManagerServiceHandler
1538 * EnvConditions: NA
1539 * CaseDescription: Verify the normal process of RegisterWindowManagerServiceHandler
1540 */
1541 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_RegisterWindowManagerServiceHandler_001, TestSize.Level1)
1542 {
1543 sptr<IWindowManagerServiceHandler> handler = nullptr;
1544 auto res = proxy_->RegisterWindowManagerServiceHandler(handler);
1545 EXPECT_EQ(res, INNER_ERR);
1546 }
1547
1548 /*
1549 * Feature: AbilityManagerService
1550 * Function: CompleteFirstFrameDrawing
1551 * SubFunction: NA
1552 * FunctionPoints: AbilityManagerService CompleteFirstFrameDrawing
1553 * EnvConditions: NA
1554 * CaseDescription: Verify the normal process of CompleteFirstFrameDrawing
1555 */
1556 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_CompleteFirstFrameDrawing_001, TestSize.Level1)
1557 {
1558 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1559 .Times(1)
1560 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1561 sptr<IRemoteObject> abilityToken = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1562 proxy_->CompleteFirstFrameDrawing(abilityToken);
1563 EXPECT_EQ(IAbilityManager::COMPLETEFIRSTFRAMEDRAWING, mock_->code_);
1564 }
1565
1566 /*
1567 * Feature: AbilityManagerService
1568 * Function: GetAbilityRunningInfos
1569 * SubFunction: NA
1570 * FunctionPoints: AbilityManagerService GetAbilityRunningInfos
1571 * EnvConditions: NA
1572 * CaseDescription: Verify the normal process of GetAbilityRunningInfos
1573 */
1574 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetAbilityRunningInfos_001, TestSize.Level1)
1575 {
1576 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1577 .Times(1)
1578 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1579 std::vector<AbilityRunningInfo> info;
1580 auto res = proxy_->GetAbilityRunningInfos(info);
1581 EXPECT_EQ(IAbilityManager::GET_ABILITY_RUNNING_INFO, mock_->code_);
1582 EXPECT_EQ(res, NO_ERROR);
1583 }
1584
1585 /*
1586 * Feature: AbilityManagerService
1587 * Function: GetExtensionRunningInfos
1588 * SubFunction: NA
1589 * FunctionPoints: AbilityManagerService GetExtensionRunningInfos
1590 * EnvConditions: NA
1591 * CaseDescription: Verify the normal process of GetExtensionRunningInfos
1592 */
1593 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetExtensionRunningInfos_001, TestSize.Level1)
1594 {
1595 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1596 .Times(1)
1597 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1598 int upperLimit = 0;
1599 std::vector<ExtensionRunningInfo> info;
1600 auto res = proxy_->GetExtensionRunningInfos(upperLimit, info);
1601 EXPECT_EQ(IAbilityManager::GET_EXTENSION_RUNNING_INFO, mock_->code_);
1602 EXPECT_EQ(res, NO_ERROR);
1603 }
1604
1605 /*
1606 * Feature: AbilityManagerService
1607 * Function: GetProcessRunningInfos
1608 * SubFunction: NA
1609 * FunctionPoints: AbilityManagerService GetProcessRunningInfos
1610 * EnvConditions: NA
1611 * CaseDescription: Verify the normal process of GetProcessRunningInfos
1612 */
1613 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetProcessRunningInfos_001, TestSize.Level1)
1614 {
1615 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1616 .Times(1)
1617 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1618 std::vector<AppExecFwk::RunningProcessInfo> info;
1619 auto res = proxy_->GetProcessRunningInfos(info);
1620 EXPECT_EQ(IAbilityManager::GET_PROCESS_RUNNING_INFO, mock_->code_);
1621 EXPECT_EQ(res, NO_ERROR);
1622 }
1623
1624 /*
1625 * Feature: AbilityManagerService
1626 * Function: StartSyncRemoteMissions
1627 * SubFunction: NA
1628 * FunctionPoints: AbilityManagerService StartSyncRemoteMissions
1629 * EnvConditions: NA
1630 * CaseDescription: Verify the normal process of StartSyncRemoteMissions
1631 */
1632 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartSyncRemoteMissions_001, TestSize.Level1)
1633 {
1634 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1635 .Times(1)
1636 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1637 std::string devId = "";
1638 bool fixConflict = true;
1639 int64_t tag = 0;
1640 auto res = proxy_->StartSyncRemoteMissions(devId, fixConflict, tag);
1641 EXPECT_EQ(IAbilityManager::START_SYNC_MISSIONS, mock_->code_);
1642 EXPECT_EQ(res, NO_ERROR);
1643 }
1644
1645 /*
1646 * Feature: AbilityManagerService
1647 * Function: StopSyncRemoteMissions
1648 * SubFunction: NA
1649 * FunctionPoints: AbilityManagerService StopSyncRemoteMissions
1650 * EnvConditions: NA
1651 * CaseDescription: Verify the normal process of StopSyncRemoteMissions
1652 */
1653 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StopSyncRemoteMissions_001, TestSize.Level1)
1654 {
1655 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1656 .Times(1)
1657 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1658 std::string devId = "";
1659 auto res = proxy_->StopSyncRemoteMissions(devId);
1660 EXPECT_EQ(IAbilityManager::STOP_SYNC_MISSIONS, mock_->code_);
1661 EXPECT_EQ(res, NO_ERROR);
1662 }
1663
1664 /*
1665 * Feature: AbilityManagerService
1666 * Function: SetAbilityController
1667 * SubFunction: NA
1668 * FunctionPoints: AbilityManagerService SetAbilityController
1669 * EnvConditions: NA
1670 * CaseDescription: Verify the normal process of SetAbilityController
1671 */
1672 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_SetAbilityController_001, TestSize.Level1)
1673 {
1674 sptr<AppExecFwk::IAbilityController> abilityController = nullptr;
1675 bool imAStabilityTest = true;
1676 auto res = proxy_->SetAbilityController(abilityController, imAStabilityTest);
1677 EXPECT_EQ(res, ERR_INVALID_VALUE);
1678 }
1679
1680 /*
1681 * Feature: AbilityManagerService
1682 * Function: IsRunningInStabilityTest
1683 * SubFunction: NA
1684 * FunctionPoints: AbilityManagerService IsRunningInStabilityTest
1685 * EnvConditions: NA
1686 * CaseDescription: Verify the normal process of IsRunningInStabilityTest
1687 */
1688 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_IsRunningInStabilityTest_001, TestSize.Level1)
1689 {
1690 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1691 .Times(1)
1692 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1693 auto res = proxy_->IsRunningInStabilityTest();
1694 EXPECT_EQ(IAbilityManager::IS_USER_A_STABILITY_TEST, mock_->code_);
1695 EXPECT_EQ(res, NO_ERROR);
1696 }
1697
1698 /*
1699 * Feature: AbilityManagerService
1700 * Function: StartUserTest
1701 * SubFunction: NA
1702 * FunctionPoints: AbilityManagerService StartUserTest
1703 * EnvConditions: NA
1704 * CaseDescription: Verify the normal process of StartUserTest
1705 */
1706 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartUserTest_001, TestSize.Level1)
1707 {
1708 Want want;
1709 sptr<IRemoteObject> observer = nullptr;
1710 auto res = proxy_->StartUserTest(want, observer);
1711 EXPECT_EQ(res, INNER_ERR);
1712 }
1713
1714 /*
1715 * Feature: AbilityManagerService
1716 * Function: FinishUserTest
1717 * SubFunction: NA
1718 * FunctionPoints: AbilityManagerService FinishUserTest
1719 * EnvConditions: NA
1720 * CaseDescription: Verify the normal process of FinishUserTest
1721 */
1722 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_FinishUserTest_001, TestSize.Level1)
1723 {
1724 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1725 .Times(1)
1726 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1727 std::string msg = "";
1728 int64_t resultCode = 0;
1729 std::string bundleName = "";
1730 auto res = proxy_->FinishUserTest(msg, resultCode, bundleName);
1731 EXPECT_EQ(IAbilityManager::FINISH_USER_TEST, mock_->code_);
1732 EXPECT_EQ(res, NO_ERROR);
1733 }
1734
1735 /*
1736 * Feature: AbilityManagerService
1737 * Function: DelegatorDoAbilityForeground
1738 * SubFunction: NA
1739 * FunctionPoints: AbilityManagerService DelegatorDoAbilityForeground
1740 * EnvConditions: NA
1741 * CaseDescription: Verify the normal process of DelegatorDoAbilityForeground
1742 */
1743 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DelegatorDoAbilityForeground_001, TestSize.Level1)
1744 {
1745 sptr<IRemoteObject> token = nullptr;
1746 auto res = proxy_->DelegatorDoAbilityForeground(token);
1747 EXPECT_EQ(res, ERR_INVALID_VALUE);
1748 }
1749
1750 /*
1751 * Feature: AbilityManagerService
1752 * Function: DelegatorDoAbilityBackground
1753 * SubFunction: NA
1754 * FunctionPoints: AbilityManagerService DelegatorDoAbilityBackground
1755 * EnvConditions: NA
1756 * CaseDescription: Verify the normal process of DelegatorDoAbilityBackground
1757 */
1758 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DelegatorDoAbilityBackground_001, TestSize.Level1)
1759 {
1760 sptr<IRemoteObject> token = nullptr;
1761 auto res = proxy_->DelegatorDoAbilityBackground(token);
1762 EXPECT_EQ(res, ERR_INVALID_VALUE);
1763 }
1764
1765 /*
1766 * Feature: AbilityManagerService
1767 * Function: DoAbilityForeground
1768 * SubFunction: NA
1769 * FunctionPoints: AbilityManagerService DoAbilityForeground
1770 * EnvConditions: NA
1771 * CaseDescription: Verify the normal process of DoAbilityForeground
1772 */
1773 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DoAbilityForeground_001, TestSize.Level1)
1774 {
1775 sptr<IRemoteObject> token = nullptr;
1776 uint32_t flag = 0;
1777 auto res = proxy_->DoAbilityForeground(token, flag);
1778 EXPECT_EQ(res, ERR_INVALID_VALUE);
1779 }
1780
1781 /*
1782 * Feature: AbilityManagerService
1783 * Function: DoAbilityBackground
1784 * SubFunction: NA
1785 * FunctionPoints: AbilityManagerService DoAbilityBackground
1786 * EnvConditions: NA
1787 * CaseDescription: Verify the normal process of DoAbilityBackground
1788 */
1789 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DoAbilityBackground_001, TestSize.Level1)
1790 {
1791 sptr<IRemoteObject> token = nullptr;
1792 uint32_t flag = 0;
1793 auto res = proxy_->DoAbilityBackground(token, flag);
1794 EXPECT_EQ(res, ERR_INVALID_VALUE);
1795 }
1796
1797 /*
1798 * Feature: AbilityManagerService
1799 * Function: SendANRProcessID
1800 * SubFunction: NA
1801 * FunctionPoints: AbilityManagerService SendANRProcessID
1802 * EnvConditions: NA
1803 * CaseDescription: Verify the normal process of SendANRProcessID
1804 */
1805 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_SendANRProcessID_001, TestSize.Level1)
1806 {
1807 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1808 .Times(1)
1809 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1810 int pid = 0;
1811 auto res = proxy_->SendANRProcessID(pid);
1812 EXPECT_EQ(IAbilityManager::SEND_APP_NOT_RESPONSE_PROCESS_ID, mock_->code_);
1813 EXPECT_EQ(res, NO_ERROR);
1814 }
1815
1816 /*
1817 * Feature: AbilityManagerService
1818 * Function: GetMissionIdByToken
1819 * SubFunction: NA
1820 * FunctionPoints: AbilityManagerService GetMissionIdByToken
1821 * EnvConditions: NA
1822 * CaseDescription: Verify the normal process of GetMissionIdByToken
1823 */
1824 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_GetMissionIdByToken_001, TestSize.Level1)
1825 {
1826 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1827 .Times(1)
1828 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1829 OHOS::sptr<IRemoteObject> token = sptr<IRemoteObject>(new (std::nothrow) MockAbilityToken());
1830 auto res = proxy_->GetMissionIdByToken(token);
1831 EXPECT_EQ(IAbilityManager::GET_MISSION_ID_BY_ABILITY_TOKEN, mock_->code_);
1832 EXPECT_EQ(res, NO_ERROR);
1833 }
1834
1835 #ifdef ABILITY_COMMAND_FOR_TEST
1836 /*
1837 * Feature: AbilityManagerService
1838 * Function: BlockAmsService
1839 * SubFunction: NA
1840 * FunctionPoints: AbilityManagerService BlockAmsService
1841 * EnvConditions: NA
1842 * CaseDescription: Verify the normal process of BlockAmsService
1843 */
1844 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_BlockAmsService_001, TestSize.Level1)
1845 {
1846 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1847 .Times(1)
1848 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1849 auto res = proxy_->BlockAmsService();
1850 EXPECT_EQ(IAbilityManager::BLOCK_AMS_SERVICE, mock_->code_);
1851 EXPECT_EQ(res, NO_ERROR);
1852 }
1853 #endif
1854
1855 #ifdef ABILITY_COMMAND_FOR_TEST
1856 /*
1857 * Feature: AbilityManagerService
1858 * Function: BlockAbility
1859 * SubFunction: NA
1860 * FunctionPoints: AbilityManagerService BlockAbility
1861 * EnvConditions: NA
1862 * CaseDescription: Verify the normal process of BlockAbility
1863 */
1864 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_BlockAbility_001, TestSize.Level1)
1865 {
1866 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1867 .Times(1)
1868 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1869 int32_t abilityRecordId = 0;
1870 auto res = proxy_->BlockAbility(abilityRecordId);
1871 EXPECT_EQ(IAbilityManager::BLOCK_ABILITY, mock_->code_);
1872 EXPECT_EQ(res, NO_ERROR);
1873 }
1874 #endif
1875
1876 #ifdef ABILITY_COMMAND_FOR_TEST
1877 /*
1878 * Feature: AbilityManagerService
1879 * Function: BlockAppService
1880 * SubFunction: NA
1881 * FunctionPoints: AbilityManagerService BlockAppService
1882 * EnvConditions: NA
1883 * CaseDescription: Verify the normal process of BlockAppService
1884 */
1885 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_BlockAppService_001, TestSize.Level1)
1886 {
1887 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1888 .Times(1)
1889 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1890 auto res = proxy_->BlockAppService();
1891 EXPECT_EQ(IAbilityManager::BLOCK_APP_SERVICE, mock_->code_);
1892 EXPECT_EQ(res, NO_ERROR);
1893 }
1894 #endif
1895
1896 /*
1897 * Feature: AbilityManagerService
1898 * Function: FreeInstallAbilityFromRemote
1899 * SubFunction: NA
1900 * FunctionPoints: AbilityManagerService FreeInstallAbilityFromRemote
1901 * EnvConditions: NA
1902 * CaseDescription: Verify the normal process of FreeInstallAbilityFromRemote
1903 */
1904 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_FreeInstallAbilityFromRemote_001, TestSize.Level1)
1905 {
1906 Want want;
1907 sptr<IRemoteObject> callback = nullptr;
1908 int32_t userId = 0;
1909 int requestCode = 0;
1910 auto res = proxy_->FreeInstallAbilityFromRemote(want, callback, userId, requestCode);
1911 EXPECT_EQ(res, INNER_ERR);
1912 }
1913
1914 /*
1915 * Feature: AbilityManagerService
1916 * Function: DumpAbilityInfoDone
1917 * SubFunction: NA
1918 * FunctionPoints: AbilityManagerService DumpAbilityInfoDone
1919 * EnvConditions: NA
1920 * CaseDescription: Verify the normal process of DumpAbilityInfoDone
1921 */
1922 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_DumpAbilityInfoDone_001, TestSize.Level1)
1923 {
1924 std::vector<std::string> infos;
1925 sptr<IRemoteObject> callerToken = nullptr;
1926 auto res = proxy_->DumpAbilityInfoDone(infos, callerToken);
1927 EXPECT_EQ(res, INNER_ERR);
1928 }
1929
1930 /*
1931 * Feature: AbilityManagerService
1932 * Function: StartAbility
1933 * SubFunction: NA
1934 * FunctionPoints: AbilityManagerService StartAbility
1935 * EnvConditions: NA
1936 * CaseDescription: Verify the normal process of startability
1937 */
1938 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_StartAbility_001, TestSize.Level1)
1939 {
1940 EXPECT_CALL(*mock_, SendRequest(_, _, _, _))
1941 .Times(1)
1942 .WillOnce(Invoke(mock_.GetRefPtr(), &AbilityManagerStubMock::InvokeSendRequest));
1943 const Want want;
1944 sptr<IRemoteObject> callerToken = nullptr;
1945 auto res = proxy_->StartAbility(want, callerToken);
1946 EXPECT_EQ(IAbilityManager::START_ABILITY_ADD_CALLER, mock_->code_);
1947 EXPECT_EQ(res, NO_ERROR);
1948 }
1949
1950 /*
1951 * Feature: AbilityManagerService
1952 * Function: CallRequestDone
1953 * SubFunction: NA
1954 * FunctionPoints: AbilityManagerService CallRequestDone
1955 * EnvConditions: NA
1956 * CaseDescription: Verify the normal process of CallRequestDone
1957 */
1958 HWTEST_F(AbilityManagerProxyTest, AbilityManagerProxy_CallRequestDone_001, TestSize.Level1)
1959 {
1960 sptr<IRemoteObject> token = nullptr;
1961 sptr<IRemoteObject> callStub = nullptr;
1962 proxy_->CallRequestDone(token, callStub);
1963 EXPECT_TRUE(true);
1964 }
1965 } // namespace AAFwk
1966 } // namespace OHOS
1967