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