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