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_message.h"
19 #include "param_stub.h"
20 #include "param_init.h"
21 #include "trigger_manager.h"
22 #include "le_timer.h"
23 
24 using namespace testing::ext;
25 using namespace std;
26 
TestTriggerExecute(TriggerNode * trigger,const char * content,uint32_t size)27 static int TestTriggerExecute(TriggerNode *trigger, const char *content, uint32_t size)
28 {
29     return 0;
30 }
31 
CheckServerParamValue(const char * name,const char * expectValue)32 static int CheckServerParamValue(const char *name, const char *expectValue)
33 {
34     char tmp[PARAM_BUFFER_SIZE] = {0};
35     u_int32_t len = sizeof(tmp);
36     SystemReadParam(name, tmp, &len);
37     printf("CheckParamValue name %s value: \'%s\' expectValue:\'%s\' \n", name, tmp, expectValue);
38     EXPECT_NE((int)strlen(tmp), 0);
39     if (expectValue != nullptr) {
40         EXPECT_EQ(strcmp(tmp, expectValue), 0);
41     }
42     return 0;
43 }
44 
45 namespace init_ut {
46 static ParamTaskPtr g_worker = nullptr;
47 class ParamServiceUnitTest : public ::testing::Test {
48 public:
ParamServiceUnitTest()49     ParamServiceUnitTest() {}
~ParamServiceUnitTest()50     virtual ~ParamServiceUnitTest() {}
51 
SetUpTestCase(void)52     static void SetUpTestCase(void) {}
53 
SetUp()54     void SetUp()
55     {
56         if (GetParamSecurityLabel() != nullptr) {
57             GetParamSecurityLabel()->cred.uid = 1000;  // 1000 test uid
58             GetParamSecurityLabel()->cred.gid = 1000;  // 1000 test gid
59         }
60     }
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         // 获取到跟属性
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, 0);
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         GetParamSecurityLabel()->cred.gid = 9999;  // 9999 test gid
162         const char *name = "label4.test.aaa.bbb.ccc.dddd.eee";
163         const char *value = "2001";
164         ParamAuditData auditData = {};
165         auditData.name = "label4.test.aaa.bbb.ccc.dddd.eee";
166         auditData.dacData.gid = 203;  // 203 test gid
167         auditData.dacData.uid = geteuid();
168         auditData.dacData.mode = 0666;  // 0666 test mode
169         SystemWriteParam(name, value);
170         uint32_t labelIndex = 0;
171         AddSecurityLabel(&auditData);
172         WorkSpace *workspace = GetWorkSpace(WORKSPACE_INDEX_DAC);
173         ParamTrieNode *paramNode = FindTrieNode(workspace, name, strlen(name), &labelIndex);
174         ParamSecurityNode *node = (ParamSecurityNode *)GetTrieNode(workspace, labelIndex);
175         if (paramNode == nullptr || node == nullptr) {
176             EXPECT_EQ(1, 0);
177             return 0;
178         }
179         EXPECT_EQ(node->gid, auditData.dacData.gid);
180         return 0;
181     }
182 
TestBufferValue(char * buffer,uint32_t len)183     void TestBufferValue(char *buffer, uint32_t len)
184     {
185         const int printBase = 10;
186         for (uint32_t index = 0; index <= len; index++) {
187             buffer[index] = '0' + index % printBase;
188             if (index != 0 && index % printBase == 0) {
189                 buffer[index] = '.';
190             }
191         }
192         buffer[len] = '\0';
193     }
194 
TestNameIsValid()195     int TestNameIsValid()
196     {
197         char buffer[PARAM_BUFFER_SIZE];
198         // set name length = 127
199         TestBufferValue(buffer, PARAM_NAME_LEN_MAX - 1);
200         int ret = SystemWriteParam(buffer, "1111");
201         EXPECT_EQ(ret, 0);
202         TestBufferValue(buffer, PARAM_NAME_LEN_MAX);
203         ret = SystemWriteParam(buffer, "1111");
204         EXPECT_NE(ret, 0);
205         TestBufferValue(buffer, PARAM_NAME_LEN_MAX + 1);
206         ret = SystemWriteParam(buffer, "1111");
207         EXPECT_NE(ret, 0);
208 
209         ret = SystemWriteParam(" ", "1111");
210         EXPECT_NE(ret, 0);
211         ret = SystemWriteParam("__.__..", "1111");
212         EXPECT_NE(ret, 0);
213         ret = SystemWriteParam(".__..", "1111");
214         EXPECT_NE(ret, 0);
215         ret = SystemWriteParam("test.-@:_", "1111");
216         EXPECT_EQ(ret, 0);
217 
218         // 保存一个只读的属性，大于最大值
219         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
220         ret = SystemWriteParam("const.test_readonly.dddddddddddddddddd.fffffffffffffffffff", buffer);
221         EXPECT_EQ(ret, 0);
222 
223         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX + 1);
224         ret = SystemWriteParam("const.test_readonly.aaaaaaaaaaaaaaaaaa.fffffffffffffffffff", buffer);
225         EXPECT_EQ(ret, 0);
226 
227         // 更新只读项目
228         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
229         ret = SystemWriteParam("const.test_readonly.dddddddddddddddddd.fffffffffffffffffff", buffer);
230         EXPECT_NE(ret, 0);
231 
232         // 写普通属性
233         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
234         ret = SystemWriteParam("test.bigvalue.dddddddddddddddddd.fffffffffffffffffff", buffer);
235         EXPECT_EQ(ret, 0);
236         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX + 1);
237         ret = SystemWriteParam("test.bigvalue.dddddddddddddddddd.fffffffffffffffffff", buffer);
238         EXPECT_NE(ret, 0);
239 
240         // invalid name
241         TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
242         ret = SystemWriteParam("test.invalidname..fffffffffffffffffff", buffer);
243         EXPECT_NE(ret, 0);
244         ret = SystemWriteParam("test.invalidname.%fffffffffffffffffff", buffer);
245         EXPECT_NE(ret, 0);
246         ret = SystemWriteParam("test.invalidname.$fffffffffffffffffff", buffer);
247         EXPECT_NE(ret, 0);
248         return 0;
249     }
250 
TestParamTraversal()251     int TestParamTraversal()
252     {
253         char value[PARAM_BUFFER_SIZE + PARAM_BUFFER_SIZE] = {0};
254         SystemTraversalParameter(
255             "",
256             [](ParamHandle handle, void *cookie) {
257                 SystemGetParameterName(handle, (char *)cookie, PARAM_BUFFER_SIZE);
258                 u_int32_t len = PARAM_BUFFER_SIZE;
259                 SystemGetParameterValue(handle, ((char *)cookie) + PARAM_BUFFER_SIZE, &len);
260                 printf("$$$$$$$$Param %s=%s \n", (char *)cookie, ((char *)cookie) + PARAM_BUFFER_SIZE);
261             },
262             (void *)value);
263         return 0;
264     }
265 
TestUpdateParam(const char * name,const char * value)266     int TestUpdateParam(const char *name, const char *value)
267     {
268         SystemWriteParam(name, value);
269         SystemWriteParam(name, value);
270         SystemWriteParam(name, value);
271         SystemWriteParam(name, value);
272         CheckServerParamValue(name, value);
273         return 0;
274     }
275 
TestPersistParam()276     int TestPersistParam()
277     {
278         RegisterPersistParamOps(nullptr);
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         SystemWriteParam("persist.111.cccc.bbbb.cccc.dddd.eeee", "1104");
285         SystemWriteParam("persist.111.eeee.bbbb.cccc.dddd.eeee", "1105");
286         CheckServerParamValue("persist.111.ffff.bbbb.cccc.dddd.eeee", "1101");
287         SystemWriteParam("persist.111.ffff.bbbb.cccc.dddd.eeee", "1106");
288         CheckServerParamValue("persist.111.ffff.bbbb.cccc.dddd.eeee", "1106");
289 
290         SystemWriteParam("persist.111.bbbb.cccc.dddd.1107", "1107");
291         SystemWriteParam("persist.111.bbbb.cccc.dddd.1108", "1108");
292         SystemWriteParam("persist.111.bbbb.cccc.dddd.1109", "1108");
293 
294         SystemWriteParam("persist.111.bbbb.cccc.dddd.1110", "1108");
295         SystemWriteParam("persist.111.bbbb.cccc.dddd.1111", "1108");
296         TimerCallbackForSave(nullptr, nullptr);
297         LoadPersistParams();
298         return 0;
299     }
300 
CreateAndGetStreamTask()301     ParamTaskPtr CreateAndGetStreamTask()
302     {
303         OnIncomingConnect(LE_GetDefaultLoop(), GetParamService()->serverTask);
304         EXPECT_NE(GetParamService()->watcherTask, nullptr);
305         return GetParamService()->watcherTask;
306     }
307 
TestServiceProcessMessage(const char * name,const char * value,int userLabel)308     int TestServiceProcessMessage(const char *name, const char *value, int userLabel)
309     {
310         if (g_worker == nullptr) {
311             g_worker = CreateAndGetStreamTask();
312         }
313         if (g_worker == nullptr) {
314             return 0;
315         }
316         ParamSecurityOps *paramSecurityOps = GetParamSecurityOps(0);
317         if (userLabel && paramSecurityOps != nullptr) {
318             paramSecurityOps->securityFreeLabel = TestFreeLocalSecurityLabel;
319             paramSecurityOps->securityCheckParamPermission = TestCheckParamPermission;
320         }
321         uint32_t msgSize = sizeof(ParamMessage) + sizeof(ParamMsgContent) + PARAM_ALIGN(strlen(value) + 1);
322         ParamMessage *request = (ParamMessage *)CreateParamMessage(MSG_SET_PARAM, name, msgSize);
323         PARAM_CHECK(request != nullptr, return -1, "Failed to malloc for connect");
324         do {
325             request->type = MSG_SET_PARAM;
326             uint32_t offset = 0;
327             int ret = FillParamMsgContent(request, &offset, PARAM_VALUE, value, strlen(value));
328             PARAM_CHECK(ret == 0, break, "Failed to fill value");
329             ProcessMessage((const ParamTaskPtr)g_worker, (const ParamMessage *)request);
330         } while (0);
331         free(request);
332         RegisterSecurityOps(1);
333         return 0;
334     }
335 
AddWatch(int type,const char * name,const char * value)336     int AddWatch(int type, const char *name, const char *value)
337     {
338         if (g_worker == nullptr) {
339             g_worker = CreateAndGetStreamTask();
340         }
341         if (g_worker == nullptr) {
342             return 0;
343         }
344         uint32_t msgSize = sizeof(ParamMessage) + sizeof(ParamMsgContent) + sizeof(ParamMsgContent)
345             + PARAM_ALIGN(strlen(value) + 1) + sizeof(uint32_t);
346         ParamMessage *request = (ParamMessage *)(ParamMessage *)CreateParamMessage(type, name, msgSize);
347         PARAM_CHECK(request != nullptr, return -1, "Failed to malloc for connect");
348         do {
349             uint32_t offset = 0;
350             int ret = FillParamMsgContent(request, &offset, PARAM_VALUE, value, strlen(value));
351             PARAM_CHECK(ret == 0, break, "Failed to fill value");
352 
353             ParamMsgContent *content = (ParamMsgContent *)(request->data + offset);
354             content->type = PARAM_WAIT_TIMEOUT;
355             content->contentSize = sizeof(uint32_t);
356             *((uint32_t *)(content->content)) = 100; // 100 is test value
357             offset += sizeof(ParamMsgContent) + sizeof(uint32_t);
358             request->msgSize = offset + sizeof(ParamMessage);
359 
360             ProcessMessage((const ParamTaskPtr)g_worker, (const ParamMessage *)request);
361         } while (0);
362         free(request);
363         return 0;
364     }
365 
366     // 无匹配
TestAddParamWait1()367     int TestAddParamWait1()
368     {
369         const char *name = "wait.aaa.bbb.ccc.111";
370         const char *value = "wait1";
371         AddWatch(MSG_WAIT_PARAM, name, value);
372         SystemWriteParam(name, value);
373         // execute trigger
374         LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
375         return 0;
376     }
377 
378     // 模糊匹配
TestAddParamWait2()379     int TestAddParamWait2()
380     {
381         const char *name = "wait.aaa.bbb.ccc.222";
382         const char *value = "wait2";
383         AddWatch(MSG_WAIT_PARAM, name, "*");
384         SystemWriteParam(name, value);
385         // execute trigger
386         LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
387         return 0;
388     }
389 
390     // 属性存在
TestAddParamWait3()391     int TestAddParamWait3()
392     {
393         const char *name = "wait.aaa.bbb.ccc.333";
394         const char *value = "wait3";
395         SystemWriteParam(name, value);
396         AddWatch(MSG_WAIT_PARAM, name, value);
397         // execute trigger
398         LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
399         return 0;
400     }
401 
TestAddParamWatch1()402     int TestAddParamWatch1()
403     {
404         const char *name = "watch.aaa.bbb.ccc.111";
405         const char *value = "watch1";
406         AddWatch(MSG_ADD_WATCHER, name, value);
407         std::string newName = name;
408         newName += ".test.test.test";
409         SystemWriteParam(newName.c_str(), value);
410         // execute trigger
411         LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
412         return 0;
413     }
414 
TestAddParamWatch2()415     int TestAddParamWatch2()
416     {
417         const char *name = "watch.aaa.bbb.ccc.222";
418         const char *value = "watch2";
419         AddWatch(MSG_ADD_WATCHER, name, "*");
420         SystemWriteParam(name, value);
421         // execute trigger
422         LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
423         return 0;
424     }
425 
TestAddParamWatch3()426     int TestAddParamWatch3()
427     {
428         const char *name = "watch.aaa.bbb.ccc.333";
429         const char *value = "watch3";
430         std::string newName = name;
431         newName += ".test.test.test";
432         SystemWriteParam(newName.c_str(), value);
433         AddWatch(MSG_ADD_WATCHER, name, value);
434         char buffer[] = "testbuff";
435         CheckTrigger(GetTriggerWorkSpace(), TRIGGER_PARAM_WATCH, buffer, strlen(buffer), TestTriggerExecute);
436         AddWatch(MSG_DEL_WATCHER, name, value);
437         return 0;
438     }
439 
TestCloseTriggerWatch()440     int TestCloseTriggerWatch()
441     {
442 #ifdef PARAM_SUPPORT_TRIGGER
443         SystemDumpTriggers(1, nullptr);
444 #endif
445         ParamWatcher *watcher = (ParamWatcher *)ParamGetTaskUserData(g_worker);
446         ClearWatchTrigger(watcher, TRIGGER_PARAM_WAIT);
447         ParamTaskClose(g_worker);
448         g_worker = nullptr;
449         ParamTaskClose(g_worker);
450         SystemWriteParam("init.svc.param_watcher", "stopped");
451         return 0;
452     }
453 
TestServiceCtrl(const char * serviceName,uint16_t mode)454     int TestServiceCtrl(const char *serviceName, uint16_t mode)
455     {
456         // service forbid
457         TestSetParamCheckResult("ohos.servicectrl.", mode, 1);
458         return SystemWriteParam("ohos.ctl.start", serviceName);
459     }
460 
TestPowerCtrl(const char * reboot,uint16_t mode)461     int TestPowerCtrl(const char *reboot, uint16_t mode)
462     {
463         // service forbid
464         TestSetParamCheckResult("ohos.servicectrl.reboot", mode, 1);
465         return SystemWriteParam("ohos.startup.powerctrl", reboot);
466     }
467 };
468 
469 HWTEST_F(ParamServiceUnitTest, Init_TestPersistParam_001, TestSize.Level0)
470 {
471     ParamServiceUnitTest test;
472     test.TestPersistParam();
473 }
474 
475 HWTEST_F(ParamServiceUnitTest, Init_TestReadCmdline_001, TestSize.Level0)
476 {
477     const char *snData = "222222222222222222222";
478     CreateTestFile(STARTUP_INIT_UT_PATH "/system/etc/sn", snData);
479     // for cmdline
480     std::string cmdLineForSn = "bootgroup=device.charge.group earlycon=uart8250,mmio32,0xfe660000 "
481         "root=PARTUUID=614e0000-0000 rw rootwait rootfstype=ext4 console=ttyFIQ0 hardware=rk3568"
482         " BOOT_IMAGE=/kernel  init=/init";
483     std::string snWithPath = cmdLineForSn + "ohos.boot.sn=" + STARTUP_INIT_UT_PATH "/system/etc/sn";
484     CreateTestFile(BOOT_CMD_LINE, snWithPath.c_str());
485     LoadParamFromCmdLine();
486     std::string snWithSN = cmdLineForSn + "ohos.boot.sn=" + snData;
487     CreateTestFile(BOOT_CMD_LINE, snWithSN.c_str());
488     LoadParamFromCmdLine();
489     CreateTestFile(BOOT_CMD_LINE, cmdLineForSn.c_str());
490     LoadParamFromCmdLine();
491 }
492 
493 HWTEST_F(ParamServiceUnitTest, Init_TestServiceProcessMessage_001, TestSize.Level0)
494 {
495     ParamServiceUnitTest test;
496     test.TestServiceProcessMessage("wertt.qqqq.wwww.rrrr", "wwww.eeeee", 1);
497     test.TestServiceProcessMessage("wertt.2222.wwww.3333", "wwww.eeeee", 0);
498 }
499 
500 HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWait_001, TestSize.Level0)
501 {
502     ParamServiceUnitTest test;
503     test.TestAddParamWait1();
504 }
505 
506 HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWait_002, TestSize.Level0)
507 {
508     ParamServiceUnitTest test;
509     test.TestAddParamWait2();
510 }
511 
512 HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWait_003, TestSize.Level0)
513 {
514     ParamServiceUnitTest test;
515     test.TestAddParamWait3();
516 }
517 
518 HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWatch_001, TestSize.Level0)
519 {
520     ParamServiceUnitTest test;
521     test.TestAddParamWatch1();
522 }
523 
524 HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWatch_002, TestSize.Level0)
525 {
526     ParamServiceUnitTest test;
527     test.TestAddParamWatch2();
528 }
529 
530 #ifndef OHOS_LITE
531 HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWatch_003, TestSize.Level0)
532 {
533     ParamServiceUnitTest test;
534     test.TestAddParamWatch3();
535     int hashCode = CheckWatchTriggerTimeout();
536     EXPECT_EQ(hashCode, 0);
537 }
538 
539 HWTEST_F(ParamServiceUnitTest, Init_TestCloseTriggerWatch_001, TestSize.Level0)
540 {
541     ParamServiceUnitTest test;
542     test.TestCloseTriggerWatch();
543 }
544 
545 HWTEST_F(ParamServiceUnitTest, Init_TestServiceCtrl_001, TestSize.Level0)
546 {
547     ParamServiceUnitTest test;
548     int ret = test.TestServiceCtrl("server1", 0770);
549     EXPECT_NE(ret, 0);
550 #ifdef PARAM_SUPPORT_SELINUX
551     // selinux forbid
552     ret = test.TestServiceCtrl("server2", 0772);
553     EXPECT_NE(ret, 0);
554 #endif
555     ret = 0;
556 }
557 
558 HWTEST_F(ParamServiceUnitTest, Init_TestPowerCtrl_001, TestSize.Level0)
559 {
560     ParamServiceUnitTest test;
561     int ret = test.TestPowerCtrl("reboot,shutdown", 0770);
562     EXPECT_NE(ret, 0);
563     ret = test.TestPowerCtrl("reboot,shutdown", 0772);
564 #ifdef PARAM_SUPPORT_SELINUX
565     // selinux forbid
566     EXPECT_NE(ret, 0);
567 #endif
568     ret = test.TestPowerCtrl("reboot,updater", 0770);
569     EXPECT_NE(ret, 0);
570     ret = test.TestPowerCtrl("reboot,updater", 0772);
571 #ifdef PARAM_SUPPORT_SELINUX
572     // selinux forbid
573     EXPECT_NE(ret, 0);
574 #endif
575     ret = test.TestPowerCtrl("reboot,flashd", 0770);
576     EXPECT_NE(ret, 0);
577     ret = test.TestPowerCtrl("reboot,flashd", 0772);
578 #ifdef PARAM_SUPPORT_SELINUX
579     // selinux forbid
580     EXPECT_NE(ret, 0);
581 #endif
582 
583     ret = test.TestPowerCtrl("reboot", 0770);
584     EXPECT_NE(ret, 0);
585     ret = test.TestPowerCtrl("reboot", 0772);
586 #ifdef PARAM_SUPPORT_SELINUX
587     // selinux forbid
588     EXPECT_NE(ret, 0);
589 #endif
590 
591     ParamServiceStop();
592 }
593 #endif
594 }  // namespace init_ut
595