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 "trigger_manager.h"
21 #include "le_timer.h"
22
23 using namespace testing::ext;
24 using namespace std;
25
TestTriggerExecute(TriggerNode * trigger,const char * content,uint32_t size)26 static int TestTriggerExecute(TriggerNode *trigger, const char *content, uint32_t size)
27 {
28 return 0;
29 }
30
CheckServerParamValue(const char * name,const char * expectValue)31 static int CheckServerParamValue(const char *name, const char *expectValue)
32 {
33 char tmp[PARAM_BUFFER_SIZE] = {0};
34 u_int32_t len = sizeof(tmp);
35 SystemReadParam(name, tmp, &len);
36 printf("CheckParamValue name %s value: \'%s\' expectValue:\'%s\' \n", name, tmp, expectValue);
37 EXPECT_NE((int)strlen(tmp), 0);
38 if (expectValue != nullptr) {
39 EXPECT_EQ(strcmp(tmp, expectValue), 0);
40 }
41 return 0;
42 }
43
44 namespace init_ut {
45 static ParamTaskPtr g_worker = nullptr;
46 class ParamServiceUnitTest : public ::testing::Test {
47 public:
ParamServiceUnitTest()48 ParamServiceUnitTest() {}
~ParamServiceUnitTest()49 virtual ~ParamServiceUnitTest() {}
50
SetUpTestCase(void)51 static void SetUpTestCase(void)
52 {
53 PrepareInitUnitTestEnv();
54 }
SetUp()55 void SetUp()
56 {
57 if (GetParamSecurityLabel() != nullptr) {
58 GetParamSecurityLabel()->cred.uid = 1000; // 1000 test uid
59 GetParamSecurityLabel()->cred.gid = 1000; // 1000 test gid
60 }
61 }
TearDown()62 void TearDown() {}
TestBody()63 void TestBody() {}
64
TestSetParams(const char * params[][1+1],int num)65 int TestSetParams(const char *params[][1 + 1], int num)
66 {
67 for (int i = 0; i < num; i++) {
68 SystemWriteParam(params[i][0], params[i][1]);
69 }
70
71 // check
72 for (int i = 0; i < num; i++) {
73 CheckServerParamValue(params[i][0], params[i][1]);
74 }
75
76 for (int i = num - 1; i >= 0; i--) {
77 CheckServerParamValue(params[i][0], params[i][1]);
78 }
79 return 0;
80 }
81
TestAddSecurityLabel1()82 int TestAddSecurityLabel1()
83 {
84 GetParamSecurityLabel()->cred.gid = 9999; // 9999 test gid
85 const char *name = "label1.test.aaa.bbb.ccc.dddd.eee";
86 const char *value = "2001";
87 uint32_t labelIndex = 0;
88 SystemWriteParam(name, value);
89 // 获取到跟属性
90 WorkSpace *workspace = GetWorkSpace(WORKSPACE_INDEX_DAC);
91 (void)FindTrieNode(workspace, name, strlen(name), &labelIndex);
92 ParamSecurityNode *node = (ParamSecurityNode *)GetTrieNode(workspace, labelIndex);
93 if (node == nullptr) {
94 EXPECT_EQ(1, 0);
95 return 0;
96 }
97 EXPECT_EQ(node->gid, 0);
98 return 0;
99 }
100
101 // 添加一个label，最长匹配到这个节点
TestAddSecurityLabel2()102 int TestAddSecurityLabel2()
103 {
104 GetParamSecurityLabel()->cred.gid = 9999; // 9999 test gid
105 const char *name = "label2.test.aaa.bbb.ccc.dddd.eee";
106 const char *value = "2001";
107 ParamAuditData auditData = {};
108 auditData.name = "label2.test.aaa";
109 auditData.dacData.gid = 202; // 202 test dac gid
110 auditData.dacData.uid = geteuid();
111 auditData.dacData.mode = 0666; // 0666 test mode
112 SystemWriteParam(name, value);
113 uint32_t labelIndex = 0;
114 AddSecurityLabel(&auditData);
115 WorkSpace *workspace = GetWorkSpace(WORKSPACE_INDEX_DAC);
116 (void)FindTrieNode(workspace, name, strlen(name), &labelIndex);
117 ParamSecurityNode *node = (ParamSecurityNode *)GetTrieNode(workspace, labelIndex);
118 if (node == nullptr) {
119 EXPECT_EQ(1, 0);
120 return 0;
121 }
122 EXPECT_EQ(node->gid, auditData.dacData.gid);
123 return 0;
124 }
125
126 // 添加一个label，最长匹配到最后一个相同节点
TestAddSecurityLabel3()127 int TestAddSecurityLabel3()
128 {
129 GetParamSecurityLabel()->cred.gid = 9999; // 9999 test gid
130 const char *name = "label3.test.aaa.bbb.ccc.dddd.eee";
131 const char *value = "2001";
132 ParamAuditData auditData = {};
133 auditData.name = "label3.test.aaa";
134 auditData.dacData.gid = 203; // 203 test gid
135 auditData.dacData.uid = geteuid();
136 auditData.dacData.mode = 0666; // 0666 test mode
137 SystemWriteParam(name, value);
138 AddSecurityLabel(&auditData);
139
140 auditData.name = "label3.test.aaa.bbb.ccc.dddd.eee.dddd";
141 auditData.dacData.gid = 202; // 202 test dac gid
142 auditData.dacData.uid = geteuid();
143 auditData.dacData.mode = 0666; // 0666 test mode
144 SystemWriteParam(name, value);
145 AddSecurityLabel(&auditData);
146
147 uint32_t labelIndex = 0;
148 WorkSpace *workspace = GetWorkSpace(WORKSPACE_INDEX_DAC);
149 ParamTrieNode *paramNode = FindTrieNode(workspace, name, strlen(name), &labelIndex);
150 ParamSecurityNode *node = (ParamSecurityNode *)GetTrieNode(workspace, labelIndex);
151 if (paramNode == nullptr || node == nullptr) {
152 EXPECT_EQ(1, 0);
153 return 0;
154 }
155 EXPECT_EQ((int)node->gid, 203); // 203 test gid
156 return 0;
157 }
158
159 // 添加一个label，完全匹配
TestAddSecurityLabel4()160 int TestAddSecurityLabel4()
161 {
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
TestBufferValue(char * buffer,uint32_t len)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
TestNameIsValid()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 ret = SystemWriteParam(" ", "1111");
211 EXPECT_NE(ret, 0);
212 ret = SystemWriteParam("__.__..", "1111");
213 EXPECT_NE(ret, 0);
214 ret = SystemWriteParam(".__..", "1111");
215 EXPECT_NE(ret, 0);
216 ret = SystemWriteParam("test.-@:_", "1111");
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_EQ(ret, 0);
223
224 TestBufferValue(buffer, PARAM_VALUE_LEN_MAX + 1);
225 ret = SystemWriteParam("const.test_readonly.aaaaaaaaaaaaaaaaaa.fffffffffffffffffff", buffer);
226 EXPECT_EQ(ret, 0);
227
228 // 更新只读项目
229 TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
230 ret = SystemWriteParam("const.test_readonly.dddddddddddddddddd.fffffffffffffffffff", buffer);
231 EXPECT_NE(ret, 0);
232
233 // 写普通属性
234 TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
235 ret = SystemWriteParam("test.bigvalue.dddddddddddddddddd.fffffffffffffffffff", buffer);
236 EXPECT_EQ(ret, 0);
237 TestBufferValue(buffer, PARAM_VALUE_LEN_MAX + 1);
238 ret = SystemWriteParam("test.bigvalue.dddddddddddddddddd.fffffffffffffffffff", buffer);
239 EXPECT_NE(ret, 0);
240
241 // invalid name
242 TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
243 ret = SystemWriteParam("test.invalidname..fffffffffffffffffff", buffer);
244 EXPECT_NE(ret, 0);
245 ret = SystemWriteParam("test.invalidname.%fffffffffffffffffff", buffer);
246 EXPECT_NE(ret, 0);
247 ret = SystemWriteParam("test.invalidname.$fffffffffffffffffff", buffer);
248 EXPECT_NE(ret, 0);
249 return 0;
250 }
251
TestParamTraversal()252 int TestParamTraversal()
253 {
254 char value[PARAM_BUFFER_SIZE + PARAM_BUFFER_SIZE] = {0};
255 SystemTraversalParameter(
256 "",
257 [](ParamHandle handle, void *cookie) {
258 SystemGetParameterName(handle, (char *)cookie, PARAM_BUFFER_SIZE);
259 u_int32_t len = PARAM_BUFFER_SIZE;
260 SystemGetParameterValue(handle, ((char *)cookie) + PARAM_BUFFER_SIZE, &len);
261 printf("$$$$$$$$Param %s=%s \n", (char *)cookie, ((char *)cookie) + PARAM_BUFFER_SIZE);
262 },
263 (void *)value);
264 return 0;
265 }
266
TestUpdateParam(const char * name,const char * value)267 int TestUpdateParam(const char *name, const char *value)
268 {
269 SystemWriteParam(name, value);
270 SystemWriteParam(name, value);
271 SystemWriteParam(name, value);
272 SystemWriteParam(name, value);
273 CheckServerParamValue(name, value);
274 return 0;
275 }
276
TestPersistParam()277 int TestPersistParam()
278 {
279 RegisterPersistParamOps(nullptr);
280 LoadPersistParams();
281 SystemWriteParam("persist.111.ffff.bbbb.cccc.dddd.eeee", "1101");
282 SystemWriteParam("persist.111.aaaa.bbbb.cccc.dddd.eeee", "1102");
283 SystemWriteParam("persist.111.bbbb.cccc.dddd.eeee", "1103");
284 CheckServerParamValue("persist.111.bbbb.cccc.dddd.eeee", "1103");
285 SystemWriteParam("persist.111.cccc.bbbb.cccc.dddd.eeee", "1104");
286 SystemWriteParam("persist.111.eeee.bbbb.cccc.dddd.eeee", "1105");
287 CheckServerParamValue("persist.111.ffff.bbbb.cccc.dddd.eeee", "1101");
288 SystemWriteParam("persist.111.ffff.bbbb.cccc.dddd.eeee", "1106");
289 CheckServerParamValue("persist.111.ffff.bbbb.cccc.dddd.eeee", "1106");
290
291 SystemWriteParam("persist.111.bbbb.cccc.dddd.1107", "1107");
292 SystemWriteParam("persist.111.bbbb.cccc.dddd.1108", "1108");
293 SystemWriteParam("persist.111.bbbb.cccc.dddd.1109", "1108");
294
295 SystemWriteParam("persist.111.bbbb.cccc.dddd.1110", "1108");
296 SystemWriteParam("persist.111.bbbb.cccc.dddd.1111", "1108");
297 TimerCallbackForSave(nullptr, nullptr);
298 LoadPersistParams();
299 return 0;
300 }
301
CreateAndGetStreamTask()302 ParamTaskPtr CreateAndGetStreamTask()
303 {
304 OnIncomingConnect(LE_GetDefaultLoop(), GetParamService()->serverTask);
305 EXPECT_NE(GetParamService()->watcherTask, nullptr);
306 return GetParamService()->watcherTask;
307 }
308
TestServiceProcessMessage(const char * name,const char * value,int userLabel)309 int TestServiceProcessMessage(const char *name, const char *value, int userLabel)
310 {
311 if (g_worker == nullptr) {
312 g_worker = CreateAndGetStreamTask();
313 }
314 if (g_worker == nullptr) {
315 return 0;
316 }
317 ParamSecurityOps *paramSecurityOps = GetParamSecurityOps(0);
318 if (userLabel && paramSecurityOps != nullptr) {
319 paramSecurityOps->securityFreeLabel = TestFreeLocalSecurityLabel;
320 paramSecurityOps->securityCheckParamPermission = TestCheckParamPermission;
321 }
322 uint32_t msgSize = sizeof(ParamMessage) + sizeof(ParamMsgContent) + PARAM_ALIGN(strlen(value) + 1);
323 ParamMessage *request = (ParamMessage *)CreateParamMessage(MSG_SET_PARAM, name, msgSize);
324 PARAM_CHECK(request != nullptr, return -1, "Failed to malloc for connect");
325 do {
326 request->type = MSG_SET_PARAM;
327 uint32_t offset = 0;
328 int ret = FillParamMsgContent(request, &offset, PARAM_VALUE, value, strlen(value));
329 PARAM_CHECK(ret == 0, break, "Failed to fill value");
330 ProcessMessage((const ParamTaskPtr)g_worker, (const ParamMessage *)request);
331 } while (0);
332 free(request);
333 RegisterSecurityOps(1);
334 return 0;
335 }
336
AddWatch(int type,const char * name,const char * value)337 int AddWatch(int type, const char *name, const char *value)
338 {
339 if (g_worker == nullptr) {
340 g_worker = CreateAndGetStreamTask();
341 }
342 if (g_worker == nullptr) {
343 return 0;
344 }
345 uint32_t msgSize = sizeof(ParamMessage) + sizeof(ParamMsgContent) + sizeof(ParamMsgContent)
346 + PARAM_ALIGN(strlen(value) + 1) + sizeof(uint32_t);
347 ParamMessage *request = (ParamMessage *)(ParamMessage *)CreateParamMessage(type, name, msgSize);
348 PARAM_CHECK(request != nullptr, return -1, "Failed to malloc for connect");
349 do {
350 uint32_t offset = 0;
351 int ret = FillParamMsgContent(request, &offset, PARAM_VALUE, value, strlen(value));
352 PARAM_CHECK(ret == 0, break, "Failed to fill value");
353
354 ParamMsgContent *content = (ParamMsgContent *)(request->data + offset);
355 content->type = PARAM_WAIT_TIMEOUT;
356 content->contentSize = sizeof(uint32_t);
357 *((uint32_t *)(content->content)) = 100; // 100 is test value
358 offset += sizeof(ParamMsgContent) + sizeof(uint32_t);
359 request->msgSize = offset + sizeof(ParamMessage);
360
361 ProcessMessage((const ParamTaskPtr)g_worker, (const ParamMessage *)request);
362 } while (0);
363 free(request);
364 return 0;
365 }
366
367 // 无匹配
TestAddParamWait1()368 int TestAddParamWait1()
369 {
370 const char *name = "wait.aaa.bbb.ccc.111";
371 const char *value = "wait1";
372 AddWatch(MSG_WAIT_PARAM, name, value);
373 SystemWriteParam(name, value);
374 // execute trigger
375 LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
376 return 0;
377 }
378
379 // 模糊匹配
TestAddParamWait2()380 int TestAddParamWait2()
381 {
382 const char *name = "wait.aaa.bbb.ccc.222";
383 const char *value = "wait2";
384 AddWatch(MSG_WAIT_PARAM, name, "*");
385 SystemWriteParam(name, value);
386 // execute trigger
387 LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
388 return 0;
389 }
390
391 // 属性存在
TestAddParamWait3()392 int TestAddParamWait3()
393 {
394 const char *name = "wait.aaa.bbb.ccc.333";
395 const char *value = "wait3";
396 SystemWriteParam(name, value);
397 AddWatch(MSG_WAIT_PARAM, name, value);
398 // execute trigger
399 LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
400 return 0;
401 }
402
TestAddParamWatch1()403 int TestAddParamWatch1()
404 {
405 const char *name = "watch.aaa.bbb.ccc.111";
406 const char *value = "watch1";
407 AddWatch(MSG_ADD_WATCHER, name, value);
408 std::string newName = name;
409 newName += ".test.test.test";
410 SystemWriteParam(newName.c_str(), value);
411 // execute trigger
412 LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
413 return 0;
414 }
415
TestAddParamWatch2()416 int TestAddParamWatch2()
417 {
418 const char *name = "watch.aaa.bbb.ccc.222";
419 const char *value = "watch2";
420 AddWatch(MSG_ADD_WATCHER, name, "*");
421 SystemWriteParam(name, value);
422 // execute trigger
423 LE_DoAsyncEvent(LE_GetDefaultLoop(), GetTriggerWorkSpace()->eventHandle);
424 return 0;
425 }
426
TestAddParamWatch3()427 int TestAddParamWatch3()
428 {
429 const char *name = "watch.aaa.bbb.ccc.333";
430 const char *value = "watch3";
431 std::string newName = name;
432 newName += ".test.test.test";
433 SystemWriteParam(newName.c_str(), value);
434 AddWatch(MSG_ADD_WATCHER, name, value);
435 char buffer[] = "testbuff";
436 CheckTrigger(GetTriggerWorkSpace(), TRIGGER_PARAM_WATCH, buffer, strlen(buffer), TestTriggerExecute);
437 AddWatch(MSG_DEL_WATCHER, name, value);
438 return 0;
439 }
440
TestCloseTriggerWatch()441 int TestCloseTriggerWatch()
442 {
443 #ifdef PARAM_SUPPORT_TRIGGER
444 SystemDumpTriggers(1, nullptr);
445 #endif
446 ParamWatcher *watcher = (ParamWatcher *)ParamGetTaskUserData(g_worker);
447 ClearWatchTrigger(watcher, TRIGGER_PARAM_WAIT);
448 ParamTaskClose(g_worker);
449 g_worker = nullptr;
450 ParamTaskClose(g_worker);
451 SystemWriteParam("init.svc.param_watcher", "stopped");
452 return 0;
453 }
454
TestServiceCtrl(const char * serviceName,uint16_t mode)455 int TestServiceCtrl(const char *serviceName, uint16_t mode)
456 {
457 // service forbid
458 TestSetParamCheckResult("ohos.servicectrl.", mode, 1);
459 return SystemWriteParam("ohos.ctl.start", serviceName);
460 }
461
TestPowerCtrl(const char * reboot,uint16_t mode)462 int TestPowerCtrl(const char *reboot, uint16_t mode)
463 {
464 // service forbid
465 TestSetParamCheckResult("ohos.servicectrl.reboot", mode, 1);
466 return SystemWriteParam("ohos.startup.powerctrl", reboot);
467 }
468 };
469
470 HWTEST_F(ParamServiceUnitTest, TestPersistParam, TestSize.Level0)
471 {
472 ParamServiceUnitTest test;
473 test.TestPersistParam();
474 }
475
476 HWTEST_F(ParamServiceUnitTest, TestReadCmdline, 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 LoadParamFromCmdLine();
487 std::string snWithSN = cmdLineForSn + "ohos.boot.sn=" + snData;
488 CreateTestFile(BOOT_CMD_LINE, snWithSN.c_str());
489 LoadParamFromCmdLine();
490 CreateTestFile(BOOT_CMD_LINE, cmdLineForSn.c_str());
491 LoadParamFromCmdLine();
492 }
493
494 HWTEST_F(ParamServiceUnitTest, TestServiceProcessMessage, TestSize.Level0)
495 {
496 ParamServiceUnitTest test;
497 test.TestServiceProcessMessage("wertt.qqqq.wwww.rrrr", "wwww.eeeee", 1);
498 test.TestServiceProcessMessage("wertt.2222.wwww.3333", "wwww.eeeee", 0);
499 }
500
501 HWTEST_F(ParamServiceUnitTest, TestAddParamWait1, TestSize.Level0)
502 {
503 ParamServiceUnitTest test;
504 test.TestAddParamWait1();
505 }
506
507 HWTEST_F(ParamServiceUnitTest, TestAddParamWait2, TestSize.Level0)
508 {
509 ParamServiceUnitTest test;
510 test.TestAddParamWait2();
511 }
512
513 HWTEST_F(ParamServiceUnitTest, TestAddParamWait3, TestSize.Level0)
514 {
515 ParamServiceUnitTest test;
516 test.TestAddParamWait3();
517 }
518
519 HWTEST_F(ParamServiceUnitTest, TestAddParamWatch1, TestSize.Level0)
520 {
521 ParamServiceUnitTest test;
522 test.TestAddParamWatch1();
523 }
524
525 HWTEST_F(ParamServiceUnitTest, TestAddParamWatch2, TestSize.Level0)
526 {
527 ParamServiceUnitTest test;
528 test.TestAddParamWatch2();
529 }
530
531 #ifndef OHOS_LITE
532 HWTEST_F(ParamServiceUnitTest, TestAddParamWatch3, TestSize.Level0)
533 {
534 ParamServiceUnitTest test;
535 test.TestAddParamWatch3();
536 if (GetParamService()->timer != nullptr) {
537 ((TimerTask *)GetParamService()->timer)->processTimer(nullptr, nullptr);
538 }
539 int hashCode = CheckWatchTriggerTimeout();
540 EXPECT_EQ(hashCode, 0);
541 }
542
543 HWTEST_F(ParamServiceUnitTest, TestCloseTriggerWatch, TestSize.Level0)
544 {
545 ParamServiceUnitTest test;
546 test.TestCloseTriggerWatch();
547 }
548
549 HWTEST_F(ParamServiceUnitTest, TestServiceCtrl, TestSize.Level0)
550 {
551 ParamServiceUnitTest test;
552 int ret = test.TestServiceCtrl("server1", 0770);
553 EXPECT_NE(ret, 0);
554 #ifdef PARAM_SUPPORT_SELINUX
555 // selinux forbid
556 ret = test.TestServiceCtrl("server2", 0772);
557 EXPECT_NE(ret, 0);
558 #endif
559 ret = 0;
560 }
561
562 HWTEST_F(ParamServiceUnitTest, TestPowerCtrl, TestSize.Level0)
563 {
564 ParamServiceUnitTest test;
565 int ret = test.TestPowerCtrl("reboot,shutdown", 0770);
566 EXPECT_NE(ret, 0);
567 ret = test.TestPowerCtrl("reboot,shutdown", 0772);
568 #ifdef PARAM_SUPPORT_SELINUX
569 // selinux forbid
570 EXPECT_NE(ret, 0);
571 #endif
572 ret = test.TestPowerCtrl("reboot,updater", 0770);
573 EXPECT_NE(ret, 0);
574 ret = test.TestPowerCtrl("reboot,updater", 0772);
575 #ifdef PARAM_SUPPORT_SELINUX
576 // selinux forbid
577 EXPECT_NE(ret, 0);
578 #endif
579 ret = test.TestPowerCtrl("reboot,flashd", 0770);
580 EXPECT_NE(ret, 0);
581 ret = test.TestPowerCtrl("reboot,flashd", 0772);
582 #ifdef PARAM_SUPPORT_SELINUX
583 // selinux forbid
584 EXPECT_NE(ret, 0);
585 #endif
586
587 ret = test.TestPowerCtrl("reboot", 0770);
588 EXPECT_NE(ret, 0);
589 ret = test.TestPowerCtrl("reboot", 0772);
590 #ifdef PARAM_SUPPORT_SELINUX
591 // selinux forbid
592 EXPECT_NE(ret, 0);
593 #endif
594
595 ParamServiceStop();
596 }
597 #endif
598 } // namespace init_ut
599