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 #include <gtest/gtest.h>
16 
17 #include "init_param.h"
18 #include "param_base.h"
19 #include "param_message.h"
20 #include "param_stub.h"
21 #include "param_init.h"
22 #include "trigger_manager.h"
23 #include "param_utils.h"
24 #include "param_osadp.h"
25 #include "param_manager.h"
26 #include "sys_param.h"
27 
28 using namespace testing::ext;
29 using namespace std;
30 
31 extern "C" {
32 void ParamWorBaseLog(InitLogLevel logLevel, uint32_t domain, const char *tag, const char *fmt, ...);
OnClose(const TaskHandle taskHandle)33 static void OnClose(const TaskHandle taskHandle)
34 {
35 }
36 }
37 
CheckServerParamValue(const char *name, const char *expectValue)38 static int CheckServerParamValue(const char *name, const char *expectValue)
39 {
40     char tmp[PARAM_BUFFER_SIZE] = {0};
41     u_int32_t len = sizeof(tmp);
42     SystemReadParam(name, tmp, &len);
43     printf("CheckParamValue name %s value: \'%s\' expectValue:\'%s\' \n", name, tmp, expectValue);
44     EXPECT_GE((int)strlen(tmp), 0);
45     if (expectValue != nullptr) {
46         EXPECT_EQ(strcmp(tmp, expectValue), 0);
47     }
48     return 0;
49 }
50 
51 namespace init_ut {
52 class ParamUnitTest : public ::testing::Test {
53 public:
ParamUnitTest()54     ParamUnitTest() {}
~ParamUnitTest()55     virtual ~ParamUnitTest() {}
56 
SetUpTestCase(void)57     static void SetUpTestCase(void) {}
SetUp()58     void SetUp() {}
TearDown()59     void TearDown() {}
TestBody()60     void TestBody() {}
61 
TestSetParams(const char *params[][1 + 1], int num)62     int TestSetParams(const char *params[][1 + 1], int num)
63     {
64         for (int i = 0; i < num; i++) {
65             SystemWriteParam(params[i][0], params[i][1]);
66         }
67 
68         // check
69         for (int i = 0; i < num; i++) {
70             CheckServerParamValue(params[i][0], params[i][1]);
71         }
72 
73         for (int i = num - 1; i >= 0; i--) {
74             CheckServerParamValue(params[i][0], params[i][1]);
75         }
76         return 0;
77     }
78 
TestAddSecurityLabel1()79     int TestAddSecurityLabel1()
80     {
81         GetParamSecurityLabel()->cred.gid = 9999;  // 9999 test gid
82         const char *name = "label1.test.aaa.bbb.ccc.dddd.eee";
83         const char *value = "2001";
84         uint32_t labelIndex = 0;
85         SystemWriteParam(name, value);
86         // get root
87         WorkSpace *workspace = GetWorkSpace(WORKSPACE_INDEX_DAC);
88         (void)FindTrieNode(workspace, name, strlen(name), &labelIndex);
89         ParamSecurityNode *node = (ParamSecurityNode *)GetTrieNode(workspace, labelIndex);
90         if (node == nullptr) {
91             EXPECT_EQ(1, 0);
92             return 0;
93         }
94         EXPECT_EQ(node->gid, DAC_DEFAULT_GROUP);
95         return 0;
96     }
97 
98     // 添加一个label，最长匹配到这个节点
TestAddSecurityLabel2()99     int TestAddSecurityLabel2()
100     {
101         GetParamSecurityLabel()->cred.gid = 9999;  // 9999 test gid
102         const char *name = "label2.test.aaa.bbb.ccc.dddd.eee";
103         const char *value = "2001";
104         ParamAuditData auditData = {};
105         auditData.name = "label2.test.aaa";
106         auditData.dacData.gid = 202;  // 202 test dac gid
107         auditData.dacData.uid = geteuid();
108         auditData.dacData.mode = 0666;  // 0666 test mode
109         SystemWriteParam(name, value);
110         uint32_t labelIndex = 0;
111         AddSecurityLabel(&auditData);
112         WorkSpace *workspace = GetWorkSpace(WORKSPACE_INDEX_DAC);
113         (void)FindTrieNode(workspace, name, strlen(name), &labelIndex);
114         ParamSecurityNode *node = (ParamSecurityNode *)GetTrieNode(workspace, labelIndex);
115         if (node == nullptr) {
116             EXPECT_EQ(1, 0);
117             return 0;
118         }
119         EXPECT_EQ(node->gid, auditData.dacData.gid);
120         return 0;
121     }
122 
123     // 添加一个label，最长匹配到最后一个相同节点
TestAddSecurityLabel3()124     int TestAddSecurityLabel3()
125     {
126         GetParamSecurityLabel()->cred.gid = 9999;  // 9999 test gid
127         const char *name = "label3.test.aaa.bbb.ccc.dddd.eee";
128         const char *value = "2001";
129         ParamAuditData auditData = {};
130         auditData.name = "label3.test.aaa";
131         auditData.dacData.gid = 203;  // 203 test gid
132         auditData.dacData.uid = geteuid();
133         auditData.dacData.mode = 0666;  // 0666 test mode
134         SystemWriteParam(name, value);
135         AddSecurityLabel(&auditData);
136 
137         auditData.name = "label3.test.aaa.bbb.ccc.dddd.eee.dddd";
138         auditData.dacData.gid = 202;  // 202 test dac gid
139         auditData.dacData.uid = geteuid();
140         auditData.dacData.mode = 0666;  // 0666 test mode
141         SystemWriteParam(name, value);
142         AddSecurityLabel(&auditData);
143 
144         uint32_t labelIndex = 0;
145         WorkSpace *workspace = GetWorkSpace(WORKSPACE_INDEX_DAC);
146         ParamTrieNode *paramNode = FindTrieNode(workspace, name, strlen(name), &labelIndex);
147         ParamSecurityNode *node = (ParamSecurityNode *)GetTrieNode(workspace, labelIndex);
148         if (paramNode == nullptr || node == nullptr) {
149             EXPECT_EQ(1, 0);
150             return 0;
151         }
152         EXPECT_EQ((int)node->gid, 203);  // 203 test gid
153         return 0;
154     }
155 
156     // 添加一个label，完全匹配
TestAddSecurityLabel4()157     int TestAddSecurityLabel4()
158     {
159 #if !(defined __LITEOS_A__ || defined __LITEOS_M__)
160         ResetParamSecurityLabel();
161 #endif
162         GetParamSecurityLabel()->cred.gid = 9999;  // 9999 test gid
163         const char *name = "label4.test.aaa.bbb.ccc.dddd.eee";
164         const char *value = "2001";
165         ParamAuditData auditData = {};
166         auditData.name = "label4.test.aaa.bbb.ccc.dddd.eee";
167         auditData.dacData.gid = 203;  // 203 test gid
168         auditData.dacData.uid = geteuid();
169         auditData.dacData.mode = 0666;  // 0666 test mode
170         SystemWriteParam(name, value);
171         uint32_t labelIndex = 0;
172         AddSecurityLabel(&auditData);
173         WorkSpace *workspace = GetWorkSpace(WORKSPACE_INDEX_DAC);
174         ParamTrieNode *paramNode = FindTrieNode(workspace, name, strlen(name), &labelIndex);
175         ParamSecurityNode *node = (ParamSecurityNode *)GetTrieNode(workspace, labelIndex);
176         if (paramNode == nullptr || node == nullptr) {
177             EXPECT_EQ(1, 0);
178             return 0;
179         }
180         EXPECT_EQ(node->gid, auditData.dacData.gid);
181         return 0;
182     }
183 
TestBufferValue(char *buffer, uint32_t len)184     void TestBufferValue(char *buffer, uint32_t len)
185     {
186         const int printBase = 10;
187         for (uint32_t index = 0; index <= len; index++) {
188             buffer[index] = '0' + index % printBase;
189             if (index != 0 && index % printBase == 0) {
190                 buffer[index] = '.';
191             }
192         }
193         buffer[len] = '\0';
194     }
195 
TestNameIsValid()196     int TestNameIsValid()
197     {
198         char buffer[PARAM_BUFFER_SIZE];
199         // set name length = 127
200         TestBufferValue(buffer, PARAM_NAME_LEN_MAX - 1);
201         int ret = SystemWriteParam(buffer, "1111");
202         EXPECT_EQ(ret, 0);
203         TestBufferValue(buffer, PARAM_NAME_LEN_MAX);
204         ret = SystemWriteParam(buffer, "1111");
205         EXPECT_NE(ret, 0);
206         TestBufferValue(buffer, PARAM_NAME_LEN_MAX + 1);
207         ret = SystemWriteParam(buffer, "1111");
208         EXPECT_NE(ret, 0);
209 
210         // 保存一个只读的属性，大于最大值
211         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
212         ret = SystemWriteParam("const.test_readonly.dddddddddddddddddd.fffffffffffffffffff", buffer);
213         EXPECT_EQ(ret, 0);
214 
215         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX + 1);
216         ret = SystemWriteParam("const.test_readonly.aaaaaaaaaaaaaaaaaa.fffffffffffffffffff", buffer);
217         EXPECT_EQ(ret, 0);
218 
219         // 更新只读项目
220         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
221         ret = SystemWriteParam("const.test_readonly.dddddddddddddddddd.fffffffffffffffffff", buffer);
222         EXPECT_NE(ret, 0);
223 
224         // 写普通属性
225         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
226         ret = SystemWriteParam("test.bigvalue.dddddddddddddddddd.fffffffffffffffffff", buffer);
227         EXPECT_EQ(ret, 0);
228         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX + 1);
229         ret = SystemWriteParam("test.bigvalue.dddddddddddddddddd.fffffffffffffffffff", buffer);
230         EXPECT_NE(ret, 0);
231 
232         // invalid name
233         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
234         ret = SystemWriteParam("test.invalidname..fffffffffffffffffff", buffer);
235         EXPECT_NE(ret, 0);
236         ret = SystemWriteParam("test.invalidname.%fffffffffffffffffff", buffer);
237         EXPECT_NE(ret, 0);
238         ret = SystemWriteParam("test.invalidname.$fffffffffffffffffff", buffer);
239         EXPECT_NE(ret, 0);
240         return 0;
241     }
242 
TestParamTraversal()243     int TestParamTraversal()
244     {
245         char value[PARAM_BUFFER_SIZE + PARAM_BUFFER_SIZE] = {0};
246         SystemTraversalParameter(
247             "",
248             [](ParamHandle handle, void *cookie) {
249                 SystemGetParameterName(handle, (char *)cookie, PARAM_BUFFER_SIZE);
250                 u_int32_t len = PARAM_BUFFER_SIZE;
251                 SystemGetParameterValue(handle, ((char *)cookie) + PARAM_BUFFER_SIZE, &len);
252                 printf("$$$$$$$$Param %s=%s \n", (char *)cookie, ((char *)cookie) + PARAM_BUFFER_SIZE);
253             },
254             (void *)value);
255         return 0;
256     }
257 
TestUpdateParam(const char *name, const char *value)258     int TestUpdateParam(const char *name, const char *value)
259     {
260         SystemWriteParam(name, value);
261         SystemWriteParam(name, value);
262         SystemWriteParam(name, value);
263         SystemWriteParam(name, value);
264         CheckServerParamValue(name, value);
265         return 0;
266     }
267 
TestPersistParam()268     int TestPersistParam()
269     {
270         ParamAuditData auditData = {};
271         auditData.name = "persist.";
272         auditData.dacData.gid = 0;
273         auditData.dacData.uid = 0;
274         auditData.dacData.mode = 0777;  // 0777 test mode
275         AddSecurityLabel(&auditData);
276 
277         LoadPersistParams();
278         SystemWriteParam("persist.111.ffff.bbbb.cccc.dddd.eeee", "1101");
279         SystemWriteParam("persist.111.aaaa.bbbb.cccc.dddd.eeee", "1102");
280         SystemWriteParam("persist.111.bbbb.cccc.dddd.eeee", "1103");
281         CheckServerParamValue("persist.111.bbbb.cccc.dddd.eeee", "1103");
282 
283         SystemWriteParam("persist.111.cccc.bbbb.cccc.dddd.eeee", "1104");
284         SystemWriteParam("persist.111.eeee.bbbb.cccc.dddd.eeee", "1105");
285         CheckServerParamValue("persist.111.ffff.bbbb.cccc.dddd.eeee", "1101");
286         SystemWriteParam("persist.111.ffff.bbbb.cccc.dddd.eeee", "1106");
287         CheckServerParamValue("persist.111.ffff.bbbb.cccc.dddd.eeee", "1106");
288         sleep(1);
289         SystemWriteParam("persist.111.bbbb.cccc.dddd.1107", "1107");
290         SystemWriteParam("persist.111.bbbb.cccc.dddd.1108", "1108");
291         SystemWriteParam("persist.111.bbbb.cccc.dddd.1109", "1108");
292         sleep(1);
293         SystemWriteParam("persist.111.bbbb.cccc.dddd.1110", "1108");
294         SystemWriteParam("persist.111.bbbb.cccc.dddd.1111", "1108");
295         TimerCallbackForSave(nullptr, nullptr);
296         LoadPersistParams();
297         return 0;
298     }
299 
TestPrivatePersistParam()300     int TestPrivatePersistParam()
301     {
302         LoadPrivatePersistParams();
303         SystemWriteParam("persist.test.111.aaa.bbb.ccc", "111");
304         SystemWriteParam("persist.test.222.aaa.bbb.ccc", "222");
305         SystemWriteParam("persist.test.333.aaa.bbb.ccc", "333");
306         CheckServerParamValue("persist.test.333.aaa.bbb.ccc", "333");
307         sleep(1);
308         TimerCallbackForSave(nullptr, nullptr);
309         LoadPrivatePersistParams();
310         return 0;
311     }
312 
TestDumpParamMemory()313     int TestDumpParamMemory()
314     {
315         SystemDumpParameters(1, -1, nullptr);
316         return 0;
317     }
318 
GetWorkSpaceIndex(const char *name)319     uint32_t GetWorkSpaceIndex(const char *name)
320     {
321 #ifdef PARAM_SUPPORT_SELINUX
322         ParamWorkSpace *paramSpace = GetParamWorkSpace();
323         PARAM_CHECK(paramSpace != nullptr, return (uint32_t)-1, "Invalid paramSpace");
324         return (paramSpace->selinuxSpace.getParamLabelIndex != nullptr) ?
325             paramSpace->selinuxSpace.getParamLabelIndex(name) + WORKSPACE_INDEX_BASE : (uint32_t)-1;
326 #else
327         return 0;
328 #endif
329     }
330 };
331 
HWTEST_F(ParamUnitTest, Init_TestPersistParam_001, TestSize.Level0)332 HWTEST_F(ParamUnitTest, Init_TestPersistParam_001, TestSize.Level0)
333 {
334     ParamUnitTest test;
335     test.TestPersistParam();
336 }
337 
HWTEST_F(ParamUnitTest, Init_TestPersistParam_002, TestSize.Level0)338 HWTEST_F(ParamUnitTest, Init_TestPersistParam_002, TestSize.Level0)
339 {
340     ParamUnitTest test;
341     test.TestPrivatePersistParam();
342 }
343 
HWTEST_F(ParamUnitTest, Init_TestSetParam_001, TestSize.Level0)344 HWTEST_F(ParamUnitTest, Init_TestSetParam_001, TestSize.Level0)
345 {
346     ParamUnitTest test;
347     const char *params[][2] = {{"111.2222", "1"},
348                                {"111.2222.3333", "2"},
349                                {"111.2222.3333.4444", "3"},
350                                {"111.2222.3333.4444.666", "4"},
351                                {"111.2222.3333.4444.666.777", "5"}};
352     test.TestSetParams(params, 5);
353 }
354 
HWTEST_F(ParamUnitTest, Init_TestSetParam_002, TestSize.Level0)355 HWTEST_F(ParamUnitTest, Init_TestSetParam_002, TestSize.Level0)
356 {
357     ParamUnitTest test;
358     const char *params[][2] = {{"111.2222.xxxx.xxx.xxx", "1_1"},
359                                {"111.2222.3333.xxx", "1_2"},
360                                {"111.2222.xxxx.3333.4444", "1_3"},
361                                {"111.2222.3333.xxxx.4444.666", "1_4"},
362                                {"111.2222.3333.4444.666.xxxxx.777", "1_5"}};
363     test.TestSetParams(params, 5);
364 
365     const char *ctrlParams[][2] = {{"ctl.start.111.2222.xxxx.xxx.xxx", "2_1"},
366                                    {"ctl.start.111.2222.3333.xxx", "2_2"},
367                                    {"ctl.start.111.2222.xxxx.3333.4444", "2_3"},
368                                    {"ctl.start.111.2222.3333.xxxx.4444.666", "2_4"},
369                                    {"ctl.start.111.2222.3333.4444.666.xxxxx.777", "2_5"}};
370     test.TestSetParams(ctrlParams, 5);
371 
372     const char *sysParams[][2] = {{"ohos.startup.powerctrl.111.2222.xxxx.xxx.xxx", "3_1"},
373                                   {"ohos.startup.powerctrl.111.2222.3333.xxx", "3_2"},
374                                   {"ohos.startup.powerctrl.111.2222.xxxx.3333.4444", "3_3"},
375                                   {"ohos.startup.powerctrl.111.2222.3333.xxxx.4444.666", "3_4"},
376                                   {"ohos.startup.powerctrl.111.2222.3333.4444.666.xxxxx.777", "3_5"}};
377     test.TestSetParams(sysParams, 5);
378 }
379 
HWTEST_F(ParamUnitTest, Init_TestNameIsValid_001, TestSize.Level0)380 HWTEST_F(ParamUnitTest, Init_TestNameIsValid_001, TestSize.Level0)
381 {
382     ParamUnitTest test;
383     test.TestNameIsValid();
384 }
385 
HWTEST_F(ParamUnitTest, Init_TestParamValue_001, TestSize.Level0)386 HWTEST_F(ParamUnitTest, Init_TestParamValue_001, TestSize.Level0)
387 {
388     // support empty string
389     const char *name = "test_readonly.dddddddddddddddddd.fffffffffffffffffff";
390     int ret = SystemWriteParam(name, "");
391     EXPECT_EQ(ret, 0);
392     CheckServerParamValue(name, "");
393     ret = SystemWriteParam(name, "111111111");
394     EXPECT_EQ(ret, 0);
395     CheckServerParamValue(name, "111111111");
396     ret = SystemWriteParam(name, "");
397     EXPECT_EQ(ret, 0);
398     CheckServerParamValue(name, "");
399 }
400 
HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_001, TestSize.Level0)401 HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_001, TestSize.Level0)
402 {
403     ParamUnitTest test;
404     test.TestAddSecurityLabel1();
405 }
406 
HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_002, TestSize.Level0)407 HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_002, TestSize.Level0)
408 {
409     ParamUnitTest test;
410     test.TestAddSecurityLabel2();
411 }
412 
HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_003, TestSize.Level0)413 HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_003, TestSize.Level0)
414 {
415     ParamUnitTest test;
416     test.TestAddSecurityLabel3();
417 }
418 
HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_004, TestSize.Level0)419 HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_004, TestSize.Level0)
420 {
421     ParamUnitTest test;
422     test.TestAddSecurityLabel4();
423 }
424 
HWTEST_F(ParamUnitTest, Init_TestUpdateParam_001, TestSize.Level0)425 HWTEST_F(ParamUnitTest, Init_TestUpdateParam_001, TestSize.Level0)
426 {
427     ParamUnitTest test;
428     test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "100");
429     test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "101");
430     test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "102");
431     test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "103");
432     test.TestUpdateParam("net.tcp.default_init_rwnd", "60");
433 }
434 
HWTEST_F(ParamUnitTest, Init_TestParamTraversal_001, TestSize.Level0)435 HWTEST_F(ParamUnitTest, Init_TestParamTraversal_001, TestSize.Level0)
436 {
437     ParamUnitTest test;
438     test.TestParamTraversal();
439 }
440 
HWTEST_F(ParamUnitTest, Init_TestDumpParamMemory_001, TestSize.Level0)441 HWTEST_F(ParamUnitTest, Init_TestDumpParamMemory_001, TestSize.Level0)
442 {
443     ParamUnitTest test;
444     test.TestDumpParamMemory();
445 }
446 
HWTEST_F(ParamUnitTest, Init_TestLinuxRWLock_001, TestSize.Level0)447 HWTEST_F(ParamUnitTest, Init_TestLinuxRWLock_001, TestSize.Level0)
448 {
449     ParamRWMutexCreate(nullptr);
450     ParamRWMutexWRLock(nullptr);
451     ParamRWMutexRDLock(nullptr);
452     ParamRWMutexUnlock(nullptr);
453     ParamRWMutexDelete(nullptr);
454     ParamMutexDelete(nullptr);
455 }
456 
HWTEST_F(ParamUnitTest, Init_TestWorkSpace_001, TestSize.Level0)457 HWTEST_F(ParamUnitTest, Init_TestWorkSpace_001, TestSize.Level0)
458 {
459     int ret = AddWorkSpace("test.workspace.1", GetWorkSpaceIndex("test.workspace.1"), 0, PARAM_WORKSPACE_DEF);
460     EXPECT_EQ(ret, 0);
461     ret = AddWorkSpace("test.workspace.2", GetWorkSpaceIndex("test.workspace.2"), 0, PARAM_WORKSPACE_DEF);
462     EXPECT_EQ(ret, 0);
463     ret = AddWorkSpace("test.workspace.3", GetWorkSpaceIndex("test.workspace.3"), 0, PARAM_WORKSPACE_DEF);
464     EXPECT_EQ(ret, 0);
465     WorkSpace *space = GetWorkSpace(GetWorkSpaceIndex("test.workspace.1"));
466     EXPECT_NE(space, nullptr);
467     CloseWorkSpace(nullptr);
468 }
469 
HWTEST_F(ParamUnitTest, Init_TestWorkSpace_002, TestSize.Level0)470 HWTEST_F(ParamUnitTest, Init_TestWorkSpace_002, TestSize.Level0)
471 {
472     const char *spaceName = "test.workspace2";
473     const size_t size = strlen(spaceName) + 1;
474     WorkSpace *workSpace = (WorkSpace *)malloc(sizeof(WorkSpace) + size);
475     if (workSpace == nullptr) {
476         EXPECT_NE(workSpace, nullptr);
477         return;
478     }
479     workSpace->flags = 0;
480     workSpace->area = nullptr;
481     int ret = PARAM_STRCPY(workSpace->fileName, size, spaceName);
482     EXPECT_EQ(ret, 0);
483     CloseWorkSpace(workSpace);
484     free(workSpace);
485 }
486 
487 #if !(defined __LITEOS_A__ || defined __LITEOS_M__) // can not support parameter type
HWTEST_F(ParamUnitTest, Init_TestParamValueType_001, TestSize.Level0)488 HWTEST_F(ParamUnitTest, Init_TestParamValueType_001, TestSize.Level0)
489 {
490     int ret = SystemWriteParam("test.type.int.1000", "10000");
491     EXPECT_EQ(ret, 0);
492 
493     ret = SystemWriteParam("test.type.int.1001", "-1111111144444444444441111111666666661");
494     EXPECT_EQ(ret, PARAM_CODE_INVALID_VALUE);
495     ret = SystemWriteParam("test.type.int.1001", "1111111111444444444444411111166666666");
496     EXPECT_EQ(ret, PARAM_CODE_INVALID_VALUE);
497 }
498 
HWTEST_F(ParamUnitTest, Init_TestParamValueType_002, TestSize.Level0)499 HWTEST_F(ParamUnitTest, Init_TestParamValueType_002, TestSize.Level0)
500 {
501     int ret = SystemWriteParam("test.type.bool.1000", "10000");
502     EXPECT_EQ(ret, PARAM_CODE_INVALID_VALUE);
503 
504     ret = SystemWriteParam("test.type.bool.1001", "-1111111111111111");
505     EXPECT_EQ(ret, PARAM_CODE_INVALID_VALUE);
506     ret = SystemWriteParam("test.type.bool.1001", "1111111111111111");
507     EXPECT_EQ(ret, PARAM_CODE_INVALID_VALUE);
508     ret = SystemWriteParam("test.type.bool.1001", "true");
509     EXPECT_EQ(ret, 0);
510     ret = SystemWriteParam("test.type.bool.1001", "false");
511     EXPECT_EQ(ret, 0);
512     ret = SystemWriteParam("test.type.bool.1001", "1");
513     EXPECT_EQ(ret, 0);
514     ret = SystemWriteParam("test.type.bool.1001", "0");
515     EXPECT_EQ(ret, 0);
516     ret = SystemWriteParam("test.type.bool.1001", "on");
517     EXPECT_EQ(ret, 0);
518     ret = SystemWriteParam("test.type.bool.1001", "off");
519     EXPECT_EQ(ret, 0);
520     ret = SystemWriteParam("test.type.bool.1001", "yes");
521     EXPECT_EQ(ret, 0);
522     ret = SystemWriteParam("test.type.bool.1001", "no");
523     EXPECT_EQ(ret, 0);
524     ret = SystemWriteParam("test.type.bool.1001", "y");
525     EXPECT_EQ(ret, 0);
526     ret = SystemWriteParam("test.type.bool.1001", "n");
527     EXPECT_EQ(ret, 0);
528 }
529 #endif
530 
HWTEST_F(ParamUnitTest, Init_TestGetServiceCtlName_001, TestSize.Level0)531 HWTEST_F(ParamUnitTest, Init_TestGetServiceCtlName_001, TestSize.Level0)
532 {
533     ServiceCtrlInfo *serviceInfo = nullptr;
534     GetServiceCtrlInfo("ohos.startup.powerctrl", "reboot,updater", &serviceInfo);
535     if (serviceInfo != nullptr) {
536         EXPECT_STREQ(serviceInfo->realKey, "ohos.servicectrl.reboot.updater.reboot,updater");
537         free(serviceInfo);
538     }
539     GetServiceCtrlInfo("ohos.ctl.stop", "test", &serviceInfo);
540     if (serviceInfo != nullptr) {
541         EXPECT_STREQ(serviceInfo->realKey, "ohos.servicectrl.stop.test");
542         free(serviceInfo);
543     }
544     GetServiceCtrlInfo("ohos.servicectrl.stop", "test", &serviceInfo);
545     if (serviceInfo != nullptr) {
546         EXPECT_STREQ(serviceInfo->realKey, "ohos.servicectrl.stop.test");
547         free(serviceInfo);
548     }
549     ParamWorBaseLog(INIT_DEBUG, PARAN_DOMAIN, "PARAM", "%s", "ParamWorBaseLog");
550 }
551 
HWTEST_F(ParamUnitTest, Init_TestFindTrieNode_001, TestSize.Level0)552 HWTEST_F(ParamUnitTest, Init_TestFindTrieNode_001, TestSize.Level0)
553 {
554     int ret = AddWorkSpace("test.workspace.1", GetWorkSpaceIndex("test.workspace.1"), 0, PARAM_WORKSPACE_DEF);
555     EXPECT_EQ(ret, 0);
556     WorkSpace *space = GetWorkSpaceByName("test.workspace.1");
557     ASSERT_NE(space, nullptr);
558     ParamTrieNode *node = FindTrieNode(nullptr, nullptr, 0, nullptr);
559     ASSERT_EQ(node, nullptr);
560     node = FindTrieNode(space, nullptr, 0, nullptr);
561     ASSERT_EQ(node, nullptr);
562     node = FindTrieNode(space, "111111", 0, nullptr);
563     ASSERT_EQ(node, nullptr);
564     node = FindTrieNode(space, "find.test.111111", strlen("find.test.111111"), nullptr);
565     ASSERT_EQ(node, nullptr);
566 }
567 
568 #ifndef OHOS_LITE
HWTEST_F(ParamUnitTest, Init_TestConnectServer_001, TestSize.Level0)569 HWTEST_F(ParamUnitTest, Init_TestConnectServer_001, TestSize.Level0)
570 {
571     int ret = ConnectServer(-1, CLIENT_PIPE_NAME);
572     EXPECT_NE(ret, 0);
573     int fd = socket(PF_UNIX, SOCK_STREAM, 0);
574     ret = ConnectServer(fd, "");
575     EXPECT_NE(ret, 0);
576     ret = ConnectServer(fd, CLIENT_PIPE_NAME);
577     EXPECT_EQ(ret, 0);
578     close(fd);
579 }
580 
HWTEST_F(ParamUnitTest, Init_TestRequestMessage_001, TestSize.Level0)581 HWTEST_F(ParamUnitTest, Init_TestRequestMessage_001, TestSize.Level0)
582 {
583     const int maxSize = 1024 * 64 + 10;
584     const int msgSize = sizeof(ParamMessage) + 128; // 128 TEST
585     ParamMessage *msg = CreateParamMessage(0, nullptr, msgSize);
586     EXPECT_EQ(msg, nullptr);
587     msg = CreateParamMessage(0, "nullptr", maxSize);
588     EXPECT_EQ(msg, nullptr);
589     msg = CreateParamMessage(0, "22222222222222222222222222222222222222222"
590         "333333333333333333333333333333333333333333333333333333333333333333333"
591         "555555555555555555555555555555555555555555555555555555555555555555555", msgSize);
592     EXPECT_EQ(msg, nullptr);
593 
594     // success
595     msg = CreateParamMessage(0, "22222222222222222222222222222222222222222", msgSize);
596     EXPECT_NE(msg, nullptr);
597     uint32_t start = 0;
598     int ret = FillParamMsgContent(nullptr, &start, 0, nullptr, 0);
599     EXPECT_NE(ret, 0);
600     ret = FillParamMsgContent(msg, nullptr, 0, nullptr, 0);
601     EXPECT_NE(ret, 0);
602     ret = FillParamMsgContent(msg, &start, 0, nullptr, 0);
603     EXPECT_NE(ret, 0);
604     ret = FillParamMsgContent(msg, &start, 0, "22222", 0);
605     EXPECT_EQ(ret, 0);
606     ret = FillParamMsgContent(msg, &start, 0, "22222", msgSize);
607     EXPECT_NE(ret, 0);
608     // fill success
609     ret = FillParamMsgContent(msg, &start, 0, "22222", strlen("22222"));
610     EXPECT_EQ(ret, 0);
611     msg->msgSize = start + sizeof(ParamMessage);
612 
613     uint32_t offset = 0;
614     ParamMsgContent *content = GetNextContent(nullptr, &offset);
615     EXPECT_EQ(content, nullptr);
616     content = GetNextContent(msg, nullptr);
617     EXPECT_EQ(content, nullptr);
618     offset = 0;
619     content = GetNextContent(msg, &offset);
620     EXPECT_NE(content, nullptr);
621     content = GetNextContent(msg, &offset);
622     EXPECT_NE(content, nullptr);
623     free(msg);
624 }
625 
HWTEST_F(ParamUnitTest, Init_TestServerTaskFail_001, TestSize.Level0)626 HWTEST_F(ParamUnitTest, Init_TestServerTaskFail_001, TestSize.Level0)
627 {
628     ParamTaskPtr serverTask = nullptr;
629     ParamStreamInfo info = {};
630     info.server = const_cast<char *>(PIPE_NAME);
631     info.close = nullptr;
632     info.recvMessage = nullptr;
633     info.incomingConnect = nullptr;
634     int ret = ParamServerCreate(nullptr, &info);
635     EXPECT_NE(ret, 0);
636     ret = ParamServerCreate(&serverTask, nullptr);
637     EXPECT_NE(ret, 0);
638     ret = ParamServerCreate(&serverTask, &info);
639     EXPECT_NE(ret, 0);
640 }
641 
HWTEST_F(ParamUnitTest, Init_TestStreamTaskFail_001, TestSize.Level0)642 HWTEST_F(ParamUnitTest, Init_TestStreamTaskFail_001, TestSize.Level0)
643 {
644     ParamTaskPtr client = nullptr;
645     ParamStreamInfo info = {};
646     info.flags = PARAM_TEST_FLAGS;
647     info.server = nullptr;
648     info.close = OnClose;
649     info.recvMessage = ProcessMessage;
650     info.incomingConnect = nullptr;
651 
652     int ret = ParamStreamCreate(&client, nullptr, &info, sizeof(ParamWatcher));
653     EXPECT_NE(ret, 0);
654     ret = ParamStreamCreate(&client, GetParamService()->serverTask, nullptr, sizeof(ParamWatcher));
655     EXPECT_NE(ret, 0);
656     info.close = nullptr;
657     ret = ParamStreamCreate(&client, GetParamService()->serverTask, &info, sizeof(ParamWatcher));
658     EXPECT_NE(ret, 0);
659     info.close = OnClose;
660     info.recvMessage = nullptr;
661     ret = ParamStreamCreate(&client, GetParamService()->serverTask, &info, sizeof(ParamWatcher));
662     EXPECT_NE(ret, 0);
663     ret = ParamStreamCreate(&client, nullptr, nullptr, sizeof(ParamWatcher));
664     EXPECT_NE(ret, 0);
665 
666     void *data = ParamGetTaskUserData(client);
667     EXPECT_EQ(data, nullptr);
668 
669     ret = ParamTaskSendMsg(nullptr, nullptr);
670     EXPECT_NE(ret, 0);
671     ret = ParamTaskSendMsg(GetParamService()->serverTask, nullptr);
672     EXPECT_NE(ret, 0);
673 }
674 
HWTEST_F(ParamUnitTest, Init_TestParamCache_001, TestSize.Level0)675 HWTEST_F(ParamUnitTest, Init_TestParamCache_001, TestSize.Level0)
676 {
677     const char *value = CachedParameterGet(nullptr);
678     EXPECT_EQ(value, nullptr);
679     const char *name = "test.write.1111111.222222";
680     CachedHandle cacheHandle = CachedParameterCreate(name, "true");
681     EXPECT_NE(cacheHandle, nullptr);
682     value = CachedParameterGet(cacheHandle);
683     EXPECT_EQ(strcmp(value, "true"), 0);
684     uint32_t dataIndex = 0;
685     int ret = WriteParam(name, "false", &dataIndex, 0);
686     EXPECT_EQ(ret, 0);
687     value = CachedParameterGet(cacheHandle);
688     EXPECT_EQ(strcmp(value, "false"), 0);
689     CachedParameterDestroy(cacheHandle);
690 
691     // cache 2, for parameter exist
692     CachedHandle cacheHandle3 = CachedParameterCreate(name, "true");
693     EXPECT_NE(cacheHandle3, nullptr);
694     value = CachedParameterGet(cacheHandle3);
695     EXPECT_EQ(strcmp(value, "false"), 0);
696     ret = WriteParam(name, "2222222", &dataIndex, 0);
697     EXPECT_EQ(ret, 0);
698     int valueChange = 0;
699     value = CachedParameterGetChanged(cacheHandle3, &valueChange);
700     EXPECT_EQ(strcmp(value, "2222222"), 0);
701     EXPECT_EQ(valueChange, 1);
702     CachedParameterGetChanged(cacheHandle3, nullptr);
703     CachedParameterDestroy(cacheHandle3);
704 }
705 #endif
706 }
707