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