1 /*
2  * Copyright (c) 2021-2024 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #include <gtest/gtest.h>
17 #include "ability_manager_stub_impl_mock.h"
18 #include "ability_scheduler.h"
19 #include "app_debug_listener_stub_mock.h"
20 #include "hilog_tag_wrapper.h"
21 #include "iremote_proxy.h"
22 #include "mock_ability_connect_callback.h"
23 #include "mock_ability_token.h"
24 
25 using namespace testing::ext;
26 using namespace testing;
27 
28 namespace OHOS {
29 namespace AAFwk {
30 namespace {
31 const int USER_ID = 100;
32 }  // namespace
33 
34 class AbilityManagerStubTest : public testing::Test {
35 public:
36     static void SetUpTestCase(void);
37     static void TearDownTestCase(void);
38     void SetUp();
39     void TearDown();
40     void WriteInterfaceToken(MessageParcel& data);
41     sptr<AbilityManagerStubImplMock> stub_{ nullptr };
42 };
43 
SetUpTestCase(void)44 void AbilityManagerStubTest::SetUpTestCase(void)
45 {}
TearDownTestCase(void)46 void AbilityManagerStubTest::TearDownTestCase(void)
47 {}
TearDown()48 void AbilityManagerStubTest::TearDown()
49 {}
50 
SetUp()51 void AbilityManagerStubTest::SetUp()
52 {
53     stub_ = new AbilityManagerStubImplMock();
54 }
55 
WriteInterfaceToken(MessageParcel & data)56 void AbilityManagerStubTest::WriteInterfaceToken(MessageParcel& data)
57 {
58     data.WriteInterfaceToken(AbilityManagerStub::GetDescriptor());
59 }
60 
61 /**
62  * @tc.name: AbilityManagerStub_DumpSysStateInner_0100
63  * @tc.desc: DumpSysStateInner
64  * @tc.type: FUNC
65  * @tc.require: SR000GH1GO
66  */
67 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DumpSysStateInner_0100, TestSize.Level1)
68 {
69     TAG_LOGI(AAFwkTag::TEST, "AbilityManagerStub_DumpSysStateInner_0100 start");
70 
71     MessageParcel data;
72     MessageParcel reply;
73     MessageOption option;
74 
75     WriteInterfaceToken(data);
76 
77     std::string args = "-a";
78     data.WriteString16(Str8ToStr16(args));
79 
80     bool isClient = false;
81     data.WriteBool(isClient);
82 
83     bool isUserID = true;
84     data.WriteBool(isUserID);
85 
86     data.WriteInt32(USER_ID);
87 
88     int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::DUMPSYS_STATE),
89         data, reply, option);
90     EXPECT_EQ(res, NO_ERROR);
91 
92     TAG_LOGI(AAFwkTag::TEST, "AbilityManagerStub_DumpSysStateInner_0100 end");
93 }  // namespace AAFwk
94 
95 /*
96  * Feature: AbilityManagerService
97  * Function: OnRemoteRequest
98  * SubFunction: NA
99  * FunctionPoints: AbilityManagerService OnRemoteRequest
100  * EnvConditions: code is START_ABILITY
101  * CaseDescription: Verify that on remote request is normal and abnormal
102  */
103 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_001, TestSize.Level1)
104 {
105     MessageParcel data;
106     MessageParcel reply;
107     MessageOption option;
108 
109     Want want;
110     WriteInterfaceToken(data);
111     want.SetFlags(10);
112     data.WriteParcelable(&want);
113     data.WriteInt32(1);
114     int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY),
115         data, reply, option);
116 
117     EXPECT_EQ(res, NO_ERROR);
118 
119     data.WriteParcelable(nullptr);
120     data.WriteInt32(1);
121     int res1 = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY),
122         data, reply, option);
123     EXPECT_NE(res1, NO_ERROR);
124 }
125 
126 /*
127  * Feature: AbilityManagerService
128  * Function: OnRemoteRequest
129  * SubFunction: NA
130  * FunctionPoints: AbilityManagerService OnRemoteRequest
131  * EnvConditions: code is TERMINATE_ABILITY
132  * CaseDescription: Verify that on remote request is normal and abnormal
133  */
134 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_002, TestSize.Level1)
135 {
136     MessageParcel data;
137     MessageParcel reply;
138     MessageOption option;
139 
140     Want want;
141     want.SetFlags(10);
142     OHOS::sptr<IRemoteObject> token = nullptr;
143     WriteInterfaceToken(data);
144     data.WriteParcelable(token);
145     data.WriteParcelable(&want);
146     int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::TERMINATE_ABILITY),
147         data, reply, option);
148 
149     EXPECT_EQ(res, NO_ERROR);
150 }
151 
152 /*
153  * Feature: AbilityManagerService
154  * Function: OnRemoteRequest
155  * SubFunction: NA
156  * FunctionPoints: AbilityManagerService OnRemoteRequest
157  * EnvConditions: code is CONNECT_ABILITY
158  * CaseDescription: Verify that on remote request is normal
159  */
160 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_004, TestSize.Level1)
161 {
162     MessageParcel data;
163     MessageParcel reply;
164     MessageOption option;
165 
166     Want want;
167     want.SetFlags(10);
168     sptr<IAbilityConnection> connect = new AbilityConnectCallback();
169     sptr<IRemoteObject> callerToken = nullptr;
170     WriteInterfaceToken(data);
171     data.WriteParcelable(&want);
172     data.WriteParcelable(connect->AsObject());
173     data.WriteParcelable(callerToken);
174     int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY),
175         data, reply, option);
176 
177     EXPECT_EQ(res, NO_ERROR);
178 }
179 
180 /*
181  * Feature: AbilityManagerService
182  * Function: OnRemoteRequest
183  * SubFunction: NA
184  * FunctionPoints: NA
185  * EnvConditions: NA
186  * CaseDescription: OnRemoteRequest static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY
187  */
188 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_005, TestSize.Level1)
189 {
190     MessageParcel data;
191     MessageParcel reply;
192     MessageOption option;
193 
194     Want want;
195     want.SetFlags(10);
196     sptr<IAbilityConnection> connect = new AbilityConnectCallback();
197     sptr<IRemoteObject> callerToken = nullptr;
198     WriteInterfaceToken(data);
199     data.WriteParcelable(&want);
200     data.WriteParcelable(connect->AsObject());
201     data.WriteParcelable(callerToken);
202     int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY),
203         data, reply, option);
204 
205     EXPECT_EQ(res, NO_ERROR);
206 }
207 
208 /*
209  * Feature: AbilityManagerService
210  * Function: OnRemoteRequest
211  * SubFunction: NA
212  * FunctionPoints: NA
213  * EnvConditions: NA
214  * CaseDescription: OnRemoteRequest static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY
215  */
216 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_006, TestSize.Level1)
217 {
218     MessageParcel data;
219     MessageParcel reply;
220     MessageOption option;
221 
222     sptr<IAbilityConnection> connect = new AbilityConnectCallback();
223     sptr<IRemoteObject> callerToken = nullptr;
224     WriteInterfaceToken(data);
225     data.WriteParcelable(nullptr);
226     data.WriteParcelable(connect->AsObject());
227     data.WriteParcelable(callerToken);
228     int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY),
229         data, reply, option);
230 
231     EXPECT_NE(res, NO_ERROR);
232 }
233 
234 /*
235  * Feature: AbilityManagerService
236  * Function: OnRemoteRequest
237  * SubFunction: NA
238  * FunctionPoints: AbilityManagerService OnRemoteRequest
239  * EnvConditions: code is DISCONNECT_ABILITY
240  * CaseDescription: Verify that on remote request is normal
241  */
242 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_007, TestSize.Level1)
243 {
244     MessageParcel data;
245     MessageParcel reply;
246     MessageOption option;
247 
248     sptr<IAbilityConnection> connect = new AbilityConnectCallback();
249     WriteInterfaceToken(data);
250     data.WriteParcelable(connect->AsObject());
251     stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::DISCONNECT_ABILITY),
252         data, reply, option);
253 
254     EXPECT_TRUE(stub_ != nullptr);
255 }
256 
257 /*
258  * Feature: AbilityManagerService
259  * Function: OnRemoteRequest
260  * SubFunction: NA
261  * FunctionPoints: AbilityManagerService OnRemoteRequest
262  * EnvConditions: code is ATTACH_ABILITY_THREAD
263  * CaseDescription: Verify that on remote request is normal
264  */
265 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_008, TestSize.Level1)
266 {
267     MessageParcel data;
268     MessageParcel reply;
269     MessageOption option;
270 
271     sptr<IAbilityScheduler> scheduler = new AbilityScheduler();
272     sptr<IRemoteObject> token = nullptr;
273     WriteInterfaceToken(data);
274     data.WriteParcelable(scheduler->AsObject());
275     data.WriteParcelable(token);
276     stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::ATTACH_ABILITY_THREAD),
277         data, reply, option);
278 
279     EXPECT_TRUE(stub_ != nullptr);
280 }
281 
282 /*
283  * Feature: AbilityManagerService
284  * Function: OnRemoteRequest
285  * SubFunction: NA
286  * FunctionPoints: AbilityManagerService OnRemoteRequest
287  * EnvConditions: code is ABILITY_TRANSITION_DONE
288  * CaseDescription: Verify that on remote request is normal
289  */
290 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_009, TestSize.Level1)
291 {
292     MessageParcel data;
293     MessageParcel reply;
294     MessageOption option;
295 
296     sptr<IRemoteObject> token = sptr<AppExecFwk::MockAbilityToken>(new (std::nothrow) AppExecFwk::MockAbilityToken());
297     WriteInterfaceToken(data);
298     bool ret = data.WriteRemoteObject(token);
299     ret |= data.WriteInt32(1);
300     PacMap pMap;
301     pMap.PutIntValue(std::string("1"), 1);
302     ret |= data.WriteParcelable(&pMap);
303     if (ret) {
304         int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::ABILITY_TRANSITION_DONE),
305         data, reply, option);
306         EXPECT_EQ(res, NO_ERROR);
307     }
308 }
309 
310 /*
311  * Feature: AbilityManagerService
312  * Function: OnRemoteRequest
313  * SubFunction: NA
314  * FunctionPoints: AbilityManagerService OnRemoteRequest
315  * EnvConditions: code is CONNECT_ABILITY_DONE
316  * CaseDescription: Verify that on remote request is normal
317  */
318 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_010, TestSize.Level1)
319 {
320     MessageParcel data;
321     MessageParcel reply;
322     MessageOption option;
323 
324     sptr<IRemoteObject> token = nullptr;
325     sptr<IRemoteObject> remoteObject = nullptr;
326     WriteInterfaceToken(data);
327     data.WriteParcelable(token);
328     data.WriteParcelable(remoteObject);
329     int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY_DONE),
330         data, reply, option);
331 
332     EXPECT_EQ(res, NO_ERROR);
333 }
334 
335 /*
336  * Feature: AbilityManagerService
337  * Function: OnRemoteRequest
338  * SubFunction: NA
339  * FunctionPoints: AbilityManagerService OnRemoteRequest
340  * EnvConditions: code is DISCONNECT_ABILITY_DONE
341  * CaseDescription: Verify that on remote request is normal
342  */
343 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_011, TestSize.Level1)
344 {
345     MessageParcel data;
346     MessageParcel reply;
347     MessageOption option;
348 
349     sptr<IRemoteObject> token = nullptr;
350     WriteInterfaceToken(data);
351     data.WriteParcelable(token);
352     int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::DISCONNECT_ABILITY_DONE),
353         data, reply, option);
354 
355     EXPECT_EQ(res, NO_ERROR);
356 }
357 
358 /*
359  * Feature: AbilityManagerService
360  * Function: OnRemoteRequest
361  * SubFunction: NA
362  * FunctionPoints: AbilityManagerService OnRemoteRequest
363  * EnvConditions: code is SEND_RESULT_TO_ABILITY
364  * CaseDescription: Verify that on remote request is normal
365  */
366 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_012, TestSize.Level1)
367 {
368     MessageParcel data;
369     MessageParcel reply;
370     MessageOption option;
371 
372     WriteInterfaceToken(data);
373     int requestCode = -1;
374     int resultCode = -1;
375     Want want;
376     data.WriteInt32(requestCode);
377     data.WriteInt32(resultCode);
378     data.WriteParcelable(&want);
379     int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::SEND_RESULT_TO_ABILITY),
380         data, reply, option);
381 
382     EXPECT_EQ(res, NO_ERROR);
383 }
384 
385 /*
386  * Feature: AbilityManagerService
387  * Function: OnRemoteRequest
388  * SubFunction: NA
389  * FunctionPoints: AbilityManagerService OnRemoteRequest
390  * EnvConditions: code is DUMP_STATE
391  * CaseDescription: Verify that on remote request is normal
392  */
393 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_013, TestSize.Level1)
394 {
395     MessageParcel data;
396     MessageParcel reply;
397     MessageOption option;
398 
399     std::string args = "aaa";
400     std::vector<std::string> info;
401     WriteInterfaceToken(data);
402     data.WriteString16(Str8ToStr16(args));
403     int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::DUMP_STATE),
404         data, reply, option);
405 
406     EXPECT_EQ(res, NO_ERROR);
407 }
408 
409 /*
410  * Feature: AbilityManagerService
411  * Function: OnRemoteRequest
412  * SubFunction: NA
413  * FunctionPoints: AbilityManagerService OnRemoteRequest
414  * EnvConditions: code is default
415  * CaseDescription: Verify that on remote request is normal
416  */
417 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_016, TestSize.Level1)
418 {
419     MessageParcel data;
420     MessageParcel reply;
421     MessageOption option;
422     WriteInterfaceToken(data);
423     int res = stub_->OnRemoteRequest(5000, data, reply, option);
424 
425     EXPECT_NE(res, NO_ERROR);
426 }
427 
428 /*
429  * Feature: AbilityManagerService
430  * Function: OnRemoteRequest
431  * SubFunction: NA
432  * FunctionPoints: AbilityManagerService OnRemoteRequest
433  * EnvConditions: code is START_CALL_ABILITY
434  * CaseDescription: Verify that on remote request is normal
435  */
436 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_018, TestSize.Level1)
437 {
438     MessageParcel data;
439     MessageParcel reply;
440     MessageOption option;
441     Want want;
442     WriteInterfaceToken(data);
443     want.SetFlags(10);
444     data.WriteParcelable(&want);
445     stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_CALL_ABILITY),
446         data, reply, option);
447 
448     EXPECT_TRUE(stub_ != nullptr);
449 }
450 
451 /*
452  * Feature: AbilityManagerService
453  * Function: OnRemoteRequest
454  * SubFunction: NA
455  * FunctionPoints: AbilityManagerService OnRemoteRequest
456  * EnvConditions: code is START_CALL_ABILITY
457  * CaseDescription: Verify that on remote request is ERR_INVALID_VALUE
458  */
459 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_019, TestSize.Level1)
460 {
461     MessageParcel data;
462     MessageParcel reply;
463     MessageOption option;
464     WriteInterfaceToken(data);
465     int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::START_CALL_ABILITY),
466         data, reply, option);
467 
468     EXPECT_EQ(res, ERR_INVALID_VALUE);
469 }
470 
471 /*
472  * Feature: AbilityManagerService
473  * Function: OnRemoteRequest
474  * SubFunction: NA
475  * FunctionPoints: AbilityManagerService OnRemoteRequest
476  * EnvConditions: code is START_CALL_ABILITY
477  * CaseDescription: Verify that on remote request is normal
478  */
479 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_020, TestSize.Level1)
480 {
481     MessageParcel data;
482     MessageParcel reply;
483     MessageOption option;
484     WriteInterfaceToken(data);
485     AppExecFwk::ElementName element;
486     sptr<IAbilityConnection> connect = new AbilityConnectCallback();
487     data.WriteParcelable(connect->AsObject());
488     data.WriteParcelable(&element);
489     int res = stub_->OnRemoteRequest(static_cast<uint32_t>(AbilityManagerInterfaceCode::RELEASE_CALL_ABILITY),
490         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(static_cast<uint32_t>(AbilityManagerInterfaceCode::RELEASE_CALL_ABILITY),
510         data, reply, option);
511 
512     EXPECT_EQ(res, ERR_INVALID_VALUE);
513 }
514 
515 /*
516  * Feature: AbilityManagerService
517  * Function: GetTopAbilityInner
518  * SubFunction: NA
519  * FunctionPoints: AbilityManagerService GetTopAbilityInner
520  * EnvConditions: NA
521  * CaseDescription: Verify the function GetTopAbilityInner is normal flow.
522  */
523 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetTopAbilityInner_001, TestSize.Level1)
524 {
525     MessageParcel data;
526     MessageParcel reply;
527     auto res = stub_->GetTopAbilityInner(data, reply);
528     EXPECT_EQ(res, NO_ERROR);
529 }
530 
531 /*
532  * Feature: AbilityManagerService
533  * Function: GetElementNameByTokenInner
534  * SubFunction: NA
535  * FunctionPoints: AbilityManagerService GetElementNameByTokenInner
536  * EnvConditions: NA
537  * CaseDescription: Verify the function GetElementNameByTokenInner is normal flow.
538  */
539 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetElementNameByTokenInner_001, TestSize.Level1)
540 {
541     MessageParcel data;
542     MessageParcel reply;
543     auto res = stub_->GetElementNameByTokenInner(data, reply);
544     EXPECT_EQ(res, NO_ERROR);
545 }
546 
547 /*
548  * Feature: AbilityManagerService
549  * Function: MoveAbilityToBackgroundInner
550  * SubFunction: NA
551  * FunctionPoints: AbilityManagerService MoveAbilityToBackgroundInner
552  * EnvConditions: NA
553  * CaseDescription: Verify the function MoveAbilityToBackgroundInner is normal flow.
554  */
555 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveAbilityToBackgroundInner_001, TestSize.Level1)
556 {
557     MessageParcel data;
558     MessageParcel reply;
559     auto res = stub_->MoveAbilityToBackgroundInner(data, reply);
560     EXPECT_EQ(res, NO_ERROR);
561 }
562 
563 /*
564  * Feature: AbilityManagerService
565  * Function: MoveUIAbilityToBackgroundInner
566  * SubFunction: NA
567  * FunctionPoints: AbilityManagerService MoveUIAbilityToBackgroundInner
568  * EnvConditions: NA
569  * CaseDescription: Verify the function MoveUIAbilityToBackgroundInner is normal flow.
570  */
571 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveUIAbilityToBackgroundInner_001, TestSize.Level1)
572 {
573     MessageParcel data;
574     MessageParcel reply;
575     auto res = stub_->MoveUIAbilityToBackgroundInner(data, reply);
576     EXPECT_EQ(res, IPC_STUB_ERR);
577 }
578 
579 /*
580  * Feature: AbilityManagerService
581  * Function: TerminateAbilityInner
582  * SubFunction: NA
583  * FunctionPoints: AbilityManagerService TerminateAbilityInner
584  * EnvConditions: NA
585  * CaseDescription: Verify the function TerminateAbilityInner is normal flow.
586  */
587 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_TerminateAbilityInner_001, TestSize.Level1)
588 {
589     MessageParcel data;
590     MessageParcel reply;
591     auto res = stub_->TerminateAbilityInner(data, reply);
592     EXPECT_EQ(res, NO_ERROR);
593 }
594 
595 /*
596  * Feature: AbilityManagerService
597  * Function: TerminateUIExtensionAbilityInner
598  * SubFunction: NA
599  * FunctionPoints: AbilityManagerService TerminateUIExtensionAbilityInner
600  * EnvConditions: NA
601  * CaseDescription: Verify the function TerminateUIExtensionAbilityInner is normal flow.
602  */
603 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_TerminateUIExtensionAbilityInner_001, TestSize.Level1)
604 {
605     MessageParcel data;
606     MessageParcel reply;
607     auto res = stub_->TerminateUIExtensionAbilityInner(data, reply);
608     EXPECT_EQ(res, NO_ERROR);
609 }
610 
611 /*
612  * Feature: AbilityManagerService
613  * Function: SendResultToAbilityInner
614  * SubFunction: NA
615  * FunctionPoints: AbilityManagerService SendResultToAbilityInner
616  * EnvConditions: NA
617  * CaseDescription: Verify the function SendResultToAbilityInner is normal flow.
618  */
619 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SendResultToAbilityInner_001, TestSize.Level1)
620 {
621     MessageParcel data;
622     MessageParcel reply;
623     auto res = stub_->SendResultToAbilityInner(data, reply);
624     EXPECT_EQ(res, ERR_INVALID_VALUE);
625 }
626 
627 /*
628  * Feature: AbilityManagerService
629  * Function: MinimizeAbilityInner
630  * SubFunction: NA
631  * FunctionPoints: AbilityManagerService MinimizeAbilityInner
632  * EnvConditions: NA
633  * CaseDescription: Verify the function MinimizeAbilityInner is normal flow.
634  */
635 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MinimizeAbilityInner_001, TestSize.Level1)
636 {
637     MessageParcel data;
638     MessageParcel reply;
639     auto res = stub_->MinimizeAbilityInner(data, reply);
640     EXPECT_EQ(res, NO_ERROR);
641 }
642 
643 /*
644  * Feature: AbilityManagerService
645  * Function: MinimizeUIExtensionAbilityInner
646  * SubFunction: NA
647  * FunctionPoints: AbilityManagerService MinimizeUIExtensionAbilityInner
648  * EnvConditions: NA
649  * CaseDescription: Verify the function MinimizeUIExtensionAbilityInner is normal flow.
650  */
651 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MinimizeUIExtensionAbilityInner_001, TestSize.Level1)
652 {
653     MessageParcel data;
654     MessageParcel reply;
655     auto res = stub_->MinimizeUIExtensionAbilityInner(data, reply);
656     EXPECT_EQ(res, NO_ERROR);
657 }
658 
659 /*
660  * Feature: AbilityManagerService
661  * Function: MinimizeUIAbilityBySCBInner
662  * SubFunction: NA
663  * FunctionPoints: AbilityManagerService MinimizeUIAbilityBySCBInner
664  * EnvConditions: NA
665  * CaseDescription: Verify the function MinimizeUIAbilityBySCBInner is normal flow.
666  */
667 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MinimizeUIAbilityBySCBInner_001, TestSize.Level1)
668 {
669     MessageParcel data;
670     MessageParcel reply;
671     auto res = stub_->MinimizeUIAbilityBySCBInner(data, reply);
672     EXPECT_EQ(res, NO_ERROR);
673 }
674 
675 /*
676  * Feature: AbilityManagerService
677  * Function: AttachAbilityThreadInner
678  * SubFunction: NA
679  * FunctionPoints: AbilityManagerService AttachAbilityThreadInner
680  * EnvConditions: NA
681  * CaseDescription: Verify the function AttachAbilityThreadInner is normal flow.
682  */
683 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AttachAbilityThreadInner_001, TestSize.Level1)
684 {
685     MessageParcel data;
686     MessageParcel reply;
687     stub_->AttachAbilityThreadInner(data, reply);
688     EXPECT_TRUE(stub_ != nullptr);
689 }
690 
691 /*
692  * Feature: AbilityManagerService
693  * Function: AbilityTransitionDoneInner
694  * SubFunction: NA
695  * FunctionPoints: AbilityManagerService AbilityTransitionDoneInner
696  * EnvConditions: NA
697  * CaseDescription: Verify the function AbilityTransitionDoneInner is normal flow.
698  */
699 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AbilityTransitionDoneInner_001, TestSize.Level1)
700 {
701     MessageParcel data;
702     MessageParcel reply;
703     auto res = stub_->AbilityTransitionDoneInner(data, reply);
704     EXPECT_EQ(res, ERR_INVALID_VALUE);
705 }
706 
707 /*
708  * Feature: AbilityManagerService
709  * Function: ScheduleConnectAbilityDoneInner
710  * SubFunction: NA
711  * FunctionPoints: AbilityManagerService ScheduleConnectAbilityDoneInner
712  * EnvConditions: NA
713  * CaseDescription: Verify the function ScheduleConnectAbilityDoneInner is normal flow.
714  */
715 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ScheduleConnectAbilityDoneInner_001, TestSize.Level1)
716 {
717     MessageParcel data;
718     MessageParcel reply;
719     auto res = stub_->ScheduleConnectAbilityDoneInner(data, reply);
720     EXPECT_EQ(res, NO_ERROR);
721 }
722 
723 /*
724  * Feature: AbilityManagerService
725  * Function: ScheduleDisconnectAbilityDoneInner
726  * SubFunction: NA
727  * FunctionPoints: AbilityManagerService ScheduleDisconnectAbilityDoneInner
728  * EnvConditions: NA
729  * CaseDescription: Verify the function ScheduleDisconnectAbilityDoneInner is normal flow.
730  */
731 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ScheduleDisconnectAbilityDoneInner_001, TestSize.Level1)
732 {
733     MessageParcel data;
734     MessageParcel reply;
735     auto res = stub_->ScheduleDisconnectAbilityDoneInner(data, reply);
736     EXPECT_EQ(res, NO_ERROR);
737 }
738 
739 /*
740  * Feature: AbilityManagerService
741  * Function: ScheduleCommandAbilityDoneInner
742  * SubFunction: NA
743  * FunctionPoints: AbilityManagerService ScheduleCommandAbilityDoneInner
744  * EnvConditions: NA
745  * CaseDescription: Verify the function ScheduleCommandAbilityDoneInner is normal flow.
746  */
747 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ScheduleCommandAbilityDoneInner_001, TestSize.Level1)
748 {
749     MessageParcel data;
750     MessageParcel reply;
751     auto res = stub_->ScheduleCommandAbilityDoneInner(data, reply);
752     EXPECT_EQ(res, NO_ERROR);
753 }
754 
755 /*
756  * Feature: AbilityManagerService
757  * Function: ScheduleCommandAbilityWindowDoneInner
758  * SubFunction: NA
759  * FunctionPoints: AbilityManagerService ScheduleCommandAbilityWindowDoneInner
760  * EnvConditions: NA
761  * CaseDescription: Verify the function ScheduleCommandAbilityWindowDoneInner is normal flow.
762  */
763 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ScheduleCommandAbilityWindowDoneInner_001, TestSize.Level1)
764 {
765     MessageParcel data;
766     MessageParcel reply;
767     auto res = stub_->ScheduleCommandAbilityWindowDoneInner(data, reply);
768     EXPECT_EQ(res, NO_ERROR);
769 }
770 
771 /*
772  * Feature: AbilityManagerService
773  * Function: AcquireDataAbilityInner
774  * SubFunction: NA
775  * FunctionPoints: AbilityManagerService AcquireDataAbilityInner
776  * EnvConditions: NA
777  * CaseDescription: Verify the function AcquireDataAbilityInner is normal flow.
778  */
779 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AcquireDataAbilityInner_001, TestSize.Level1)
780 {
781     MessageParcel data;
782     MessageParcel reply;
783     auto res = stub_->AcquireDataAbilityInner(data, reply);
784     EXPECT_EQ(res, NO_ERROR);
785 }
786 
787 /*
788  * Feature: AbilityManagerService
789  * Function: ReleaseDataAbilityInner
790  * SubFunction: NA
791  * FunctionPoints: AbilityManagerService ReleaseDataAbilityInner
792  * EnvConditions: NA
793  * CaseDescription: Verify the function ReleaseDataAbilityInner is normal flow.
794  */
795 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ReleaseDataAbilityInner_001, TestSize.Level1)
796 {
797     MessageParcel data;
798     MessageParcel reply;
799     stub_->ReleaseDataAbilityInner(data, reply);
800     EXPECT_TRUE(stub_ != nullptr);
801 }
802 
803 /*
804  * Feature: AbilityManagerService
805  * Function: KillProcessInner
806  * SubFunction: NA
807  * FunctionPoints: AbilityManagerService KillProcessInner
808  * EnvConditions: NA
809  * CaseDescription: Verify the function KillProcessInner is normal flow.
810  */
811 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_KillProcessInner_001, TestSize.Level1)
812 {
813     MessageParcel data;
814     MessageParcel reply;
815     auto res = stub_->KillProcessInner(data, reply);
816     EXPECT_EQ(res, NO_ERROR);
817 }
818 
819 /*
820  * Feature: AbilityManagerService
821  * Function: UninstallAppInner
822  * SubFunction: NA
823  * FunctionPoints: AbilityManagerService UninstallAppInner
824  * EnvConditions: NA
825  * CaseDescription: Verify the function UninstallAppInner is normal flow.
826  */
827 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UninstallAppInner_001, TestSize.Level1)
828 {
829     MessageParcel data;
830     MessageParcel reply;
831     auto res = stub_->UninstallAppInner(data, reply);
832     EXPECT_EQ(res, NO_ERROR);
833 }
834 
835 /*
836  * Feature: AbilityManagerService
837  * Function: UpgradeAppInner
838  * SubFunction: NA
839  * FunctionPoints: AbilityManagerService UpgradeAppInner
840  * EnvConditions: NA
841  * CaseDescription: Verify the function UpgradeAppInner is normal flow.
842  */
843 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UpgradeAppInner_001, TestSize.Level1)
844 {
845     MessageParcel data;
846     MessageParcel reply;
847     auto res = stub_->UpgradeAppInner(data, reply);
848     EXPECT_EQ(res, NO_ERROR);
849 }
850 
851 
852 /*
853  * Feature: AbilityManagerService
854  * Function: StartAbilityInner
855  * SubFunction: NA
856  * FunctionPoints: AbilityManagerService StartAbilityInner
857  * EnvConditions: NA
858  * CaseDescription: Verify the function StartAbilityInner is normal flow.
859  */
860 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityInner_001, TestSize.Level1)
861 {
862     MessageParcel data;
863     MessageParcel reply;
864     auto res = stub_->StartAbilityInner(data, reply);
865     EXPECT_EQ(res, ERR_INVALID_VALUE);
866 }
867 
868 /*
869  * Feature: AbilityManagerService
870  * Function: StartAbilityInnerSpecifyTokenId
871  * SubFunction: NA
872  * FunctionPoints: AbilityManagerService StartAbilityInnerSpecifyTokenId
873  * EnvConditions: NA
874  * CaseDescription: Verify the function StartAbilityInnerSpecifyTokenId is normal flow.
875  */
876 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityInnerSpecifyTokenId_001, TestSize.Level1)
877 {
878     MessageParcel data;
879     MessageParcel reply;
880     auto res = stub_->StartAbilityInnerSpecifyTokenId(data, reply);
881     EXPECT_EQ(res, ERR_INVALID_VALUE);
882 }
883 
884 /*
885  * Feature: AbilityManagerService
886  * Function: StartAbilityByUIContentSessionAddCallerInner
887  * SubFunction: NA
888  * FunctionPoints: AbilityManagerService StartAbilityByUIContentSessionAddCallerInner
889  * EnvConditions: NA
890  * CaseDescription: Verify the function StartAbilityByUIContentSessionAddCallerInner is normal flow.
891  */
892 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityByUIContentSessionAddCallerInner_001, TestSize.Level1)
893 {
894     MessageParcel data;
895     MessageParcel reply;
896     auto res = stub_->StartAbilityByUIContentSessionAddCallerInner(data, reply);
897     EXPECT_EQ(res, ERR_INVALID_VALUE);
898 }
899 
900 /*
901  * Feature: AbilityManagerService
902  * Function: StartAbilityByUIContentSessionForOptionsInner
903  * SubFunction: NA
904  * FunctionPoints: AbilityManagerService StartAbilityByUIContentSessionForOptionsInner
905  * EnvConditions: NA
906  * CaseDescription: Verify the function StartAbilityByUIContentSessionForOptionsInner is normal flow.
907  */
908 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityByUIContentSessionForOptionsInner_001, TestSize.Level1)
909 {
910     MessageParcel data;
911     MessageParcel reply;
912     auto res = stub_->StartAbilityByUIContentSessionForOptionsInner(data, reply);
913     EXPECT_EQ(res, ERR_INVALID_VALUE);
914 }
915 
916 /*
917  * Feature: AbilityManagerService
918  * Function: StartExtensionAbilityInner
919  * SubFunction: NA
920  * FunctionPoints: AbilityManagerService StartExtensionAbilityInner
921  * EnvConditions: NA
922  * CaseDescription: Verify the function StartExtensionAbilityInner is normal flow.
923  */
924 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartExtensionAbilityInner_001, TestSize.Level1)
925 {
926     MessageParcel data;
927     MessageParcel reply;
928     auto res = stub_->StartExtensionAbilityInner(data, reply);
929     EXPECT_EQ(res, ERR_INVALID_VALUE);
930 }
931 
932 /*
933  * Feature: AbilityManagerService
934  * Function: RequestModalUIExtensionInner
935  * SubFunction: NA
936  * FunctionPoints: AbilityManagerService RequestModalUIExtensionInner
937  * EnvConditions: NA
938  * CaseDescription: Verify the function RequestModalUIExtensionInner is normal flow.
939  */
940 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RequestModalUIExtensionInner_001, TestSize.Level1)
941 {
942     MessageParcel data;
943     MessageParcel reply;
944     auto res = stub_->RequestModalUIExtensionInner(data, reply);
945     EXPECT_EQ(res, ERR_INVALID_VALUE);
946 }
947 
948 /*
949  * Feature: AbilityManagerService
950  * Function: PreloadUIExtensionAbilityInner
951  * SubFunction: NA
952  * FunctionPoints: AbilityManagerService PreloadUIExtensionAbilityInner
953  * EnvConditions: NA
954  * CaseDescription: Verify the function PreloadUIExtensionAbilityInner is normal flow.
955  */
956 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_PreloadUIExtensionAbilityInner_001, TestSize.Level1)
957 {
958     MessageParcel data;
959     MessageParcel reply;
960     auto res = stub_->PreloadUIExtensionAbilityInner(data, reply);
961     EXPECT_EQ(res, ERR_INVALID_VALUE);
962 }
963 
964 /*
965  * Feature: AbilityManagerService
966  * Function: StartUIExtensionAbilityInner
967  * SubFunction: NA
968  * FunctionPoints: AbilityManagerService StartUIExtensionAbilityInner
969  * EnvConditions: NA
970  * CaseDescription: Verify the function StartUIExtensionAbilityInner is normal flow.
971  */
972 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUIExtensionAbilityInner_001, TestSize.Level1)
973 {
974     MessageParcel data;
975     MessageParcel reply;
976     auto res = stub_->StartUIExtensionAbilityInner(data, reply);
977     EXPECT_EQ(res, NO_ERROR);
978 }
979 
980 /*
981  * Feature: AbilityManagerService
982  * Function: StartUIExtensionAbilityEmbeddedInner
983  * SubFunction: NA
984  * FunctionPoints: AbilityManagerService StartUIExtensionAbilityEmbeddedInner
985  * EnvConditions: NA
986  * CaseDescription: Verify the function StartUIExtensionAbilityEmbeddedInner is normal flow.
987  */
988 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUIExtensionAbilityEmbeddedInner_001, TestSize.Level1)
989 {
990     MessageParcel data;
991     MessageParcel reply;
992     auto res = stub_->StartUIExtensionAbilityEmbeddedInner(data, reply);
993     EXPECT_EQ(res, NO_ERROR);
994 }
995 
996 /*
997  * Feature: AbilityManagerService
998  * Function: StartUIExtensionConstrainedEmbeddedInner
999  * SubFunction: NA
1000  * FunctionPoints: AbilityManagerService StartUIExtensionConstrainedEmbeddedInner
1001  * EnvConditions: NA
1002  * CaseDescription: Verify the function StartUIExtensionConstrainedEmbeddedInner is normal flow.
1003  */
1004 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUIExtensionConstrainedEmbeddedInner_001, TestSize.Level1)
1005 {
1006     MessageParcel data;
1007     MessageParcel reply;
1008     auto res = stub_->StartUIExtensionConstrainedEmbeddedInner(data, reply);
1009     EXPECT_EQ(res, NO_ERROR);
1010 }
1011 
1012 /*
1013  * Feature: AbilityManagerService
1014  * Function: StopExtensionAbilityInner
1015  * SubFunction: NA
1016  * FunctionPoints: AbilityManagerService StopExtensionAbilityInner
1017  * EnvConditions: NA
1018  * CaseDescription: Verify the function StopExtensionAbilityInner is normal flow.
1019  */
1020 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StopExtensionAbilityInner_001, TestSize.Level1)
1021 {
1022     MessageParcel data;
1023     MessageParcel reply;
1024     auto res = stub_->StopExtensionAbilityInner(data, reply);
1025     EXPECT_EQ(res, ERR_INVALID_VALUE);
1026 }
1027 
1028 /*
1029  * Feature: AbilityManagerService
1030  * Function: StartAbilityAddCallerInner
1031  * SubFunction: NA
1032  * FunctionPoints: AbilityManagerService StartAbilityAddCallerInner
1033  * EnvConditions: NA
1034  * CaseDescription: Verify the function StartAbilityAddCallerInner is normal flow.
1035  */
1036 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityAddCallerInner_001, TestSize.Level1)
1037 {
1038     MessageParcel data;
1039     MessageParcel reply;
1040     auto res = stub_->StartAbilityAddCallerInner(data, reply);
1041     EXPECT_EQ(res, ERR_INVALID_VALUE);
1042 }
1043 
1044 /*
1045  * Feature: AbilityManagerService
1046  * Function: StartAbilityAsCallerByTokenInner
1047  * SubFunction: NA
1048  * FunctionPoints: AbilityManagerService StartAbilityAsCallerByTokenInner
1049  * EnvConditions: NA
1050  * CaseDescription: Verify the function StartAbilityAsCallerByTokenInner is normal flow.
1051  */
1052 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityAsCallerByTokenInner_001, TestSize.Level1)
1053 {
1054     MessageParcel data;
1055     MessageParcel reply;
1056     auto res = stub_->StartAbilityAsCallerByTokenInner(data, reply);
1057     EXPECT_EQ(res, ERR_INVALID_VALUE);
1058 }
1059 
1060 /*
1061  * Feature: AbilityManagerService
1062  * Function: StartAbilityAsCallerForOptionInner
1063  * SubFunction: NA
1064  * FunctionPoints: AbilityManagerService StartAbilityAsCallerForOptionInner
1065  * EnvConditions: NA
1066  * CaseDescription: Verify the function StartAbilityAsCallerForOptionInner is normal flow.
1067  */
1068 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityAsCallerForOptionInner_001, TestSize.Level1)
1069 {
1070     MessageParcel data;
1071     MessageParcel reply;
1072     auto res = stub_->StartAbilityAsCallerForOptionInner(data, reply);
1073     EXPECT_EQ(res, ERR_INVALID_VALUE);
1074 }
1075 
1076 /*
1077  * Feature: AbilityManagerService
1078  * Function: ConnectAbilityInner
1079  * SubFunction: NA
1080  * FunctionPoints: AbilityManagerService ConnectAbilityInner
1081  * EnvConditions: NA
1082  * CaseDescription: Verify the function ConnectAbilityInner is normal flow.
1083  */
1084 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ConnectAbilityInner_001, TestSize.Level1)
1085 {
1086     MessageParcel data;
1087     MessageParcel reply;
1088     auto res = stub_->ConnectAbilityInner(data, reply);
1089     EXPECT_EQ(res, ERR_INVALID_VALUE);
1090 }
1091 
1092 /*
1093  * Feature: AbilityManagerService
1094  * Function: ConnectAbilityWithTypeInner
1095  * SubFunction: NA
1096  * FunctionPoints: AbilityManagerService ConnectAbilityWithTypeInner
1097  * EnvConditions: NA
1098  * CaseDescription: Verify the function ConnectAbilityWithTypeInner is normal flow.
1099  */
1100 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ConnectAbilityWithTypeInner_001, TestSize.Level1)
1101 {
1102     MessageParcel data;
1103     MessageParcel reply;
1104     auto res = stub_->ConnectAbilityWithTypeInner(data, reply);
1105     EXPECT_EQ(res, ERR_INVALID_VALUE);
1106 }
1107 
1108 /*
1109  * Feature: AbilityManagerService
1110  * Function: ConnectUIExtensionAbilityInner
1111  * SubFunction: NA
1112  * FunctionPoints: AbilityManagerService ConnectUIExtensionAbilityInner
1113  * EnvConditions: NA
1114  * CaseDescription: Verify the function ConnectUIExtensionAbilityInner is normal flow.
1115  */
1116 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ConnectUIExtensionAbilityInner_001, TestSize.Level1)
1117 {
1118     MessageParcel data;
1119     MessageParcel reply;
1120     auto res = stub_->ConnectUIExtensionAbilityInner(data, reply);
1121     EXPECT_EQ(res, ERR_INVALID_VALUE);
1122 }
1123 
1124 /*
1125  * Feature: AbilityManagerService
1126  * Function: DisconnectAbilityInner
1127  * SubFunction: NA
1128  * FunctionPoints: AbilityManagerService DisconnectAbilityInner
1129  * EnvConditions: NA
1130  * CaseDescription: Verify the function DisconnectAbilityInner is normal flow.
1131  */
1132 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DisconnectAbilityInner_001, TestSize.Level1)
1133 {
1134     MessageParcel data;
1135     MessageParcel reply;
1136     stub_->DisconnectAbilityInner(data, reply);
1137     EXPECT_TRUE(stub_ != nullptr);
1138 }
1139 
1140 /*
1141  * Feature: AbilityManagerService
1142  * Function: StopServiceAbilityInner
1143  * SubFunction: NA
1144  * FunctionPoints: AbilityManagerService StopServiceAbilityInner
1145  * EnvConditions: NA
1146  * CaseDescription: Verify the function StopServiceAbilityInner is normal flow.
1147  */
1148 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StopServiceAbilityInner_001, TestSize.Level1)
1149 {
1150     MessageParcel data;
1151     MessageParcel reply;
1152     auto res = stub_->StopServiceAbilityInner(data, reply);
1153     EXPECT_EQ(res, ERR_INVALID_VALUE);
1154 }
1155 
1156 /*
1157  * Feature: AbilityManagerService
1158  * Function: DumpSysStateInner
1159  * SubFunction: NA
1160  * FunctionPoints: AbilityManagerService DumpSysStateInner
1161  * EnvConditions: NA
1162  * CaseDescription: Verify the function DumpSysStateInner is normal flow.
1163  */
1164 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DumpSysStateInner_001, TestSize.Level1)
1165 {
1166     MessageParcel data;
1167     MessageParcel reply;
1168     auto res = stub_->DumpSysStateInner(data, reply);
1169     EXPECT_EQ(res, ERR_INVALID_VALUE);
1170 }
1171 
1172 /*
1173  * Feature: AbilityManagerService
1174  * Function: DumpStateInner
1175  * SubFunction: NA
1176  * FunctionPoints: AbilityManagerService DumpStateInner
1177  * EnvConditions: NA
1178  * CaseDescription: Verify the function DumpStateInner is normal flow.
1179  */
1180 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DumpStateInner_001, TestSize.Level1)
1181 {
1182     MessageParcel data;
1183     MessageParcel reply;
1184     auto res = stub_->DumpStateInner(data, reply);
1185     EXPECT_EQ(res, ERR_INVALID_VALUE);
1186 }
1187 
1188 /*
1189  * Feature: AbilityManagerService
1190  * Function: StartAbilityForSettingsInner
1191  * SubFunction: NA
1192  * FunctionPoints: AbilityManagerService StartAbilityForSettingsInner
1193  * EnvConditions: NA
1194  * CaseDescription: Verify the function StartAbilityForSettingsInner is normal flow.
1195  */
1196 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityForSettingsInner_001, TestSize.Level1)
1197 {
1198     MessageParcel data;
1199     MessageParcel reply;
1200     auto res = stub_->StartAbilityForSettingsInner(data, reply);
1201     EXPECT_EQ(res, ERR_INVALID_VALUE);
1202 }
1203 
1204 /*
1205  * Feature: AbilityManagerService
1206  * Function: StartAbilityForOptionsInner
1207  * SubFunction: NA
1208  * FunctionPoints: AbilityManagerService StartAbilityForOptionsInner
1209  * EnvConditions: NA
1210  * CaseDescription: Verify the function StartAbilityForOptionsInner is normal flow.
1211  */
1212 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityForOptionsInner_001, TestSize.Level1)
1213 {
1214     MessageParcel data;
1215     MessageParcel reply;
1216     auto res = stub_->StartAbilityForOptionsInner(data, reply);
1217     EXPECT_EQ(res, ERR_INVALID_VALUE);
1218 }
1219 
1220 /*
1221  * Feature: AbilityManagerService
1222  * Function: CloseUIAbilityBySCBInner
1223  * SubFunction: NA
1224  * FunctionPoints: AbilityManagerService CloseUIAbilityBySCBInner
1225  * EnvConditions: NA
1226  * CaseDescription: Verify the function CloseUIAbilityBySCBInner is normal flow.
1227  */
1228 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CloseUIAbilityBySCBInner_001, TestSize.Level1)
1229 {
1230     MessageParcel data;
1231     MessageParcel reply;
1232     auto res = stub_->CloseUIAbilityBySCBInner(data, reply);
1233     EXPECT_EQ(res, NO_ERROR);
1234 }
1235 
1236 /*
1237  * Feature: AbilityManagerService
1238  * Function: GetWantSenderInner
1239  * SubFunction: NA
1240  * FunctionPoints: AbilityManagerService GetWantSenderInner
1241  * EnvConditions: NA
1242  * CaseDescription: Verify the function GetWantSenderInner is normal flow.
1243  */
1244 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetWantSenderInner_001, TestSize.Level1)
1245 {
1246     MessageParcel data;
1247     MessageParcel reply;
1248     auto res = stub_->GetWantSenderInner(data, reply);
1249     EXPECT_EQ(res, ERR_INVALID_VALUE);
1250 }
1251 
1252 /*
1253  * Feature: AbilityManagerService
1254  * Function: SendWantSenderInner
1255  * SubFunction: NA
1256  * FunctionPoints: AbilityManagerService SendWantSenderInner
1257  * EnvConditions: NA
1258  * CaseDescription: Verify the function SendWantSenderInner is normal flow.
1259  */
1260 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SendWantSenderInner_001, TestSize.Level1)
1261 {
1262     MessageParcel data;
1263     MessageParcel reply;
1264     auto res = stub_->SendWantSenderInner(data, reply);
1265     EXPECT_EQ(res, ERR_INVALID_VALUE);
1266 }
1267 
1268 /*
1269  * Feature: AbilityManagerService
1270  * Function: CancelWantSenderInner
1271  * SubFunction: NA
1272  * FunctionPoints: AbilityManagerService CancelWantSenderInner
1273  * EnvConditions: NA
1274  * CaseDescription: Verify the function CancelWantSenderInner is normal flow.
1275  */
1276 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CancelWantSenderInner_001, TestSize.Level1)
1277 {
1278     MessageParcel data;
1279     MessageParcel reply;
1280     auto res = stub_->CancelWantSenderInner(data, reply);
1281     EXPECT_EQ(res, ERR_INVALID_VALUE);
1282 }
1283 
1284 /*
1285  * Feature: AbilityManagerService
1286  * Function: GetPendingWantUidInner
1287  * SubFunction: NA
1288  * FunctionPoints: AbilityManagerService GetPendingWantUidInner
1289  * EnvConditions: NA
1290  * CaseDescription: Verify the function GetPendingWantUidInner is normal flow.
1291  */
1292 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantUidInner_001, TestSize.Level1)
1293 {
1294     MessageParcel data;
1295     MessageParcel reply;
1296     auto res = stub_->GetPendingWantUidInner(data, reply);
1297     EXPECT_EQ(res, ERR_INVALID_VALUE);
1298 }
1299 
1300 /*
1301  * Feature: AbilityManagerService
1302  * Function: GetPendingWantUserIdInner
1303  * SubFunction: NA
1304  * FunctionPoints: AbilityManagerService GetPendingWantUserIdInner
1305  * EnvConditions: NA
1306  * CaseDescription: Verify the function GetPendingWantUserIdInner is normal flow.
1307  */
1308 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantUserIdInner_001, TestSize.Level1)
1309 {
1310     MessageParcel data;
1311     MessageParcel reply;
1312     auto res = stub_->GetPendingWantUserIdInner(data, reply);
1313     EXPECT_EQ(res, ERR_INVALID_VALUE);
1314 }
1315 
1316 /*
1317  * Feature: AbilityManagerService
1318  * Function: GetPendingWantBundleNameInner
1319  * SubFunction: NA
1320  * FunctionPoints: AbilityManagerService GetPendingWantBundleNameInner
1321  * EnvConditions: NA
1322  * CaseDescription: Verify the function GetPendingWantBundleNameInner is normal flow.
1323  */
1324 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantBundleNameInner_001, TestSize.Level1)
1325 {
1326     MessageParcel data;
1327     MessageParcel reply;
1328     auto res = stub_->GetPendingWantBundleNameInner(data, reply);
1329     EXPECT_EQ(res, ERR_INVALID_VALUE);
1330 }
1331 
1332 /*
1333  * Feature: AbilityManagerService
1334  * Function: GetPendingWantCodeInner
1335  * SubFunction: NA
1336  * FunctionPoints: AbilityManagerService GetPendingWantCodeInner
1337  * EnvConditions: NA
1338  * CaseDescription: Verify the function GetPendingWantCodeInner is normal flow.
1339  */
1340 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantCodeInner_001, TestSize.Level1)
1341 {
1342     MessageParcel data;
1343     MessageParcel reply;
1344     auto res = stub_->GetPendingWantCodeInner(data, reply);
1345     EXPECT_EQ(res, ERR_INVALID_VALUE);
1346 }
1347 
1348 /*
1349  * Feature: AbilityManagerService
1350  * Function: GetPendingWantTypeInner
1351  * SubFunction: NA
1352  * FunctionPoints: AbilityManagerService GetPendingWantTypeInner
1353  * EnvConditions: NA
1354  * CaseDescription: Verify the function GetPendingWantTypeInner is normal flow.
1355  */
1356 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantTypeInner_001, TestSize.Level1)
1357 {
1358     MessageParcel data;
1359     MessageParcel reply;
1360     auto res = stub_->GetPendingWantTypeInner(data, reply);
1361     EXPECT_EQ(res, ERR_INVALID_VALUE);
1362 }
1363 
1364 /*
1365  * Feature: AbilityManagerService
1366  * Function: RegisterCancelListenerInner
1367  * SubFunction: NA
1368  * FunctionPoints: AbilityManagerService RegisterCancelListenerInner
1369  * EnvConditions: NA
1370  * CaseDescription: Verify the function RegisterCancelListenerInner is normal flow.
1371  */
1372 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterCancelListenerInner_001, TestSize.Level1)
1373 {
1374     MessageParcel data;
1375     MessageParcel reply;
1376     auto res = stub_->RegisterCancelListenerInner(data, reply);
1377     EXPECT_EQ(res, ERR_INVALID_VALUE);
1378 }
1379 
1380 /*
1381  * Feature: AbilityManagerService
1382  * Function: UnregisterCancelListenerInner
1383  * SubFunction: NA
1384  * FunctionPoints: AbilityManagerService UnregisterCancelListenerInner
1385  * EnvConditions: NA
1386  * CaseDescription: Verify the function UnregisterCancelListenerInner is normal flow.
1387  */
1388 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterCancelListenerInner_001, TestSize.Level1)
1389 {
1390     MessageParcel data;
1391     MessageParcel reply;
1392     auto res = stub_->UnregisterCancelListenerInner(data, reply);
1393     EXPECT_EQ(res, ERR_INVALID_VALUE);
1394 }
1395 
1396 /*
1397  * Feature: AbilityManagerService
1398  * Function: GetPendingRequestWantInner
1399  * SubFunction: NA
1400  * FunctionPoints: AbilityManagerService GetPendingRequestWantInner
1401  * EnvConditions: NA
1402  * CaseDescription: Verify the function GetPendingRequestWantInner is normal flow.
1403  */
1404 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingRequestWantInner_001, TestSize.Level1)
1405 {
1406     MessageParcel data;
1407     MessageParcel reply;
1408     auto res = stub_->GetPendingRequestWantInner(data, reply);
1409     EXPECT_EQ(res, ERR_INVALID_VALUE);
1410 }
1411 
1412 /*
1413  * Feature: AbilityManagerService
1414  * Function: GetWantSenderInfoInner
1415  * SubFunction: NA
1416  * FunctionPoints: AbilityManagerService GetWantSenderInfoInner
1417  * EnvConditions: NA
1418  * CaseDescription: Verify the function GetWantSenderInfoInner is normal flow.
1419  */
1420 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetWantSenderInfoInner_001, TestSize.Level1)
1421 {
1422     MessageParcel data;
1423     MessageParcel reply;
1424     auto res = stub_->GetWantSenderInfoInner(data, reply);
1425     EXPECT_EQ(res, ERR_INVALID_VALUE);
1426 }
1427 
1428 /*
1429  * Feature: AbilityManagerService
1430  * Function: GetAppMemorySizeInner
1431  * SubFunction: NA
1432  * FunctionPoints: AbilityManagerService GetAppMemorySizeInner
1433  * EnvConditions: NA
1434  * CaseDescription: Verify the function GetAppMemorySizeInner is normal flow.
1435  */
1436 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetAppMemorySizeInner_001, TestSize.Level1)
1437 {
1438     MessageParcel data;
1439     MessageParcel reply;
1440     auto res = stub_->GetAppMemorySizeInner(data, reply);
1441     EXPECT_EQ(res, NO_ERROR);
1442 }
1443 
1444 /*
1445  * Feature: AbilityManagerService
1446  * Function: IsRamConstrainedDeviceInner
1447  * SubFunction: NA
1448  * FunctionPoints: AbilityManagerService IsRamConstrainedDeviceInner
1449  * EnvConditions: NA
1450  * CaseDescription: Verify the function IsRamConstrainedDeviceInner is normal flow.
1451  */
1452 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsRamConstrainedDeviceInner_001, TestSize.Level1)
1453 {
1454     MessageParcel data;
1455     MessageParcel reply;
1456     auto res = stub_->IsRamConstrainedDeviceInner(data, reply);
1457     EXPECT_EQ(res, NO_ERROR);
1458 }
1459 
1460 /*
1461  * Feature: AbilityManagerService
1462  * Function: ContinueMissionInner
1463  * SubFunction: NA
1464  * FunctionPoints: AbilityManagerService ContinueMissionInner
1465  * EnvConditions: NA
1466  * CaseDescription: Verify the function ContinueMissionInner is normal flow.
1467  */
1468 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ContinueMissionInner_001, TestSize.Level1)
1469 {
1470     MessageParcel data;
1471     MessageParcel reply;
1472     auto res = stub_->ContinueMissionInner(data, reply);
1473     EXPECT_EQ(res, ERR_NULL_OBJECT);
1474 }
1475 
1476 /*
1477  * Feature: AbilityManagerService
1478  * Function: ContinueMissionOfBundleNameInner
1479  * SubFunction: NA
1480  * FunctionPoints: AbilityManagerService ContinueMissionOfBundleNameInner
1481  * EnvConditions: NA
1482  * CaseDescription: Verify the function ContinueMissionOfBundleNameInner is normal flow.
1483  */
1484 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ContinueMissionOfBundleNameInner_001, TestSize.Level1)
1485 {
1486     MessageParcel data;
1487     MessageParcel reply;
1488     auto res = stub_->ContinueMissionOfBundleNameInner(data, reply);
1489     EXPECT_EQ(res, ERR_NULL_OBJECT);
1490 }
1491 
1492 /*
1493  * Feature: AbilityManagerService
1494  * Function: ContinueMissionOfBundleNameInner
1495  * SubFunction: NA
1496  * FunctionPoints: AbilityManagerService ContinueMissionOfBundleNameInner
1497  * EnvConditions: NA
1498  * CaseDescription: Verify the function ContinueMissionOfBundleNameInner is normal flow.
1499  */
1500 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ContinueMissionOfBundleNameInner_002, TestSize.Level1)
1501 {
1502     MessageParcel data;
1503     MessageParcel reply;
1504     Want want;
1505     data.WriteParcelable(&want);
1506     auto res = stub_->ContinueMissionOfBundleNameInner(data, reply);
1507     EXPECT_EQ(res, ERR_NULL_OBJECT);
1508 }
1509 
1510 /*
1511  * Feature: AbilityManagerService
1512  * Function: ContinueAbilityInner
1513  * SubFunction: NA
1514  * FunctionPoints: AbilityManagerService ContinueAbilityInner
1515  * EnvConditions: NA
1516  * CaseDescription: Verify the function ContinueAbilityInner is normal flow.
1517  */
1518 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ContinueAbilityInner_001, TestSize.Level1)
1519 {
1520     MessageParcel data;
1521     MessageParcel reply;
1522     auto res = stub_->ContinueAbilityInner(data, reply);
1523     EXPECT_EQ(res, NO_ERROR);
1524 }
1525 
1526 /*
1527  * Feature: AbilityManagerService
1528  * Function: StartContinuationInner
1529  * SubFunction: NA
1530  * FunctionPoints: AbilityManagerService StartContinuationInner
1531  * EnvConditions: NA
1532  * CaseDescription: Verify the function StartContinuationInner is normal flow.
1533  */
1534 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartContinuationInner_001, TestSize.Level1)
1535 {
1536     MessageParcel data;
1537     MessageParcel reply;
1538     auto res = stub_->StartContinuationInner(data, reply);
1539     EXPECT_EQ(res, ERR_NULL_OBJECT);
1540 }
1541 
1542 /*
1543  * Feature: AbilityManagerService
1544  * Function: NotifyCompleteContinuationInner
1545  * SubFunction: NA
1546  * FunctionPoints: AbilityManagerService NotifyCompleteContinuationInner
1547  * EnvConditions: NA
1548  * CaseDescription: Verify the function NotifyCompleteContinuationInner is normal flow.
1549  */
1550 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_NotifyCompleteContinuationInner_001, TestSize.Level1)
1551 {
1552     MessageParcel data;
1553     MessageParcel reply;
1554     auto res = stub_->NotifyCompleteContinuationInner(data, reply);
1555     EXPECT_EQ(res, NO_ERROR);
1556 }
1557 
1558 /*
1559  * Feature: AbilityManagerService
1560  * Function: NotifyContinuationResultInner
1561  * SubFunction: NA
1562  * FunctionPoints: AbilityManagerService NotifyContinuationResultInner
1563  * EnvConditions: NA
1564  * CaseDescription: Verify the function NotifyContinuationResultInner is normal flow.
1565  */
1566 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_NotifyContinuationResultInner_001, TestSize.Level1)
1567 {
1568     MessageParcel data;
1569     MessageParcel reply;
1570     auto res = stub_->NotifyContinuationResultInner(data, reply);
1571     EXPECT_EQ(res, NO_ERROR);
1572 }
1573 
1574 /*
1575  * Feature: AbilityManagerService
1576  * Function: LockMissionForCleanupInner
1577  * SubFunction: NA
1578  * FunctionPoints: AbilityManagerService LockMissionForCleanupInner
1579  * EnvConditions: NA
1580  * CaseDescription: Verify the function LockMissionForCleanupInner is normal flow.
1581  */
1582 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_LockMissionForCleanupInner_001, TestSize.Level1)
1583 {
1584     MessageParcel data;
1585     MessageParcel reply;
1586     auto res = stub_->LockMissionForCleanupInner(data, reply);
1587     EXPECT_EQ(res, NO_ERROR);
1588 }
1589 
1590 /*
1591  * Feature: AbilityManagerService
1592  * Function: UnlockMissionForCleanupInner
1593  * SubFunction: NA
1594  * FunctionPoints: AbilityManagerService UnlockMissionForCleanupInner
1595  * EnvConditions: NA
1596  * CaseDescription: Verify the function UnlockMissionForCleanupInner is normal flow.
1597  */
1598 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnlockMissionForCleanupInner_001, TestSize.Level1)
1599 {
1600     MessageParcel data;
1601     MessageParcel reply;
1602     auto res = stub_->UnlockMissionForCleanupInner(data, reply);
1603     EXPECT_EQ(res, NO_ERROR);
1604 }
1605 
1606 /*
1607  * Feature: AbilityManagerService
1608  * Function: SetLockedStateInner
1609  * SubFunction: NA
1610  * FunctionPoints: AbilityManagerService SetLockedStateInner
1611  * EnvConditions: NA
1612  * CaseDescription: Verify the function SetLockedStateInner is normal flow.
1613  */
1614 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetLockedStateInner_001, TestSize.Level1)
1615 {
1616     MessageParcel data;
1617     MessageParcel reply;
1618     auto res = stub_->SetLockedStateInner(data, reply);
1619     EXPECT_EQ(res, NO_ERROR);
1620 }
1621 
1622 /*
1623  * Feature: AbilityManagerService
1624  * Function: RegisterMissionListenerInner
1625  * SubFunction: NA
1626  * FunctionPoints: AbilityManagerService RegisterMissionListenerInner
1627  * EnvConditions: NA
1628  * CaseDescription: Verify the function RegisterMissionListenerInner is normal flow.
1629  */
1630 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterMissionListenerInner_001, TestSize.Level1)
1631 {
1632     MessageParcel data;
1633     MessageParcel reply;
1634     auto res = stub_->RegisterMissionListenerInner(data, reply);
1635     EXPECT_EQ(res, ERR_INVALID_VALUE);
1636 }
1637 
1638 /*
1639  * Feature: AbilityManagerService
1640  * Function: UnRegisterMissionListenerInner
1641  * SubFunction: NA
1642  * FunctionPoints: AbilityManagerService UnRegisterMissionListenerInner
1643  * EnvConditions: NA
1644  * CaseDescription: Verify the function UnRegisterMissionListenerInner is normal flow.
1645  */
1646 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnRegisterMissionListenerInner_001, TestSize.Level1)
1647 {
1648     MessageParcel data;
1649     MessageParcel reply;
1650     auto res = stub_->UnRegisterMissionListenerInner(data, reply);
1651     EXPECT_EQ(res, ERR_INVALID_VALUE);
1652 }
1653 
1654 /*
1655  * Feature: AbilityManagerService
1656  * Function: GetMissionInfosInner
1657  * SubFunction: NA
1658  * FunctionPoints: AbilityManagerService GetMissionInfosInner
1659  * EnvConditions: NA
1660  * CaseDescription: Verify the function GetMissionInfosInner is normal flow.
1661  */
1662 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetMissionInfosInner_001, TestSize.Level1)
1663 {
1664     MessageParcel data;
1665     MessageParcel reply;
1666     auto res = stub_->GetMissionInfosInner(data, reply);
1667     EXPECT_EQ(res, NO_ERROR);
1668 }
1669 
1670 /*
1671  * Feature: AbilityManagerService
1672  * Function: GetMissionInfoInner
1673  * SubFunction: NA
1674  * FunctionPoints: AbilityManagerService GetMissionInfoInner
1675  * EnvConditions: NA
1676  * CaseDescription: Verify the function GetMissionInfoInner is normal flow.
1677  */
1678 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetMissionInfoInner_001, TestSize.Level1)
1679 {
1680     MessageParcel data;
1681     MessageParcel reply;
1682     auto res = stub_->GetMissionInfoInner(data, reply);
1683     EXPECT_EQ(res, NO_ERROR);
1684 }
1685 
1686 /*
1687  * Feature: AbilityManagerService
1688  * Function: CleanMissionInner
1689  * SubFunction: NA
1690  * FunctionPoints: AbilityManagerService CleanMissionInner
1691  * EnvConditions: NA
1692  * CaseDescription: Verify the function CleanMissionInner is normal flow.
1693  */
1694 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CleanMissionInner_001, TestSize.Level1)
1695 {
1696     MessageParcel data;
1697     MessageParcel reply;
1698     auto res = stub_->CleanMissionInner(data, reply);
1699     EXPECT_EQ(res, NO_ERROR);
1700 }
1701 
1702 /*
1703  * Feature: AbilityManagerService
1704  * Function: CleanAllMissionsInner
1705  * SubFunction: NA
1706  * FunctionPoints: AbilityManagerService CleanAllMissionsInner
1707  * EnvConditions: NA
1708  * CaseDescription: Verify the function CleanAllMissionsInner is normal flow.
1709  */
1710 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CleanAllMissionsInner_001, TestSize.Level1)
1711 {
1712     MessageParcel data;
1713     MessageParcel reply;
1714     auto res = stub_->CleanAllMissionsInner(data, reply);
1715     EXPECT_EQ(res, NO_ERROR);
1716 }
1717 
1718 /*
1719  * Feature: AbilityManagerService
1720  * Function: MoveMissionToFrontInner
1721  * SubFunction: NA
1722  * FunctionPoints: AbilityManagerService MoveMissionToFrontInner
1723  * EnvConditions: NA
1724  * CaseDescription: Verify the function MoveMissionToFrontInner is normal flow.
1725  */
1726 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveMissionToFrontInner_001, TestSize.Level1)
1727 {
1728     MessageParcel data;
1729     MessageParcel reply;
1730     auto res = stub_->MoveMissionToFrontInner(data, reply);
1731     EXPECT_EQ(res, NO_ERROR);
1732 }
1733 
1734 /*
1735  * Feature: AbilityManagerService
1736  * Function: MoveMissionsToForegroundInner
1737  * SubFunction: NA
1738  * FunctionPoints: AbilityManagerService MoveMissionsToForegroundInner
1739  * EnvConditions: NA
1740  * CaseDescription: Verify the function MoveMissionsToForegroundInner is normal flow.
1741  */
1742 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveMissionsToForegroundInner_001, TestSize.Level1)
1743 {
1744     TAG_LOGD(AAFwkTag::TEST, "%{public}s is called.", __func__);
1745     MessageParcel data;
1746     MessageParcel reply;
1747     auto res = stub_->MoveMissionsToForegroundInner(data, reply);
1748     EXPECT_EQ(res, NO_ERROR);
1749 }
1750 
1751 /*
1752  * Feature: AbilityManagerService
1753  * Function: MoveMissionsToBackgroundInner
1754  * SubFunction: NA
1755  * FunctionPoints: AbilityManagerService MoveMissionsToBackgroundInner
1756  * EnvConditions: NA
1757  * CaseDescription: Verify the function MoveMissionsToBackgroundInner is normal flow.
1758  */
1759 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveMissionsToBackgroundInner_001, TestSize.Level1)
1760 {
1761     TAG_LOGD(AAFwkTag::TEST, "%{public}s is called.", __func__);
1762     MessageParcel data;
1763     MessageParcel reply;
1764     auto res = stub_->MoveMissionsToBackgroundInner(data, reply);
1765     EXPECT_EQ(res, NO_ERROR);
1766 }
1767 
1768 /*
1769  * Feature: AbilityManagerService
1770  * Function: GetMissionIdByTokenInner
1771  * SubFunction: NA
1772  * FunctionPoints: AbilityManagerService GetMissionIdByTokenInner
1773  * EnvConditions: NA
1774  * CaseDescription: Verify the function GetMissionIdByTokenInner is normal flow.
1775  */
1776 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetMissionIdByTokenInner_001, TestSize.Level1)
1777 {
1778     MessageParcel data;
1779     MessageParcel reply;
1780     auto res = stub_->GetMissionIdByTokenInner(data, reply);
1781     EXPECT_EQ(res, NO_ERROR);
1782 }
1783 
1784 /*
1785  * Feature: AbilityManagerService
1786  * Function: MoveMissionToFrontByOptionsInner
1787  * SubFunction: NA
1788  * FunctionPoints: AbilityManagerService MoveMissionToFrontByOptionsInner
1789  * EnvConditions: NA
1790  * CaseDescription: Verify the function MoveMissionToFrontByOptionsInner is normal flow.
1791  */
1792 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveMissionToFrontByOptionsInner_001, TestSize.Level1)
1793 {
1794     MessageParcel data;
1795     MessageParcel reply;
1796     auto res = stub_->MoveMissionToFrontByOptionsInner(data, reply);
1797     EXPECT_EQ(res, ERR_INVALID_VALUE);
1798 }
1799 
1800 /*
1801  * Feature: AbilityManagerService
1802  * Function: StartAbilityByCallInner
1803  * SubFunction: NA
1804  * FunctionPoints: AbilityManagerService StartAbilityByCallInner
1805  * EnvConditions: NA
1806  * CaseDescription: Verify the function StartAbilityByCallInner is normal flow.
1807  */
1808 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityByCallInner_001, TestSize.Level1)
1809 {
1810     MessageParcel data;
1811     MessageParcel reply;
1812     auto res = stub_->StartAbilityByCallInner(data, reply);
1813     EXPECT_EQ(res, ERR_INVALID_VALUE);
1814 }
1815 
1816 /*
1817  * Feature: AbilityManagerService
1818  * Function: StartUIAbilityBySCBInner
1819  * SubFunction: NA
1820  * FunctionPoints: AbilityManagerService StartUIAbilityBySCBInner
1821  * EnvConditions: NA
1822  * CaseDescription: Verify the function StartUIAbilityBySCBInner is normal flow.
1823  */
1824 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUIAbilityBySCBInner_001, TestSize.Level1)
1825 {
1826     MessageParcel data;
1827     MessageParcel reply;
1828     auto res = stub_->StartUIAbilityBySCBInner(data, reply);
1829     EXPECT_EQ(res, NO_ERROR);
1830 }
1831 
1832 /*
1833  * Feature: AbilityManagerService
1834  * Function: ReleaseCallInner
1835  * SubFunction: NA
1836  * FunctionPoints: AbilityManagerService ReleaseCallInner
1837  * EnvConditions: NA
1838  * CaseDescription: Verify the function ReleaseCallInner is normal flow.
1839  */
1840 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ReleaseCallInner_001, TestSize.Level1)
1841 {
1842     MessageParcel data;
1843     MessageParcel reply;
1844     auto res = stub_->ReleaseCallInner(data, reply);
1845     EXPECT_EQ(res, ERR_INVALID_VALUE);
1846 }
1847 
1848 /*
1849  * Feature: AbilityManagerService
1850  * Function: StartUserInner
1851  * SubFunction: NA
1852  * FunctionPoints: AbilityManagerService StartUserInner
1853  * EnvConditions: NA
1854  * CaseDescription: Verify the function StartUserInner is normal flow.
1855  */
1856 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUserInner_001, TestSize.Level1)
1857 {
1858     MessageParcel data;
1859     MessageParcel reply;
1860     auto res = stub_->StartUserInner(data, reply);
1861     EXPECT_NE(res, NO_ERROR);
1862 }
1863 
1864 /*
1865  * Feature: AbilityManagerService
1866  * Function: StopUserInner
1867  * SubFunction: NA
1868  * FunctionPoints: AbilityManagerService StopUserInner
1869  * EnvConditions: NA
1870  * CaseDescription: Verify the function StopUserInner is normal flow.
1871  */
1872 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StopUserInner_001, TestSize.Level1)
1873 {
1874     MessageParcel data;
1875     MessageParcel reply;
1876     auto res = stub_->StopUserInner(data, reply);
1877     EXPECT_EQ(res, NO_ERROR);
1878 }
1879 
1880 /*
1881  * Feature: AbilityManagerService
1882  * Function: LogoutUserInner
1883  * SubFunction: NA
1884  * FunctionPoints: AbilityManagerService LogoutUserInner
1885  * EnvConditions: NA
1886  * CaseDescription: Verify the function LogoutUserInner is normal flow.
1887  */
1888 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_LogoutUserInner_001, TestSize.Level1)
1889 {
1890     MessageParcel data;
1891     MessageParcel reply;
1892     auto res = stub_->LogoutUserInner(data, reply);
1893     EXPECT_EQ(res, NO_ERROR);
1894 }
1895 
1896 /*
1897  * Feature: AbilityManagerService
1898  * Function: GetAbilityRunningInfosInner
1899  * SubFunction: NA
1900  * FunctionPoints: AbilityManagerService GetAbilityRunningInfosInner
1901  * EnvConditions: NA
1902  * CaseDescription: Verify the function GetAbilityRunningInfosInner is normal flow.
1903  */
1904 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetAbilityRunningInfosInner_001, TestSize.Level1)
1905 {
1906     MessageParcel data;
1907     MessageParcel reply;
1908     auto res = stub_->GetAbilityRunningInfosInner(data, reply);
1909     EXPECT_EQ(res, NO_ERROR);
1910 }
1911 
1912 /*
1913  * Feature: AbilityManagerService
1914  * Function: GetExtensionRunningInfosInner
1915  * SubFunction: NA
1916  * FunctionPoints: AbilityManagerService GetExtensionRunningInfosInner
1917  * EnvConditions: NA
1918  * CaseDescription: Verify the function GetExtensionRunningInfosInner is normal flow.
1919  */
1920 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetExtensionRunningInfosInner_001, TestSize.Level1)
1921 {
1922     MessageParcel data;
1923     MessageParcel reply;
1924     auto res = stub_->GetExtensionRunningInfosInner(data, reply);
1925     EXPECT_EQ(res, NO_ERROR);
1926 }
1927 
1928 /*
1929  * Feature: AbilityManagerService
1930  * Function: GetProcessRunningInfosInner
1931  * SubFunction: NA
1932  * FunctionPoints: AbilityManagerService GetProcessRunningInfosInner
1933  * EnvConditions: NA
1934  * CaseDescription: Verify the function GetProcessRunningInfosInner is normal flow.
1935  */
1936 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetProcessRunningInfosInner_001, TestSize.Level1)
1937 {
1938     MessageParcel data;
1939     MessageParcel reply;
1940     auto res = stub_->GetProcessRunningInfosInner(data, reply);
1941     EXPECT_EQ(res, NO_ERROR);
1942 }
1943 
1944 /*
1945  * Feature: AbilityManagerService
1946  * Function: StartSyncRemoteMissionsInner
1947  * SubFunction: NA
1948  * FunctionPoints: AbilityManagerService StartSyncRemoteMissionsInner
1949  * EnvConditions: NA
1950  * CaseDescription: Verify the function StartSyncRemoteMissionsInner is normal flow.
1951  */
1952 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartSyncRemoteMissionsInner_001, TestSize.Level1)
1953 {
1954     MessageParcel data;
1955     MessageParcel reply;
1956     auto res = stub_->StartSyncRemoteMissionsInner(data, reply);
1957     EXPECT_EQ(res, NO_ERROR);
1958 }
1959 
1960 /*
1961  * Feature: AbilityManagerService
1962  * Function: StopSyncRemoteMissionsInner
1963  * SubFunction: NA
1964  * FunctionPoints: AbilityManagerService StopSyncRemoteMissionsInner
1965  * EnvConditions: NA
1966  * CaseDescription: Verify the function StopSyncRemoteMissionsInner is normal flow.
1967  */
1968 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StopSyncRemoteMissionsInner_001, TestSize.Level1)
1969 {
1970     MessageParcel data;
1971     MessageParcel reply;
1972     auto res = stub_->StopSyncRemoteMissionsInner(data, reply);
1973     EXPECT_EQ(res, NO_ERROR);
1974 }
1975 
1976 /*
1977  * Feature: AbilityManagerService
1978  * Function: RegisterRemoteMissionListenerInner
1979  * SubFunction: NA
1980  * FunctionPoints: AbilityManagerService RegisterRemoteMissionListenerInner
1981  * EnvConditions: NA
1982  * CaseDescription: Verify the function RegisterRemoteMissionListenerInner is normal flow.
1983  */
1984 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterRemoteMissionListenerInner_001, TestSize.Level1)
1985 {
1986     MessageParcel data;
1987     MessageParcel reply;
1988     auto res = stub_->RegisterRemoteMissionListenerInner(data, reply);
1989     EXPECT_EQ(res, INVALID_PARAMETERS_ERR);
1990 }
1991 
1992 /*
1993  * Feature: AbilityManagerService
1994  * Function: UnRegisterRemoteMissionListenerInner
1995  * SubFunction: NA
1996  * FunctionPoints: AbilityManagerService UnRegisterRemoteMissionListenerInner
1997  * EnvConditions: NA
1998  * CaseDescription: Verify the function UnRegisterRemoteMissionListenerInner is normal flow.
1999  */
2000 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnRegisterRemoteMissionListenerInner_001, TestSize.Level1)
2001 {
2002     MessageParcel data;
2003     MessageParcel reply;
2004     auto res = stub_->UnRegisterRemoteMissionListenerInner(data, reply);
2005     EXPECT_EQ(res, INVALID_PARAMETERS_ERR);
2006 }
2007 
2008 /*
2009  * Feature: AbilityManagerService
2010  * Function: RegisterRemoteOnListenerInner
2011  * SubFunction: NA
2012  * FunctionPoints: AbilityManagerService RegisterRemoteOnListenerInner
2013  * EnvConditions: NA
2014  * CaseDescription: Verify the function RegisterRemoteOnListenerInner is normal flow.
2015  */
2016 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterRemoteOnListenerInner_001, TestSize.Level1)
2017 {
2018     MessageParcel data;
2019     MessageParcel reply;
2020     auto res = stub_->RegisterRemoteOnListenerInner(data, reply);
2021     EXPECT_EQ(res, ERR_NULL_OBJECT);
2022 }
2023 
2024 /**
2025  * @tc.name: SetResidentProcessEnableInner_001
2026  * @tc.desc: SetResidentProcessEnableInner
2027  * @tc.type: FUNC
2028  */
2029 HWTEST_F(AbilityManagerStubTest, SetResidentProcessEnableInner_001, TestSize.Level1)
2030 {
2031     ASSERT_NE(stub_, nullptr);
2032     MessageParcel data;
2033     MessageParcel reply;
2034     auto result = stub_->SetResidentProcessEnableInner(data, reply);
2035     EXPECT_EQ(result, NO_ERROR);
2036 }
2037 
2038 /*
2039  * Feature: AbilityManagerService
2040  * Function: RegisterRemoteOffListenerInner
2041  * SubFunction: NA
2042  * FunctionPoints: AbilityManagerService RegisterRemoteOffListenerInner
2043  * EnvConditions: NA
2044  * CaseDescription: Verify the function RegisterRemoteOffListenerInner is normal flow.
2045  */
2046 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterRemoteOffListenerInner_001, TestSize.Level1)
2047 {
2048     MessageParcel data;
2049     MessageParcel reply;
2050     auto res = stub_->RegisterRemoteOffListenerInner(data, reply);
2051     EXPECT_EQ(res, ERR_NULL_OBJECT);
2052 }
2053 
2054 /*
2055  * Feature: AbilityManagerService
2056  * Function: RegisterSnapshotHandlerInner
2057  * SubFunction: NA
2058  * FunctionPoints: AbilityManagerService RegisterSnapshotHandlerInner
2059  * EnvConditions: NA
2060  * CaseDescription: Verify the function RegisterSnapshotHandlerInner is normal flow.
2061  */
2062 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterSnapshotHandlerInner_001, TestSize.Level1)
2063 {
2064     MessageParcel data;
2065     MessageParcel reply;
2066     auto res = stub_->RegisterSnapshotHandlerInner(data, reply);
2067     EXPECT_EQ(res, ERR_NULL_OBJECT);
2068 }
2069 
2070 /*
2071  * Feature: AbilityManagerService
2072  * Function: GetMissionSnapshotInfoInner
2073  * SubFunction: NA
2074  * FunctionPoints: AbilityManagerService GetMissionSnapshotInfoInner
2075  * EnvConditions: NA
2076  * CaseDescription: Verify the function GetMissionSnapshotInfoInner is normal flow.
2077  */
2078 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetMissionSnapshotInfoInner_001, TestSize.Level1)
2079 {
2080     MessageParcel data;
2081     MessageParcel reply;
2082     auto res = stub_->GetMissionSnapshotInfoInner(data, reply);
2083     EXPECT_EQ(res, NO_ERROR);
2084 }
2085 
2086 /*
2087  * Feature: AbilityManagerService
2088  * Function: SetAbilityControllerInner
2089  * SubFunction: NA
2090  * FunctionPoints: AbilityManagerService SetAbilityControllerInner
2091  * EnvConditions: NA
2092  * CaseDescription: Verify the function SetAbilityControllerInner is normal flow.
2093  */
2094 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetAbilityControllerInner_001, TestSize.Level1)
2095 {
2096     MessageParcel data;
2097     MessageParcel reply;
2098     auto res = stub_->SetAbilityControllerInner(data, reply);
2099     EXPECT_EQ(res, ERR_NULL_OBJECT);
2100 }
2101 
2102 /*
2103  * Feature: AbilityManagerService
2104  * Function: IsRunningInStabilityTestInner
2105  * SubFunction: NA
2106  * FunctionPoints: AbilityManagerService IsRunningInStabilityTestInner
2107  * EnvConditions: NA
2108  * CaseDescription: Verify the function IsRunningInStabilityTestInner is normal flow.
2109  */
2110 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsRunningInStabilityTestInner_001, TestSize.Level1)
2111 {
2112     MessageParcel data;
2113     MessageParcel reply;
2114     auto res = stub_->IsRunningInStabilityTestInner(data, reply);
2115     EXPECT_EQ(res, NO_ERROR);
2116 }
2117 
2118 /*
2119  * Feature: AbilityManagerService
2120  * Function: StartUserTestInner
2121  * SubFunction: NA
2122  * FunctionPoints: AbilityManagerService StartUserTestInner
2123  * EnvConditions: NA
2124  * CaseDescription: Verify the function StartUserTestInner is normal flow.
2125  */
2126 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUserTestInner_001, TestSize.Level1)
2127 {
2128     MessageParcel data;
2129     MessageParcel reply;
2130     auto res = stub_->StartUserTestInner(data, reply);
2131     EXPECT_EQ(res, ERR_INVALID_VALUE);
2132 }
2133 
2134 /*
2135  * Feature: AbilityManagerService
2136  * Function: FinishUserTestInner
2137  * SubFunction: NA
2138  * FunctionPoints: AbilityManagerService FinishUserTestInner
2139  * EnvConditions: NA
2140  * CaseDescription: Verify the function FinishUserTestInner is normal flow.
2141  */
2142 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_FinishUserTestInner_001, TestSize.Level1)
2143 {
2144     MessageParcel data;
2145     MessageParcel reply;
2146     auto res = stub_->FinishUserTestInner(data, reply);
2147     EXPECT_EQ(res, NO_ERROR);
2148 }
2149 
2150 /*
2151  * Feature: AbilityManagerService
2152  * Function: GetTopAbilityTokenInner
2153  * SubFunction: NA
2154  * FunctionPoints: AbilityManagerService GetTopAbilityTokenInner
2155  * EnvConditions: NA
2156  * CaseDescription: Verify the function GetTopAbilityTokenInner is normal flow.
2157  */
2158 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetTopAbilityTokenInner_001, TestSize.Level1)
2159 {
2160     MessageParcel data;
2161     MessageParcel reply;
2162     auto res = stub_->GetTopAbilityTokenInner(data, reply);
2163     EXPECT_EQ(res, ERR_INVALID_VALUE);
2164 }
2165 
2166 /*
2167  * Feature: AbilityManagerStub
2168  * Function: CheckUIExtensionIsFocusedInner
2169  * SubFunction: NA
2170  * FunctionPoints: AbilityManagerService CheckUIExtensionIsFocusedInner
2171  * EnvConditions: NA
2172  * CaseDescription: Verify the function CheckUIExtensionIsFocused is normal flow.
2173  */
2174 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CheckUIExtensionIsFocusedInner_001, TestSize.Level1)
2175 {
2176     MessageParcel data;
2177     MessageParcel reply;
2178     auto res = stub_->CheckUIExtensionIsFocusedInner(data, reply);
2179     EXPECT_EQ(res, NO_ERROR);
2180 }
2181 
2182 
2183 /*
2184  * Feature: AbilityManagerService
2185  * Function: DelegatorDoAbilityForegroundInner
2186  * SubFunction: NA
2187  * FunctionPoints: AbilityManagerService DelegatorDoAbilityForegroundInner
2188  * EnvConditions: NA
2189  * CaseDescription: Verify the function DelegatorDoAbilityForegroundInner is normal flow.
2190  */
2191 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DelegatorDoAbilityForegroundInner_001, TestSize.Level1)
2192 {
2193     MessageParcel data;
2194     MessageParcel reply;
2195     auto res = stub_->DelegatorDoAbilityForegroundInner(data, reply);
2196     EXPECT_EQ(res, NO_ERROR);
2197 }
2198 
2199 /*
2200  * Feature: AbilityManagerService
2201  * Function: DelegatorDoAbilityBackgroundInner
2202  * SubFunction: NA
2203  * FunctionPoints: AbilityManagerService DelegatorDoAbilityBackgroundInner
2204  * EnvConditions: NA
2205  * CaseDescription: Verify the function DelegatorDoAbilityBackgroundInner is normal flow.
2206  */
2207 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DelegatorDoAbilityBackgroundInner_001, TestSize.Level1)
2208 {
2209     MessageParcel data;
2210     MessageParcel reply;
2211     auto res = stub_->DelegatorDoAbilityBackgroundInner(data, reply);
2212     EXPECT_EQ(res, NO_ERROR);
2213 }
2214 
2215 /*
2216  * Feature: AbilityManagerService
2217  * Function: DoAbilityForeground
2218  * SubFunction: NA
2219  * FunctionPoints: AbilityManagerService DoAbilityForeground
2220  * EnvConditions: NA
2221  * CaseDescription: Verify the function DoAbilityForeground is normal flow.
2222  */
2223 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DoAbilityForeground_001, TestSize.Level1)
2224 {
2225     sptr<IRemoteObject> token = nullptr;
2226     uint32_t flag = 0;
2227     auto res = stub_->DoAbilityForeground(token, flag);
2228     EXPECT_EQ(res, 0);
2229 }
2230 
2231 /*
2232  * Feature: AbilityManagerService
2233  * Function: DoAbilityBackground
2234  * SubFunction: NA
2235  * FunctionPoints: AbilityManagerService DoAbilityBackground
2236  * EnvConditions: NA
2237  * CaseDescription: Verify the function DoAbilityBackground is normal flow.
2238  */
2239 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DoAbilityBackground_001, TestSize.Level1)
2240 {
2241     sptr<IRemoteObject> token = nullptr;
2242     uint32_t flag = 0;
2243     auto res = stub_->DoAbilityBackground(token, flag);
2244     EXPECT_EQ(res, 0);
2245 }
2246 
2247 /*
2248  * Feature: AbilityManagerService
2249  * Function: DoAbilityForegroundInner
2250  * SubFunction: NA
2251  * FunctionPoints: AbilityManagerService DoAbilityForegroundInner
2252  * EnvConditions: NA
2253  * CaseDescription: Verify the function DoAbilityForegroundInner is normal flow.
2254  */
2255 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DoAbilityForegroundInner_001, TestSize.Level1)
2256 {
2257     MessageParcel data;
2258     MessageParcel reply;
2259     auto res = stub_->DoAbilityForegroundInner(data, reply);
2260     EXPECT_EQ(res, NO_ERROR);
2261 }
2262 
2263 /*
2264  * Feature: AbilityManagerService
2265  * Function: DoAbilityBackgroundInner
2266  * SubFunction: NA
2267  * FunctionPoints: AbilityManagerService DoAbilityBackgroundInner
2268  * EnvConditions: NA
2269  * CaseDescription: Verify the function DoAbilityBackgroundInner is normal flow.
2270  */
2271 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DoAbilityBackgroundInner_001, TestSize.Level1)
2272 {
2273     MessageParcel data;
2274     MessageParcel reply;
2275     auto res = stub_->DoAbilityBackgroundInner(data, reply);
2276     EXPECT_EQ(res, NO_ERROR);
2277 }
2278 
2279 /*
2280  * Feature: AbilityManagerService
2281  * Function: RegisterObserver
2282  * SubFunction: NA
2283  * FunctionPoints: AbilityManagerService RegisterObserver
2284  * EnvConditions: NA
2285  * CaseDescription: Verify the function RegisterObserver is normal flow.
2286  */
2287 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterObserver_001, TestSize.Level1)
2288 {
2289     sptr<AbilityRuntime::IConnectionObserver> observer = nullptr;
2290     auto res = stub_->RegisterObserver(observer);
2291     EXPECT_EQ(res, NO_ERROR);
2292 }
2293 
2294 /*
2295  * Feature: AbilityManagerService
2296  * Function: UnregisterObserver
2297  * SubFunction: NA
2298  * FunctionPoints: AbilityManagerService UnregisterObserver
2299  * EnvConditions: NA
2300  * CaseDescription: Verify the function UnregisterObserver is normal flow.
2301  */
2302 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterObserver_001, TestSize.Level1)
2303 {
2304     sptr<AbilityRuntime::IConnectionObserver> observer = nullptr;
2305     auto res = stub_->UnregisterObserver(observer);
2306     EXPECT_EQ(res, NO_ERROR);
2307 }
2308 
2309 #ifdef WITH_DLP
2310 /*
2311  * Feature: AbilityManagerService
2312  * Function: GetDlpConnectionInfos
2313  * SubFunction: NA
2314  * FunctionPoints: AbilityManagerService GetDlpConnectionInfos
2315  * EnvConditions: NA
2316  * CaseDescription: Verify the function GetDlpConnectionInfos is normal flow.
2317  */
2318 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetDlpConnectionInfos_001, TestSize.Level1)
2319 {
2320     std::vector<AbilityRuntime::DlpConnectionInfo> infos;
2321     auto res = stub_->GetDlpConnectionInfos(infos);
2322     EXPECT_EQ(res, NO_ERROR);
2323 }
2324 #endif // WITH_DLP
2325 
2326 /*
2327  * Feature: AbilityManagerService
2328  * Function: GetConnectionData
2329  * SubFunction: NA
2330  * FunctionPoints: AbilityManagerService GetConnectionData
2331  * EnvConditions: NA
2332  * CaseDescription: Verify the function GetConnectionData is normal flow.
2333  */
2334 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetConnectionData_001, TestSize.Level1)
2335 {
2336     std::vector<AbilityRuntime::ConnectionData> connectionData;
2337     auto res = stub_->GetConnectionData(connectionData);
2338     EXPECT_EQ(res, NO_ERROR);
2339 }
2340 
2341 #ifdef ABILITY_COMMAND_FOR_TEST
2342 /*
2343  * Feature: AbilityManagerService
2344  * Function: ForceTimeoutForTestInner
2345  * SubFunction: NA
2346  * FunctionPoints: AbilityManagerService ForceTimeoutForTestInner
2347  * EnvConditions: NA
2348  * CaseDescription: Verify the function ForceTimeoutForTestInner is normal flow.
2349  */
2350 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ForceTimeoutForTestInner_001, TestSize.Level1)
2351 {
2352     MessageParcel data;
2353     MessageParcel reply;
2354     auto res = stub_->ForceTimeoutForTestInner(data, reply);
2355     EXPECT_EQ(res, NO_ERROR);
2356 }
2357 #endif
2358 
2359 /*
2360  * Feature: AbilityManagerService
2361  * Function: FreeInstallAbilityFromRemoteInner
2362  * SubFunction: NA
2363  * FunctionPoints: AbilityManagerService FreeInstallAbilityFromRemoteInner
2364  * EnvConditions: NA
2365  * CaseDescription: Verify the function FreeInstallAbilityFromRemoteInner is normal flow.
2366  */
2367 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_FreeInstallAbilityFromRemoteInner_001, TestSize.Level1)
2368 {
2369     MessageParcel data;
2370     MessageParcel reply;
2371     auto res = stub_->FreeInstallAbilityFromRemoteInner(data, reply);
2372     EXPECT_EQ(res, ERR_INVALID_VALUE);
2373 }
2374 
2375 /*
2376  * Feature: AbilityManagerService
2377  * Function: AddFreeInstallObserverInner
2378  * SubFunction: NA
2379  * FunctionPoints: AbilityManagerService AddFreeInstallObserverInner
2380  * EnvConditions: NA
2381  * CaseDescription: Verify the function AddFreeInstallObserverInner is normal flow.
2382  */
2383 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AddFreeInstallObserverInner_001, TestSize.Level1)
2384 {
2385     MessageParcel data;
2386     MessageParcel reply;
2387     auto res = stub_->AddFreeInstallObserverInner(data, reply);
2388     EXPECT_EQ(res, ERR_INVALID_VALUE);
2389 }
2390 
2391 /*
2392  * Feature: AbilityManagerService
2393  * Function: DumpAbilityInfoDoneInner
2394  * SubFunction: NA
2395  * FunctionPoints: AbilityManagerService DumpAbilityInfoDoneInner
2396  * EnvConditions: NA
2397  * CaseDescription: Verify the function DumpAbilityInfoDoneInner is normal flow.
2398  */
2399 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DumpAbilityInfoDoneInner_001, TestSize.Level1)
2400 {
2401     MessageParcel data;
2402     MessageParcel reply;
2403     auto res = stub_->DumpAbilityInfoDoneInner(data, reply);
2404     EXPECT_EQ(res, NO_ERROR);
2405 }
2406 
2407 /*
2408  * Feature: AbilityManagerService
2409  * Function: UpdateMissionSnapShotFromWMSInner
2410  * SubFunction: NA
2411  * FunctionPoints: AbilityManagerService UpdateMissionSnapShotFromWMSInner
2412  * EnvConditions: NA
2413  * CaseDescription: Verify the function UpdateMissionSnapShotFromWMSInner is normal flow.
2414  */
2415 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UpdateMissionSnapShotFromWMSInner_001, TestSize.Level1)
2416 {
2417     MessageParcel data;
2418     MessageParcel reply;
2419     auto res = stub_->UpdateMissionSnapShotFromWMSInner(data, reply);
2420     EXPECT_EQ(res, ERR_NULL_OBJECT);
2421 }
2422 
2423 /*
2424  * Feature: AbilityManagerService
2425  * Function: EnableRecoverAbilityInner
2426  * SubFunction: NA
2427  * FunctionPoints: AbilityManagerService EnableRecoverAbilityInner
2428  * EnvConditions: NA
2429  * CaseDescription: Verify the function EnableRecoverAbilityInner is normal flow.
2430  */
2431 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_EnableRecoverAbilityInner_001, TestSize.Level1)
2432 {
2433     MessageParcel data;
2434     MessageParcel reply;
2435     auto res = stub_->EnableRecoverAbilityInner(data, reply);
2436     EXPECT_EQ(res, ERR_NULL_OBJECT);
2437 }
2438 
2439 /*
2440  * Feature: AbilityManagerService
2441  * Function: HandleRequestDialogService
2442  * SubFunction: NA
2443  * FunctionPoints: AbilityManagerService HandleRequestDialogService
2444  * EnvConditions: NA
2445  * CaseDescription: Verify the function HandleRequestDialogService is normal flow.
2446  */
2447 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_HandleRequestDialogService_001, TestSize.Level1)
2448 {
2449     MessageParcel data;
2450     MessageParcel reply;
2451     auto res = stub_->HandleRequestDialogService(data, reply);
2452     EXPECT_EQ(res, ERR_INVALID_VALUE);
2453 }
2454 
2455 /**
2456  * @tc.number: HandleReportDrawnCompleted_001
2457  * @tc.name: HandleReportDrawnCompleted
2458  * @tc.desc: Returns ERR_INVALID_VALUE after passing in parameters
2459  */
2460 HWTEST_F(AbilityManagerStubTest, HandleReportDrawnCompleted_001, TestSize.Level1)
2461 {
2462     MessageParcel data;
2463     MessageParcel reply;
2464     auto res = stub_->HandleReportDrawnCompleted(data, reply);
2465     EXPECT_EQ(res, ERR_INVALID_VALUE);
2466 }
2467 
2468 /*
2469  * Feature: AbilityManagerService
2470  * Function: AcquireShareDataInner
2471  * SubFunction: NA
2472  * FunctionPoints: AbilityManagerService AcquireShareDataInner
2473  * EnvConditions: NA
2474  * CaseDescription: Verify the function AcquireShareDataInner is normal flow.
2475  */
2476 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AcquireShareDataInner_001, TestSize.Level1)
2477 {
2478     MessageParcel data;
2479     MessageParcel reply;
2480     auto res = stub_->AcquireShareDataInner(data, reply);
2481     EXPECT_EQ(res, ERR_INVALID_VALUE);
2482 }
2483 
2484 /*
2485  * Feature: AbilityManagerService
2486  * Function: ShareDataDoneInner
2487  * SubFunction: NA
2488  * FunctionPoints: AbilityManagerService ShareDataDoneInner
2489  * EnvConditions: NA
2490  * CaseDescription: Verify the function ShareDataDoneInner is normal flow.
2491  */
2492 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ShareDataDoneInner_001, TestSize.Level1)
2493 {
2494     MessageParcel data;
2495     MessageParcel reply;
2496     auto res = stub_->ShareDataDoneInner(data, reply);
2497     EXPECT_EQ(res, ERR_NULL_OBJECT);
2498 }
2499 
2500 /*
2501  * Feature: AbilityManagerService
2502  * Function: GetAbilityTokenByCalleeObjInner
2503  * SubFunction: NA
2504  * FunctionPoints: AbilityManagerService GetAbilityTokenByCalleeObjInner
2505  * EnvConditions: NA
2506  * CaseDescription: Verify the function GetAbilityTokenByCalleeObjInner is normal flow.
2507  */
2508 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetAbilityTokenByCalleeObjInner_001, TestSize.Level1)
2509 {
2510     MessageParcel data;
2511     MessageParcel reply;
2512     auto res = stub_->GetAbilityTokenByCalleeObjInner(data, reply);
2513     EXPECT_EQ(res, ERR_NULL_OBJECT);
2514 }
2515 
2516 #ifdef ABILITY_COMMAND_FOR_TEST
2517 /*
2518  * Feature: AbilityManagerService
2519  * Function: ScheduleRecoverAbilityInner
2520  * SubFunction: NA
2521  * FunctionPoints: AbilityManagerService ScheduleRecoverAbilityInner
2522  * EnvConditions: NA
2523  * CaseDescription: Verify the function ScheduleRecoverAbilityInner is normal flow.
2524  */
2525 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ScheduleRecoverAbilityInner_001, TestSize.Level1)
2526 {
2527     MessageParcel data;
2528     MessageParcel reply;
2529     auto res = stub_->ScheduleRecoverAbilityInner(data, reply);
2530     EXPECT_EQ(res, ERR_NULL_OBJECT);
2531 }
2532 #endif
2533 
2534 #ifdef ABILITY_COMMAND_FOR_TEST
2535 /*
2536  * Feature: AbilityManagerService
2537  * Function: EnableRecoverAbilityInner
2538  * SubFunction: NA
2539  * FunctionPoints: AbilityManagerService EnableRecoverAbilityInner
2540  * EnvConditions: NA
2541  * CaseDescription: Verify the function EnableRecoverAbilityInner is normal flow.
2542  */
2543 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_EnableRecoverAbilityInner_001, TestSize.Level1)
2544 {
2545     MessageParcel data;
2546     MessageParcel reply;
2547     auto res = stub_->EnableRecoverAbilityInner(data, reply);
2548     EXPECT_EQ(res, ERR_NULL_OBJECT);
2549 }
2550 #endif
2551 
2552 /*
2553  * Feature: AbilityManagerService
2554  * Function: RegisterConnectionObserverInner
2555  * SubFunction: NA
2556  * FunctionPoints: AbilityManagerService RegisterConnectionObserverInner
2557  * EnvConditions: NA
2558  * CaseDescription: Verify the function RegisterConnectionObserverInner is normal flow.
2559  */
2560 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterConnectionObserverInner_001, TestSize.Level1)
2561 {
2562     MessageParcel data;
2563     MessageParcel reply;
2564     auto res = stub_->RegisterConnectionObserverInner(data, reply);
2565     EXPECT_EQ(res, ERR_NULL_OBJECT);
2566 }
2567 
2568 /*
2569  * Feature: AbilityManagerService
2570  * Function: UnregisterConnectionObserverInner
2571  * SubFunction: NA
2572  * FunctionPoints: AbilityManagerService UnregisterConnectionObserverInner
2573  * EnvConditions: NA
2574  * CaseDescription: Verify the function UnregisterConnectionObserverInner is normal flow.
2575  */
2576 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterConnectionObserverInner_001, TestSize.Level1)
2577 {
2578     MessageParcel data;
2579     MessageParcel reply;
2580     auto res = stub_->UnregisterConnectionObserverInner(data, reply);
2581     EXPECT_EQ(res, ERR_NULL_OBJECT);
2582 }
2583 
2584 #ifdef WITH_DLP
2585 /*
2586  * Feature: AbilityManagerService
2587  * Function: GetDlpConnectionInfosInner
2588  * SubFunction: NA
2589  * FunctionPoints: AbilityManagerService GetDlpConnectionInfosInner
2590  * EnvConditions: NA
2591  * CaseDescription: Verify the function GetDlpConnectionInfosInner is normal flow.
2592  */
2593 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetDlpConnectionInfosInner_001, TestSize.Level1)
2594 {
2595     MessageParcel data;
2596     MessageParcel reply;
2597     auto res = stub_->GetDlpConnectionInfosInner(data, reply);
2598     EXPECT_EQ(res, ERR_OK);
2599 }
2600 #endif // WITH_DLP
2601 
2602 /*
2603  * Feature: AbilityManagerService
2604  * Function: GetConnectionDataInner
2605  * SubFunction: NA
2606  * FunctionPoints: AbilityManagerService GetConnectionDataInner
2607  * EnvConditions: NA
2608  * CaseDescription: Verify the function GetConnectionDataInner is normal flow.
2609  */
2610 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetConnectionDataInner_001, TestSize.Level1)
2611 {
2612     MessageParcel data;
2613     MessageParcel reply;
2614     auto res = stub_->GetConnectionDataInner(data, reply);
2615     EXPECT_EQ(res, ERR_OK);
2616 }
2617 
2618 /*
2619  * Feature: AbilityManagerService
2620  * Function: SetMissionContinueStateInner
2621  * SubFunction: NA
2622  * FunctionPoints: AbilityManagerService SetMissionContinueStateInner
2623  * EnvConditions: NA
2624  * CaseDescription: Verify the function SetMissionContinueStateInner is normal flow.
2625  */
2626 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetMissionContinueStateInner_001, TestSize.Level1)
2627 {
2628     MessageParcel data;
2629     MessageParcel reply;
2630     auto res = stub_->SetMissionContinueStateInner(data, reply);
2631     EXPECT_EQ(res, ERR_NULL_OBJECT);
2632 }
2633 
2634 /*
2635  * Feature: AbilityManagerService
2636  * Function: SetMissionLabelInner
2637  * SubFunction: NA
2638  * FunctionPoints: AbilityManagerService SetMissionLabelInner
2639  * EnvConditions: NA
2640  * CaseDescription: Verify the function SetMissionLabelInner is normal flow.
2641  */
2642 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetMissionLabelInner_001, TestSize.Level1)
2643 {
2644     MessageParcel data;
2645     MessageParcel reply;
2646     auto res = stub_->SetMissionLabelInner(data, reply);
2647     EXPECT_EQ(res, ERR_NULL_OBJECT);
2648 }
2649 
2650 /*
2651  * Feature: AbilityManagerService
2652  * Function: SetMissionIconInner
2653  * SubFunction: NA
2654  * FunctionPoints: AbilityManagerService SetMissionIconInner
2655  * EnvConditions: NA
2656  * CaseDescription: Verify the function SetMissionIconInner is normal flow.
2657  */
2658 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetMissionIconInner_001, TestSize.Level1)
2659 {
2660     MessageParcel data;
2661     MessageParcel reply;
2662     auto res = stub_->SetMissionIconInner(data, reply);
2663     EXPECT_EQ(res, ERR_NULL_OBJECT);
2664 }
2665 
2666 /*
2667  * Feature: AbilityManagerService
2668  * Function: RegisterWindowManagerServiceHandlerInner
2669  * SubFunction: NA
2670  * FunctionPoints: AbilityManagerService RegisterWindowManagerServiceHandlerInner
2671  * EnvConditions: NA
2672  * CaseDescription: Verify the function RegisterWindowManagerServiceHandlerInner is normal flow.
2673  */
2674 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterWindowManagerServiceHandlerInner_001, TestSize.Level1)
2675 {
2676     MessageParcel data;
2677     MessageParcel reply;
2678     auto res = stub_->RegisterWindowManagerServiceHandlerInner(data, reply);
2679     EXPECT_EQ(res, ERR_NULL_OBJECT);
2680 }
2681 
2682 /*
2683  * Feature: AbilityManagerService
2684  * Function: CompleteFirstFrameDrawingInner
2685  * SubFunction: NA
2686  * FunctionPoints: AbilityManagerService CompleteFirstFrameDrawingInner
2687  * EnvConditions: NA
2688  * CaseDescription: Verify the function CompleteFirstFrameDrawingInner is normal flow.
2689  */
2690 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CompleteFirstFrameDrawingInner_001, TestSize.Level1)
2691 {
2692     MessageParcel data;
2693     MessageParcel reply;
2694     auto res = stub_->CompleteFirstFrameDrawingInner(data, reply);
2695     EXPECT_EQ(res, ERR_NULL_OBJECT);
2696 }
2697 
2698 /*
2699  * Feature: AbilityManagerService
2700  * Function: CompleteFirstFrameDrawingBySCBInner
2701  * SubFunction: NA
2702  * FunctionPoints: AbilityManagerService CompleteFirstFrameDrawingBySCBInner
2703  * EnvConditions: NA
2704  * CaseDescription: Verify the function CompleteFirstFrameDrawingBySCBInner is normal flow.
2705  */
2706 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CompleteFirstFrameDrawingBySCBInner_001, TestSize.Level1)
2707 {
2708     MessageParcel data;
2709     MessageParcel reply;
2710     auto res = stub_->CompleteFirstFrameDrawingBySCBInner(data, reply);
2711     EXPECT_EQ(res, NO_ERROR);
2712 }
2713 
2714 /*
2715  * Feature: AbilityManagerService
2716  * Function: GetDialogSessionInfoInner
2717  * SubFunction: NA
2718  * FunctionPoints: AbilityManagerService GetDialogSessionInfoInner
2719  * EnvConditions: NA
2720  * CaseDescription: Verify the function GetDialogSessionInfoInner is normal flow.
2721  */
2722 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetDialogSessionInfoInner_001, TestSize.Level1)
2723 {
2724     MessageParcel data;
2725     MessageParcel reply;
2726     auto res = stub_->GetDialogSessionInfoInner(data, reply);
2727     EXPECT_EQ(res, ERR_INVALID_VALUE);
2728 }
2729 
2730 /*
2731  * Feature: AbilityManagerService
2732  * Function: SendDialogResultInner
2733  * SubFunction: NA
2734  * FunctionPoints: AbilityManagerService SendDialogResultInner
2735  * EnvConditions: NA
2736  * CaseDescription: Verify the function SendDialogResultInner is normal flow.
2737  */
2738 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SendDialogResultInner_001, TestSize.Level1)
2739 {
2740     MessageParcel data;
2741     MessageParcel reply;
2742     auto res = stub_->SendDialogResultInner(data, reply);
2743     EXPECT_EQ(res, ERR_INVALID_VALUE);
2744 }
2745 
2746 /*
2747  * Feature: AbilityManagerService
2748  * Function: RegisterAbilityFirstFrameStateObserverInner
2749  * SubFunction: NA
2750  * FunctionPoints: AbilityManagerService RegisterAbilityFirstFrameStateObserverInner
2751  * EnvConditions: NA
2752  * CaseDescription: Verify the function RegisterAbilityFirstFrameStateObserverInner is normal flow.
2753  */
2754 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterAbilityFirstFrameStateObserverInner_001, TestSize.Level1)
2755 {
2756     MessageParcel data;
2757     MessageParcel reply;
2758     auto res = stub_->RegisterAbilityFirstFrameStateObserverInner(data, reply);
2759     EXPECT_EQ(res, ERR_INVALID_VALUE);
2760 }
2761 
2762 /*
2763  * Feature: AbilityManagerService
2764  * Function: UnregisterAbilityFirstFrameStateObserverInner
2765  * SubFunction: NA
2766  * FunctionPoints: AbilityManagerService UnregisterAbilityFirstFrameStateObserverInner
2767  * EnvConditions: NA
2768  * CaseDescription: Verify the function UnregisterAbilityFirstFrameStateObserverInner is normal flow.
2769  */
2770 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterAbilityFirstFrameStateObserverInner_001, TestSize.Level1)
2771 {
2772     MessageParcel data;
2773     MessageParcel reply;
2774     auto res = stub_->UnregisterAbilityFirstFrameStateObserverInner(data, reply);
2775     EXPECT_EQ(res, ERR_INVALID_VALUE);
2776 }
2777 
2778 /*
2779  * Feature: AbilityManagerService
2780  * Function: CallRequestDone
2781  * SubFunction: NA
2782  * FunctionPoints: AbilityManagerService CallRequestDone
2783  * EnvConditions: NA
2784  * CaseDescription: Verify the function CallRequestDone is normal flow.
2785  */
2786 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CallRequestDone_001, TestSize.Level1)
2787 {
2788     sptr<IRemoteObject> token = nullptr;
2789     sptr<IRemoteObject> callStub = nullptr;
2790     stub_->CallRequestDone(token, callStub);
2791     EXPECT_TRUE(true);
2792 }
2793 
2794 /*
2795  * Feature: AbilityManagerService
2796  * Function: IsValidMissionIdsInner
2797  * SubFunction: NA
2798  * FunctionPoints: AbilityManagerService IsValidMissionIdsInner
2799  * EnvConditions: NA
2800  * CaseDescription: Verify the function IsValidMissionIdsInner is normal flow.
2801  */
2802 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsValidMissionIdsInner_001, TestSize.Level1)
2803 {
2804     MessageParcel data;
2805     MessageParcel reply;
__anon383db82a0202(const std::vector<int32_t>& ids, std::vector<MissionValidResult>& results) 2806     auto isValidMissionIdsTask = [&](const std::vector<int32_t>& ids, std::vector<MissionValidResult>& results) {
2807         MissionValidResult result;
2808         result.missionId = 1;
2809         result.isValid = true;
2810         results.push_back(result);
2811         return ERR_OK;
2812     };
2813     EXPECT_CALL(*stub_, IsValidMissionIds(_, _)).Times(1).WillOnce(testing::Invoke(isValidMissionIdsTask));
2814     EXPECT_EQ(stub_->IsValidMissionIdsInner(data, reply), NO_ERROR);
2815 }
2816 
2817 /*
2818  * Feature: AbilityManagerService
2819  * Function: IsValidMissionIdsInner
2820  * SubFunction: NA
2821  * FunctionPoints: AbilityManagerService IsValidMissionIdsInner
2822  * EnvConditions: NA
2823  * CaseDescription: Verify the function IsValidMissionIdsInner is normal flow.
2824  */
2825 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsValidMissionIdsInner_002, TestSize.Level1)
2826 {
2827     MessageParcel data;
2828     MessageParcel reply;
__anon383db82a0302(const std::vector<int32_t>& ids, std::vector<MissionValidResult>& results) 2829     auto isValidMissionIdsTask = [&](const std::vector<int32_t>& ids, std::vector<MissionValidResult>& results) {
2830         GTEST_LOG_(INFO) << "AbilityManagerStub_IsValidMissionIdsInner_002 caller";
2831         return ERR_INVALID_VALUE;
2832     };
2833     EXPECT_CALL(*stub_, IsValidMissionIds(_, _)).Times(1).WillOnce(testing::Invoke(isValidMissionIdsTask));
2834     EXPECT_EQ(stub_->IsValidMissionIdsInner(data, reply), NO_ERROR);
2835 }
2836 
2837 /*
2838  * Feature: AbilityManagerService
2839  * Function: ForceExitAppInner
2840  * SubFunction: NA
2841  * FunctionPoints: AbilityManagerService ForceExitAppInner
2842  * EnvConditions: NA
2843  * CaseDescription: Verify the function ForceExitAppInner is normal flow.
2844  */
2845 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ForceExitAppInner_001, TestSize.Level1)
2846 {
2847     MessageParcel data;
2848     MessageParcel reply;
2849     auto res = stub_->ForceExitAppInner(data, reply);
2850     EXPECT_EQ(res, ERR_INVALID_VALUE);
2851 }
2852 
2853 /*
2854  * Feature: AbilityManagerService
2855  * Function: RecordAppExitReasonInner
2856  * SubFunction: NA
2857  * FunctionPoints: AbilityManagerService RecordAppExitReasonInner
2858  * EnvConditions: NA
2859  * CaseDescription: Verify the function RecordAppExitReasonInner is normal flow.
2860  */
2861 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RecordAppExitReasonInner_001, TestSize.Level1)
2862 {
2863     MessageParcel data;
2864     MessageParcel reply;
2865     auto res = stub_->RecordAppExitReasonInner(data, reply);
2866     EXPECT_EQ(res, ERR_INVALID_VALUE);
2867 }
2868 
2869 /*
2870  * Feature: AbilityManagerService
2871  * Function: RecordProcessExitReasonInner
2872  * SubFunction: NA
2873  * FunctionPoints: AbilityManagerService RecordProcessExitReasonInner
2874  * EnvConditions: NA
2875  * CaseDescription: Verify the function RecordProcessExitReasonInner is normal flow.
2876  */
2877 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RecordProcessExitReasonInner_001, TestSize.Level1)
2878 {
2879     MessageParcel data;
2880     MessageParcel reply;
2881     auto res = stub_->RecordProcessExitReasonInner(data, reply);
2882     EXPECT_EQ(res, ERR_INVALID_VALUE);
2883 }
2884 
2885 /*
2886  * Feature: AbilityManagerService
2887  * Function: SetRootSceneSessionInner
2888  * SubFunction: NA
2889  * FunctionPoints: AbilityManagerService SetRootSceneSessionInner
2890  * EnvConditions: NA
2891  * CaseDescription: Verify the function SetRootSceneSessionInner is normal flow.
2892  */
2893 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetRootSceneSessionInner_001, TestSize.Level1)
2894 {
2895     MessageParcel data;
2896     MessageParcel reply;
2897     auto res = stub_->SetRootSceneSessionInner(data, reply);
2898     EXPECT_EQ(res, ERR_INVALID_VALUE);
2899 }
2900 
2901 /*
2902  * Feature: AbilityManagerService
2903  * Function: CallUIAbilityBySCBInner
2904  * SubFunction: NA
2905  * FunctionPoints: AbilityManagerService CallUIAbilityBySCBInner
2906  * EnvConditions: NA
2907  * CaseDescription: Verify the function CallUIAbilityBySCBInner is normal flow.
2908  */
2909 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CallUIAbilityBySCBInner_001, TestSize.Level1)
2910 {
2911     MessageParcel data;
2912     MessageParcel reply;
2913     auto res = stub_->CallUIAbilityBySCBInner(data, reply);
2914     EXPECT_EQ(res, NO_ERROR);
2915 }
2916 
2917 /*
2918  * Feature: AbilityManagerService
2919  * Function: SetSessionManagerServiceInner
2920  * SubFunction: NA
2921  * FunctionPoints: AbilityManagerService SetSessionManagerServiceInner
2922  * EnvConditions: NA
2923  * CaseDescription: Verify the function SetSessionManagerServiceInner is normal flow.
2924  */
2925 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetSessionManagerServiceInner_001, TestSize.Level1)
2926 {
2927     MessageParcel data;
2928     MessageParcel reply;
2929     auto res = stub_->CallUIAbilityBySCBInner(data, reply);
2930     EXPECT_EQ(res, NO_ERROR);
2931 }
2932 
2933 /*
2934  * Feature: AbilityManagerService
2935  * Function: RegisterIAbilityManagerCollaboratorInner
2936  * SubFunction: NA
2937  * FunctionPoints: AbilityManagerService RegisterIAbilityManagerCollaboratorInner
2938  * EnvConditions: NA
2939  * CaseDescription: Verify the function RegisterIAbilityManagerCollaboratorInner is normal flow.
2940  */
2941 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterIAbilityManagerCollaboratorInner_001, TestSize.Level1)
2942 {
2943     MessageParcel data;
2944     MessageParcel reply;
2945     auto res = stub_->RegisterIAbilityManagerCollaboratorInner(data, reply);
2946     EXPECT_EQ(res, ERR_NULL_OBJECT);
2947 }
2948 
2949 /*
2950  * Feature: AbilityManagerService
2951  * Function: UnregisterIAbilityManagerCollaboratorInner
2952  * SubFunction: NA
2953  * FunctionPoints: AbilityManagerService UnregisterIAbilityManagerCollaboratorInner
2954  * EnvConditions: NA
2955  * CaseDescription: Verify the function UnregisterIAbilityManagerCollaboratorInner is normal flow.
2956  */
2957 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterIAbilityManagerCollaboratorInner_001, TestSize.Level1)
2958 {
2959     MessageParcel data;
2960     MessageParcel reply;
2961     auto res = stub_->UnregisterIAbilityManagerCollaboratorInner(data, reply);
2962     EXPECT_EQ(res, NO_ERROR);
2963 }
2964 
2965 /*
2966  * Feature: AbilityManagerService
2967  * Function: PrepareTerminateAbilityBySCBInner
2968  * SubFunction: NA
2969  * FunctionPoints: AbilityManagerService PrepareTerminateAbilityBySCBInner
2970  * EnvConditions: NA
2971  * CaseDescription: Verify the normal process of PrepareTerminateAbilityBySCB.
2972  */
2973 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_PrepareTerminateAbilityBySCBInner_002, TestSize.Level1)
2974 {
2975     MessageParcel data;
2976     MessageParcel reply;
__anon383db82a0402(const sptr<SessionInfo> &sessionInfo, bool &isTerminate) 2977     auto prepareTerminateAbilityBySCBTask = [](const sptr<SessionInfo> &sessionInfo, bool &isTerminate) {
2978         GTEST_LOG_(INFO) << "AbilityManagerStub_IsValidMissionIdsInner_002 caller";
2979         return ERR_INVALID_VALUE;
2980     };
2981     EXPECT_CALL(*stub_, PrepareTerminateAbilityBySCB(_, _)).Times(1).WillOnce(
2982         testing::Invoke(prepareTerminateAbilityBySCBTask));
2983     EXPECT_EQ(stub_->PrepareTerminateAbilityBySCBInner(data, reply), ERR_INVALID_VALUE);
2984 }
2985 
2986 /*
2987  * Feature: AbilityManagerService
2988  * Function: RegisterStatusBarDelegateInner
2989  * SubFunction: NA
2990  * FunctionPoints: AbilityManagerService RegisterStatusBarDelegateInner
2991  * EnvConditions: NA
2992  * CaseDescription: Verify the function RegisterStatusBarDelegateInner is normal flow.
2993  */
2994 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterStatusBarDelegateInner_001, TestSize.Level1)
2995 {
2996     MessageParcel data;
2997     MessageParcel reply;
2998     auto res = stub_->RegisterStatusBarDelegateInner(data, reply);
2999     EXPECT_EQ(res, ERR_NULL_OBJECT);
3000 }
3001 
3002 /*
3003  * Feature: AbilityManagerService
3004  * Function: KillProcessWithPrepareTerminateInner
3005  * SubFunction: NA
3006  * FunctionPoints: AbilityManagerService KillProcessWithPrepareTerminateInner
3007  * EnvConditions: NA
3008  * CaseDescription: Verify the function KillProcessWithPrepareTerminateInner is normal flow.
3009  */
3010 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_KillProcessWithPrepareTerminateInner_001, TestSize.Level1)
3011 {
3012     MessageParcel data;
3013     MessageParcel reply;
3014     auto res = stub_->KillProcessWithPrepareTerminateInner(data, reply);
3015     EXPECT_EQ(res, ERR_INVALID_VALUE);
3016 }
3017 
3018 /*
3019  * Feature: AbilityManagerService
3020  * Function: RegisterSessionHandlerInner
3021  * SubFunction: NA
3022  * FunctionPoints: AbilityManagerService RegisterSessionHandlerInner
3023  * EnvConditions: NA
3024  * CaseDescription: Verify the function RegisterSessionHandlerInner is normal flow.
3025  */
3026 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterSessionHandlerInner_001, TestSize.Level1)
3027 {
3028     MessageParcel data;
3029     MessageParcel reply;
3030     auto res = stub_->RegisterSessionHandlerInner(data, reply);
3031     EXPECT_EQ(res, ERR_INVALID_VALUE);
3032 }
3033 
3034 /*
3035  * Feature: AbilityManagerService
3036  * Function: StartSpecifiedAbilityBySCBInner
3037  * SubFunction: NA
3038  * FunctionPoints: AbilityManagerService StartSpecifiedAbilityBySCBInner
3039  * EnvConditions: NA
3040  * CaseDescription: Verify the function StartSpecifiedAbilityBySCBInner is normal flow.
3041  */
3042 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartSpecifiedAbilityBySCBInner_001, TestSize.Level1)
3043 {
3044     MessageParcel data;
3045     MessageParcel reply;
3046     auto res = stub_->StartSpecifiedAbilityBySCBInner(data, reply);
3047     EXPECT_EQ(res, ERR_INVALID_VALUE);
3048 }
3049 
3050 /*
3051  * Feature: AbilityManagerService
3052  * Function: StartSpecifiedAbilityBySCBInner
3053  * SubFunction: NA
3054  * FunctionPoints: AbilityManagerService StartSpecifiedAbilityBySCBInner
3055  * EnvConditions: NA
3056  * CaseDescription: Verify the function StartSpecifiedAbilityBySCBInner is normal flow.
3057  */
3058 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartSpecifiedAbilityBySCBInner_002, TestSize.Level1)
3059 {
3060     MessageParcel data;
3061     MessageParcel reply;
3062     Want want;
3063     data.WriteParcelable(&want);
3064     EXPECT_EQ(stub_->StartSpecifiedAbilityBySCBInner(data, reply), NO_ERROR);
3065 }
3066 
3067 /*
3068  * Feature: AbilityManagerService
3069  * Function: IsAbilityControllerStartInner
3070  * SubFunction: NA
3071  * FunctionPoints: AbilityManagerService IsAbilityControllerStartInner
3072  * EnvConditions: NA
3073  * CaseDescription: Verify the function IsAbilityControllerStartInner is normal flow.
3074  */
3075 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsAbilityControllerStartInner_001, TestSize.Level1)
3076 {
3077     MessageParcel data;
3078     MessageParcel reply;
3079     Want want;
3080     data.WriteParcelable(&want);
3081     EXPECT_EQ(stub_->IsAbilityControllerStartInner(data, reply), NO_ERROR);
3082 }
3083 
3084 /*
3085  * Feature: AbilityManagerService
3086  * Function: ExecuteIntentInner
3087  * SubFunction: NA
3088  * FunctionPoints: AbilityManagerService ExecuteIntentInner
3089  * EnvConditions: NA
3090  * CaseDescription: Verify the function ExecuteIntentInner is normal flow.
3091  */
3092 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ExecuteIntentInner_001, TestSize.Level1)
3093 {
3094     MessageParcel data;
3095     MessageParcel reply;
3096     auto res = stub_->ExecuteIntentInner(data, reply);
3097     EXPECT_EQ(res, ERR_INVALID_VALUE);
3098 }
3099 
3100 /*
3101  * Feature: AbilityManagerService
3102  * Function: StartAbilityByInsightIntentInner
3103  * SubFunction: NA
3104  * FunctionPoints: AbilityManagerService StartAbilityByInsightIntentInner
3105  * EnvConditions: NA
3106  * CaseDescription: Verify the function StartAbilityByInsightIntentInner is normal flow.
3107  */
3108 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityByInsightIntentInner_001, TestSize.Level1)
3109 {
3110     MessageParcel data;
3111     MessageParcel reply;
3112     auto res = stub_->StartAbilityByInsightIntentInner(data, reply);
3113     EXPECT_EQ(res, ERR_INVALID_VALUE);
3114 }
3115 
3116 /*
3117  * Feature: AbilityManagerService
3118  * Function: ExecuteInsightIntentDoneInner
3119  * SubFunction: NA
3120  * FunctionPoints: AbilityManagerService ExecuteInsightIntentDoneInner
3121  * EnvConditions: NA
3122  * CaseDescription: Verify the function ExecuteInsightIntentDoneInner is normal flow.
3123  */
3124 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ExecuteInsightIntentDoneInner_001, TestSize.Level1)
3125 {
3126     MessageParcel data;
3127     MessageParcel reply;
3128     auto res = stub_->ExecuteInsightIntentDoneInner(data, reply);
3129     EXPECT_EQ(res, ERR_INVALID_VALUE);
3130 }
3131 
3132 /*
3133  * Feature: AbilityManagerService
3134  * Function: SetApplicationAutoStartupByEDMInner
3135  * SubFunction: NA
3136  * FunctionPoints: AbilityManagerService SetApplicationAutoStartupByEDMInner
3137  * EnvConditions: NA
3138  * CaseDescription: Verify the function SetApplicationAutoStartupByEDMInner is normal flow.
3139  */
3140 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetApplicationAutoStartupByEDMInner_001, TestSize.Level1)
3141 {
3142     MessageParcel data;
3143     MessageParcel reply;
3144     auto res = stub_->SetApplicationAutoStartupByEDMInner(data, reply);
3145     EXPECT_EQ(res, ERR_INVALID_VALUE);
3146 }
3147 
3148 /*
3149  * Feature: AbilityManagerService
3150  * Function: CancelApplicationAutoStartupByEDMInner
3151  * SubFunction: NA
3152  * FunctionPoints: AbilityManagerService CancelApplicationAutoStartupByEDMInner
3153  * EnvConditions: NA
3154  * CaseDescription: Verify the function CancelApplicationAutoStartupByEDMInner is normal flow.
3155  */
3156 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CancelApplicationAutoStartupByEDMInner_001, TestSize.Level1)
3157 {
3158     MessageParcel data;
3159     MessageParcel reply;
3160     auto res = stub_->CancelApplicationAutoStartupByEDMInner(data, reply);
3161     EXPECT_EQ(res, ERR_INVALID_VALUE);
3162 }
3163 
3164 /*
3165  * Feature: AbilityManagerService
3166  * Function: OpenFileInner
3167  * SubFunction: NA
3168  * FunctionPoints: AbilityManagerService OpenFileInner
3169  * EnvConditions: NA
3170  * CaseDescription: Verify the function OpenFileInner is normal flow.
3171  */
3172 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_OpenFileInner_001, TestSize.Level1)
3173 {
3174     MessageParcel data;
3175     MessageParcel reply;
3176     auto res = stub_->OpenFileInner(data, reply);
3177     EXPECT_EQ(res, ERR_DEAD_OBJECT);
3178 }
3179 
3180 /*
3181  * Feature: AbilityManagerService
3182  * Function: RequestAssertFaultDialogInner
3183  * SubFunction: NA
3184  * FunctionPoints: AbilityManagerService RequestAssertFaultDialogInner
3185  * EnvConditions: NA
3186  * CaseDescription: Verify the function RequestAssertFaultDialogInner is normal flow.
3187  */
3188 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RequestAssertFaultDialogInner_001, TestSize.Level1)
3189 {
3190     MessageParcel data;
3191     MessageParcel reply;
3192     auto res = stub_->RequestAssertFaultDialogInner(data, reply);
3193     EXPECT_EQ(res, ERR_NULL_OBJECT);
3194 }
3195 
3196 /*
3197  * Feature: AbilityManagerService
3198  * Function: NotifyDebugAssertResultInner
3199  * SubFunction: NA
3200  * FunctionPoints: AbilityManagerService NotifyDebugAssertResultInner
3201  * EnvConditions: NA
3202  * CaseDescription: Verify the function NotifyDebugAssertResultInner is normal flow.
3203  */
3204 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_NotifyDebugAssertResultInner_001, TestSize.Level1)
3205 {
3206     MessageParcel data;
3207     MessageParcel reply;
3208     auto res = stub_->NotifyDebugAssertResultInner(data, reply);
3209     EXPECT_EQ(res, NO_ERROR);
3210 }
3211 
3212 /*
3213  * Feature: AbilityManagerService
3214  * Function: UpdateSessionInfoBySCBInner
3215  * SubFunction: NA
3216  * FunctionPoints: AbilityManagerService UpdateSessionInfoBySCBInner
3217  * EnvConditions: NA
3218  * CaseDescription: Verify the function UpdateSessionInfoBySCBInner is normal flow.
3219  */
3220 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UpdateSessionInfoBySCBInner_001, TestSize.Level1)
3221 {
3222     MessageParcel data;
3223     MessageParcel reply;
3224     auto res = stub_->UpdateSessionInfoBySCBInner(data, reply);
3225     EXPECT_EQ(res, NO_ERROR);
3226 }
3227 
3228 /*
3229  * Feature: AbilityManagerService
3230  * Function: OpenAtomicServiceInner
3231  * SubFunction: NA
3232  * FunctionPoints: AbilityManagerService OpenAtomicServiceInner
3233  * EnvConditions: NA
3234  * CaseDescription: Verify the function OpenAtomicServiceInner is normal flow.
3235  */
3236 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_OpenAtomicServiceInner_001, TestSize.Level1)
3237 {
3238     MessageParcel data;
3239     MessageParcel reply;
3240     auto res = stub_->OpenAtomicServiceInner(data, reply);
3241     EXPECT_EQ(res, ERR_INVALID_VALUE);
3242 }
3243 
3244 /*
3245  * Feature: AbilityManagerService
3246  * Function: IsEmbeddedOpenAllowedInner
3247  * SubFunction: NA
3248  * FunctionPoints: AbilityManagerService IsEmbeddedOpenAllowedInner
3249  * EnvConditions: NA
3250  * CaseDescription: Verify the function IsEmbeddedOpenAllowedInner is normal flow.
3251  */
3252 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsEmbeddedOpenAllowedInner_001, TestSize.Level1)
3253 {
3254     MessageParcel data;
3255     MessageParcel reply;
3256     auto res = stub_->IsEmbeddedOpenAllowedInner(data, reply);
3257     EXPECT_EQ(res, NO_ERROR);
3258 }
3259 
3260 /*
3261  * Feature: AbilityManagerService
3262  * Function: StartShortcutInner
3263  * SubFunction: NA
3264  * FunctionPoints: AbilityManagerService StartShortcutInner
3265  * EnvConditions: NA
3266  * CaseDescription: Verify the function StartShortcutInner is normal flow.
3267  */
3268 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartShortcutInner_001, TestSize.Level1)
3269 {
3270     MessageParcel data;
3271     MessageParcel reply;
3272     auto res = stub_->StartShortcutInner(data, reply);
3273     EXPECT_EQ(res, ERR_INVALID_VALUE);
3274 }
3275 
3276 /*
3277  * Feature: AbilityManagerService
3278  * Function: GetAbilityStateByPersistentIdInner
3279  * SubFunction: NA
3280  * FunctionPoints: AbilityManagerService GetAbilityStateByPersistentIdInner
3281  * EnvConditions: NA
3282  * CaseDescription: Verify the function GetAbilityStateByPersistentIdInner is normal flow.
3283  */
3284 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetAbilityStateByPersistentIdInner_001, TestSize.Level1)
3285 {
3286     MessageParcel data;
3287     MessageParcel reply;
3288     auto res = stub_->GetAbilityStateByPersistentIdInner(data, reply);
3289     EXPECT_EQ(res, NO_ERROR);
3290 }
3291 
3292 /*
3293  * Feature: AbilityManagerService
3294  * Function: TransferAbilityResultForExtensionInner
3295  * SubFunction: NA
3296  * FunctionPoints: AbilityManagerService TransferAbilityResultForExtensionInner
3297  * EnvConditions: NA
3298  * CaseDescription: Verify the function TransferAbilityResultForExtensionInner is normal flow.
3299  */
3300 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_TransferAbilityResultForExtensionInner_001, TestSize.Level1)
3301 {
3302     MessageParcel data;
3303     MessageParcel reply;
3304     auto res = stub_->TransferAbilityResultForExtensionInner(data, reply);
3305     EXPECT_EQ(res, ERR_INVALID_VALUE);
3306 }
3307 
3308 /**
3309  * @tc.name: AbilityManagerStub_RegisterAppDebugListenerInner_001
3310  * @tc.desc: Test the status of RegisterAppDebugListenerInner, check empty AppDebugListener.
3311  * @tc.type: FUNC
3312  */
3313 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterAppDebugListenerInner_001, TestSize.Level1)
3314 {
3315     EXPECT_NE(stub_, nullptr);
3316     MessageParcel data;
3317     MessageParcel reply;
3318     auto res = stub_->RegisterAppDebugListenerInner(data, reply);
3319     EXPECT_EQ(res, ERR_INVALID_VALUE);
3320 }
3321 
3322 /**
3323  * @tc.name: AbilityManagerStub_RegisterAppDebugListenerInner_002
3324  * @tc.desc: Test the status of RegisterAppDebugListenerInner.
3325  * @tc.type: FUNC
3326  */
3327 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterAppDebugListenerInner_002, TestSize.Level1)
3328 {
3329     EXPECT_NE(stub_, nullptr);
3330     MessageParcel data;
3331     MessageParcel reply;
3332     auto token = new AppExecFwk::AppDebugListenerStubMock();
3333     EXPECT_NE(token, nullptr);
3334     auto ret = data.WriteRemoteObject(token);
3335     EXPECT_EQ(ret, true);
3336     int res = stub_->RegisterAppDebugListenerInner(data, reply);
3337     EXPECT_EQ(res, NO_ERROR);
3338 }
3339 
3340 /**
3341  * @tc.name: AbilityManagerStub_UnregisterAppDebugListenerInner_001
3342  * @tc.desc: Test the status of UnregisterAppDebugListenerInner, check empty appDebugListener.
3343  * @tc.type: FUNC
3344  */
3345 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterAppDebugListenerInner_001, TestSize.Level1)
3346 {
3347     EXPECT_NE(stub_, nullptr);
3348     MessageParcel data;
3349     MessageParcel reply;
3350     auto res = stub_->UnregisterAppDebugListenerInner(data, reply);
3351     EXPECT_EQ(res, ERR_INVALID_VALUE);
3352 }
3353 
3354 /**
3355  * @tc.name: AbilityManagerStub_UnregisterAppDebugListenerInner_002
3356  * @tc.desc: Test the status of UnregisterAppDebugListenerInner.
3357  * @tc.type: FUNC
3358  */
3359 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterAppDebugListenerInner_002, TestSize.Level1)
3360 {
3361     EXPECT_NE(stub_, nullptr);
3362     MessageParcel data;
3363     MessageParcel reply;
3364     auto token = new AppExecFwk::AppDebugListenerStubMock();
3365     EXPECT_NE(token, nullptr);
3366     bool ret = data.WriteRemoteObject(token);
3367     EXPECT_EQ(ret, true);
3368     auto res = stub_->UnregisterAppDebugListenerInner(data, reply);
3369     EXPECT_EQ(res, NO_ERROR);
3370 }
3371 
3372 /**
3373  * @tc.name: AbilityManagerStub_AttachAppDebugInner_001
3374  * @tc.desc: Test the state of AttachAppDebugInner.
3375  * @tc.type: FUNC
3376  */
3377 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AttachAppDebugInner_001, TestSize.Level1)
3378 {
3379     EXPECT_NE(stub_, nullptr);
3380     MessageParcel data;
3381     MessageParcel reply;
3382     std::string bundleName = "bundleName";
3383     data.WriteString(bundleName);
3384     auto res = stub_->AttachAppDebugInner(data, reply);
3385     EXPECT_EQ(res, NO_ERROR);
3386 }
3387 
3388 /**
3389  * @tc.name: AbilityManagerStub_AttachAppDebugInner_002
3390  * @tc.desc: Test the state of AttachAppDebugInner, check empty bundleName;
3391  * @tc.type: FUNC
3392  */
3393 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AttachAppDebugInner_002, TestSize.Level1)
3394 {
3395     EXPECT_NE(stub_, nullptr);
3396     MessageParcel data;
3397     MessageParcel reply;
3398     auto res = stub_->AttachAppDebugInner(data, reply);
3399     EXPECT_EQ(res, ERR_INVALID_VALUE);
3400 }
3401 
3402 /**
3403  * @tc.name: AbilityManagerStub_DetachAppDebugInner_001
3404  * @tc.desc: Test the state of DetachAppDebugInner.
3405  * @tc.type: FUNC
3406  */
3407 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DetachAppDebugInner_001, TestSize.Level1)
3408 {
3409     EXPECT_NE(stub_, nullptr);
3410     MessageParcel data;
3411     MessageParcel reply;
3412     std::string bundleName = "bundleName";
3413     data.WriteString(bundleName);
3414     auto res = stub_->DetachAppDebugInner(data, reply);
3415     EXPECT_EQ(res, NO_ERROR);
3416 }
3417 
3418 /**
3419  * @tc.name: AbilityManagerStub_DetachAppDebugInner_002
3420  * @tc.desc: Test the state of DetachAppDebugInner, check empty bundleName.
3421  * @tc.type: FUNC
3422  */
3423 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DetachAppDebugInner_002, TestSize.Level1)
3424 {
3425     EXPECT_NE(stub_, nullptr);
3426     MessageParcel data;
3427     MessageParcel reply;
3428     auto res = stub_->DetachAppDebugInner(data, reply);
3429     EXPECT_EQ(res, ERR_INVALID_VALUE);
3430 }
3431 
3432 /**
3433  * @tc.name: AbilityManagerStub_GetForegroundUIAbilitiesInner_001
3434  * @tc.desc: Test function GetForegroundUIAbilitiesInner when normally.
3435  * @tc.type: FUNC
3436  */
3437 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetForegroundUIAbilitiesInner_001, TestSize.Level1)
3438 {
3439     MessageParcel data;
3440     MessageParcel reply;
3441     auto res = stub_->GetForegroundUIAbilitiesInner(data, reply);
3442     EXPECT_EQ(res, ERR_OK);
3443 }
3444 
3445 /**
3446  * @tc.name: AbilityManagerStubTest_RegisterAutoStartupSystemCallbackInner_0100
3447  * @tc.desc: Test the state of RegisterAutoStartupSystemCallbackInner
3448  * @tc.type: FUNC
3449  */
3450 HWTEST_F(AbilityManagerStubTest, RegisterAutoStartupSystemCallbackInner_0100, TestSize.Level1)
3451 {
3452     MessageParcel data;
3453     MessageParcel reply;
3454     sptr<AppExecFwk::MockAbilityToken> token = new (std::nothrow) AppExecFwk::MockAbilityToken();
3455     EXPECT_NE(token, nullptr);
3456     data.WriteRemoteObject(token);
3457     auto result = stub_->RegisterAutoStartupSystemCallbackInner(data, reply);
3458     EXPECT_EQ(result, NO_ERROR);
3459 }
3460 
3461 /**
3462  * @tc.name: AbilityManagerStubTest_RegisterAutoStartupSystemCallbackInner_0200
3463  * @tc.desc: Test the state of RegisterAutoStartupSystemCallbackInner
3464  * @tc.type: FUNC
3465  */
3466 HWTEST_F(AbilityManagerStubTest, RegisterAutoStartupSystemCallbackInner_0200, TestSize.Level1)
3467 {
3468     MessageParcel data;
3469     MessageParcel reply;
3470     auto result = stub_->RegisterAutoStartupSystemCallbackInner(data, reply);
3471     EXPECT_EQ(result, ERR_INVALID_VALUE);
3472 }
3473 
3474 /**
3475  * @tc.name: AbilityManagerStubTest_UnregisterAutoStartupSystemCallbackInner_0100
3476  * @tc.desc: Test the state of UnregisterAutoStartupSystemCallbackInner
3477  * @tc.type: FUNC
3478  */
3479 HWTEST_F(AbilityManagerStubTest, UnregisterAutoStartupSystemCallbackInner_0100, TestSize.Level1)
3480 {
3481     MessageParcel data;
3482     MessageParcel reply;
3483     sptr<AppExecFwk::MockAbilityToken> token = new (std::nothrow) AppExecFwk::MockAbilityToken();
3484     EXPECT_NE(token, nullptr);
3485     data.WriteRemoteObject(token);
3486     auto result = stub_->UnregisterAutoStartupSystemCallbackInner(data, reply);
3487     EXPECT_EQ(result, NO_ERROR);
3488 }
3489 
3490 /**
3491  * @tc.name: AbilityManagerStubTest_UnregisterAutoStartupSystemCallbackInner_0200
3492  * @tc.desc: Test the state of UnregisterAutoStartupSystemCallbackInner
3493  * @tc.type: FUNC
3494  */
3495 HWTEST_F(AbilityManagerStubTest, UnregisterAutoStartupSystemCallbackInner_0200, TestSize.Level1)
3496 {
3497     MessageParcel data;
3498     MessageParcel reply;
3499     auto result = stub_->UnregisterAutoStartupSystemCallbackInner(data, reply);
3500     EXPECT_EQ(result, ERR_INVALID_VALUE);
3501 }
3502 /**
3503  * @tc.name: AbilityManagerStubTest_SetApplicationAutoStartupInner_0100
3504  * @tc.desc: Test the state of SetApplicationAutoStartupInner
3505  * @tc.type: FUNC
3506  */
3507 HWTEST_F(AbilityManagerStubTest, SetApplicationAutoStartupInner_0100, TestSize.Level1)
3508 {
3509     MessageParcel data;
3510     MessageParcel reply;
3511     Want want;
3512     data.WriteParcelable(&want);
3513     auto result = stub_->SetApplicationAutoStartupInner(data, reply);
3514     EXPECT_EQ(result, NO_ERROR);
3515 }
3516 
3517 /**
3518  * @tc.name: AbilityManagerStubTest_SetApplicationAutoStartupInner_0200
3519  * @tc.desc: Test the state of SetApplicationAutoStartupInner
3520  * @tc.type: FUNC
3521  */
3522 HWTEST_F(AbilityManagerStubTest, SetApplicationAutoStartupInner_0200, TestSize.Level1)
3523 {
3524     MessageParcel data;
3525     MessageParcel reply;
3526     auto result = stub_->SetApplicationAutoStartupInner(data, reply);
3527     EXPECT_EQ(result, ERR_INVALID_VALUE);
3528 }
3529 
3530 /**
3531  * @tc.name: AbilityManagerStubTest_CancelApplicationAutoStartupInner_0100
3532  * @tc.desc: Test the state of CancelApplicationAutoStartupInner
3533  * @tc.type: FUNC
3534  */
3535 HWTEST_F(AbilityManagerStubTest, CancelApplicationAutoStartupInner_0100, TestSize.Level1)
3536 {
3537     MessageParcel data;
3538     MessageParcel reply;
3539     Want want;
3540     data.WriteParcelable(&want);
3541     auto result = stub_->CancelApplicationAutoStartupInner(data, reply);
3542     EXPECT_EQ(result, NO_ERROR);
3543 }
3544 
3545 /**
3546  * @tc.name: AbilityManagerStubTest_CancelApplicationAutoStartupInner_0200
3547  * @tc.desc: Test the state of CancelApplicationAutoStartupInner
3548  * @tc.type: FUNC
3549  */
3550 HWTEST_F(AbilityManagerStubTest, CancelApplicationAutoStartupInner_0200, TestSize.Level1)
3551 {
3552     MessageParcel data;
3553     MessageParcel reply;
3554     auto result = stub_->CancelApplicationAutoStartupInner(data, reply);
3555     EXPECT_EQ(result, ERR_INVALID_VALUE);
3556 }
3557 
3558 /**
3559  * @tc.name: AbilityManagerStubTest_QueryAllAutoStartupApplicationsInner_0100
3560  * @tc.desc: Test the state of QueryAllAutoStartupApplicationsInner
3561  * @tc.type: FUNC
3562  */
3563 HWTEST_F(AbilityManagerStubTest, QueryAllAutoStartupApplicationsInner_0100, TestSize.Level1)
3564 {
3565     MessageParcel data;
3566     MessageParcel reply;
3567     Want want;
3568     data.WriteParcelable(&want);
3569     auto result = stub_->QueryAllAutoStartupApplicationsInner(data, reply);
3570     EXPECT_EQ(result, NO_ERROR);
3571 }
3572 
3573 /**
3574  * @tc.name: GetUIExtensionRootHostInfo_0100
3575  * @tc.desc: GetUIExtensionRootHostInfo
3576  * @tc.type: FUNC
3577  * @tc.require: issueI92G6Z
3578  */
3579 HWTEST_F(AbilityManagerStubTest, GetUIExtensionRootHostInfo_0100, TestSize.Level1)
3580 {
3581     TAG_LOGI(AAFwkTag::TEST, "begin");
3582 
3583     MessageParcel data;
3584     bool writeRet = data.WriteInterfaceToken(AbilityManagerStubImplMock::GetDescriptor());
3585     auto token = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
3586     auto userId = USER_ID;
3587     writeRet &= data.WriteBool(true);
3588     writeRet &= data.WriteRemoteObject(token);
3589     writeRet &= data.WriteInt32(userId);
3590     EXPECT_EQ(writeRet, true);
3591 
3592     EXPECT_CALL(*stub_, GetUIExtensionRootHostInfo(_, _, _)).Times(1);
3593 
3594     MessageParcel reply;
3595     MessageOption option;
3596     auto ret = stub_->OnRemoteRequest(
3597         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_UI_EXTENSION_ROOT_HOST_INFO), data, reply, option);
3598     EXPECT_EQ(ret, NO_ERROR);
3599 
3600     TAG_LOGI(AAFwkTag::TEST, "end");
3601 }
3602 
3603 /**
3604  * @tc.name: RestartAppInner_0100
3605  * @tc.desc: RestartAppInner
3606  * @tc.type: FUNC
3607  */
3608 HWTEST_F(AbilityManagerStubTest, RestartAppInner_0100, TestSize.Level1)
3609 {
3610     MessageParcel data;
3611     MessageParcel reply;
3612     Want want;
3613     data.WriteParcelable(&want);
3614     auto result = stub_->RestartAppInner(data, reply);
3615     EXPECT_EQ(result, NO_ERROR);
3616 }
3617 
3618 /**
3619  * @tc.name: ChangeAbilityVisibility_0100
3620  * @tc.desc: ChangeAbilityVisibility
3621  * @tc.type: FUNC
3622  */
3623 HWTEST_F(AbilityManagerStubTest, ChangeAbilityVisibility_0100, TestSize.Level1)
3624 {
3625     TAG_LOGI(AAFwkTag::TEST, "begin");
3626 
3627     MessageParcel data;
3628     MessageParcel reply;
3629     auto token = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
3630     data.WriteRemoteObject(token);
3631     data.WriteBool(true);
3632 
3633     auto ret = stub_->ChangeAbilityVisibilityInner(data, reply);
3634     EXPECT_EQ(ret, NO_ERROR);
3635 
3636     TAG_LOGI(AAFwkTag::TEST, "end");
3637 }
3638 
3639 /**
3640  * @tc.name: ChangeUIAbilityVisibilityBySCB_0100
3641  * @tc.desc: ChangeUIAbilityVisibilityBySCB
3642  * @tc.type: FUNC
3643  */
3644 HWTEST_F(AbilityManagerStubTest, ChangeUIAbilityVisibilityBySCB_0100, TestSize.Level1)
3645 {
3646     TAG_LOGI(AAFwkTag::TEST, "begin");
3647 
3648     MessageParcel data;
3649     MessageParcel reply;
3650     sptr<SessionInfo> session = new (std::nothrow) SessionInfo();
3651     data.WriteParcelable(session);
3652     data.WriteBool(true);
3653 
3654     auto ret = stub_->ChangeUIAbilityVisibilityBySCBInner(data, reply);
3655     EXPECT_EQ(ret, NO_ERROR);
3656 
3657     TAG_LOGI(AAFwkTag::TEST, "end");
3658 }
3659 } // namespace AAFwk
3660 } // namespace OHOS
3661