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