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