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