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 <cfloat>
16 #include <chrono>
17 #include <climits>
18 #include <functional>
19 #include <iostream>
20 #include <random>
21 #include "../include/getparam.h"
22
23 using namespace std;
24 namespace OHOS {
25 namespace AccountSA {
26 const int ACCOUNT_FUZZ_BOOL = 2;
27 const int ACCOUNT_FUZZ_CHAR_LEFT = -128;
28 const int ACCOUNT_FUZZ_CHAR_RIGHT = 127;
29 const int INDEX_ZERO = 0;
30 const int INDEX_ONE = 1;
31 const int INDEX_TWO = 2;
32 const int INDEX_THREE = 3;
33 const size_t RANDOM_MIN = 0;
34 const size_t RANDOM_MAX = 255;
35
GetBoolParam()36 bool GetBoolParam()
37 {
38 bool param = false;
39 if (GetIntParam() % ACCOUNT_FUZZ_BOOL == 0) {
40 param = true;
41 }
42 cout << "Bool param is: " << param << endl;
43 return param;
44 }
45
GenRandom(size_t min,size_t max)46 size_t GenRandom(size_t min, size_t max)
47 {
48 std::random_device rd;
49 static uniform_int_distribution<size_t> u(min, max);
50 static default_random_engine e(rd());
51 size_t param = u(e);
52 return param;
53 }
54
GetS8Param()55 int8_t GetS8Param()
56 {
57 std::random_device rd;
58 static uniform_int_distribution<int8_t> u(INT8_MIN, INT8_MAX);
59 static default_random_engine e(rd());
60 int8_t param = u(e);
61 cout << "Int8_t param is: " << param << endl;
62 return param;
63 }
64
GetS16Param()65 int16_t GetS16Param()
66 {
67 std::random_device rd;
68 static uniform_int_distribution<int16_t> u(INT16_MIN, INT16_MAX);
69 static default_random_engine e(rd());
70 int16_t param = u(e);
71 cout << "Int16_t param is: " << param << endl;
72 return param;
73 }
74
GetS32Param()75 int32_t GetS32Param()
76 {
77 std::random_device rd;
78 static uniform_int_distribution<int32_t> u(INT32_MIN, INT32_MAX);
79 static default_random_engine e(rd());
80 int32_t param = u(e);
81 cout << "Int32_t param is: " << param << endl;
82 return param;
83 }
84
GetS64Param()85 int64_t GetS64Param()
86 {
87 std::random_device rd;
88 static uniform_int_distribution<int64_t> u(INT64_MIN, INT64_MAX);
89 static default_random_engine e(rd());
90 int64_t param = u(e);
91 cout << "Int64_t param is: " << param << endl;
92 return param;
93 }
94
95 template<class T>
GetUnsignParam()96 T GetUnsignParam()
97 {
98 std::random_device rd;
99 static uniform_int_distribution<T> u;
100 static default_random_engine e(rd());
101 T param = u(e);
102 return param;
103 }
104
GetSizeTParam()105 size_t GetSizeTParam()
106 {
107 size_t param = GetUnsignParam<size_t>();
108 return param;
109 }
110
GetU8Param()111 uint8_t GetU8Param()
112 {
113 uint8_t param = GetUnsignParam<uint8_t>();
114 cout << "Uint8_t param is: " << param << endl;
115 return param;
116 }
117
GetUIntParam()118 unsigned int GetUIntParam()
119 {
120 unsigned int param = GetUnsignParam<unsigned int>();
121 cout << "Unsigned int param is: " << param << endl;
122 return param;
123 }
124
GetU16Param()125 uint16_t GetU16Param()
126 {
127 uint16_t param = GetUnsignParam<uint16_t>();
128 cout << "Uint16_t param is: " << param << endl;
129 return param;
130 }
131
GetU32Param()132 uint32_t GetU32Param()
133 {
134 uint32_t param = GetUnsignParam<uint32_t>();
135 cout << "Uint32_t param is: " << param << endl;
136 return param;
137 }
138
GetU64Param()139 uint64_t GetU64Param()
140 {
141 uint64_t param = GetUnsignParam<uint64_t>();
142 cout << "Uint64_t param is: " << param << endl;
143 return param;
144 }
145
GetShortParam()146 short GetShortParam()
147 {
148 std::random_device rd;
149 static uniform_int_distribution<short> u(SHRT_MIN, SHRT_MAX);
150 static default_random_engine e(rd());
151 short param = u(e);
152 cout << "Short param is: " << param << endl;
153 return param;
154 }
155
GetLongParam()156 long GetLongParam()
157 {
158 std::random_device rd;
159 static uniform_int_distribution<long> u(LONG_MIN, LONG_MAX);
160 static default_random_engine e(rd());
161 long param = u(e);
162 cout << "Long param is: " << param << endl;
163 return param;
164 }
165
GetIntParam()166 int GetIntParam()
167 {
168 std::random_device rd;
169 static uniform_int_distribution<> u(INT_MIN, INT_MAX);
170 static default_random_engine e(rd());
171 int param = u(e);
172 cout << "Int param is: " << param << endl;
173 return param;
174 }
175
GetDoubleParam()176 double GetDoubleParam()
177 {
178 double param = 0;
179 std::random_device rd;
180 static uniform_real_distribution<double> u(DBL_MIN, DBL_MAX);
181 static default_random_engine e(rd());
182 param = u(e);
183 cout << "double param is: " << param << endl;
184 return param;
185 }
186
GetFloatParam()187 float GetFloatParam()
188 {
189 float param = 0;
190 std::random_device rd;
191 static uniform_real_distribution<float> u(FLT_MIN, FLT_MAX);
192 static default_random_engine e(rd());
193 param = u(e);
194 cout << "Float param is: " << param << endl;
195 return param;
196 }
197
GetCharParam()198 char GetCharParam()
199 {
200 std::random_device rd;
201 static uniform_int_distribution<> u(ACCOUNT_FUZZ_CHAR_LEFT, ACCOUNT_FUZZ_CHAR_RIGHT);
202 static default_random_engine e(rd());
203 char param = u(e);
204 return param;
205 }
206
GetStringParam()207 string GetStringParam()
208 {
209 string param = "";
210 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
211 while (len--) {
212 param += GetCharParam();
213 }
214 cout << "String param length is: " << param.length() << endl;
215 return param;
216 }
217
218 template<class T>
GetUnsignVectorParam()219 vector<T> GetUnsignVectorParam()
220 {
221 vector<T> param;
222 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
223 while (len--) {
224 T t = GetUnsignParam<T>();
225 param.push_back(t);
226 }
227 cout << "Uint vector param length is: " << param.size() << endl;
228 return param;
229 }
230
231 template<class T>
GetClassParam()232 T GetClassParam()
233 {
234 T param;
235 return param;
236 }
237
GetBoolVectorParam()238 std::vector<bool> GetBoolVectorParam()
239 {
240 vector<bool> param;
241 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
242 while (len--) {
243 int t = GetBoolParam();
244 param.push_back(t);
245 }
246 cout << "Bool vector param length is: " << param.size() << endl;
247 return param;
248 }
249
GetShortVectorParam()250 std::vector<short> GetShortVectorParam()
251 {
252 vector<short> param;
253 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
254 while (len--) {
255 short t = GetShortParam();
256 param.push_back(t);
257 }
258 cout << "Short vector param length is: " << param.size() << endl;
259 return param;
260 }
261
GetLongVectorParam()262 std::vector<long> GetLongVectorParam()
263 {
264 vector<long> param;
265 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
266 while (len--) {
267 long t = GetLongParam();
268 param.push_back(t);
269 }
270 cout << "Long vector param length is: " << param.size() << endl;
271 return param;
272 }
273
GetIntVectorParam()274 vector<int> GetIntVectorParam()
275 {
276 vector<int> param;
277 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
278 while (len--) {
279 int t = GetIntParam();
280 param.push_back(t);
281 }
282 cout << "Int vector param length is: " << param.size() << endl;
283 return param;
284 }
285
GetFloatVectorParam()286 std::vector<float> GetFloatVectorParam()
287 {
288 vector<float> param;
289 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
290 while (len--) {
291 float t = GetIntParam();
292 param.push_back(t);
293 }
294 cout << "Float vector param length is: " << param.size() << endl;
295 return param;
296 }
297
GetDoubleVectorParam()298 std::vector<double> GetDoubleVectorParam()
299 {
300 vector<double> param;
301 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
302 while (len--) {
303 double t = GetIntParam();
304 param.push_back(t);
305 }
306 cout << "Double vector param length is: " << param.size() << endl;
307 return param;
308 }
309
GetCharVectorParam()310 vector<char> GetCharVectorParam()
311 {
312 vector<char> param;
313 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
314 while (len--) {
315 char t = GetCharParam();
316 param.push_back(t);
317 }
318 cout << "Char vector param length is: " << param.size() << endl;
319 return param;
320 }
321
GetStringVectorParam()322 vector<string> GetStringVectorParam()
323 {
324 vector<string> param;
325 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
326 while (len--) {
327 string t = GetStringParam();
328 param.push_back(t);
329 }
330 cout << "String vector param length is: " << param.size() << endl;
331 return param;
332 }
333
GetS8VectorParam()334 vector<int8_t> GetS8VectorParam()
335 {
336 vector<int8_t> param;
337 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
338 while (len--) {
339 int8_t temp = GetS8Param();
340 param.push_back(temp);
341 }
342 cout << "Int8_t vector param length is: " << param.size() << endl;
343 return param;
344 }
345
GetS16VectorParam()346 vector<int16_t> GetS16VectorParam()
347 {
348 vector<int16_t> param;
349 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
350 while (len--) {
351 int16_t temp = GetS16Param();
352 param.push_back(temp);
353 }
354 cout << "Int16_t vector param length is: " << param.size() << endl;
355 return param;
356 }
357
GetS32VectorParam()358 vector<int32_t> GetS32VectorParam()
359 {
360 vector<int32_t> param;
361 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
362 while (len--) {
363 int32_t temp = GetS32Param();
364 param.push_back(temp);
365 }
366 cout << "Int32_t vector param length is: " << param.size() << endl;
367 return param;
368 }
369
GetS64VectorParam()370 vector<int64_t> GetS64VectorParam()
371 {
372 vector<int64_t> param;
373 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
374 while (len--) {
375 int64_t temp = GetS64Param();
376 param.push_back(temp);
377 }
378 cout << "Int32_t vector param length is: " << param.size() << endl;
379 return param;
380 }
381
GetParamAppAccountInfo()382 AppAccountInfo GetParamAppAccountInfo()
383 {
384 AppAccountInfo accountInfo(GetStringParam(), GetStringParam());
385 return accountInfo;
386 }
387
GetVectorParamAppAccountInfo()388 std::vector<AppAccountInfo> GetVectorParamAppAccountInfo()
389 {
390 std::vector<OHOS::AccountSA::AppAccountInfo> param;
391 size_t len = GenRandom(RANDOM_MIN, RANDOM_MAX);
392 while (len--) {
393 AppAccountInfo accInfo(GetStringParam(), GetStringParam());
394 param.push_back(accInfo);
395 }
396 cout << "Char vector param length is: " << param.size() << endl;
397 return param;
398 }
399
GetAppAccountSubscriber()400 std::shared_ptr<AppAccountSubscriber> GetAppAccountSubscriber()
401 {
402 return std::make_shared<TestAppAccountSubscriber>();
403 }
404
GetParamOsAccountType()405 OHOS::AccountSA::OsAccountType GetParamOsAccountType()
406 {
407 switch (GetIntParam() % INDEX_THREE) {
408 case INDEX_ZERO:
409 return OHOS::AccountSA::OsAccountType::ADMIN;
410 break;
411 case INDEX_ONE:
412 return OHOS::AccountSA::OsAccountType::NORMAL;
413 break;
414 case INDEX_TWO:
415 return OHOS::AccountSA::OsAccountType::GUEST;
416 break;
417 default:
418 return OHOS::AccountSA::OsAccountType::NORMAL;
419 break;
420 }
421 }
422
GetParamOsAccountInfo()423 OsAccountInfo GetParamOsAccountInfo()
424 {
425 if (GetBoolParam()) {
426 OsAccountInfo osAccountInfo;
427 return osAccountInfo;
428 } else {
429 OsAccountInfo osAccountInfo(GetIntParam(), GetStringParam(), GetParamOsAccountType(), GetS64Param());
430 return osAccountInfo;
431 }
432 }
433
GetParamDomainAccountInfo()434 DomainAccountInfo GetParamDomainAccountInfo()
435 {
436 if (GetBoolParam()) {
437 DomainAccountInfo domainAccountInfo;
438 return domainAccountInfo;
439 } else {
440 DomainAccountInfo domainAccountInfo(GetStringParam(), GetStringParam());
441 return domainAccountInfo;
442 }
443 }
444 } // namespace AccountSA
445 } // namespace OHOS