1 /*
2 * Copyright (c) 2022 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 <thread>
17 #include <gtest/gtest.h>
18 #include <cstdint>
19 #include "param_wrapper.h"
20 #include "parameter.h"
21 #include "parameters.h"
22 #include "sysversion.h"
23 #include "param_comm.h"
24 #include "init_param.h"
25 #include "sysparam_errno.h"
26 #include "sys_param.h"
27
28 using namespace std;
29 using namespace testing::ext;
30 using namespace OHOS;
31
32 const int THREAD_NUM = 5;
33
34 namespace initModuleTest {
GetAllParameterTestFunc(void)35 static void GetAllParameterTestFunc(void)
36 {
37 EXPECT_STRNE(GetSecurityPatchTag(), nullptr);
38 EXPECT_STRNE(GetOSFullName(), nullptr);
39 EXPECT_STRNE(GetVersionId(), nullptr);
40 EXPECT_STRNE(GetBuildRootHash(), nullptr);
41 EXPECT_STRNE(GetOsReleaseType(), nullptr);
42 GetSdkApiVersion();
43 EXPECT_STRNE(GetDeviceType(), nullptr);
44 EXPECT_STRNE(GetProductModel(), nullptr);
45 EXPECT_STRNE(GetProductModelAlias(), nullptr);
46 EXPECT_STRNE(GetManufacture(), nullptr);
47 EXPECT_STRNE(GetBrand(), nullptr);
48 EXPECT_STRNE(GetMarketName(), nullptr);
49 EXPECT_STRNE(GetProductSeries(), nullptr);
50 EXPECT_STRNE(GetSoftwareModel(), nullptr);
51 EXPECT_STRNE(GetHardwareModel(), nullptr);
52 EXPECT_STRNE(GetHardwareProfile(), nullptr);
53 EXPECT_STRNE(GetSerial(), nullptr);
54 EXPECT_STRNE(GetAbiList(), nullptr);
55 EXPECT_STRNE(GetDisplayVersion(), nullptr);
56 EXPECT_STRNE(GetIncrementalVersion(), nullptr);
57 EXPECT_STRNE(GetBootloaderVersion(), nullptr);
58 EXPECT_STRNE(GetBuildType(), nullptr);
59 EXPECT_STRNE(GetBuildUser(), nullptr);
60 EXPECT_STRNE(GetBuildHost(), nullptr);
61 EXPECT_STRNE(GetBuildTime(), nullptr);
62 GetFirstApiVersion();
63 EXPECT_STRNE(system::GetDeviceType().c_str(), nullptr);
64 }
65
GetUdidTestFunc(char * udid,int size)66 static void GetUdidTestFunc(char* udid, int size)
67 {
68 int ret = GetDevUdid(udid, size);
69 EXPECT_EQ(ret, 0);
70 EXPECT_STRNE(udid, nullptr);
71 }
72
SetParameterTestFunc(const char * key,const char * value)73 static void SetParameterTestFunc(const char *key, const char *value)
74 {
75 EXPECT_EQ(SetParameter(key, value), 0);
76 uint32_t handle = FindParameter(key);
77 EXPECT_NE(handle, static_cast<unsigned int>(-1));
78 uint32_t result = GetParameterCommitId(handle);
79 EXPECT_NE(result, static_cast<unsigned int>(-1));
80 char nameGet[PARAM_NAME_LEN_MAX] = {0};
81 int ret = GetParameterName(handle, nameGet, PARAM_NAME_LEN_MAX);
82 EXPECT_EQ(ret, strlen(nameGet));
83 EXPECT_STREQ(key, nameGet);
84 char valueGet[PARAM_VALUE_LEN_MAX] = {0};
85 ret = GetParameterValue(handle, valueGet, PARAM_VALUE_LEN_MAX);
86 EXPECT_EQ(ret, strlen(valueGet));
87 EXPECT_STREQ(value, valueGet);
88 EXPECT_NE(GetSystemCommitId(), 0);
89 }
90
GetParameterTestReInt(const char * key,const char * def,char * value,uint32_t len)91 static void GetParameterTestReInt(const char *key, const char *def, char *value, uint32_t len)
92 {
93 int ret = GetParameter(key, def, value, len);
94 EXPECT_EQ(ret, strlen(value));
95 EXPECT_STREQ(value, "v10.1.1");
96 }
97
GetParameterTestFuncReStr(string key,string def)98 static void GetParameterTestFuncReStr(string key, string def)
99 {
100 string ret = system::GetParameter(key, def);
101 EXPECT_STREQ(ret.c_str(), "v10.1.1");
102 }
103
ParamSetFun(string key,string value)104 static void ParamSetFun(string key, string value)
105 {
106 bool ret = system::SetParameter(key, value);
107 EXPECT_TRUE(ret);
108 string testValue = system::GetParameter(key, "");
109 EXPECT_STREQ(testValue.c_str(), value.c_str());
110 }
111
TestParameterChange(const char * key,const char * value,void * context)112 static void TestParameterChange(const char *key, const char *value, void *context)
113 {
114 std::cout<<"TestParameterChange key: "<<key<<"value: "<<value<<endl;
115 }
116
TestParameterWatchChange(void)117 static void TestParameterWatchChange(void)
118 {
119 size_t index = 1;
120 int ret = WatchParameter("test.param.watcher.test1", TestParameterChange, reinterpret_cast<void *>(index));
121 EXPECT_EQ(ret, 0);
122 ret = RemoveParameterWatcher("test.param.watcher.test1", TestParameterChange, reinterpret_cast<void *>(index));
123 EXPECT_EQ(ret, 0);
124 }
125
126 class SysparaModuleTest : public testing::Test {
127 public:
SetUpTestCase(void)128 static void SetUpTestCase(void) {};
TearDownTestCase(void)129 static void TearDownTestCase(void) {};
SetUp(void)130 void SetUp(void) {};
TearDown(void)131 void TearDown(void) {};
132 };
133
134 HWTEST_F(SysparaModuleTest, Syspara_SysVersion_test_001, TestSize.Level0)
135 {
136 GTEST_LOG_(INFO) << "Syspara_SysVersion_test_001 start";
137 GetMajorVersion();
138 GetSeniorVersion();
139 GetFeatureVersion();
140 GetBuildVersion();
141 GTEST_LOG_(INFO) << "Syspara_SysVersion_test_001 end";
142 }
143
144 HWTEST_F(SysparaModuleTest, Syspara_GetParam_test_002, TestSize.Level0)
145 {
146 GTEST_LOG_(INFO) << "Syspara_GetParam_test_002 start";
147 for (int i = 0; i < THREAD_NUM; ++i) {
148 std::thread(GetAllParameterTestFunc).join();
149 }
150 GTEST_LOG_(INFO) << "Syspara_GetParam_test_002 end";
151 }
152
153 HWTEST_F(SysparaModuleTest, Syspara_GetUdid_test_003, TestSize.Level0)
154 {
155 GTEST_LOG_(INFO) << "Syspara_GetUdid_test_003 start";
156 for (int i = 0; i < THREAD_NUM; ++i) {
157 char udid[UDID_LEN] = {0};
158 std::thread(GetUdidTestFunc, udid, UDID_LEN).join();
159 }
160 GTEST_LOG_(INFO) << "Syspara_GetUdid_test_003 end";
161 }
162
163 HWTEST_F(SysparaModuleTest, Syspara_SetParameter_test_004, TestSize.Level0)
164 {
165 GTEST_LOG_(INFO) << "Syspara_SetParameter_test_004 start";
166 char key1[] = "test1.param.version";
167 char value1[] = "v10.1.1";
168 char key2[] = "test2.param.version";
169 char value2[] = "v10.2.2";
170 char key3[] = "test3.param.version";
171 char value3[] = "v10.3.3";
172 std::thread(SetParameterTestFunc, key1, value1).join();
173 std::thread(SetParameterTestFunc, key2, value2).join();
174 std::thread(SetParameterTestFunc, key3, value3).join();
175 GTEST_LOG_(INFO) << "Syspara_SetParameter_test_004 end";
176 }
177
178 HWTEST_F(SysparaModuleTest, Syspara_SetParameter_test_005, TestSize.Level0)
179 {
180 GTEST_LOG_(INFO) << "Syspara_SetParameter_test_005 start";
181 // check param name length
182 char key1[] = "test.param.name.xxxxxxxxxxxxxxxxxxxxxx.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.xxxxxxxxxxxxxxxxxxxxxxxxxx";
183 char value[] = "test.value.xxxx";
184 int ret = SetParameter(key1, value);
185 EXPECT_EQ(ret, EC_INVALID);
186 // check param name, Illegal param name
187 char key2[] = ".test.param.name.xxxxx";
188 ret = SetParameter(key2, value);
189 EXPECT_EQ(ret, EC_INVALID);
190 char key3[] = "test..param.name.xxxxx";
191 ret = SetParameter(key3, value);
192 EXPECT_EQ(ret, EC_INVALID);
193 char key4[] = "test..param. .name";
194 ret = SetParameter(key4, value);
195 EXPECT_EQ(ret, EC_INVALID);
196 // check param name, legal param name
197 char key5[] = "test.param.name.--__.:::";
198 ret = SetParameter(key5, value);
199 EXPECT_EQ(ret, 0);
200 EXPECT_STREQ(value, "test.value.xxxx");
201 char key6[] = "test.param.name.@@@.---";
202 ret = SetParameter(key6, value);
203 EXPECT_EQ(ret, 0);
204 EXPECT_STREQ(value, "test.value.xxxx");
205 // not const param, check param value, bool 8, int 32, other 96
206 char key7[] = "test.param.name.xxxx";
207 char value1[] = "test.value.xxxxxxxxx.xxxxxxxxxxxxx.xxxxxxxxxxxx.xxxxxxxxxxxxxxx.xxxxxxxxxxxxxxxxxxxxxx.xxxxxxxxxx";
208 ret = SetParameter(key7, value1);
209 EXPECT_EQ(ret, SYSPARAM_INVALID_VALUE);
210 char key8[] = "startup.service.ctl.test.int";
211 char value2[] = "111111111111111111111111111111111";
212 ret = SetParameter(key8, value2);
213 EXPECT_EQ(ret, SYSPARAM_INVALID_VALUE);
214 GTEST_LOG_(INFO) << "Syspara_SetParameter_test_005 end";
215 }
216
217 HWTEST_F(SysparaModuleTest, Syspara_Getparameter_test_006, TestSize.Level0)
218 {
219 GTEST_LOG_(INFO) << "Syspara_Getparameter_test_006 start";
220 string key = "test.param.set.001";
221 string value = "xxx.xxx.xxx";
222 bool ret = system::SetParameter(key, value);
223 EXPECT_TRUE(ret);
224 string testValue = system::GetParameter(key, "");
225 EXPECT_STREQ(testValue.c_str(), value.c_str());
226 // not read param value,the result is default
227 testValue = system::GetParameter("test.param.set.002", "aaa.aaa.aaa");
228 EXPECT_STREQ(testValue.c_str(), "aaa.aaa.aaa");
229 testValue = system::GetParameter("test.param.set.003", "");
230 EXPECT_STREQ(testValue.c_str(), "");
231 // correct set value
232 string key1 = "test.param.set.bool";
233 ret = system::SetParameter(key1, "1");
234 EXPECT_TRUE(ret);
235 EXPECT_TRUE(system::GetBoolParameter(key1, false));
236 ret = system::SetParameter(key1, "y");
237 EXPECT_TRUE(ret);
238 EXPECT_TRUE(system::GetBoolParameter(key1, false));
239 ret = system::SetParameter(key1, "yes");
240 EXPECT_TRUE(ret);
241 EXPECT_TRUE(system::GetBoolParameter(key1, false));
242 ret = system::SetParameter(key1, "on");
243 EXPECT_TRUE(ret);
244 EXPECT_TRUE(system::GetBoolParameter(key1, false));
245 ret = system::SetParameter(key1, "true");
246 EXPECT_TRUE(ret);
247 EXPECT_TRUE(system::GetBoolParameter(key1, false));
248 ret = system::SetParameter(key1, "0");
249 EXPECT_TRUE(ret);
250 EXPECT_FALSE(system::GetBoolParameter(key1, true));
251 ret = system::SetParameter(key1, "off");
252 EXPECT_TRUE(ret);
253 EXPECT_FALSE(system::GetBoolParameter(key1, true));
254 ret = system::SetParameter(key1, "n");
255 EXPECT_TRUE(ret);
256 EXPECT_FALSE(system::GetBoolParameter(key1, true));
257 ret = system::SetParameter(key1, "no");
258 EXPECT_TRUE(ret);
259 EXPECT_FALSE(system::GetBoolParameter(key1, true));
260 ret = system::SetParameter(key1, "false");
261 EXPECT_TRUE(ret);
262 EXPECT_FALSE(system::GetBoolParameter(key1, true));
263 // set value type not bool,the result get form def
264 ret = system::SetParameter(key1, "test");
265 EXPECT_TRUE(ret);
266 EXPECT_TRUE(system::GetBoolParameter(key1, true));
267 EXPECT_FALSE(system::GetBoolParameter(key1, false));
268 GTEST_LOG_(INFO) << "Syspara_Getparameter_test_006 end";
269 }
270
271 HWTEST_F(SysparaModuleTest, Syspara_SetParameter_test_007, TestSize.Level0)
272 {
273 GTEST_LOG_(INFO) << "Syspara_SetParameter_test_007 start";
274 string key1 = "const.param.test";
275 string value1 = "test.param.value.001";
276
277 int ret = 0;
278 string vRet = "";
279 uint32_t handle1 = FindParameter(key1.c_str());
280 cout<<"handle1 is: "<<handle1<<std::endl;
281 if (handle1 == static_cast<uint32_t>(-1)) {
282 ret = SetParameter(key1.c_str(), value1.c_str());
283 EXPECT_EQ(ret, 0);
284 vRet = system::GetParameter(key1, "");
285 EXPECT_STREQ(vRet.c_str(), value1.c_str());
286 }
287 string value2 = "test.param.value.002";
288 ret = SetParameter(key1.c_str(), value2.c_str());
289 EXPECT_EQ(ret, EC_INVALID);
290
291 string key2 = "ro.param.test";
292 string value3 = "test.param.value.003";
293 uint32_t handle2 = FindParameter(key2.c_str());
294 cout<<"handle2 is: "<<handle2<<std::endl;
295 if (handle2 == static_cast<uint32_t>(-1)) {
296 ret = SetParameter(key2.c_str(), value3.c_str());
297 EXPECT_EQ(ret, 0);
298 vRet = system::GetParameter(key2, "");
299 EXPECT_STREQ(vRet.c_str(), value3.c_str());
300 }
301 string value4 = "test.param.value.004";
302 ret = SetParameter(key2.c_str(), value4.c_str());
303 EXPECT_EQ(ret, EC_INVALID);
304 GTEST_LOG_(INFO) << "Syspara_SetParameter_test_007 end";
305 }
306
307 HWTEST_F(SysparaModuleTest, Syspara_GetParameterReIntOrStr_test_008, TestSize.Level0)
308 {
309 GTEST_LOG_(INFO) << "Syspara_GetParameterReIntOrStr_test_008 start";
310 string key = "test1.param.version";
311 string value = "v10.1.1";
312 int ret = SetParameter(key.c_str(), value.c_str());
313 EXPECT_EQ(ret, 0);
314 char retValue[PARAM_VALUE_LEN_MAX] = {0};
315 for (int i = 0; i < THREAD_NUM; ++i) {
316 std::thread(GetParameterTestReInt, key.c_str(), "", retValue, PARAM_VALUE_LEN_MAX).join();
317 }
318 for (int j = 0; j < THREAD_NUM; ++j) {
319 std::thread(GetParameterTestFuncReStr, key, "").join();
320 }
321 GTEST_LOG_(INFO) << "Syspara_GetParameterReIntOrStr_test_008 end";
322 }
323
324 HWTEST_F(SysparaModuleTest, Syspara_WaitParameter_test_009, TestSize.Level0)
325 {
326 GTEST_LOG_(INFO) << "Syspara_WaitParameter_test_009 start";
327 // param already set succeed,waitParamter succeed.
328 char key[] = "test1.param.wait";
329 char value[] = "aaa.bbb.ccc";
330 int ret = SetParameter(key, value);
331 EXPECT_EQ(ret, 0);
332 ret = WaitParameter(key, value, 5);
333 EXPECT_EQ(ret, 0);
334 // param not set,waitParamter will wait param set,return succeed.
335 char key1[] = "test2.param.wait";
336 char value1[] = "aaa.aaa.aaa";
337 std::thread(ParamSetFun, key1, value1).join();
338 ret = WaitParameter(key1, value1, 5);
339 EXPECT_EQ(ret, 0);
340 char key2[] = "test3.param.wait";
341 std::thread(ParamSetFun, key2, "*****").join();
342 ret = WaitParameter(key2, "*****", 5);
343 EXPECT_EQ(ret, 0);
344 // param not set,waitParamter will timeout,return failed.
345 char key3[] = "test4.param.wait";
346 ret = WaitParameter(key3, "*****", 5);
347 EXPECT_EQ(ret, SYSPARAM_WAIT_TIMEOUT);
348 GTEST_LOG_(INFO) << "Syspara_WaitParameter_test_009 end";
349 }
350
351 HWTEST_F(SysparaModuleTest, Syspara_watcherParameter_test_010, TestSize.Level0)
352 {
353 GTEST_LOG_(INFO) << "Syspara_watcherParameter_test_010 start";
354 for (int i = 0; i < THREAD_NUM; ++i) {
355 std::thread(TestParameterWatchChange).join();
356 }
357
358 std::thread(ParamSetFun, "test.param.watcher.test1", "test.param.value.xxx").join();
359
360 GTEST_LOG_(INFO) << "Syspara_watcherParameter_test_010 end";
361 }
362
363 HWTEST_F(SysparaModuleTest, Syspara_GetParameter_test_011, TestSize.Level0)
364 {
365 GTEST_LOG_(INFO) << "Syspara_GetParameter_test_011 start";
366
367 char key1[] = "test.param.int1";
368 char value1[] = "0x111111";
369 EXPECT_EQ(SetParameter(key1, value1), 0);
370 EXPECT_EQ(GetIntParameter(key1, 0), 1118481); // 0x111111 decimalism result
371 EXPECT_EQ(GetUintParameter(key1, 0), 1118481);
372
373 char key2[] = "test.param.int2";
374 char value2[] = "-0x111111";
375 EXPECT_EQ(SetParameter(key2, value2), 0);
376 EXPECT_EQ(GetIntParameter(key2, 0), -1118481); // 0x111111 decimalism result
377
378 GetUintParameter(key2, 0);
379
380 char key3[] = "test.param.int3";
381 char value3[] = "9999999";
382 EXPECT_EQ(SetParameter(key3, value3), 0);
383 EXPECT_EQ(GetIntParameter(key3, 0), 9999999); // value3 int result
384 EXPECT_EQ(GetUintParameter(key3, 0), 9999999); // value3 uint result
385
386 char key4[] = "test.param.int4";
387 char value4[] = "-9999999";
388 EXPECT_EQ(SetParameter(key4, value4), 0);
389 EXPECT_EQ(GetIntParameter(key4, 0), -9999999); // value4 int result
390 EXPECT_EQ(GetUintParameter(key4, 0), 0);
391
392 char key5[] = "test.param.int5";
393 char value5[] = "-2147483648"; // INT32_MIN
394 EXPECT_EQ(SetParameter(key5, value5), 0);
395 EXPECT_EQ(GetIntParameter(key5, 0), 0);
396
397 char key6[] = "test.param.int6";
398 char value6[] = "2147483647"; // INT32_MAX
399 EXPECT_EQ(SetParameter(key6, value6), 0);
400 EXPECT_EQ(GetIntParameter(key6, 0), 0);
401
402 char key7[] = "test.param.uint7";
403 char value7[] = "4294967295"; // UINT32_MAX
404 EXPECT_EQ(SetParameter(key7, value7), 0);
405 EXPECT_EQ(GetUintParameter(key7, 0), 0);
406
407 GTEST_LOG_(INFO) << "Syspara_GetParameter_test_011 end";
408 }
409
410 HWTEST_F(SysparaModuleTest, Syspara_CacheParameter_test_001, TestSize.Level0)
411 {
412 GTEST_LOG_(INFO) << "Syspara_CacheParameter_test_001 start";
413
414 const char *name = "test.write.1111111.222222";
415 CachedHandle cacheHandle = CachedParameterCreate(name, "true");
416 EXPECT_NE(cacheHandle, nullptr);
417 const char *value = CachedParameterGet(cacheHandle);
418 int ret = SetParameter(name, "false");
419 EXPECT_EQ(ret, 0);
420
421 value = CachedParameterGet(cacheHandle);
422 EXPECT_EQ(strcmp(value, "false"), 0);
423 CachedParameterDestroy(cacheHandle);
424
425 GTEST_LOG_(INFO) << "Syspara_CacheParameter_test_001 end";
426 }
427
428 HWTEST_F(SysparaModuleTest, Syspara_CacheParameter_test_002, TestSize.Level0)
429 {
430 GTEST_LOG_(INFO) << "Syspara_CacheParameter_test_002 start";
431
432 const char *name = "test.write.1111111.333333";
433 int ret = SetParameter(name, "3333");
434 EXPECT_EQ(ret, 0);
435 CachedHandle cacheHandle3 = CachedParameterCreate(name, "true");
436 EXPECT_NE(cacheHandle3, nullptr);
437 const char *value = CachedParameterGet(cacheHandle3);
438 EXPECT_EQ(strcmp(value, "3333"), 0);
439
440 ret = SetParameter(name, "2222222");
441 EXPECT_EQ(ret, 0);
442 int valueChange = 0;
443 value = CachedParameterGetChanged(cacheHandle3, &valueChange);
444 EXPECT_EQ(strcmp(value, "2222222"), 0);
445 EXPECT_EQ(valueChange, 1);
446 CachedParameterDestroy(cacheHandle3);
447 GTEST_LOG_(INFO) << "Syspara_CacheParameter_test_002 end";
448 }
449
450 HWTEST_F(SysparaModuleTest, Syspara_SaveParameters_test_001, TestSize.Level0)
451 {
452 GTEST_LOG_(INFO) << "Syspara_SaveParameters_test_001 start";
453
454 char key1[] = "test.param.int1";
455 char value1[] = "0x111111";
456 EXPECT_EQ(SetParameter(key1, value1), 0);
457 char key2[] = "persist.test.param.int2";
458 char value2[] = "-0x111111";
459 EXPECT_EQ(SetParameter(key2, value2), 0);
460 EXPECT_EQ(SaveParameters(), 0);
461
462 GTEST_LOG_(INFO) << "Syspara_SaveParameters_test_001 end";
463 }
464 }