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