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