1 /*
2 * Copyright (c) 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_schedule_stub_second_mock.h"
18 #include "data_ability_predicates.h"
19
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace AAFwk {
24 constexpr int CYCLE_LIMIT = 2000;
25 class AbilitySchedulerStubSecondTest : public testing::Test {
26 public:
27 static void SetUpTestCase(void);
28 static void TearDownTestCase(void);
29 void SetUp();
30 void TearDown();
31 void WriteInterfaceToken(MessageParcel& data);
32 sptr<AbilitySchedulerStubMock> stub_{ nullptr };
33 };
34
SetUpTestCase(void)35 void AbilitySchedulerStubSecondTest::SetUpTestCase(void)
36 {}
TearDownTestCase(void)37 void AbilitySchedulerStubSecondTest::TearDownTestCase(void)
38 {}
TearDown(void)39 void AbilitySchedulerStubSecondTest::TearDown(void)
40 {}
41
SetUp(void)42 void AbilitySchedulerStubSecondTest::SetUp(void)
43 {
44 stub_ = new AbilitySchedulerStubMock();
45 }
WriteInterfaceToken(MessageParcel & data)46 void AbilitySchedulerStubSecondTest::WriteInterfaceToken(MessageParcel& data)
47 {
48 data.WriteInterfaceToken(AbilitySchedulerStub::GetDescriptor());
49 }
50
51 /**
52 * @tc.name: AbilitySchedulerStubSecond_001
53 * @tc.desc: test BatchInsertInner
54 * @tc.type: FUNC
55 */
56 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_001, TestSize.Level1)
57 {
58 MessageParcel data;
59 MessageParcel reply;
60
61 auto res = stub_->BatchInsertInner(data, reply);
62 EXPECT_EQ(res, ERR_INVALID_VALUE);
63
64 auto uri = std::make_shared<Uri>("test_uri");
65 data.WriteParcelable(uri.get());
66 res = stub_->BatchInsertInner(data, reply);
67 EXPECT_EQ(res, ERR_INVALID_VALUE);
68
69 MessageParcel data2;
70 data2.WriteParcelable(uri.get());
71 int largeCount = CYCLE_LIMIT + 1;
72 data2.WriteInt32(largeCount);
73 res = stub_->BatchInsertInner(data2, reply);
74 EXPECT_EQ(res, ERR_INVALID_VALUE);
75
76 MessageParcel data3;
77 Want want;
78 LifeCycleStateInfo stateInfo;
79 data3.WriteParcelable(&want);
80 data3.WriteParcelable(&stateInfo);
81 res = stub_->BatchInsertInner(data3, reply);
82 EXPECT_EQ(res, NO_ERROR);
83 }
84
85 /**
86 * @tc.name: AbilitySchedulerStubSecond_002
87 * @tc.desc: test RegisterObserverInner
88 * @tc.type: FUNC
89 */
90 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_002, TestSize.Level1)
91 {
92 MessageParcel data;
93 MessageParcel reply;
94
95 auto res = stub_->RegisterObserverInner(data, reply);
96 EXPECT_EQ(res, ERR_INVALID_VALUE);
97
98 auto uri = std::make_shared<Uri>("test_uri");
99 data.WriteParcelable(uri.get());
100 res = stub_->RegisterObserverInner(data, reply);
101 EXPECT_EQ(res, ERR_INVALID_VALUE);
102
103 MessageParcel data2;
104 data2.WriteParcelable(uri.get());
105 sptr<IDataAbilityObserver> dataObserver(new (std::nothrow) MockDataAbilityObserverStub());
106 data2.WriteRemoteObject(dataObserver->AsObject());
107 res = stub_->RegisterObserverInner(data2, reply);
108 EXPECT_EQ(res, NO_ERROR);
109 }
110
111 /**
112 * @tc.name: AbilitySchedulerStubSecond_003
113 * @tc.desc: test UnregisterObserverInner
114 * @tc.type: FUNC
115 */
116 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_003, TestSize.Level1)
117 {
118 MessageParcel data;
119 MessageParcel reply;
120
121 auto res = stub_->UnregisterObserverInner(data, reply);
122 EXPECT_EQ(res, ERR_INVALID_VALUE);
123
124 auto uri = std::make_shared<Uri>("test_uri");
125 data.WriteParcelable(uri.get());
126 res = stub_->UnregisterObserverInner(data, reply);
127 EXPECT_EQ(res, ERR_INVALID_VALUE);
128
129 MessageParcel data2;
130 data2.WriteParcelable(uri.get());
131 sptr<IDataAbilityObserver> dataObserver(new (std::nothrow) MockDataAbilityObserverStub());
132 data2.WriteRemoteObject(dataObserver->AsObject());
133 res = stub_->UnregisterObserverInner(data2, reply);
134 EXPECT_EQ(res, NO_ERROR);
135 }
136
137 /**
138 * @tc.name: AbilitySchedulerStubSecond_004
139 * @tc.desc: test NotifyChangeInner
140 * @tc.type: FUNC
141 */
142 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_004, TestSize.Level1)
143 {
144 MessageParcel data;
145 MessageParcel reply;
146
147 auto res = stub_->NotifyChangeInner(data, reply);
148 EXPECT_EQ(res, ERR_INVALID_VALUE);
149
150 auto uri = std::make_shared<Uri>("test_uri");
151 data.WriteParcelable(uri.get());
152 res = stub_->NotifyChangeInner(data, reply);
153 EXPECT_EQ(res, NO_ERROR);
154 }
155
156 /**
157 * @tc.name: AbilitySchedulerStubSecond_005
158 * @tc.desc: test NormalizeUriInner
159 * @tc.type: FUNC
160 */
161 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_005, TestSize.Level1)
162 {
163 MessageParcel data;
164 MessageParcel reply;
165
166 auto res = stub_->NormalizeUriInner(data, reply);
167 EXPECT_EQ(res, ERR_INVALID_VALUE);
168
169 auto uri = std::make_shared<Uri>("test_uri");
170 data.WriteParcelable(uri.get());
171 res = stub_->NormalizeUriInner(data, reply);
172 EXPECT_EQ(res, NO_ERROR);
173 }
174
175 /**
176 * @tc.name: AbilitySchedulerStubSecond_006
177 * @tc.desc: test DenormalizeUriInner
178 * @tc.type: FUNC
179 */
180 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_006, TestSize.Level1)
181 {
182 MessageParcel data;
183 MessageParcel reply;
184
185 auto res = stub_->DenormalizeUriInner(data, reply);
186 EXPECT_EQ(res, ERR_INVALID_VALUE);
187
188 auto uri = std::make_shared<Uri>("test_uri");
189 data.WriteParcelable(uri.get());
190 res = stub_->DenormalizeUriInner(data, reply);
191 EXPECT_EQ(res, NO_ERROR);
192 }
193
194 /**
195 * @tc.name: AbilitySchedulerStubSecond_007
196 * @tc.desc: test ExecuteBatchInner
197 * @tc.type: FUNC
198 */
199 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_007, TestSize.Level1)
200 {
201 MessageParcel data;
202 MessageParcel reply;
203
204 auto res = stub_->ExecuteBatchInner(data, reply);
205 EXPECT_EQ(res, ERR_INVALID_VALUE);
206
207 int largeCount = CYCLE_LIMIT + 1;
208 data.WriteInt32(largeCount);
209 res = stub_->ExecuteBatchInner(data, reply);
210
211 MessageParcel data2;
212 int count = 10;
213 data2.WriteInt32(count);
214 res = stub_->ExecuteBatchInner(data2, reply);
215 EXPECT_EQ(res, ERR_INVALID_VALUE);
216 }
217
218 /**
219 * @tc.name: AbilitySchedulerStubSecond_008
220 * @tc.desc: test DumpAbilityInfoInner
221 * @tc.type: FUNC
222 */
223 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_008, TestSize.Level1)
224 {
225 MessageParcel data;
226 MessageParcel reply;
227
228 data.WriteInt32(200);
229 auto res = stub_->DumpAbilityInfoInner(data, reply);
230 EXPECT_EQ(res, ERR_INVALID_VALUE);
231 }
232
233 /**
234 * @tc.name: AbilitySchedulerStubSecond_009
235 * @tc.desc: test NotifyContinuationResultInner
236 * @tc.type: FUNC
237 */
238 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_009, TestSize.Level1)
239 {
240 MessageParcel data;
241 MessageParcel reply;
242
243 data.WriteInt32(200);
244 auto res = stub_->NotifyContinuationResultInner(data, reply);
245 EXPECT_EQ(res, NO_ERROR);
246 }
247
248 /**
249 * @tc.name: AbilitySchedulerStubSecond_010
250 * @tc.desc: test OnExecuteIntentInner
251 * @tc.type: FUNC
252 */
253 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_010, TestSize.Level1)
254 {
255 MessageParcel data;
256 MessageParcel reply;
257
258 auto res = stub_->OnExecuteIntentInner(data, reply);
259 EXPECT_EQ(res, ERR_INVALID_VALUE);
260
261 Want want;
262 data.WriteParcelable(&want);
263 res = stub_->OnExecuteIntentInner(data, reply);
264 EXPECT_EQ(res, NO_ERROR);
265 }
266
267 /**
268 * @tc.name: AbilitySchedulerStubSecond_011
269 * @tc.desc: test ContinueAbilityInner
270 * @tc.type: FUNC
271 */
272 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_011, TestSize.Level1)
273 {
274 MessageParcel data;
275 MessageParcel reply;
276 std::string expectedDeviceId = "test_device_id";
277 uint32_t expectedVersionCode = 12345;
278 data.WriteString(expectedDeviceId);
279 data.WriteUint32(expectedVersionCode);
280 auto res = stub_->ContinueAbilityInner(data, reply);
281 EXPECT_EQ(res, NO_ERROR);
282 }
283
284 /**
285 * @tc.name: AbilitySchedulerStubSecond_012
286 * @tc.desc: test ShareDataInner
287 * @tc.type: FUNC
288 */
289 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_012, TestSize.Level1)
290 {
291 MessageParcel data;
292 MessageParcel reply;
293 int32_t requestCode = 200;
294 data.WriteInt32(requestCode);
295 auto res = stub_->ShareDataInner(data, reply);
296 EXPECT_EQ(res, NO_ERROR);
297 }
298
299 /**
300 * @tc.name: AbilitySchedulerStubSecond_013
301 * @tc.desc: test CreateModalUIExtensionInner
302 * @tc.type: FUNC
303 */
304 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_013, TestSize.Level1)
305 {
306 MessageParcel data;
307 MessageParcel reply;
308
309 auto res = stub_->CreateModalUIExtensionInner(data, reply);
310 EXPECT_EQ(res, ERR_INVALID_VALUE);
311
312 Want want;
313 data.WriteParcelable(&want);
314 res = stub_->CreateModalUIExtensionInner(data, reply);
315 EXPECT_EQ(res, NO_ERROR);
316 }
317
318 /**
319 * @tc.name: AbilitySchedulerStubSecond_014
320 * @tc.desc: test UpdateSessionTokenInner
321 * @tc.type: FUNC
322 */
323 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_014, TestSize.Level1)
324 {
325 MessageParcel data;
326 MessageParcel reply;
327 sptr<IRemoteObject> token;
328 data.WriteRemoteObject(token);
329 auto res = stub_->UpdateSessionTokenInner(data, reply);
330 EXPECT_EQ(res, NO_ERROR);
331 }
332
333 /**
334 * @tc.name: AbilitySchedulerStubSecond_015
335 * @tc.desc: test CollaborateDataInner
336 * @tc.type: FUNC
337 */
338 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_015, TestSize.Level1)
339 {
340 MessageParcel data;
341 MessageParcel reply;
342
343 auto res = stub_->CollaborateDataInner(data);
344 EXPECT_EQ(res, ERR_INVALID_VALUE);
345
346 Want want;
347 data.WriteParcelable(&want);
348 res = stub_->CollaborateDataInner(data);
349 EXPECT_EQ(res, NO_ERROR);
350 }
351
352 /**
353 * @tc.name: AbilitySchedulerStubSecond_016
354 * @tc.desc: test OnRemoteRequestInner
355 * @tc.type: FUNC
356 */
357 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_016, TestSize.Level1)
358 {
359 MessageParcel data;
360 MessageParcel reply;
361 MessageOption option;
362 auto res = stub_->OnRemoteRequestInner(IAbilityScheduler::SCHEDULE_SHARE_DATA, data, reply, option);
363 EXPECT_EQ(res, NO_ERROR);
364 }
365
366 /**
367 * @tc.name: AbilitySchedulerStubSecond_017
368 * @tc.desc: test OnRemoteRequestInnerFirst
369 * @tc.type: FUNC
370 */
371 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_017, TestSize.Level1)
372 {
373 MessageParcel data;
374 MessageParcel reply;
375 MessageOption option;
376
377 int res = stub_->OnRemoteRequestInnerFirst(IAbilityScheduler::SCHEDULE_ABILITY_COMMAND, data, reply, option);
378 EXPECT_EQ(res, ERR_INVALID_VALUE);
379
380 res = stub_->OnRemoteRequestInnerFirst(IAbilityScheduler::SCHEDULE_ABILITY_PREPARE_TERMINATE, data, reply, option);
381 EXPECT_EQ(res, NO_ERROR);
382
383 res = stub_->OnRemoteRequestInnerFirst(IAbilityScheduler::SCHEDULE_ABILITY_COMMAND_WINDOW, data, reply, option);
384 EXPECT_EQ(res, ERR_INVALID_VALUE);
385
386 res = stub_->OnRemoteRequestInnerFirst(IAbilityScheduler::SCHEDULE_RESTORE_ABILITY_STATE, data, reply, option);
387 EXPECT_EQ(res, ERR_INVALID_VALUE);
388
389 res = stub_->OnRemoteRequestInnerFirst(IAbilityScheduler::SCHEDULE_GETFILETYPES, data, reply, option);
390 EXPECT_EQ(res, ERR_INVALID_VALUE);
391
392 res = stub_->OnRemoteRequestInnerFirst(IAbilityScheduler::SCHEDULE_OPENFILE, data, reply, option);
393 EXPECT_EQ(res, ERR_INVALID_VALUE);
394
395 res = stub_->OnRemoteRequestInnerFirst(IAbilityScheduler::SCHEDULE_OPENRAWFILE, data, reply, option);
396 EXPECT_EQ(res, ERR_INVALID_VALUE);
397
398 res = stub_->OnRemoteRequestInnerFirst(IAbilityScheduler::SCHEDULE_INSERT, data, reply, option);
399 EXPECT_EQ(res, ERR_INVALID_VALUE);
400
401 res = stub_->OnRemoteRequestInnerFirst(IAbilityScheduler::SCHEDULE_UPDATE, data, reply, option);
402 EXPECT_EQ(res, ERR_INVALID_VALUE);
403
404 res = stub_->OnRemoteRequestInnerFirst(IAbilityScheduler::SCHEDULE_DELETE, data, reply, option);
405 EXPECT_EQ(res, ERR_INVALID_VALUE);
406 }
407
408 /**
409 * @tc.name: AbilitySchedulerStubSecond_018
410 * @tc.desc: test OnRemoteRequestInnerSecond
411 * @tc.type: FUNC
412 */
413 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_018, TestSize.Level1)
414 {
415 MessageParcel data;
416 MessageParcel reply;
417 MessageOption option;
418
419 int res = stub_->OnRemoteRequestInnerSecond(IAbilityScheduler::SCHEDULE_QUERY, data, reply, option);
420 EXPECT_EQ(res, ERR_INVALID_VALUE);
421
422 res = stub_->OnRemoteRequestInnerSecond(IAbilityScheduler::SCHEDULE_CALL, data, reply, option);
423 EXPECT_EQ(res, ERR_INVALID_VALUE);
424
425 res = stub_->OnRemoteRequestInnerSecond(IAbilityScheduler::SCHEDULE_GETTYPE, data, reply, option);
426 EXPECT_EQ(res, ERR_INVALID_VALUE);
427
428 res = stub_->OnRemoteRequestInnerSecond(IAbilityScheduler::SCHEDULE_RELOAD, data, reply, option);
429 EXPECT_EQ(res, ERR_INVALID_VALUE);
430
431 res = stub_->OnRemoteRequestInnerSecond(IAbilityScheduler::SCHEDULE_BATCHINSERT, data, reply, option);
432 EXPECT_EQ(res, ERR_INVALID_VALUE);
433
434 res = stub_->OnRemoteRequestInnerSecond(IAbilityScheduler::SCHEDULE_REGISTEROBSERVER, data, reply, option);
435 EXPECT_EQ(res, ERR_INVALID_VALUE);
436
437 res = stub_->OnRemoteRequestInnerSecond(IAbilityScheduler::SCHEDULE_UNREGISTEROBSERVER, data, reply, option);
438 EXPECT_EQ(res, ERR_INVALID_VALUE);
439
440 res = stub_->OnRemoteRequestInnerSecond(IAbilityScheduler::SCHEDULE_NOTIFYCHANGE, data, reply, option);
441 EXPECT_EQ(res, ERR_INVALID_VALUE);
442
443 res = stub_->OnRemoteRequestInnerSecond(IAbilityScheduler::SCHEDULE_NORMALIZEURI, data, reply, option);
444 EXPECT_EQ(res, ERR_INVALID_VALUE);
445
446 res = stub_->OnRemoteRequestInnerSecond(IAbilityScheduler::SCHEDULE_DENORMALIZEURI, data, reply, option);
447 EXPECT_EQ(res, ERR_INVALID_VALUE);
448
449 res = stub_->OnRemoteRequestInnerSecond(IAbilityScheduler::SCHEDULE_EXECUTEBATCH, data, reply, option);
450 EXPECT_EQ(res, ERR_INVALID_VALUE);
451
452 res = stub_->OnRemoteRequestInnerSecond(IAbilityScheduler::NOTIFY_CONTINUATION_RESULT, data, reply, option);
453 EXPECT_EQ(res, NO_ERROR);
454
455 res = stub_->OnRemoteRequestInnerSecond(IAbilityScheduler::CONTINUE_ABILITY, data, reply, option);
456 EXPECT_EQ(res, NO_ERROR);
457 }
458
459 /**
460 * @tc.name: AbilitySchedulerStubSecond_019
461 * @tc.desc: test OnRemoteRequestInnerThird
462 * @tc.type: FUNC
463 */
464 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_019, TestSize.Level1)
465 {
466 MessageParcel data;
467 MessageParcel reply;
468 MessageOption option;
469
470 uint32_t code = IAbilityScheduler::SCHEDULE_SHARE_DATA;
471 int res = stub_->OnRemoteRequestInnerThird(code, data, reply, option);
472 EXPECT_EQ(res, NO_ERROR);
473
474 code = 31;
475 res = stub_->OnRemoteRequestInnerThird(code, data, reply, option);
476 EXPECT_EQ(res, ERR_INVALID_VALUE);
477
478 code = IAbilityScheduler::CREATE_MODAL_UI_EXTENSION;
479 res = stub_->OnRemoteRequestInnerThird(code, data, reply, option);
480 EXPECT_EQ(res, ERR_INVALID_VALUE);
481
482 code = IAbilityScheduler::UPDATE_SESSION_TOKEN;
483 res = stub_->OnRemoteRequestInnerThird(code, data, reply, option);
484 EXPECT_EQ(res, NO_ERROR);
485
486 code = IAbilityScheduler::SCHEDULE_COLLABORATE_DATA;
487 res = stub_->OnRemoteRequestInnerThird(code, data, reply, option);
488 EXPECT_EQ(res, ERR_INVALID_VALUE);
489 }
490
491 /**
492 * @tc.name: AbilitySchedulerStubSecond_020
493 * @tc.desc: test OnRemoteRequest
494 * @tc.type: FUNC
495 */
496 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_020, TestSize.Level1)
497 {
498 MessageParcel data;
499 MessageParcel reply;
500 MessageOption option;
501 auto res = stub_->OnRemoteRequest(INT_MAX, data, reply, option);
502 EXPECT_EQ(res, ERR_INVALID_STATE);
503 }
504
505 /**
506 * @tc.name: AbilitySchedulerStubSecond_021
507 * @tc.desc: test AbilityTransactionInner
508 * @tc.type: FUNC
509 */
510 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_021, TestSize.Level1)
511 {
512 MessageParcel data;
513 MessageParcel reply;
514 auto res = stub_->AbilityTransactionInner(data, reply);
515 EXPECT_EQ(res, ERR_INVALID_VALUE);
516
517 Want want;
518 data.WriteParcelable(&want);
519 res = stub_->AbilityTransactionInner(data, reply);
520 EXPECT_EQ(res, ERR_INVALID_VALUE);
521 }
522
523 /**
524 * @tc.name: AbilitySchedulerStubSecond_022
525 * @tc.desc: test AbilityTransactionInner
526 * @tc.type: FUNC
527 */
528 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_022, TestSize.Level1)
529 {
530 MessageParcel data;
531 MessageParcel reply;
532
533 Want want;
534 LifeCycleStateInfo stateInfo;
535 data.WriteParcelable(&want);
536 data.WriteParcelable(&stateInfo);
537 data.WriteBool(true);
538 auto res = stub_->AbilityTransactionInner(data, reply);
539 EXPECT_EQ(res, NO_ERROR);
540 }
541
542 /**
543 * @tc.name: AbilitySchedulerStubSecond_023
544 * @tc.desc: test DisconnectAbilityInner
545 * @tc.type: FUNC
546 */
547 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_023, TestSize.Level1)
548 {
549 MessageParcel data;
550 MessageParcel reply;
551 Want want;
552 data.WriteParcelable(&want);
553 auto res = stub_->DisconnectAbilityInner(data, reply);
554 EXPECT_EQ(res, NO_ERROR);
555 }
556
557 /**
558 * @tc.name: AbilitySchedulerStubSecond_024
559 * @tc.desc: test CommandAbilityInner
560 * @tc.type: FUNC
561 */
562 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_024, TestSize.Level1)
563 {
564 MessageParcel data;
565 MessageParcel reply;
566 auto res = stub_->CommandAbilityInner(data, reply);
567 EXPECT_EQ(res, ERR_INVALID_VALUE);
568
569 Want want;
570 data.WriteParcelable(&want);
571 res = stub_->CommandAbilityInner(data, reply);
572 EXPECT_EQ(res, NO_ERROR);
573 }
574
575 /**
576 * @tc.name: AbilitySchedulerStubSecond_025
577 * @tc.desc: test PrepareTerminateAbilityInner
578 * @tc.type: FUNC
579 */
580 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_025, TestSize.Level1)
581 {
582 MessageParcel data;
583 MessageParcel reply;
584 auto res = stub_->PrepareTerminateAbilityInner(data, reply);
585 EXPECT_EQ(res, NO_ERROR);
586 }
587
588 /**
589 * @tc.name: AbilitySchedulerStubSecond_026
590 * @tc.desc: test CommandAbilityWindowInner
591 * @tc.type: FUNC
592 */
593 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_026, TestSize.Level1)
594 {
595 MessageParcel data;
596 MessageParcel reply;
597 auto res = stub_->CommandAbilityWindowInner(data, reply);
598 EXPECT_EQ(res, ERR_INVALID_VALUE);
599
600 Want want;
601 data.WriteParcelable(&want);
602 res = stub_->CommandAbilityWindowInner(data, reply);
603 EXPECT_EQ(res, NO_ERROR);
604 }
605
606 /**
607 * @tc.name: AbilitySchedulerStubSecond_027
608 * @tc.desc: test RestoreAbilityStateInner
609 * @tc.type: FUNC
610 */
611 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_027, TestSize.Level1)
612 {
613 MessageParcel data;
614 MessageParcel reply;
615 auto res = stub_->RestoreAbilityStateInner(data, reply);
616 EXPECT_EQ(res, ERR_INVALID_VALUE);
617
618 PacMap pacMap;
619 data.WriteParcelable(&pacMap);
620 res = stub_->RestoreAbilityStateInner(data, reply);
621 EXPECT_EQ(res, NO_ERROR);
622 }
623
624 /**
625 * @tc.name: AbilitySchedulerStubSecond_028
626 * @tc.desc: test GetFileTypesInner
627 * @tc.type: FUNC
628 */
629 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_028, TestSize.Level1)
630 {
631 MessageParcel data;
632 MessageParcel reply;
633
634 auto res = stub_->GetFileTypesInner(data, reply);
635 EXPECT_EQ(res, ERR_INVALID_VALUE);
636
637 Uri uri("test_uri");
638 data.WriteParcelable(&uri);
639 res = stub_->GetFileTypesInner(data, reply);
640 EXPECT_EQ(res, ERR_INVALID_VALUE);
641
642 MessageParcel data2;
643 data2.WriteParcelable(&uri);
644 data2.WriteString("test");
645 res = stub_->GetFileTypesInner(data2, reply);
646 EXPECT_EQ(res, NO_ERROR);
647 }
648
649 /**
650 * @tc.name: AbilitySchedulerStubSecond_029
651 * @tc.desc: test OpenFileInner wangyi test failed
652 * @tc.type: FUNC
653 */
654 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_029, TestSize.Level1)
655 {
656 MessageParcel data;
657 MessageParcel reply;
658
659 auto res = stub_->OpenFileInner(data, reply);
660 EXPECT_EQ(res, ERR_INVALID_VALUE);
661
662 Uri uri("test_uri");
663 data.WriteParcelable(&uri);
664 res = stub_->OpenFileInner(data, reply);
665 EXPECT_EQ(res, ERR_INVALID_VALUE);
666
667 MessageParcel data2;
668 data2.WriteParcelable(&uri);
669 data2.WriteString("r");
670 res = stub_->OpenFileInner(data2, reply);
671 EXPECT_EQ(res, ERR_INVALID_VALUE);
672 }
673
674 /**
675 * @tc.name: AbilitySchedulerStubSecond_030
676 * @tc.desc: test OpenRawFileInner
677 * @tc.type: FUNC
678 */
679 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_030, TestSize.Level1)
680 {
681 MessageParcel data;
682 MessageParcel reply;
683
684 auto res = stub_->OpenRawFileInner(data, reply);
685 EXPECT_EQ(res, ERR_INVALID_VALUE);
686
687 Uri uri("test_uri");
688 data.WriteParcelable(&uri);
689 res = stub_->OpenRawFileInner(data, reply);
690 EXPECT_EQ(res, ERR_INVALID_VALUE);
691
692 MessageParcel data2;
693 data2.WriteParcelable(&uri);
694 data2.WriteString("w");
695 res = stub_->OpenRawFileInner(data2, reply);
696 EXPECT_EQ(res, NO_ERROR);
697 }
698
699 /**
700 * @tc.name: AbilitySchedulerStubSecond_031
701 * @tc.desc: test InsertInner
702 * @tc.type: FUNC
703 */
704 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_031, TestSize.Level1)
705 {
706 MessageParcel data;
707 MessageParcel reply;
708
709 auto res = stub_->InsertInner(data, reply);
710 EXPECT_EQ(res, ERR_INVALID_VALUE);
711
712 Uri uri("test_uri");
713 data.WriteParcelable(&uri);
714 res = stub_->InsertInner(data, reply);
715 EXPECT_EQ(res, NO_ERROR);
716 }
717
718 /**
719 * @tc.name: AbilitySchedulerStubSecond_032
720 * @tc.desc: test CallInner
721 * @tc.type: FUNC
722 */
723 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_032, TestSize.Level1)
724 {
725 MessageParcel data;
726 MessageParcel reply;
727
728 auto res = stub_->CallInner(data, reply);
729 EXPECT_EQ(res, ERR_INVALID_VALUE);
730
731 Uri uri("test_uri");
732 data.WriteParcelable(&uri);
733 res = stub_->CallInner(data, reply);
734 EXPECT_EQ(res, ERR_INVALID_VALUE);
735
736 MessageParcel data2;
737 data2.WriteParcelable(&uri);
738 data2.WriteString("test_str");
739 data2.WriteString("test_str1");
740 res = stub_->CallInner(data2, reply);
741 EXPECT_EQ(res, ERR_INVALID_VALUE);
742
743 MessageParcel data3;
744 PacMap pacMap;
745 data3.WriteParcelable(&uri);
746 data3.WriteString("test_str");
747 data3.WriteString("test_str1");
748 data3.WriteParcelable(&pacMap);
749 res = stub_->CallInner(data3, reply);
750 EXPECT_EQ(res, NO_ERROR);
751 }
752
753 /**
754 * @tc.name: AbilitySchedulerStubSecond_033
755 * @tc.desc: test UpdatetInner
756 * @tc.type: FUNC
757 */
758 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_033, TestSize.Level1)
759 {
760 MessageParcel data;
761 MessageParcel reply;
762
763 auto res = stub_->UpdatetInner(data, reply);
764 EXPECT_EQ(res, ERR_INVALID_VALUE);
765
766 Uri uri("test_uri");
767 data.WriteParcelable(&uri);
768 res = stub_->UpdatetInner(data, reply);
769 EXPECT_EQ(res, ERR_INVALID_VALUE);
770
771 MessageParcel data2;
772 NativeRdb::DataAbilityPredicates predicates;
773 WriteInterfaceToken(data2);
774 data2.WriteParcelable(&uri);
775 data2.WriteParcelable(&predicates);
776 res = stub_->UpdatetInner(data2, reply);
777 EXPECT_EQ(res, NO_ERROR);
778 }
779
780 /**
781 * @tc.name: AbilitySchedulerStubSecond_034
782 * @tc.desc: test DeleteInner
783 * @tc.type: FUNC
784 */
785 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_034, TestSize.Level1)
786 {
787 MessageParcel data;
788 MessageParcel reply;
789
790 auto res = stub_->DeleteInner(data, reply);
791 EXPECT_EQ(res, ERR_INVALID_VALUE);
792
793 Uri uri("test_uri");
794 data.WriteParcelable(&uri);
795 res = stub_->DeleteInner(data, reply);
796 EXPECT_EQ(res, ERR_INVALID_VALUE);
797
798 MessageParcel data2;
799 NativeRdb::DataAbilityPredicates predicates;
800 data2.WriteParcelable(&uri);
801 data2.WriteParcelable(&predicates);
802 res = stub_->DeleteInner(data2, reply);
803 EXPECT_EQ(res, NO_ERROR);
804 }
805
806 /**
807 * @tc.name: AbilitySchedulerStubSecond_035
808 * @tc.desc: test QueryInner
809 * @tc.type: FUNC
810 */
811 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_035, TestSize.Level1)
812 {
813 MessageParcel data;
814 MessageParcel reply;
815
816 auto res = stub_->QueryInner(data, reply);
817 EXPECT_EQ(res, ERR_INVALID_VALUE);
818
819 Uri uri("test_uri");
820 data.WriteParcelable(&uri);
821 res = stub_->QueryInner(data, reply);
822 EXPECT_EQ(res, ERR_INVALID_VALUE);
823
824 MessageParcel data2;
825 NativeRdb::DataAbilityPredicates predicates;
826 WriteInterfaceToken(data2);
827 data2.WriteParcelable(&uri);
828 data2.WriteParcelable(&predicates);
829 res = stub_->QueryInner(data2, reply);
830 EXPECT_EQ(res, ERR_INVALID_VALUE);
831 }
832
833 /**
834 * @tc.name: AbilitySchedulerStubSecond_036
835 * @tc.desc: test GetTypeInner
836 * @tc.type: FUNC
837 */
838 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_036, TestSize.Level1)
839 {
840 MessageParcel data;
841 MessageParcel reply;
842
843 auto res = stub_->GetTypeInner(data, reply);
844 EXPECT_EQ(res, ERR_INVALID_VALUE);
845
846 Uri uri("test_uri");
847 data.WriteParcelable(&uri);
848 res = stub_->GetTypeInner(data, reply);
849 EXPECT_EQ(res, NO_ERROR);
850 }
851
852 /**
853 * @tc.name: AbilitySchedulerStubSecond_037
854 * @tc.desc: test ReloadInner
855 * @tc.type: FUNC
856 */
857 HWTEST_F(AbilitySchedulerStubSecondTest, AbilitySchedulerStubSecond_037, TestSize.Level1)
858 {
859 MessageParcel data;
860 MessageParcel reply;
861
862 auto res = stub_->ReloadInner(data, reply);
863 EXPECT_EQ(res, ERR_INVALID_VALUE);
864
865 Uri uri("test_uri");
866 data.WriteParcelable(&uri);
867 res = stub_->ReloadInner(data, reply);
868 EXPECT_EQ(res, ERR_INVALID_VALUE);
869
870 MessageParcel data2;
871 PacMap pacMap;
872 data2.WriteParcelable(&uri);
873 data2.WriteParcelable(&pacMap);
874 res = stub_->ReloadInner(data2, reply);
875 EXPECT_EQ(res, NO_ERROR);
876 }
877 } // namespace AAFwk
878 } // namespace OHOS
879