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
24using namespace testing::ext;
25using namespace std;
26
27static int TestTriggerExecute(TriggerNode *trigger, const char *content, uint32_t size)
28{
29    return 0;
30}
31
32static 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
45namespace init_ut {
46static ParamTaskPtr g_worker = nullptr;
47class ParamServiceUnitTest : public ::testing::Test {
48public:
49    ParamServiceUnitTest() {}
50    virtual ~ParamServiceUnitTest() {}
51
52    static void SetUpTestCase(void) {}
53
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    }
61    void TearDown() {}
62    void TestBody() {}
63
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
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，最长匹配到这个节点
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，最长匹配到最后一个相同节点
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，完全匹配
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
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
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
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
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
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
301    ParamTaskPtr CreateAndGetStreamTask()
302    {
303        OnIncomingConnect(LE_GetDefaultLoop(), GetParamService()->serverTask);
304        EXPECT_NE(GetParamService()->watcherTask, nullptr);
305        return GetParamService()->watcherTask;
306    }
307
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
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    // 无匹配
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    // 模糊匹配
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    // 属性存在
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
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
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
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
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
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
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
469HWTEST_F(ParamServiceUnitTest, Init_TestPersistParam_001, TestSize.Level0)
470{
471    ParamServiceUnitTest test;
472    test.TestPersistParam();
473}
474
475HWTEST_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
493HWTEST_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
500HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWait_001, TestSize.Level0)
501{
502    ParamServiceUnitTest test;
503    test.TestAddParamWait1();
504}
505
506HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWait_002, TestSize.Level0)
507{
508    ParamServiceUnitTest test;
509    test.TestAddParamWait2();
510}
511
512HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWait_003, TestSize.Level0)
513{
514    ParamServiceUnitTest test;
515    test.TestAddParamWait3();
516}
517
518HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWatch_001, TestSize.Level0)
519{
520    ParamServiceUnitTest test;
521    test.TestAddParamWatch1();
522}
523
524HWTEST_F(ParamServiceUnitTest, Init_TestAddParamWatch_002, TestSize.Level0)
525{
526    ParamServiceUnitTest test;
527    test.TestAddParamWatch2();
528}
529
530#ifndef OHOS_LITE
531HWTEST_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
539HWTEST_F(ParamServiceUnitTest, Init_TestCloseTriggerWatch_001, TestSize.Level0)
540{
541    ParamServiceUnitTest test;
542    test.TestCloseTriggerWatch();
543}
544
545HWTEST_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
558HWTEST_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