• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
332 HWTEST_F(ParamUnitTest, Init_TestPersistParam_001, TestSize.Level0)
333 {
334     ParamUnitTest test;
335     int ret = test.TestPersistParam();
336     EXPECT_EQ(ret, 0);
337 }
338 
339 HWTEST_F(ParamUnitTest, Init_TestPersistParam_002, TestSize.Level0)
340 {
341     ParamUnitTest test;
342     int ret = test.TestPrivatePersistParam();
343     EXPECT_EQ(ret, 0);
344 }
345 
346 HWTEST_F(ParamUnitTest, Init_TestSetParam_001, TestSize.Level0)
347 {
348     ParamUnitTest test;
349     const char *params[][2] = {{"111.2222", "1"},
350                                {"111.2222.3333", "2"},
351                                {"111.2222.3333.4444", "3"},
352                                {"111.2222.3333.4444.666", "4"},
353                                {"111.2222.3333.4444.666.777", "5"}};
354     int ret = test.TestSetParams(params, 5);
355     EXPECT_EQ(ret, 0);
356 }
357 
358 HWTEST_F(ParamUnitTest, Init_TestSetParam_002, TestSize.Level0)
359 {
360     ParamUnitTest test;
361     const char *params[][2] = {{"111.2222.xxxx.xxx.xxx", "1_1"},
362                                {"111.2222.3333.xxx", "1_2"},
363                                {"111.2222.xxxx.3333.4444", "1_3"},
364                                {"111.2222.3333.xxxx.4444.666", "1_4"},
365                                {"111.2222.3333.4444.666.xxxxx.777", "1_5"}};
366     int ret = test.TestSetParams(params, 5);
367     EXPECT_EQ(ret, 0);
368 
369     const char *ctrlParams[][2] = {{"ctl.start.111.2222.xxxx.xxx.xxx", "2_1"},
370                                    {"ctl.start.111.2222.3333.xxx", "2_2"},
371                                    {"ctl.start.111.2222.xxxx.3333.4444", "2_3"},
372                                    {"ctl.start.111.2222.3333.xxxx.4444.666", "2_4"},
373                                    {"ctl.start.111.2222.3333.4444.666.xxxxx.777", "2_5"}};
374     ret = test.TestSetParams(ctrlParams, 5);
375     EXPECT_EQ(ret, 0);
376 
377     const char *sysParams[][2] = {{"ohos.startup.powerctrl.111.2222.xxxx.xxx.xxx", "3_1"},
378                                   {"ohos.startup.powerctrl.111.2222.3333.xxx", "3_2"},
379                                   {"ohos.startup.powerctrl.111.2222.xxxx.3333.4444", "3_3"},
380                                   {"ohos.startup.powerctrl.111.2222.3333.xxxx.4444.666", "3_4"},
381                                   {"ohos.startup.powerctrl.111.2222.3333.4444.666.xxxxx.777", "3_5"}};
382     ret = test.TestSetParams(sysParams, 5);
383     EXPECT_EQ(ret, 0);
384 }
385 
386 HWTEST_F(ParamUnitTest, Init_TestNameIsValid_001, TestSize.Level0)
387 {
388     ParamUnitTest test;
389     int ret = test.TestNameIsValid();
390     EXPECT_EQ(ret, 0);
391 }
392 
393 HWTEST_F(ParamUnitTest, Init_TestParamValue_001, TestSize.Level0)
394 {
395     // support empty string
396     const char *name = "test_readonly.dddddddddddddddddd.fffffffffffffffffff";
397     int ret = SystemWriteParam(name, "");
398     EXPECT_EQ(ret, 0);
399     CheckServerParamValue(name, "");
400     ret = SystemWriteParam(name, "111111111");
401     EXPECT_EQ(ret, 0);
402     CheckServerParamValue(name, "111111111");
403     ret = SystemWriteParam(name, "");
404     EXPECT_EQ(ret, 0);
405     CheckServerParamValue(name, "");
406 }
407 
408 HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_001, TestSize.Level0)
409 {
410     ParamUnitTest test;
411     int ret = test.TestAddSecurityLabel1();
412     EXPECT_EQ(ret, 0);
413 }
414 
415 HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_002, TestSize.Level0)
416 {
417     ParamUnitTest test;
418     int ret = test.TestAddSecurityLabel2();
419     EXPECT_EQ(ret, 0);
420 }
421 
422 HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_003, TestSize.Level0)
423 {
424     ParamUnitTest test;
425     int ret = test.TestAddSecurityLabel3();
426     EXPECT_EQ(ret, 0);
427 }
428 
429 HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_004, TestSize.Level0)
430 {
431     ParamUnitTest test;
432     int ret = test.TestAddSecurityLabel4();
433     EXPECT_EQ(ret, 0);
434 }
435 
436 HWTEST_F(ParamUnitTest, Init_TestUpdateParam_001, TestSize.Level0)
437 {
438     ParamUnitTest test;
439     int ret = test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "100");
440     EXPECT_EQ(ret, 0);
441     ret = test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "101");
442     EXPECT_EQ(ret, 0);
443     ret = test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "102");
444     EXPECT_EQ(ret, 0);
445     ret = test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "103");
446     EXPECT_EQ(ret, 0);
447     ret = test.TestUpdateParam("net.tcp.default_init_rwnd", "60");
448     EXPECT_EQ(ret, 0);
449 }
450 
451 HWTEST_F(ParamUnitTest, Init_TestParamTraversal_001, TestSize.Level0)
452 {
453     ParamUnitTest test;
454     int ret = test.TestParamTraversal();
455     EXPECT_EQ(ret, 0);
456 }
457 
458 HWTEST_F(ParamUnitTest, Init_TestDumpParamMemory_001, TestSize.Level0)
459 {
460     ParamUnitTest test;
461     int ret = test.TestDumpParamMemory();
462     EXPECT_EQ(ret, 0);
463 }
464 
465 HWTEST_F(ParamUnitTest, Init_TestLinuxRWLock_001, TestSize.Level0)
466 {
467     int ret = ParamRWMutexCreate(nullptr);
468     EXPECT_EQ(ret, -1);
469     ret = ParamRWMutexWRLock(nullptr);
470     EXPECT_EQ(ret, -1);
471     ret = ParamRWMutexRDLock(nullptr);
472     EXPECT_EQ(ret, -1);
473     ret = ParamRWMutexUnlock(nullptr);
474     EXPECT_EQ(ret, -1);
475     ret = ParamRWMutexDelete(nullptr);
476     EXPECT_EQ(ret, -1);
477     ret = ParamMutexDelete(nullptr);
478     EXPECT_EQ(ret, 0);
479 }
480 
481 HWTEST_F(ParamUnitTest, Init_TestWorkSpace_001, TestSize.Level0)
482 {
483     int ret = AddWorkSpace("test.workspace.1", GetWorkSpaceIndex("test.workspace.1"), 0, PARAM_WORKSPACE_DEF);
484     EXPECT_EQ(ret, 0);
485     ret = AddWorkSpace("test.workspace.2", GetWorkSpaceIndex("test.workspace.2"), 0, PARAM_WORKSPACE_DEF);
486     EXPECT_EQ(ret, 0);
487     ret = AddWorkSpace("test.workspace.3", GetWorkSpaceIndex("test.workspace.3"), 0, PARAM_WORKSPACE_DEF);
488     EXPECT_EQ(ret, 0);
489     WorkSpace *space = GetWorkSpace(GetWorkSpaceIndex("test.workspace.1"));
490     EXPECT_NE(space, nullptr);
491     CloseWorkSpace(nullptr);
492 }
493 
494 HWTEST_F(ParamUnitTest, Init_TestWorkSpace_002, TestSize.Level0)
495 {
496     const char *spaceName = "test.workspace2";
497     const size_t size = strlen(spaceName) + 1;
498     WorkSpace *workSpace = (WorkSpace *)malloc(sizeof(WorkSpace) + size);
499     if (workSpace == nullptr) {
500         EXPECT_NE(workSpace, nullptr);
501         return;
502     }
503     workSpace->flags = 0;
504     workSpace->area = nullptr;
505     int ret = PARAM_STRCPY(workSpace->fileName, size, spaceName);
506     EXPECT_EQ(ret, 0);
507     CloseWorkSpace(workSpace);
508     free(workSpace);
509 }
510 
511 #if !(defined __LITEOS_A__ || defined __LITEOS_M__) // can not support parameter type
512 HWTEST_F(ParamUnitTest, Init_TestParamValueType_001, TestSize.Level0)
513 {
514     int ret = SystemWriteParam("test.type.int.1000", "10000");
515     EXPECT_EQ(ret, 0);
516 
517     ret = SystemWriteParam("test.type.int.1001", "-1111111144444444444441111111666666661");
518     EXPECT_EQ(ret, PARAM_CODE_INVALID_VALUE);
519     ret = SystemWriteParam("test.type.int.1001", "1111111111444444444444411111166666666");
520     EXPECT_EQ(ret, PARAM_CODE_INVALID_VALUE);
521 }
522 
523 HWTEST_F(ParamUnitTest, Init_TestParamValueType_002, TestSize.Level0)
524 {
525     int ret = SystemWriteParam("test.type.bool.1000", "10000");
526     EXPECT_EQ(ret, PARAM_CODE_INVALID_VALUE);
527 
528     ret = SystemWriteParam("test.type.bool.1001", "-1111111111111111");
529     EXPECT_EQ(ret, PARAM_CODE_INVALID_VALUE);
530     ret = SystemWriteParam("test.type.bool.1001", "1111111111111111");
531     EXPECT_EQ(ret, PARAM_CODE_INVALID_VALUE);
532     ret = SystemWriteParam("test.type.bool.1001", "true");
533     EXPECT_EQ(ret, 0);
534     ret = SystemWriteParam("test.type.bool.1001", "false");
535     EXPECT_EQ(ret, 0);
536     ret = SystemWriteParam("test.type.bool.1001", "1");
537     EXPECT_EQ(ret, 0);
538     ret = SystemWriteParam("test.type.bool.1001", "0");
539     EXPECT_EQ(ret, 0);
540     ret = SystemWriteParam("test.type.bool.1001", "on");
541     EXPECT_EQ(ret, 0);
542     ret = SystemWriteParam("test.type.bool.1001", "off");
543     EXPECT_EQ(ret, 0);
544     ret = SystemWriteParam("test.type.bool.1001", "yes");
545     EXPECT_EQ(ret, 0);
546     ret = SystemWriteParam("test.type.bool.1001", "no");
547     EXPECT_EQ(ret, 0);
548     ret = SystemWriteParam("test.type.bool.1001", "y");
549     EXPECT_EQ(ret, 0);
550     ret = SystemWriteParam("test.type.bool.1001", "n");
551     EXPECT_EQ(ret, 0);
552 }
553 #endif
554 
555 HWTEST_F(ParamUnitTest, Init_TestGetServiceCtlName_001, TestSize.Level0)
556 {
557     ServiceCtrlInfo *serviceInfo = nullptr;
558     GetServiceCtrlInfo("ohos.startup.powerctrl", "reboot,updater", &serviceInfo);
559     if (serviceInfo != nullptr) {
560         EXPECT_STREQ(serviceInfo->realKey, "ohos.servicectrl.reboot.updater.reboot,updater");
561         free(serviceInfo);
562     }
563     GetServiceCtrlInfo("ohos.ctl.stop", "test", &serviceInfo);
564     if (serviceInfo != nullptr) {
565         EXPECT_STREQ(serviceInfo->realKey, "ohos.servicectrl.stop.test");
566         free(serviceInfo);
567     }
568     GetServiceCtrlInfo("ohos.servicectrl.stop", "test", &serviceInfo);
569     if (serviceInfo != nullptr) {
570         EXPECT_STREQ(serviceInfo->realKey, "ohos.servicectrl.stop.test");
571         free(serviceInfo);
572     }
573     ParamWorBaseLog(INIT_DEBUG, PARAN_DOMAIN, "PARAM", "%s", "ParamWorBaseLog");
574 }
575 
576 HWTEST_F(ParamUnitTest, Init_TestFindTrieNode_001, TestSize.Level0)
577 {
578     int ret = AddWorkSpace("test.workspace.1", GetWorkSpaceIndex("test.workspace.1"), 0, PARAM_WORKSPACE_DEF);
579     EXPECT_EQ(ret, 0);
580     WorkSpace *space = GetWorkSpaceByName("test.workspace.1");
581     ASSERT_NE(space, nullptr);
582     ParamTrieNode *node = FindTrieNode(nullptr, nullptr, 0, nullptr);
583     ASSERT_EQ(node, nullptr);
584     node = FindTrieNode(space, nullptr, 0, nullptr);
585     ASSERT_EQ(node, nullptr);
586     node = FindTrieNode(space, "111111", 0, nullptr);
587     ASSERT_EQ(node, nullptr);
588     node = FindTrieNode(space, "find.test.111111", strlen("find.test.111111"), nullptr);
589     ASSERT_EQ(node, nullptr);
590 }
591 
592 #ifndef OHOS_LITE
593 HWTEST_F(ParamUnitTest, Init_TestConnectServer_001, TestSize.Level0)
594 {
595     int ret = ConnectServer(-1, CLIENT_PIPE_NAME);
596     EXPECT_NE(ret, 0);
597     int fd = socket(PF_UNIX, SOCK_STREAM, 0);
598     ret = ConnectServer(fd, "");
599     EXPECT_NE(ret, 0);
600     ret = ConnectServer(fd, CLIENT_PIPE_NAME);
601     EXPECT_EQ(ret, 0);
602     close(fd);
603 }
604 
605 HWTEST_F(ParamUnitTest, Init_TestRequestMessage_001, TestSize.Level0)
606 {
607     const int maxSize = 1024 * 64 + 10;
608     const int msgSize = sizeof(ParamMessage) + 128; // 128 TEST
609     ParamMessage *msg = CreateParamMessage(0, nullptr, msgSize);
610     EXPECT_EQ(msg, nullptr);
611     msg = CreateParamMessage(0, "nullptr", maxSize);
612     EXPECT_EQ(msg, nullptr);
613     msg = CreateParamMessage(0, "22222222222222222222222222222222222222222"
614         "333333333333333333333333333333333333333333333333333333333333333333333"
615         "555555555555555555555555555555555555555555555555555555555555555555555", msgSize);
616     EXPECT_EQ(msg, nullptr);
617 
618     // success
619     msg = CreateParamMessage(0, "22222222222222222222222222222222222222222", msgSize);
620     EXPECT_NE(msg, nullptr);
621     uint32_t start = 0;
622     int ret = FillParamMsgContent(nullptr, &start, 0, nullptr, 0);
623     EXPECT_NE(ret, 0);
624     ret = FillParamMsgContent(msg, nullptr, 0, nullptr, 0);
625     EXPECT_NE(ret, 0);
626     ret = FillParamMsgContent(msg, &start, 0, nullptr, 0);
627     EXPECT_NE(ret, 0);
628     ret = FillParamMsgContent(msg, &start, 0, "22222", 0);
629     EXPECT_EQ(ret, 0);
630     ret = FillParamMsgContent(msg, &start, 0, "22222", msgSize);
631     EXPECT_NE(ret, 0);
632     // fill success
633     ret = FillParamMsgContent(msg, &start, 0, "22222", strlen("22222"));
634     EXPECT_EQ(ret, 0);
635     msg->msgSize = start + sizeof(ParamMessage);
636 
637     uint32_t offset = 0;
638     ParamMsgContent *content = GetNextContent(nullptr, &offset);
639     EXPECT_EQ(content, nullptr);
640     content = GetNextContent(msg, nullptr);
641     EXPECT_EQ(content, nullptr);
642     offset = 0;
643     content = GetNextContent(msg, &offset);
644     EXPECT_NE(content, nullptr);
645     content = GetNextContent(msg, &offset);
646     EXPECT_NE(content, nullptr);
647     free(msg);
648 }
649 
650 HWTEST_F(ParamUnitTest, Init_TestServerTaskFail_001, TestSize.Level0)
651 {
652     ParamTaskPtr serverTask = nullptr;
653     ParamStreamInfo info = {};
654     info.server = const_cast<char *>(PIPE_NAME);
655     info.close = nullptr;
656     info.recvMessage = nullptr;
657     info.incomingConnect = nullptr;
658     int ret = ParamServerCreate(nullptr, &info);
659     EXPECT_NE(ret, 0);
660     ret = ParamServerCreate(&serverTask, nullptr);
661     EXPECT_NE(ret, 0);
662     ret = ParamServerCreate(&serverTask, &info);
663     EXPECT_NE(ret, 0);
664 }
665 
666 HWTEST_F(ParamUnitTest, Init_TestStreamTaskFail_001, TestSize.Level0)
667 {
668     ParamTaskPtr client = nullptr;
669     ParamStreamInfo info = {};
670     info.flags = PARAM_TEST_FLAGS;
671     info.server = nullptr;
672     info.close = OnClose;
673     info.recvMessage = ProcessMessage;
674     info.incomingConnect = nullptr;
675 
676     int ret = ParamStreamCreate(&client, nullptr, &info, sizeof(ParamWatcher));
677     EXPECT_NE(ret, 0);
678     ret = ParamStreamCreate(&client, GetParamService()->serverTask, nullptr, sizeof(ParamWatcher));
679     EXPECT_NE(ret, 0);
680     info.close = nullptr;
681     ret = ParamStreamCreate(&client, GetParamService()->serverTask, &info, sizeof(ParamWatcher));
682     EXPECT_NE(ret, 0);
683     info.close = OnClose;
684     info.recvMessage = nullptr;
685     ret = ParamStreamCreate(&client, GetParamService()->serverTask, &info, sizeof(ParamWatcher));
686     EXPECT_NE(ret, 0);
687     ret = ParamStreamCreate(&client, nullptr, nullptr, sizeof(ParamWatcher));
688     EXPECT_NE(ret, 0);
689 
690     void *data = ParamGetTaskUserData(client);
691     EXPECT_EQ(data, nullptr);
692 
693     ret = ParamTaskSendMsg(nullptr, nullptr);
694     EXPECT_NE(ret, 0);
695     ret = ParamTaskSendMsg(GetParamService()->serverTask, nullptr);
696     EXPECT_NE(ret, 0);
697 }
698 
699 HWTEST_F(ParamUnitTest, Init_TestParamCache_001, TestSize.Level0)
700 {
701     const char *value = CachedParameterGet(nullptr);
702     EXPECT_EQ(value, nullptr);
703     const char *name = "test.write.1111111.222222";
704     CachedHandle cacheHandle = CachedParameterCreate(name, "true");
705     EXPECT_NE(cacheHandle, nullptr);
706     value = CachedParameterGet(cacheHandle);
707     EXPECT_EQ(strcmp(value, "true"), 0);
708     uint32_t dataIndex = 0;
709     int ret = WriteParam(name, "false", &dataIndex, 0);
710     EXPECT_EQ(ret, 0);
711     value = CachedParameterGet(cacheHandle);
712     EXPECT_EQ(strcmp(value, "false"), 0);
713     CachedParameterDestroy(cacheHandle);
714 
715     // cache 2, for parameter exist
716     CachedHandle cacheHandle3 = CachedParameterCreate(name, "true");
717     EXPECT_NE(cacheHandle3, nullptr);
718     value = CachedParameterGet(cacheHandle3);
719     EXPECT_EQ(strcmp(value, "false"), 0);
720     ret = WriteParam(name, "2222222", &dataIndex, 0);
721     EXPECT_EQ(ret, 0);
722     int valueChange = 0;
723     value = CachedParameterGetChanged(cacheHandle3, &valueChange);
724     EXPECT_EQ(strcmp(value, "2222222"), 0);
725     EXPECT_EQ(valueChange, 1);
726     CachedParameterGetChanged(cacheHandle3, nullptr);
727     CachedParameterDestroy(cacheHandle3);
728 }
729 #endif
730 }
731