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 <memory>
16
17 #include "init_param.h"
18 #include "init_unittest.h"
19 #include "param_stub.h"
20 #include "trigger_manager.h"
21
22 using namespace testing::ext;
23 using namespace std;
CheckServerParamValue(const char * name,const char * expectValue)24 static int CheckServerParamValue(const char *name, const char *expectValue)
25 {
26 char tmp[PARAM_BUFFER_SIZE] = { 0 };
27 u_int32_t len = sizeof(tmp);
28 SystemReadParam(name, tmp, &len);
29 printf("CheckParamValue name %s value: \'%s\' expectValue:\'%s\' \n", name, tmp, expectValue);
30 EXPECT_NE((int)strlen(tmp), 0);
31 if (expectValue != nullptr) {
32 EXPECT_EQ(strcmp(tmp, expectValue), 0);
33 }
34 return 0;
35 }
36
37 extern "C" {
38 extern void TimerCallbackForSave(ParamTaskPtr timer, void *context);
39 }
40
41 static ParamTaskPtr g_worker = nullptr;
42 class ParamUnitTest : public ::testing::Test {
43 public:
ParamUnitTest()44 ParamUnitTest() {}
~ParamUnitTest()45 virtual ~ParamUnitTest() {}
46
SetUp()47 void SetUp() {}
TearDown()48 void TearDown() {}
TestBody()49 void TestBody() {}
50
TestSetParams(const char * params[][1+1],int num)51 int TestSetParams(const char *params[][1 + 1], int num)
52 {
53 for (int i = 0; i < num; i++) {
54 SystemWriteParam(params[i][0], params[i][1]);
55 }
56
57 // check
58 for (int i = 0; i < num; i++) {
59 CheckServerParamValue(params[i][0], params[i][1]);
60 }
61
62 for (int i = num - 1; i >= 0; i--) {
63 CheckServerParamValue(params[i][0], params[i][1]);
64 }
65 return 0;
66 }
67
TestAddSecurityLabel1()68 int TestAddSecurityLabel1()
69 {
70 GetParamWorkSpace()->securityLabel->cred.gid = 9999; // 9999 test gid
71 const char *name = "label1.test.aaa.bbb.ccc.dddd.eee";
72 const char *value = "2001";
73 uint32_t labelIndex = 0;
74 SystemWriteParam(name, value);
75 // 获取到跟属性
76 ParamTrieNode *paramNode = FindTrieNode(&GetParamWorkSpace()->paramSpace, name, strlen(name), &labelIndex);
77 ParamSecruityNode *node = (ParamSecruityNode *)GetTrieNode(&GetParamWorkSpace()->paramSpace, labelIndex);
78 if (paramNode == nullptr || node == nullptr) {
79 EXPECT_EQ(1, 0);
80 return 0;
81 }
82 EXPECT_EQ(node->gid, getegid());
83 return 0;
84 }
85
86 // 添加一个label，最长匹配到这个节点
TestAddSecurityLabel2()87 int TestAddSecurityLabel2()
88 {
89 GetParamWorkSpace()->securityLabel->cred.gid = 9999; // 9999 test gid
90 const char *name = "label2.test.aaa.bbb.ccc.dddd.eee";
91 const char *value = "2001";
92 ParamAuditData auditData = {};
93 auditData.name = "label2.test.aaa";
94 auditData.label = "label2.test.aaa";
95 auditData.dacData.gid = 202; // 202 test dac gid
96 auditData.dacData.uid = geteuid();
97 auditData.dacData.mode = 0666; // 0666 test mode
98 SystemWriteParam(name, value);
99 uint32_t labelIndex = 0;
100 AddSecurityLabel(&auditData, GetParamWorkSpace());
101 ParamTrieNode *paramNode = FindTrieNode(&GetParamWorkSpace()->paramSpace, name, strlen(name), &labelIndex);
102 ParamSecruityNode *node = (ParamSecruityNode *)GetTrieNode(&GetParamWorkSpace()->paramSpace, labelIndex);
103 if (paramNode == nullptr || node == nullptr) {
104 EXPECT_EQ(1, 0);
105 return 0;
106 }
107 EXPECT_EQ(node->gid, auditData.dacData.gid);
108 return 0;
109 }
110
111 // 添加一个label，最长匹配到最后一个相同节点
TestAddSecurityLabel3()112 int TestAddSecurityLabel3()
113 {
114 GetParamWorkSpace()->securityLabel->cred.gid = 9999; // 9999 test gid
115 const char *name = "label3.test.aaa.bbb.ccc.dddd.eee";
116 const char *value = "2001";
117 ParamAuditData auditData = {};
118 auditData.name = "label3.test.aaa";
119 auditData.label = "label3.test.aaa";
120 auditData.dacData.gid = 203; // 203 test gid
121 auditData.dacData.uid = geteuid();
122 auditData.dacData.mode = 0666; // 0666 test mode
123 SystemWriteParam(name, value);
124 AddSecurityLabel(&auditData, GetParamWorkSpace());
125
126 auditData.name = "label3.test.aaa.bbb.ccc.dddd.eee.dddd";
127 auditData.label = "label3.test.aaa.bbb.ccc.dddd.eee.dddd";
128 auditData.dacData.gid = 202; // 202 test dac gid
129 auditData.dacData.uid = geteuid();
130 auditData.dacData.mode = 0666; // 0666 test mode
131 SystemWriteParam(name, value);
132 AddSecurityLabel(&auditData, GetParamWorkSpace());
133
134 uint32_t labelIndex = 0;
135 ParamTrieNode *paramNode = FindTrieNode(&GetParamWorkSpace()->paramSpace, name, strlen(name), &labelIndex);
136 ParamSecruityNode *node = (ParamSecruityNode *)GetTrieNode(&GetParamWorkSpace()->paramSpace, labelIndex);
137 if (paramNode == nullptr || node == nullptr) {
138 EXPECT_EQ(1, 0);
139 return 0;
140 }
141 EXPECT_EQ((int)node->gid, 203); // 203 test gid
142 return 0;
143 }
144
145 // 添加一个label，完全匹配
TestAddSecurityLabel4()146 int TestAddSecurityLabel4()
147 {
148 GetParamWorkSpace()->securityLabel->cred.gid = 9999; // 9999 test gid
149 const char *name = "label4.test.aaa.bbb.ccc.dddd.eee";
150 const char *value = "2001";
151 ParamAuditData auditData = {};
152 auditData.name = "label4.test.aaa.bbb.ccc.dddd.eee";
153 auditData.label = "label4.test.aaa.bbb.ccc.dddd.eee";
154 auditData.dacData.gid = 203; // 203 test gid
155 auditData.dacData.uid = geteuid();
156 auditData.dacData.mode = 0666; // 0666 test mode
157 SystemWriteParam(name, value);
158 uint32_t labelIndex = 0;
159 AddSecurityLabel(&auditData, GetParamWorkSpace());
160 ParamTrieNode *paramNode = FindTrieNode(&GetParamWorkSpace()->paramSpace, name, strlen(name), &labelIndex);
161 ParamSecruityNode *node = (ParamSecruityNode *)GetTrieNode(&GetParamWorkSpace()->paramSpace, labelIndex);
162 if (paramNode == nullptr || node == nullptr) {
163 EXPECT_EQ(1, 0);
164 return 0;
165 }
166 EXPECT_EQ(node->gid, auditData.dacData.gid);
167 return 0;
168 }
169
TestBufferValue(char * buffer,uint32_t len)170 void TestBufferValue(char *buffer, uint32_t len)
171 {
172 const int printBase = 10;
173 for (uint32_t index = 0; index <= len; index++) {
174 buffer[index] = '0' + index % printBase;
175 if (index != 0 && index % printBase == 0) {
176 buffer[index] = '.';
177 }
178 }
179 buffer[len] = '\0';
180 }
181
TestNameIsValid()182 int TestNameIsValid()
183 {
184 char buffer[PARAM_BUFFER_SIZE];
185 // set name length = 127
186 TestBufferValue(buffer, PARAM_NAME_LEN_MAX - 1);
187 int ret = SystemWriteParam(buffer, "1111");
188 EXPECT_EQ(ret, 0);
189 TestBufferValue(buffer, PARAM_NAME_LEN_MAX);
190 ret = SystemWriteParam(buffer, "1111");
191 EXPECT_NE(ret, 0);
192 TestBufferValue(buffer, PARAM_NAME_LEN_MAX + 1);
193 ret = SystemWriteParam(buffer, "1111");
194 EXPECT_NE(ret, 0);
195
196 // 保存一个只读的属性，大于最大值
197 TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
198 ret = SystemWriteParam("const.test_readonly.dddddddddddddddddd.fffffffffffffffffff", buffer);
199 EXPECT_EQ(ret, 0);
200
201 TestBufferValue(buffer, PARAM_VALUE_LEN_MAX + 1);
202 ret = SystemWriteParam("const.test_readonly.aaaaaaaaaaaaaaaaaa.fffffffffffffffffff", buffer);
203 EXPECT_EQ(ret, 0);
204
205 // 更新只读项目
206 TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
207 ret = SystemWriteParam("const.test_readonly.dddddddddddddddddd.fffffffffffffffffff", buffer);
208 EXPECT_NE(ret, 0);
209
210 // 写普通属性
211 TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
212 ret = SystemWriteParam("test.bigvalue.dddddddddddddddddd.fffffffffffffffffff", buffer);
213 EXPECT_EQ(ret, 0);
214 TestBufferValue(buffer, PARAM_VALUE_LEN_MAX + 1);
215 ret = SystemWriteParam("test.bigvalue.dddddddddddddddddd.fffffffffffffffffff", buffer);
216 EXPECT_NE(ret, 0);
217
218 // invalid name
219 TestBufferValue(buffer, PARAM_VALUE_LEN_MAX - 1);
220 ret = SystemWriteParam("test.invalidname..fffffffffffffffffff", buffer);
221 EXPECT_NE(ret, 0);
222 ret = SystemWriteParam("test.invalidname.%fffffffffffffffffff", buffer);
223 EXPECT_NE(ret, 0);
224 ret = SystemWriteParam("test.invalidname.$fffffffffffffffffff", buffer);
225 EXPECT_NE(ret, 0);
226 return 0;
227 }
228
TestParamTraversal()229 int TestParamTraversal()
230 {
231 char value[PARAM_BUFFER_SIZE + PARAM_BUFFER_SIZE] = { 0 };
232 TraversalParam(GetParamWorkSpace(), "",
233 [](ParamHandle handle, void *cookie) {
234 ReadParamName(GetParamWorkSpace(), handle, (char *)cookie, PARAM_BUFFER_SIZE);
235 u_int32_t len = PARAM_BUFFER_SIZE;
236 ReadParamValue(GetParamWorkSpace(), handle, ((char *)cookie) + PARAM_BUFFER_SIZE, &len);
237 printf("$$$$$$$$Param %s=%s \n", (char *)cookie, ((char *)cookie) + PARAM_BUFFER_SIZE);
238 },
239 (void *)value);
240 return 0;
241 }
242
TestUpdateParam(const char * name,const char * value)243 int TestUpdateParam(const char *name, const char *value)
244 {
245 SystemWriteParam(name, value);
246 SystemWriteParam(name, value);
247 SystemWriteParam(name, value);
248 SystemWriteParam(name, value);
249 CheckServerParamValue(name, value);
250 return 0;
251 }
252
TestPersistParam()253 int TestPersistParam()
254 {
255 LoadPersistParams();
256 SystemWriteParam("persist.111.ffff.bbbb.cccc.dddd.eeee", "1101");
257 SystemWriteParam("persist.111.aaaa.bbbb.cccc.dddd.eeee", "1102");
258 SystemWriteParam("persist.111.bbbb.cccc.dddd.eeee", "1103");
259 CheckServerParamValue("persist.111.bbbb.cccc.dddd.eeee", "1103");
260 SystemWriteParam("persist.111.cccc.bbbb.cccc.dddd.eeee", "1104");
261 SystemWriteParam("persist.111.eeee.bbbb.cccc.dddd.eeee", "1105");
262 CheckServerParamValue("persist.111.ffff.bbbb.cccc.dddd.eeee", "1101");
263 SystemWriteParam("persist.111.ffff.bbbb.cccc.dddd.eeee", "1106");
264 CheckServerParamValue("persist.111.ffff.bbbb.cccc.dddd.eeee", "1106");
265 sleep(1);
266 SystemWriteParam("persist.111.bbbb.cccc.dddd.1107", "1107");
267 SystemWriteParam("persist.111.bbbb.cccc.dddd.1108", "1108");
268 SystemWriteParam("persist.111.bbbb.cccc.dddd.1109", "1108");
269 sleep(1);
270 SystemWriteParam("persist.111.bbbb.cccc.dddd.1110", "1108");
271 SystemWriteParam("persist.111.bbbb.cccc.dddd.1111", "1108");
272 if (GetParamWorkSpace() != nullptr) {
273 TimerCallbackForSave(nullptr, &(GetParamWorkSpace()->paramSpace));
274 }
275 LoadPersistParams();
276 return 0;
277 }
278
FillLabelContent(ParamSecurityOps * paramSecurityOps,ParamMessage * request,uint32_t * start,uint32_t length)279 int FillLabelContent(ParamSecurityOps *paramSecurityOps, ParamMessage *request, uint32_t *start, uint32_t length)
280 {
281 if (length == 0) {
282 return 0;
283 }
284 uint32_t bufferSize = request->msgSize - sizeof(ParamMessage);
285 uint32_t offset = *start;
286 PARAM_CHECK((offset + sizeof(ParamMsgContent) + length) <= bufferSize,
287 return -1, "Invalid msgSize %u offset %u length %u", request->msgSize, offset, bufferSize);
288 ParamMsgContent *content = (ParamMsgContent *)(request->data + offset);
289 content->type = PARAM_LABEL;
290 content->contentSize = 0;
291 if (length != 0 && paramSecurityOps->securityEncodeLabel != nullptr) {
292 int ret = paramSecurityOps->securityEncodeLabel(
293 GetParamWorkSpace()->securityLabel, content->content, &length);
294 PARAM_CHECK(ret == 0, return -1, "Failed to get label length");
295 content->contentSize = length;
296 }
297 offset += sizeof(ParamMsgContent) + PARAM_ALIGN(content->contentSize);
298 *start = offset;
299 return 0;
300 }
301
CreateAndGetStreamTask()302 ParamTaskPtr CreateAndGetStreamTask()
303 {
304 ParamStreamInfo info = {};
305 info.flags = PARAM_TEST_FLAGS;
306 info.server = NULL;
307 info.close = NULL;
308 info.recvMessage = ProcessMessage;
309 info.incomingConnect = NULL;
310 ParamTaskPtr client = NULL;
311 int ret = ParamStreamCreate(&client, GetParamWorkSpace()->serverTask, &info, sizeof(ParamWatcher));
312 PARAM_CHECK(ret == 0, return NULL, "Failed to create client");
313
314 ParamWatcher *watcher = (ParamWatcher *)ParamGetTaskUserData(client);
315 PARAM_CHECK(watcher != NULL, return NULL, "Failed to get watcher");
316 ListInit(&watcher->triggerHead);
317 watcher->stream = client;
318 GetParamWorkSpace()->watcherTask = client;
319 return GetParamWorkSpace()->watcherTask;
320 }
321
TestServiceProcessMessage(const char * name,const char * value,int userLabel)322 int TestServiceProcessMessage(const char *name, const char *value, int userLabel)
323 {
324 if (g_worker == nullptr) {
325 g_worker = CreateAndGetStreamTask();
326 }
327 if (g_worker == nullptr) {
328 return 0;
329 }
330 uint32_t labelLen = 0;
331 ParamSecurityOps *paramSecurityOps = &GetParamWorkSpace()->paramSecurityOps;
332 if (userLabel) {
333 paramSecurityOps->securityEncodeLabel = TestEncodeSecurityLabel;
334 paramSecurityOps->securityDecodeLabel = TestDecodeSecurityLabel;
335 paramSecurityOps->securityFreeLabel = TestFreeLocalSecurityLabel;
336 paramSecurityOps->securityCheckParamPermission = TestCheckParamPermission;
337 }
338 uint32_t msgSize = sizeof(ParamMessage) + sizeof(ParamMsgContent) + PARAM_ALIGN(strlen(value) + 1);
339 if (paramSecurityOps->securityEncodeLabel != nullptr) {
340 int ret = paramSecurityOps->securityEncodeLabel(GetParamWorkSpace()->securityLabel, nullptr, &labelLen);
341 PARAM_CHECK(ret == 0, return -1, "Failed to get label length");
342 msgSize += sizeof(ParamMsgContent) + PARAM_ALIGN(labelLen);
343 }
344 ParamMessage *request = (ParamMessage *)CreateParamMessage(MSG_SET_PARAM, name, msgSize);
345 PARAM_CHECK(request != nullptr, return -1, "Failed to malloc for connect");
346 do {
347 request->type = MSG_SET_PARAM;
348 uint32_t offset = 0;
349 int ret = FillParamMsgContent(request, &offset, PARAM_VALUE, value, strlen(value));
350 PARAM_CHECK(ret == 0, break, "Failed to fill value");
351 ret = FillLabelContent(paramSecurityOps, request, &offset, labelLen);
352 PARAM_CHECK(ret == 0, break, "Failed to fill label");
353 ProcessMessage((const ParamTaskPtr)g_worker, (const ParamMessage *)request);
354 } while (0);
355 free(request);
356 CheckServerParamValue(name, value);
357 RegisterSecurityOps(paramSecurityOps, 1);
358 return 0;
359 }
360
AddWatch(int type,const char * name,const char * value)361 int AddWatch(int type, const char *name, const char *value)
362 {
363 if (g_worker == nullptr) {
364 g_worker = CreateAndGetStreamTask();
365 }
366 if (g_worker == nullptr) {
367 return 0;
368 }
369 uint32_t msgSize = sizeof(ParamMessage) + sizeof(ParamMsgContent) + PARAM_ALIGN(strlen(value) + 1);
370 ParamMessage *request = (ParamMessage *)(ParamMessage *)CreateParamMessage(type, name, msgSize);
371 PARAM_CHECK(request != nullptr, return -1, "Failed to malloc for connect");
372 do {
373 uint32_t offset = 0;
374 int ret = FillParamMsgContent(request, &offset, PARAM_VALUE, value, strlen(value));
375 PARAM_CHECK(ret == 0, break, "Failed to fill value");
376 ProcessMessage((const ParamTaskPtr)g_worker, (const ParamMessage *)request);
377 } while (0);
378 free(request);
379 return 0;
380 }
381
382 // 无匹配
TestAddParamWait1()383 int TestAddParamWait1()
384 {
385 const char *name = "wait.aaa.bbb.ccc.111";
386 const char *value = "wait1";
387 AddWatch(MSG_WAIT_PARAM, name, value);
388 SystemWriteParam(name, value);
389 return 0;
390 }
391
392 // 模糊匹配
TestAddParamWait2()393 int TestAddParamWait2()
394 {
395 const char *name = "wait.aaa.bbb.ccc.222";
396 const char *value = "wait2";
397 AddWatch(MSG_WAIT_PARAM, name, "*");
398 SystemWriteParam(name, value);
399 return 0;
400 }
401
402 // 属性存在
TestAddParamWait3()403 int TestAddParamWait3()
404 {
405 const char *name = "wait.aaa.bbb.ccc.333";
406 const char *value = "wait3";
407 SystemWriteParam(name, value);
408 AddWatch(MSG_WAIT_PARAM, name, value);
409 return 0;
410 }
411
TestAddParamWatch1()412 int TestAddParamWatch1()
413 {
414 const char *name = "watch.aaa.bbb.ccc.111";
415 const char *value = "watch1";
416 AddWatch(MSG_ADD_WATCHER, name, value);
417 std::string newName = name;
418 newName += ".test.test.test";
419 SystemWriteParam(newName.c_str(), value);
420 return 0;
421 }
422
TestAddParamWatch2()423 int TestAddParamWatch2()
424 {
425 const char *name = "watch.aaa.bbb.ccc.222";
426 const char *value = "watch2";
427 AddWatch(MSG_ADD_WATCHER, name, "*");
428 SystemWriteParam(name, value);
429 return 0;
430 }
431
TestAddParamWatch3()432 int TestAddParamWatch3()
433 {
434 const char *name = "watch.aaa.bbb.ccc.333";
435 const char *value = "watch3";
436 std::string newName = name;
437 newName += ".test.test.test";
438 SystemWriteParam(newName.c_str(), value);
439 AddWatch(MSG_ADD_WATCHER, name, value);
440 return 0;
441 }
442
TestCloseTriggerWatch()443 int TestCloseTriggerWatch()
444 {
445 ParamWatcher *watcher = (ParamWatcher *)ParamGetTaskUserData(g_worker);
446 ClearWatchTrigger(watcher, TRIGGER_PARAM_WAIT);
447 ParamTaskClose(g_worker);
448 g_worker = nullptr;
449 SystemWriteParam("init.svc.param_watcher", "stopped");
450 return 0;
451 }
452
TestDumpParamMemory()453 int TestDumpParamMemory()
454 {
455 DumpParametersAndTriggers();
456 return 0;
457 }
458
TestServiceCtrl(const char * serviceName,int mode)459 int TestServiceCtrl(const char *serviceName, int mode)
460 {
461 // service forbit
462 ParamAuditData auditData = {};
463 auditData.name = "ohos.servicectrl.";
464 auditData.label = "";
465 auditData.dacData.gid = 202; // 202 test dac gid
466 auditData.dacData.uid = 202; // 202 test dac uid
467 auditData.dacData.mode = mode;
468 AddSecurityLabel(&auditData, GetParamWorkSpace());
469 return SystemWriteParam("ohos.ctl.start", serviceName);
470 }
471
TestPowerCtrl(const char * reboot,int mode)472 int TestPowerCtrl(const char *reboot, int mode)
473 {
474 // service forbit
475 ParamAuditData auditData = {};
476 auditData.name = "ohos.servicectrl.";
477 auditData.label = "";
478 auditData.dacData.gid = 202; // 202 test dac gid
479 auditData.dacData.uid = 202; // 202 test dac uid
480 auditData.dacData.mode = mode;
481 AddSecurityLabel(&auditData, GetParamWorkSpace());
482 return SystemWriteParam("ohos.startup.powerctrl", reboot);
483 }
484 };
485
486 HWTEST_F(ParamUnitTest, TestPersistParam, TestSize.Level0)
487 {
488 ParamUnitTest test;
489 test.TestPersistParam();
490 }
491
492 HWTEST_F(ParamUnitTest, TestSetParam_1, TestSize.Level0)
493 {
494 ParamUnitTest test;
495 const char *params[][2] = { { "111.2222", "1" },
496 { "111.2222.3333", "2" },
497 { "111.2222.3333.4444", "3" },
498 { "111.2222.3333.4444.666", "4" },
499 { "111.2222.3333.4444.666.777", "5" } };
500 test.TestSetParams(params, 5);
501 }
502
503 HWTEST_F(ParamUnitTest, TestSetParam_2, TestSize.Level0)
504 {
505 ParamUnitTest test;
506 const char *params[][2] = { { "111.2222.xxxx.xxx.xxx", "1_1" },
507 { "111.2222.3333.xxx", "1_2" },
508 { "111.2222.xxxx.3333.4444", "1_3" },
509 { "111.2222.3333.xxxx.4444.666", "1_4" },
510 { "111.2222.3333.4444.666.xxxxx.777", "1_5" } };
511 test.TestSetParams(params, 5);
512
513 const char *ctrlParams[][2] = { { "ctl.start.111.2222.xxxx.xxx.xxx", "2_1" },
514 { "ctl.start.111.2222.3333.xxx", "2_2" },
515 { "ctl.start.111.2222.xxxx.3333.4444", "2_3" },
516 { "ctl.start.111.2222.3333.xxxx.4444.666", "2_4" },
517 { "ctl.start.111.2222.3333.4444.666.xxxxx.777", "2_5" } };
518 test.TestSetParams(ctrlParams, 5);
519
520 const char *sysParams[][2] = { { "ohos.startup.powerctrl.111.2222.xxxx.xxx.xxx", "3_1" },
521 { "ohos.startup.powerctrl.111.2222.3333.xxx", "3_2" },
522 { "ohos.startup.powerctrl.111.2222.xxxx.3333.4444", "3_3" },
523 { "ohos.startup.powerctrl.111.2222.3333.xxxx.4444.666", "3_4" },
524 { "ohos.startup.powerctrl.111.2222.3333.4444.666.xxxxx.777", "3_5" } };
525 test.TestSetParams(sysParams, 5);
526 }
527
528 HWTEST_F(ParamUnitTest, TestNameIsValid, TestSize.Level0)
529 {
530 ParamUnitTest test;
531 test.TestNameIsValid();
532 }
533
534 HWTEST_F(ParamUnitTest, TestAddSecurityLabel1, TestSize.Level0)
535 {
536 ParamUnitTest test;
537 test.TestAddSecurityLabel1();
538 }
539
540 HWTEST_F(ParamUnitTest, TestAddSecurityLabel2, TestSize.Level0)
541 {
542 ParamUnitTest test;
543 test.TestAddSecurityLabel2();
544 }
545
546 HWTEST_F(ParamUnitTest, TestAddSecurityLabel3, TestSize.Level0)
547 {
548 ParamUnitTest test;
549 test.TestAddSecurityLabel3();
550 }
551
552 HWTEST_F(ParamUnitTest, TestAddSecurityLabel4, TestSize.Level0)
553 {
554 ParamUnitTest test;
555 test.TestAddSecurityLabel4();
556 }
557
558 HWTEST_F(ParamUnitTest, TestUpdateParam, TestSize.Level0)
559 {
560 ParamUnitTest test;
561 test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "100");
562 test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "101");
563 test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "102");
564 test.TestUpdateParam("test.aaa.bbb.ccc.ddd", "103");
565 test.TestUpdateParam("net.tcp.default_init_rwnd", "60");
566 }
567
568 HWTEST_F(ParamUnitTest, TestServiceProcessMessage, TestSize.Level0)
569 {
570 ParamUnitTest test;
571 test.TestServiceProcessMessage("wertt.qqqq.wwww.rrrr", "wwww.eeeee", 1);
572 test.TestServiceProcessMessage("wertt.2222.wwww.3333", "wwww.eeeee", 0);
573 }
574
575 HWTEST_F(ParamUnitTest, TestAddParamWait1, TestSize.Level0)
576 {
577 ParamUnitTest test;
578 test.TestAddParamWait1();
579 }
580
581 HWTEST_F(ParamUnitTest, TestAddParamWait2, TestSize.Level0)
582 {
583 ParamUnitTest test;
584 test.TestAddParamWait2();
585 }
586
587 HWTEST_F(ParamUnitTest, TestAddParamWait3, TestSize.Level0)
588 {
589 ParamUnitTest test;
590 test.TestAddParamWait3();
591 }
592
593 HWTEST_F(ParamUnitTest, TestAddParamWatch1, TestSize.Level0)
594 {
595 ParamUnitTest test;
596 test.TestAddParamWatch1();
597 }
598
599 HWTEST_F(ParamUnitTest, TestAddParamWatch2, TestSize.Level0)
600 {
601 ParamUnitTest test;
602 test.TestAddParamWatch2();
603 }
604
605 HWTEST_F(ParamUnitTest, TestAddParamWatch3, TestSize.Level0)
606 {
607 ParamUnitTest test;
608 test.TestAddParamWatch3();
609 }
610
611 HWTEST_F(ParamUnitTest, TestCloseTriggerWatch, TestSize.Level0)
612 {
613 ParamUnitTest test;
614 test.TestCloseTriggerWatch();
615 }
616
617 HWTEST_F(ParamUnitTest, TestParamTraversal, TestSize.Level0)
618 {
619 ParamUnitTest test;
620 test.TestParamTraversal();
621 }
622
623 HWTEST_F(ParamUnitTest, TestDumpParamMemory, TestSize.Level0)
624 {
625 ParamUnitTest test;
626 test.TestDumpParamMemory();
627 }
628
629 HWTEST_F(ParamUnitTest, TestServiceCtrl, TestSize.Level0)
630 {
631 ParamUnitTest test;
632 int ret = test.TestServiceCtrl("server1", 0770);
633 EXPECT_NE(ret, 0);
634 ret = test.TestServiceCtrl("server2", 0772);
635 EXPECT_EQ(ret, 0);
636 }
637
638 HWTEST_F(ParamUnitTest, TestPowerCtrl, TestSize.Level0)
639 {
640 ParamUnitTest test;
641 int ret = test.TestPowerCtrl("reboot,shutdown", 0770);
642 EXPECT_NE(ret, 0);
643 ret = test.TestPowerCtrl("reboot,shutdown", 0772);
644 EXPECT_EQ(ret, 0);
645 ret = test.TestPowerCtrl("reboot,updater", 0770);
646 EXPECT_NE(ret, 0);
647 ret = test.TestPowerCtrl("reboot,updater", 0772);
648 EXPECT_EQ(ret, 0);
649 ret = test.TestPowerCtrl("reboot,flash", 0770);
650 EXPECT_NE(ret, 0);
651 ret = test.TestPowerCtrl("reboot,flash", 0772);
652 EXPECT_EQ(ret, 0);
653 ret = test.TestPowerCtrl("reboot", 0770);
654 EXPECT_NE(ret, 0);
655 ret = test.TestPowerCtrl("reboot", 0772);
656 EXPECT_EQ(ret, 0);
657 }