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