• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "begetctl.h"
16 #include "param_stub.h"
17 #include "securec.h"
18 #include "shell.h"
19 
20 using namespace std;
21 using namespace testing::ext;
22 
23 namespace init_ut {
24 class BegetctlUnitTest : public testing::Test {
25 public:
SetUpTestCase(void)26     static void SetUpTestCase(void) {};
TearDownTestCase(void)27     static void TearDownTestCase(void) {};
SetUp(void)28     void SetUp(void) {};
TearDown(void)29     void TearDown(void) {};
30 };
31 
32 HWTEST_F(BegetctlUnitTest, TestShellInit, TestSize.Level0)
33 {
34     BShellParamCmdRegister(GetShellHandle(), 0);
35     const char *args[] = {
36         "param"
37     };
38     BShellEnvDirectExecute(GetShellHandle(), 1, const_cast<char **>(args));
39 }
40 
41 HWTEST_F(BegetctlUnitTest, TestShellLs, TestSize.Level1)
42 {
43     BShellParamCmdRegister(GetShellHandle(), 0);
44     const char *args[] = {
45         "param", "ls"
46     };
47     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
48 }
49 
50 HWTEST_F(BegetctlUnitTest, TestShellLsWithR, TestSize.Level1)
51 {
52     BShellParamCmdRegister(GetShellHandle(), 0);
53     const char *args[] = {
54         "param", "ls", "-r"
55     };
56     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
57 }
58 
59 HWTEST_F(BegetctlUnitTest, TestShellLsGet, TestSize.Level1)
60 {
61     BShellParamCmdRegister(GetShellHandle(), 0);
62     const char *args[] = {
63         "param", "get"
64     };
65     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
66 }
67 
68 HWTEST_F(BegetctlUnitTest, TestShellSet, TestSize.Level1)
69 {
70     BShellParamCmdRegister(GetShellHandle(), 0);
71     const char *args[] = {
72         "param", "set", "aaaaa", "1234567"
73     };
74     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
75 }
76 
77 HWTEST_F(BegetctlUnitTest, TestShellGetWithKey, TestSize.Level1)
78 {
79     BShellParamCmdRegister(GetShellHandle(), 0);
80     const char *args[] = {
81         "param", "get", "aaaaa"
82     };
83     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
84 }
85 
86 HWTEST_F(BegetctlUnitTest, TestShellWait, TestSize.Level1)
87 {
88     BShellParamCmdRegister(GetShellHandle(), 0);
89     const char *args[] = {
90         "param", "wait", "aaaaa"
91     };
92     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
93 }
94 HWTEST_F(BegetctlUnitTest, TestShellWaitFalse, TestSize.Level1)
95 {
96     BShellParamCmdRegister(GetShellHandle(), 0);
97     const char *args[] = {
98         "param", "wait"
99     };
100     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
101 }
102 
103 HWTEST_F(BegetctlUnitTest, TestShellWaitWithKey, TestSize.Level1)
104 {
105     BShellParamCmdRegister(GetShellHandle(), 0);
106     const char *args[] = {
107         "param", "wait", "aaaaa", "12*", "30"
108     };
109     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
110 }
111 HWTEST_F(BegetctlUnitTest, TestShellParamShell, TestSize.Level1)
112 {
113     BShellParamCmdRegister(GetShellHandle(), 0);
114     const char *args[] = {
115         "param", "shell"
116     };
117     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
118 }
119 HWTEST_F(BegetctlUnitTest, TestShellLsWithvalue, TestSize.Level1)
120 {
121     BShellParamCmdRegister(GetShellHandle(), 0);
122     BShellEnvSetParam(GetShellHandle(), PARAM_REVERESD_NAME_CURR_PARAMETER, "..a", PARAM_STRING, (void *)"..a");
123     const char *args[] = {
124         "param", "ls", PARAM_REVERESD_NAME_CURR_PARAMETER
125     };
126     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
127 }
128 HWTEST_F(BegetctlUnitTest, TestShellLsWithvalueExist, TestSize.Level1)
129 {
130     BShellParamCmdRegister(GetShellHandle(), 0);
131     BShellEnvSetParam(GetShellHandle(), PARAM_REVERESD_NAME_CURR_PARAMETER, "#", PARAM_STRING, (void *)"#");
132     const char *args[] = {
133         "param", "ls", "-r", PARAM_REVERESD_NAME_CURR_PARAMETER
134     };
135     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
136 }
137 
138 HWTEST_F(BegetctlUnitTest, TestPartitionSlot_1, TestSize.Level1)
139 {
140     const char *args[] = {
141         "partitionslot", "getslot"
142     };
143     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
144 }
145 
146 HWTEST_F(BegetctlUnitTest, TestPartitionSlot_2, TestSize.Level1)
147 {
148     const char *args[] = {
149         "partitionslot", "getsuffix", "1"
150     };
151     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
152 }
153 
154 HWTEST_F(BegetctlUnitTest, TestPartitionSlot_3, TestSize.Level1)
155 {
156     const char *args[] = {
157         "partitionslot", "setactive", "1"
158     };
159     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
160 }
161 
162 HWTEST_F(BegetctlUnitTest, TestPartitionSlot_4, TestSize.Level1)
163 {
164     const char *args[] = {
165         "partitionslot", "setunboot", "2"
166     };
167     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
168 }
169 
170 HWTEST_F(BegetctlUnitTest, TestPartitionSlot_5, TestSize.Level1)
171 {
172     const char *args[] = {
173         "partitionslot", "setactive"
174     };
175     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
176 }
177 
178 HWTEST_F(BegetctlUnitTest, TestPartitionSlot_6, TestSize.Level1)
179 {
180     const char *args[] = {
181         "partitionslot", "setunboot"
182     };
183     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
184 }
185 
186 HWTEST_F(BegetctlUnitTest, TestPartitionSlot_7, TestSize.Level1)
187 {
188     const char *args[] = {
189         "partitionslot", "getsuffix"
190     };
191     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
192 }
193 
194 HWTEST_F(BegetctlUnitTest, TestBegetctl_1, TestSize.Level1)
195 {
196     const char *args[] = {
197         "set", "log", "level", "1"
198     };
199     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
200 }
201 
202 HWTEST_F(BegetctlUnitTest, TestBegetctl_2, TestSize.Level1)
203 {
204     const char *args[] = {
205         "get", "log", "level"
206     };
207     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
208 }
209 
210 HWTEST_F(BegetctlUnitTest, TestBegetctl_3, TestSize.Level1)
211 {
212     const char *args[] = {
213         "set", "log", "level"
214     };
215     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
216 }
217 
218 HWTEST_F(BegetctlUnitTest, TestBegetctl_4, TestSize.Level1)
219 {
220     const char *args[] = {
221         "set", "log", "level", "1000"
222     };
223     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
224 }
225 
226 HWTEST_F(BegetctlUnitTest, TestBegetctl_5, TestSize.Level1)
227 {
228     const char *args[] = {
229         "set", "log", "level", "a"
230     };
231     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
232 }
233 
234 HWTEST_F(BegetctlUnitTest, TestBootChart_1, TestSize.Level1)
235 {
236     const char *args[] = {
237         "bootchart", "enable"
238     };
239     SystemWriteParam("persist.init.bootchart.enabled", "1");
240     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
241 }
242 
243 HWTEST_F(BegetctlUnitTest, TestBootChart_2, TestSize.Level1)
244 {
245     const char *args[] = {
246         "bootchart", "start"
247     };
248 
249     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
250 }
251 
252 HWTEST_F(BegetctlUnitTest, TestBootChart_3, TestSize.Level1)
253 {
254     const char *args[] = {
255         "bootchart", "stop"
256     };
257     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
258 }
259 
260 HWTEST_F(BegetctlUnitTest, TestBootChart_4, TestSize.Level1)
261 {
262     const char *args[] = {
263         "bootchart", "disable"
264     };
265     SystemWriteParam("persist.init.bootchart.enabled", "0");
266     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
267 }
268 
269 HWTEST_F(BegetctlUnitTest, TestBootChart_5, TestSize.Level1)
270 {
271     const char *args[] = {
272         "bootchart"
273     };
274     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
275 }
276 
277 HWTEST_F(BegetctlUnitTest, TestDumpService_1, TestSize.Level1)
278 {
279     const char *args[] = {
280         "bootevent", "enable"
281     };
282     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
283 }
284 
285 HWTEST_F(BegetctlUnitTest, TestDumpService_2, TestSize.Level1)
286 {
287     const char *args[] = {
288         "bootevent", "disable"
289     };
290     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
291 }
292 
293 HWTEST_F(BegetctlUnitTest, TestDumpService_3, TestSize.Level1)
294 {
295     const char *args[] = {
296         "dump_service", "all"
297     };
298     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
299 }
300 
301 HWTEST_F(BegetctlUnitTest, TestDumpService_4, TestSize.Level1)
302 {
303     const char *args[] = {
304         "dump_service", "param_watcher"
305     };
306     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
307 }
308 
309 HWTEST_F(BegetctlUnitTest, TestDumpService_5, TestSize.Level1)
310 {
311     const char *args[] = {
312         "dump_service", "parameter-service", "trigger"
313     };
314     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
315 }
316 
317 HWTEST_F(BegetctlUnitTest, TestMiscDaemon, TestSize.Level1)
318 {
319     const char *args[] = {
320         "misc_daemon", "--write_logo", BOOT_CMD_LINE
321     };
322     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
323 }
324 
325 HWTEST_F(BegetctlUnitTest, TestMiscDaemon_1, TestSize.Level1)
326 {
327     const char *args[] = {
328         "misc_daemon", "--write_logo1111", "test"
329     };
330     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
331 }
332 
333 HWTEST_F(BegetctlUnitTest, TestMiscDaemon_2, TestSize.Level1)
334 {
335     const char *args[] = {
336         "misc_daemon", "--write_logo", ""
337     };
338     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
339 }
340 
341 HWTEST_F(BegetctlUnitTest, TestMiscDaemon_3, TestSize.Level1)
342 {
343     const char *args[] = {
344         "misc_daemon", "--write_logo"
345     };
346     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
347 }
348 
349 HWTEST_F(BegetctlUnitTest, TestMiscDaemon_4, TestSize.Level1)
350 {
351     // clear misc logo
352     const char *args[] = {
353         "misc_daemon", "--write_logo", "sssssssss"
354     };
355     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
356 }
357 
358 HWTEST_F(BegetctlUnitTest, TestModulectl_1, TestSize.Level1)
359 {
360     const char *args[] = {
361         "modulectl", "install", "testModule"
362     };
363     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
364 }
365 
366 HWTEST_F(BegetctlUnitTest, TestModulectl_2, TestSize.Level1)
367 {
368     const char *args[] = {
369         "modulectl", "uninstall", "testModule"
370     };
371     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
372 }
373 
374 HWTEST_F(BegetctlUnitTest, TestModulectl_3, TestSize.Level1)
375 {
376     const char *args[] = {
377         "modulectl", "list", "testModule"
378     };
379     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
380 }
381 
382 HWTEST_F(BegetctlUnitTest, TestModulectl_4, TestSize.Level1)
383 {
384     const char *args[] = {
385         "modulectl", "install"
386     };
387     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
388 }
389 
390 HWTEST_F(BegetctlUnitTest, TestModulectl_5, TestSize.Level1)
391 {
392     const char *args[] = {
393         "modulectl", "list"
394     };
395     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
396 }
397 
398 HWTEST_F(BegetctlUnitTest, TestModulectl_6, TestSize.Level1)
399 {
400     BShellEnvDirectExecute(GetShellHandle(), 0, nullptr);
401 }
402 
403 HWTEST_F(BegetctlUnitTest, TestServiceControl_1, TestSize.Level1)
404 {
405     const char *args[] = {
406         "service_control", "stop", "test"
407     };
408     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
409 }
410 
411 HWTEST_F(BegetctlUnitTest, TestServiceControl_2, TestSize.Level1)
412 {
413     const char *args[] = {
414         "service_control", "start", "test"
415     };
416     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
417 }
418 
419 HWTEST_F(BegetctlUnitTest, TestServiceControl_3, TestSize.Level1)
420 {
421     const char *args[] = {
422         "stop_service", "test"
423     };
424     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
425 }
426 
427 HWTEST_F(BegetctlUnitTest, TestServiceControl_4, TestSize.Level1)
428 {
429     const char *args[] = {
430         "start_service", "test"
431     };
432     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
433 }
434 
435 HWTEST_F(BegetctlUnitTest, TestServiceControl_5, TestSize.Level1)
436 {
437     const char *args[] = {
438         "timer_stop", "test"
439     };
440     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
441 }
442 
443 HWTEST_F(BegetctlUnitTest, TestServiceControl_6, TestSize.Level1)
444 {
445     const char *args[] = {
446         "timer_stop"
447     };
448     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
449 }
450 
451 HWTEST_F(BegetctlUnitTest, TestServiceControl_7, TestSize.Level1)
452 {
453     const char *args[] = {
454         "timer_start", "test-service", "10"
455     };
456     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
457 }
458 
459 HWTEST_F(BegetctlUnitTest, TestServiceControl_8, TestSize.Level1)
460 {
461     const char *args[] = {
462         "timer_start", "test-service",
463     };
464     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
465 }
466 
467 HWTEST_F(BegetctlUnitTest, TestServiceControl_9, TestSize.Level1)
468 {
469     const char *args[] = {
470         "timer_start", "test-service", "ww"
471     };
472     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
473 }
474 
475 HWTEST_F(BegetctlUnitTest, TestServiceControl_10, TestSize.Level1)
476 {
477     const char *args[] = {
478         "xxxxxxxxxxxxxx", "test-service", "ww"
479     };
480     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
481 }
482 
483 HWTEST_F(BegetctlUnitTest, TestSetLogLevel_1, TestSize.Level1)
484 {
485     const char *args[] = {
486         "setloglevel", "1"
487     };
488     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
489 }
490 
491 HWTEST_F(BegetctlUnitTest, TestSetLogLevel_2, TestSize.Level1)
492 {
493     const char *args[] = {
494         "getloglevel"
495     };
496     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
497 }
498 
499 HWTEST_F(BegetctlUnitTest, TestSetLogLevel_3, TestSize.Level1)
500 {
501     const char *args[] = {
502         "setloglevel", "a"
503     };
504     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
505 }
506 
507 HWTEST_F(BegetctlUnitTest, TestSetLogLevel_4, TestSize.Level1)
508 {
509     const char *args[] = {
510         "setloglevel"
511     };
512     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
513 }
514 
515 HWTEST_F(BegetctlUnitTest, TestSetLogLevel_5, TestSize.Level1)
516 {
517     const char *args[] = {
518         "setloglevel"
519     };
520     BShellEnvDirectExecute(GetShellHandle(), 0, const_cast<char **>(args));
521 }
522 
523 HWTEST_F(BegetctlUnitTest, TestSandbox, TestSize.Level1)
524 {
525     const char *args[] = {
526         "sandbox", "-s", "test", "-n", "test2", "-p", "test3", "-h", "?"
527     };
528     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
529 }
530 
531 HWTEST_F(BegetctlUnitTest, TestReboot_1, TestSize.Level1)
532 {
533     const char *args[] = {
534         "reboot"
535     };
536     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
537 }
538 
539 HWTEST_F(BegetctlUnitTest, TestReboot_2, TestSize.Level1)
540 {
541     const char *args[] = {
542         "reboot", "shutdown"
543     };
544     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
545 }
546 
547 HWTEST_F(BegetctlUnitTest, TestReboot_3, TestSize.Level1)
548 {
549     const char *args[] = {
550         "reboot", "charge"
551     };
552     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
553 }
554 
555 HWTEST_F(BegetctlUnitTest, TestReboot_4, TestSize.Level1)
556 {
557     const char *args[] = {
558         "reboot", "updater"
559     };
560     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
561 }
562 
563 HWTEST_F(BegetctlUnitTest, TestReboot_5, TestSize.Level1)
564 {
565     const char *args[] = {
566         "reboot", "updater:aaaaaaa"
567     };
568     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
569 }
570 
571 HWTEST_F(BegetctlUnitTest, TestReboot_6, TestSize.Level1)
572 {
573     const char *args[] = {
574         "reboot", "flashd:aaaaaaa"
575     };
576     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
577 }
578 
579 HWTEST_F(BegetctlUnitTest, TestReboot_7, TestSize.Level1)
580 {
581     const char *args[] = {
582         "reboot", "flashd"
583     };
584     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
585 }
586 
587 HWTEST_F(BegetctlUnitTest, TestReboot_8, TestSize.Level1)
588 {
589     const char *args[] = {
590         "reboot", "suspend"
591     };
592     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
593 }
594 
595 HWTEST_F(BegetctlUnitTest, TestReboot_9, TestSize.Level1)
596 {
597     const char *args[] = {
598         "reboot", "222222222"
599     };
600     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
601 }
602 
603 HWTEST_F(BegetctlUnitTest, TestGid_1, TestSize.Level1)
604 {
605     const char *args[] = {
606         "dac", "gid", "logd"
607     };
608     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
609 }
610 
611 HWTEST_F(BegetctlUnitTest, TestGid_2, TestSize.Level1)
612 {
613     const char *args[] = {
614         "dac"
615     };
616     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
617 }
618 
619 HWTEST_F(BegetctlUnitTest, TestUid_1, TestSize.Level1)
620 {
621     const char *args[] = {
622         "dac", "uid", ""
623     };
624     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
625 }
626 
627 HWTEST_F(BegetctlUnitTest, TestUid_2, TestSize.Level1)
628 {
629     const char *args[] = {
630         "dac", "uid", ""
631     };
632     BShellEnvDirectExecute(GetShellHandle(), sizeof(args) / sizeof(args[0]), const_cast<char **>(args));
633 }
634 }  // namespace init_ut
635