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
28using namespace testing::ext;
29using namespace std;
30
31extern "C" {
32void ParamWorBaseLog(InitLogLevel logLevel, uint32_t domain, const char *tag, const char *fmt, ...);
33static void OnClose(const TaskHandle taskHandle)
34{
35}
36}
37
38static 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
51namespace init_ut {
52class ParamUnitTest : public ::testing::Test {
53public:
54    ParamUnitTest() {}
55    virtual ~ParamUnitTest() {}
56
57    static void SetUpTestCase(void) {}
58    void SetUp() {}
59    void TearDown() {}
60    void TestBody() {}
61
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
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，最长匹配到这个节点
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，最长匹配到最后一个相同节点
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，完全匹配
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
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
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
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
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
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
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
313    int TestDumpParamMemory()
314    {
315        SystemDumpParameters(1, -1, nullptr);
316        return 0;
317    }
318
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
332HWTEST_F(ParamUnitTest, Init_TestPersistParam_001, TestSize.Level0)
333{
334    ParamUnitTest test;
335    test.TestPersistParam();
336}
337
338HWTEST_F(ParamUnitTest, Init_TestPersistParam_002, TestSize.Level0)
339{
340    ParamUnitTest test;
341    test.TestPrivatePersistParam();
342}
343
344HWTEST_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
355HWTEST_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
380HWTEST_F(ParamUnitTest, Init_TestNameIsValid_001, TestSize.Level0)
381{
382    ParamUnitTest test;
383    test.TestNameIsValid();
384}
385
386HWTEST_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
401HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_001, TestSize.Level0)
402{
403    ParamUnitTest test;
404    test.TestAddSecurityLabel1();
405}
406
407HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_002, TestSize.Level0)
408{
409    ParamUnitTest test;
410    test.TestAddSecurityLabel2();
411}
412
413HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_003, TestSize.Level0)
414{
415    ParamUnitTest test;
416    test.TestAddSecurityLabel3();
417}
418
419HWTEST_F(ParamUnitTest, Init_TestAddSecurityLabel_004, TestSize.Level0)
420{
421    ParamUnitTest test;
422    test.TestAddSecurityLabel4();
423}
424
425HWTEST_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
435HWTEST_F(ParamUnitTest, Init_TestParamTraversal_001, TestSize.Level0)
436{
437    ParamUnitTest test;
438    test.TestParamTraversal();
439}
440
441HWTEST_F(ParamUnitTest, Init_TestDumpParamMemory_001, TestSize.Level0)
442{
443    ParamUnitTest test;
444    test.TestDumpParamMemory();
445}
446
447HWTEST_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
457HWTEST_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
470HWTEST_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
488HWTEST_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
499HWTEST_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
531HWTEST_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
552HWTEST_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
569HWTEST_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
581HWTEST_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
626HWTEST_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
642HWTEST_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
675HWTEST_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