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: StartAbilityForResultAsCallerInner
1079 * SubFunction: NA
1080 * FunctionPoints: AbilityManagerService StartAbilityForResultAsCallerInner
1081 * EnvConditions: NA
1082 * CaseDescription: Verify the function StartAbilityForResultAsCallerInner is normal flow.
1083 */
1084 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityForResultAsCallerInner_001, TestSize.Level1)
1085 {
1086 MessageParcel data;
1087 MessageParcel reply;
1088 auto res = stub_->StartAbilityForResultAsCallerInner(data, reply);
1089 EXPECT_EQ(res, ERR_INVALID_VALUE);
1090 }
1091
1092 /*
1093 * Feature: AbilityManagerService
1094 * Function: StartAbilityForResultAsCallerForOptionsInner
1095 * SubFunction: NA
1096 * FunctionPoints: AbilityManagerService StartAbilityForResultAsCallerForOptionsInner
1097 * EnvConditions: NA
1098 * CaseDescription: Verify the function StartAbilityForResultAsCallerForOptionsInner is normal flow.
1099 */
1100 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityForResultAsCallerForOptionsInner_001, TestSize.Level1)
1101 {
1102 MessageParcel data;
1103 MessageParcel reply;
1104 auto res = stub_->StartAbilityForResultAsCallerForOptionsInner(data, reply);
1105 EXPECT_EQ(res, ERR_INVALID_VALUE);
1106 }
1107
1108 /*
1109 * Feature: AbilityManagerService
1110 * Function: ConnectAbilityInner
1111 * SubFunction: NA
1112 * FunctionPoints: AbilityManagerService ConnectAbilityInner
1113 * EnvConditions: NA
1114 * CaseDescription: Verify the function ConnectAbilityInner is normal flow.
1115 */
1116 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ConnectAbilityInner_001, TestSize.Level1)
1117 {
1118 MessageParcel data;
1119 MessageParcel reply;
1120 auto res = stub_->ConnectAbilityInner(data, reply);
1121 EXPECT_EQ(res, ERR_INVALID_VALUE);
1122 }
1123
1124 /*
1125 * Feature: AbilityManagerService
1126 * Function: ConnectAbilityWithTypeInner
1127 * SubFunction: NA
1128 * FunctionPoints: AbilityManagerService ConnectAbilityWithTypeInner
1129 * EnvConditions: NA
1130 * CaseDescription: Verify the function ConnectAbilityWithTypeInner is normal flow.
1131 */
1132 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ConnectAbilityWithTypeInner_001, TestSize.Level1)
1133 {
1134 MessageParcel data;
1135 MessageParcel reply;
1136 auto res = stub_->ConnectAbilityWithTypeInner(data, reply);
1137 EXPECT_EQ(res, ERR_INVALID_VALUE);
1138 }
1139
1140 /*
1141 * Feature: AbilityManagerService
1142 * Function: ConnectUIExtensionAbilityInner
1143 * SubFunction: NA
1144 * FunctionPoints: AbilityManagerService ConnectUIExtensionAbilityInner
1145 * EnvConditions: NA
1146 * CaseDescription: Verify the function ConnectUIExtensionAbilityInner is normal flow.
1147 */
1148 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ConnectUIExtensionAbilityInner_001, TestSize.Level1)
1149 {
1150 MessageParcel data;
1151 MessageParcel reply;
1152 auto res = stub_->ConnectUIExtensionAbilityInner(data, reply);
1153 EXPECT_EQ(res, ERR_INVALID_VALUE);
1154 }
1155
1156 /*
1157 * Feature: AbilityManagerService
1158 * Function: DisconnectAbilityInner
1159 * SubFunction: NA
1160 * FunctionPoints: AbilityManagerService DisconnectAbilityInner
1161 * EnvConditions: NA
1162 * CaseDescription: Verify the function DisconnectAbilityInner is normal flow.
1163 */
1164 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DisconnectAbilityInner_001, TestSize.Level1)
1165 {
1166 MessageParcel data;
1167 MessageParcel reply;
1168 stub_->DisconnectAbilityInner(data, reply);
1169 EXPECT_TRUE(stub_ != nullptr);
1170 }
1171
1172 /*
1173 * Feature: AbilityManagerService
1174 * Function: StopServiceAbilityInner
1175 * SubFunction: NA
1176 * FunctionPoints: AbilityManagerService StopServiceAbilityInner
1177 * EnvConditions: NA
1178 * CaseDescription: Verify the function StopServiceAbilityInner is normal flow.
1179 */
1180 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StopServiceAbilityInner_001, TestSize.Level1)
1181 {
1182 MessageParcel data;
1183 MessageParcel reply;
1184 auto res = stub_->StopServiceAbilityInner(data, reply);
1185 EXPECT_EQ(res, ERR_INVALID_VALUE);
1186 }
1187
1188 /*
1189 * Feature: AbilityManagerService
1190 * Function: DumpSysStateInner
1191 * SubFunction: NA
1192 * FunctionPoints: AbilityManagerService DumpSysStateInner
1193 * EnvConditions: NA
1194 * CaseDescription: Verify the function DumpSysStateInner is normal flow.
1195 */
1196 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DumpSysStateInner_001, TestSize.Level1)
1197 {
1198 MessageParcel data;
1199 MessageParcel reply;
1200 auto res = stub_->DumpSysStateInner(data, reply);
1201 EXPECT_EQ(res, ERR_INVALID_VALUE);
1202 }
1203
1204 /*
1205 * Feature: AbilityManagerService
1206 * Function: DumpStateInner
1207 * SubFunction: NA
1208 * FunctionPoints: AbilityManagerService DumpStateInner
1209 * EnvConditions: NA
1210 * CaseDescription: Verify the function DumpStateInner is normal flow.
1211 */
1212 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DumpStateInner_001, TestSize.Level1)
1213 {
1214 MessageParcel data;
1215 MessageParcel reply;
1216 auto res = stub_->DumpStateInner(data, reply);
1217 EXPECT_EQ(res, ERR_INVALID_VALUE);
1218 }
1219
1220 /*
1221 * Feature: AbilityManagerService
1222 * Function: StartAbilityForSettingsInner
1223 * SubFunction: NA
1224 * FunctionPoints: AbilityManagerService StartAbilityForSettingsInner
1225 * EnvConditions: NA
1226 * CaseDescription: Verify the function StartAbilityForSettingsInner is normal flow.
1227 */
1228 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityForSettingsInner_001, TestSize.Level1)
1229 {
1230 MessageParcel data;
1231 MessageParcel reply;
1232 auto res = stub_->StartAbilityForSettingsInner(data, reply);
1233 EXPECT_EQ(res, ERR_INVALID_VALUE);
1234 }
1235
1236 /*
1237 * Feature: AbilityManagerService
1238 * Function: StartAbilityForOptionsInner
1239 * SubFunction: NA
1240 * FunctionPoints: AbilityManagerService StartAbilityForOptionsInner
1241 * EnvConditions: NA
1242 * CaseDescription: Verify the function StartAbilityForOptionsInner is normal flow.
1243 */
1244 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityForOptionsInner_001, TestSize.Level1)
1245 {
1246 MessageParcel data;
1247 MessageParcel reply;
1248 auto res = stub_->StartAbilityForOptionsInner(data, reply);
1249 EXPECT_EQ(res, ERR_INVALID_VALUE);
1250 }
1251
1252 /*
1253 * Feature: AbilityManagerService
1254 * Function: CloseUIAbilityBySCBInner
1255 * SubFunction: NA
1256 * FunctionPoints: AbilityManagerService CloseUIAbilityBySCBInner
1257 * EnvConditions: NA
1258 * CaseDescription: Verify the function CloseUIAbilityBySCBInner is normal flow.
1259 */
1260 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CloseUIAbilityBySCBInner_001, TestSize.Level1)
1261 {
1262 MessageParcel data;
1263 MessageParcel reply;
1264 auto res = stub_->CloseUIAbilityBySCBInner(data, reply);
1265 EXPECT_EQ(res, NO_ERROR);
1266 }
1267
1268 /*
1269 * Feature: AbilityManagerService
1270 * Function: GetWantSenderInner
1271 * SubFunction: NA
1272 * FunctionPoints: AbilityManagerService GetWantSenderInner
1273 * EnvConditions: NA
1274 * CaseDescription: Verify the function GetWantSenderInner is normal flow.
1275 */
1276 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetWantSenderInner_001, TestSize.Level1)
1277 {
1278 MessageParcel data;
1279 MessageParcel reply;
1280 auto res = stub_->GetWantSenderInner(data, reply);
1281 EXPECT_EQ(res, ERR_INVALID_VALUE);
1282 }
1283
1284 /*
1285 * Feature: AbilityManagerService
1286 * Function: SendWantSenderInner
1287 * SubFunction: NA
1288 * FunctionPoints: AbilityManagerService SendWantSenderInner
1289 * EnvConditions: NA
1290 * CaseDescription: Verify the function SendWantSenderInner is normal flow.
1291 */
1292 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SendWantSenderInner_001, TestSize.Level1)
1293 {
1294 MessageParcel data;
1295 MessageParcel reply;
1296 auto res = stub_->SendWantSenderInner(data, reply);
1297 EXPECT_EQ(res, ERR_INVALID_VALUE);
1298 }
1299
1300 /*
1301 * Feature: AbilityManagerService
1302 * Function: CancelWantSenderInner
1303 * SubFunction: NA
1304 * FunctionPoints: AbilityManagerService CancelWantSenderInner
1305 * EnvConditions: NA
1306 * CaseDescription: Verify the function CancelWantSenderInner is normal flow.
1307 */
1308 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CancelWantSenderInner_001, TestSize.Level1)
1309 {
1310 MessageParcel data;
1311 MessageParcel reply;
1312 auto res = stub_->CancelWantSenderInner(data, reply);
1313 EXPECT_EQ(res, ERR_INVALID_VALUE);
1314 }
1315
1316 /*
1317 * Feature: AbilityManagerService
1318 * Function: GetPendingWantUidInner
1319 * SubFunction: NA
1320 * FunctionPoints: AbilityManagerService GetPendingWantUidInner
1321 * EnvConditions: NA
1322 * CaseDescription: Verify the function GetPendingWantUidInner is normal flow.
1323 */
1324 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantUidInner_001, TestSize.Level1)
1325 {
1326 MessageParcel data;
1327 MessageParcel reply;
1328 auto res = stub_->GetPendingWantUidInner(data, reply);
1329 EXPECT_EQ(res, ERR_INVALID_VALUE);
1330 }
1331
1332 /*
1333 * Feature: AbilityManagerService
1334 * Function: GetPendingWantUserIdInner
1335 * SubFunction: NA
1336 * FunctionPoints: AbilityManagerService GetPendingWantUserIdInner
1337 * EnvConditions: NA
1338 * CaseDescription: Verify the function GetPendingWantUserIdInner is normal flow.
1339 */
1340 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantUserIdInner_001, TestSize.Level1)
1341 {
1342 MessageParcel data;
1343 MessageParcel reply;
1344 auto res = stub_->GetPendingWantUserIdInner(data, reply);
1345 EXPECT_EQ(res, ERR_INVALID_VALUE);
1346 }
1347
1348 /*
1349 * Feature: AbilityManagerService
1350 * Function: GetPendingWantBundleNameInner
1351 * SubFunction: NA
1352 * FunctionPoints: AbilityManagerService GetPendingWantBundleNameInner
1353 * EnvConditions: NA
1354 * CaseDescription: Verify the function GetPendingWantBundleNameInner is normal flow.
1355 */
1356 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantBundleNameInner_001, TestSize.Level1)
1357 {
1358 MessageParcel data;
1359 MessageParcel reply;
1360 auto res = stub_->GetPendingWantBundleNameInner(data, reply);
1361 EXPECT_EQ(res, ERR_INVALID_VALUE);
1362 }
1363
1364 /*
1365 * Feature: AbilityManagerService
1366 * Function: GetPendingWantCodeInner
1367 * SubFunction: NA
1368 * FunctionPoints: AbilityManagerService GetPendingWantCodeInner
1369 * EnvConditions: NA
1370 * CaseDescription: Verify the function GetPendingWantCodeInner is normal flow.
1371 */
1372 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantCodeInner_001, TestSize.Level1)
1373 {
1374 MessageParcel data;
1375 MessageParcel reply;
1376 auto res = stub_->GetPendingWantCodeInner(data, reply);
1377 EXPECT_EQ(res, ERR_INVALID_VALUE);
1378 }
1379
1380 /*
1381 * Feature: AbilityManagerService
1382 * Function: GetPendingWantTypeInner
1383 * SubFunction: NA
1384 * FunctionPoints: AbilityManagerService GetPendingWantTypeInner
1385 * EnvConditions: NA
1386 * CaseDescription: Verify the function GetPendingWantTypeInner is normal flow.
1387 */
1388 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingWantTypeInner_001, TestSize.Level1)
1389 {
1390 MessageParcel data;
1391 MessageParcel reply;
1392 auto res = stub_->GetPendingWantTypeInner(data, reply);
1393 EXPECT_EQ(res, ERR_INVALID_VALUE);
1394 }
1395
1396 /*
1397 * Feature: AbilityManagerService
1398 * Function: RegisterCancelListenerInner
1399 * SubFunction: NA
1400 * FunctionPoints: AbilityManagerService RegisterCancelListenerInner
1401 * EnvConditions: NA
1402 * CaseDescription: Verify the function RegisterCancelListenerInner is normal flow.
1403 */
1404 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterCancelListenerInner_001, TestSize.Level1)
1405 {
1406 MessageParcel data;
1407 MessageParcel reply;
1408 auto res = stub_->RegisterCancelListenerInner(data, reply);
1409 EXPECT_EQ(res, ERR_INVALID_VALUE);
1410 }
1411
1412 /*
1413 * Feature: AbilityManagerService
1414 * Function: UnregisterCancelListenerInner
1415 * SubFunction: NA
1416 * FunctionPoints: AbilityManagerService UnregisterCancelListenerInner
1417 * EnvConditions: NA
1418 * CaseDescription: Verify the function UnregisterCancelListenerInner is normal flow.
1419 */
1420 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterCancelListenerInner_001, TestSize.Level1)
1421 {
1422 MessageParcel data;
1423 MessageParcel reply;
1424 auto res = stub_->UnregisterCancelListenerInner(data, reply);
1425 EXPECT_EQ(res, ERR_INVALID_VALUE);
1426 }
1427
1428 /*
1429 * Feature: AbilityManagerService
1430 * Function: GetPendingRequestWantInner
1431 * SubFunction: NA
1432 * FunctionPoints: AbilityManagerService GetPendingRequestWantInner
1433 * EnvConditions: NA
1434 * CaseDescription: Verify the function GetPendingRequestWantInner is normal flow.
1435 */
1436 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetPendingRequestWantInner_001, TestSize.Level1)
1437 {
1438 MessageParcel data;
1439 MessageParcel reply;
1440 auto res = stub_->GetPendingRequestWantInner(data, reply);
1441 EXPECT_EQ(res, ERR_INVALID_VALUE);
1442 }
1443
1444 /*
1445 * Feature: AbilityManagerService
1446 * Function: GetWantSenderInfoInner
1447 * SubFunction: NA
1448 * FunctionPoints: AbilityManagerService GetWantSenderInfoInner
1449 * EnvConditions: NA
1450 * CaseDescription: Verify the function GetWantSenderInfoInner is normal flow.
1451 */
1452 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetWantSenderInfoInner_001, TestSize.Level1)
1453 {
1454 MessageParcel data;
1455 MessageParcel reply;
1456 auto res = stub_->GetWantSenderInfoInner(data, reply);
1457 EXPECT_EQ(res, ERR_INVALID_VALUE);
1458 }
1459
1460 /*
1461 * Feature: AbilityManagerService
1462 * Function: GetAppMemorySizeInner
1463 * SubFunction: NA
1464 * FunctionPoints: AbilityManagerService GetAppMemorySizeInner
1465 * EnvConditions: NA
1466 * CaseDescription: Verify the function GetAppMemorySizeInner is normal flow.
1467 */
1468 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetAppMemorySizeInner_001, TestSize.Level1)
1469 {
1470 MessageParcel data;
1471 MessageParcel reply;
1472 auto res = stub_->GetAppMemorySizeInner(data, reply);
1473 EXPECT_EQ(res, NO_ERROR);
1474 }
1475
1476 /*
1477 * Feature: AbilityManagerService
1478 * Function: IsRamConstrainedDeviceInner
1479 * SubFunction: NA
1480 * FunctionPoints: AbilityManagerService IsRamConstrainedDeviceInner
1481 * EnvConditions: NA
1482 * CaseDescription: Verify the function IsRamConstrainedDeviceInner is normal flow.
1483 */
1484 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsRamConstrainedDeviceInner_001, TestSize.Level1)
1485 {
1486 MessageParcel data;
1487 MessageParcel reply;
1488 auto res = stub_->IsRamConstrainedDeviceInner(data, reply);
1489 EXPECT_EQ(res, NO_ERROR);
1490 }
1491
1492 /*
1493 * Feature: AbilityManagerService
1494 * Function: ContinueMissionInner
1495 * SubFunction: NA
1496 * FunctionPoints: AbilityManagerService ContinueMissionInner
1497 * EnvConditions: NA
1498 * CaseDescription: Verify the function ContinueMissionInner is normal flow.
1499 */
1500 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ContinueMissionInner_001, TestSize.Level1)
1501 {
1502 MessageParcel data;
1503 MessageParcel reply;
1504 auto res = stub_->ContinueMissionInner(data, reply);
1505 EXPECT_EQ(res, ERR_NULL_OBJECT);
1506 }
1507
1508 /*
1509 * Feature: AbilityManagerService
1510 * Function: ContinueMissionOfBundleNameInner
1511 * SubFunction: NA
1512 * FunctionPoints: AbilityManagerService ContinueMissionOfBundleNameInner
1513 * EnvConditions: NA
1514 * CaseDescription: Verify the function ContinueMissionOfBundleNameInner is normal flow.
1515 */
1516 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ContinueMissionOfBundleNameInner_001, TestSize.Level1)
1517 {
1518 MessageParcel data;
1519 MessageParcel reply;
1520 auto res = stub_->ContinueMissionOfBundleNameInner(data, reply);
1521 EXPECT_EQ(res, ERR_NULL_OBJECT);
1522 }
1523
1524 /*
1525 * Feature: AbilityManagerService
1526 * Function: ContinueMissionOfBundleNameInner
1527 * SubFunction: NA
1528 * FunctionPoints: AbilityManagerService ContinueMissionOfBundleNameInner
1529 * EnvConditions: NA
1530 * CaseDescription: Verify the function ContinueMissionOfBundleNameInner is normal flow.
1531 */
1532 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ContinueMissionOfBundleNameInner_002, TestSize.Level1)
1533 {
1534 MessageParcel data;
1535 MessageParcel reply;
1536 Want want;
1537 data.WriteParcelable(&want);
1538 auto res = stub_->ContinueMissionOfBundleNameInner(data, reply);
1539 EXPECT_EQ(res, ERR_NULL_OBJECT);
1540 }
1541
1542 /*
1543 * Feature: AbilityManagerService
1544 * Function: ContinueAbilityInner
1545 * SubFunction: NA
1546 * FunctionPoints: AbilityManagerService ContinueAbilityInner
1547 * EnvConditions: NA
1548 * CaseDescription: Verify the function ContinueAbilityInner is normal flow.
1549 */
1550 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ContinueAbilityInner_001, TestSize.Level1)
1551 {
1552 MessageParcel data;
1553 MessageParcel reply;
1554 auto res = stub_->ContinueAbilityInner(data, reply);
1555 EXPECT_EQ(res, NO_ERROR);
1556 }
1557
1558 /*
1559 * Feature: AbilityManagerService
1560 * Function: StartContinuationInner
1561 * SubFunction: NA
1562 * FunctionPoints: AbilityManagerService StartContinuationInner
1563 * EnvConditions: NA
1564 * CaseDescription: Verify the function StartContinuationInner is normal flow.
1565 */
1566 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartContinuationInner_001, TestSize.Level1)
1567 {
1568 MessageParcel data;
1569 MessageParcel reply;
1570 auto res = stub_->StartContinuationInner(data, reply);
1571 EXPECT_EQ(res, ERR_NULL_OBJECT);
1572 }
1573
1574 /*
1575 * Feature: AbilityManagerService
1576 * Function: NotifyCompleteContinuationInner
1577 * SubFunction: NA
1578 * FunctionPoints: AbilityManagerService NotifyCompleteContinuationInner
1579 * EnvConditions: NA
1580 * CaseDescription: Verify the function NotifyCompleteContinuationInner is normal flow.
1581 */
1582 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_NotifyCompleteContinuationInner_001, TestSize.Level1)
1583 {
1584 MessageParcel data;
1585 MessageParcel reply;
1586 auto res = stub_->NotifyCompleteContinuationInner(data, reply);
1587 EXPECT_EQ(res, NO_ERROR);
1588 }
1589
1590 /*
1591 * Feature: AbilityManagerService
1592 * Function: NotifyContinuationResultInner
1593 * SubFunction: NA
1594 * FunctionPoints: AbilityManagerService NotifyContinuationResultInner
1595 * EnvConditions: NA
1596 * CaseDescription: Verify the function NotifyContinuationResultInner is normal flow.
1597 */
1598 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_NotifyContinuationResultInner_001, TestSize.Level1)
1599 {
1600 MessageParcel data;
1601 MessageParcel reply;
1602 auto res = stub_->NotifyContinuationResultInner(data, reply);
1603 EXPECT_EQ(res, NO_ERROR);
1604 }
1605
1606 /*
1607 * Feature: AbilityManagerService
1608 * Function: LockMissionForCleanupInner
1609 * SubFunction: NA
1610 * FunctionPoints: AbilityManagerService LockMissionForCleanupInner
1611 * EnvConditions: NA
1612 * CaseDescription: Verify the function LockMissionForCleanupInner is normal flow.
1613 */
1614 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_LockMissionForCleanupInner_001, TestSize.Level1)
1615 {
1616 MessageParcel data;
1617 MessageParcel reply;
1618 auto res = stub_->LockMissionForCleanupInner(data, reply);
1619 EXPECT_EQ(res, NO_ERROR);
1620 }
1621
1622 /*
1623 * Feature: AbilityManagerService
1624 * Function: UnlockMissionForCleanupInner
1625 * SubFunction: NA
1626 * FunctionPoints: AbilityManagerService UnlockMissionForCleanupInner
1627 * EnvConditions: NA
1628 * CaseDescription: Verify the function UnlockMissionForCleanupInner is normal flow.
1629 */
1630 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnlockMissionForCleanupInner_001, TestSize.Level1)
1631 {
1632 MessageParcel data;
1633 MessageParcel reply;
1634 auto res = stub_->UnlockMissionForCleanupInner(data, reply);
1635 EXPECT_EQ(res, NO_ERROR);
1636 }
1637
1638 /*
1639 * Feature: AbilityManagerService
1640 * Function: SetLockedStateInner
1641 * SubFunction: NA
1642 * FunctionPoints: AbilityManagerService SetLockedStateInner
1643 * EnvConditions: NA
1644 * CaseDescription: Verify the function SetLockedStateInner is normal flow.
1645 */
1646 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetLockedStateInner_001, TestSize.Level1)
1647 {
1648 MessageParcel data;
1649 MessageParcel reply;
1650 auto res = stub_->SetLockedStateInner(data, reply);
1651 EXPECT_EQ(res, NO_ERROR);
1652 }
1653
1654 /*
1655 * Feature: AbilityManagerService
1656 * Function: RegisterMissionListenerInner
1657 * SubFunction: NA
1658 * FunctionPoints: AbilityManagerService RegisterMissionListenerInner
1659 * EnvConditions: NA
1660 * CaseDescription: Verify the function RegisterMissionListenerInner is normal flow.
1661 */
1662 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterMissionListenerInner_001, TestSize.Level1)
1663 {
1664 MessageParcel data;
1665 MessageParcel reply;
1666 auto res = stub_->RegisterMissionListenerInner(data, reply);
1667 EXPECT_EQ(res, ERR_INVALID_VALUE);
1668 }
1669
1670 /*
1671 * Feature: AbilityManagerService
1672 * Function: UnRegisterMissionListenerInner
1673 * SubFunction: NA
1674 * FunctionPoints: AbilityManagerService UnRegisterMissionListenerInner
1675 * EnvConditions: NA
1676 * CaseDescription: Verify the function UnRegisterMissionListenerInner is normal flow.
1677 */
1678 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnRegisterMissionListenerInner_001, TestSize.Level1)
1679 {
1680 MessageParcel data;
1681 MessageParcel reply;
1682 auto res = stub_->UnRegisterMissionListenerInner(data, reply);
1683 EXPECT_EQ(res, ERR_INVALID_VALUE);
1684 }
1685
1686 /*
1687 * Feature: AbilityManagerService
1688 * Function: GetMissionInfosInner
1689 * SubFunction: NA
1690 * FunctionPoints: AbilityManagerService GetMissionInfosInner
1691 * EnvConditions: NA
1692 * CaseDescription: Verify the function GetMissionInfosInner is normal flow.
1693 */
1694 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetMissionInfosInner_001, TestSize.Level1)
1695 {
1696 MessageParcel data;
1697 MessageParcel reply;
1698 auto res = stub_->GetMissionInfosInner(data, reply);
1699 EXPECT_EQ(res, NO_ERROR);
1700 }
1701
1702 /*
1703 * Feature: AbilityManagerService
1704 * Function: GetMissionInfoInner
1705 * SubFunction: NA
1706 * FunctionPoints: AbilityManagerService GetMissionInfoInner
1707 * EnvConditions: NA
1708 * CaseDescription: Verify the function GetMissionInfoInner is normal flow.
1709 */
1710 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetMissionInfoInner_001, TestSize.Level1)
1711 {
1712 MessageParcel data;
1713 MessageParcel reply;
1714 auto res = stub_->GetMissionInfoInner(data, reply);
1715 EXPECT_EQ(res, NO_ERROR);
1716 }
1717
1718 /*
1719 * Feature: AbilityManagerService
1720 * Function: CleanMissionInner
1721 * SubFunction: NA
1722 * FunctionPoints: AbilityManagerService CleanMissionInner
1723 * EnvConditions: NA
1724 * CaseDescription: Verify the function CleanMissionInner is normal flow.
1725 */
1726 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CleanMissionInner_001, TestSize.Level1)
1727 {
1728 MessageParcel data;
1729 MessageParcel reply;
1730 auto res = stub_->CleanMissionInner(data, reply);
1731 EXPECT_EQ(res, NO_ERROR);
1732 }
1733
1734 /*
1735 * Feature: AbilityManagerService
1736 * Function: CleanAllMissionsInner
1737 * SubFunction: NA
1738 * FunctionPoints: AbilityManagerService CleanAllMissionsInner
1739 * EnvConditions: NA
1740 * CaseDescription: Verify the function CleanAllMissionsInner is normal flow.
1741 */
1742 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CleanAllMissionsInner_001, TestSize.Level1)
1743 {
1744 MessageParcel data;
1745 MessageParcel reply;
1746 auto res = stub_->CleanAllMissionsInner(data, reply);
1747 EXPECT_EQ(res, NO_ERROR);
1748 }
1749
1750 /*
1751 * Feature: AbilityManagerService
1752 * Function: MoveMissionToFrontInner
1753 * SubFunction: NA
1754 * FunctionPoints: AbilityManagerService MoveMissionToFrontInner
1755 * EnvConditions: NA
1756 * CaseDescription: Verify the function MoveMissionToFrontInner is normal flow.
1757 */
1758 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveMissionToFrontInner_001, TestSize.Level1)
1759 {
1760 MessageParcel data;
1761 MessageParcel reply;
1762 auto res = stub_->MoveMissionToFrontInner(data, reply);
1763 EXPECT_EQ(res, NO_ERROR);
1764 }
1765
1766 /*
1767 * Feature: AbilityManagerService
1768 * Function: MoveMissionsToForegroundInner
1769 * SubFunction: NA
1770 * FunctionPoints: AbilityManagerService MoveMissionsToForegroundInner
1771 * EnvConditions: NA
1772 * CaseDescription: Verify the function MoveMissionsToForegroundInner is normal flow.
1773 */
1774 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveMissionsToForegroundInner_001, TestSize.Level1)
1775 {
1776 TAG_LOGD(AAFwkTag::TEST, "%{public}s is called.", __func__);
1777 MessageParcel data;
1778 MessageParcel reply;
1779 auto res = stub_->MoveMissionsToForegroundInner(data, reply);
1780 EXPECT_EQ(res, NO_ERROR);
1781 }
1782
1783 /*
1784 * Feature: AbilityManagerService
1785 * Function: MoveMissionsToBackgroundInner
1786 * SubFunction: NA
1787 * FunctionPoints: AbilityManagerService MoveMissionsToBackgroundInner
1788 * EnvConditions: NA
1789 * CaseDescription: Verify the function MoveMissionsToBackgroundInner is normal flow.
1790 */
1791 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveMissionsToBackgroundInner_001, TestSize.Level1)
1792 {
1793 TAG_LOGD(AAFwkTag::TEST, "%{public}s is called.", __func__);
1794 MessageParcel data;
1795 MessageParcel reply;
1796 auto res = stub_->MoveMissionsToBackgroundInner(data, reply);
1797 EXPECT_EQ(res, NO_ERROR);
1798 }
1799
1800 /*
1801 * Feature: AbilityManagerService
1802 * Function: GetMissionIdByTokenInner
1803 * SubFunction: NA
1804 * FunctionPoints: AbilityManagerService GetMissionIdByTokenInner
1805 * EnvConditions: NA
1806 * CaseDescription: Verify the function GetMissionIdByTokenInner is normal flow.
1807 */
1808 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetMissionIdByTokenInner_001, TestSize.Level1)
1809 {
1810 MessageParcel data;
1811 MessageParcel reply;
1812 auto res = stub_->GetMissionIdByTokenInner(data, reply);
1813 EXPECT_EQ(res, NO_ERROR);
1814 }
1815
1816 /*
1817 * Feature: AbilityManagerService
1818 * Function: MoveMissionToFrontByOptionsInner
1819 * SubFunction: NA
1820 * FunctionPoints: AbilityManagerService MoveMissionToFrontByOptionsInner
1821 * EnvConditions: NA
1822 * CaseDescription: Verify the function MoveMissionToFrontByOptionsInner is normal flow.
1823 */
1824 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_MoveMissionToFrontByOptionsInner_001, TestSize.Level1)
1825 {
1826 MessageParcel data;
1827 MessageParcel reply;
1828 auto res = stub_->MoveMissionToFrontByOptionsInner(data, reply);
1829 EXPECT_EQ(res, ERR_INVALID_VALUE);
1830 }
1831
1832 /*
1833 * Feature: AbilityManagerService
1834 * Function: StartAbilityByCallInner
1835 * SubFunction: NA
1836 * FunctionPoints: AbilityManagerService StartAbilityByCallInner
1837 * EnvConditions: NA
1838 * CaseDescription: Verify the function StartAbilityByCallInner is normal flow.
1839 */
1840 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityByCallInner_001, TestSize.Level1)
1841 {
1842 MessageParcel data;
1843 MessageParcel reply;
1844 auto res = stub_->StartAbilityByCallInner(data, reply);
1845 EXPECT_EQ(res, ERR_INVALID_VALUE);
1846 }
1847
1848 /*
1849 * Feature: AbilityManagerService
1850 * Function: StartUIAbilityBySCBInner
1851 * SubFunction: NA
1852 * FunctionPoints: AbilityManagerService StartUIAbilityBySCBInner
1853 * EnvConditions: NA
1854 * CaseDescription: Verify the function StartUIAbilityBySCBInner is normal flow.
1855 */
1856 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUIAbilityBySCBInner_001, TestSize.Level1)
1857 {
1858 MessageParcel data;
1859 MessageParcel reply;
1860 auto res = stub_->StartUIAbilityBySCBInner(data, reply);
1861 EXPECT_EQ(res, NO_ERROR);
1862 }
1863
1864 /*
1865 * Feature: AbilityManagerService
1866 * Function: ReleaseCallInner
1867 * SubFunction: NA
1868 * FunctionPoints: AbilityManagerService ReleaseCallInner
1869 * EnvConditions: NA
1870 * CaseDescription: Verify the function ReleaseCallInner is normal flow.
1871 */
1872 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ReleaseCallInner_001, TestSize.Level1)
1873 {
1874 MessageParcel data;
1875 MessageParcel reply;
1876 auto res = stub_->ReleaseCallInner(data, reply);
1877 EXPECT_EQ(res, ERR_INVALID_VALUE);
1878 }
1879
1880 /*
1881 * Feature: AbilityManagerService
1882 * Function: StartUserInner
1883 * SubFunction: NA
1884 * FunctionPoints: AbilityManagerService StartUserInner
1885 * EnvConditions: NA
1886 * CaseDescription: Verify the function StartUserInner is normal flow.
1887 */
1888 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUserInner_001, TestSize.Level1)
1889 {
1890 MessageParcel data;
1891 MessageParcel reply;
1892 auto res = stub_->StartUserInner(data, reply);
1893 EXPECT_NE(res, NO_ERROR);
1894 }
1895
1896 /*
1897 * Feature: AbilityManagerService
1898 * Function: StopUserInner
1899 * SubFunction: NA
1900 * FunctionPoints: AbilityManagerService StopUserInner
1901 * EnvConditions: NA
1902 * CaseDescription: Verify the function StopUserInner is normal flow.
1903 */
1904 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StopUserInner_001, TestSize.Level1)
1905 {
1906 MessageParcel data;
1907 MessageParcel reply;
1908 auto res = stub_->StopUserInner(data, reply);
1909 EXPECT_EQ(res, NO_ERROR);
1910 }
1911
1912 /*
1913 * Feature: AbilityManagerService
1914 * Function: LogoutUserInner
1915 * SubFunction: NA
1916 * FunctionPoints: AbilityManagerService LogoutUserInner
1917 * EnvConditions: NA
1918 * CaseDescription: Verify the function LogoutUserInner is normal flow.
1919 */
1920 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_LogoutUserInner_001, TestSize.Level1)
1921 {
1922 MessageParcel data;
1923 MessageParcel reply;
1924 auto res = stub_->LogoutUserInner(data, reply);
1925 EXPECT_EQ(res, NO_ERROR);
1926 }
1927
1928 /*
1929 * Feature: AbilityManagerService
1930 * Function: GetAbilityRunningInfosInner
1931 * SubFunction: NA
1932 * FunctionPoints: AbilityManagerService GetAbilityRunningInfosInner
1933 * EnvConditions: NA
1934 * CaseDescription: Verify the function GetAbilityRunningInfosInner is normal flow.
1935 */
1936 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetAbilityRunningInfosInner_001, TestSize.Level1)
1937 {
1938 MessageParcel data;
1939 MessageParcel reply;
1940 auto res = stub_->GetAbilityRunningInfosInner(data, reply);
1941 EXPECT_EQ(res, NO_ERROR);
1942 }
1943
1944 /*
1945 * Feature: AbilityManagerService
1946 * Function: GetExtensionRunningInfosInner
1947 * SubFunction: NA
1948 * FunctionPoints: AbilityManagerService GetExtensionRunningInfosInner
1949 * EnvConditions: NA
1950 * CaseDescription: Verify the function GetExtensionRunningInfosInner is normal flow.
1951 */
1952 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetExtensionRunningInfosInner_001, TestSize.Level1)
1953 {
1954 MessageParcel data;
1955 MessageParcel reply;
1956 auto res = stub_->GetExtensionRunningInfosInner(data, reply);
1957 EXPECT_EQ(res, NO_ERROR);
1958 }
1959
1960 /*
1961 * Feature: AbilityManagerService
1962 * Function: GetProcessRunningInfosInner
1963 * SubFunction: NA
1964 * FunctionPoints: AbilityManagerService GetProcessRunningInfosInner
1965 * EnvConditions: NA
1966 * CaseDescription: Verify the function GetProcessRunningInfosInner is normal flow.
1967 */
1968 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetProcessRunningInfosInner_001, TestSize.Level1)
1969 {
1970 MessageParcel data;
1971 MessageParcel reply;
1972 auto res = stub_->GetProcessRunningInfosInner(data, reply);
1973 EXPECT_EQ(res, NO_ERROR);
1974 }
1975
1976 /*
1977 * Feature: AbilityManagerService
1978 * Function: StartSyncRemoteMissionsInner
1979 * SubFunction: NA
1980 * FunctionPoints: AbilityManagerService StartSyncRemoteMissionsInner
1981 * EnvConditions: NA
1982 * CaseDescription: Verify the function StartSyncRemoteMissionsInner is normal flow.
1983 */
1984 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartSyncRemoteMissionsInner_001, TestSize.Level1)
1985 {
1986 MessageParcel data;
1987 MessageParcel reply;
1988 auto res = stub_->StartSyncRemoteMissionsInner(data, reply);
1989 EXPECT_EQ(res, NO_ERROR);
1990 }
1991
1992 /*
1993 * Feature: AbilityManagerService
1994 * Function: StopSyncRemoteMissionsInner
1995 * SubFunction: NA
1996 * FunctionPoints: AbilityManagerService StopSyncRemoteMissionsInner
1997 * EnvConditions: NA
1998 * CaseDescription: Verify the function StopSyncRemoteMissionsInner is normal flow.
1999 */
2000 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StopSyncRemoteMissionsInner_001, TestSize.Level1)
2001 {
2002 MessageParcel data;
2003 MessageParcel reply;
2004 auto res = stub_->StopSyncRemoteMissionsInner(data, reply);
2005 EXPECT_EQ(res, NO_ERROR);
2006 }
2007
2008 /*
2009 * Feature: AbilityManagerService
2010 * Function: RegisterRemoteMissionListenerInner
2011 * SubFunction: NA
2012 * FunctionPoints: AbilityManagerService RegisterRemoteMissionListenerInner
2013 * EnvConditions: NA
2014 * CaseDescription: Verify the function RegisterRemoteMissionListenerInner is normal flow.
2015 */
2016 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterRemoteMissionListenerInner_001, TestSize.Level1)
2017 {
2018 MessageParcel data;
2019 MessageParcel reply;
2020 auto res = stub_->RegisterRemoteMissionListenerInner(data, reply);
2021 EXPECT_EQ(res, INVALID_PARAMETERS_ERR);
2022 }
2023
2024 /*
2025 * Feature: AbilityManagerService
2026 * Function: UnRegisterRemoteMissionListenerInner
2027 * SubFunction: NA
2028 * FunctionPoints: AbilityManagerService UnRegisterRemoteMissionListenerInner
2029 * EnvConditions: NA
2030 * CaseDescription: Verify the function UnRegisterRemoteMissionListenerInner is normal flow.
2031 */
2032 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnRegisterRemoteMissionListenerInner_001, TestSize.Level1)
2033 {
2034 MessageParcel data;
2035 MessageParcel reply;
2036 auto res = stub_->UnRegisterRemoteMissionListenerInner(data, reply);
2037 EXPECT_EQ(res, INVALID_PARAMETERS_ERR);
2038 }
2039
2040 /*
2041 * Feature: AbilityManagerService
2042 * Function: RegisterRemoteOnListenerInner
2043 * SubFunction: NA
2044 * FunctionPoints: AbilityManagerService RegisterRemoteOnListenerInner
2045 * EnvConditions: NA
2046 * CaseDescription: Verify the function RegisterRemoteOnListenerInner is normal flow.
2047 */
2048 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterRemoteOnListenerInner_001, TestSize.Level1)
2049 {
2050 MessageParcel data;
2051 MessageParcel reply;
2052 auto res = stub_->RegisterRemoteOnListenerInner(data, reply);
2053 EXPECT_EQ(res, ERR_NULL_OBJECT);
2054 }
2055
2056 /**
2057 * @tc.name: SetResidentProcessEnableInner_001
2058 * @tc.desc: SetResidentProcessEnableInner
2059 * @tc.type: FUNC
2060 */
2061 HWTEST_F(AbilityManagerStubTest, SetResidentProcessEnableInner_001, TestSize.Level1)
2062 {
2063 ASSERT_NE(stub_, nullptr);
2064 MessageParcel data;
2065 MessageParcel reply;
2066 auto result = stub_->SetResidentProcessEnableInner(data, reply);
2067 EXPECT_EQ(result, NO_ERROR);
2068 }
2069
2070 /*
2071 * Feature: AbilityManagerService
2072 * Function: RegisterRemoteOffListenerInner
2073 * SubFunction: NA
2074 * FunctionPoints: AbilityManagerService RegisterRemoteOffListenerInner
2075 * EnvConditions: NA
2076 * CaseDescription: Verify the function RegisterRemoteOffListenerInner is normal flow.
2077 */
2078 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterRemoteOffListenerInner_001, TestSize.Level1)
2079 {
2080 MessageParcel data;
2081 MessageParcel reply;
2082 auto res = stub_->RegisterRemoteOffListenerInner(data, reply);
2083 EXPECT_EQ(res, ERR_NULL_OBJECT);
2084 }
2085
2086 /*
2087 * Feature: AbilityManagerService
2088 * Function: RegisterSnapshotHandlerInner
2089 * SubFunction: NA
2090 * FunctionPoints: AbilityManagerService RegisterSnapshotHandlerInner
2091 * EnvConditions: NA
2092 * CaseDescription: Verify the function RegisterSnapshotHandlerInner is normal flow.
2093 */
2094 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterSnapshotHandlerInner_001, TestSize.Level1)
2095 {
2096 MessageParcel data;
2097 MessageParcel reply;
2098 auto res = stub_->RegisterSnapshotHandlerInner(data, reply);
2099 EXPECT_EQ(res, ERR_NULL_OBJECT);
2100 }
2101
2102 /*
2103 * Feature: AbilityManagerService
2104 * Function: GetMissionSnapshotInfoInner
2105 * SubFunction: NA
2106 * FunctionPoints: AbilityManagerService GetMissionSnapshotInfoInner
2107 * EnvConditions: NA
2108 * CaseDescription: Verify the function GetMissionSnapshotInfoInner is normal flow.
2109 */
2110 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetMissionSnapshotInfoInner_001, TestSize.Level1)
2111 {
2112 MessageParcel data;
2113 MessageParcel reply;
2114 auto res = stub_->GetMissionSnapshotInfoInner(data, reply);
2115 EXPECT_EQ(res, NO_ERROR);
2116 }
2117
2118 /*
2119 * Feature: AbilityManagerService
2120 * Function: SetAbilityControllerInner
2121 * SubFunction: NA
2122 * FunctionPoints: AbilityManagerService SetAbilityControllerInner
2123 * EnvConditions: NA
2124 * CaseDescription: Verify the function SetAbilityControllerInner is normal flow.
2125 */
2126 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetAbilityControllerInner_001, TestSize.Level1)
2127 {
2128 MessageParcel data;
2129 MessageParcel reply;
2130 auto res = stub_->SetAbilityControllerInner(data, reply);
2131 EXPECT_EQ(res, ERR_NULL_OBJECT);
2132 }
2133
2134 /*
2135 * Feature: AbilityManagerService
2136 * Function: IsRunningInStabilityTestInner
2137 * SubFunction: NA
2138 * FunctionPoints: AbilityManagerService IsRunningInStabilityTestInner
2139 * EnvConditions: NA
2140 * CaseDescription: Verify the function IsRunningInStabilityTestInner is normal flow.
2141 */
2142 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsRunningInStabilityTestInner_001, TestSize.Level1)
2143 {
2144 MessageParcel data;
2145 MessageParcel reply;
2146 auto res = stub_->IsRunningInStabilityTestInner(data, reply);
2147 EXPECT_EQ(res, NO_ERROR);
2148 }
2149
2150 /*
2151 * Feature: AbilityManagerService
2152 * Function: StartUserTestInner
2153 * SubFunction: NA
2154 * FunctionPoints: AbilityManagerService StartUserTestInner
2155 * EnvConditions: NA
2156 * CaseDescription: Verify the function StartUserTestInner is normal flow.
2157 */
2158 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartUserTestInner_001, TestSize.Level1)
2159 {
2160 MessageParcel data;
2161 MessageParcel reply;
2162 auto res = stub_->StartUserTestInner(data, reply);
2163 EXPECT_EQ(res, ERR_INVALID_VALUE);
2164 }
2165
2166 /*
2167 * Feature: AbilityManagerService
2168 * Function: FinishUserTestInner
2169 * SubFunction: NA
2170 * FunctionPoints: AbilityManagerService FinishUserTestInner
2171 * EnvConditions: NA
2172 * CaseDescription: Verify the function FinishUserTestInner is normal flow.
2173 */
2174 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_FinishUserTestInner_001, TestSize.Level1)
2175 {
2176 MessageParcel data;
2177 MessageParcel reply;
2178 auto res = stub_->FinishUserTestInner(data, reply);
2179 EXPECT_EQ(res, NO_ERROR);
2180 }
2181
2182 /*
2183 * Feature: AbilityManagerService
2184 * Function: GetTopAbilityTokenInner
2185 * SubFunction: NA
2186 * FunctionPoints: AbilityManagerService GetTopAbilityTokenInner
2187 * EnvConditions: NA
2188 * CaseDescription: Verify the function GetTopAbilityTokenInner is normal flow.
2189 */
2190 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetTopAbilityTokenInner_001, TestSize.Level1)
2191 {
2192 MessageParcel data;
2193 MessageParcel reply;
2194 auto res = stub_->GetTopAbilityTokenInner(data, reply);
2195 EXPECT_EQ(res, ERR_INVALID_VALUE);
2196 }
2197
2198 /*
2199 * Feature: AbilityManagerStub
2200 * Function: CheckUIExtensionIsFocusedInner
2201 * SubFunction: NA
2202 * FunctionPoints: AbilityManagerService CheckUIExtensionIsFocusedInner
2203 * EnvConditions: NA
2204 * CaseDescription: Verify the function CheckUIExtensionIsFocused is normal flow.
2205 */
2206 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CheckUIExtensionIsFocusedInner_001, TestSize.Level1)
2207 {
2208 MessageParcel data;
2209 MessageParcel reply;
2210 auto res = stub_->CheckUIExtensionIsFocusedInner(data, reply);
2211 EXPECT_EQ(res, NO_ERROR);
2212 }
2213
2214
2215 /*
2216 * Feature: AbilityManagerService
2217 * Function: DelegatorDoAbilityForegroundInner
2218 * SubFunction: NA
2219 * FunctionPoints: AbilityManagerService DelegatorDoAbilityForegroundInner
2220 * EnvConditions: NA
2221 * CaseDescription: Verify the function DelegatorDoAbilityForegroundInner is normal flow.
2222 */
2223 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DelegatorDoAbilityForegroundInner_001, TestSize.Level1)
2224 {
2225 MessageParcel data;
2226 MessageParcel reply;
2227 auto res = stub_->DelegatorDoAbilityForegroundInner(data, reply);
2228 EXPECT_EQ(res, NO_ERROR);
2229 }
2230
2231 /*
2232 * Feature: AbilityManagerService
2233 * Function: DelegatorDoAbilityBackgroundInner
2234 * SubFunction: NA
2235 * FunctionPoints: AbilityManagerService DelegatorDoAbilityBackgroundInner
2236 * EnvConditions: NA
2237 * CaseDescription: Verify the function DelegatorDoAbilityBackgroundInner is normal flow.
2238 */
2239 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DelegatorDoAbilityBackgroundInner_001, TestSize.Level1)
2240 {
2241 MessageParcel data;
2242 MessageParcel reply;
2243 auto res = stub_->DelegatorDoAbilityBackgroundInner(data, reply);
2244 EXPECT_EQ(res, NO_ERROR);
2245 }
2246
2247 /*
2248 * Feature: AbilityManagerService
2249 * Function: DoAbilityForeground
2250 * SubFunction: NA
2251 * FunctionPoints: AbilityManagerService DoAbilityForeground
2252 * EnvConditions: NA
2253 * CaseDescription: Verify the function DoAbilityForeground is normal flow.
2254 */
2255 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DoAbilityForeground_001, TestSize.Level1)
2256 {
2257 sptr<IRemoteObject> token = nullptr;
2258 uint32_t flag = 0;
2259 auto res = stub_->DoAbilityForeground(token, flag);
2260 EXPECT_EQ(res, NO_ERROR);
2261 }
2262
2263 /*
2264 * Feature: AbilityManagerService
2265 * Function: DoAbilityBackground
2266 * SubFunction: NA
2267 * FunctionPoints: AbilityManagerService DoAbilityBackground
2268 * EnvConditions: NA
2269 * CaseDescription: Verify the function DoAbilityBackground is normal flow.
2270 */
2271 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DoAbilityBackground_001, TestSize.Level1)
2272 {
2273 sptr<IRemoteObject> token = nullptr;
2274 uint32_t flag = 0;
2275 auto res = stub_->DoAbilityBackground(token, flag);
2276 EXPECT_EQ(res, NO_ERROR);
2277 }
2278
2279 /*
2280 * Feature: AbilityManagerService
2281 * Function: DoAbilityForegroundInner
2282 * SubFunction: NA
2283 * FunctionPoints: AbilityManagerService DoAbilityForegroundInner
2284 * EnvConditions: NA
2285 * CaseDescription: Verify the function DoAbilityForegroundInner is normal flow.
2286 */
2287 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DoAbilityForegroundInner_001, TestSize.Level1)
2288 {
2289 MessageParcel data;
2290 MessageParcel reply;
2291 auto res = stub_->DoAbilityForegroundInner(data, reply);
2292 EXPECT_EQ(res, NO_ERROR);
2293 }
2294
2295 /*
2296 * Feature: AbilityManagerService
2297 * Function: DoAbilityBackgroundInner
2298 * SubFunction: NA
2299 * FunctionPoints: AbilityManagerService DoAbilityBackgroundInner
2300 * EnvConditions: NA
2301 * CaseDescription: Verify the function DoAbilityBackgroundInner is normal flow.
2302 */
2303 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DoAbilityBackgroundInner_001, TestSize.Level1)
2304 {
2305 MessageParcel data;
2306 MessageParcel reply;
2307 auto res = stub_->DoAbilityBackgroundInner(data, reply);
2308 EXPECT_EQ(res, NO_ERROR);
2309 }
2310
2311 /*
2312 * Feature: AbilityManagerService
2313 * Function: RegisterObserver
2314 * SubFunction: NA
2315 * FunctionPoints: AbilityManagerService RegisterObserver
2316 * EnvConditions: NA
2317 * CaseDescription: Verify the function RegisterObserver is normal flow.
2318 */
2319 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterObserver_001, TestSize.Level1)
2320 {
2321 sptr<AbilityRuntime::IConnectionObserver> observer = nullptr;
2322 auto res = stub_->RegisterObserver(observer);
2323 EXPECT_EQ(res, NO_ERROR);
2324 }
2325
2326 /*
2327 * Feature: AbilityManagerService
2328 * Function: UnregisterObserver
2329 * SubFunction: NA
2330 * FunctionPoints: AbilityManagerService UnregisterObserver
2331 * EnvConditions: NA
2332 * CaseDescription: Verify the function UnregisterObserver is normal flow.
2333 */
2334 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterObserver_001, TestSize.Level1)
2335 {
2336 sptr<AbilityRuntime::IConnectionObserver> observer = nullptr;
2337 auto res = stub_->UnregisterObserver(observer);
2338 EXPECT_EQ(res, NO_ERROR);
2339 }
2340
2341 #ifdef WITH_DLP
2342 /*
2343 * Feature: AbilityManagerService
2344 * Function: GetDlpConnectionInfos
2345 * SubFunction: NA
2346 * FunctionPoints: AbilityManagerService GetDlpConnectionInfos
2347 * EnvConditions: NA
2348 * CaseDescription: Verify the function GetDlpConnectionInfos is normal flow.
2349 */
2350 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetDlpConnectionInfos_001, TestSize.Level1)
2351 {
2352 std::vector<AbilityRuntime::DlpConnectionInfo> infos;
2353 auto res = stub_->GetDlpConnectionInfos(infos);
2354 EXPECT_EQ(res, NO_ERROR);
2355 }
2356 #endif // WITH_DLP
2357
2358 /*
2359 * Feature: AbilityManagerService
2360 * Function: GetConnectionData
2361 * SubFunction: NA
2362 * FunctionPoints: AbilityManagerService GetConnectionData
2363 * EnvConditions: NA
2364 * CaseDescription: Verify the function GetConnectionData is normal flow.
2365 */
2366 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetConnectionData_001, TestSize.Level1)
2367 {
2368 std::vector<AbilityRuntime::ConnectionData> connectionData;
2369 auto res = stub_->GetConnectionData(connectionData);
2370 EXPECT_EQ(res, NO_ERROR);
2371 }
2372
2373 #ifdef ABILITY_COMMAND_FOR_TEST
2374 /*
2375 * Feature: AbilityManagerService
2376 * Function: ForceTimeoutForTestInner
2377 * SubFunction: NA
2378 * FunctionPoints: AbilityManagerService ForceTimeoutForTestInner
2379 * EnvConditions: NA
2380 * CaseDescription: Verify the function ForceTimeoutForTestInner is normal flow.
2381 */
2382 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ForceTimeoutForTestInner_001, TestSize.Level1)
2383 {
2384 MessageParcel data;
2385 MessageParcel reply;
2386 auto res = stub_->ForceTimeoutForTestInner(data, reply);
2387 EXPECT_EQ(res, NO_ERROR);
2388 }
2389 #endif
2390
2391 /*
2392 * Feature: AbilityManagerService
2393 * Function: FreeInstallAbilityFromRemoteInner
2394 * SubFunction: NA
2395 * FunctionPoints: AbilityManagerService FreeInstallAbilityFromRemoteInner
2396 * EnvConditions: NA
2397 * CaseDescription: Verify the function FreeInstallAbilityFromRemoteInner is normal flow.
2398 */
2399 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_FreeInstallAbilityFromRemoteInner_001, TestSize.Level1)
2400 {
2401 MessageParcel data;
2402 MessageParcel reply;
2403 auto res = stub_->FreeInstallAbilityFromRemoteInner(data, reply);
2404 EXPECT_EQ(res, ERR_INVALID_VALUE);
2405 }
2406
2407 /*
2408 * Feature: AbilityManagerService
2409 * Function: AddFreeInstallObserverInner
2410 * SubFunction: NA
2411 * FunctionPoints: AbilityManagerService AddFreeInstallObserverInner
2412 * EnvConditions: NA
2413 * CaseDescription: Verify the function AddFreeInstallObserverInner is normal flow.
2414 */
2415 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AddFreeInstallObserverInner_001, TestSize.Level1)
2416 {
2417 MessageParcel data;
2418 MessageParcel reply;
2419 auto res = stub_->AddFreeInstallObserverInner(data, reply);
2420 EXPECT_EQ(res, ERR_INVALID_VALUE);
2421 }
2422
2423 /*
2424 * Feature: AbilityManagerService
2425 * Function: DumpAbilityInfoDoneInner
2426 * SubFunction: NA
2427 * FunctionPoints: AbilityManagerService DumpAbilityInfoDoneInner
2428 * EnvConditions: NA
2429 * CaseDescription: Verify the function DumpAbilityInfoDoneInner is normal flow.
2430 */
2431 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DumpAbilityInfoDoneInner_001, TestSize.Level1)
2432 {
2433 MessageParcel data;
2434 MessageParcel reply;
2435 auto res = stub_->DumpAbilityInfoDoneInner(data, reply);
2436 EXPECT_EQ(res, NO_ERROR);
2437 }
2438
2439 /*
2440 * Feature: AbilityManagerService
2441 * Function: UpdateMissionSnapShotFromWMSInner
2442 * SubFunction: NA
2443 * FunctionPoints: AbilityManagerService UpdateMissionSnapShotFromWMSInner
2444 * EnvConditions: NA
2445 * CaseDescription: Verify the function UpdateMissionSnapShotFromWMSInner is normal flow.
2446 */
2447 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UpdateMissionSnapShotFromWMSInner_001, TestSize.Level1)
2448 {
2449 MessageParcel data;
2450 MessageParcel reply;
2451 auto res = stub_->UpdateMissionSnapShotFromWMSInner(data, reply);
2452 EXPECT_EQ(res, ERR_NULL_OBJECT);
2453 }
2454
2455 /*
2456 * Feature: AbilityManagerService
2457 * Function: EnableRecoverAbilityInner
2458 * SubFunction: NA
2459 * FunctionPoints: AbilityManagerService EnableRecoverAbilityInner
2460 * EnvConditions: NA
2461 * CaseDescription: Verify the function EnableRecoverAbilityInner is normal flow.
2462 */
2463 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_EnableRecoverAbilityInner_001, TestSize.Level1)
2464 {
2465 MessageParcel data;
2466 MessageParcel reply;
2467 auto res = stub_->EnableRecoverAbilityInner(data, reply);
2468 EXPECT_EQ(res, ERR_NULL_OBJECT);
2469 }
2470
2471 /*
2472 * Feature: AbilityManagerService
2473 * Function: HandleRequestDialogService
2474 * SubFunction: NA
2475 * FunctionPoints: AbilityManagerService HandleRequestDialogService
2476 * EnvConditions: NA
2477 * CaseDescription: Verify the function HandleRequestDialogService is normal flow.
2478 */
2479 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_HandleRequestDialogService_001, TestSize.Level1)
2480 {
2481 MessageParcel data;
2482 MessageParcel reply;
2483 auto res = stub_->HandleRequestDialogService(data, reply);
2484 EXPECT_EQ(res, ERR_INVALID_VALUE);
2485 }
2486
2487 /**
2488 * @tc.number: HandleReportDrawnCompleted_001
2489 * @tc.name: HandleReportDrawnCompleted
2490 * @tc.desc: Returns ERR_INVALID_VALUE after passing in parameters
2491 */
2492 HWTEST_F(AbilityManagerStubTest, HandleReportDrawnCompleted_001, TestSize.Level1)
2493 {
2494 MessageParcel data;
2495 MessageParcel reply;
2496 auto res = stub_->HandleReportDrawnCompleted(data, reply);
2497 EXPECT_EQ(res, ERR_INVALID_VALUE);
2498 }
2499
2500 /*
2501 * Feature: AbilityManagerService
2502 * Function: AcquireShareDataInner
2503 * SubFunction: NA
2504 * FunctionPoints: AbilityManagerService AcquireShareDataInner
2505 * EnvConditions: NA
2506 * CaseDescription: Verify the function AcquireShareDataInner is normal flow.
2507 */
2508 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AcquireShareDataInner_001, TestSize.Level1)
2509 {
2510 MessageParcel data;
2511 MessageParcel reply;
2512 auto res = stub_->AcquireShareDataInner(data, reply);
2513 EXPECT_EQ(res, ERR_INVALID_VALUE);
2514 }
2515
2516 /*
2517 * Feature: AbilityManagerService
2518 * Function: ShareDataDoneInner
2519 * SubFunction: NA
2520 * FunctionPoints: AbilityManagerService ShareDataDoneInner
2521 * EnvConditions: NA
2522 * CaseDescription: Verify the function ShareDataDoneInner is normal flow.
2523 */
2524 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ShareDataDoneInner_001, TestSize.Level1)
2525 {
2526 MessageParcel data;
2527 MessageParcel reply;
2528 auto res = stub_->ShareDataDoneInner(data, reply);
2529 EXPECT_EQ(res, ERR_NULL_OBJECT);
2530 }
2531
2532 /*
2533 * Feature: AbilityManagerService
2534 * Function: GetAbilityTokenByCalleeObjInner
2535 * SubFunction: NA
2536 * FunctionPoints: AbilityManagerService GetAbilityTokenByCalleeObjInner
2537 * EnvConditions: NA
2538 * CaseDescription: Verify the function GetAbilityTokenByCalleeObjInner is normal flow.
2539 */
2540 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetAbilityTokenByCalleeObjInner_001, TestSize.Level1)
2541 {
2542 MessageParcel data;
2543 MessageParcel reply;
2544 auto res = stub_->GetAbilityTokenByCalleeObjInner(data, reply);
2545 EXPECT_EQ(res, ERR_NULL_OBJECT);
2546 }
2547
2548 #ifdef ABILITY_COMMAND_FOR_TEST
2549 /*
2550 * Feature: AbilityManagerService
2551 * Function: ScheduleRecoverAbilityInner
2552 * SubFunction: NA
2553 * FunctionPoints: AbilityManagerService ScheduleRecoverAbilityInner
2554 * EnvConditions: NA
2555 * CaseDescription: Verify the function ScheduleRecoverAbilityInner is normal flow.
2556 */
2557 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ScheduleRecoverAbilityInner_001, TestSize.Level1)
2558 {
2559 MessageParcel data;
2560 MessageParcel reply;
2561 auto res = stub_->ScheduleRecoverAbilityInner(data, reply);
2562 EXPECT_EQ(res, ERR_NULL_OBJECT);
2563 }
2564 #endif
2565
2566 #ifdef ABILITY_COMMAND_FOR_TEST
2567 /*
2568 * Feature: AbilityManagerService
2569 * Function: EnableRecoverAbilityInner
2570 * SubFunction: NA
2571 * FunctionPoints: AbilityManagerService EnableRecoverAbilityInner
2572 * EnvConditions: NA
2573 * CaseDescription: Verify the function EnableRecoverAbilityInner is normal flow.
2574 */
2575 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_EnableRecoverAbilityInner_001, TestSize.Level1)
2576 {
2577 MessageParcel data;
2578 MessageParcel reply;
2579 auto res = stub_->EnableRecoverAbilityInner(data, reply);
2580 EXPECT_EQ(res, ERR_NULL_OBJECT);
2581 }
2582 #endif
2583
2584 /*
2585 * Feature: AbilityManagerService
2586 * Function: RegisterConnectionObserverInner
2587 * SubFunction: NA
2588 * FunctionPoints: AbilityManagerService RegisterConnectionObserverInner
2589 * EnvConditions: NA
2590 * CaseDescription: Verify the function RegisterConnectionObserverInner is normal flow.
2591 */
2592 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterConnectionObserverInner_001, TestSize.Level1)
2593 {
2594 MessageParcel data;
2595 MessageParcel reply;
2596 auto res = stub_->RegisterConnectionObserverInner(data, reply);
2597 EXPECT_EQ(res, ERR_NULL_OBJECT);
2598 }
2599
2600 /*
2601 * Feature: AbilityManagerService
2602 * Function: UnregisterConnectionObserverInner
2603 * SubFunction: NA
2604 * FunctionPoints: AbilityManagerService UnregisterConnectionObserverInner
2605 * EnvConditions: NA
2606 * CaseDescription: Verify the function UnregisterConnectionObserverInner is normal flow.
2607 */
2608 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterConnectionObserverInner_001, TestSize.Level1)
2609 {
2610 MessageParcel data;
2611 MessageParcel reply;
2612 auto res = stub_->UnregisterConnectionObserverInner(data, reply);
2613 EXPECT_EQ(res, ERR_NULL_OBJECT);
2614 }
2615
2616 #ifdef WITH_DLP
2617 /*
2618 * Feature: AbilityManagerService
2619 * Function: GetDlpConnectionInfosInner
2620 * SubFunction: NA
2621 * FunctionPoints: AbilityManagerService GetDlpConnectionInfosInner
2622 * EnvConditions: NA
2623 * CaseDescription: Verify the function GetDlpConnectionInfosInner is normal flow.
2624 */
2625 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetDlpConnectionInfosInner_001, TestSize.Level1)
2626 {
2627 MessageParcel data;
2628 MessageParcel reply;
2629 auto res = stub_->GetDlpConnectionInfosInner(data, reply);
2630 EXPECT_EQ(res, ERR_OK);
2631 }
2632 #endif // WITH_DLP
2633
2634 /*
2635 * Feature: AbilityManagerService
2636 * Function: GetConnectionDataInner
2637 * SubFunction: NA
2638 * FunctionPoints: AbilityManagerService GetConnectionDataInner
2639 * EnvConditions: NA
2640 * CaseDescription: Verify the function GetConnectionDataInner is normal flow.
2641 */
2642 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetConnectionDataInner_001, TestSize.Level1)
2643 {
2644 MessageParcel data;
2645 MessageParcel reply;
2646 auto res = stub_->GetConnectionDataInner(data, reply);
2647 EXPECT_EQ(res, ERR_OK);
2648 }
2649
2650 /*
2651 * Feature: AbilityManagerService
2652 * Function: SetMissionContinueStateInner
2653 * SubFunction: NA
2654 * FunctionPoints: AbilityManagerService SetMissionContinueStateInner
2655 * EnvConditions: NA
2656 * CaseDescription: Verify the function SetMissionContinueStateInner is normal flow.
2657 */
2658 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetMissionContinueStateInner_001, TestSize.Level1)
2659 {
2660 MessageParcel data;
2661 MessageParcel reply;
2662 auto res = stub_->SetMissionContinueStateInner(data, reply);
2663 EXPECT_EQ(res, ERR_NULL_OBJECT);
2664 }
2665
2666 /*
2667 * Feature: AbilityManagerService
2668 * Function: SetMissionLabelInner
2669 * SubFunction: NA
2670 * FunctionPoints: AbilityManagerService SetMissionLabelInner
2671 * EnvConditions: NA
2672 * CaseDescription: Verify the function SetMissionLabelInner is normal flow.
2673 */
2674 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetMissionLabelInner_001, TestSize.Level1)
2675 {
2676 MessageParcel data;
2677 MessageParcel reply;
2678 auto res = stub_->SetMissionLabelInner(data, reply);
2679 EXPECT_EQ(res, ERR_NULL_OBJECT);
2680 }
2681
2682 /*
2683 * Feature: AbilityManagerService
2684 * Function: SetMissionIconInner
2685 * SubFunction: NA
2686 * FunctionPoints: AbilityManagerService SetMissionIconInner
2687 * EnvConditions: NA
2688 * CaseDescription: Verify the function SetMissionIconInner is normal flow.
2689 */
2690 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetMissionIconInner_001, TestSize.Level1)
2691 {
2692 MessageParcel data;
2693 MessageParcel reply;
2694 auto res = stub_->SetMissionIconInner(data, reply);
2695 EXPECT_EQ(res, ERR_NULL_OBJECT);
2696 }
2697
2698 /*
2699 * Feature: AbilityManagerService
2700 * Function: RegisterWindowManagerServiceHandlerInner
2701 * SubFunction: NA
2702 * FunctionPoints: AbilityManagerService RegisterWindowManagerServiceHandlerInner
2703 * EnvConditions: NA
2704 * CaseDescription: Verify the function RegisterWindowManagerServiceHandlerInner is normal flow.
2705 */
2706 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterWindowManagerServiceHandlerInner_001, TestSize.Level1)
2707 {
2708 MessageParcel data;
2709 MessageParcel reply;
2710 auto res = stub_->RegisterWindowManagerServiceHandlerInner(data, reply);
2711 EXPECT_EQ(res, ERR_NULL_OBJECT);
2712 }
2713
2714 /*
2715 * Feature: AbilityManagerService
2716 * Function: CompleteFirstFrameDrawingInner
2717 * SubFunction: NA
2718 * FunctionPoints: AbilityManagerService CompleteFirstFrameDrawingInner
2719 * EnvConditions: NA
2720 * CaseDescription: Verify the function CompleteFirstFrameDrawingInner is normal flow.
2721 */
2722 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CompleteFirstFrameDrawingInner_001, TestSize.Level1)
2723 {
2724 MessageParcel data;
2725 MessageParcel reply;
2726 auto res = stub_->CompleteFirstFrameDrawingInner(data, reply);
2727 EXPECT_EQ(res, ERR_NULL_OBJECT);
2728 }
2729
2730 /*
2731 * Feature: AbilityManagerService
2732 * Function: CompleteFirstFrameDrawingBySCBInner
2733 * SubFunction: NA
2734 * FunctionPoints: AbilityManagerService CompleteFirstFrameDrawingBySCBInner
2735 * EnvConditions: NA
2736 * CaseDescription: Verify the function CompleteFirstFrameDrawingBySCBInner is normal flow.
2737 */
2738 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CompleteFirstFrameDrawingBySCBInner_001, TestSize.Level1)
2739 {
2740 MessageParcel data;
2741 MessageParcel reply;
2742 auto res = stub_->CompleteFirstFrameDrawingBySCBInner(data, reply);
2743 EXPECT_EQ(res, NO_ERROR);
2744 }
2745
2746 /*
2747 * Feature: AbilityManagerService
2748 * Function: GetDialogSessionInfoInner
2749 * SubFunction: NA
2750 * FunctionPoints: AbilityManagerService GetDialogSessionInfoInner
2751 * EnvConditions: NA
2752 * CaseDescription: Verify the function GetDialogSessionInfoInner is normal flow.
2753 */
2754 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetDialogSessionInfoInner_001, TestSize.Level1)
2755 {
2756 MessageParcel data;
2757 MessageParcel reply;
2758 auto res = stub_->GetDialogSessionInfoInner(data, reply);
2759 EXPECT_EQ(res, ERR_INVALID_VALUE);
2760 }
2761
2762 /*
2763 * Feature: AbilityManagerService
2764 * Function: SendDialogResultInner
2765 * SubFunction: NA
2766 * FunctionPoints: AbilityManagerService SendDialogResultInner
2767 * EnvConditions: NA
2768 * CaseDescription: Verify the function SendDialogResultInner is normal flow.
2769 */
2770 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SendDialogResultInner_001, TestSize.Level1)
2771 {
2772 MessageParcel data;
2773 MessageParcel reply;
2774 auto res = stub_->SendDialogResultInner(data, reply);
2775 EXPECT_EQ(res, ERR_INVALID_VALUE);
2776 }
2777
2778 /*
2779 * Feature: AbilityManagerService
2780 * Function: RegisterAbilityFirstFrameStateObserverInner
2781 * SubFunction: NA
2782 * FunctionPoints: AbilityManagerService RegisterAbilityFirstFrameStateObserverInner
2783 * EnvConditions: NA
2784 * CaseDescription: Verify the function RegisterAbilityFirstFrameStateObserverInner is normal flow.
2785 */
2786 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterAbilityFirstFrameStateObserverInner_001, TestSize.Level1)
2787 {
2788 MessageParcel data;
2789 MessageParcel reply;
2790 auto res = stub_->RegisterAbilityFirstFrameStateObserverInner(data, reply);
2791 EXPECT_EQ(res, ERR_INVALID_VALUE);
2792 }
2793
2794 /*
2795 * Feature: AbilityManagerService
2796 * Function: UnregisterAbilityFirstFrameStateObserverInner
2797 * SubFunction: NA
2798 * FunctionPoints: AbilityManagerService UnregisterAbilityFirstFrameStateObserverInner
2799 * EnvConditions: NA
2800 * CaseDescription: Verify the function UnregisterAbilityFirstFrameStateObserverInner is normal flow.
2801 */
2802 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterAbilityFirstFrameStateObserverInner_001, TestSize.Level1)
2803 {
2804 MessageParcel data;
2805 MessageParcel reply;
2806 auto res = stub_->UnregisterAbilityFirstFrameStateObserverInner(data, reply);
2807 EXPECT_EQ(res, ERR_INVALID_VALUE);
2808 }
2809
2810 /*
2811 * Feature: AbilityManagerService
2812 * Function: CallRequestDone
2813 * SubFunction: NA
2814 * FunctionPoints: AbilityManagerService CallRequestDone
2815 * EnvConditions: NA
2816 * CaseDescription: Verify the function CallRequestDone is normal flow.
2817 */
2818 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CallRequestDone_001, TestSize.Level1)
2819 {
2820 sptr<IRemoteObject> token = nullptr;
2821 sptr<IRemoteObject> callStub = nullptr;
2822 stub_->CallRequestDone(token, callStub);
2823 EXPECT_TRUE(stub_ != nullptr);
2824 }
2825
2826 /*
2827 * Feature: AbilityManagerService
2828 * Function: IsValidMissionIdsInner
2829 * SubFunction: NA
2830 * FunctionPoints: AbilityManagerService IsValidMissionIdsInner
2831 * EnvConditions: NA
2832 * CaseDescription: Verify the function IsValidMissionIdsInner is normal flow.
2833 */
2834 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsValidMissionIdsInner_001, TestSize.Level1)
2835 {
2836 MessageParcel data;
2837 MessageParcel reply;
__anon676eec320202(const std::vector<int32_t>& ids, std::vector<MissionValidResult>& results) 2838 auto isValidMissionIdsTask = [&](const std::vector<int32_t>& ids, std::vector<MissionValidResult>& results) {
2839 MissionValidResult result;
2840 result.missionId = 1;
2841 result.isValid = true;
2842 results.push_back(result);
2843 return ERR_OK;
2844 };
2845 EXPECT_CALL(*stub_, IsValidMissionIds(_, _)).Times(1).WillOnce(testing::Invoke(isValidMissionIdsTask));
2846 EXPECT_EQ(stub_->IsValidMissionIdsInner(data, reply), NO_ERROR);
2847 }
2848
2849 /*
2850 * Feature: AbilityManagerService
2851 * Function: IsValidMissionIdsInner
2852 * SubFunction: NA
2853 * FunctionPoints: AbilityManagerService IsValidMissionIdsInner
2854 * EnvConditions: NA
2855 * CaseDescription: Verify the function IsValidMissionIdsInner is normal flow.
2856 */
2857 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsValidMissionIdsInner_002, TestSize.Level1)
2858 {
2859 MessageParcel data;
2860 MessageParcel reply;
__anon676eec320302(const std::vector<int32_t>& ids, std::vector<MissionValidResult>& results) 2861 auto isValidMissionIdsTask = [&](const std::vector<int32_t>& ids, std::vector<MissionValidResult>& results) {
2862 GTEST_LOG_(INFO) << "AbilityManagerStub_IsValidMissionIdsInner_002 caller";
2863 return ERR_INVALID_VALUE;
2864 };
2865 EXPECT_CALL(*stub_, IsValidMissionIds(_, _)).Times(1).WillOnce(testing::Invoke(isValidMissionIdsTask));
2866 EXPECT_EQ(stub_->IsValidMissionIdsInner(data, reply), NO_ERROR);
2867 }
2868
2869 /*
2870 * Feature: AbilityManagerService
2871 * Function: ForceExitAppInner
2872 * SubFunction: NA
2873 * FunctionPoints: AbilityManagerService ForceExitAppInner
2874 * EnvConditions: NA
2875 * CaseDescription: Verify the function ForceExitAppInner is normal flow.
2876 */
2877 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ForceExitAppInner_001, TestSize.Level1)
2878 {
2879 MessageParcel data;
2880 MessageParcel reply;
2881 auto res = stub_->ForceExitAppInner(data, reply);
2882 EXPECT_EQ(res, ERR_INVALID_VALUE);
2883 }
2884
2885 /*
2886 * Feature: AbilityManagerService
2887 * Function: RecordAppExitReasonInner
2888 * SubFunction: NA
2889 * FunctionPoints: AbilityManagerService RecordAppExitReasonInner
2890 * EnvConditions: NA
2891 * CaseDescription: Verify the function RecordAppExitReasonInner is normal flow.
2892 */
2893 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RecordAppExitReasonInner_001, TestSize.Level1)
2894 {
2895 MessageParcel data;
2896 MessageParcel reply;
2897 auto res = stub_->RecordAppExitReasonInner(data, reply);
2898 EXPECT_EQ(res, ERR_INVALID_VALUE);
2899 }
2900
2901 /*
2902 * Feature: AbilityManagerService
2903 * Function: RecordProcessExitReasonInner
2904 * SubFunction: NA
2905 * FunctionPoints: AbilityManagerService RecordProcessExitReasonInner
2906 * EnvConditions: NA
2907 * CaseDescription: Verify the function RecordProcessExitReasonInner is normal flow.
2908 */
2909 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RecordProcessExitReasonInner_001, TestSize.Level1)
2910 {
2911 MessageParcel data;
2912 MessageParcel reply;
2913 auto res = stub_->RecordProcessExitReasonInner(data, reply);
2914 EXPECT_EQ(res, ERR_INVALID_VALUE);
2915 }
2916
2917 /*
2918 * Feature: AbilityManagerService
2919 * Function: SetRootSceneSessionInner
2920 * SubFunction: NA
2921 * FunctionPoints: AbilityManagerService SetRootSceneSessionInner
2922 * EnvConditions: NA
2923 * CaseDescription: Verify the function SetRootSceneSessionInner is normal flow.
2924 */
2925 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetRootSceneSessionInner_001, TestSize.Level1)
2926 {
2927 MessageParcel data;
2928 MessageParcel reply;
2929 auto res = stub_->SetRootSceneSessionInner(data, reply);
2930 EXPECT_EQ(res, ERR_INVALID_VALUE);
2931 }
2932
2933 /*
2934 * Feature: AbilityManagerService
2935 * Function: CallUIAbilityBySCBInner
2936 * SubFunction: NA
2937 * FunctionPoints: AbilityManagerService CallUIAbilityBySCBInner
2938 * EnvConditions: NA
2939 * CaseDescription: Verify the function CallUIAbilityBySCBInner is normal flow.
2940 */
2941 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CallUIAbilityBySCBInner_001, TestSize.Level1)
2942 {
2943 MessageParcel data;
2944 MessageParcel reply;
2945 auto res = stub_->CallUIAbilityBySCBInner(data, reply);
2946 EXPECT_EQ(res, NO_ERROR);
2947 }
2948
2949 /*
2950 * Feature: AbilityManagerService
2951 * Function: SetSessionManagerServiceInner
2952 * SubFunction: NA
2953 * FunctionPoints: AbilityManagerService SetSessionManagerServiceInner
2954 * EnvConditions: NA
2955 * CaseDescription: Verify the function SetSessionManagerServiceInner is normal flow.
2956 */
2957 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetSessionManagerServiceInner_001, TestSize.Level1)
2958 {
2959 MessageParcel data;
2960 MessageParcel reply;
2961 auto res = stub_->CallUIAbilityBySCBInner(data, reply);
2962 EXPECT_EQ(res, NO_ERROR);
2963 }
2964
2965 /*
2966 * Feature: AbilityManagerService
2967 * Function: RegisterIAbilityManagerCollaboratorInner
2968 * SubFunction: NA
2969 * FunctionPoints: AbilityManagerService RegisterIAbilityManagerCollaboratorInner
2970 * EnvConditions: NA
2971 * CaseDescription: Verify the function RegisterIAbilityManagerCollaboratorInner is normal flow.
2972 */
2973 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterIAbilityManagerCollaboratorInner_001, TestSize.Level1)
2974 {
2975 MessageParcel data;
2976 MessageParcel reply;
2977 auto res = stub_->RegisterIAbilityManagerCollaboratorInner(data, reply);
2978 EXPECT_EQ(res, ERR_NULL_OBJECT);
2979 }
2980
2981 /*
2982 * Feature: AbilityManagerService
2983 * Function: UnregisterIAbilityManagerCollaboratorInner
2984 * SubFunction: NA
2985 * FunctionPoints: AbilityManagerService UnregisterIAbilityManagerCollaboratorInner
2986 * EnvConditions: NA
2987 * CaseDescription: Verify the function UnregisterIAbilityManagerCollaboratorInner is normal flow.
2988 */
2989 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterIAbilityManagerCollaboratorInner_001, TestSize.Level1)
2990 {
2991 MessageParcel data;
2992 MessageParcel reply;
2993 auto res = stub_->UnregisterIAbilityManagerCollaboratorInner(data, reply);
2994 EXPECT_EQ(res, NO_ERROR);
2995 }
2996
2997 /*
2998 * Feature: AbilityManagerService
2999 * Function: PrepareTerminateAbilityBySCBInner
3000 * SubFunction: NA
3001 * FunctionPoints: AbilityManagerService PrepareTerminateAbilityBySCBInner
3002 * EnvConditions: NA
3003 * CaseDescription: Verify the normal process of PrepareTerminateAbilityBySCB.
3004 */
3005 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_PrepareTerminateAbilityBySCBInner_002, TestSize.Level1)
3006 {
3007 MessageParcel data;
3008 MessageParcel reply;
__anon676eec320402(const sptr<SessionInfo> &sessionInfo, bool &isTerminate) 3009 auto prepareTerminateAbilityBySCBTask = [&](const sptr<SessionInfo> &sessionInfo, bool &isTerminate) {
3010 GTEST_LOG_(INFO) << "AbilityManagerStub_IsValidMissionIdsInner_002 caller";
3011 return ERR_INVALID_VALUE;
3012 };
3013 EXPECT_CALL(*stub_, PrepareTerminateAbilityBySCB(_, _)).Times(1).WillOnce(
3014 testing::Invoke(prepareTerminateAbilityBySCBTask));
3015 EXPECT_EQ(stub_->PrepareTerminateAbilityBySCBInner(data, reply), ERR_INVALID_VALUE);
3016 }
3017
3018 /*
3019 * Feature: AbilityManagerService
3020 * Function: RegisterStatusBarDelegateInner
3021 * SubFunction: NA
3022 * FunctionPoints: AbilityManagerService RegisterStatusBarDelegateInner
3023 * EnvConditions: NA
3024 * CaseDescription: Verify the function RegisterStatusBarDelegateInner is normal flow.
3025 */
3026 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterStatusBarDelegateInner_001, TestSize.Level1)
3027 {
3028 MessageParcel data;
3029 MessageParcel reply;
3030 auto res = stub_->RegisterStatusBarDelegateInner(data, reply);
3031 EXPECT_EQ(res, ERR_NULL_OBJECT);
3032 }
3033
3034 /*
3035 * Feature: AbilityManagerService
3036 * Function: KillProcessWithPrepareTerminateInner
3037 * SubFunction: NA
3038 * FunctionPoints: AbilityManagerService KillProcessWithPrepareTerminateInner
3039 * EnvConditions: NA
3040 * CaseDescription: Verify the function KillProcessWithPrepareTerminateInner is normal flow.
3041 */
3042 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_KillProcessWithPrepareTerminateInner_001, TestSize.Level1)
3043 {
3044 MessageParcel data;
3045 MessageParcel reply;
3046 auto res = stub_->KillProcessWithPrepareTerminateInner(data, reply);
3047 EXPECT_EQ(res, ERR_INVALID_VALUE);
3048 }
3049
3050 /*
3051 * Feature: AbilityManagerService
3052 * Function: RegisterSessionHandlerInner
3053 * SubFunction: NA
3054 * FunctionPoints: AbilityManagerService RegisterSessionHandlerInner
3055 * EnvConditions: NA
3056 * CaseDescription: Verify the function RegisterSessionHandlerInner is normal flow.
3057 */
3058 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterSessionHandlerInner_001, TestSize.Level1)
3059 {
3060 MessageParcel data;
3061 MessageParcel reply;
3062 auto res = stub_->RegisterSessionHandlerInner(data, reply);
3063 EXPECT_EQ(res, ERR_INVALID_VALUE);
3064 }
3065
3066 /*
3067 * Feature: AbilityManagerService
3068 * Function: StartSpecifiedAbilityBySCBInner
3069 * SubFunction: NA
3070 * FunctionPoints: AbilityManagerService StartSpecifiedAbilityBySCBInner
3071 * EnvConditions: NA
3072 * CaseDescription: Verify the function StartSpecifiedAbilityBySCBInner is normal flow.
3073 */
3074 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartSpecifiedAbilityBySCBInner_001, TestSize.Level1)
3075 {
3076 MessageParcel data;
3077 MessageParcel reply;
3078 auto res = stub_->StartSpecifiedAbilityBySCBInner(data, reply);
3079 EXPECT_EQ(res, ERR_INVALID_VALUE);
3080 }
3081
3082 /*
3083 * Feature: AbilityManagerService
3084 * Function: StartSpecifiedAbilityBySCBInner
3085 * SubFunction: NA
3086 * FunctionPoints: AbilityManagerService StartSpecifiedAbilityBySCBInner
3087 * EnvConditions: NA
3088 * CaseDescription: Verify the function StartSpecifiedAbilityBySCBInner is normal flow.
3089 */
3090 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartSpecifiedAbilityBySCBInner_002, TestSize.Level1)
3091 {
3092 MessageParcel data;
3093 MessageParcel reply;
3094 Want want;
3095 data.WriteParcelable(&want);
3096 EXPECT_EQ(stub_->StartSpecifiedAbilityBySCBInner(data, reply), NO_ERROR);
3097 }
3098
3099 /*
3100 * Feature: AbilityManagerService
3101 * Function: IsAbilityControllerStartInner
3102 * SubFunction: NA
3103 * FunctionPoints: AbilityManagerService IsAbilityControllerStartInner
3104 * EnvConditions: NA
3105 * CaseDescription: Verify the function IsAbilityControllerStartInner is normal flow.
3106 */
3107 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsAbilityControllerStartInner_001, TestSize.Level1)
3108 {
3109 MessageParcel data;
3110 MessageParcel reply;
3111 Want want;
3112 data.WriteParcelable(&want);
3113 EXPECT_EQ(stub_->IsAbilityControllerStartInner(data, reply), NO_ERROR);
3114 }
3115
3116 /*
3117 * Feature: AbilityManagerService
3118 * Function: ExecuteIntentInner
3119 * SubFunction: NA
3120 * FunctionPoints: AbilityManagerService ExecuteIntentInner
3121 * EnvConditions: NA
3122 * CaseDescription: Verify the function ExecuteIntentInner is normal flow.
3123 */
3124 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ExecuteIntentInner_001, TestSize.Level1)
3125 {
3126 MessageParcel data;
3127 MessageParcel reply;
3128 auto res = stub_->ExecuteIntentInner(data, reply);
3129 EXPECT_EQ(res, ERR_INVALID_VALUE);
3130 }
3131
3132 /*
3133 * Feature: AbilityManagerService
3134 * Function: StartAbilityByInsightIntentInner
3135 * SubFunction: NA
3136 * FunctionPoints: AbilityManagerService StartAbilityByInsightIntentInner
3137 * EnvConditions: NA
3138 * CaseDescription: Verify the function StartAbilityByInsightIntentInner is normal flow.
3139 */
3140 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartAbilityByInsightIntentInner_001, TestSize.Level1)
3141 {
3142 MessageParcel data;
3143 MessageParcel reply;
3144 auto res = stub_->StartAbilityByInsightIntentInner(data, reply);
3145 EXPECT_EQ(res, ERR_INVALID_VALUE);
3146 }
3147
3148 /*
3149 * Feature: AbilityManagerService
3150 * Function: ExecuteInsightIntentDoneInner
3151 * SubFunction: NA
3152 * FunctionPoints: AbilityManagerService ExecuteInsightIntentDoneInner
3153 * EnvConditions: NA
3154 * CaseDescription: Verify the function ExecuteInsightIntentDoneInner is normal flow.
3155 */
3156 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_ExecuteInsightIntentDoneInner_001, TestSize.Level1)
3157 {
3158 MessageParcel data;
3159 MessageParcel reply;
3160 auto res = stub_->ExecuteInsightIntentDoneInner(data, reply);
3161 EXPECT_EQ(res, ERR_INVALID_VALUE);
3162 }
3163
3164 /*
3165 * Feature: AbilityManagerService
3166 * Function: SetApplicationAutoStartupByEDMInner
3167 * SubFunction: NA
3168 * FunctionPoints: AbilityManagerService SetApplicationAutoStartupByEDMInner
3169 * EnvConditions: NA
3170 * CaseDescription: Verify the function SetApplicationAutoStartupByEDMInner is normal flow.
3171 */
3172 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_SetApplicationAutoStartupByEDMInner_001, TestSize.Level1)
3173 {
3174 MessageParcel data;
3175 MessageParcel reply;
3176 auto res = stub_->SetApplicationAutoStartupByEDMInner(data, reply);
3177 EXPECT_EQ(res, ERR_INVALID_VALUE);
3178 }
3179
3180 /*
3181 * Feature: AbilityManagerService
3182 * Function: CancelApplicationAutoStartupByEDMInner
3183 * SubFunction: NA
3184 * FunctionPoints: AbilityManagerService CancelApplicationAutoStartupByEDMInner
3185 * EnvConditions: NA
3186 * CaseDescription: Verify the function CancelApplicationAutoStartupByEDMInner is normal flow.
3187 */
3188 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_CancelApplicationAutoStartupByEDMInner_001, TestSize.Level1)
3189 {
3190 MessageParcel data;
3191 MessageParcel reply;
3192 auto res = stub_->CancelApplicationAutoStartupByEDMInner(data, reply);
3193 EXPECT_EQ(res, ERR_INVALID_VALUE);
3194 }
3195
3196 /*
3197 * Feature: AbilityManagerService
3198 * Function: OpenFileInner
3199 * SubFunction: NA
3200 * FunctionPoints: AbilityManagerService OpenFileInner
3201 * EnvConditions: NA
3202 * CaseDescription: Verify the function OpenFileInner is normal flow.
3203 */
3204 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_OpenFileInner_001, TestSize.Level1)
3205 {
3206 MessageParcel data;
3207 MessageParcel reply;
3208 auto res = stub_->OpenFileInner(data, reply);
3209 EXPECT_EQ(res, ERR_DEAD_OBJECT);
3210 }
3211
3212 /*
3213 * Feature: AbilityManagerService
3214 * Function: RequestAssertFaultDialogInner
3215 * SubFunction: NA
3216 * FunctionPoints: AbilityManagerService RequestAssertFaultDialogInner
3217 * EnvConditions: NA
3218 * CaseDescription: Verify the function RequestAssertFaultDialogInner is normal flow.
3219 */
3220 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RequestAssertFaultDialogInner_001, TestSize.Level1)
3221 {
3222 MessageParcel data;
3223 MessageParcel reply;
3224 auto res = stub_->RequestAssertFaultDialogInner(data, reply);
3225 EXPECT_EQ(res, ERR_NULL_OBJECT);
3226 }
3227
3228 /*
3229 * Feature: AbilityManagerService
3230 * Function: NotifyDebugAssertResultInner
3231 * SubFunction: NA
3232 * FunctionPoints: AbilityManagerService NotifyDebugAssertResultInner
3233 * EnvConditions: NA
3234 * CaseDescription: Verify the function NotifyDebugAssertResultInner is normal flow.
3235 */
3236 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_NotifyDebugAssertResultInner_001, TestSize.Level1)
3237 {
3238 MessageParcel data;
3239 MessageParcel reply;
3240 auto res = stub_->NotifyDebugAssertResultInner(data, reply);
3241 EXPECT_EQ(res, NO_ERROR);
3242 }
3243
3244 /*
3245 * Feature: AbilityManagerService
3246 * Function: UpdateSessionInfoBySCBInner
3247 * SubFunction: NA
3248 * FunctionPoints: AbilityManagerService UpdateSessionInfoBySCBInner
3249 * EnvConditions: NA
3250 * CaseDescription: Verify the function UpdateSessionInfoBySCBInner is normal flow.
3251 */
3252 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UpdateSessionInfoBySCBInner_001, TestSize.Level1)
3253 {
3254 MessageParcel data;
3255 MessageParcel reply;
3256 auto res = stub_->UpdateSessionInfoBySCBInner(data, reply);
3257 EXPECT_EQ(res, NO_ERROR);
3258 }
3259
3260 /*
3261 * Feature: AbilityManagerService
3262 * Function: OpenAtomicServiceInner
3263 * SubFunction: NA
3264 * FunctionPoints: AbilityManagerService OpenAtomicServiceInner
3265 * EnvConditions: NA
3266 * CaseDescription: Verify the function OpenAtomicServiceInner is normal flow.
3267 */
3268 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_OpenAtomicServiceInner_001, TestSize.Level1)
3269 {
3270 MessageParcel data;
3271 MessageParcel reply;
3272 auto res = stub_->OpenAtomicServiceInner(data, reply);
3273 EXPECT_EQ(res, ERR_INVALID_VALUE);
3274 }
3275
3276 /*
3277 * Feature: AbilityManagerService
3278 * Function: IsEmbeddedOpenAllowedInner
3279 * SubFunction: NA
3280 * FunctionPoints: AbilityManagerService IsEmbeddedOpenAllowedInner
3281 * EnvConditions: NA
3282 * CaseDescription: Verify the function IsEmbeddedOpenAllowedInner is normal flow.
3283 */
3284 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_IsEmbeddedOpenAllowedInner_001, TestSize.Level1)
3285 {
3286 MessageParcel data;
3287 MessageParcel reply;
3288 auto res = stub_->IsEmbeddedOpenAllowedInner(data, reply);
3289 EXPECT_EQ(res, NO_ERROR);
3290 }
3291
3292 /*
3293 * Feature: AbilityManagerService
3294 * Function: StartShortcutInner
3295 * SubFunction: NA
3296 * FunctionPoints: AbilityManagerService StartShortcutInner
3297 * EnvConditions: NA
3298 * CaseDescription: Verify the function StartShortcutInner is normal flow.
3299 */
3300 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_StartShortcutInner_001, TestSize.Level1)
3301 {
3302 MessageParcel data;
3303 MessageParcel reply;
3304 auto res = stub_->StartShortcutInner(data, reply);
3305 EXPECT_EQ(res, ERR_INVALID_VALUE);
3306 }
3307
3308 /*
3309 * Feature: AbilityManagerService
3310 * Function: GetAbilityStateByPersistentIdInner
3311 * SubFunction: NA
3312 * FunctionPoints: AbilityManagerService GetAbilityStateByPersistentIdInner
3313 * EnvConditions: NA
3314 * CaseDescription: Verify the function GetAbilityStateByPersistentIdInner is normal flow.
3315 */
3316 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetAbilityStateByPersistentIdInner_001, TestSize.Level1)
3317 {
3318 MessageParcel data;
3319 MessageParcel reply;
3320 auto res = stub_->GetAbilityStateByPersistentIdInner(data, reply);
3321 EXPECT_EQ(res, NO_ERROR);
3322 }
3323
3324 /*
3325 * Feature: AbilityManagerService
3326 * Function: TransferAbilityResultForExtensionInner
3327 * SubFunction: NA
3328 * FunctionPoints: AbilityManagerService TransferAbilityResultForExtensionInner
3329 * EnvConditions: NA
3330 * CaseDescription: Verify the function TransferAbilityResultForExtensionInner is normal flow.
3331 */
3332 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_TransferAbilityResultForExtensionInner_001, TestSize.Level1)
3333 {
3334 MessageParcel data;
3335 MessageParcel reply;
3336 auto res = stub_->TransferAbilityResultForExtensionInner(data, reply);
3337 EXPECT_EQ(res, ERR_INVALID_VALUE);
3338 }
3339
3340 /**
3341 * @tc.name: AbilityManagerStub_RegisterAppDebugListenerInner_001
3342 * @tc.desc: Test the status of RegisterAppDebugListenerInner, check empty AppDebugListener.
3343 * @tc.type: FUNC
3344 */
3345 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterAppDebugListenerInner_001, TestSize.Level1)
3346 {
3347 EXPECT_NE(stub_, nullptr);
3348 MessageParcel data;
3349 MessageParcel reply;
3350 auto res = stub_->RegisterAppDebugListenerInner(data, reply);
3351 EXPECT_EQ(res, ERR_INVALID_VALUE);
3352 }
3353
3354 /**
3355 * @tc.name: AbilityManagerStub_RegisterAppDebugListenerInner_002
3356 * @tc.desc: Test the status of RegisterAppDebugListenerInner.
3357 * @tc.type: FUNC
3358 */
3359 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_RegisterAppDebugListenerInner_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 auto ret = data.WriteRemoteObject(token);
3367 EXPECT_EQ(ret, true);
3368 int res = stub_->RegisterAppDebugListenerInner(data, reply);
3369 EXPECT_EQ(res, NO_ERROR);
3370 }
3371
3372 /**
3373 * @tc.name: AbilityManagerStub_UnregisterAppDebugListenerInner_001
3374 * @tc.desc: Test the status of UnregisterAppDebugListenerInner, check empty appDebugListener.
3375 * @tc.type: FUNC
3376 */
3377 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterAppDebugListenerInner_001, TestSize.Level1)
3378 {
3379 EXPECT_NE(stub_, nullptr);
3380 MessageParcel data;
3381 MessageParcel reply;
3382 auto res = stub_->UnregisterAppDebugListenerInner(data, reply);
3383 EXPECT_EQ(res, ERR_INVALID_VALUE);
3384 }
3385
3386 /**
3387 * @tc.name: AbilityManagerStub_UnregisterAppDebugListenerInner_002
3388 * @tc.desc: Test the status of UnregisterAppDebugListenerInner.
3389 * @tc.type: FUNC
3390 */
3391 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_UnregisterAppDebugListenerInner_002, TestSize.Level1)
3392 {
3393 EXPECT_NE(stub_, nullptr);
3394 MessageParcel data;
3395 MessageParcel reply;
3396 auto token = new AppExecFwk::AppDebugListenerStubMock();
3397 EXPECT_NE(token, nullptr);
3398 bool ret = data.WriteRemoteObject(token);
3399 EXPECT_EQ(ret, true);
3400 auto res = stub_->UnregisterAppDebugListenerInner(data, reply);
3401 EXPECT_EQ(res, NO_ERROR);
3402 }
3403
3404 /**
3405 * @tc.name: AbilityManagerStub_AttachAppDebugInner_001
3406 * @tc.desc: Test the state of AttachAppDebugInner.
3407 * @tc.type: FUNC
3408 */
3409 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AttachAppDebugInner_001, TestSize.Level1)
3410 {
3411 EXPECT_NE(stub_, nullptr);
3412 MessageParcel data;
3413 MessageParcel reply;
3414 std::string bundleName = "bundleName";
3415 data.WriteString(bundleName);
3416 auto res = stub_->AttachAppDebugInner(data, reply);
3417 EXPECT_EQ(res, NO_ERROR);
3418 }
3419
3420 /**
3421 * @tc.name: AbilityManagerStub_AttachAppDebugInner_002
3422 * @tc.desc: Test the state of AttachAppDebugInner, check empty bundleName;
3423 * @tc.type: FUNC
3424 */
3425 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_AttachAppDebugInner_002, TestSize.Level1)
3426 {
3427 EXPECT_NE(stub_, nullptr);
3428 MessageParcel data;
3429 MessageParcel reply;
3430 auto res = stub_->AttachAppDebugInner(data, reply);
3431 EXPECT_EQ(res, ERR_INVALID_VALUE);
3432 }
3433
3434 /**
3435 * @tc.name: AbilityManagerStub_DetachAppDebugInner_001
3436 * @tc.desc: Test the state of DetachAppDebugInner.
3437 * @tc.type: FUNC
3438 */
3439 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DetachAppDebugInner_001, TestSize.Level1)
3440 {
3441 EXPECT_NE(stub_, nullptr);
3442 MessageParcel data;
3443 MessageParcel reply;
3444 std::string bundleName = "bundleName";
3445 data.WriteString(bundleName);
3446 auto res = stub_->DetachAppDebugInner(data, reply);
3447 EXPECT_EQ(res, NO_ERROR);
3448 }
3449
3450 /**
3451 * @tc.name: AbilityManagerStub_DetachAppDebugInner_002
3452 * @tc.desc: Test the state of DetachAppDebugInner, check empty bundleName.
3453 * @tc.type: FUNC
3454 */
3455 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_DetachAppDebugInner_002, TestSize.Level1)
3456 {
3457 EXPECT_NE(stub_, nullptr);
3458 MessageParcel data;
3459 MessageParcel reply;
3460 auto res = stub_->DetachAppDebugInner(data, reply);
3461 EXPECT_EQ(res, ERR_INVALID_VALUE);
3462 }
3463
3464 /**
3465 * @tc.name: AbilityManagerStub_GetForegroundUIAbilitiesInner_001
3466 * @tc.desc: Test function GetForegroundUIAbilitiesInner when normally.
3467 * @tc.type: FUNC
3468 */
3469 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_GetForegroundUIAbilitiesInner_001, TestSize.Level1)
3470 {
3471 MessageParcel data;
3472 MessageParcel reply;
3473 auto res = stub_->GetForegroundUIAbilitiesInner(data, reply);
3474 EXPECT_EQ(res, ERR_OK);
3475 }
3476
3477 /**
3478 * @tc.name: AbilityManagerStubTest_RegisterAutoStartupSystemCallbackInner_0100
3479 * @tc.desc: Test the state of RegisterAutoStartupSystemCallbackInner
3480 * @tc.type: FUNC
3481 */
3482 HWTEST_F(AbilityManagerStubTest, RegisterAutoStartupSystemCallbackInner_0100, TestSize.Level1)
3483 {
3484 MessageParcel data;
3485 MessageParcel reply;
3486 sptr<AppExecFwk::MockAbilityToken> token = new (std::nothrow) AppExecFwk::MockAbilityToken();
3487 EXPECT_NE(token, nullptr);
3488 data.WriteRemoteObject(token);
3489 auto result = stub_->RegisterAutoStartupSystemCallbackInner(data, reply);
3490 EXPECT_EQ(result, NO_ERROR);
3491 }
3492
3493 /**
3494 * @tc.name: AbilityManagerStubTest_RegisterAutoStartupSystemCallbackInner_0200
3495 * @tc.desc: Test the state of RegisterAutoStartupSystemCallbackInner
3496 * @tc.type: FUNC
3497 */
3498 HWTEST_F(AbilityManagerStubTest, RegisterAutoStartupSystemCallbackInner_0200, TestSize.Level1)
3499 {
3500 MessageParcel data;
3501 MessageParcel reply;
3502 auto result = stub_->RegisterAutoStartupSystemCallbackInner(data, reply);
3503 EXPECT_EQ(result, ERR_INVALID_VALUE);
3504 }
3505
3506 /**
3507 * @tc.name: AbilityManagerStubTest_UnregisterAutoStartupSystemCallbackInner_0100
3508 * @tc.desc: Test the state of UnregisterAutoStartupSystemCallbackInner
3509 * @tc.type: FUNC
3510 */
3511 HWTEST_F(AbilityManagerStubTest, UnregisterAutoStartupSystemCallbackInner_0100, TestSize.Level1)
3512 {
3513 MessageParcel data;
3514 MessageParcel reply;
3515 sptr<AppExecFwk::MockAbilityToken> token = new (std::nothrow) AppExecFwk::MockAbilityToken();
3516 EXPECT_NE(token, nullptr);
3517 data.WriteRemoteObject(token);
3518 auto result = stub_->UnregisterAutoStartupSystemCallbackInner(data, reply);
3519 EXPECT_EQ(result, NO_ERROR);
3520 }
3521
3522 /**
3523 * @tc.name: AbilityManagerStubTest_UnregisterAutoStartupSystemCallbackInner_0200
3524 * @tc.desc: Test the state of UnregisterAutoStartupSystemCallbackInner
3525 * @tc.type: FUNC
3526 */
3527 HWTEST_F(AbilityManagerStubTest, UnregisterAutoStartupSystemCallbackInner_0200, TestSize.Level1)
3528 {
3529 MessageParcel data;
3530 MessageParcel reply;
3531 auto result = stub_->UnregisterAutoStartupSystemCallbackInner(data, reply);
3532 EXPECT_EQ(result, ERR_INVALID_VALUE);
3533 }
3534 /**
3535 * @tc.name: AbilityManagerStubTest_SetApplicationAutoStartupInner_0100
3536 * @tc.desc: Test the state of SetApplicationAutoStartupInner
3537 * @tc.type: FUNC
3538 */
3539 HWTEST_F(AbilityManagerStubTest, SetApplicationAutoStartupInner_0100, TestSize.Level1)
3540 {
3541 MessageParcel data;
3542 MessageParcel reply;
3543 Want want;
3544 data.WriteParcelable(&want);
3545 auto result = stub_->SetApplicationAutoStartupInner(data, reply);
3546 EXPECT_EQ(result, NO_ERROR);
3547 }
3548
3549 /**
3550 * @tc.name: AbilityManagerStubTest_SetApplicationAutoStartupInner_0200
3551 * @tc.desc: Test the state of SetApplicationAutoStartupInner
3552 * @tc.type: FUNC
3553 */
3554 HWTEST_F(AbilityManagerStubTest, SetApplicationAutoStartupInner_0200, TestSize.Level1)
3555 {
3556 MessageParcel data;
3557 MessageParcel reply;
3558 auto result = stub_->SetApplicationAutoStartupInner(data, reply);
3559 EXPECT_EQ(result, ERR_INVALID_VALUE);
3560 }
3561
3562 /**
3563 * @tc.name: AbilityManagerStubTest_CancelApplicationAutoStartupInner_0100
3564 * @tc.desc: Test the state of CancelApplicationAutoStartupInner
3565 * @tc.type: FUNC
3566 */
3567 HWTEST_F(AbilityManagerStubTest, CancelApplicationAutoStartupInner_0100, TestSize.Level1)
3568 {
3569 MessageParcel data;
3570 MessageParcel reply;
3571 Want want;
3572 data.WriteParcelable(&want);
3573 auto result = stub_->CancelApplicationAutoStartupInner(data, reply);
3574 EXPECT_EQ(result, NO_ERROR);
3575 }
3576
3577 /**
3578 * @tc.name: AbilityManagerStubTest_CancelApplicationAutoStartupInner_0200
3579 * @tc.desc: Test the state of CancelApplicationAutoStartupInner
3580 * @tc.type: FUNC
3581 */
3582 HWTEST_F(AbilityManagerStubTest, CancelApplicationAutoStartupInner_0200, TestSize.Level1)
3583 {
3584 MessageParcel data;
3585 MessageParcel reply;
3586 auto result = stub_->CancelApplicationAutoStartupInner(data, reply);
3587 EXPECT_EQ(result, ERR_INVALID_VALUE);
3588 }
3589
3590 /**
3591 * @tc.name: AbilityManagerStubTest_QueryAllAutoStartupApplicationsInner_0100
3592 * @tc.desc: Test the state of QueryAllAutoStartupApplicationsInner
3593 * @tc.type: FUNC
3594 */
3595 HWTEST_F(AbilityManagerStubTest, QueryAllAutoStartupApplicationsInner_0100, TestSize.Level1)
3596 {
3597 MessageParcel data;
3598 MessageParcel reply;
3599 Want want;
3600 data.WriteParcelable(&want);
3601 auto result = stub_->QueryAllAutoStartupApplicationsInner(data, reply);
3602 EXPECT_EQ(result, NO_ERROR);
3603 }
3604
3605 /**
3606 * @tc.name: GetUIExtensionRootHostInfo_0100
3607 * @tc.desc: GetUIExtensionRootHostInfo
3608 * @tc.type: FUNC
3609 * @tc.require: issueI92G6Z
3610 */
3611 HWTEST_F(AbilityManagerStubTest, GetUIExtensionRootHostInfo_0100, TestSize.Level1)
3612 {
3613 TAG_LOGI(AAFwkTag::TEST, "begin");
3614
3615 MessageParcel data;
3616 bool writeRet = data.WriteInterfaceToken(AbilityManagerStubImplMock::GetDescriptor());
3617 auto token = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
3618 auto userId = USER_ID;
3619 writeRet &= data.WriteBool(true);
3620 writeRet &= data.WriteRemoteObject(token);
3621 writeRet &= data.WriteInt32(userId);
3622 EXPECT_EQ(writeRet, true);
3623
3624 EXPECT_CALL(*stub_, GetUIExtensionRootHostInfo(_, _, _)).Times(1);
3625
3626 MessageParcel reply;
3627 MessageOption option;
3628 auto ret = stub_->OnRemoteRequest(
3629 static_cast<uint32_t>(AbilityManagerInterfaceCode::GET_UI_EXTENSION_ROOT_HOST_INFO), data, reply, option);
3630 EXPECT_EQ(ret, NO_ERROR);
3631
3632 TAG_LOGI(AAFwkTag::TEST, "end");
3633 }
3634
3635 /**
3636 * @tc.name: RestartAppInner_0100
3637 * @tc.desc: RestartAppInner
3638 * @tc.type: FUNC
3639 */
3640 HWTEST_F(AbilityManagerStubTest, RestartAppInner_0100, TestSize.Level1)
3641 {
3642 MessageParcel data;
3643 MessageParcel reply;
3644 Want want;
3645 data.WriteParcelable(&want);
3646 auto result = stub_->RestartAppInner(data, reply);
3647 EXPECT_EQ(result, NO_ERROR);
3648 }
3649
3650 /**
3651 * @tc.name: ChangeAbilityVisibility_0100
3652 * @tc.desc: ChangeAbilityVisibility
3653 * @tc.type: FUNC
3654 */
3655 HWTEST_F(AbilityManagerStubTest, ChangeAbilityVisibility_0100, TestSize.Level1)
3656 {
3657 TAG_LOGI(AAFwkTag::TEST, "begin");
3658
3659 MessageParcel data;
3660 MessageParcel reply;
3661 auto token = sptr<AppExecFwk::MockAbilityToken>::MakeSptr();
3662 data.WriteRemoteObject(token);
3663 data.WriteBool(true);
3664
3665 auto ret = stub_->ChangeAbilityVisibilityInner(data, reply);
3666 EXPECT_EQ(ret, NO_ERROR);
3667
3668 TAG_LOGI(AAFwkTag::TEST, "end");
3669 }
3670
3671 /**
3672 * @tc.name: ChangeUIAbilityVisibilityBySCB_0100
3673 * @tc.desc: ChangeUIAbilityVisibilityBySCB
3674 * @tc.type: FUNC
3675 */
3676 HWTEST_F(AbilityManagerStubTest, ChangeUIAbilityVisibilityBySCB_0100, TestSize.Level1)
3677 {
3678 TAG_LOGI(AAFwkTag::TEST, "begin");
3679
3680 MessageParcel data;
3681 MessageParcel reply;
3682 sptr<SessionInfo> session = new (std::nothrow) SessionInfo();
3683 data.WriteParcelable(session);
3684 data.WriteBool(true);
3685
3686 auto ret = stub_->ChangeUIAbilityVisibilityBySCBInner(data, reply);
3687 EXPECT_EQ(ret, NO_ERROR);
3688
3689 TAG_LOGI(AAFwkTag::TEST, "end");
3690 }
3691
3692 /*
3693 * Feature: AbilityManagerService
3694 * Function: TerminateMissionInner
3695 * SubFunction: NA
3696 * FunctionPoints: AbilityManagerService TerminateMissionInner
3697 * EnvConditions: NA
3698 * CaseDescription: Verify the function TerminateMissionInner is normal flow.
3699 */
3700 HWTEST_F(AbilityManagerStubTest, AbilityManagerStub_TerminateMissionInner_001, TestSize.Level1)
3701 {
3702 MessageParcel data;
3703 MessageParcel reply;
3704 auto res = stub_->TerminateMissionInner(data, reply);
3705 EXPECT_EQ(res, NO_ERROR);
3706 }
3707 } // namespace AAFwk
3708 } // namespace OHOS
3709