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 int ret = test.TestPersistParam();
473 EXPECT_EQ(ret, 0);
474 }
475
476 HWTEST_F(ParamServiceUnitTest, Init_TestReadCmdline_001, TestSize.Level0)
477 {
478 const char *snData = "222222222222222222222";
479 CreateTestFile(STARTUP_INIT_UT_PATH "/system/etc/sn", snData);
480 // for cmdline
481 std::string cmdLineForSn = "bootgroup=device.charge.group earlycon=uart8250,mmio32,0xfe660000 "
482 "root=PARTUUID=614e0000-0000 rw rootwait rootfstype=ext4 console=ttyFIQ0 hardware=rk3568"
483 " BOOT_IMAGE=/kernel init=/init";
484 std::string snWithPath = cmdLineForSn + "ohos.boot.sn=" + STARTUP_INIT_UT_PATH "/system/etc/sn";
485 CreateTestFile(BOOT_CMD_LINE, snWithPath.c_str());
486 int ret = LoadParamFromCmdLine();
487 EXPECT_EQ(ret, 0);
488 std::string snWithSN = cmdLineForSn + "ohos.boot.sn=" + snData;
489 CreateTestFile(BOOT_CMD_LINE, snWithSN.c_str());
490 ret = LoadParamFromCmdLine();
491 EXPECT_EQ(ret, 0);
492 CreateTestFile(BOOT_CMD_LINE, cmdLineForSn.c_str());
493 ret = LoadParamFromCmdLine();
494 EXPECT_EQ(ret, 0);
495 }
496
497 HWTEST_F(ParamServiceUnitTest, Init_TestServiceProcessMessage_001, TestSize.Level0)
498 {
499 ParamServiceUnitTest test;
500 int ret = test.TestServiceProcessMessage("wertt.qqqq.wwww.rrrr", "wwww.eeeee", 1);
501 EXPECT_EQ(ret, 0);
502 ret = test.TestServiceProcessMessage("wertt.2222.wwww.3333", "wwww.eeeee", 0);
503 EXPECT_EQ(ret, 0);
504 }
505
506 HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWait_001, TestSize.Level0)
507 {
508 ParamServiceUnitTest test;
509 int ret = test.TestAddParamWait1();
510 EXPECT_EQ(ret, 0);
511 }
512
513 HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWait_002, TestSize.Level0)
514 {
515 ParamServiceUnitTest test;
516 int ret = test.TestAddParamWait2();
517 EXPECT_EQ(ret, 0);
518 }
519
520 HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWait_003, TestSize.Level0)
521 {
522 ParamServiceUnitTest test;
523 int ret = test.TestAddParamWait3();
524 EXPECT_EQ(ret, 0);
525 }
526
527 HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWatch_001, TestSize.Level0)
528 {
529 ParamServiceUnitTest test;
530 int ret = test.TestAddParamWatch1();
531 EXPECT_EQ(ret, 0);
532 }
533
534 HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWatch_002, TestSize.Level0)
535 {
536 ParamServiceUnitTest test;
537 int ret = test.TestAddParamWatch2();
538 EXPECT_EQ(ret, 0);
539 }
540
541 #ifndef OHOS_LITE
542 HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWatch_003, TestSize.Level0)
543 {
544 ParamServiceUnitTest test;
545 test.TestAddParamWatch3();
546 int hashCode = CheckWatchTriggerTimeout();
547 EXPECT_EQ(hashCode, 0);
548 }
549
550 HWTEST_F(ParamServiceUnitTest, Init_TestCloseTriggerWatch_001, TestSize.Level0)
551 {
552 ParamServiceUnitTest test;
553 int ret = test.TestCloseTriggerWatch();
554 EXPECT_EQ(ret, 0);
555 }
556
557 HWTEST_F(ParamServiceUnitTest, Init_TestServiceCtrl_001, TestSize.Level0)
558 {
559 ParamServiceUnitTest test;
560 int ret = test.TestServiceCtrl("server1", 0770);
561 EXPECT_NE(ret, 0);
562 #ifdef PARAM_SUPPORT_SELINUX
563 // selinux forbid
564 ret = test.TestServiceCtrl("server2", 0772);
565 EXPECT_NE(ret, 0);
566 #endif
567 ret = 0;
568 }
569
570 HWTEST_F(ParamServiceUnitTest, Init_TestPowerCtrl_001, TestSize.Level0)
571 {
572 ParamServiceUnitTest test;
573 int ret = test.TestPowerCtrl("reboot,shutdown", 0770);
574 EXPECT_NE(ret, 0);
575 ret = test.TestPowerCtrl("reboot,shutdown", 0772);
576 #ifdef PARAM_SUPPORT_SELINUX
577 // selinux forbid
578 EXPECT_NE(ret, 0);
579 #endif
580 ret = test.TestPowerCtrl("reboot,updater", 0770);
581 EXPECT_NE(ret, 0);
582 ret = test.TestPowerCtrl("reboot,updater", 0772);
583 #ifdef PARAM_SUPPORT_SELINUX
584 // selinux forbid
585 EXPECT_NE(ret, 0);
586 #endif
587 ret = test.TestPowerCtrl("reboot,flashd", 0770);
588 EXPECT_NE(ret, 0);
589 ret = test.TestPowerCtrl("reboot,flashd", 0772);
590 #ifdef PARAM_SUPPORT_SELINUX
591 // selinux forbid
592 EXPECT_NE(ret, 0);
593 #endif
594
595 ret = test.TestPowerCtrl("reboot", 0770);
596 EXPECT_NE(ret, 0);
597 ret = test.TestPowerCtrl("reboot", 0772);
598 #ifdef PARAM_SUPPORT_SELINUX
599 // selinux forbid
600 EXPECT_NE(ret, 0);
601 #endif
602
603 ParamServiceStop();
604 }
605 #endif
606 } // namespace init_ut
607