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