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