1 /*
2 * Copyright (c) 2021-2023 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "iremote_proxy.h"
18 #include "ability_manager_stub_impl_mock.h"
19 #include "ability_scheduler.h"
20 #include "mock_ability_connect_callback.h"
21 #include "mock_ability_token.h"
22
23 using namespace testing::ext;
24 using namespace testing;
25
26 namespace OHOS {
27 namespace AAFwk {
28 namespace {
29 const int USER_ID = 100;
30 } // namespace
31
32 class AbilityManagerStubTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38 void WriteInterfaceToken(MessageParcel& data);
39 sptr<AbilityManagerStubImplMock> stub_{ nullptr };
40 };
41
SetUpTestCase(void)42 void AbilityManagerStubTest::SetUpTestCase(void)
43 {}
TearDownTestCase(void)44 void AbilityManagerStubTest::TearDownTestCase(void)
45 {}
TearDown()46 void AbilityManagerStubTest::TearDown()
47 {}
48
SetUp()49 void AbilityManagerStubTest::SetUp()
50 {
51 stub_ = new AbilityManagerStubImplMock();
52 }
53
WriteInterfaceToken(MessageParcel & data)54 void AbilityManagerStubTest::WriteInterfaceToken(MessageParcel& data)
55 {
56 data.WriteInterfaceToken(AbilityManagerStub::GetDescriptor());
57 }
58
59 /**
60 * @tc.name: AbilityManagerStub_DumpSysStateInner_0100
61 * @tc.desc: DumpSysStateInner
62 * @tc.type: FUNC
63 * @tc.require: SR000GH1GO
64 */
65 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DumpSysStateInner_0100, TestSize.Level1)
66 {
67 HILOG_INFO("AbilityManagerStub_DumpSysStateInner_0100 start");
68
69 MessageParcel data;
70 MessageParcel reply;
71 MessageOption option;
72
73 WriteInterfaceToken(data);
74
75 std::string args = "-a";
76 data.WriteString16(Str8ToStr16(args));
77
78 bool isClient = false;
79 data.WriteBool(isClient);
80
81 bool isUserID = true;
82 data.WriteBool(isUserID);
83
84 data.WriteInt32(USER_ID);
85
86 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::DUMPSYS_STATE),
87 data, reply, option);
88 EXPECT_EQ(res, NO_ERROR);
89
90 HILOG_INFO("AbilityManagerStub_DumpSysStateInner_0100 end");
91 } // namespace AAFwk
92
93 /*
94 * Feature: AbilityManagerService
95 * Function: OnRemoteRequest
96 * SubFunction: NA
97 * FunctionPoints: AbilityManagerService OnRemoteRequest
98 * EnvConditions: code is START_ABILITY
99 * CaseDescription: Verify that on remote request is normal and abnormal
100 */
101 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_001, TestSize.Level1)
102 {
103 MessageParcel data;
104 MessageParcel reply;
105 MessageOption option;
106
107 Want want;
108 WriteInterfaceToken(data);
109 want.SetFlags(10);
110 data.WriteParcelable(&want);
111 data.WriteInt32(1);
112 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY),
113 data, reply, option);
114
115 EXPECT_EQ(res, NO_ERROR);
116
117 data.WriteParcelable(nullptr);
118 data.WriteInt32(1);
119 int res1 = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY),
120 data, reply, option);
121 EXPECT_NE(res1, NO_ERROR);
122 }
123
124 /*
125 * Feature: AbilityManagerService
126 * Function: OnRemoteRequest
127 * SubFunction: NA
128 * FunctionPoints: AbilityManagerService OnRemoteRequest
129 * EnvConditions: code is TERMINATE_ABILITY
130 * CaseDescription: Verify that on remote request is normal and abnormal
131 */
132 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_002, TestSize.Level1)
133 {
134 MessageParcel data;
135 MessageParcel reply;
136 MessageOption option;
137
138 Want want;
139 want.SetFlags(10);
140 OHOS::sptr<IRemoteObject> token = nullptr;
141 WriteInterfaceToken(data);
142 data.WriteParcelable(token);
143 data.WriteParcelable(&want);
144 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::TERMINATE_ABILITY),
145 data, reply, option);
146
147 EXPECT_EQ(res, NO_ERROR);
148 }
149
150 /*
151 * Feature: AbilityManagerService
152 * Function: OnRemoteRequest
153 * SubFunction: NA
154 * FunctionPoints: AbilityManagerService OnRemoteRequest
155 * EnvConditions: code is CONNECT_ABILITY
156 * CaseDescription: Verify that on remote request is normal
157 */
158 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_004, TestSize.Level1)
159 {
160 MessageParcel data;
161 MessageParcel reply;
162 MessageOption option;
163
164 Want want;
165 want.SetFlags(10);
166 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
167 sptr<IRemoteObject> callerToken = nullptr;
168 WriteInterfaceToken(data);
169 data.WriteParcelable(&want);
170 data.WriteParcelable(connect->AsObject());
171 data.WriteParcelable(callerToken);
172 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY),
173 data, reply, option);
174
175 EXPECT_EQ(res, NO_ERROR);
176 }
177
178 /*
179 * Feature: AbilityManagerService
180 * Function: OnRemoteRequest
181 * SubFunction: NA
182 * FunctionPoints: NA
183 * EnvConditions: NA
184 * CaseDescription: OnRemoteRequest static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY
185 */
186 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_005, TestSize.Level1)
187 {
188 MessageParcel data;
189 MessageParcel reply;
190 MessageOption option;
191
192 Want want;
193 want.SetFlags(10);
194 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
195 sptr<IRemoteObject> callerToken = nullptr;
196 WriteInterfaceToken(data);
197 data.WriteParcelable(&want);
198 data.WriteParcelable(connect->AsObject());
199 data.WriteParcelable(callerToken);
200 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY),
201 data, reply, option);
202
203 EXPECT_EQ(res, NO_ERROR);
204 }
205
206 /*
207 * Feature: AbilityManagerService
208 * Function: OnRemoteRequest
209 * SubFunction: NA
210 * FunctionPoints: NA
211 * EnvConditions: NA
212 * CaseDescription: OnRemoteRequest static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY
213 */
214 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_006, TestSize.Level1)
215 {
216 MessageParcel data;
217 MessageParcel reply;
218 MessageOption option;
219
220 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
221 sptr<IRemoteObject> callerToken = nullptr;
222 WriteInterfaceToken(data);
223 data.WriteParcelable(nullptr);
224 data.WriteParcelable(connect->AsObject());
225 data.WriteParcelable(callerToken);
226 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY),
227 data, reply, option);
228
229 EXPECT_NE(res, NO_ERROR);
230 }
231
232 /*
233 * Feature: AbilityManagerService
234 * Function: OnRemoteRequest
235 * SubFunction: NA
236 * FunctionPoints: AbilityManagerService OnRemoteRequest
237 * EnvConditions: code is DISCONNECT_ABILITY
238 * CaseDescription: Verify that on remote request is normal
239 */
240 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_007, TestSize.Level1)
241 {
242 MessageParcel data;
243 MessageParcel reply;
244 MessageOption option;
245
246 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
247 WriteInterfaceToken(data);
248 data.WriteParcelable(connect->AsObject());
249 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::DISCONNECT_ABILITY),
250 data, reply, option);
251
252 EXPECT_EQ(res, NO_ERROR);
253 }
254
255 /*
256 * Feature: AbilityManagerService
257 * Function: OnRemoteRequest
258 * SubFunction: NA
259 * FunctionPoints: AbilityManagerService OnRemoteRequest
260 * EnvConditions: code is ATTACH_ABILITY_THREAD
261 * CaseDescription: Verify that on remote request is normal
262 */
263 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_008, TestSize.Level1)
264 {
265 MessageParcel data;
266 MessageParcel reply;
267 MessageOption option;
268
269 sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
270 sptr<IRemoteObject> token = nullptr;
271 WriteInterfaceToken(data);
272 data.WriteParcelable(scheduler->AsObject());
273 data.WriteParcelable(token);
274 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::ATTACH_ABILITY_THREAD),
275 data, reply, option);
276
277 EXPECT_EQ(res, NO_ERROR);
278 }
279
280 /*
281 * Feature: AbilityManagerService
282 * Function: OnRemoteRequest
283 * SubFunction: NA
284 * FunctionPoints: AbilityManagerService OnRemoteRequest
285 * EnvConditions: code is ABILITY_TRANSITION_DONE
286 * CaseDescription: Verify that on remote request is normal
287 */
288 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_009, TestSize.Level1)
289 {
290 MessageParcel data;
291 MessageParcel reply;
292 MessageOption option;
293
294 sptr<IRemoteObject> token = sptr<AppExecFwk::MockAbilityToken>(new (std::nothrow) AppExecFwk::MockAbilityToken());
295 WriteInterfaceToken(data);
296 bool ret = data.WriteRemoteObject(token);
297 ret |= data.WriteInt32(1);
298 PacMap pMap;
299 pMap.PutIntValue(std::string("1"), 1);
300 ret |= data.WriteParcelable(&pMap);
301 if (ret) {
302 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::ABILITY_TRANSITION_DONE),
303 data, reply, option);
304 EXPECT_EQ(res, NO_ERROR);
305 }
306 }
307
308 /*
309 * Feature: AbilityManagerService
310 * Function: OnRemoteRequest
311 * SubFunction: NA
312 * FunctionPoints: AbilityManagerService OnRemoteRequest
313 * EnvConditions: code is CONNECT_ABILITY_DONE
314 * CaseDescription: Verify that on remote request is normal
315 */
316 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_010, TestSize.Level1)
317 {
318 MessageParcel data;
319 MessageParcel reply;
320 MessageOption option;
321
322 sptr<IRemoteObject> token = nullptr;
323 sptr<IRemoteObject> remoteObject = nullptr;
324 WriteInterfaceToken(data);
325 data.WriteParcelable(token);
326 data.WriteParcelable(remoteObject);
327 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY_DONE),
328 data, reply, option);
329
330 EXPECT_EQ(res, NO_ERROR);
331 }
332
333 /*
334 * Feature: AbilityManagerService
335 * Function: OnRemoteRequest
336 * SubFunction: NA
337 * FunctionPoints: AbilityManagerService OnRemoteRequest
338 * EnvConditions: code is DISCONNECT_ABILITY_DONE
339 * CaseDescription: Verify that on remote request is normal
340 */
341 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_011, TestSize.Level1)
342 {
343 MessageParcel data;
344 MessageParcel reply;
345 MessageOption option;
346
347 sptr<IRemoteObject> token = nullptr;
348 WriteInterfaceToken(data);
349 data.WriteParcelable(token);
350 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::DISCONNECT_ABILITY_DONE),
351 data, reply, option);
352
353 EXPECT_EQ(res, NO_ERROR);
354 }
355
356 /*
357 * Feature: AbilityManagerService
358 * Function: OnRemoteRequest
359 * SubFunction: NA
360 * FunctionPoints: AbilityManagerService OnRemoteRequest
361 * EnvConditions: code is SEND_RESULT_TO_ABILITY
362 * CaseDescription: Verify that on remote request is normal
363 */
364 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_012, TestSize.Level1)
365 {
366 MessageParcel data;
367 MessageParcel reply;
368 MessageOption option;
369
370 WriteInterfaceToken(data);
371 int requestCode = -1;
372 int resultCode = -1;
373 Want want;
374 data.WriteInt32(requestCode);
375 data.WriteInt32(resultCode);
376 data.WriteParcelable(&want);
377 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::SEND_RESULT_TO_ABILITY),
378 data, reply, option);
379
380 EXPECT_EQ(res, NO_ERROR);
381 }
382
383 /*
384 * Feature: AbilityManagerService
385 * Function: OnRemoteRequest
386 * SubFunction: NA
387 * FunctionPoints: AbilityManagerService OnRemoteRequest
388 * EnvConditions: code is DUMP_STATE
389 * CaseDescription: Verify that on remote request is normal
390 */
391 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_013, TestSize.Level1)
392 {
393 MessageParcel data;
394 MessageParcel reply;
395 MessageOption option;
396
397 std::string args = "aaa";
398 std::vector<std::string> info;
399 WriteInterfaceToken(data);
400 data.WriteString16(Str8ToStr16(args));
401 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::DUMP_STATE),
402 data, reply, option);
403
404 EXPECT_EQ(res, NO_ERROR);
405 }
406
407 /*
408 * Feature: AbilityManagerService
409 * Function: OnRemoteRequest
410 * SubFunction: NA
411 * FunctionPoints: AbilityManagerService OnRemoteRequest
412 * EnvConditions: code is default
413 * CaseDescription: Verify that on remote request is normal
414 */
415 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_016, TestSize.Level1)
416 {
417 MessageParcel data;
418 MessageParcel reply;
419 MessageOption option;
420 WriteInterfaceToken(data);
421 int res = stub_->OnRemoteRequest(5000, data, reply, option);
422
423 EXPECT_NE(res, NO_ERROR);
424 }
425
426 /*
427 * Feature: AbilityManagerService
428 * Function: OnRemoteRequest
429 * SubFunction: NA
430 * FunctionPoints: AbilityManagerService OnRemoteRequest
431 * EnvConditions: code is START_CALL_ABILITY
432 * CaseDescription: Verify that on remote request is normal
433 */
434 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_018, TestSize.Level1)
435 {
436 MessageParcel data;
437 MessageParcel reply;
438 MessageOption option;
439 Want want;
440 WriteInterfaceToken(data);
441 want.SetFlags(10);
442 data.WriteParcelable(&want);
443 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_CALL_ABILITY),
444 data, reply, option);
445
446 EXPECT_EQ(res, NO_ERROR);
447 }
448
449 /*
450 * Feature: AbilityManagerService
451 * Function: OnRemoteRequest
452 * SubFunction: NA
453 * FunctionPoints: AbilityManagerService OnRemoteRequest
454 * EnvConditions: code is START_CALL_ABILITY
455 * CaseDescription: Verify that on remote request is ERR_INVALID_VALUE
456 */
457 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_019, TestSize.Level1)
458 {
459 MessageParcel data;
460 MessageParcel reply;
461 MessageOption option;
462 WriteInterfaceToken(data);
463 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_CALL_ABILITY),
464 data, reply, option);
465
466 EXPECT_EQ(res, ERR_INVALID_VALUE);
467 }
468
469 /*
470 * Feature: AbilityManagerService
471 * Function: OnRemoteRequest
472 * SubFunction: NA
473 * FunctionPoints: AbilityManagerService OnRemoteRequest
474 * EnvConditions: code is START_CALL_ABILITY
475 * CaseDescription: Verify that on remote request is normal
476 */
477 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_020, TestSize.Level1)
478 {
479 MessageParcel data;
480 MessageParcel reply;
481 MessageOption option;
482 WriteInterfaceToken(data);
483 AppExecFwk::ElementName element;
484 sptr<IAbilityConnection> connect = new AbilityConnectCallback();
485 data.WriteParcelable(connect->AsObject());
486 data.WriteParcelable(&element);
487 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::RELEASE_CALL_ABILITY),
488 data, reply, option);
489
490 EXPECT_EQ(res, ERR_INVALID_VALUE);
491 }
492
493 /*
494 * Feature: AbilityManagerService
495 * Function: OnRemoteRequest
496 * SubFunction: NA
497 * FunctionPoints: AbilityManagerService OnRemoteRequest
498 * EnvConditions: code is START_CALL_ABILITY
499 * CaseDescription: Verify that on remote request is ERR_INVALID_VALUE
500 */
501 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_021, TestSize.Level1)
502 {
503 MessageParcel data;
504 MessageParcel reply;
505 MessageOption option;
506 WriteInterfaceToken(data);
507 int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::RELEASE_CALL_ABILITY),
508 data, reply, option);
509
510 EXPECT_EQ(res, ERR_INVALID_VALUE);
511 }
512
513 /*
514 * Feature: AbilityManagerService
515 * Function: GetTopAbilityInner
516 * SubFunction: NA
517 * FunctionPoints: AbilityManagerService GetTopAbilityInner
518 * EnvConditions: NA
519 * CaseDescription: Verify the function GetTopAbilityInner is normal flow.
520 */
521 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetTopAbilityInner_001, TestSize.Level1)
522 {
523 MessageParcel data;
524 MessageParcel reply;
525 auto res = stub_->GetTopAbilityInner(data, reply);
526 EXPECT_EQ(res, NO_ERROR);
527 }
528
529 /*
530 * Feature: AbilityManagerService
531 * Function: TerminateAbilityInner
532 * SubFunction: NA
533 * FunctionPoints: AbilityManagerService TerminateAbilityInner
534 * EnvConditions: NA
535 * CaseDescription: Verify the function TerminateAbilityInner is normal flow.
536 */
537 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_TerminateAbilityInner_001, TestSize.Level1)
538 {
539 MessageParcel data;
540 MessageParcel reply;
541 auto res = stub_->TerminateAbilityInner(data, reply);
542 EXPECT_EQ(res, NO_ERROR);
543 }
544
545 /*
546 * Feature: AbilityManagerService
547 * Function: SendResultToAbilityInner
548 * SubFunction: NA
549 * FunctionPoints: AbilityManagerService SendResultToAbilityInner
550 * EnvConditions: NA
551 * CaseDescription: Verify the function SendResultToAbilityInner is normal flow.
552 */
553 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SendResultToAbilityInner_001, TestSize.Level1)
554 {
555 MessageParcel data;
556 MessageParcel reply;
557 auto res = stub_->SendResultToAbilityInner(data, reply);
558 EXPECT_EQ(res, ERR_INVALID_VALUE);
559 }
560
561 /*
562 * Feature: AbilityManagerService
563 * Function: MinimizeAbilityInner
564 * SubFunction: NA
565 * FunctionPoints: AbilityManagerService MinimizeAbilityInner
566 * EnvConditions: NA
567 * CaseDescription: Verify the function MinimizeAbilityInner is normal flow.
568 */
569 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MinimizeAbilityInner_001, TestSize.Level1)
570 {
571 MessageParcel data;
572 MessageParcel reply;
573 auto res = stub_->MinimizeAbilityInner(data, reply);
574 EXPECT_EQ(res, NO_ERROR);
575 }
576
577 /*
578 * Feature: AbilityManagerService
579 * Function: AttachAbilityThreadInner
580 * SubFunction: NA
581 * FunctionPoints: AbilityManagerService AttachAbilityThreadInner
582 * EnvConditions: NA
583 * CaseDescription: Verify the function AttachAbilityThreadInner is normal flow.
584 */
585 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AttachAbilityThreadInner_001, TestSize.Level1)
586 {
587 MessageParcel data;
588 MessageParcel reply;
589 auto res = stub_->AttachAbilityThreadInner(data, reply);
590 EXPECT_EQ(res, NO_ERROR);
591 }
592
593 /*
594 * Feature: AbilityManagerService
595 * Function: AbilityTransitionDoneInner
596 * SubFunction: NA
597 * FunctionPoints: AbilityManagerService AbilityTransitionDoneInner
598 * EnvConditions: NA
599 * CaseDescription: Verify the function AbilityTransitionDoneInner is normal flow.
600 */
601 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AbilityTransitionDoneInner_001, TestSize.Level1)
602 {
603 MessageParcel data;
604 MessageParcel reply;
605 auto res = stub_->AbilityTransitionDoneInner(data, reply);
606 EXPECT_EQ(res, ERR_INVALID_VALUE);
607 }
608
609 /*
610 * Feature: AbilityManagerService
611 * Function: ScheduleConnectAbilityDoneInner
612 * SubFunction: NA
613 * FunctionPoints: AbilityManagerService ScheduleConnectAbilityDoneInner
614 * EnvConditions: NA
615 * CaseDescription: Verify the function ScheduleConnectAbilityDoneInner is normal flow.
616 */
617 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ScheduleConnectAbilityDoneInner_001, TestSize.Level1)
618 {
619 MessageParcel data;
620 MessageParcel reply;
621 auto res = stub_->ScheduleConnectAbilityDoneInner(data, reply);
622 EXPECT_EQ(res, NO_ERROR);
623 }
624
625 /*
626 * Feature: AbilityManagerService
627 * Function: ScheduleDisconnectAbilityDoneInner
628 * SubFunction: NA
629 * FunctionPoints: AbilityManagerService ScheduleDisconnectAbilityDoneInner
630 * EnvConditions: NA
631 * CaseDescription: Verify the function ScheduleDisconnectAbilityDoneInner is normal flow.
632 */
633 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ScheduleDisconnectAbilityDoneInner_001, TestSize.Level1)
634 {
635 MessageParcel data;
636 MessageParcel reply;
637 auto res = stub_->ScheduleDisconnectAbilityDoneInner(data, reply);
638 EXPECT_EQ(res, NO_ERROR);
639 }
640
641 /*
642 * Feature: AbilityManagerService
643 * Function: ScheduleCommandAbilityDoneInner
644 * SubFunction: NA
645 * FunctionPoints: AbilityManagerService ScheduleCommandAbilityDoneInner
646 * EnvConditions: NA
647 * CaseDescription: Verify the function ScheduleCommandAbilityDoneInner is normal flow.
648 */
649 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ScheduleCommandAbilityDoneInner_001, TestSize.Level1)
650 {
651 MessageParcel data;
652 MessageParcel reply;
653 auto res = stub_->ScheduleCommandAbilityDoneInner(data, reply);
654 EXPECT_EQ(res, NO_ERROR);
655 }
656
657 /*
658 * Feature: AbilityManagerService
659 * Function: ScheduleCommandAbilityWindowDoneInner
660 * SubFunction: NA
661 * FunctionPoints: AbilityManagerService ScheduleCommandAbilityWindowDoneInner
662 * EnvConditions: NA
663 * CaseDescription: Verify the function ScheduleCommandAbilityWindowDoneInner is normal flow.
664 */
665 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ScheduleCommandAbilityWindowDoneInner_001, TestSize.Level1)
666 {
667 MessageParcel data;
668 MessageParcel reply;
669 auto res = stub_->ScheduleCommandAbilityWindowDoneInner(data, reply);
670 EXPECT_EQ(res, NO_ERROR);
671 }
672
673 /*
674 * Feature: AbilityManagerService
675 * Function: AcquireDataAbilityInner
676 * SubFunction: NA
677 * FunctionPoints: AbilityManagerService AcquireDataAbilityInner
678 * EnvConditions: NA
679 * CaseDescription: Verify the function AcquireDataAbilityInner is normal flow.
680 */
681 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AcquireDataAbilityInner_001, TestSize.Level1)
682 {
683 MessageParcel data;
684 MessageParcel reply;
685 auto res = stub_->AcquireDataAbilityInner(data, reply);
686 EXPECT_EQ(res, NO_ERROR);
687 }
688
689 /*
690 * Feature: AbilityManagerService
691 * Function: ReleaseDataAbilityInner
692 * SubFunction: NA
693 * FunctionPoints: AbilityManagerService ReleaseDataAbilityInner
694 * EnvConditions: NA
695 * CaseDescription: Verify the function ReleaseDataAbilityInner is normal flow.
696 */
697 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ReleaseDataAbilityInner_001, TestSize.Level1)
698 {
699 MessageParcel data;
700 MessageParcel reply;
701 auto res = stub_->ReleaseDataAbilityInner(data, reply);
702 EXPECT_EQ(res, NO_ERROR);
703 }
704
705 /*
706 * Feature: AbilityManagerService
707 * Function: KillProcessInner
708 * SubFunction: NA
709 * FunctionPoints: AbilityManagerService KillProcessInner
710 * EnvConditions: NA
711 * CaseDescription: Verify the function KillProcessInner is normal flow.
712 */
713 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_KillProcessInner_001, TestSize.Level1)
714 {
715 MessageParcel data;
716 MessageParcel reply;
717 auto res = stub_->KillProcessInner(data, reply);
718 EXPECT_EQ(res, NO_ERROR);
719 }
720
721 /*
722 * Feature: AbilityManagerService
723 * Function: ClearUpApplicationDataInner
724 * SubFunction: NA
725 * FunctionPoints: AbilityManagerService ClearUpApplicationDataInner
726 * EnvConditions: NA
727 * CaseDescription: Verify the function ClearUpApplicationDataInner is normal flow.
728 */
729 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ClearUpApplicationDataInner_001, TestSize.Level1)
730 {
731 MessageParcel data;
732 MessageParcel reply;
733 auto res = stub_->ClearUpApplicationDataInner(data, reply);
734 EXPECT_EQ(res, NO_ERROR);
735 }
736
737 /*
738 * Feature: AbilityManagerService
739 * Function: UninstallAppInner
740 * SubFunction: NA
741 * FunctionPoints: AbilityManagerService UninstallAppInner
742 * EnvConditions: NA
743 * CaseDescription: Verify the function UninstallAppInner is normal flow.
744 */
745 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UninstallAppInner_001, TestSize.Level1)
746 {
747 MessageParcel data;
748 MessageParcel reply;
749 auto res = stub_->UninstallAppInner(data, reply);
750 EXPECT_EQ(res, NO_ERROR);
751 }
752
753 /*
754 * Feature: AbilityManagerService
755 * Function: StartAbilityInner
756 * SubFunction: NA
757 * FunctionPoints: AbilityManagerService StartAbilityInner
758 * EnvConditions: NA
759 * CaseDescription: Verify the function StartAbilityInner is normal flow.
760 */
761 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityInner_001, TestSize.Level1)
762 {
763 MessageParcel data;
764 MessageParcel reply;
765 auto res = stub_->StartAbilityInner(data, reply);
766 EXPECT_EQ(res, ERR_INVALID_VALUE);
767 }
768
769 /*
770 * Feature: AbilityManagerService
771 * Function: StartExtensionAbilityInner
772 * SubFunction: NA
773 * FunctionPoints: AbilityManagerService StartExtensionAbilityInner
774 * EnvConditions: NA
775 * CaseDescription: Verify the function StartExtensionAbilityInner is normal flow.
776 */
777 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartExtensionAbilityInner_001, TestSize.Level1)
778 {
779 MessageParcel data;
780 MessageParcel reply;
781 auto res = stub_->StartExtensionAbilityInner(data, reply);
782 EXPECT_EQ(res, ERR_INVALID_VALUE);
783 }
784
785 /*
786 * Feature: AbilityManagerService
787 * Function: StopExtensionAbilityInner
788 * SubFunction: NA
789 * FunctionPoints: AbilityManagerService StopExtensionAbilityInner
790 * EnvConditions: NA
791 * CaseDescription: Verify the function StopExtensionAbilityInner is normal flow.
792 */
793 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StopExtensionAbilityInner_001, TestSize.Level1)
794 {
795 MessageParcel data;
796 MessageParcel reply;
797 auto res = stub_->StopExtensionAbilityInner(data, reply);
798 EXPECT_EQ(res, ERR_INVALID_VALUE);
799 }
800
801 /*
802 * Feature: AbilityManagerService
803 * Function: StartAbilityAddCallerInner
804 * SubFunction: NA
805 * FunctionPoints: AbilityManagerService StartAbilityAddCallerInner
806 * EnvConditions: NA
807 * CaseDescription: Verify the function StartAbilityAddCallerInner is normal flow.
808 */
809 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityAddCallerInner_001, TestSize.Level1)
810 {
811 MessageParcel data;
812 MessageParcel reply;
813 auto res = stub_->StartAbilityAddCallerInner(data, reply);
814 EXPECT_EQ(res, ERR_INVALID_VALUE);
815 }
816
817 /*
818 * Feature: AbilityManagerService
819 * Function: StartAbilityAsCallerByTokenInner
820 * SubFunction: NA
821 * FunctionPoints: AbilityManagerService StartAbilityAsCallerByTokenInner
822 * EnvConditions: NA
823 * CaseDescription: Verify the function StartAbilityAsCallerByTokenInner is normal flow.
824 */
825 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityAsCallerByTokenInner_001, TestSize.Level1)
826 {
827 MessageParcel data;
828 MessageParcel reply;
829 auto res = stub_->StartAbilityAsCallerByTokenInner(data, reply);
830 EXPECT_EQ(res, ERR_INVALID_VALUE);
831 }
832
833 /*
834 * Feature: AbilityManagerService
835 * Function: StartAbilityAsCallerForOptionInner
836 * SubFunction: NA
837 * FunctionPoints: AbilityManagerService StartAbilityAsCallerForOptionInner
838 * EnvConditions: NA
839 * CaseDescription: Verify the function StartAbilityAsCallerForOptionInner is normal flow.
840 */
841 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityAsCallerForOptionInner_001, TestSize.Level1)
842 {
843 MessageParcel data;
844 MessageParcel reply;
845 auto res = stub_->StartAbilityAsCallerForOptionInner(data, reply);
846 EXPECT_EQ(res, ERR_INVALID_VALUE);
847 }
848
849 /*
850 * Feature: AbilityManagerService
851 * Function: ConnectAbilityInner
852 * SubFunction: NA
853 * FunctionPoints: AbilityManagerService ConnectAbilityInner
854 * EnvConditions: NA
855 * CaseDescription: Verify the function ConnectAbilityInner is normal flow.
856 */
857 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ConnectAbilityInner_001, TestSize.Level1)
858 {
859 MessageParcel data;
860 MessageParcel reply;
861 auto res = stub_->ConnectAbilityInner(data, reply);
862 EXPECT_EQ(res, ERR_INVALID_VALUE);
863 }
864
865 /*
866 * Feature: AbilityManagerService
867 * Function: ConnectAbilityWithTypeInner
868 * SubFunction: NA
869 * FunctionPoints: AbilityManagerService ConnectAbilityWithTypeInner
870 * EnvConditions: NA
871 * CaseDescription: Verify the function ConnectAbilityWithTypeInner is normal flow.
872 */
873 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ConnectAbilityWithTypeInner_001, TestSize.Level1)
874 {
875 MessageParcel data;
876 MessageParcel reply;
877 auto res = stub_->ConnectAbilityWithTypeInner(data, reply);
878 EXPECT_EQ(res, ERR_INVALID_VALUE);
879 }
880
881 /*
882 * Feature: AbilityManagerService
883 * Function: DisconnectAbilityInner
884 * SubFunction: NA
885 * FunctionPoints: AbilityManagerService DisconnectAbilityInner
886 * EnvConditions: NA
887 * CaseDescription: Verify the function DisconnectAbilityInner is normal flow.
888 */
889 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DisconnectAbilityInner_001, TestSize.Level1)
890 {
891 MessageParcel data;
892 MessageParcel reply;
893 auto res = stub_->DisconnectAbilityInner(data, reply);
894 EXPECT_EQ(res, NO_ERROR);
895 }
896
897 /*
898 * Feature: AbilityManagerService
899 * Function: StopServiceAbilityInner
900 * SubFunction: NA
901 * FunctionPoints: AbilityManagerService StopServiceAbilityInner
902 * EnvConditions: NA
903 * CaseDescription: Verify the function StopServiceAbilityInner is normal flow.
904 */
905 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StopServiceAbilityInner_001, TestSize.Level1)
906 {
907 MessageParcel data;
908 MessageParcel reply;
909 auto res = stub_->StopServiceAbilityInner(data, reply);
910 EXPECT_EQ(res, ERR_INVALID_VALUE);
911 }
912
913 /*
914 * Feature: AbilityManagerService
915 * Function: DumpSysStateInner
916 * SubFunction: NA
917 * FunctionPoints: AbilityManagerService DumpSysStateInner
918 * EnvConditions: NA
919 * CaseDescription: Verify the function DumpSysStateInner is normal flow.
920 */
921 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DumpSysStateInner_001, TestSize.Level1)
922 {
923 MessageParcel data;
924 MessageParcel reply;
925 auto res = stub_->DumpSysStateInner(data, reply);
926 EXPECT_EQ(res, ERR_INVALID_VALUE);
927 }
928
929 /*
930 * Feature: AbilityManagerService
931 * Function: DumpStateInner
932 * SubFunction: NA
933 * FunctionPoints: AbilityManagerService DumpStateInner
934 * EnvConditions: NA
935 * CaseDescription: Verify the function DumpStateInner is normal flow.
936 */
937 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DumpStateInner_001, TestSize.Level1)
938 {
939 MessageParcel data;
940 MessageParcel reply;
941 auto res = stub_->DumpStateInner(data, reply);
942 EXPECT_EQ(res, ERR_INVALID_VALUE);
943 }
944
945 /*
946 * Feature: AbilityManagerService
947 * Function: StartAbilityForSettingsInner
948 * SubFunction: NA
949 * FunctionPoints: AbilityManagerService StartAbilityForSettingsInner
950 * EnvConditions: NA
951 * CaseDescription: Verify the function StartAbilityForSettingsInner is normal flow.
952 */
953 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityForSettingsInner_001, TestSize.Level1)
954 {
955 MessageParcel data;
956 MessageParcel reply;
957 auto res = stub_->StartAbilityForSettingsInner(data, reply);
958 EXPECT_EQ(res, ERR_INVALID_VALUE);
959 }
960
961 /*
962 * Feature: AbilityManagerService
963 * Function: StartAbilityForOptionsInner
964 * SubFunction: NA
965 * FunctionPoints: AbilityManagerService StartAbilityForOptionsInner
966 * EnvConditions: NA
967 * CaseDescription: Verify the function StartAbilityForOptionsInner is normal flow.
968 */
969 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityForOptionsInner_001, TestSize.Level1)
970 {
971 MessageParcel data;
972 MessageParcel reply;
973 auto res = stub_->StartAbilityForOptionsInner(data, reply);
974 EXPECT_EQ(res, ERR_INVALID_VALUE);
975 }
976
977 /*
978 * Feature: AbilityManagerService
979 * Function: GetWantSenderInner
980 * SubFunction: NA
981 * FunctionPoints: AbilityManagerService GetWantSenderInner
982 * EnvConditions: NA
983 * CaseDescription: Verify the function GetWantSenderInner is normal flow.
984 */
985 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetWantSenderInner_001, TestSize.Level1)
986 {
987 MessageParcel data;
988 MessageParcel reply;
989 auto res = stub_->GetWantSenderInner(data, reply);
990 EXPECT_EQ(res, ERR_INVALID_VALUE);
991 }
992
993 /*
994 * Feature: AbilityManagerService
995 * Function: SendWantSenderInner
996 * SubFunction: NA
997 * FunctionPoints: AbilityManagerService SendWantSenderInner
998 * EnvConditions: NA
999 * CaseDescription: Verify the function SendWantSenderInner is normal flow.
1000 */
1001 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SendWantSenderInner_001, TestSize.Level1)
1002 {
1003 MessageParcel data;
1004 MessageParcel reply;
1005 auto res = stub_->SendWantSenderInner(data, reply);
1006 EXPECT_EQ(res, ERR_INVALID_VALUE);
1007 }
1008
1009 /*
1010 * Feature: AbilityManagerService
1011 * Function: CancelWantSenderInner
1012 * SubFunction: NA
1013 * FunctionPoints: AbilityManagerService CancelWantSenderInner
1014 * EnvConditions: NA
1015 * CaseDescription: Verify the function CancelWantSenderInner is normal flow.
1016 */
1017 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CancelWantSenderInner_001, TestSize.Level1)
1018 {
1019 MessageParcel data;
1020 MessageParcel reply;
1021 auto res = stub_->CancelWantSenderInner(data, reply);
1022 EXPECT_EQ(res, ERR_INVALID_VALUE);
1023 }
1024
1025 /*
1026 * Feature: AbilityManagerService
1027 * Function: GetPendingWantUidInner
1028 * SubFunction: NA
1029 * FunctionPoints: AbilityManagerService GetPendingWantUidInner
1030 * EnvConditions: NA
1031 * CaseDescription: Verify the function GetPendingWantUidInner is normal flow.
1032 */
1033 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantUidInner_001, TestSize.Level1)
1034 {
1035 MessageParcel data;
1036 MessageParcel reply;
1037 auto res = stub_->GetPendingWantUidInner(data, reply);
1038 EXPECT_EQ(res, ERR_INVALID_VALUE);
1039 }
1040
1041 /*
1042 * Feature: AbilityManagerService
1043 * Function: GetPendingWantUserIdInner
1044 * SubFunction: NA
1045 * FunctionPoints: AbilityManagerService GetPendingWantUserIdInner
1046 * EnvConditions: NA
1047 * CaseDescription: Verify the function GetPendingWantUserIdInner is normal flow.
1048 */
1049 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantUserIdInner_001, TestSize.Level1)
1050 {
1051 MessageParcel data;
1052 MessageParcel reply;
1053 auto res = stub_->GetPendingWantUserIdInner(data, reply);
1054 EXPECT_EQ(res, ERR_INVALID_VALUE);
1055 }
1056
1057 /*
1058 * Feature: AbilityManagerService
1059 * Function: GetPendingWantBundleNameInner
1060 * SubFunction: NA
1061 * FunctionPoints: AbilityManagerService GetPendingWantBundleNameInner
1062 * EnvConditions: NA
1063 * CaseDescription: Verify the function GetPendingWantBundleNameInner is normal flow.
1064 */
1065 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantBundleNameInner_001, TestSize.Level1)
1066 {
1067 MessageParcel data;
1068 MessageParcel reply;
1069 auto res = stub_->GetPendingWantBundleNameInner(data, reply);
1070 EXPECT_EQ(res, ERR_INVALID_VALUE);
1071 }
1072
1073 /*
1074 * Feature: AbilityManagerService
1075 * Function: GetPendingWantCodeInner
1076 * SubFunction: NA
1077 * FunctionPoints: AbilityManagerService GetPendingWantCodeInner
1078 * EnvConditions: NA
1079 * CaseDescription: Verify the function GetPendingWantCodeInner is normal flow.
1080 */
1081 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantCodeInner_001, TestSize.Level1)
1082 {
1083 MessageParcel data;
1084 MessageParcel reply;
1085 auto res = stub_->GetPendingWantCodeInner(data, reply);
1086 EXPECT_EQ(res, ERR_INVALID_VALUE);
1087 }
1088
1089 /*
1090 * Feature: AbilityManagerService
1091 * Function: GetPendingWantTypeInner
1092 * SubFunction: NA
1093 * FunctionPoints: AbilityManagerService GetPendingWantTypeInner
1094 * EnvConditions: NA
1095 * CaseDescription: Verify the function GetPendingWantTypeInner is normal flow.
1096 */
1097 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantTypeInner_001, TestSize.Level1)
1098 {
1099 MessageParcel data;
1100 MessageParcel reply;
1101 auto res = stub_->GetPendingWantTypeInner(data, reply);
1102 EXPECT_EQ(res, ERR_INVALID_VALUE);
1103 }
1104
1105 /*
1106 * Feature: AbilityManagerService
1107 * Function: RegisterCancelListenerInner
1108 * SubFunction: NA
1109 * FunctionPoints: AbilityManagerService RegisterCancelListenerInner
1110 * EnvConditions: NA
1111 * CaseDescription: Verify the function RegisterCancelListenerInner is normal flow.
1112 */
1113 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterCancelListenerInner_001, TestSize.Level1)
1114 {
1115 MessageParcel data;
1116 MessageParcel reply;
1117 auto res = stub_->RegisterCancelListenerInner(data, reply);
1118 EXPECT_EQ(res, ERR_INVALID_VALUE);
1119 }
1120
1121 /*
1122 * Feature: AbilityManagerService
1123 * Function: UnregisterCancelListenerInner
1124 * SubFunction: NA
1125 * FunctionPoints: AbilityManagerService UnregisterCancelListenerInner
1126 * EnvConditions: NA
1127 * CaseDescription: Verify the function UnregisterCancelListenerInner is normal flow.
1128 */
1129 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterCancelListenerInner_001, TestSize.Level1)
1130 {
1131 MessageParcel data;
1132 MessageParcel reply;
1133 auto res = stub_->UnregisterCancelListenerInner(data, reply);
1134 EXPECT_EQ(res, ERR_INVALID_VALUE);
1135 }
1136
1137 /*
1138 * Feature: AbilityManagerService
1139 * Function: GetPendingRequestWantInner
1140 * SubFunction: NA
1141 * FunctionPoints: AbilityManagerService GetPendingRequestWantInner
1142 * EnvConditions: NA
1143 * CaseDescription: Verify the function GetPendingRequestWantInner is normal flow.
1144 */
1145 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingRequestWantInner_001, TestSize.Level1)
1146 {
1147 MessageParcel data;
1148 MessageParcel reply;
1149 auto res = stub_->GetPendingRequestWantInner(data, reply);
1150 EXPECT_EQ(res, ERR_INVALID_VALUE);
1151 }
1152
1153 /*
1154 * Feature: AbilityManagerService
1155 * Function: GetWantSenderInfoInner
1156 * SubFunction: NA
1157 * FunctionPoints: AbilityManagerService GetWantSenderInfoInner
1158 * EnvConditions: NA
1159 * CaseDescription: Verify the function GetWantSenderInfoInner is normal flow.
1160 */
1161 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetWantSenderInfoInner_001, TestSize.Level1)
1162 {
1163 MessageParcel data;
1164 MessageParcel reply;
1165 auto res = stub_->GetWantSenderInfoInner(data, reply);
1166 EXPECT_EQ(res, ERR_INVALID_VALUE);
1167 }
1168
1169 /*
1170 * Feature: AbilityManagerService
1171 * Function: GetAppMemorySizeInner
1172 * SubFunction: NA
1173 * FunctionPoints: AbilityManagerService GetAppMemorySizeInner
1174 * EnvConditions: NA
1175 * CaseDescription: Verify the function GetAppMemorySizeInner is normal flow.
1176 */
1177 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetAppMemorySizeInner_001, TestSize.Level1)
1178 {
1179 MessageParcel data;
1180 MessageParcel reply;
1181 auto res = stub_->GetAppMemorySizeInner(data, reply);
1182 EXPECT_EQ(res, NO_ERROR);
1183 }
1184
1185 /*
1186 * Feature: AbilityManagerService
1187 * Function: IsRamConstrainedDeviceInner
1188 * SubFunction: NA
1189 * FunctionPoints: AbilityManagerService IsRamConstrainedDeviceInner
1190 * EnvConditions: NA
1191 * CaseDescription: Verify the function IsRamConstrainedDeviceInner is normal flow.
1192 */
1193 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsRamConstrainedDeviceInner_001, TestSize.Level1)
1194 {
1195 MessageParcel data;
1196 MessageParcel reply;
1197 auto res = stub_->IsRamConstrainedDeviceInner(data, reply);
1198 EXPECT_EQ(res, NO_ERROR);
1199 }
1200
1201 /*
1202 * Feature: AbilityManagerService
1203 * Function: ContinueMissionInner
1204 * SubFunction: NA
1205 * FunctionPoints: AbilityManagerService ContinueMissionInner
1206 * EnvConditions: NA
1207 * CaseDescription: Verify the function ContinueMissionInner is normal flow.
1208 */
1209 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ContinueMissionInner_001, TestSize.Level1)
1210 {
1211 MessageParcel data;
1212 MessageParcel reply;
1213 auto res = stub_->ContinueMissionInner(data, reply);
1214 EXPECT_EQ(res, ERR_NULL_OBJECT);
1215 }
1216
1217 /*
1218 * Feature: AbilityManagerService
1219 * Function: ContinueMissionOfBundleNameInner
1220 * SubFunction: NA
1221 * FunctionPoints: AbilityManagerService ContinueMissionOfBundleNameInner
1222 * EnvConditions: NA
1223 * CaseDescription: Verify the function ContinueMissionOfBundleNameInner is normal flow.
1224 */
1225 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ContinueMissionOfBundleNameInner_001, TestSize.Level1)
1226 {
1227 MessageParcel data;
1228 MessageParcel reply;
1229 auto res = stub_->ContinueMissionOfBundleNameInner(data, reply);
1230 EXPECT_EQ(res, ERR_NULL_OBJECT);
1231 }
1232
1233 /*
1234 * Feature: AbilityManagerService
1235 * Function: ContinueAbilityInner
1236 * SubFunction: NA
1237 * FunctionPoints: AbilityManagerService ContinueAbilityInner
1238 * EnvConditions: NA
1239 * CaseDescription: Verify the function ContinueAbilityInner is normal flow.
1240 */
1241 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ContinueAbilityInner_001, TestSize.Level1)
1242 {
1243 MessageParcel data;
1244 MessageParcel reply;
1245 auto res = stub_->ContinueAbilityInner(data, reply);
1246 EXPECT_EQ(res, NO_ERROR);
1247 }
1248
1249 /*
1250 * Feature: AbilityManagerService
1251 * Function: StartContinuationInner
1252 * SubFunction: NA
1253 * FunctionPoints: AbilityManagerService StartContinuationInner
1254 * EnvConditions: NA
1255 * CaseDescription: Verify the function StartContinuationInner is normal flow.
1256 */
1257 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartContinuationInner_001, TestSize.Level1)
1258 {
1259 MessageParcel data;
1260 MessageParcel reply;
1261 auto res = stub_->StartContinuationInner(data, reply);
1262 EXPECT_EQ(res, ERR_NULL_OBJECT);
1263 }
1264
1265 /*
1266 * Feature: AbilityManagerService
1267 * Function: NotifyCompleteContinuationInner
1268 * SubFunction: NA
1269 * FunctionPoints: AbilityManagerService NotifyCompleteContinuationInner
1270 * EnvConditions: NA
1271 * CaseDescription: Verify the function NotifyCompleteContinuationInner is normal flow.
1272 */
1273 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_NotifyCompleteContinuationInner_001, TestSize.Level1)
1274 {
1275 MessageParcel data;
1276 MessageParcel reply;
1277 auto res = stub_->NotifyCompleteContinuationInner(data, reply);
1278 EXPECT_EQ(res, NO_ERROR);
1279 }
1280
1281 /*
1282 * Feature: AbilityManagerService
1283 * Function: NotifyContinuationResultInner
1284 * SubFunction: NA
1285 * FunctionPoints: AbilityManagerService NotifyContinuationResultInner
1286 * EnvConditions: NA
1287 * CaseDescription: Verify the function NotifyContinuationResultInner is normal flow.
1288 */
1289 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_NotifyContinuationResultInner_001, TestSize.Level1)
1290 {
1291 MessageParcel data;
1292 MessageParcel reply;
1293 auto res = stub_->NotifyContinuationResultInner(data, reply);
1294 EXPECT_EQ(res, NO_ERROR);
1295 }
1296
1297 /*
1298 * Feature: AbilityManagerService
1299 * Function: LockMissionForCleanupInner
1300 * SubFunction: NA
1301 * FunctionPoints: AbilityManagerService LockMissionForCleanupInner
1302 * EnvConditions: NA
1303 * CaseDescription: Verify the function LockMissionForCleanupInner is normal flow.
1304 */
1305 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_LockMissionForCleanupInner_001, TestSize.Level1)
1306 {
1307 MessageParcel data;
1308 MessageParcel reply;
1309 auto res = stub_->LockMissionForCleanupInner(data, reply);
1310 EXPECT_EQ(res, NO_ERROR);
1311 }
1312
1313 /*
1314 * Feature: AbilityManagerService
1315 * Function: UnlockMissionForCleanupInner
1316 * SubFunction: NA
1317 * FunctionPoints: AbilityManagerService UnlockMissionForCleanupInner
1318 * EnvConditions: NA
1319 * CaseDescription: Verify the function UnlockMissionForCleanupInner is normal flow.
1320 */
1321 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnlockMissionForCleanupInner_001, TestSize.Level1)
1322 {
1323 MessageParcel data;
1324 MessageParcel reply;
1325 auto res = stub_->UnlockMissionForCleanupInner(data, reply);
1326 EXPECT_EQ(res, NO_ERROR);
1327 }
1328
1329 /*
1330 * Feature: AbilityManagerService
1331 * Function: RegisterMissionListenerInner
1332 * SubFunction: NA
1333 * FunctionPoints: AbilityManagerService RegisterMissionListenerInner
1334 * EnvConditions: NA
1335 * CaseDescription: Verify the function RegisterMissionListenerInner is normal flow.
1336 */
1337 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterMissionListenerInner_001, TestSize.Level1)
1338 {
1339 MessageParcel data;
1340 MessageParcel reply;
1341 auto res = stub_->RegisterMissionListenerInner(data, reply);
1342 EXPECT_EQ(res, ERR_INVALID_VALUE);
1343 }
1344
1345 /*
1346 * Feature: AbilityManagerService
1347 * Function: UnRegisterMissionListenerInner
1348 * SubFunction: NA
1349 * FunctionPoints: AbilityManagerService UnRegisterMissionListenerInner
1350 * EnvConditions: NA
1351 * CaseDescription: Verify the function UnRegisterMissionListenerInner is normal flow.
1352 */
1353 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnRegisterMissionListenerInner_001, TestSize.Level1)
1354 {
1355 MessageParcel data;
1356 MessageParcel reply;
1357 auto res = stub_->UnRegisterMissionListenerInner(data, reply);
1358 EXPECT_EQ(res, ERR_INVALID_VALUE);
1359 }
1360
1361 /*
1362 * Feature: AbilityManagerService
1363 * Function: GetMissionInfosInner
1364 * SubFunction: NA
1365 * FunctionPoints: AbilityManagerService GetMissionInfosInner
1366 * EnvConditions: NA
1367 * CaseDescription: Verify the function GetMissionInfosInner is normal flow.
1368 */
1369 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetMissionInfosInner_001, TestSize.Level1)
1370 {
1371 MessageParcel data;
1372 MessageParcel reply;
1373 auto res = stub_->GetMissionInfosInner(data, reply);
1374 EXPECT_EQ(res, NO_ERROR);
1375 }
1376
1377 /*
1378 * Feature: AbilityManagerService
1379 * Function: GetMissionInfoInner
1380 * SubFunction: NA
1381 * FunctionPoints: AbilityManagerService GetMissionInfoInner
1382 * EnvConditions: NA
1383 * CaseDescription: Verify the function GetMissionInfoInner is normal flow.
1384 */
1385 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetMissionInfoInner_001, TestSize.Level1)
1386 {
1387 MessageParcel data;
1388 MessageParcel reply;
1389 auto res = stub_->GetMissionInfoInner(data, reply);
1390 EXPECT_EQ(res, NO_ERROR);
1391 }
1392
1393 /*
1394 * Feature: AbilityManagerService
1395 * Function: CleanMissionInner
1396 * SubFunction: NA
1397 * FunctionPoints: AbilityManagerService CleanMissionInner
1398 * EnvConditions: NA
1399 * CaseDescription: Verify the function CleanMissionInner is normal flow.
1400 */
1401 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CleanMissionInner_001, TestSize.Level1)
1402 {
1403 MessageParcel data;
1404 MessageParcel reply;
1405 auto res = stub_->CleanMissionInner(data, reply);
1406 EXPECT_EQ(res, NO_ERROR);
1407 }
1408
1409 /*
1410 * Feature: AbilityManagerService
1411 * Function: CleanAllMissionsInner
1412 * SubFunction: NA
1413 * FunctionPoints: AbilityManagerService CleanAllMissionsInner
1414 * EnvConditions: NA
1415 * CaseDescription: Verify the function CleanAllMissionsInner is normal flow.
1416 */
1417 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CleanAllMissionsInner_001, TestSize.Level1)
1418 {
1419 MessageParcel data;
1420 MessageParcel reply;
1421 auto res = stub_->CleanAllMissionsInner(data, reply);
1422 EXPECT_EQ(res, NO_ERROR);
1423 }
1424
1425 /*
1426 * Feature: AbilityManagerService
1427 * Function: MoveMissionToFrontInner
1428 * SubFunction: NA
1429 * FunctionPoints: AbilityManagerService MoveMissionToFrontInner
1430 * EnvConditions: NA
1431 * CaseDescription: Verify the function MoveMissionToFrontInner is normal flow.
1432 */
1433 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveMissionToFrontInner_001, TestSize.Level1)
1434 {
1435 MessageParcel data;
1436 MessageParcel reply;
1437 auto res = stub_->MoveMissionToFrontInner(data, reply);
1438 EXPECT_EQ(res, NO_ERROR);
1439 }
1440
1441 /*
1442 * Feature: AbilityManagerService
1443 * Function: MoveMissionsToForegroundInner
1444 * SubFunction: NA
1445 * FunctionPoints: AbilityManagerService MoveMissionsToForegroundInner
1446 * EnvConditions: NA
1447 * CaseDescription: Verify the function MoveMissionsToForegroundInner is normal flow.
1448 */
1449 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveMissionsToForegroundInner_001, TestSize.Level1)
1450 {
1451 HILOG_DEBUG("%{public}s is called.", __func__);
1452 MessageParcel data;
1453 MessageParcel reply;
1454 auto res = stub_->MoveMissionsToForegroundInner(data, reply);
1455 EXPECT_EQ(res, NO_ERROR);
1456 }
1457
1458 /*
1459 * Feature: AbilityManagerService
1460 * Function: MoveMissionsToBackgroundInner
1461 * SubFunction: NA
1462 * FunctionPoints: AbilityManagerService MoveMissionsToBackgroundInner
1463 * EnvConditions: NA
1464 * CaseDescription: Verify the function MoveMissionsToBackgroundInner is normal flow.
1465 */
1466 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveMissionsToBackgroundInner_001, TestSize.Level1)
1467 {
1468 HILOG_DEBUG("%{public}s is called.", __func__);
1469 MessageParcel data;
1470 MessageParcel reply;
1471 auto res = stub_->MoveMissionsToBackgroundInner(data, reply);
1472 EXPECT_EQ(res, NO_ERROR);
1473 }
1474
1475 /*
1476 * Feature: AbilityManagerService
1477 * Function: GetMissionIdByTokenInner
1478 * SubFunction: NA
1479 * FunctionPoints: AbilityManagerService GetMissionIdByTokenInner
1480 * EnvConditions: NA
1481 * CaseDescription: Verify the function GetMissionIdByTokenInner is normal flow.
1482 */
1483 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetMissionIdByTokenInner_001, TestSize.Level1)
1484 {
1485 MessageParcel data;
1486 MessageParcel reply;
1487 auto res = stub_->GetMissionIdByTokenInner(data, reply);
1488 EXPECT_EQ(res, NO_ERROR);
1489 }
1490
1491 /*
1492 * Feature: AbilityManagerService
1493 * Function: MoveMissionToFrontByOptionsInner
1494 * SubFunction: NA
1495 * FunctionPoints: AbilityManagerService MoveMissionToFrontByOptionsInner
1496 * EnvConditions: NA
1497 * CaseDescription: Verify the function MoveMissionToFrontByOptionsInner is normal flow.
1498 */
1499 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveMissionToFrontByOptionsInner_001, TestSize.Level1)
1500 {
1501 MessageParcel data;
1502 MessageParcel reply;
1503 auto res = stub_->MoveMissionToFrontByOptionsInner(data, reply);
1504 EXPECT_EQ(res, ERR_INVALID_VALUE);
1505 }
1506
1507 /*
1508 * Feature: AbilityManagerService
1509 * Function: StartAbilityByCallInner
1510 * SubFunction: NA
1511 * FunctionPoints: AbilityManagerService StartAbilityByCallInner
1512 * EnvConditions: NA
1513 * CaseDescription: Verify the function StartAbilityByCallInner is normal flow.
1514 */
1515 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityByCallInner_001, TestSize.Level1)
1516 {
1517 MessageParcel data;
1518 MessageParcel reply;
1519 auto res = stub_->StartAbilityByCallInner(data, reply);
1520 EXPECT_EQ(res, ERR_INVALID_VALUE);
1521 }
1522
1523 /*
1524 * Feature: AbilityManagerService
1525 * Function: ReleaseCallInner
1526 * SubFunction: NA
1527 * FunctionPoints: AbilityManagerService ReleaseCallInner
1528 * EnvConditions: NA
1529 * CaseDescription: Verify the function ReleaseCallInner is normal flow.
1530 */
1531 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ReleaseCallInner_001, TestSize.Level1)
1532 {
1533 MessageParcel data;
1534 MessageParcel reply;
1535 auto res = stub_->ReleaseCallInner(data, reply);
1536 EXPECT_EQ(res, ERR_INVALID_VALUE);
1537 }
1538
1539 /*
1540 * Feature: AbilityManagerService
1541 * Function: StartUserInner
1542 * SubFunction: NA
1543 * FunctionPoints: AbilityManagerService StartUserInner
1544 * EnvConditions: NA
1545 * CaseDescription: Verify the function StartUserInner is normal flow.
1546 */
1547 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUserInner_001, TestSize.Level1)
1548 {
1549 MessageParcel data;
1550 MessageParcel reply;
1551 auto res = stub_->StartUserInner(data, reply);
1552 EXPECT_EQ(res, NO_ERROR);
1553 }
1554
1555 /*
1556 * Feature: AbilityManagerService
1557 * Function: StopUserInner
1558 * SubFunction: NA
1559 * FunctionPoints: AbilityManagerService StopUserInner
1560 * EnvConditions: NA
1561 * CaseDescription: Verify the function StopUserInner is normal flow.
1562 */
1563 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StopUserInner_001, TestSize.Level1)
1564 {
1565 MessageParcel data;
1566 MessageParcel reply;
1567 auto res = stub_->StopUserInner(data, reply);
1568 EXPECT_EQ(res, NO_ERROR);
1569 }
1570
1571 /*
1572 * Feature: AbilityManagerService
1573 * Function: GetAbilityRunningInfosInner
1574 * SubFunction: NA
1575 * FunctionPoints: AbilityManagerService GetAbilityRunningInfosInner
1576 * EnvConditions: NA
1577 * CaseDescription: Verify the function GetAbilityRunningInfosInner is normal flow.
1578 */
1579 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetAbilityRunningInfosInner_001, TestSize.Level1)
1580 {
1581 MessageParcel data;
1582 MessageParcel reply;
1583 auto res = stub_->GetAbilityRunningInfosInner(data, reply);
1584 EXPECT_EQ(res, NO_ERROR);
1585 }
1586
1587 /*
1588 * Feature: AbilityManagerService
1589 * Function: GetExtensionRunningInfosInner
1590 * SubFunction: NA
1591 * FunctionPoints: AbilityManagerService GetExtensionRunningInfosInner
1592 * EnvConditions: NA
1593 * CaseDescription: Verify the function GetExtensionRunningInfosInner is normal flow.
1594 */
1595 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetExtensionRunningInfosInner_001, TestSize.Level1)
1596 {
1597 MessageParcel data;
1598 MessageParcel reply;
1599 auto res = stub_->GetExtensionRunningInfosInner(data, reply);
1600 EXPECT_EQ(res, NO_ERROR);
1601 }
1602
1603 /*
1604 * Feature: AbilityManagerService
1605 * Function: GetProcessRunningInfosInner
1606 * SubFunction: NA
1607 * FunctionPoints: AbilityManagerService GetProcessRunningInfosInner
1608 * EnvConditions: NA
1609 * CaseDescription: Verify the function GetProcessRunningInfosInner is normal flow.
1610 */
1611 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetProcessRunningInfosInner_001, TestSize.Level1)
1612 {
1613 MessageParcel data;
1614 MessageParcel reply;
1615 auto res = stub_->GetProcessRunningInfosInner(data, reply);
1616 EXPECT_EQ(res, NO_ERROR);
1617 }
1618
1619 /*
1620 * Feature: AbilityManagerService
1621 * Function: StartSyncRemoteMissionsInner
1622 * SubFunction: NA
1623 * FunctionPoints: AbilityManagerService StartSyncRemoteMissionsInner
1624 * EnvConditions: NA
1625 * CaseDescription: Verify the function StartSyncRemoteMissionsInner is normal flow.
1626 */
1627 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartSyncRemoteMissionsInner_001, TestSize.Level1)
1628 {
1629 MessageParcel data;
1630 MessageParcel reply;
1631 auto res = stub_->StartSyncRemoteMissionsInner(data, reply);
1632 EXPECT_EQ(res, NO_ERROR);
1633 }
1634
1635 /*
1636 * Feature: AbilityManagerService
1637 * Function: StopSyncRemoteMissionsInner
1638 * SubFunction: NA
1639 * FunctionPoints: AbilityManagerService StopSyncRemoteMissionsInner
1640 * EnvConditions: NA
1641 * CaseDescription: Verify the function StopSyncRemoteMissionsInner is normal flow.
1642 */
1643 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StopSyncRemoteMissionsInner_001, TestSize.Level1)
1644 {
1645 MessageParcel data;
1646 MessageParcel reply;
1647 auto res = stub_->StopSyncRemoteMissionsInner(data, reply);
1648 EXPECT_EQ(res, NO_ERROR);
1649 }
1650
1651 /*
1652 * Feature: AbilityManagerService
1653 * Function: RegisterRemoteMissionListenerInner
1654 * SubFunction: NA
1655 * FunctionPoints: AbilityManagerService RegisterRemoteMissionListenerInner
1656 * EnvConditions: NA
1657 * CaseDescription: Verify the function RegisterRemoteMissionListenerInner is normal flow.
1658 */
1659 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterRemoteMissionListenerInner_001, TestSize.Level1)
1660 {
1661 MessageParcel data;
1662 MessageParcel reply;
1663 auto res = stub_->RegisterRemoteMissionListenerInner(data, reply);
1664 EXPECT_EQ(res, ERR_NULL_OBJECT);
1665 }
1666
1667 /*
1668 * Feature: AbilityManagerService
1669 * Function: UnRegisterRemoteMissionListenerInner
1670 * SubFunction: NA
1671 * FunctionPoints: AbilityManagerService UnRegisterRemoteMissionListenerInner
1672 * EnvConditions: NA
1673 * CaseDescription: Verify the function UnRegisterRemoteMissionListenerInner is normal flow.
1674 */
1675 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnRegisterRemoteMissionListenerInner_001, TestSize.Level1)
1676 {
1677 MessageParcel data;
1678 MessageParcel reply;
1679 auto res = stub_->UnRegisterRemoteMissionListenerInner(data, reply);
1680 EXPECT_EQ(res, ERR_NULL_OBJECT);
1681 }
1682
1683 /*
1684 * Feature: AbilityManagerService
1685 * Function: RegisterRemoteOnListenerInner
1686 * SubFunction: NA
1687 * FunctionPoints: AbilityManagerService RegisterRemoteOnListenerInner
1688 * EnvConditions: NA
1689 * CaseDescription: Verify the function RegisterRemoteOnListenerInner is normal flow.
1690 */
1691 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterRemoteOnListenerInner_001, TestSize.Level1)
1692 {
1693 MessageParcel data;
1694 MessageParcel reply;
1695 auto res = stub_->RegisterRemoteOnListenerInner(data, reply);
1696 EXPECT_EQ(res, ERR_NULL_OBJECT);
1697 }
1698
1699 /*
1700 * Feature: AbilityManagerService
1701 * Function: RegisterRemoteOffListenerInner
1702 * SubFunction: NA
1703 * FunctionPoints: AbilityManagerService RegisterRemoteOffListenerInner
1704 * EnvConditions: NA
1705 * CaseDescription: Verify the function RegisterRemoteOffListenerInner is normal flow.
1706 */
1707 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterRemoteOffListenerInner_001, TestSize.Level1)
1708 {
1709 MessageParcel data;
1710 MessageParcel reply;
1711 auto res = stub_->RegisterRemoteOffListenerInner(data, reply);
1712 EXPECT_EQ(res, ERR_NULL_OBJECT);
1713 }
1714
1715 /*
1716 * Feature: AbilityManagerService
1717 * Function: RegisterSnapshotHandlerInner
1718 * SubFunction: NA
1719 * FunctionPoints: AbilityManagerService RegisterSnapshotHandlerInner
1720 * EnvConditions: NA
1721 * CaseDescription: Verify the function RegisterSnapshotHandlerInner is normal flow.
1722 */
1723 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterSnapshotHandlerInner_001, TestSize.Level1)
1724 {
1725 MessageParcel data;
1726 MessageParcel reply;
1727 auto res = stub_->RegisterSnapshotHandlerInner(data, reply);
1728 EXPECT_EQ(res, ERR_NULL_OBJECT);
1729 }
1730
1731 /*
1732 * Feature: AbilityManagerService
1733 * Function: GetMissionSnapshotInfoInner
1734 * SubFunction: NA
1735 * FunctionPoints: AbilityManagerService GetMissionSnapshotInfoInner
1736 * EnvConditions: NA
1737 * CaseDescription: Verify the function GetMissionSnapshotInfoInner is normal flow.
1738 */
1739 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetMissionSnapshotInfoInner_001, TestSize.Level1)
1740 {
1741 MessageParcel data;
1742 MessageParcel reply;
1743 auto res = stub_->GetMissionSnapshotInfoInner(data, reply);
1744 EXPECT_EQ(res, NO_ERROR);
1745 }
1746
1747 /*
1748 * Feature: AbilityManagerService
1749 * Function: SetAbilityControllerInner
1750 * SubFunction: NA
1751 * FunctionPoints: AbilityManagerService SetAbilityControllerInner
1752 * EnvConditions: NA
1753 * CaseDescription: Verify the function SetAbilityControllerInner is normal flow.
1754 */
1755 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetAbilityControllerInner_001, TestSize.Level1)
1756 {
1757 MessageParcel data;
1758 MessageParcel reply;
1759 auto res = stub_->SetAbilityControllerInner(data, reply);
1760 EXPECT_EQ(res, ERR_NULL_OBJECT);
1761 }
1762
1763 /*
1764 * Feature: AbilityManagerService
1765 * Function: IsRunningInStabilityTestInner
1766 * SubFunction: NA
1767 * FunctionPoints: AbilityManagerService IsRunningInStabilityTestInner
1768 * EnvConditions: NA
1769 * CaseDescription: Verify the function IsRunningInStabilityTestInner is normal flow.
1770 */
1771 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsRunningInStabilityTestInner_001, TestSize.Level1)
1772 {
1773 MessageParcel data;
1774 MessageParcel reply;
1775 auto res = stub_->IsRunningInStabilityTestInner(data, reply);
1776 EXPECT_EQ(res, NO_ERROR);
1777 }
1778
1779 /*
1780 * Feature: AbilityManagerService
1781 * Function: StartUserTestInner
1782 * SubFunction: NA
1783 * FunctionPoints: AbilityManagerService StartUserTestInner
1784 * EnvConditions: NA
1785 * CaseDescription: Verify the function StartUserTestInner is normal flow.
1786 */
1787 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUserTestInner_001, TestSize.Level1)
1788 {
1789 MessageParcel data;
1790 MessageParcel reply;
1791 auto res = stub_->StartUserTestInner(data, reply);
1792 EXPECT_EQ(res, ERR_INVALID_VALUE);
1793 }
1794
1795 /*
1796 * Feature: AbilityManagerService
1797 * Function: FinishUserTestInner
1798 * SubFunction: NA
1799 * FunctionPoints: AbilityManagerService FinishUserTestInner
1800 * EnvConditions: NA
1801 * CaseDescription: Verify the function FinishUserTestInner is normal flow.
1802 */
1803 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_FinishUserTestInner_001, TestSize.Level1)
1804 {
1805 MessageParcel data;
1806 MessageParcel reply;
1807 auto res = stub_->FinishUserTestInner(data, reply);
1808 EXPECT_EQ(res, NO_ERROR);
1809 }
1810
1811 /*
1812 * Feature: AbilityManagerService
1813 * Function: GetTopAbilityTokenInner
1814 * SubFunction: NA
1815 * FunctionPoints: AbilityManagerService GetTopAbilityTokenInner
1816 * EnvConditions: NA
1817 * CaseDescription: Verify the function GetTopAbilityTokenInner is normal flow.
1818 */
1819 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetTopAbilityTokenInner_001, TestSize.Level1)
1820 {
1821 MessageParcel data;
1822 MessageParcel reply;
1823 auto res = stub_->GetTopAbilityTokenInner(data, reply);
1824 EXPECT_EQ(res, ERR_INVALID_VALUE);
1825 }
1826
1827 /*
1828 * Feature: AbilityManagerStub
1829 * Function: CheckUIExtensionIsFocusedInner
1830 * SubFunction: NA
1831 * FunctionPoints: AbilityManagerService CheckUIExtensionIsFocusedInner
1832 * EnvConditions: NA
1833 * CaseDescription: Verify the function CheckUIExtensionIsFocused is normal flow.
1834 */
1835 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CheckUIExtensionIsFocusedInner_001, TestSize.Level1)
1836 {
1837 MessageParcel data;
1838 MessageParcel reply;
1839 auto res = stub_->CheckUIExtensionIsFocusedInner(data, reply);
1840 EXPECT_EQ(res, NO_ERROR);
1841 }
1842
1843
1844 /*
1845 * Feature: AbilityManagerService
1846 * Function: DelegatorDoAbilityForegroundInner
1847 * SubFunction: NA
1848 * FunctionPoints: AbilityManagerService DelegatorDoAbilityForegroundInner
1849 * EnvConditions: NA
1850 * CaseDescription: Verify the function DelegatorDoAbilityForegroundInner is normal flow.
1851 */
1852 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DelegatorDoAbilityForegroundInner_001, TestSize.Level1)
1853 {
1854 MessageParcel data;
1855 MessageParcel reply;
1856 auto res = stub_->DelegatorDoAbilityForegroundInner(data, reply);
1857 EXPECT_EQ(res, NO_ERROR);
1858 }
1859
1860 /*
1861 * Feature: AbilityManagerService
1862 * Function: DelegatorDoAbilityBackgroundInner
1863 * SubFunction: NA
1864 * FunctionPoints: AbilityManagerService DelegatorDoAbilityBackgroundInner
1865 * EnvConditions: NA
1866 * CaseDescription: Verify the function DelegatorDoAbilityBackgroundInner is normal flow.
1867 */
1868 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DelegatorDoAbilityBackgroundInner_001, TestSize.Level1)
1869 {
1870 MessageParcel data;
1871 MessageParcel reply;
1872 auto res = stub_->DelegatorDoAbilityBackgroundInner(data, reply);
1873 EXPECT_EQ(res, NO_ERROR);
1874 }
1875
1876 /*
1877 * Feature: AbilityManagerService
1878 * Function: DoAbilityForeground
1879 * SubFunction: NA
1880 * FunctionPoints: AbilityManagerService DoAbilityForeground
1881 * EnvConditions: NA
1882 * CaseDescription: Verify the function DoAbilityForeground is normal flow.
1883 */
1884 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DoAbilityForeground_001, TestSize.Level1)
1885 {
1886 sptr<IRemoteObject> token = nullptr;
1887 uint32_t flag = 0;
1888 auto res = stub_->DoAbilityForeground(token, flag);
1889 EXPECT_EQ(res, 0);
1890 }
1891
1892 /*
1893 * Feature: AbilityManagerService
1894 * Function: DoAbilityBackground
1895 * SubFunction: NA
1896 * FunctionPoints: AbilityManagerService DoAbilityBackground
1897 * EnvConditions: NA
1898 * CaseDescription: Verify the function DoAbilityBackground is normal flow.
1899 */
1900 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DoAbilityBackground_001, TestSize.Level1)
1901 {
1902 sptr<IRemoteObject> token = nullptr;
1903 uint32_t flag = 0;
1904 auto res = stub_->DoAbilityBackground(token, flag);
1905 EXPECT_EQ(res, 0);
1906 }
1907
1908 /*
1909 * Feature: AbilityManagerService
1910 * Function: DoAbilityForegroundInner
1911 * SubFunction: NA
1912 * FunctionPoints: AbilityManagerService DoAbilityForegroundInner
1913 * EnvConditions: NA
1914 * CaseDescription: Verify the function DoAbilityForegroundInner is normal flow.
1915 */
1916 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DoAbilityForegroundInner_001, TestSize.Level1)
1917 {
1918 MessageParcel data;
1919 MessageParcel reply;
1920 auto res = stub_->DoAbilityForegroundInner(data, reply);
1921 EXPECT_EQ(res, NO_ERROR);
1922 }
1923
1924 /*
1925 * Feature: AbilityManagerService
1926 * Function: DoAbilityBackgroundInner
1927 * SubFunction: NA
1928 * FunctionPoints: AbilityManagerService DoAbilityBackgroundInner
1929 * EnvConditions: NA
1930 * CaseDescription: Verify the function DoAbilityBackgroundInner is normal flow.
1931 */
1932 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DoAbilityBackgroundInner_001, TestSize.Level1)
1933 {
1934 MessageParcel data;
1935 MessageParcel reply;
1936 auto res = stub_->DoAbilityBackgroundInner(data, reply);
1937 EXPECT_EQ(res, NO_ERROR);
1938 }
1939
1940 /*
1941 * Feature: AbilityManagerService
1942 * Function: SendANRProcessIDInner
1943 * SubFunction: NA
1944 * FunctionPoints: AbilityManagerService SendANRProcessIDInner
1945 * EnvConditions: NA
1946 * CaseDescription: Verify the function SendANRProcessIDInner is normal flow.
1947 */
1948 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SendANRProcessIDInner_001, TestSize.Level1)
1949 {
1950 MessageParcel data;
1951 MessageParcel reply;
1952 auto res = stub_->SendANRProcessIDInner(data, reply);
1953 EXPECT_EQ(res, NO_ERROR);
1954 }
1955
1956 /*
1957 * Feature: AbilityManagerService
1958 * Function: RegisterObserver
1959 * SubFunction: NA
1960 * FunctionPoints: AbilityManagerService RegisterObserver
1961 * EnvConditions: NA
1962 * CaseDescription: Verify the function RegisterObserver is normal flow.
1963 */
1964 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterObserver_001, TestSize.Level1)
1965 {
1966 sptr<AbilityRuntime::IConnectionObserver> observer = nullptr;
1967 auto res = stub_->RegisterObserver(observer);
1968 EXPECT_EQ(res, NO_ERROR);
1969 }
1970
1971 /*
1972 * Feature: AbilityManagerService
1973 * Function: UnregisterObserver
1974 * SubFunction: NA
1975 * FunctionPoints: AbilityManagerService UnregisterObserver
1976 * EnvConditions: NA
1977 * CaseDescription: Verify the function UnregisterObserver is normal flow.
1978 */
1979 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterObserver_001, TestSize.Level1)
1980 {
1981 sptr<AbilityRuntime::IConnectionObserver> observer = nullptr;
1982 auto res = stub_->UnregisterObserver(observer);
1983 EXPECT_EQ(res, NO_ERROR);
1984 }
1985
1986 /*
1987 * Feature: AbilityManagerService
1988 * Function: GetDlpConnectionInfos
1989 * SubFunction: NA
1990 * FunctionPoints: AbilityManagerService GetDlpConnectionInfos
1991 * EnvConditions: NA
1992 * CaseDescription: Verify the function GetDlpConnectionInfos is normal flow.
1993 */
1994 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetDlpConnectionInfos_001, TestSize.Level1)
1995 {
1996 std::vector<AbilityRuntime::DlpConnectionInfo> infos;
1997 auto res = stub_->GetDlpConnectionInfos(infos);
1998 EXPECT_EQ(res, NO_ERROR);
1999 }
2000
2001 #ifdef ABILITY_COMMAND_FOR_TEST
2002 /*
2003 * Feature: AbilityManagerService
2004 * Function: ForceTimeoutForTestInner
2005 * SubFunction: NA
2006 * FunctionPoints: AbilityManagerService ForceTimeoutForTestInner
2007 * EnvConditions: NA
2008 * CaseDescription: Verify the function ForceTimeoutForTestInner is normal flow.
2009 */
2010 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ForceTimeoutForTestInner_001, TestSize.Level1)
2011 {
2012 MessageParcel data;
2013 MessageParcel reply;
2014 auto res = stub_->ForceTimeoutForTestInner(data, reply);
2015 EXPECT_EQ(res, NO_ERROR);
2016 }
2017 #endif
2018
2019 #ifdef ABILITY_COMMAND_FOR_TEST
2020 /*
2021 * Feature: AbilityManagerService
2022 * Function: BlockAbilityInner
2023 * SubFunction: NA
2024 * FunctionPoints: AbilityManagerService BlockAbilityInner
2025 * EnvConditions: NA
2026 * CaseDescription: Verify the function BlockAbilityInner is normal flow.
2027 */
2028 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_BlockAbilityInner_001, TestSize.Level1)
2029 {
2030 MessageParcel data;
2031 MessageParcel reply;
2032 auto res = stub_->BlockAbilityInner(data, reply);
2033 EXPECT_EQ(res, NO_ERROR);
2034 }
2035 #endif
2036
2037 #ifdef ABILITY_COMMAND_FOR_TEST
2038 /*
2039 * Feature: AbilityManagerService
2040 * Function: BlockAmsServiceInner
2041 * SubFunction: NA
2042 * FunctionPoints: AbilityManagerService BlockAmsServiceInner
2043 * EnvConditions: NA
2044 * CaseDescription: Verify the function BlockAmsServiceInner is normal flow.
2045 */
2046 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_BlockAmsServiceInner_001, TestSize.Level1)
2047 {
2048 MessageParcel data;
2049 MessageParcel reply;
2050 auto res = stub_->BlockAmsServiceInner(data, reply);
2051 EXPECT_EQ(res, NO_ERROR);
2052 }
2053 #endif
2054
2055 #ifdef ABILITY_COMMAND_FOR_TEST
2056 /*
2057 * Feature: AbilityManagerService
2058 * Function: BlockAppServiceInner
2059 * SubFunction: NA
2060 * FunctionPoints: AbilityManagerService BlockAppServiceInner
2061 * EnvConditions: NA
2062 * CaseDescription: Verify the function BlockAppServiceInner is normal flow.
2063 */
2064 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_BlockAppServiceInner_001, TestSize.Level1)
2065 {
2066 MessageParcel data;
2067 MessageParcel reply;
2068 auto res = stub_->BlockAppServiceInner(data, reply);
2069 EXPECT_EQ(res, NO_ERROR);
2070 }
2071 #endif
2072
2073 /*
2074 * Feature: AbilityManagerService
2075 * Function: FreeInstallAbilityFromRemoteInner
2076 * SubFunction: NA
2077 * FunctionPoints: AbilityManagerService FreeInstallAbilityFromRemoteInner
2078 * EnvConditions: NA
2079 * CaseDescription: Verify the function FreeInstallAbilityFromRemoteInner is normal flow.
2080 */
2081 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_FreeInstallAbilityFromRemoteInner_001, TestSize.Level1)
2082 {
2083 MessageParcel data;
2084 MessageParcel reply;
2085 auto res = stub_->FreeInstallAbilityFromRemoteInner(data, reply);
2086 EXPECT_EQ(res, ERR_INVALID_VALUE);
2087 }
2088
2089 /*
2090 * Feature: AbilityManagerService
2091 * Function: DumpAbilityInfoDoneInner
2092 * SubFunction: NA
2093 * FunctionPoints: AbilityManagerService DumpAbilityInfoDoneInner
2094 * EnvConditions: NA
2095 * CaseDescription: Verify the function DumpAbilityInfoDoneInner is normal flow.
2096 */
2097 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DumpAbilityInfoDoneInner_001, TestSize.Level1)
2098 {
2099 MessageParcel data;
2100 MessageParcel reply;
2101 auto res = stub_->DumpAbilityInfoDoneInner(data, reply);
2102 EXPECT_EQ(res, NO_ERROR);
2103 }
2104
2105 /**
2106 * @tc.number: HandleReportDrawnCompleted_001
2107 * @tc.name: HandleReportDrawnCompleted
2108 * @tc.desc: Returns ERR_INVALID_VALUE after passing in parameters
2109 */
2110 HWTEST_F(AbilityManagerStubTest, HandleReportDrawnCompleted_001, TestSize.Level1)
2111 {
2112 MessageParcel data;
2113 MessageParcel reply;
2114 auto res = stub_->HandleReportDrawnCompleted(data, reply);
2115 EXPECT_EQ(res, ERR_INVALID_VALUE);
2116 }
2117
2118 #ifdef ABILITY_COMMAND_FOR_TEST
2119 /*
2120 * Feature: AbilityManagerService
2121 * Function: ScheduleRecoverAbilityInner
2122 * SubFunction: NA
2123 * FunctionPoints: AbilityManagerService ScheduleRecoverAbilityInner
2124 * EnvConditions: NA
2125 * CaseDescription: Verify the function ScheduleRecoverAbilityInner is normal flow.
2126 */
2127 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ScheduleRecoverAbilityInner_001, TestSize.Level1)
2128 {
2129 MessageParcel data;
2130 MessageParcel reply;
2131 auto res = stub_->ScheduleRecoverAbilityInner(data, reply);
2132 EXPECT_EQ(res, ERR_NULL_OBJECT);
2133 }
2134 #endif
2135
2136 #ifdef ABILITY_COMMAND_FOR_TEST
2137 /*
2138 * Feature: AbilityManagerService
2139 * Function: EnableRecoverAbilityInner
2140 * SubFunction: NA
2141 * FunctionPoints: AbilityManagerService EnableRecoverAbilityInner
2142 * EnvConditions: NA
2143 * CaseDescription: Verify the function EnableRecoverAbilityInner is normal flow.
2144 */
2145 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_EnableRecoverAbilityInner_001, TestSize.Level1)
2146 {
2147 MessageParcel data;
2148 MessageParcel reply;
2149 auto res = stub_->EnableRecoverAbilityInner(data, reply);
2150 EXPECT_EQ(res, ERR_NULL_OBJECT);
2151 }
2152 #endif
2153
2154 /*
2155 * Feature: AbilityManagerService
2156 * Function: RegisterConnectionObserverInner
2157 * SubFunction: NA
2158 * FunctionPoints: AbilityManagerService RegisterConnectionObserverInner
2159 * EnvConditions: NA
2160 * CaseDescription: Verify the function RegisterConnectionObserverInner is normal flow.
2161 */
2162 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterConnectionObserverInner_001, TestSize.Level1)
2163 {
2164 MessageParcel data;
2165 MessageParcel reply;
2166 auto res = stub_->RegisterConnectionObserverInner(data, reply);
2167 EXPECT_EQ(res, ERR_NULL_OBJECT);
2168 }
2169
2170 /*
2171 * Feature: AbilityManagerService
2172 * Function: UnregisterConnectionObserverInner
2173 * SubFunction: NA
2174 * FunctionPoints: AbilityManagerService UnregisterConnectionObserverInner
2175 * EnvConditions: NA
2176 * CaseDescription: Verify the function UnregisterConnectionObserverInner is normal flow.
2177 */
2178 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterConnectionObserverInner_001, TestSize.Level1)
2179 {
2180 MessageParcel data;
2181 MessageParcel reply;
2182 auto res = stub_->UnregisterConnectionObserverInner(data, reply);
2183 EXPECT_EQ(res, ERR_NULL_OBJECT);
2184 }
2185
2186 /*
2187 * Feature: AbilityManagerService
2188 * Function: GetDlpConnectionInfosInner
2189 * SubFunction: NA
2190 * FunctionPoints: AbilityManagerService GetDlpConnectionInfosInner
2191 * EnvConditions: NA
2192 * CaseDescription: Verify the function GetDlpConnectionInfosInner is normal flow.
2193 */
2194 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetDlpConnectionInfosInner_001, TestSize.Level1)
2195 {
2196 MessageParcel data;
2197 MessageParcel reply;
2198 auto res = stub_->GetDlpConnectionInfosInner(data, reply);
2199 EXPECT_EQ(res, ERR_OK);
2200 }
2201
2202 /*
2203 * Feature: AbilityManagerService
2204 * Function: SetMissionContinueStateInner
2205 * SubFunction: NA
2206 * FunctionPoints: AbilityManagerService SetMissionContinueStateInner
2207 * EnvConditions: NA
2208 * CaseDescription: Verify the function SetMissionContinueStateInner is normal flow.
2209 */
2210 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetMissionContinueStateInner_001, TestSize.Level1)
2211 {
2212 MessageParcel data;
2213 MessageParcel reply;
2214 auto res = stub_->SetMissionContinueStateInner(data, reply);
2215 EXPECT_EQ(res, ERR_NULL_OBJECT);
2216 }
2217
2218 /*
2219 * Feature: AbilityManagerService
2220 * Function: SetMissionLabelInner
2221 * SubFunction: NA
2222 * FunctionPoints: AbilityManagerService SetMissionLabelInner
2223 * EnvConditions: NA
2224 * CaseDescription: Verify the function SetMissionLabelInner is normal flow.
2225 */
2226 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetMissionLabelInner_001, TestSize.Level1)
2227 {
2228 MessageParcel data;
2229 MessageParcel reply;
2230 auto res = stub_->SetMissionLabelInner(data, reply);
2231 EXPECT_EQ(res, ERR_NULL_OBJECT);
2232 }
2233
2234 /*
2235 * Feature: AbilityManagerService
2236 * Function: SetMissionIconInner
2237 * SubFunction: NA
2238 * FunctionPoints: AbilityManagerService SetMissionIconInner
2239 * EnvConditions: NA
2240 * CaseDescription: Verify the function SetMissionIconInner is normal flow.
2241 */
2242 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetMissionIconInner_001, TestSize.Level1)
2243 {
2244 MessageParcel data;
2245 MessageParcel reply;
2246 auto res = stub_->SetMissionIconInner(data, reply);
2247 EXPECT_EQ(res, ERR_NULL_OBJECT);
2248 }
2249
2250 /*
2251 * Feature: AbilityManagerService
2252 * Function: RegisterWindowManagerServiceHandlerInner
2253 * SubFunction: NA
2254 * FunctionPoints: AbilityManagerService RegisterWindowManagerServiceHandlerInner
2255 * EnvConditions: NA
2256 * CaseDescription: Verify the function RegisterWindowManagerServiceHandlerInner is normal flow.
2257 */
2258 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterWindowManagerServiceHandlerInner_001, TestSize.Level1)
2259 {
2260 MessageParcel data;
2261 MessageParcel reply;
2262 auto res = stub_->RegisterWindowManagerServiceHandlerInner(data, reply);
2263 EXPECT_EQ(res, ERR_NULL_OBJECT);
2264 }
2265
2266 /*
2267 * Feature: AbilityManagerService
2268 * Function: CompleteFirstFrameDrawingInner
2269 * SubFunction: NA
2270 * FunctionPoints: AbilityManagerService CompleteFirstFrameDrawingInner
2271 * EnvConditions: NA
2272 * CaseDescription: Verify the function CompleteFirstFrameDrawingInner is normal flow.
2273 */
2274 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CompleteFirstFrameDrawingInner_001, TestSize.Level1)
2275 {
2276 MessageParcel data;
2277 MessageParcel reply;
2278 auto res = stub_->CompleteFirstFrameDrawingInner(data, reply);
2279 EXPECT_EQ(res, ERR_NULL_OBJECT);
2280 }
2281
2282 /*
2283 * Feature: AbilityManagerService
2284 * Function: CallRequestDone
2285 * SubFunction: NA
2286 * FunctionPoints: AbilityManagerService CallRequestDone
2287 * EnvConditions: NA
2288 * CaseDescription: Verify the function CallRequestDone is normal flow.
2289 */
2290 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CallRequestDone_001, TestSize.Level1)
2291 {
2292 sptr<IRemoteObject> token = nullptr;
2293 sptr<IRemoteObject> callStub = nullptr;
2294 stub_->CallRequestDone(token, callStub);
2295 EXPECT_TRUE(true);
2296 }
2297
2298 /*
2299 * Feature: AbilityManagerService
2300 * Function: IsValidMissionIdsInner
2301 * SubFunction: NA
2302 * FunctionPoints: AbilityManagerService IsValidMissionIdsInner
2303 * EnvConditions: NA
2304 * CaseDescription: Verify the function IsValidMissionIdsInner is normal flow.
2305 */
2306 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsValidMissionIdsInner_001, TestSize.Level1)
2307 {
2308 MessageParcel data;
2309 MessageParcel reply;
__anonacefc9510202(const std::vector<int32_t>& ids, std::vector<MissionVaildResult>& results) 2310 auto isValidMissionIdsTask = [&](const std::vector<int32_t>& ids, std::vector<MissionVaildResult>& results) {
2311 MissionVaildResult result;
2312 result.missionId = 1;
2313 result.isVaild = true;
2314 results.push_back(result);
2315 return ERR_OK;
2316 };
2317 EXPECT_CALL(*stub_, IsValidMissionIds(_, _)).Times(1).WillOnce(testing::Invoke(isValidMissionIdsTask));
2318 EXPECT_EQ(stub_->IsValidMissionIdsInner(data, reply), NO_ERROR);
2319 }
2320
2321 /*
2322 * Feature: AbilityManagerService
2323 * Function: IsValidMissionIdsInner
2324 * SubFunction: NA
2325 * FunctionPoints: AbilityManagerService IsValidMissionIdsInner
2326 * EnvConditions: NA
2327 * CaseDescription: Verify the function IsValidMissionIdsInner is normal flow.
2328 */
2329 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsValidMissionIdsInner_002, TestSize.Level1)
2330 {
2331 MessageParcel data;
2332 MessageParcel reply;
__anonacefc9510302(const std::vector<int32_t>& ids, std::vector<MissionVaildResult>& results) 2333 auto isValidMissionIdsTask = [&](const std::vector<int32_t>& ids, std::vector<MissionVaildResult>& results) {
2334 GTEST_LOG_(INFO) << "AbilityManagerStub_IsValidMissionIdsInner_002 caller";
2335 return ERR_INVALID_VALUE;
2336 };
2337 EXPECT_CALL(*stub_, IsValidMissionIds(_, _)).Times(1).WillOnce(testing::Invoke(isValidMissionIdsTask));
2338 EXPECT_EQ(stub_->IsValidMissionIdsInner(data, reply), NO_ERROR);
2339 }
2340 } // namespace AAFwk
2341 } // namespace OHOS
2342