• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 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 AbilityManagerStubSecondTest : 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 AbilityManagerStubSecondTest::SetUpTestCase(void)
45 {}
TearDownTestCase(void)46 void AbilityManagerStubSecondTest::TearDownTestCase(void)
47 {}
TearDown()48 void AbilityManagerStubSecondTest::TearDown()
49 {}
50 
SetUp()51 void AbilityManagerStubSecondTest::SetUp()
52 {
53     stub_ = new AbilityManagerStubImplMock();
54 }
55 
WriteInterfaceToken(MessageParcel & data)56 void AbilityManagerStubSecondTest::WriteInterfaceToken(MessageParcel& data)
57 {
58     data.WriteInterfaceToken(AbilityManagerStub::GetDescriptor());
59 }
60 
61 
62 /**
63  * @tc.name: OnRemoteRequestInnerFirst_0100
64  * @tc.desc: Test OnRemoteRequestInnerFirst
65  * @tc.type: FUNC
66  */
67 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerFirst_0100, TestSize.Level1)
68 {
69     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerFirst_0100 begin");
70 
71     MessageParcel data;
72     MessageParcel reply;
73     MessageOption option;
74     uint32_t code[] = {
75         static_cast<uint32_t>(AbilityManagerInterfaceCode::TERMINATE_ABILITY),
76         static_cast<uint32_t>(AbilityManagerInterfaceCode::MINIMIZE_ABILITY),
77         static_cast<uint32_t>(AbilityManagerInterfaceCode::ATTACH_ABILITY_THREAD),
78         static_cast<uint32_t>(AbilityManagerInterfaceCode::ABILITY_TRANSITION_DONE),
79         static_cast<uint32_t>(AbilityManagerInterfaceCode::ABILITY_WINDOW_CONFIG_TRANSITION_DONE),
80         static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY_DONE),
81         static_cast<uint32_t>(AbilityManagerInterfaceCode::DISCONNECT_ABILITY_DONE),
82         static_cast<uint32_t>(AbilityManagerInterfaceCode::COMMAND_ABILITY_DONE),
83         static_cast<uint32_t>(AbilityManagerInterfaceCode::COMMAND_ABILITY_WINDOW_DONE),
84         static_cast<uint32_t>(AbilityManagerInterfaceCode::ACQUIRE_DATA_ABILITY),
85         static_cast<uint32_t>(AbilityManagerInterfaceCode::RELEASE_DATA_ABILITY),
86         static_cast<uint32_t>(AbilityManagerInterfaceCode::BACK_TO_CALLER_UIABILITY)
87     };
88 
89     int i = 0;
90     while (i < sizeof(code) / sizeof(uint32_t)) {
91         stub_->OnRemoteRequestInnerFirst(code[i++], data, reply, option);
92     }
93 
94     uint32_t code_ = 0;
95     auto ret = stub_->OnRemoteRequestInnerFirst(code_, data, reply, option);
96     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
97 
98     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerFirst_0100 end");
99 }
100 
101 /**
102  * @tc.name: OnRemoteRequestInnerSecond_0100
103  * @tc.desc: Test OnRemoteRequestInnerSecond
104  * @tc.type: FUNC
105  */
106 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerSecond_0100, TestSize.Level1)
107 {
108     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerSecond_0100 begin");
109 
110     MessageParcel data;
111     MessageParcel reply;
112     MessageOption option;
113     uint32_t code[] = {
114         static_cast<uint32_t>(AbilityManagerInterfaceCode::KILL_PROCESS),
115         static_cast<uint32_t>(AbilityManagerInterfaceCode::UNINSTALL_APP),
116         static_cast<uint32_t>(AbilityManagerInterfaceCode::UPGRADE_APP),
117         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY),
118         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_ADD_CALLER),
119         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_WITH_SPECIFY_TOKENID),
120         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_AS_CALLER_BY_TOKEN),
121         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_AS_CALLER_FOR_OPTIONS),
122         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_SESSION_ABILITY_ADD_CALLER),
123         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_SESSION_ABILITY_FOR_OPTIONS),
124         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_ONLY_UI_ABILITY)
125     };
126 
127     int i = 0;
128     while (i < sizeof(code) / sizeof(uint32_t)) {
129         stub_->OnRemoteRequestInnerSecond(code[i++], data, reply, option);
130     }
131 
132     uint32_t code_ = 0;
133     auto ret = stub_->OnRemoteRequestInnerSecond(code_, data, reply, option);
134     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
135 
136     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerSecond_0100 end");
137 }
138 
139 /**
140  * @tc.name: OnRemoteRequestInnerThird_0100
141  * @tc.desc: Test OnRemoteRequestInnerThird
142  * @tc.type: FUNC
143  */
144 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerThird_0100, TestSize.Level1)
145 {
146     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerThird_0100 begin");
147 
148     MessageParcel data;
149     MessageParcel reply;
150     MessageOption option;
151     uint32_t code[] = {
152         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_BY_INSIGHT_INTENT),
153         static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY),
154         static_cast<uint32_t>(AbilityManagerInterfaceCode::DISCONNECT_ABILITY),
155         static_cast<uint32_t>(AbilityManagerInterfaceCode::STOP_SERVICE_ABILITY),
156         static_cast<uint32_t>(AbilityManagerInterfaceCode::DUMP_STATE),
157         static_cast<uint32_t>(AbilityManagerInterfaceCode::DUMPSYS_STATE),
158         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_FOR_SETTINGS),
159         static_cast<uint32_t>(AbilityManagerInterfaceCode::CONTINUE_MISSION),
160         static_cast<uint32_t>(AbilityManagerInterfaceCode::CONTINUE_MISSION_OF_BUNDLENAME),
161         static_cast<uint32_t>(AbilityManagerInterfaceCode::CONTINUE_ABILITY)
162     };
163 
164     int i = 0;
165     while (i < sizeof(code) / sizeof(uint32_t)) {
166         stub_->OnRemoteRequestInnerThird(code[i++], data, reply, option);
167     }
168 
169     uint32_t code_ = 0;
170     auto ret = stub_->OnRemoteRequestInnerThird(code_, data, reply, option);
171     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
172 
173     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerThird_0100 end");
174 }
175 
176 /**
177  * @tc.name: OnRemoteRequestInnerFourth_0100
178  * @tc.desc: Test OnRemoteRequestInnerFourth
179  * @tc.type: FUNC
180  */
181 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerFourth_0100, TestSize.Level1)
182 {
183     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerFourth_0100 begin");
184 
185     MessageParcel data;
186     MessageParcel reply;
187     MessageOption option;
188     uint32_t code[] = {
189         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_CONTINUATION),
190         static_cast<uint32_t>(AbilityManagerInterfaceCode::NOTIFY_COMPLETE_CONTINUATION),
191         static_cast<uint32_t>(AbilityManagerInterfaceCode::NOTIFY_CONTINUATION_RESULT),
192         static_cast<uint32_t>(AbilityManagerInterfaceCode::SEND_RESULT_TO_ABILITY),
193         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_REMOTE_MISSION_LISTENER),
194         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_REMOTE_ON_LISTENER),
195         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_REMOTE_OFF_LISTENER),
196         static_cast<uint32_t>(AbilityManagerInterfaceCode::UNREGISTER_REMOTE_MISSION_LISTENER),
197         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_FOR_OPTIONS),
198         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_SYNC_MISSIONS)
199     };
200 
201     int i = 0;
202     while (i < sizeof(code) / sizeof(uint32_t)) {
203         stub_->OnRemoteRequestInnerFourth(code[i++], data, reply, option);
204     }
205 
206     uint32_t code_ = 0;
207     auto ret = stub_->OnRemoteRequestInnerFourth(code_, data, reply, option);
208     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
209 
210     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerFourth_0100 end");
211 }
212 
213 /**
214  * @tc.name: OnRemoteRequestInnerFifth_0100
215  * @tc.desc: Test OnRemoteRequestInnerFifth
216  * @tc.type: FUNC
217  */
218 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerFifth_0100, TestSize.Level1)
219 {
220     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerFifth_0100 begin");
221 
222     MessageParcel data;
223     MessageParcel reply;
224     MessageOption option;
225     uint32_t code[] = {
226         static_cast<uint32_t>(AbilityManagerInterfaceCode::STOP_SYNC_MISSIONS),
227         static_cast<uint32_t>(AbilityManagerInterfaceCode::FORCE_TIMEOUT),
228         static_cast<uint32_t>(AbilityManagerInterfaceCode::FREE_INSTALL_ABILITY_FROM_REMOTE),
229         static_cast<uint32_t>(AbilityManagerInterfaceCode::ADD_FREE_INSTALL_OBSERVER),
230         static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_ABILITY_WITH_TYPE),
231         static_cast<uint32_t>(AbilityManagerInterfaceCode::ABILITY_RECOVERY),
232         static_cast<uint32_t>(AbilityManagerInterfaceCode::ABILITY_RECOVERY_ENABLE),
233         static_cast<uint32_t>(AbilityManagerInterfaceCode::ABILITY_RECOVERY_SUBMITINFO),
234         static_cast<uint32_t>(AbilityManagerInterfaceCode::CLEAR_RECOVERY_PAGE_STACK),
235         static_cast<uint32_t>(AbilityManagerInterfaceCode::MINIMIZE_UI_ABILITY_BY_SCB),
236         static_cast<uint32_t>(AbilityManagerInterfaceCode::CLOSE_UI_ABILITY_BY_SCB)
237     };
238 
239     int i = 0;
240     while (i < sizeof(code) / sizeof(uint32_t)) {
241         stub_->OnRemoteRequestInnerFifth(code[i++], data, reply, option);
242     }
243 
244     uint32_t code_ = 0;
245     auto ret = stub_->OnRemoteRequestInnerFifth(code_, data, reply, option);
246     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
247 
248     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerFifth_0100 end");
249 }
250 
251 /**
252  * @tc.name: OnRemoteRequestInnerSixth_0100
253  * @tc.desc: Test OnRemoteRequestInnerSixth
254  * @tc.type: FUNC
255  */
256 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerSixth_0100, TestSize.Level1)
257 {
258     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerSixth_0100 begin");
259 
260     MessageParcel data;
261     MessageParcel reply;
262     MessageOption option;
263     uint32_t code[] = {
264         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_COLLABORATOR),
265         static_cast<uint32_t>(AbilityManagerInterfaceCode::UNREGISTER_COLLABORATOR),
266         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_APP_DEBUG_LISTENER),
267         static_cast<uint32_t>(AbilityManagerInterfaceCode::UNREGISTER_APP_DEBUG_LISTENER),
268         static_cast<uint32_t>(AbilityManagerInterfaceCode::ATTACH_APP_DEBUG),
269         static_cast<uint32_t>(AbilityManagerInterfaceCode::DETACH_APP_DEBUG),
270         static_cast<uint32_t>(AbilityManagerInterfaceCode::IS_ABILITY_CONTROLLER_START),
271         static_cast<uint32_t>(AbilityManagerInterfaceCode::EXECUTE_INTENT),
272         static_cast<uint32_t>(AbilityManagerInterfaceCode::EXECUTE_INSIGHT_INTENT_DONE),
273         static_cast<uint32_t>(AbilityManagerInterfaceCode::OPEN_FILE)
274     };
275 
276     int i = 0;
277     while (i < sizeof(code) / sizeof(uint32_t)) {
278         stub_->OnRemoteRequestInnerSixth(code[i++], data, reply, option);
279     }
280 
281     uint32_t code_ = 0;
282     auto ret = stub_->OnRemoteRequestInnerSixth(code_, data, reply, option);
283     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
284 
285     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerSixth_0100 end");
286 }
287 
288 /**
289  * @tc.name: OnRemoteRequestInnerSeventh_0100
290  * @tc.desc: Test OnRemoteRequestInnerSeventh
291  * @tc.type: FUNC
292  */
293 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerSeventh_0100, TestSize.Level1)
294 {
295     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerSeventh_0100 begin");
296 
297     MessageParcel data;
298     MessageParcel reply;
299     MessageOption option;
300     uint32_t code[] = {
301         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_SENDER),
302         static_cast<uint32_t>(AbilityManagerInterfaceCode::SEND_PENDING_WANT_SENDER),
303         static_cast<uint32_t>(AbilityManagerInterfaceCode::CANCEL_PENDING_WANT_SENDER),
304         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_UID),
305         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_USERID),
306         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_BUNDLENAME),
307         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_CODE),
308         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_TYPE),
309         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_CANCEL_LISTENER),
310         static_cast<uint32_t>(AbilityManagerInterfaceCode::UNREGISTER_CANCEL_LISTENER)
311     };
312 
313     int i = 0;
314     while (i < sizeof(code) / sizeof(uint32_t)) {
315         stub_->OnRemoteRequestInnerSeventh(code[i++], data, reply, option);
316     }
317 
318     uint32_t code_ = 0;
319     auto ret = stub_->OnRemoteRequestInnerSeventh(code_, data, reply, option);
320     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
321 
322     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerSeventh_0100 end");
323 }
324 
325 /**
326  * @tc.name: OnRemoteRequestInnerEighth_0100
327  * @tc.desc: Test OnRemoteRequestInnerEighth
328  * @tc.type: FUNC
329  */
330 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerEighth_0100, TestSize.Level1)
331 {
332     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerEighth_0100 begin");
333 
334     MessageParcel data;
335     MessageParcel reply;
336     MessageOption option;
337     uint32_t code[] = {
338         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PENDING_REQUEST_WANT),
339         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_SENDER_INFO),
340         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_APP_MEMORY_SIZE),
341         static_cast<uint32_t>(AbilityManagerInterfaceCode::IS_RAM_CONSTRAINED_DEVICE),
342         static_cast<uint32_t>(AbilityManagerInterfaceCode::LOCK_MISSION_FOR_CLEANUP),
343         static_cast<uint32_t>(AbilityManagerInterfaceCode::UNLOCK_MISSION_FOR_CLEANUP),
344         static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_SESSION_LOCKED_STATE),
345         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_MISSION_LISTENER),
346         static_cast<uint32_t>(AbilityManagerInterfaceCode::UNREGISTER_MISSION_LISTENER)
347     };
348 
349     int i = 0;
350     while (i < sizeof(code) / sizeof(uint32_t)) {
351         stub_->OnRemoteRequestInnerEighth(code[i++], data, reply, option);
352     }
353 
354     uint32_t code_ = 0;
355     auto ret = stub_->OnRemoteRequestInnerEighth(code_, data, reply, option);
356     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
357 
358     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerEighth_0100 end");
359 }
360 
361 /**
362  * @tc.name: OnRemoteRequestInnerNinth_0100
363  * @tc.desc: Test OnRemoteRequestInnerNinth
364  * @tc.type: FUNC
365  */
366 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerNinth_0100, TestSize.Level1)
367 {
368     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerNinth_0100 begin");
369 
370     MessageParcel data;
371     MessageParcel reply;
372     MessageOption option;
373     uint32_t code[] = {
374         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_MISSION_INFOS),
375         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_MISSION_INFO_BY_ID),
376         static_cast<uint32_t>(AbilityManagerInterfaceCode::CLEAN_MISSION),
377         static_cast<uint32_t>(AbilityManagerInterfaceCode::CLEAN_ALL_MISSIONS),
378         static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSION_TO_FRONT),
379         static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSION_TO_FRONT_BY_OPTIONS),
380         static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSIONS_TO_FOREGROUND),
381         static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_MISSIONS_TO_BACKGROUND),
382         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_CALL_ABILITY),
383         static_cast<uint32_t>(AbilityManagerInterfaceCode::CALL_REQUEST_DONE)
384     };
385 
386     int i = 0;
387     while (i < sizeof(code) / sizeof(uint32_t)) {
388         stub_->OnRemoteRequestInnerNinth(code[i++], data, reply, option);
389     }
390 
391     uint32_t code_ = 0;
392     auto ret = stub_->OnRemoteRequestInnerNinth(code_, data, reply, option);
393     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
394 
395     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerNinth_0100 end");
396 }
397 
398 /**
399  * @tc.name: OnRemoteRequestInnerTenth_0100
400  * @tc.desc: Test OnRemoteRequestInnerTenth
401  * @tc.type: FUNC
402  */
403 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerTenth_0100, TestSize.Level1)
404 {
405     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerTenth_0100 begin");
406 
407     MessageParcel data;
408     MessageParcel reply;
409     MessageOption option;
410     uint32_t code[] = {
411         static_cast<uint32_t>(AbilityManagerInterfaceCode::RELEASE_CALL_ABILITY),
412         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_USER),
413         static_cast<uint32_t>(AbilityManagerInterfaceCode::STOP_USER),
414         static_cast<uint32_t>(AbilityManagerInterfaceCode::LOGOUT_USER),
415         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_ABILITY_RUNNING_INFO),
416         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_EXTENSION_RUNNING_INFO),
417         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PROCESS_RUNNING_INFO),
418         static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_ABILITY_CONTROLLER),
419         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_MISSION_SNAPSHOT_INFO),
420         static_cast<uint32_t>(AbilityManagerInterfaceCode::IS_USER_A_STABILITY_TEST)
421     };
422 
423     int i = 0;
424     while (i < sizeof(code) / sizeof(uint32_t)) {
425         stub_->OnRemoteRequestInnerTenth(code[i++], data, reply, option);
426     }
427 
428     uint32_t code_ = 0;
429     auto ret = stub_->OnRemoteRequestInnerTenth(code_, data, reply, option);
430     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
431 
432     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerTenth_0100 end");
433 }
434 
435 /**
436  * @tc.name: OnRemoteRequestInnerEleventh_0100
437  * @tc.desc: Test OnRemoteRequestInnerEleventh
438  * @tc.type: FUNC
439  */
440 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerEleventh_0100, TestSize.Level1)
441 {
442     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerEleventh_0100 begin");
443 
444     MessageParcel data;
445     MessageParcel reply;
446     MessageOption option;
447     uint32_t code[] = {
448         static_cast<uint32_t>(AbilityManagerInterfaceCode::ACQUIRE_SHARE_DATA),
449         static_cast<uint32_t>(AbilityManagerInterfaceCode::SHARE_DATA_DONE),
450         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_ABILITY_TOKEN),
451         static_cast<uint32_t>(AbilityManagerInterfaceCode::FORCE_EXIT_APP),
452         static_cast<uint32_t>(AbilityManagerInterfaceCode::RECORD_APP_EXIT_REASON),
453         static_cast<uint32_t>(AbilityManagerInterfaceCode::RECORD_PROCESS_EXIT_REASON),
454         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_SESSION_HANDLER)
455     };
456 
457     int i = 0;
458     while (i < sizeof(code) / sizeof(uint32_t)) {
459         stub_->OnRemoteRequestInnerEleventh(code[i++], data, reply, option);
460     }
461 
462     uint32_t code_ = 0;
463     auto ret = stub_->OnRemoteRequestInnerEleventh(code_, data, reply, option);
464     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
465 
466     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerEleventh_0100 end");
467 }
468 
469 /**
470  * @tc.name: OnRemoteRequestInnerTwelveth_0100
471  * @tc.desc: Test OnRemoteRequestInnerTwelveth
472  * @tc.type: FUNC
473  */
474 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerTwelveth_0100, TestSize.Level1)
475 {
476     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerTwelveth_0100 begin");
477 
478     MessageParcel data;
479     MessageParcel reply;
480     MessageOption option;
481     uint32_t code[] = {
482         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_USER_TEST),
483         static_cast<uint32_t>(AbilityManagerInterfaceCode::FINISH_USER_TEST),
484         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_TOP_ABILITY_TOKEN),
485         static_cast<uint32_t>(AbilityManagerInterfaceCode::CHECK_UI_EXTENSION_IS_FOCUSED),
486         static_cast<uint32_t>(AbilityManagerInterfaceCode::DELEGATOR_DO_ABILITY_FOREGROUND),
487         static_cast<uint32_t>(AbilityManagerInterfaceCode::DELEGATOR_DO_ABILITY_BACKGROUND),
488         static_cast<uint32_t>(AbilityManagerInterfaceCode::DO_ABILITY_FOREGROUND),
489         static_cast<uint32_t>(AbilityManagerInterfaceCode::DO_ABILITY_BACKGROUND),
490         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_MISSION_ID_BY_ABILITY_TOKEN),
491         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_TOP_ABILITY)
492     };
493 
494     int i = 0;
495     while (i < sizeof(code) / sizeof(uint32_t)) {
496         stub_->OnRemoteRequestInnerTwelveth(code[i++], data, reply, option);
497     }
498 
499     uint32_t code_ = 0;
500     auto ret = stub_->OnRemoteRequestInnerTwelveth(code_, data, reply, option);
501     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
502 
503     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerTwelveth_0100 end");
504 }
505 
506 /**
507  * @tc.name: OnRemoteRequestInnerThirteenth_0100
508  * @tc.desc: Test OnRemoteRequestInnerThirteenth
509  * @tc.type: FUNC
510  */
511 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerThirteenth_0100, TestSize.Level1)
512 {
513     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerThirteenth_0100 begin");
514 
515     MessageParcel data;
516     MessageParcel reply;
517     MessageOption option;
518     uint32_t code[] = {
519         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_ELEMENT_NAME_BY_TOKEN),
520         static_cast<uint32_t>(AbilityManagerInterfaceCode::DUMP_ABILITY_INFO_DONE),
521         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_EXTENSION_ABILITY),
522         static_cast<uint32_t>(AbilityManagerInterfaceCode::STOP_EXTENSION_ABILITY),
523         static_cast<uint32_t>(AbilityManagerInterfaceCode::UPDATE_MISSION_SNAPSHOT_FROM_WMS),
524         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_CONNECTION_OBSERVER),
525         static_cast<uint32_t>(AbilityManagerInterfaceCode::UNREGISTER_CONNECTION_OBSERVER),
526         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_DLP_CONNECTION_INFOS),
527         static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_ABILITY_TO_BACKGROUND),
528         static_cast<uint32_t>(AbilityManagerInterfaceCode::MOVE_UI_ABILITY_TO_BACKGROUND)
529     };
530 
531     int i = 0;
532     while (i < sizeof(code) / sizeof(uint32_t)) {
533         stub_->OnRemoteRequestInnerThirteenth(code[i++], data, reply, option);
534     }
535 
536     uint32_t code_ = 0;
537     auto ret = stub_->OnRemoteRequestInnerThirteenth(code_, data, reply, option);
538     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
539 
540     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerThirteenth_0100 end");
541 }
542 
543 /**
544  * @tc.name: OnRemoteRequestInnerFourteenth_0100
545  * @tc.desc: Test OnRemoteRequestInnerFourteenth
546  * @tc.type: FUNC
547  */
548 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerFourteenth_0100, TestSize.Level1)
549 {
550     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerFourteenth_0100 begin");
551 
552     MessageParcel data;
553     MessageParcel reply;
554     MessageOption option;
555     uint32_t code[] = {
556         static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_MISSION_CONTINUE_STATE),
557         static_cast<uint32_t>(AbilityManagerInterfaceCode::PREPARE_TERMINATE_ABILITY_BY_SCB),
558         static_cast<uint32_t>(AbilityManagerInterfaceCode::REQUESET_MODAL_UIEXTENSION),
559         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_UI_EXTENSION_ROOT_HOST_INFO),
560         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_UI_EXTENSION_SESSION_INFO),
561         static_cast<uint32_t>(AbilityManagerInterfaceCode::PRELOAD_UIEXTENSION_ABILITY),
562         static_cast<uint32_t>(AbilityManagerInterfaceCode::TERMINATE_UI_SERVICE_EXTENSION_ABILITY)
563     };
564 
565     int i = 0;
566     while (i < sizeof(code) / sizeof(uint32_t)) {
567         stub_->OnRemoteRequestInnerFourteenth(code[i++], data, reply, option);
568     }
569 
570     uint32_t code_ = 0;
571     auto ret = stub_->OnRemoteRequestInnerFourteenth(code_, data, reply, option);
572     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
573 
574     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerFourteenth_0100 end");
575 }
576 
577 /**
578  * @tc.name: OnRemoteRequestInnerFifteenth_0100
579  * @tc.desc: Test OnRemoteRequestInnerFifteenth
580  * @tc.type: FUNC
581  */
582 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerFifteenth_0100, TestSize.Level1)
583 {
584     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerFifteenth_0100 begin");
585 
586     MessageParcel data;
587     MessageParcel reply;
588     MessageOption option;
589     uint32_t code[] = {
590         static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_MISSION_LABEL),
591         static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_MISSION_ICON),
592         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_WMS_HANDLER),
593         static_cast<uint32_t>(AbilityManagerInterfaceCode::COMPLETEFIRSTFRAMEDRAWING),
594         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_EXTENSION_ABILITY),
595         static_cast<uint32_t>(AbilityManagerInterfaceCode::MINIMIZE_UI_EXTENSION_ABILITY),
596         static_cast<uint32_t>(AbilityManagerInterfaceCode::TERMINATE_UI_EXTENSION_ABILITY),
597         static_cast<uint32_t>(AbilityManagerInterfaceCode::CONNECT_UI_EXTENSION_ABILITY),
598         static_cast<uint32_t>(AbilityManagerInterfaceCode::PREPARE_TERMINATE_ABILITY),
599         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_DIALOG_SESSION_INFO),
600         static_cast<uint32_t>(AbilityManagerInterfaceCode::SEND_DIALOG_RESULT),
601         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_ABILITY_FIRST_FRAME_STATE_OBSERVER),
602         static_cast<uint32_t>(AbilityManagerInterfaceCode::UNREGISTER_ABILITY_FIRST_FRAME_STATE_OBSERVER)
603     };
604 
605     int i = 0;
606     while (i < sizeof(code) / sizeof(uint32_t)) {
607         stub_->OnRemoteRequestInnerFifteenth(code[i++], data, reply, option);
608     }
609 
610     uint32_t code_ = 0;
611     auto ret = stub_->OnRemoteRequestInnerFifteenth(code_, data, reply, option);
612     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
613 
614     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerFifteenth_0100 end");
615 }
616 
617 /**
618  * @tc.name: OnRemoteRequestInnerSixteenth_0100
619  * @tc.desc: Test OnRemoteRequestInnerSixteenth
620  * @tc.type: FUNC
621  */
622 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerSixteenth_0100, TestSize.Level1)
623 {
624     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerSixteenth_0100 begin");
625 
626     MessageParcel data;
627     MessageParcel reply;
628     MessageOption option;
629     uint32_t code[] = {
630         static_cast<uint32_t>(AbilityManagerInterfaceCode::COMPLETE_FIRST_FRAME_DRAWING_BY_SCB),
631         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_EXTENSION_ABILITY_EMBEDDED),
632         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_EXTENSION_CONSTRAINED_EMBEDDED),
633         static_cast<uint32_t>(AbilityManagerInterfaceCode::REQUEST_DIALOG_SERVICE),
634         static_cast<uint32_t>(AbilityManagerInterfaceCode::REPORT_DRAWN_COMPLETED),
635         static_cast<uint32_t>(AbilityManagerInterfaceCode::QUERY_MISSION_VAILD),
636         static_cast<uint32_t>(AbilityManagerInterfaceCode::VERIFY_PERMISSION),
637         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_UI_ABILITY_BY_SCB),
638         static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_ROOT_SCENE_SESSION),
639         static_cast<uint32_t>(AbilityManagerInterfaceCode::CALL_ABILITY_BY_SCB),
640         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_SPECIFIED_ABILITY_BY_SCB)
641     };
642 
643     int i = 0;
644     while (i < sizeof(code) / sizeof(uint32_t)) {
645         stub_->OnRemoteRequestInnerSixteenth(code[i++], data, reply, option);
646     }
647 
648     uint32_t code_ = 0;
649     auto ret = stub_->OnRemoteRequestInnerSixteenth(code_, data, reply, option);
650     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
651 
652     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerSixteenth_0100 end");
653 }
654 
655 /**
656  * @tc.name: OnRemoteRequestInnerSeventeenth_0100
657  * @tc.desc: Test OnRemoteRequestInnerSeventeenth
658  * @tc.type: FUNC
659  */
660 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerSeventeenth_0100, TestSize.Level1)
661 {
662     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerSeventeenth_0100 begin");
663 
664     MessageParcel data;
665     MessageParcel reply;
666     MessageOption option;
667     uint32_t code[] = {
668         static_cast<uint32_t>(AbilityManagerInterfaceCode::NOTIFY_SAVE_AS_RESULT),
669         static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_SESSIONMANAGERSERVICE),
670         static_cast<uint32_t>(AbilityManagerInterfaceCode::UPDATE_SESSION_INFO),
671         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_STATUS_BAR_DELEGATE),
672         static_cast<uint32_t>(AbilityManagerInterfaceCode::KILL_PROCESS_WITH_PREPARE_TERMINATE),
673         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_AUTO_STARTUP_SYSTEM_CALLBACK),
674         static_cast<uint32_t>(AbilityManagerInterfaceCode::UNREGISTER_AUTO_STARTUP_SYSTEM_CALLBACK),
675         static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_APPLICATION_AUTO_STARTUP),
676         static_cast<uint32_t>(AbilityManagerInterfaceCode::CANCEL_APPLICATION_AUTO_STARTUP),
677         static_cast<uint32_t>(AbilityManagerInterfaceCode::QUERY_ALL_AUTO_STARTUP_APPLICATION)
678     };
679 
680     int i = 0;
681     while (i < sizeof(code) / sizeof(uint32_t)) {
682         stub_->OnRemoteRequestInnerSeventeenth(code[i++], data, reply, option);
683     }
684 
685     uint32_t code_ = 0;
686     auto ret = stub_->OnRemoteRequestInnerSeventeenth(code_, data, reply, option);
687     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
688 
689     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerSeventeenth_0100 end");
690 }
691 
692 /**
693  * @tc.name: OnRemoteRequestInnerEighteenth_0100
694  * @tc.desc: Test OnRemoteRequestInnerEighteenth
695  * @tc.type: FUNC
696  */
697 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerEighteenth_0100, TestSize.Level1)
698 {
699     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerEighteenth_0100 begin");
700 
701     MessageParcel data;
702     MessageParcel reply;
703     MessageOption option;
704     uint32_t code[] = {
705         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_CONNECTION_DATA),
706         static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_APPLICATION_AUTO_STARTUP_BY_EDM),
707         static_cast<uint32_t>(AbilityManagerInterfaceCode::CANCEL_APPLICATION_AUTO_STARTUP_BY_EDM),
708         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_FOR_RESULT_AS_CALLER),
709         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_FOR_RESULT_AS_CALLER_FOR_OPTIONS),
710         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_FOREGROUND_UI_ABILITIES),
711         static_cast<uint32_t>(AbilityManagerInterfaceCode::RESTART_APP),
712         static_cast<uint32_t>(AbilityManagerInterfaceCode::OPEN_ATOMIC_SERVICE),
713         static_cast<uint32_t>(AbilityManagerInterfaceCode::IS_EMBEDDED_OPEN_ALLOWED),
714         static_cast<uint32_t>(AbilityManagerInterfaceCode::REQUEST_ASSERT_FAULT_DIALOG)
715     };
716 
717     int i = 0;
718     while (i < sizeof(code) / sizeof(uint32_t)) {
719         stub_->OnRemoteRequestInnerEighteenth(code[i++], data, reply, option);
720     }
721 
722     uint32_t code_ = 0;
723     auto ret = stub_->OnRemoteRequestInnerEighteenth(code_, data, reply, option);
724     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
725 
726     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerEighteenth_0100 end");
727 }
728 
729 /**
730  * @tc.name: OnRemoteRequestInnerNineteenth_0100
731  * @tc.desc: Test OnRemoteRequestInnerNineteenth
732  * @tc.type: FUNC
733  */
734 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInnerNineteenth_0100, TestSize.Level1)
735 {
736     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerNineteenth_0100 begin");
737 
738     MessageParcel data;
739     MessageParcel reply;
740     MessageOption option;
741     uint32_t code[] = {
742         static_cast<uint32_t>(AbilityManagerInterfaceCode::NOTIFY_DEBUG_ASSERT_RESULT),
743         static_cast<uint32_t>(AbilityManagerInterfaceCode::CHANGE_ABILITY_VISIBILITY),
744         static_cast<uint32_t>(AbilityManagerInterfaceCode::CHANGE_UI_ABILITY_VISIBILITY_BY_SCB),
745         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_SHORTCUT),
746         static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_RESIDENT_PROCESS_ENABLE),
747         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_ABILITY_STATE_BY_PERSISTENT_ID),
748         static_cast<uint32_t>(AbilityManagerInterfaceCode::TRANSFER_ABILITY_RESULT),
749         static_cast<uint32_t>(AbilityManagerInterfaceCode::NOTIFY_FROZEN_PROCESS_BY_RSS),
750         static_cast<uint32_t>(AbilityManagerInterfaceCode::PRE_START_MISSION),
751         static_cast<uint32_t>(AbilityManagerInterfaceCode::CLEAN_UI_ABILITY_BY_SCB),
752         static_cast<uint32_t>(AbilityManagerInterfaceCode::OPEN_LINK),
753         static_cast<uint32_t>(AbilityManagerInterfaceCode::TERMINATE_MISSION),
754         static_cast<uint32_t>(AbilityManagerInterfaceCode::BLOCK_ALL_APP_START)
755     };
756 
757     int i = 0;
758     while (i < sizeof(code) / sizeof(uint32_t)) {
759         stub_->OnRemoteRequestInnerNineteenth(code[i++], data, reply, option);
760     }
761 
762     uint32_t code_ = 0;
763     auto ret = stub_->OnRemoteRequestInnerNineteenth(code_, data, reply, option);
764     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
765 
766     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInnerNineteenth_0100 end");
767 }
768 
769 /**
770  * @tc.name: OnRemoteRequestInner_0100
771  * @tc.desc: Test OnRemoteRequestInner
772  * @tc.type: FUNC
773  */
774 HWTEST_F(AbilityManagerStubSecondTest, OnRemoteRequestInner_0100, TestSize.Level1)
775 {
776     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInner_0100 begin");
777 
778     MessageParcel data;
779     MessageParcel reply;
780     MessageOption option;
781     uint32_t code = static_cast<uint32_t>(AbilityManagerInterfaceCode::TERMINATE_ABILITY);
782     stub_->OnRemoteRequestInner(code, data, reply, option);
783 
784     code = static_cast<uint32_t>(AbilityManagerInterfaceCode::ACQUIRE_SHARE_DATA);
785     stub_->OnRemoteRequestInner(code, data, reply, option);
786 
787     code = 0;
788     auto ret = stub_->OnRemoteRequestInner(code, data, reply, option);
789     EXPECT_NE(ret, ERR_OK);
790 
791     TAG_LOGI(AAFwkTag::TEST, "OnRemoteRequestInner_0100 end");
792 }
793 
794 /**
795  * @tc.name: HandleOnRemoteRequestInnerFirst_0100
796  * @tc.desc: Test HandleOnRemoteRequestInnerFirst
797  * @tc.type: FUNC
798  */
799 HWTEST_F(AbilityManagerStubSecondTest, HandleOnRemoteRequestInnerFirst_0100, TestSize.Level1)
800 {
801     TAG_LOGI(AAFwkTag::TEST, "HandleOnRemoteRequestInnerFirst_0100 begin");
802 
803     MessageParcel data;
804     MessageParcel reply;
805     MessageOption option;
806     uint32_t code[] = {
807         static_cast<uint32_t>(AbilityManagerInterfaceCode::TERMINATE_ABILITY),
808         static_cast<uint32_t>(AbilityManagerInterfaceCode::KILL_PROCESS),
809         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_ABILITY_BY_INSIGHT_INTENT),
810         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_CONTINUATION),
811         static_cast<uint32_t>(AbilityManagerInterfaceCode::STOP_SYNC_MISSIONS),
812         static_cast<uint32_t>(AbilityManagerInterfaceCode::REGISTER_COLLABORATOR),
813         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PENDING_WANT_SENDER),
814         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_PENDING_REQUEST_WANT),
815         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_MISSION_INFOS),
816         static_cast<uint32_t>(AbilityManagerInterfaceCode::RELEASE_CALL_ABILITY)
817     };
818 
819     int i = 0;
820     while (i < sizeof(code) / sizeof(uint32_t)) {
821         stub_->HandleOnRemoteRequestInnerFirst(code[i++], data, reply, option);
822     }
823 
824     uint32_t code_ = 0;
825     auto ret = stub_->HandleOnRemoteRequestInnerFirst(code_, data, reply, option);
826     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
827 
828     TAG_LOGI(AAFwkTag::TEST, "HandleOnRemoteRequestInnerFirst_0100 end");
829 }
830 
831 /**
832  * @tc.name: HandleOnRemoteRequestInnerSecond_0100
833  * @tc.desc: Test HandleOnRemoteRequestInnerSecond
834  * @tc.type: FUNC
835  */
836 HWTEST_F(AbilityManagerStubSecondTest, HandleOnRemoteRequestInnerSecond_0100, TestSize.Level1)
837 {
838     TAG_LOGI(AAFwkTag::TEST, "HandleOnRemoteRequestInnerSecond_0100 begin");
839 
840     MessageParcel data;
841     MessageParcel reply;
842     MessageOption option;
843     uint32_t code[] = {
844         static_cast<uint32_t>(AbilityManagerInterfaceCode::ACQUIRE_SHARE_DATA),
845         static_cast<uint32_t>(AbilityManagerInterfaceCode::START_USER_TEST),
846         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_ELEMENT_NAME_BY_TOKEN),
847         static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_MISSION_CONTINUE_STATE),
848         static_cast<uint32_t>(AbilityManagerInterfaceCode::SET_MISSION_LABEL),
849         static_cast<uint32_t>(AbilityManagerInterfaceCode::COMPLETE_FIRST_FRAME_DRAWING_BY_SCB),
850         static_cast<uint32_t>(AbilityManagerInterfaceCode::NOTIFY_SAVE_AS_RESULT),
851         static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_CONNECTION_DATA),
852         static_cast<uint32_t>(AbilityManagerInterfaceCode::NOTIFY_DEBUG_ASSERT_RESULT)
853     };
854 
855     int i = 0;
856     while (i < sizeof(code) / sizeof(uint32_t)) {
857         stub_->HandleOnRemoteRequestInnerSecond(code[i++], data, reply, option);
858     }
859 
860     uint32_t code_ = 0;
861     auto ret = stub_->HandleOnRemoteRequestInnerSecond(code_, data, reply, option);
862     EXPECT_EQ(ret, ERR_CODE_NOT_EXIST);
863 
864     TAG_LOGI(AAFwkTag::TEST, "HandleOnRemoteRequestInnerSecond_0100 end");
865 }
866 } // namespace AAFwk
867 } // namespace OHOS
868