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 printf("Device type =%s\n", GetDeviceType()); 48 printf("Manufacture =%s\n", GetManufacture()); 49 printf("GetBrand =%s\n", GetBrand()); 50 printf("MarketName =%s\n", GetMarketName()); 51 printf("ProductSeries =%s\n", GetProductSeries()); 52 printf("ProductModel =%s\n", GetProductModel()); 53 printf("SoftwareModel =%s\n", GetSoftwareModel()); 54 printf("HardwareModel =%s\n", GetHardwareModel()); 55 printf("Software profile =%s\n", GetHardwareProfile()); 56 printf("Serial =%s\n", GetSerial()); 57 printf("OS full name =%s\n", GetOSFullName()); 58 printf("OS Release type =%s\n", GetOsReleaseType()); 59 printf("Display version =%s\n", GetDisplayVersion()); 60 printf("bootloader version =%s\n", GetBootloaderVersion()); 61 printf("secure patch level =%s\n", GetSecurityPatchTag()); 62 } 63 64 HWTEST_F(SysparaUnitTest, parameterTest001_1, TestSize.Level0) 65 { 66 printf("secure patch level =%s\n", GetSecurityPatchTag()); 67 printf("abi list =%s\n", GetAbiList()); 68 printf("first api version =%d\n", GetFirstApiVersion()); 69 printf("SDK api version =%d\n", GetSdkApiVersion()); 70 printf("Incremental version = %s\n", GetIncrementalVersion()); 71 printf("formal id =%s\n", GetVersionId()); 72 printf("build type =%s\n", GetBuildType()); 73 printf("build user =%s\n", GetBuildUser()); 74 printf("Build host = %s\n", GetBuildHost()); 75 printf("build time =%s\n", GetBuildTime()); 76 printf("build root later..., %s\n", GetBuildRootHash()); 77 } 78 79 HWTEST_F(SysparaUnitTest, parameterTest001_2, TestSize.Level0) 80 { 81 EXPECT_STRNE(GetDeviceType(), nullptr); 82 EXPECT_STRNE(GetManufacture(), nullptr); 83 EXPECT_STRNE(GetBrand(), nullptr); 84 EXPECT_STRNE(GetMarketName(), nullptr); 85 EXPECT_STRNE(GetProductSeries(), nullptr); 86 EXPECT_STRNE(GetProductModel(), nullptr); 87 EXPECT_STRNE(GetSoftwareModel(), nullptr); 88 EXPECT_STRNE(GetHardwareModel(), nullptr); 89 EXPECT_STRNE(GetHardwareProfile(), nullptr); 90 EXPECT_STRNE(GetOSFullName(), nullptr); 91 EXPECT_STRNE(GetOsReleaseType(), nullptr); 92 EXPECT_STRNE(GetDisplayVersion(), nullptr); 93 EXPECT_STRNE(GetBootloaderVersion(), nullptr); 94 EXPECT_STRNE(GetSecurityPatchTag(), nullptr); 95 } 96 97 HWTEST_F(SysparaUnitTest, parameterTest001_3, TestSize.Level0) 98 { 99 EXPECT_STRNE(GetSecurityPatchTag(), nullptr); 100 EXPECT_STRNE(GetAbiList(), nullptr); 101 EXPECT_GT(GetFirstApiVersion(), 0); 102 EXPECT_GT(GetSdkApiVersion(), 0); 103 EXPECT_STRNE(GetIncrementalVersion(), nullptr); 104 EXPECT_STRNE(GetVersionId(), nullptr); 105 EXPECT_STRNE(GetBuildType(), nullptr); 106 EXPECT_STRNE(GetBuildUser(), nullptr); 107 EXPECT_STRNE(GetBuildHost(), nullptr); 108 EXPECT_STRNE(GetBuildTime(), nullptr); 109 EXPECT_STRNE(GetBuildRootHash(), nullptr); 110 } 111 112 HWTEST_F(SysparaUnitTest, parameterTest002, TestSize.Level0) 113 { 114 char key1[] = "test.ro.sys.version"; 115 char value1[] = "set read only key"; 116 int ret = SetParameter(key1, value1); 117 EXPECT_EQ(ret, EC_SUCCESS); 118 } 119 120 HWTEST_F(SysparaUnitTest, parameterTest003, TestSize.Level0) 121 { 122 char key2[] = "rw.sys.version*%version"; 123 char value2[] = "set value with illegal key"; 124 int ret = SetParameter(key2, value2); 125 EXPECT_EQ(ret, EC_INVALID); 126 } 127 128 /* key = 32 */ 129 HWTEST_F(SysparaUnitTest, parameterTest004, TestSize.Level0) 130 { 131 char key3[] = "rw.sys.version.utilskvparameter0"; 132 char value3[] = "set with key = 32"; 133 int ret = SetParameter(key3, value3); 134 EXPECT_EQ(ret, EC_SUCCESS); 135 } 136 137 /* value > 128 */ 138 HWTEST_F(SysparaUnitTest, parameterTest005, TestSize.Level0) 139 { 140 char key4[] = "rw.sys.version.version"; 141 char value4[] = "rw.sys.version.version.version.version flash_offset = *(hi_u32 *)DT_SetGetU32(&g_Element[0], 0)a\ 142 size = *(hi_u32 *)DT_SetGetU32(&g_Element[1], 0)a"; 143 int ret = SetParameter(key4, value4); 144 EXPECT_EQ(ret, SYSPARAM_INVALID_VALUE); 145 } 146 147 HWTEST_F(SysparaUnitTest, parameterTest006, TestSize.Level0) 148 { 149 char key1[] = "rw.product.not.exist"; 150 char value1[64] = {0}; 151 char defValue1[] = "value of key not exist..."; 152 int ret = GetParameter(key1, defValue1, value1, 64); 153 EXPECT_EQ(ret, static_cast<int>(strlen(defValue1))); 154 } 155 156 HWTEST_F(SysparaUnitTest, parameterTest007, TestSize.Level0) 157 { 158 char key2[] = "rw.sys.version.version.version.version"; 159 char value2[64] = {0}; 160 char defValue2[] = "value of key > 32 ..."; 161 int ret = GetParameter(key2, defValue2, value2, 64); 162 EXPECT_EQ(ret, static_cast<int>(strlen(defValue2))); 163 } 164 165 HWTEST_F(SysparaUnitTest, parameterTest008, TestSize.Level0) 166 { 167 char key4[] = "test.rw.sys.version"; 168 char* value4 = nullptr; 169 char defValue3[] = "value of key > 32 ..."; 170 int ret = GetParameter(key4, defValue3, value4, 0); 171 EXPECT_EQ(ret, EC_INVALID); 172 } 173 174 HWTEST_F(SysparaUnitTest, parameterTest009, TestSize.Level0) 175 { 176 char key5[] = "test.rw.product.type.2222222"; 177 char value5[] = "rw.sys.version.version.version.version \ 178 flash_offset = *(hi_u32 *)DT_SetGetU32(&g_Element[0], 0)"; 179 int ret = SetParameter(key5, value5); 180 EXPECT_EQ(ret, SYSPARAM_INVALID_VALUE); 181 char valueGet[2] = {0}; 182 char defValue3[] = "value of key > 32 ..."; 183 ret = GetParameter(key5, defValue3, valueGet, 2); 184 EXPECT_EQ(ret, EC_INVALID); 185 } 186 187 HWTEST_F(SysparaUnitTest, parameterTest0010, TestSize.Level0) 188 { 189 char key1[] = "test.rw.sys.version"; 190 char value1[] = "10.1.0"; 191 int ret = SetParameter(key1, value1); 192 EXPECT_EQ(ret, 0); 193 ret = SystemWriteParam(key1, value1); 194 EXPECT_EQ(ret, 0); 195 char valueGet1[32] = {0}; 196 ret = GetParameter(key1, "version=10.1.0", valueGet1, 32); 197 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet1))); 198 199 char key2[] = "test.rw.product.type"; 200 char value2[] = "wifi_iot"; 201 ret = SetParameter(key2, value2); 202 EXPECT_EQ(ret, 0); 203 ret = SystemWriteParam(key2, value2); 204 EXPECT_EQ(ret, 0); 205 char valueGet2[32] = {0}; 206 ret = GetParameter(key2, "version=10.1.0", valueGet2, 32); 207 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet2))); 208 209 char key3[] = "test.rw.product.manufacturer"; 210 char value3[] = "TEST MANUFACTURER"; 211 ret = SetParameter(key3, value3); 212 EXPECT_EQ(ret, 0); 213 ret = SystemWriteParam(key3, value3); 214 EXPECT_EQ(ret, 0); 215 char valueGet3[32] = {0}; 216 ret = GetParameter(key3, "version=10.1.0", valueGet3, 32); 217 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet3))); 218 219 char key4[] = "test.rw.product.marketname"; 220 char value4[] = "TEST MARKETNAME"; 221 ret = SetParameter(key4, value4); 222 EXPECT_EQ(ret, 0); 223 ret = SystemWriteParam(key4, value4); 224 EXPECT_EQ(ret, 0); 225 char valueGet4[32] = {0}; 226 ret = GetParameter(key4, "version=10.1.0", valueGet4, 32); 227 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet4))); 228 } 229 230 HWTEST_F(SysparaUnitTest, parameterTest0011, TestSize.Level0) 231 { 232 char key1[] = "test.rw.sys.version.wait1"; 233 char value1[] = "10.1.0"; 234 int ret = SetParameter(key1, value1); 235 EXPECT_EQ(ret, 0); 236 ret = SystemWriteParam(key1, value1); 237 EXPECT_EQ(ret, 0); 238 ret = WaitParameter(key1, value1, 10); 239 EXPECT_EQ(ret, 0); 240 ret = WaitParameter(key1, "*", 10); 241 EXPECT_EQ(ret, 0); 242 char key2[] = "test.rw.sys.version.wait2"; 243 ret = WaitParameter(key2, "*", 1); 244 EXPECT_EQ(ret, SYSPARAM_WAIT_TIMEOUT); 245 } 246 247 HWTEST_F(SysparaUnitTest, parameterTest0012, TestSize.Level0) 248 { 249 char key1[] = "test.rw.sys.version.version1"; 250 char value1[] = "10.1.0"; 251 int ret = SetParameter(key1, value1); 252 EXPECT_EQ(ret, 0); 253 254 ret = SystemWriteParam(key1, value1); 255 EXPECT_EQ(ret, 0); 256 // success 257 unsigned int handle = FindParameter(key1); 258 EXPECT_NE(handle, static_cast<unsigned int>(-1)); 259 char valueGet1[32] = {0}; 260 ret = GetParameterValue(handle, valueGet1, 32); 261 EXPECT_EQ(ret, static_cast<int>(strlen(valueGet1))); 262 char nameGet1[32] = {0}; 263 ret = GetParameterName(handle, nameGet1, 32); 264 EXPECT_EQ(ret, static_cast<int>(strlen(nameGet1))); 265 266 // fail 267 char key2[] = "test.rw.sys.version.version2"; 268 handle = FindParameter(key2); 269 EXPECT_EQ(handle, static_cast<unsigned int>(-1)); 270 ret = GetParameterValue(handle, valueGet1, 32); 271 EXPECT_EQ(ret, SYSPARAM_NOT_FOUND); 272 ret = GetParameterName(handle, nameGet1, 32); 273 EXPECT_EQ(ret, SYSPARAM_NOT_FOUND); 274 } 275 276 HWTEST_F(SysparaUnitTest, parameterTest0013, TestSize.Level0) 277 { 278 long long int out = 0; 279 unsigned long long int uout = 0; 280 GetParameter_(nullptr, nullptr, nullptr, 0); 281 EXPECT_EQ(GetIntParameter("test.int.get", 0) == -TEST_VALUE, 1); 282 EXPECT_EQ(GetUintParameter("test.int.get", 0), 0); 283 EXPECT_EQ(GetIntParameter("test.uint.get", 0), TEST_VALUE); 284 EXPECT_EQ(GetUintParameter("test.uint.get", 0), TEST_VALUE); 285 EXPECT_EQ(GetIntParameter("test.int.default", 10), 10); // key not find,value = default 286 EXPECT_EQ(GetUintParameter("test.uint.default", 10), 10); // key not find,value = default 287 EXPECT_EQ(IsValidParamValue(nullptr, 0), 0); 288 EXPECT_EQ(IsValidParamValue("testvalue", strlen("testvalue") + 1), 1); 289 EXPECT_EQ(StringToLL("0x11", &out), 0); 290 EXPECT_EQ(StringToULL("0x11", &uout), 0); 291 EXPECT_EQ(StringToLL("not vailed", &out), -1); 292 EXPECT_EQ(StringToULL("not vailed", &uout), -1); 293 char udid[UDID_LEN] = {0}; 294 GetDevUdid(udid, UDID_LEN); 295 EXPECT_NE(GetMajorVersion(), 0); 296 GetSeniorVersion(); 297 GetFeatureVersion(); 298 GetBuildVersion(); 299 } 300 301 #ifndef OHOS_LITE 302 // for test param_wrapper.cpp 303 HWTEST_F(SysparaUnitTest, parameterTest0014, TestSize.Level0) 304 { 305 const std::string key1 = "test.int.get"; 306 int v = OHOS::system::GetIntParameter(key1, 0); 307 EXPECT_EQ(v, -TEST_VALUE); 308 int8_t v1 = OHOS::system::GetIntParameter(key1, 0, -127, 128); // -127, 128 range 309 EXPECT_EQ(v1, -TEST_VALUE); 310 int16_t v2 = OHOS::system::GetIntParameter(key1, 0, -127, 128); // -127, 128 range 311 EXPECT_EQ(v2, -TEST_VALUE); 312 int32_t v3 = OHOS::system::GetIntParameter(key1, 0, -127, 128); // -127, 128 range 313 EXPECT_EQ(v3, -TEST_VALUE); 314 int64_t v4 = OHOS::system::GetIntParameter(key1, 0, -127, 128); // -127, 128 range 315 EXPECT_EQ(v4, -TEST_VALUE); 316 317 int8_t v5 = OHOS::system::GetIntParameter(key1, 0, -10, 10); // -10, 10 range 318 EXPECT_EQ(v5, 0); 319 320 const std::string key2 = "test.uint.get"; 321 uint8_t u1 = OHOS::system::GetUintParameter<uint8_t>(key2, 0, (uint8_t)255); // 255 max value 322 EXPECT_EQ(u1, TEST_VALUE); 323 uint16_t u2 = OHOS::system::GetUintParameter<uint16_t>(key2, 0, (uint16_t)255); // 255 max value 324 EXPECT_EQ(u2, TEST_VALUE); 325 uint32_t u3 = OHOS::system::GetUintParameter<uint32_t>(key2, 0, (uint32_t)255); // 255 max value 326 EXPECT_EQ(u3, TEST_VALUE); 327 uint64_t u4 = OHOS::system::GetUintParameter<uint64_t>(key2, 0, (uint64_t)255); // 255 max value 328 EXPECT_EQ(u4 == TEST_VALUE, 1); 329 const std::string key3 = "test.uint.get3"; 330 u1 = OHOS::system::GetUintParameter<uint8_t>(key3, 0, (uint8_t)255); // 255 max value 331 EXPECT_EQ(u1, 0); 332 u1 = OHOS::system::GetUintParameter<uint8_t>(key2, 0, (uint8_t)10); // 10 max value 333 EXPECT_EQ(u1, 0); 334 } 335 336 HWTEST_F(SysparaUnitTest, parameterTest0015, TestSize.Level0) 337 { 338 std::string type = OHOS::system::GetDeviceType(); 339 printf("device type %s \n", type.c_str()); 340 341 const std::string key1 = "test.string.get"; 342 std::string v1 = OHOS::system::GetParameter(key1, ""); 343 EXPECT_EQ(strcmp(v1.c_str(), "101"), 0); 344 345 const std::string key2 = "test.string.get2"; 346 v1 = OHOS::system::GetParameter(key2, "test2"); 347 EXPECT_EQ(strcmp(v1.c_str(), "test2"), 0); 348 349 int ret = OHOS::system::GetStringParameter(key1, v1, ""); 350 EXPECT_EQ(ret, 0); 351 EXPECT_EQ(strcmp(v1.c_str(), "101"), 0); 352 ret = OHOS::system::GetStringParameter(key2, v1, "test2"); 353 EXPECT_EQ(ret, 0); 354 EXPECT_EQ(strcmp(v1.c_str(), "test2"), 0); 355 } 356 357 HWTEST_F(SysparaUnitTest, parameterTest0016, TestSize.Level0) 358 { 359 const std::string key1 = "test.bool.get.true"; 360 bool ret = OHOS::system::GetBoolParameter(key1, false); 361 EXPECT_EQ(ret, true); 362 const std::string key2 = "test.bool.get.false"; 363 ret = OHOS::system::GetBoolParameter(key2, true); 364 EXPECT_EQ(ret, false); 365 const std::string key3 = "test.bool.get3"; 366 ret = OHOS::system::GetBoolParameter(key3, false); 367 EXPECT_EQ(ret, false); 368 } 369 #endif 370 } // namespace OHOS 371