1 /*
2 * Copyright (c) 2021 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 #include "../include/getparam.h"
16 #include <functional>
17 #include <random>
18 #include <climits>
19 #include <cfloat>
20 #include <chrono>
21 #include "abs_shared_result_set.h"
22 #include "data_ability_predicates.h"
23 #include "values_bucket.h"
24 using namespace std;
25 using namespace OHOS::AppExecFwk;
26 using Uri = OHOS::Uri;
27 namespace OHOS {
28 namespace EventFwk {
GetBoolParam()29 bool GetBoolParam()
30 {
31 bool param;
32 if (GetIntParam() % 2 == 0) {
33 param = true;
34 } else {
35 param = false;
36 }
37 cout << "Bool param is: " << param << endl;
38 return param;
39 }
40
GenRandom(size_t min,size_t max)41 size_t GenRandom(size_t min, size_t max)
42 {
43 std::random_device rd;
44 static uniform_int_distribution<size_t> u(min, max);
45 static default_random_engine e(rd());
46 size_t param = u(e);
47 return param;
48 }
49
GetS8Param()50 int8_t GetS8Param()
51 {
52 std::random_device rd;
53 static uniform_int_distribution<int8_t> u(INT8_MIN, INT8_MAX);
54 static default_random_engine e(rd());
55 int8_t param = u(e);
56 cout << "Int8_t param is: " << param << endl;
57 return param;
58 }
GetS16Param()59 int16_t GetS16Param()
60 {
61 std::random_device rd;
62 static uniform_int_distribution<int16_t> u(INT16_MIN, INT16_MAX);
63 static default_random_engine e(rd());
64 int16_t param = u(e);
65 cout << "Int16_t param is: " << param << endl;
66 return param;
67 }
GetS32Param()68 int32_t GetS32Param()
69 {
70 std::random_device rd;
71 static uniform_int_distribution<int32_t> u(INT32_MIN, INT32_MAX);
72 static default_random_engine e(rd());
73 int32_t param = u(e);
74 cout << "Int32_t param is: " << param << endl;
75 return param;
76 }
77
GetS64Param()78 int64_t GetS64Param()
79 {
80 std::random_device rd;
81 static uniform_int_distribution<int64_t> u(INT64_MIN, INT64_MAX);
82 static default_random_engine e(rd());
83 int64_t param = u(e);
84 cout << "Int64_t param is: " << param << endl;
85 return param;
86 }
87
88 template <class T>
GetUnsignParam()89 T GetUnsignParam()
90 {
91 std::random_device rd;
92 static uniform_int_distribution<T> u;
93 static default_random_engine e(rd());
94 T param = u(e);
95 return param;
96 }
97
GetSizeTParam()98 size_t GetSizeTParam()
99 {
100 size_t param = GetUnsignParam<size_t>();
101 return param;
102 }
103
GetU8Param()104 uint8_t GetU8Param()
105 {
106 uint8_t param = GetUnsignParam<uint8_t>();
107 cout << "Uint8_t param is: " << param << endl;
108 return param;
109 }
110
GetUIntParam()111 unsigned int GetUIntParam()
112 {
113 unsigned int param = GetUnsignParam<unsigned int>();
114 cout << "Unsigned int param is: " << param << endl;
115 return param;
116 }
117
GetU16Param()118 uint16_t GetU16Param()
119 {
120 uint16_t param = GetUnsignParam<uint16_t>();
121 cout << "Uint16_t param is: " << param << endl;
122 return param;
123 }
124
GetU32Param()125 uint32_t GetU32Param()
126 {
127 uint32_t param = GetUnsignParam<uint32_t>();
128 cout << "Uint32_t param is: " << param << endl;
129 return param;
130 }
131
GetU64Param()132 uint64_t GetU64Param()
133 {
134 uint64_t param = GetUnsignParam<uint64_t>();
135 cout << "Uint64_t param is: " << param << endl;
136 return param;
137 }
138
GetShortParam()139 short GetShortParam()
140 {
141 std::random_device rd;
142 static uniform_int_distribution<short> u(SHRT_MIN, SHRT_MAX);
143 static default_random_engine e(rd());
144 short param = u(e);
145 cout << "Short param is: " << param << endl;
146 return param;
147 }
148
GetLongParam()149 long GetLongParam()
150 {
151 std::random_device rd;
152 static uniform_int_distribution<long> u(LONG_MIN, LONG_MAX);
153 static default_random_engine e(rd());
154 long param = u(e);
155 cout << "Long param is: " << param << endl;
156 return param;
157 }
158
GetIntParam()159 int GetIntParam()
160 {
161 std::random_device rd;
162 static uniform_int_distribution<> u(INT_MIN, INT_MAX);
163 static default_random_engine e(rd());
164 int param = u(e);
165 cout << "Int param is: " << param << endl;
166 return param;
167 }
168
GetDoubleParam()169 double GetDoubleParam()
170 {
171 double param = 0;
172 std::random_device rd;
173 static uniform_real_distribution<double> u(DBL_MIN, DBL_MAX);
174 static default_random_engine e(rd());
175 param = u(e);
176 cout << "double param is: " << param << endl;
177 return param;
178 }
179
GetFloatParam()180 float GetFloatParam()
181 {
182 float param = 0;
183 std::random_device rd;
184 static uniform_real_distribution<float> u(FLT_MIN, FLT_MAX);
185 static default_random_engine e(rd());
186 param = u(e);
187 cout << "Float param is: " << param << endl;
188 return param;
189 }
190
GetCharParam()191 char GetCharParam()
192 {
193 std::random_device rd;
194 static uniform_int_distribution<> u(-128, 127);
195 static default_random_engine e(rd());
196 char param = u(e);
197 return param;
198 }
199
GetChar32Param()200 char32_t GetChar32Param()
201 {
202 char32_t param = ' ';
203 std::random_device rd;
204 static uniform_int_distribution<char32_t> u;
205 static default_random_engine e(rd());
206 param = u(e);
207 return param;
208 }
209
GetCharArryParam()210 char *GetCharArryParam()
211 {
212 static char param[256];
213 size_t len = 0;
214 string strparam = GetStringParam();
215 if (!strparam.empty()) {
216 len = strparam.size() + 1;
217 if (len > sizeof(param)) {
218 len = sizeof(param) - 1;
219 }
220
221 int ret = strcpy_s(param, len, strparam.c_str());
222 if(ret == 0){
223 return param;
224 } else {
225 return nullptr;
226 }
227 } else {
228 return nullptr;
229 }
230 }
231
GetStringParam()232 string GetStringParam()
233 {
234 string param = "";
235 char ch = GetCharParam();
236 size_t len = GenRandom(0, 255);
237 while (len--) {
238 ch = GetCharParam();
239 param += ch;
240 }
241 cout << "String param length is: " << param.length() << endl;
242 return param;
243 }
244
245 template <class T>
GetUnsignVectorParam()246 vector<T> GetUnsignVectorParam()
247 {
248 vector<T> param;
249 size_t len = GenRandom(0, 255);
250 while (len--) {
251 T t = GetUnsignParam<T>();
252 param.push_back(t);
253 }
254 cout << "Uint vector param length is: " << param.size() << endl;
255 return param;
256 }
257
258 template <class T>
GetClassParam()259 T GetClassParam()
260 {
261 T param;
262 return param;
263 }
264
GetBoolVectorParam()265 std::vector<bool> GetBoolVectorParam()
266 {
267 vector<bool> param;
268 size_t len = GenRandom(0, 255);
269 while (len--) {
270 int t = GetBoolParam();
271 param.push_back(t);
272 }
273 cout << "Bool vector param length is: " << param.size() << endl;
274 return param;
275 }
276
GetShortVectorParam()277 std::vector<short> GetShortVectorParam()
278 {
279 vector<short> param;
280 size_t len = GenRandom(0, 255);
281 while (len--) {
282 short t = GetShortParam();
283 param.push_back(t);
284 }
285 cout << "Short vector param length is: " << param.size() << endl;
286 return param;
287 }
288
GetLongVectorParam()289 std::vector<long> GetLongVectorParam()
290 {
291 vector<long> param;
292 size_t len = GenRandom(0, 255);
293 while (len--) {
294 long t = GetLongParam();
295 param.push_back(t);
296 }
297 cout << "Long vector param length is: " << param.size() << endl;
298 return param;
299 }
300
GetIntVectorParam()301 vector<int> GetIntVectorParam()
302 {
303 vector<int> param;
304 size_t len = GenRandom(0, 255);
305 while (len--) {
306 int t = GetIntParam();
307 param.push_back(t);
308 }
309 cout << "Int vector param length is: " << param.size() << endl;
310 return param;
311 }
312
GetFloatVectorParam()313 std::vector<float> GetFloatVectorParam()
314 {
315 vector<float> param;
316 size_t len = GenRandom(0, 255);
317 while (len--) {
318 float t = GetIntParam();
319 param.push_back(t);
320 }
321 cout << "Float vector param length is: " << param.size() << endl;
322 return param;
323 }
324
GetDoubleVectorParam()325 std::vector<double> GetDoubleVectorParam()
326 {
327 vector<double> param;
328 size_t len = GenRandom(0, 255);
329 while (len--) {
330 double t = GetIntParam();
331 param.push_back(t);
332 }
333 cout << "Double vector param length is: " << param.size() << endl;
334 return param;
335 }
336
GetCharVectorParam()337 vector<char> GetCharVectorParam()
338 {
339 vector<char> param;
340 size_t len = GenRandom(0, 255);
341 while (len--) {
342 char t = GetCharParam();
343 param.push_back(t);
344 }
345 cout << "Char vector param length is: " << param.size() << endl;
346 return param;
347 }
348
GetChar32VectorParam()349 vector<char32_t> GetChar32VectorParam()
350 {
351 vector<char32_t> param;
352 size_t len = GenRandom(0, 255);
353 while (len--) {
354 char32_t t = GetChar32Param();
355 param.push_back(t);
356 }
357 cout << "Char32_t vector param length is: " << param.size() << endl;
358 return param;
359 }
360
GetStringVectorParam()361 vector<string> GetStringVectorParam()
362 {
363 vector<string> param;
364 size_t len = GenRandom(0, 255);
365 while (len--) {
366 string t = GetStringParam();
367 param.push_back(t);
368 }
369 cout << "String vector param length is: " << param.size() << endl;
370 return param;
371 }
372
GetS8VectorParam()373 vector<int8_t> GetS8VectorParam()
374 {
375 vector<int8_t> param;
376 size_t len = GenRandom(0, 255);
377 while (len--) {
378 int8_t temp = GetS8Param();
379 param.push_back(temp);
380 }
381 cout << "Int8_t vector param length is: " << param.size() << endl;
382 return param;
383 }
384
GetS16VectorParam()385 vector<int16_t> GetS16VectorParam()
386 {
387 vector<int16_t> param;
388 size_t len = GenRandom(0, 255);
389 while (len--) {
390 int16_t temp = GetS16Param();
391 param.push_back(temp);
392 }
393 cout << "Int16_t vector param length is: " << param.size() << endl;
394 return param;
395 }
396
GetS32VectorParam()397 vector<int32_t> GetS32VectorParam()
398 {
399 vector<int32_t> param;
400 size_t len = GenRandom(0, 255);
401 while (len--) {
402 int32_t temp = GetS32Param();
403 param.push_back(temp);
404 }
405 cout << "Int32_t vector param length is: " << param.size() << endl;
406 return param;
407 }
408
GetS64VectorParam()409 vector<int64_t> GetS64VectorParam()
410 {
411 vector<int64_t> param;
412 size_t len = GenRandom(0, 255);
413 while (len--) {
414 int64_t temp = GetS64Param();
415 param.push_back(temp);
416 }
417 cout << "Int32_t vector param length is: " << param.size() << endl;
418 return param;
419 }
420
GetParamParcel()421 std::shared_ptr<Parcel> GetParamParcel()
422 {
423 return make_shared<Parcel>();
424 }
GetParamWant()425 std::shared_ptr<Want> GetParamWant()
426 {
427 return make_shared<Want>();
428 }
429
GetParamOperation()430 OHOS::AAFwk::Operation GetParamOperation()
431 {
432 return OHOS::AAFwk::Operation();
433 }
434
GetParamAsyncCommonEventResult()435 std::shared_ptr<AsyncCommonEventResult> GetParamAsyncCommonEventResult()
436 {
437 return make_shared<AsyncCommonEventResult>(
438 GetIntParam(), GetStringParam(), GetBoolParam(), GetBoolParam(), GetParamSptrRemote());
439 }
440
GetParamCommonEventData()441 std::shared_ptr<CommonEventData> GetParamCommonEventData()
442 {
443 return make_shared<CommonEventData>();
444 }
445
GetParamCommonEventManager()446 std::shared_ptr<CommonEventManager> GetParamCommonEventManager()
447 {
448 return make_shared<CommonEventManager>();
449 }
450
GetParamCommonEventPublishInfo()451 std::shared_ptr<CommonEventPublishInfo> GetParamCommonEventPublishInfo()
452 {
453 return make_shared<CommonEventPublishInfo>();
454 }
455
GetParamCommonEventSubscribeInfo()456 std::shared_ptr<CommonEventSubscribeInfo> GetParamCommonEventSubscribeInfo()
457 {
458 return make_shared<CommonEventSubscribeInfo>();
459 }
460
GetParamCommonEventSubscriber()461 std::shared_ptr<CommonEventSubscriber> GetParamCommonEventSubscriber()
462 {
463 return make_shared<TestCommonEventSubscriber>();
464 }
465
GetParamCommonEventSupport()466 std::shared_ptr<CommonEventSupport> GetParamCommonEventSupport()
467 {
468 return make_shared<CommonEventSupport>();
469 }
470
GetParamMatchingSkills()471 std::shared_ptr<MatchingSkills> GetParamMatchingSkills()
472 {
473 return make_shared<MatchingSkills>();
474 }
475
GetParamSptrRemote()476 sptr<IRemoteObject> GetParamSptrRemote()
477 {
478 return sptr<TestRemoteObject>();
479 }
480
GetParamEventRunner()481 std::shared_ptr<EventRunner> GetParamEventRunner()
482 {
483 return EventRunner::Create(GetCharArryParam());
484 }
485
GetParamEventHandler()486 std::shared_ptr<EventHandler> GetParamEventHandler()
487 {
488 return make_shared<EventHandler>(GetParamEventRunner());
489 }
490
GetParamEventQueue()491 std::shared_ptr<OHOS::AppExecFwk::EventQueue> GetParamEventQueue()
492 {
493 return make_shared<OHOS::AppExecFwk::EventQueue>();
494 }
495
GetParamEventRunnerNativeImplement()496 std::shared_ptr<EventRunnerNativeImplement> GetParamEventRunnerNativeImplement()
497 {
498 return make_shared<EventRunnerNativeImplement>(GetBoolParam());
499 }
500
GetParamFileDescriptorListener()501 std::shared_ptr<OHOS::AppExecFwk::FileDescriptorListener> GetParamFileDescriptorListener()
502 {
503 return make_shared<TestFileDescriptorListener>();
504 }
505
GetParamDumper()506 TestDumper GetParamDumper()
507 {
508 return GetClassParam<TestDumper>();
509 }
510
GetParamInnerEvent()511 InnerEvent::Pointer GetParamInnerEvent()
512 {
513 return InnerEvent::Get(GetU32Param(), GetS64Param());
514 }
515
GetParamThreadMode()516 CommonEventSubscribeInfo::ThreadMode GetParamThreadMode()
517 {
518 switch (GetIntParam() % 4) {
519 case 0:
520 return CommonEventSubscribeInfo::ThreadMode::HANDLER;
521 break;
522 case 1:
523 return CommonEventSubscribeInfo::ThreadMode::POST;
524 break;
525 case 2:
526 return CommonEventSubscribeInfo::ThreadMode::ASYNC;
527 break;
528 case 3:
529 return CommonEventSubscribeInfo::ThreadMode::BACKGROUND;
530 break;
531 default:
532 return CommonEventSubscribeInfo::ThreadMode::HANDLER;
533 break;
534 }
535 }
536
GetParamPriority()537 EventQueue::Priority GetParamPriority()
538 {
539 switch (GetIntParam() % 4) {
540 case 0:
541 return EventQueue::Priority::IMMEDIATE;
542 break;
543 case 1:
544 return EventQueue::Priority::HIGH;
545 break;
546 case 2:
547 return EventQueue::Priority::LOW;
548 break;
549 case 3:
550 return EventQueue::Priority::IDLE;
551 break;
552 default:
553 return EventQueue::Priority::LOW;
554 break;
555 }
556 }
557
GetParamLogger()558 std::shared_ptr<Logger> GetParamLogger()
559 {
560 return make_shared<TestLogger>();
561 }
562
GetParamCallback()563 InnerEvent::Callback GetParamCallback()
564 {
565 auto callback = []() { printf("Fuzz Test Inner Event Callback."); };
566 return callback;
567 }
568
GetParamTimePoint()569 OHOS::AppExecFwk::InnerEvent::TimePoint GetParamTimePoint()
570 {
571 std::chrono::steady_clock::time_point param = std::chrono::steady_clock::now();
572 return param;
573 }
574
GetParamAbilityStartSetting()575 std::shared_ptr<AbilityStartSetting> GetParamAbilityStartSetting()
576 {
577 return AbilityStartSetting::GetEmptySetting();
578 }
579
GetParamIAbilityConnection()580 sptr<OHOS::AAFwk::IAbilityConnection> GetParamIAbilityConnection()
581 {
582 return sptr<OHOS::AAFwk::IAbilityConnection>();
583 }
584
GetParamAbilityContext()585 std::shared_ptr<OHOS::AppExecFwk::AbilityContext> GetParamAbilityContext()
586 {
587 return make_shared<OHOS::AppExecFwk::AbilityContext>();
588 }
GetParamIAbilityEvent()589 std::shared_ptr<OHOS::AppExecFwk::IAbilityEvent> GetParamIAbilityEvent()
590 {
591 return make_shared<TestAbilityEvent>();
592 }
593
GetParamAbilityThread()594 sptr<OHOS::AppExecFwk::AbilityThread> GetParamAbilityThread()
595 {
596 return sptr<OHOS::AppExecFwk::AbilityThread>();
597 }
598
GetParamAbilityHandler()599 std::shared_ptr<OHOS::AppExecFwk::AbilityHandler> GetParamAbilityHandler()
600 {
601 return make_shared<OHOS::AppExecFwk::AbilityHandler>(GetParamEventRunner(), GetParamAbilityThread());
602 }
603
GetParamAbility()604 std::shared_ptr<OHOS::AppExecFwk::Ability> GetParamAbility()
605 {
606 return make_shared<OHOS::AppExecFwk::Ability>();
607 }
608
GetParamComponentContainer()609 std::shared_ptr<OHOS::AppExecFwk::ComponentContainer> GetParamComponentContainer()
610 {
611 return make_shared<OHOS::AppExecFwk::ComponentContainer>();
612 }
613
614 // std::shared_ptr<OHOS::AppExecFwk::AbilityInfo> GetParamAbilityInfo()
615 // {
616 // }
617
GetParamOHOSApplication()618 std::shared_ptr<OHOS::AppExecFwk::OHOSApplication> GetParamOHOSApplication()
619 {
620 return make_shared<OHOS::AppExecFwk::OHOSApplication>();
621 }
622
GetParamUri()623 OHOS::Uri GetParamUri()
624 {
625 return OHOS::Uri(GetStringParam());
626 }
627
GetParamValuesBucket()628 NativeRdb::ValuesBucket GetParamValuesBucket()
629 {
630 if (GetBoolParam()) {
631 NativeRdb::ValuesBucket val;
632 val.PutNull(GetStringParam());
633 return val;
634 } else {
635 return NativeRdb::ValuesBucket();
636 }
637 }
638
GetParamConfiguration()639 OHOS::AppExecFwk::Configuration GetParamConfiguration()
640 {
641 if (GetBoolParam()) {
642 OHOS::AppExecFwk::Configuration config;
643 config.AddItem(GlobalConfigurationKey::SYSTEM_LANGUAGE, GetStringParam());
644 return config;
645 } else {
646 return OHOS::AppExecFwk::Configuration();
647 }
648 }
649
GetParamDataAbilityPredicates()650 NativeRdb::DataAbilityPredicates GetParamDataAbilityPredicates()
651 {
652 if (GetBoolParam()) {
653 return NativeRdb::DataAbilityPredicates(GetStringParam());
654 } else {
655 return NativeRdb::DataAbilityPredicates();
656 }
657 }
658
GetParamPacMap()659 OHOS::AppExecFwk::PacMap GetParamPacMap()
660 {
661 return OHOS::AppExecFwk::PacMap();
662 }
663
GetParamNotificationRequest()664 OHOS::AppExecFwk::NotificationRequest GetParamNotificationRequest()
665 {
666 return OHOS::AppExecFwk::NotificationRequest();
667 }
668
GetParamProcessInfo()669 std::shared_ptr<OHOS::AppExecFwk::ProcessInfo> GetParamProcessInfo()
670 {
671 pid_t id = GetIntParam();
672 if (GetBoolParam()) {
673 return make_shared<OHOS::AppExecFwk::ProcessInfo>(GetStringParam(), id);
674 } else {
675 return make_shared<OHOS::AppExecFwk::ProcessInfo>();
676 }
677 }
678
GetParamDataUriUtils()679 std::shared_ptr<OHOS::AppExecFwk::DataUriUtils> GetParamDataUriUtils()
680 {
681 return make_shared<OHOS::AppExecFwk::DataUriUtils>();
682 }
683
GetParamContext()684 std::shared_ptr<OHOS::AppExecFwk::Context> GetParamContext()
685 {
686 return make_shared<OHOS::AppExecFwk::Ability>();
687 }
688
GetParamLifeCycle()689 std::shared_ptr<OHOS::AppExecFwk::LifeCycle> GetParamLifeCycle()
690 {
691 return make_shared<OHOS::AppExecFwk::LifeCycle>();
692 }
693
GetParamLifeCycleEvent()694 OHOS::AppExecFwk::LifeCycle::Event GetParamLifeCycleEvent()
695 {
696 switch (GetIntParam() % 7) {
697 case 0:
698 return OHOS::AppExecFwk::LifeCycle::Event::ON_ACTIVE;
699 break;
700 case 1:
701 return OHOS::AppExecFwk::LifeCycle::Event::ON_BACKGROUND;
702 break;
703 case 2:
704 return OHOS::AppExecFwk::LifeCycle::Event::ON_FOREGROUND;
705 break;
706 case 3:
707 return OHOS::AppExecFwk::LifeCycle::Event::ON_INACTIVE;
708 break;
709 case 4:
710 return OHOS::AppExecFwk::LifeCycle::Event::ON_START;
711 break;
712 case 5:
713 return OHOS::AppExecFwk::LifeCycle::Event::ON_STOP;
714 break;
715 case 6:
716 return OHOS::AppExecFwk::LifeCycle::Event::UNDEFINED;
717 break;
718 default:
719 return OHOS::AppExecFwk::LifeCycle::Event::ON_ACTIVE;
720 break;
721 }
722 }
723
GetParamElementName()724 std::shared_ptr<OHOS::AppExecFwk::ElementName> GetParamElementName()
725 {
726 if (GetBoolParam()) {
727 return make_shared<OHOS::AppExecFwk::ElementName>(GetStringParam(), GetStringParam(), GetStringParam());
728 } else {
729 return make_shared<OHOS::AppExecFwk::ElementName>();
730 }
731 }
732
GetParamWantParams()733 std::shared_ptr<OHOS::AAFwk::WantParams> GetParamWantParams()
734 {
735 return make_shared<OHOS::AAFwk::WantParams>();
736 }
737
GetParamAbilityManager()738 std::shared_ptr<OHOS::AppExecFwk::AbilityManager> GetParamAbilityManager()
739 {
740 return make_shared<OHOS::AppExecFwk::AbilityManager>();
741 }
742
GetParamPatternsMatcher()743 OHOS::AAFwk::PatternsMatcher GetParamPatternsMatcher()
744 {
745 return OHOS::AAFwk::PatternsMatcher();
746 }
747
GetParamMatchType()748 OHOS::AAFwk::MatchType GetParamMatchType()
749 {
750 switch (GetIntParam() % 4) {
751 case 0:
752 return OHOS::AAFwk::MatchType::DEFAULT;
753 break;
754 case 1:
755 return OHOS::AAFwk::MatchType::PREFIX;
756 break;
757 case 2:
758 return OHOS::AAFwk::MatchType::PATTERN;
759 break;
760 case 3:
761 return OHOS::AAFwk::MatchType::GLOBAL;
762 break;
763 default:
764 return OHOS::AAFwk::MatchType::DEFAULT;
765 break;
766 }
767 }
768
GetParamBundleMgrProxy()769 std::shared_ptr<OHOS::AppExecFwk::BundleMgrProxy> GetParamBundleMgrProxy()
770 {
771 return make_shared<OHOS::AppExecFwk::BundleMgrProxy>(GetParamSptrRemote());
772 }
773
GetParamApplicationFlag()774 OHOS::AppExecFwk::ApplicationFlag GetParamApplicationFlag()
775 {
776 if (GetBoolParam()) {
777 return OHOS::AppExecFwk::ApplicationFlag::GET_BASIC_APPLICATION_INFO;
778 } else {
779 return OHOS::AppExecFwk::ApplicationFlag::GET_APPLICATION_INFO_WITH_PERMISSION;
780 }
781 }
782
GetParamApplicationInfo()783 OHOS::AppExecFwk::ApplicationInfo GetParamApplicationInfo()
784 {
785 return OHOS::AppExecFwk::ApplicationInfo();
786 }
787
GetParamApplicationInfoVector()788 std::vector<OHOS::AppExecFwk::ApplicationInfo> GetParamApplicationInfoVector()
789 {
790 vector<OHOS::AppExecFwk::ApplicationInfo> param;
791 size_t len = GenRandom(0, 255);
792 while (len--) {
793 OHOS::AppExecFwk::ApplicationInfo t = GetParamApplicationInfo();
794 param.push_back(t);
795 }
796 cout << "ApplicationInfo vector param length is: " << param.size() << endl;
797 return param;
798 }
799
GetParamBundleFlag()800 OHOS::AppExecFwk::BundleFlag GetParamBundleFlag()
801 {
802 if (GetBoolParam()) {
803 return OHOS::AppExecFwk::BundleFlag::GET_BUNDLE_DEFAULT;
804 } else {
805 return OHOS::AppExecFwk::BundleFlag::GET_BUNDLE_WITH_ABILITIES;
806 }
807 }
808
GetParamBundleInfo()809 OHOS::AppExecFwk::BundleInfo GetParamBundleInfo()
810 {
811 return OHOS::AppExecFwk::BundleInfo();
812 }
813
GetParamHapModuleInfo()814 OHOS::AppExecFwk::HapModuleInfo GetParamHapModuleInfo()
815 {
816 return OHOS::AppExecFwk::HapModuleInfo();
817 }
818
GetParamPermissionDef()819 OHOS::AppExecFwk::PermissionDef GetParamPermissionDef()
820 {
821 return OHOS::AppExecFwk::PermissionDef();
822 }
823
GetParamPermissionDefVector()824 std::vector<OHOS::AppExecFwk::PermissionDef> GetParamPermissionDefVector()
825 {
826 vector<OHOS::AppExecFwk::PermissionDef> param;
827 size_t len = GenRandom(0, 255);
828 while (len--) {
829 OHOS::AppExecFwk::PermissionDef t = GetParamPermissionDef();
830 param.push_back(t);
831 }
832 cout << "PermissionDef vector param length is: " << param.size() << endl;
833 return param;
834 }
835
GetParamIBundleMgrMessage()836 OHOS::AppExecFwk::IBundleMgr::Message GetParamIBundleMgrMessage()
837 {
838 return (OHOS::AppExecFwk::IBundleMgr::Message)(GetIntParam() % 36);
839 }
840
GetParamMessageParcel()841 OHOS::MessageParcel GetParamMessageParcel()
842 {
843 return OHOS::MessageParcel();
844 }
845
GetParamDumpFlag()846 OHOS::AppExecFwk::DumpFlag GetParamDumpFlag()
847 {
848 switch (GetIntParam() % 3) {
849 case 0:
850 return OHOS::AppExecFwk::DumpFlag::DUMP_BUNDLE_LIST;
851 break;
852 case 1:
853 return OHOS::AppExecFwk::DumpFlag::DUMP_ALL_BUNDLE_INFO;
854 break;
855 case 2:
856 return OHOS::AppExecFwk::DumpFlag::DUMP_BUNDLE_INFO;
857 break;
858 default:
859 return OHOS::AppExecFwk::DumpFlag::DUMP_BUNDLE_LIST;
860 break;
861 }
862 }
863
GetParamICleanCacheCallback()864 sptr<OHOS::AppExecFwk::ICleanCacheCallback> GetParamICleanCacheCallback()
865 {
866 return sptr<TestICleanCacheCallback>();
867 }
868
GetParamIBundleStatusCallback()869 sptr<OHOS::AppExecFwk::IBundleStatusCallback> GetParamIBundleStatusCallback()
870 {
871 return sptr<TestIBundleStatusCallback>();
872 }
873
GetParamDataAbilityHelper()874 std::shared_ptr<OHOS::AppExecFwk::DataAbilityHelper>GetParamDataAbilityHelper()
875 {
876 return OHOS::AppExecFwk::DataAbilityHelper::Creator(std::make_shared<OHOS::AppExecFwk::Ability>());
877 }
878
879 } // namespace EventFwk
880 } // namespace OHOS
881