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 int sdkMinorApiVersion = GetSdkMinorApiVersion(); 112 printf("SDK MinorApi version =%d\n", sdkMinorApiVersion); 113 EXPECT_EQ((sdkMinorApiVersion >= -1), true); 114 int sdkPatchApiVersion = GetSdkPatchApiVersion(); 115 printf("SDK PatchApi version =%d\n", sdkPatchApiVersion); 116 EXPECT_EQ((sdkPatchApiVersion >= -1), true); 117 const char *incrementalVersion = GetIncrementalVersion(); 118 printf("Incremental version = %s\n", incrementalVersion); 119 EXPECT_STRNE(incrementalVersion, nullptr); 120 const char *formalId = GetVersionId(); 121 printf("formal id =%s\n", formalId); 122 EXPECT_STRNE(formalId, nullptr); 123 const char *buildType = GetBuildType(); 124 printf("build type =%s\n", buildType); 125 EXPECT_STRNE(buildType, nullptr); 126 const char *buildUser = GetBuildUser(); 127 printf("build user =%s\n", buildUser); 128 EXPECT_STRNE(buildUser, nullptr); 129 const char *buildHost = GetBuildHost(); 130 printf("Build host = %s\n", buildHost); 131 EXPECT_STRNE(buildHost, nullptr); 132 const char *buildTime = GetBuildTime(); 133 printf("build time =%s\n", buildTime); 134 EXPECT_STRNE(buildTime, nullptr); 135 const char *buildRootLater = GetBuildRootHash(); 136 printf("build root later..., %s\n", buildRootLater); 137 EXPECT_STRNE(buildRootLater, nullptr); 138 } 139 140 HWTEST_F(SysparaUnitTest, parameterTest001_2, TestSize.Level0) 141 { 142 EXPECT_STRNE(GetDeviceType(), nullptr); 143 EXPECT_STRNE(GetManufacture(), nullptr); 144 EXPECT_STRNE(GetBrand(), nullptr); 145 EXPECT_STRNE(GetMarketName(), nullptr); 146 EXPECT_STRNE(GetProductSeries(), nullptr); 147 EXPECT_STRNE(GetProductModel(), nullptr); 148 EXPECT_STRNE(GetProductModelAlias(), nullptr); 149 EXPECT_STRNE(GetSoftwareModel(), nullptr); 150 EXPECT_STRNE(GetHardwareModel(), nullptr); 151 EXPECT_STRNE(GetHardwareProfile(), nullptr); 152 EXPECT_STRNE(GetOSFullName(), nullptr); 153 EXPECT_STRNE(GetOsReleaseType(), nullptr); 154 EXPECT_STRNE(GetDisplayVersion(), nullptr); 155 EXPECT_STRNE(GetBootloaderVersion(), nullptr); 156 EXPECT_STRNE(GetSecurityPatchTag(), nullptr); 157 } 158 159 HWTEST_F(SysparaUnitTest, parameterTest001_3, TestSize.Level0) 160 { 161 EXPECT_STRNE(GetSecurityPatchTag(), nullptr); 162 EXPECT_STRNE(GetAbiList(), nullptr); 163 EXPECT_GT(GetFirstApiVersion(), 0); 164 EXPECT_GT(GetSdkApiVersion(), 0); 165 EXPECT_STRNE(GetIncrementalVersion(), nullptr); 166 EXPECT_STRNE(GetVersionId(), nullptr); 167 EXPECT_STRNE(GetBuildType(), nullptr); 168 EXPECT_STRNE(GetBuildUser(), nullptr); 169 EXPECT_STRNE(GetBuildHost(), nullptr); 170 EXPECT_STRNE(GetBuildTime(), nullptr); 171 EXPECT_STRNE(GetBuildRootHash(), nullptr); 172 } 173 174 HWTEST_F(SysparaUnitTest, parameterTest002, TestSize.Level0) 175 { 176 char key1[] = "test.ro.sys.version"; 177 char value1[] = "set read only key"; 178 int ret = SetParameter(key1, value1); 179 EXPECT_EQ(ret, EC_SUCCESS); 180 ret = SetParameter(nullptr, nullptr); 181 EXPECT_EQ(ret, EC_INVALID); 182 } 183 184 HWTEST_F(SysparaUnitTest, parameterTest003, TestSize.Level0) 185 { 186 char key2[] = "rw.sys.version*%version"; 187 char value2[] = "set value with illegal key"; 188 int ret = SetParameter(key2, value2); 189 EXPECT_EQ(ret, EC_INVALID); 190 } 191 192 /* key = 32 */ 193 HWTEST_F(SysparaUnitTest, parameterTest004, TestSize.Level0) 194 { 195 char key3[] = "rw.sys.version.utilskvparameter0"; 196 char value3[] = "set with key = 32"; 197 int ret = SetParameter(key3, value3); 198 EXPECT_EQ(ret, EC_SUCCESS); 199 } 200 201 /* value > 128 */ 202 HWTEST_F(SysparaUnitTest, parameterTest005, TestSize.Level0) 203 { 204 char key4[] = "rw.sys.version.version"; 205 char value4[] = "rw.sys.version.version.version.version flash_offset = *(hi_u32 *)DT_SetGetU32(&g_Element[0], 0)a\ 206 size = *(hi_u32 *)DT_SetGetU32(&g_Element[1], 0)a"; 207 int ret = SetParameter(key4, value4); 208 EXPECT_EQ(ret, SYSPARAM_INVALID_VALUE); 209 } 210 211 HWTEST_F(SysparaUnitTest, parameterTest006, TestSize.Level0) 212 { 213 char key1[] = "rw.product.not.exist"; 214 char value1[64] = {0}; 215 char defValue1[] = "value of key not exist..."; 216 int ret = GetParameter(key1, defValue1, value1, 64); 217 EXPECT_EQ(ret, static_cast<int>(strlen(defValue1))); 218 } 219 220 HWTEST_F(SysparaUnitTest, parameterTest007, TestSize.Level0) 221 { 222 char key2[] = "rw.sys.version.version.version.version"; 223 char value2[64] = {0}; 224 char defValue2[] = "value of key > 32 ..."; 225 int ret = GetParameter(key2, defValue2, value2, 64); 226 EXPECT_EQ(ret, static_cast<int>(strlen(defValue2))); 227 } 228 229 HWTEST_F(SysparaUnitTest, parameterTest008, TestSize.Level0) 230 { 231 char key4[] = "test.rw.sys.version"; 232 char* value4 = nullptr; 233 char defValue3[] = "value of key > 32 ..."; 234 int ret = GetParameter(key4, defValue3, value4, 0); 235 EXPECT_EQ(ret, EC_INVALID); 236 } 237 238 HWTEST_F(SysparaUnitTest, parameterTest009, TestSize.Level0) 239 { 240 char key5[] = "test.rw.product.type.2222222"; 241 char value5[] = "rw.sys.version.version.version.version \ 242 flash_offset = *(hi_u32 *)DT_SetGetU32(&g_Element[0], 0)"; 243 int ret = SetParameter(key5, value5); 244 EXPECT_EQ(ret, SYSPARAM_INVALID_VALUE); 245 char valueGet[2] = {0}; 246 char defValue3[] = "value of key > 32 ..."; 247 ret = GetParameter(key5, defValue3, valueGet, 2); 248 EXPECT_EQ(ret, EC_INVALID); 249 } 250 251 HWTEST_F(SysparaUnitTest, parameterTest0010, TestSize.Level0) 252 { 253 char key1[] = "test.rw.sys.version"; 254 char value1[] = "10.1.0"; 255 int ret = SetParameter(key1, value1); 256 EXPECT_EQ(ret, 0); 257 ret = SystemWriteParam(key1, value1); 258 EXPECT_EQ(ret, 0); 259 char valueGet1[32] = {0}; 260 ret = GetParameter(key1, "version=10.1.0", valueGet1, 32); 261 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet1))); 262 263 char key2[] = "test.rw.product.type"; 264 char value2[] = "wifi_iot"; 265 ret = SetParameter(key2, value2); 266 EXPECT_EQ(ret, 0); 267 ret = SystemWriteParam(key2, value2); 268 EXPECT_EQ(ret, 0); 269 char valueGet2[32] = {0}; 270 ret = GetParameter(key2, "version=10.1.0", valueGet2, 32); 271 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet2))); 272 273 char key3[] = "test.rw.product.manufacturer"; 274 char value3[] = "TEST MANUFACTURER"; 275 ret = SetParameter(key3, value3); 276 EXPECT_EQ(ret, 0); 277 ret = SystemWriteParam(key3, value3); 278 EXPECT_EQ(ret, 0); 279 char valueGet3[32] = {0}; 280 ret = GetParameter(key3, "version=10.1.0", valueGet3, 32); 281 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet3))); 282 283 char key4[] = "test.rw.product.marketname"; 284 char value4[] = "TEST MARKETNAME"; 285 ret = SetParameter(key4, value4); 286 EXPECT_EQ(ret, 0); 287 ret = SystemWriteParam(key4, value4); 288 EXPECT_EQ(ret, 0); 289 char valueGet4[32] = {0}; 290 ret = GetParameter(key4, "version=10.1.0", valueGet4, 32); 291 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet4))); 292 } 293 294 HWTEST_F(SysparaUnitTest, parameterTest0011, TestSize.Level0) 295 { 296 char key1[] = "test.rw.sys.version.wait1"; 297 char value1[] = "10.1.0"; 298 int ret = SetParameter(key1, value1); 299 EXPECT_EQ(ret, 0); 300 ret = SystemWriteParam(key1, value1); 301 EXPECT_EQ(ret, 0); 302 ret = WaitParameter(key1, value1, 10); 303 EXPECT_EQ(ret, 0); 304 ret = WaitParameter(key1, "*", 10); 305 EXPECT_EQ(ret, 0); 306 char key2[] = "test.rw.sys.version.wait2"; 307 ret = WaitParameter(key2, "*", 1); 308 EXPECT_EQ(ret, SYSPARAM_WAIT_TIMEOUT); 309 } 310 311 HWTEST_F(SysparaUnitTest, parameterTest0012, TestSize.Level0) 312 { 313 char key1[] = "test.rw.sys.version.version1"; 314 char value1[] = "10.1.0"; 315 int ret = SetParameter(key1, value1); 316 EXPECT_EQ(ret, 0); 317 318 ret = SystemWriteParam(key1, value1); 319 EXPECT_EQ(ret, 0); 320 // success 321 unsigned int handle = FindParameter(key1); 322 EXPECT_NE(handle, static_cast<unsigned int>(-1)); 323 char valueGet1[32] = {0}; 324 ret = GetParameterValue(handle, valueGet1, 32); 325 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet1))); 326 char nameGet1[32] = {0}; 327 ret = GetParameterName(handle, nameGet1, 32); 328 EXPECT_EQ(ret, static_cast<int>(strlen(nameGet1))); 329 330 // fail 331 char key2[] = "test.rw.sys.version.version2"; 332 handle = FindParameter(key2); 333 EXPECT_EQ(handle, static_cast<unsigned int>(-1)); 334 ret = GetParameterValue(handle, valueGet1, 32); 335 EXPECT_EQ(ret, SYSPARAM_NOT_FOUND); 336 ret = GetParameterName(handle, nameGet1, 32); 337 EXPECT_EQ(ret, SYSPARAM_NOT_FOUND); 338 ret = GetParameterValue(handle, nullptr, 32); 339 EXPECT_EQ(ret, EC_INVALID); 340 ret = GetParameterCommitId(handle); 341 EXPECT_EQ(ret, -1); 342 } 343 344 HWTEST_F(SysparaUnitTest, parameterTest0013, TestSize.Level0) 345 { 346 long long int out = 0; 347 unsigned long long int uout = 0; 348 GetParameter_(nullptr, nullptr, nullptr, 0); 349 EXPECT_EQ(GetIntParameter("test.int.get", 0) == -TEST_VALUE, 1); 350 EXPECT_EQ(GetUintParameter("test.int.get", 0), 0); 351 EXPECT_EQ(GetIntParameter("test.uint.get", 0), TEST_VALUE); 352 EXPECT_EQ(GetUintParameter("test.uint.get", 0), TEST_VALUE); 353 EXPECT_EQ(GetIntParameter("test.int.default", 10), 10); // key not find,value = default 354 EXPECT_EQ(GetUintParameter("test.uint.default", 10), 10); // key not find,value = default 355 EXPECT_EQ(IsValidParamValue(nullptr, 0), 0); 356 EXPECT_EQ(IsValidParamValue("testvalue", strlen("testvalue") + 1), 1); 357 EXPECT_EQ(StringToLL("0x11", &out), 0); 358 EXPECT_EQ(StringToULL("0x11", &uout), 0); 359 EXPECT_EQ(StringToLL("not vailed", &out), -1); 360 EXPECT_EQ(StringToULL("not vailed", &uout), -1); 361 char udid[UDID_LEN] = {0}; 362 GetDevUdid(udid, UDID_LEN); 363 EXPECT_NE(GetMajorVersion(), 0); 364 int ret = GetDevUdid(nullptr, UDID_LEN); 365 EXPECT_EQ(ret, EC_FAILURE); 366 GetSeniorVersion(); 367 GetFeatureVersion(); 368 GetBuildVersion(); 369 } 370 371 #ifndef OHOS_LITE 372 // for test param_wrapper.cpp 373 HWTEST_F(SysparaUnitTest, parameterTest0014, TestSize.Level0) 374 { 375 const std::string key1 = "test.int.get"; 376 OHOS::system::SetParameter(std::string("testKey"), std::string("testValue")); 377 int v = OHOS::system::GetIntParameter(key1, 0); 378 EXPECT_EQ(v, -TEST_VALUE); 379 int8_t v1 = OHOS::system::GetIntParameter(key1, 0, -127, 128); // -127, 128 range 380 EXPECT_EQ(v1, -TEST_VALUE); 381 int16_t v2 = OHOS::system::GetIntParameter(key1, 0, -127, 128); // -127, 128 range 382 EXPECT_EQ(v2, -TEST_VALUE); 383 int32_t v3 = OHOS::system::GetIntParameter(key1, 0, -127, 128); // -127, 128 range 384 EXPECT_EQ(v3, -TEST_VALUE); 385 int64_t v4 = OHOS::system::GetIntParameter(key1, 0, -127, 128); // -127, 128 range 386 EXPECT_EQ(v4, -TEST_VALUE); 387 388 int8_t v5 = OHOS::system::GetIntParameter(key1, 0, -10, 10); // -10, 10 range 389 EXPECT_EQ(v5, 0); 390 391 const std::string key2 = "test.uint.get"; 392 uint8_t u1 = OHOS::system::GetUintParameter<uint8_t>(key2, 0, (uint8_t)255); // 255 max value 393 EXPECT_EQ(u1, TEST_VALUE); 394 uint16_t u2 = OHOS::system::GetUintParameter<uint16_t>(key2, 0, (uint16_t)255); // 255 max value 395 EXPECT_EQ(u2, TEST_VALUE); 396 uint32_t u3 = OHOS::system::GetUintParameter<uint32_t>(key2, 0, (uint32_t)255); // 255 max value 397 EXPECT_EQ(u3, TEST_VALUE); 398 uint64_t u4 = OHOS::system::GetUintParameter<uint64_t>(key2, 0, (uint64_t)255); // 255 max value 399 EXPECT_EQ(u4 == TEST_VALUE, 1); 400 const std::string key3 = "test.uint.get3"; 401 u1 = OHOS::system::GetUintParameter<uint8_t>(key3, 0, (uint8_t)255); // 255 max value 402 EXPECT_EQ(u1, 0); 403 u1 = OHOS::system::GetUintParameter<uint8_t>(key2, 0, (uint8_t)10); // 10 max value 404 EXPECT_EQ(u1, 0); 405 } 406 407 HWTEST_F(SysparaUnitTest, parameterTest0015, TestSize.Level0) 408 { 409 std::string type = OHOS::system::GetDeviceType(); 410 printf("device type %s \n", type.c_str()); 411 412 const std::string key1 = "test.string.get"; 413 std::string v1 = OHOS::system::GetParameter(key1, ""); 414 EXPECT_EQ(strcmp(v1.c_str(), "101"), 0); 415 416 const std::string key2 = "test.string.get2"; 417 v1 = OHOS::system::GetParameter(key2, "test2"); 418 EXPECT_EQ(strcmp(v1.c_str(), "test2"), 0); 419 420 int ret = OHOS::system::GetStringParameter(key1, v1, ""); 421 EXPECT_EQ(ret, 0); 422 EXPECT_EQ(strcmp(v1.c_str(), "101"), 0); 423 ret = OHOS::system::GetStringParameter(key2, v1, "test2"); 424 EXPECT_EQ(ret, 0); 425 EXPECT_EQ(strcmp(v1.c_str(), "test2"), 0); 426 } 427 428 HWTEST_F(SysparaUnitTest, parameterTest0016, TestSize.Level0) 429 { 430 const std::string key1 = "test.bool.get.true"; 431 bool ret = OHOS::system::GetBoolParameter(key1, false); 432 EXPECT_EQ(ret, true); 433 const std::string key2 = "test.bool.get.false"; 434 ret = OHOS::system::GetBoolParameter(key2, true); 435 EXPECT_EQ(ret, false); 436 const std::string key3 = "test.bool.get3"; 437 ret = OHOS::system::GetBoolParameter(key3, false); 438 EXPECT_EQ(ret, false); 439 } 440 441 HWTEST_F(SysparaUnitTest, parameterTest0017, TestSize.Level0) 442 { 443 printf("distributionOS name =%s\n", GetDistributionOSName()); 444 EXPECT_STRNE(GetDistributionOSName(), nullptr); 445 printf("distributionOS version =%s\n", GetDistributionOSVersion()); 446 EXPECT_STRNE(GetDistributionOSVersion(), nullptr); 447 printf("distributionOS api version =%d\n", GetDistributionOSApiVersion()); 448 EXPECT_GT(GetDistributionOSApiVersion(), 0); 449 printf("distributionOS name =%s\n", GetDistributionOSReleaseType()); 450 EXPECT_STRNE(GetDistributionOSReleaseType(), nullptr); 451 printf("distributionOS api name =%s\n", GetDistributionOSApiName()); 452 printf("PerformanceClassLevel =%d\n", GetPerformanceClass()); 453 EXPECT_GE(GetPerformanceClass(), 0); 454 EXPECT_LE(GetPerformanceClass(), 2); 455 } 456 #endif 457 458 HWTEST_F(SysparaUnitTest, parameterTest0018, TestSize.Level0) 459 { 460 char key1[] = "test.ro.sys.version"; 461 char value1[] = "set read only key"; 462 int ret = SetParameter(key1, value1); 463 EXPECT_EQ(ret, EC_SUCCESS); 464 char key2[] = "persist.test.ro.sys.version"; 465 char value2[] = "set persist read only key"; 466 ret = SetParameter(key2, value2); 467 EXPECT_EQ(ret, EC_SUCCESS); 468 ret = SaveParameters(); 469 EXPECT_EQ(ret, 0); 470 } 471 472 #ifndef OHOS_LITE 473 HWTEST_F(SysparaUnitTest, parameterTest0019, TestSize.Level0) 474 { 475 char key1[] = "const.test.for_update_test"; 476 char key2[] = "persist.test.for_update_test"; 477 char value1[] = "initSet"; 478 char value2[] = "initUpdate"; 479 480 int ret = SystemUpdateConstParam(key1, value2); 481 EXPECT_EQ(ret, PARAM_CODE_INVALID_NAME); 482 ret = SystemWriteParam(key1, value1); 483 EXPECT_EQ(ret, 0); 484 ret = SystemUpdateConstParam(key1, value2); 485 EXPECT_EQ(ret, 0); 486 ret = SystemUpdateConstParam(key2, value2); 487 EXPECT_EQ(ret, PARAM_CODE_INVALID_NAME); 488 } 489 490 HWTEST_F(SysparaUnitTest, parameterTest0020, TestSize.Level0) 491 { 492 char key1[] = "const.test.for_update_test1"; 493 char value1[] = "initSet"; // len < 96 494 char value2[] = "initUpdate_abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" \ 495 "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; // len > 96 496 497 int ret = SystemWriteParam(key1, value1); 498 EXPECT_EQ(ret, 0); 499 ret = SystemUpdateConstParam(key1, value2); 500 EXPECT_EQ(ret, PARAM_CODE_INVALID_VALUE); 501 } 502 503 HWTEST_F(SysparaUnitTest, parameterTest0021, TestSize.Level0) 504 { 505 char key1[] = "const.test.for_update_test2"; 506 char value1[] = "initSet_abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" \ 507 "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; // len > 96 508 char value2[] = "initUpdate_abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" \ 509 "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; // len > 96 510 511 int ret = SystemWriteParam(key1, value1); 512 EXPECT_EQ(ret, 0); 513 ret = SystemUpdateConstParam(key1, value2); 514 EXPECT_EQ(ret, 0); 515 } 516 517 HWTEST_F(SysparaUnitTest, parameterTest0022, TestSize.Level0) 518 { 519 char key1[] = "const.test.for_update_test3"; 520 char value1[] = "initSet_abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" \ 521 "abcdefghijklmnopqrstuvwxyzabcdefghi"; // len = 96 522 char value2[] = "initUpdate_abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" \ 523 "abcdefghijklmnopqrstuvwxyzabcdef"; // len = 96 524 525 int ret = SystemWriteParam(key1, value1); 526 EXPECT_EQ(ret, 0); 527 ret = SystemUpdateConstParam(key1, value2); 528 EXPECT_EQ(ret, 0); 529 } 530 531 HWTEST_F(SysparaUnitTest, parameterTest0023, TestSize.Level0) 532 { 533 char key1[] = "const.test.for_update_test4"; 534 char value1[] = "initSet_abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz" \ 535 "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyz"; // len > 96 536 char value2[] = "initUpdate_abcdefghijkl"; // len < 96 537 538 int ret = SystemWriteParam(key1, value1); 539 EXPECT_EQ(ret, 0); 540 ret = SystemUpdateConstParam(key1, value2); 541 EXPECT_EQ(ret, 0); 542 } 543 #endif 544 } // namespace OHOS 545