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 16 #include "gtest/gtest.h" 17 18 #include "init_param.h" 19 #include "init_utils.h" 20 #include "parameter.h" 21 #include "param_comm.h" 22 #include "param_stub.h" 23 #ifndef OHOS_LITE 24 #include "param_wrapper.h" 25 #include "parameters.h" 26 #endif 27 #include "sysversion.h" 28 #include "sysparam_errno.h" 29 30 using namespace testing::ext; 31 32 namespace OHOS { 33 constexpr int TEST_VALUE = 101; 34 class SysparaUnitTest : public testing::Test { 35 public: SetUpTestCase()36 static void SetUpTestCase() {} TearDownTestCase()37 static void TearDownTestCase() {} SetUp()38 void SetUp() 39 { 40 SetTestPermissionResult(0); 41 } TearDown()42 void TearDown() {} 43 }; 44 45 HWTEST_F(SysparaUnitTest, parameterTest001, TestSize.Level0) 46 { 47 const char *deviceType = GetDeviceType(); 48 printf("Device type =%s\n", deviceType); 49 EXPECT_STRNE(deviceType, nullptr); 50 const char *manufacture = GetManufacture(); 51 printf("Manufacture =%s\n", manufacture); 52 EXPECT_STRNE(manufacture, nullptr); 53 const char *brand = GetBrand(); 54 printf("GetBrand =%s\n", brand); 55 EXPECT_STRNE(brand, nullptr); 56 const char *marketName = GetMarketName(); 57 printf("MarketName =%s\n", marketName); 58 EXPECT_STRNE(marketName, nullptr); 59 const char *productSeries = GetProductSeries(); 60 printf("ProductSeries =%s\n", productSeries); 61 EXPECT_STRNE(productSeries, nullptr); 62 const char *productModel = GetProductModel(); 63 printf("ProductModel =%s\n", GetProductModel()); 64 EXPECT_STRNE(productModel, nullptr); 65 const char *roductModelAlias = GetProductModelAlias(); 66 printf("ProductModelAlias =%s\n", roductModelAlias); 67 EXPECT_STRNE(roductModelAlias, nullptr); 68 const char *softwareModel = GetSoftwareModel(); 69 printf("SoftwareModel =%s\n", softwareModel); 70 EXPECT_STRNE(softwareModel, nullptr); 71 const char *hardwareModel = GetHardwareModel(); 72 printf("HardwareModel =%s\n", hardwareModel); 73 EXPECT_STRNE(hardwareModel, nullptr); 74 const char *softwareProfile = GetHardwareProfile(); 75 printf("Software profile =%s\n", softwareProfile); 76 EXPECT_STRNE(softwareProfile, nullptr); 77 const char *serial = GetSerial(); 78 printf("Serial =%s\n", serial); 79 EXPECT_STRNE(serial, nullptr); 80 const char *osFullName = GetOSFullName(); 81 printf("OS full name =%s\n", osFullName); 82 EXPECT_STRNE(osFullName, nullptr); 83 const char *osReleaseType = GetOsReleaseType(); 84 printf("OS Release type =%s\n", osReleaseType); 85 EXPECT_STRNE(osReleaseType, nullptr); 86 const char *displayVersion = GetDisplayVersion(); 87 printf("Display version =%s\n", displayVersion); 88 EXPECT_STRNE(displayVersion, nullptr); 89 const char *bootloaderVersion = GetBootloaderVersion(); 90 printf("bootloader version =%s\n", bootloaderVersion); 91 EXPECT_STRNE(bootloaderVersion, nullptr); 92 const char *securePatchLevel = GetSecurityPatchTag(); 93 printf("secure patch level =%s\n", securePatchLevel); 94 EXPECT_STRNE(securePatchLevel, nullptr); 95 } 96 97 HWTEST_F(SysparaUnitTest, parameterTest001_1, TestSize.Level0) 98 { 99 const char *securePatchLevel = GetSecurityPatchTag(); 100 printf("secure patch level =%s\n", securePatchLevel); 101 EXPECT_STRNE(securePatchLevel, nullptr); 102 const char *abiList = GetAbiList(); 103 printf("abi list =%s\n", abiList); 104 EXPECT_STRNE(abiList, nullptr); 105 int firstApiVersion = GetFirstApiVersion(); 106 printf("first api version =%d\n", firstApiVersion); 107 EXPECT_NE(firstApiVersion, -1); 108 int sdkApiVersion = GetSdkApiVersion(); 109 printf("SDK api version =%d\n", sdkApiVersion); 110 EXPECT_NE(sdkApiVersion, -1); 111 const char *incrementalVersion = GetIncrementalVersion(); 112 printf("Incremental version = %s\n", incrementalVersion); 113 EXPECT_STRNE(incrementalVersion, nullptr); 114 const char *formalId = GetVersionId(); 115 printf("formal id =%s\n", formalId); 116 EXPECT_STRNE(formalId, nullptr); 117 const char *buildType = GetBuildType(); 118 printf("build type =%s\n", buildType); 119 EXPECT_STRNE(buildType, nullptr); 120 const char *buildUser = GetBuildUser(); 121 printf("build user =%s\n", buildUser); 122 EXPECT_STRNE(buildUser, nullptr); 123 const char *buildHost = GetBuildHost(); 124 printf("Build host = %s\n", buildHost); 125 EXPECT_STRNE(buildHost, nullptr); 126 const char *buildTime = GetBuildTime(); 127 printf("build time =%s\n", buildTime); 128 EXPECT_STRNE(buildTime, nullptr); 129 const char *buildRootLater = GetBuildRootHash(); 130 printf("build root later..., %s\n", buildRootLater); 131 EXPECT_STRNE(buildRootLater, nullptr); 132 } 133 134 HWTEST_F(SysparaUnitTest, parameterTest001_2, TestSize.Level0) 135 { 136 EXPECT_STRNE(GetDeviceType(), nullptr); 137 EXPECT_STRNE(GetManufacture(), nullptr); 138 EXPECT_STRNE(GetBrand(), nullptr); 139 EXPECT_STRNE(GetMarketName(), nullptr); 140 EXPECT_STRNE(GetProductSeries(), nullptr); 141 EXPECT_STRNE(GetProductModel(), nullptr); 142 EXPECT_STRNE(GetProductModelAlias(), nullptr); 143 EXPECT_STRNE(GetSoftwareModel(), nullptr); 144 EXPECT_STRNE(GetHardwareModel(), nullptr); 145 EXPECT_STRNE(GetHardwareProfile(), nullptr); 146 EXPECT_STRNE(GetOSFullName(), nullptr); 147 EXPECT_STRNE(GetOsReleaseType(), nullptr); 148 EXPECT_STRNE(GetDisplayVersion(), nullptr); 149 EXPECT_STRNE(GetBootloaderVersion(), nullptr); 150 EXPECT_STRNE(GetSecurityPatchTag(), nullptr); 151 } 152 153 HWTEST_F(SysparaUnitTest, parameterTest001_3, TestSize.Level0) 154 { 155 EXPECT_STRNE(GetSecurityPatchTag(), nullptr); 156 EXPECT_STRNE(GetAbiList(), nullptr); 157 EXPECT_GT(GetFirstApiVersion(), 0); 158 EXPECT_GT(GetSdkApiVersion(), 0); 159 EXPECT_STRNE(GetIncrementalVersion(), nullptr); 160 EXPECT_STRNE(GetVersionId(), nullptr); 161 EXPECT_STRNE(GetBuildType(), nullptr); 162 EXPECT_STRNE(GetBuildUser(), nullptr); 163 EXPECT_STRNE(GetBuildHost(), nullptr); 164 EXPECT_STRNE(GetBuildTime(), nullptr); 165 EXPECT_STRNE(GetBuildRootHash(), nullptr); 166 } 167 168 HWTEST_F(SysparaUnitTest, parameterTest002, TestSize.Level0) 169 { 170 char key1[] = "test.ro.sys.version"; 171 char value1[] = "set read only key"; 172 int ret = SetParameter(key1, value1); 173 EXPECT_EQ(ret, EC_SUCCESS); 174 ret = SetParameter(nullptr, nullptr); 175 EXPECT_EQ(ret, EC_INVALID); 176 } 177 178 HWTEST_F(SysparaUnitTest, parameterTest003, TestSize.Level0) 179 { 180 char key2[] = "rw.sys.version*%version"; 181 char value2[] = "set value with illegal key"; 182 int ret = SetParameter(key2, value2); 183 EXPECT_EQ(ret, EC_INVALID); 184 } 185 186 /* key = 32 */ 187 HWTEST_F(SysparaUnitTest, parameterTest004, TestSize.Level0) 188 { 189 char key3[] = "rw.sys.version.utilskvparameter0"; 190 char value3[] = "set with key = 32"; 191 int ret = SetParameter(key3, value3); 192 EXPECT_EQ(ret, EC_SUCCESS); 193 } 194 195 /* value > 128 */ 196 HWTEST_F(SysparaUnitTest, parameterTest005, TestSize.Level0) 197 { 198 char key4[] = "rw.sys.version.version"; 199 char value4[] = "rw.sys.version.version.version.version flash_offset = *(hi_u32 *)DT_SetGetU32(&g_Element[0], 0)a\ 200 size = *(hi_u32 *)DT_SetGetU32(&g_Element[1], 0)a"; 201 int ret = SetParameter(key4, value4); 202 EXPECT_EQ(ret, SYSPARAM_INVALID_VALUE); 203 } 204 205 HWTEST_F(SysparaUnitTest, parameterTest006, TestSize.Level0) 206 { 207 char key1[] = "rw.product.not.exist"; 208 char value1[64] = {0}; 209 char defValue1[] = "value of key not exist..."; 210 int ret = GetParameter(key1, defValue1, value1, 64); 211 EXPECT_EQ(ret, static_cast<int>(strlen(defValue1))); 212 } 213 214 HWTEST_F(SysparaUnitTest, parameterTest007, TestSize.Level0) 215 { 216 char key2[] = "rw.sys.version.version.version.version"; 217 char value2[64] = {0}; 218 char defValue2[] = "value of key > 32 ..."; 219 int ret = GetParameter(key2, defValue2, value2, 64); 220 EXPECT_EQ(ret, static_cast<int>(strlen(defValue2))); 221 } 222 223 HWTEST_F(SysparaUnitTest, parameterTest008, TestSize.Level0) 224 { 225 char key4[] = "test.rw.sys.version"; 226 char* value4 = nullptr; 227 char defValue3[] = "value of key > 32 ..."; 228 int ret = GetParameter(key4, defValue3, value4, 0); 229 EXPECT_EQ(ret, EC_INVALID); 230 } 231 232 HWTEST_F(SysparaUnitTest, parameterTest009, TestSize.Level0) 233 { 234 char key5[] = "test.rw.product.type.2222222"; 235 char value5[] = "rw.sys.version.version.version.version \ 236 flash_offset = *(hi_u32 *)DT_SetGetU32(&g_Element[0], 0)"; 237 int ret = SetParameter(key5, value5); 238 EXPECT_EQ(ret, SYSPARAM_INVALID_VALUE); 239 char valueGet[2] = {0}; 240 char defValue3[] = "value of key > 32 ..."; 241 ret = GetParameter(key5, defValue3, valueGet, 2); 242 EXPECT_EQ(ret, EC_INVALID); 243 } 244 245 HWTEST_F(SysparaUnitTest, parameterTest0010, TestSize.Level0) 246 { 247 char key1[] = "test.rw.sys.version"; 248 char value1[] = "10.1.0"; 249 int ret = SetParameter(key1, value1); 250 EXPECT_EQ(ret, 0); 251 ret = SystemWriteParam(key1, value1); 252 EXPECT_EQ(ret, 0); 253 char valueGet1[32] = {0}; 254 ret = GetParameter(key1, "version=10.1.0", valueGet1, 32); 255 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet1))); 256 257 char key2[] = "test.rw.product.type"; 258 char value2[] = "wifi_iot"; 259 ret = SetParameter(key2, value2); 260 EXPECT_EQ(ret, 0); 261 ret = SystemWriteParam(key2, value2); 262 EXPECT_EQ(ret, 0); 263 char valueGet2[32] = {0}; 264 ret = GetParameter(key2, "version=10.1.0", valueGet2, 32); 265 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet2))); 266 267 char key3[] = "test.rw.product.manufacturer"; 268 char value3[] = "TEST MANUFACTURER"; 269 ret = SetParameter(key3, value3); 270 EXPECT_EQ(ret, 0); 271 ret = SystemWriteParam(key3, value3); 272 EXPECT_EQ(ret, 0); 273 char valueGet3[32] = {0}; 274 ret = GetParameter(key3, "version=10.1.0", valueGet3, 32); 275 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet3))); 276 277 char key4[] = "test.rw.product.marketname"; 278 char value4[] = "TEST MARKETNAME"; 279 ret = SetParameter(key4, value4); 280 EXPECT_EQ(ret, 0); 281 ret = SystemWriteParam(key4, value4); 282 EXPECT_EQ(ret, 0); 283 char valueGet4[32] = {0}; 284 ret = GetParameter(key4, "version=10.1.0", valueGet4, 32); 285 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet4))); 286 } 287 288 HWTEST_F(SysparaUnitTest, parameterTest0011, TestSize.Level0) 289 { 290 char key1[] = "test.rw.sys.version.wait1"; 291 char value1[] = "10.1.0"; 292 int ret = SetParameter(key1, value1); 293 EXPECT_EQ(ret, 0); 294 ret = SystemWriteParam(key1, value1); 295 EXPECT_EQ(ret, 0); 296 ret = WaitParameter(key1, value1, 10); 297 EXPECT_EQ(ret, 0); 298 ret = WaitParameter(key1, "*", 10); 299 EXPECT_EQ(ret, 0); 300 char key2[] = "test.rw.sys.version.wait2"; 301 ret = WaitParameter(key2, "*", 1); 302 EXPECT_EQ(ret, SYSPARAM_WAIT_TIMEOUT); 303 } 304 305 HWTEST_F(SysparaUnitTest, parameterTest0012, TestSize.Level0) 306 { 307 char key1[] = "test.rw.sys.version.version1"; 308 char value1[] = "10.1.0"; 309 int ret = SetParameter(key1, value1); 310 EXPECT_EQ(ret, 0); 311 312 ret = SystemWriteParam(key1, value1); 313 EXPECT_EQ(ret, 0); 314 // success 315 unsigned int handle = FindParameter(key1); 316 EXPECT_NE(handle, static_cast<unsigned int>(-1)); 317 char valueGet1[32] = {0}; 318 ret = GetParameterValue(handle, valueGet1, 32); 319 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet1))); 320 char nameGet1[32] = {0}; 321 ret = GetParameterName(handle, nameGet1, 32); 322 EXPECT_EQ(ret, static_cast<int>(strlen(nameGet1))); 323 324 // fail 325 char key2[] = "test.rw.sys.version.version2"; 326 handle = FindParameter(key2); 327 EXPECT_EQ(handle, static_cast<unsigned int>(-1)); 328 ret = GetParameterValue(handle, valueGet1, 32); 329 EXPECT_EQ(ret, SYSPARAM_NOT_FOUND); 330 ret = GetParameterName(handle, nameGet1, 32); 331 EXPECT_EQ(ret, SYSPARAM_NOT_FOUND); 332 ret = GetParameterValue(handle, nullptr, 32); 333 EXPECT_EQ(ret, EC_INVALID); 334 ret = GetParameterCommitId(handle); 335 EXPECT_EQ(ret, -1); 336 } 337 338 HWTEST_F(SysparaUnitTest, parameterTest0013, TestSize.Level0) 339 { 340 long long int out = 0; 341 unsigned long long int uout = 0; 342 GetParameter_(nullptr, nullptr, nullptr, 0); 343 EXPECT_EQ(GetIntParameter("test.int.get", 0) == -TEST_VALUE, 1); 344 EXPECT_EQ(GetUintParameter("test.int.get", 0), 0); 345 EXPECT_EQ(GetIntParameter("test.uint.get", 0), TEST_VALUE); 346 EXPECT_EQ(GetUintParameter("test.uint.get", 0), TEST_VALUE); 347 EXPECT_EQ(GetIntParameter("test.int.default", 10), 10); // key not find,value = default 348 EXPECT_EQ(GetUintParameter("test.uint.default", 10), 10); // key not find,value = default 349 EXPECT_EQ(IsValidParamValue(nullptr, 0), 0); 350 EXPECT_EQ(IsValidParamValue("testvalue", strlen("testvalue") + 1), 1); 351 EXPECT_EQ(StringToLL("0x11", &out), 0); 352 EXPECT_EQ(StringToULL("0x11", &uout), 0); 353 EXPECT_EQ(StringToLL("not vailed", &out), -1); 354 EXPECT_EQ(StringToULL("not vailed", &uout), -1); 355 char udid[UDID_LEN] = {0}; 356 GetDevUdid(udid, UDID_LEN); 357 EXPECT_NE(GetMajorVersion(), 0); 358 int ret = GetDevUdid(nullptr, UDID_LEN); 359 EXPECT_EQ(ret, EC_FAILURE); 360 GetSeniorVersion(); 361 GetFeatureVersion(); 362 GetBuildVersion(); 363 } 364 365 #ifndef OHOS_LITE 366 // for test param_wrapper.cpp 367 HWTEST_F(SysparaUnitTest, parameterTest0014, TestSize.Level0) 368 { 369 const std::string key1 = "test.int.get"; 370 OHOS::system::SetParameter(std::string("testKey"), std::string("testValue")); 371 int v = OHOS::system::GetIntParameter(key1, 0); 372 EXPECT_EQ(v, -TEST_VALUE); 373 int8_t v1 = OHOS::system::GetIntParameter(key1, 0, -127, 128); // -127, 128 range 374 EXPECT_EQ(v1, -TEST_VALUE); 375 int16_t v2 = OHOS::system::GetIntParameter(key1, 0, -127, 128); // -127, 128 range 376 EXPECT_EQ(v2, -TEST_VALUE); 377 int32_t v3 = OHOS::system::GetIntParameter(key1, 0, -127, 128); // -127, 128 range 378 EXPECT_EQ(v3, -TEST_VALUE); 379 int64_t v4 = OHOS::system::GetIntParameter(key1, 0, -127, 128); // -127, 128 range 380 EXPECT_EQ(v4, -TEST_VALUE); 381 382 int8_t v5 = OHOS::system::GetIntParameter(key1, 0, -10, 10); // -10, 10 range 383 EXPECT_EQ(v5, 0); 384 385 const std::string key2 = "test.uint.get"; 386 uint8_t u1 = OHOS::system::GetUintParameter<uint8_t>(key2, 0, (uint8_t)255); // 255 max value 387 EXPECT_EQ(u1, TEST_VALUE); 388 uint16_t u2 = OHOS::system::GetUintParameter<uint16_t>(key2, 0, (uint16_t)255); // 255 max value 389 EXPECT_EQ(u2, TEST_VALUE); 390 uint32_t u3 = OHOS::system::GetUintParameter<uint32_t>(key2, 0, (uint32_t)255); // 255 max value 391 EXPECT_EQ(u3, TEST_VALUE); 392 uint64_t u4 = OHOS::system::GetUintParameter<uint64_t>(key2, 0, (uint64_t)255); // 255 max value 393 EXPECT_EQ(u4 == TEST_VALUE, 1); 394 const std::string key3 = "test.uint.get3"; 395 u1 = OHOS::system::GetUintParameter<uint8_t>(key3, 0, (uint8_t)255); // 255 max value 396 EXPECT_EQ(u1, 0); 397 u1 = OHOS::system::GetUintParameter<uint8_t>(key2, 0, (uint8_t)10); // 10 max value 398 EXPECT_EQ(u1, 0); 399 } 400 401 HWTEST_F(SysparaUnitTest, parameterTest0015, TestSize.Level0) 402 { 403 std::string type = OHOS::system::GetDeviceType(); 404 printf("device type %s \n", type.c_str()); 405 406 const std::string key1 = "test.string.get"; 407 std::string v1 = OHOS::system::GetParameter(key1, ""); 408 EXPECT_EQ(strcmp(v1.c_str(), "101"), 0); 409 410 const std::string key2 = "test.string.get2"; 411 v1 = OHOS::system::GetParameter(key2, "test2"); 412 EXPECT_EQ(strcmp(v1.c_str(), "test2"), 0); 413 414 int ret = OHOS::system::GetStringParameter(key1, v1, ""); 415 EXPECT_EQ(ret, 0); 416 EXPECT_EQ(strcmp(v1.c_str(), "101"), 0); 417 ret = OHOS::system::GetStringParameter(key2, v1, "test2"); 418 EXPECT_EQ(ret, 0); 419 EXPECT_EQ(strcmp(v1.c_str(), "test2"), 0); 420 } 421 422 HWTEST_F(SysparaUnitTest, parameterTest0016, TestSize.Level0) 423 { 424 const std::string key1 = "test.bool.get.true"; 425 bool ret = OHOS::system::GetBoolParameter(key1, false); 426 EXPECT_EQ(ret, true); 427 const std::string key2 = "test.bool.get.false"; 428 ret = OHOS::system::GetBoolParameter(key2, true); 429 EXPECT_EQ(ret, false); 430 const std::string key3 = "test.bool.get3"; 431 ret = OHOS::system::GetBoolParameter(key3, false); 432 EXPECT_EQ(ret, false); 433 } 434 435 HWTEST_F(SysparaUnitTest, parameterTest0017, TestSize.Level0) 436 { 437 printf("distributionOS name =%s\n", GetDistributionOSName()); 438 EXPECT_STRNE(GetDistributionOSName(), nullptr); 439 printf("distributionOS version =%s\n", GetDistributionOSVersion()); 440 EXPECT_STRNE(GetDistributionOSVersion(), nullptr); 441 printf("distributionOS api version =%d\n", GetDistributionOSApiVersion()); 442 EXPECT_GT(GetDistributionOSApiVersion(), 0); 443 printf("distributionOS name =%s\n", GetDistributionOSReleaseType()); 444 EXPECT_STRNE(GetDistributionOSReleaseType(), nullptr); 445 printf("distributionOS name =%s\n", GetDistributionOSApiName()); 446 } 447 #endif 448 449 HWTEST_F(SysparaUnitTest, parameterTest0018, TestSize.Level0) 450 { 451 char key1[] = "test.ro.sys.version"; 452 char value1[] = "set read only key"; 453 int ret = SetParameter(key1, value1); 454 EXPECT_EQ(ret, EC_SUCCESS); 455 char key2[] = "persist.test.ro.sys.version"; 456 char value2[] = "set persist read only key"; 457 ret = SetParameter(key2, value2); 458 EXPECT_EQ(ret, EC_SUCCESS); 459 ret = SaveParameters(); 460 EXPECT_EQ(ret, 0); 461 } 462 } // namespace OHOS 463