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
16#include <unistd.h>
17#include <string.h>
18#include <locale.h>
19#include <search.h>
20#include <err.h>
21#include <regex.h>
22#include <sys/types.h>
23#include <sys/utsname.h>
24#include "gtest/gtest.h"
25#include "log.h"
26#include "utils.h"
27#include "KernelConstants.h"
28
29#define SYS_TEST_FILE_01 "/storage/data/systest01.txt"
30using namespace testing::ext;
31
32class SysApiTest : public testing::Test {
33protected:
34    // SetUpTestCase: Testsuit setup, run before 1st testcase
35    static void SetUpTestCase(void)
36    {
37        LOG("setup ok\n");
38    }
39    // TearDownTestCase: Testsuit teardown, run after last testcase
40    static void TearDownTestCase(void)
41    {
42        unsetenv("PATH");
43        unsetenv("HOME");
44        LOG("teardown ok\n");
45    }
46};
47
48/**
49* @tc.number     SUB_KERNEL_SYS_GETENV_0100
50* @tc.name       test getenv
51* @tc.desc       [C- SOFTWARE -0200]
52*/
53HWTEST_F(SysApiTest, testGetenv, Function | MediumTest | Level2)
54{
55    EXPECT_STREQ(getenv("HOME"), nullptr) << "Getenv HOME error!";
56    EXPECT_STREQ(getenv("ROOT"), nullptr) << "Getenv HOME error!";
57
58    ASSERT_EQ(setenv("PATH", "/bin", 1), 0) << "setenv PATH fail!";
59    EXPECT_STREQ(getenv("PATH"), "/bin") << "secure_get PATH env error!";
60
61    setenv("PATH", "/usr/bin", 0);
62    EXPECT_STREQ(getenv("PATH"), "/bin") << "setenv PATH error!";
63    unsetenv("PATH");
64}
65
66/**
67* @tc.number     SUB_KERNEL_SYS_SECURE_GETENV_0100
68* @tc.name       test secure_getenv
69* @tc.desc       [C- SOFTWARE -0200]
70*/
71HWTEST_F(SysApiTest, testSecureGetenv, Function | MediumTest | Level2)
72{
73    EXPECT_STREQ(secure_getenv("HOME"), NULL) << "Secure_getenv HOME error!";
74    EXPECT_STREQ(secure_getenv("ROOT"), NULL) << "Secure_getenv HOME error!";
75
76    ASSERT_EQ(setenv("PATH", "", 1), 0) << "setenv PATH fail!";
77    EXPECT_STREQ(secure_getenv("PATH"), "") << "secure_getenv PATH error!";
78
79    setenv("PATH", "/usr/bin", 0);
80    EXPECT_STREQ(secure_getenv("PATH"), "") << "setenv PATH error!";
81    unsetenv("PATH");
82}
83
84/**
85* @tc.number     SUB_KERNEL_SYS_SETENV_0100
86* @tc.name       test setenv
87* @tc.desc       [C- SOFTWARE -0200]
88*/
89HWTEST_F(SysApiTest, testSetenv, Function | MediumTest | Level2)
90{
91    ASSERT_EQ(setenv("", "/bin", 1), -1) << "envname error ";
92    ASSERT_EQ(setenv("HOME", "/bin", 1), 0) << "setenv fail!";
93    EXPECT_STREQ(secure_getenv("HOME"), "/bin") << "getenv fail !";
94    int pid;
95    pid = fork();
96    if (pid == 0) {
97        if (strcmp(secure_getenv("HOME"), "/bin") == 0) {
98            exit(0);
99        } else {
100            LOG("child process home env is different from parent !");
101            exit(1);
102        }
103    } else {
104            WaitProcExitedOK(pid);
105    }
106}
107
108/**
109* @tc.number    SUB_KERNEL_SYS_SETENV_0200
110* @tc.name      test setenv in child process
111* @tc.desc      [C- SOFTWARE -0200]
112*/
113HWTEST_F(SysApiTest, testSetenvInChild, Function | MediumTest | Level3)
114{
115    setenv("HOME", "", 1);
116    int pid;
117    pid = fork();
118    if (pid == 0) {
119        setenv("HOME", "/usr/bin", 1);
120        if (strcmp(secure_getenv("HOME"), "/usr/bin") == 0) {
121            exit(0);
122        } else {
123            LOG("child process getenv error!");
124            exit(1);
125        }
126    } else {
127        WaitProcExitedOK(pid);
128        EXPECT_STREQ(secure_getenv("HOME"), "") << "parent env has changed by child process !";
129    }
130    unsetenv("HOME");
131}
132
133/**
134* @tc.number     SUB_KERNEL_SYS_PUTENV_0100
135* @tc.name       test putenv
136* @tc.desc       [C- SOFTWARE -0200]
137*/
138HWTEST_F(SysApiTest, testPutenv, Function | MediumTest | Level2)
139{
140    ASSERT_EQ(putenv((char *)"PATH=/bin"), 0) << "putenv PATH fail!";
141    EXPECT_STREQ(secure_getenv("PATH"), "/bin") << "getenv fail !";
142    unsetenv("PATH");
143}
144
145/**
146* @tc.number     SUB_KERNEL_SYS_PUTENV_0200
147* @tc.name       test putenv in parent and child process
148* @tc.desc       [C- SOFTWARE -0200]
149*/
150HWTEST_F(SysApiTest, testPutenvInProcess, Function | MediumTest | Level3)
151{
152    ASSERT_EQ(putenv((char *)"HOME=/bin"), 0) << "putenv PATH fail!";
153    int pid;
154    pid = fork();
155    if (pid == 0) {
156        int rt = 0;
157        if (strcmp(secure_getenv("HOME"), "/bin") != 0) {
158            rt = 1;
159            LOG("child process PATH env are different from parent process!");
160        }
161        if (putenv((char *)"PATH=/bin") != 0) {
162            rt = 1;
163            LOG("putenv PATH fail in child process!");
164        }
165        exit(rt);
166    } else {
167        WaitProcExitedOK(pid);
168        EXPECT_STRNE(secure_getenv("PATH"), "/bin") << "parent env has changed by child process !";
169    }
170    unsetenv("HOME");
171    unsetenv("PATH");
172}
173
174/**
175* @tc.number    SUB_KERNEL_SYS_UNSETENV_0100
176* @tc.name      test unsetenv
177* @tc.desc      [C- SOFTWARE -0200]
178*/
179HWTEST_F(SysApiTest, testUnsetenv, Function | MediumTest | Level2)
180{
181    setenv("HOME", "/bin", 1);
182    ASSERT_EQ(unsetenv("HOME"), 0) << "delete home env error !";
183    LOG("after Unsetenv homePath=%s", secure_getenv("HOME"));
184    EXPECT_STREQ(secure_getenv("HOME"), NULL) << "home env is not null !";
185
186    ASSERT_EQ(unsetenv("ABC"), 0) << "unsetenv other env error !";
187}
188
189int CompareInt(const void *a, const void *b)
190{
191    return (*(int*)a - *(int*)b);
192}
193/**
194* @tc.number    SUB_KERNEL_SYS_QSORT_0100
195* @tc.name      test qsort int
196* @tc.desc      [C- SOFTWARE -0200]
197*/
198HWTEST_F(SysApiTest, testQsort, Function | MediumTest | Level1)
199{
200    int iArray[] = { -99, 0, 65537, 100, 15, 6000 };
201    int iArrayOk[] = { -99, 0, 15, 100, 6000, 65537 };
202    qsort(iArray, 6, sizeof(int), CompareInt);
203    for (int i = 0; i < 6; i++){
204        EXPECT_EQ(iArray[i], iArrayOk[i]) << "int qsort error!";
205    }
206}
207
208int CompareChar(const void *a, const void *b)
209{
210    return strcmp((char *)a, (char *)b);
211}
212/**
213* @tc.number    SUB_KERNEL_SYS_QSORT_0200
214* @tc.name      test qsort char
215* @tc.desc      [C- SOFTWARE -0200]
216*/
217HWTEST_F(SysApiTest, testQsortChar, Function | MediumTest | Level1)
218{
219    char cArray[] = { 'z', 's', 'a', 'j', 'p', 'o' };
220    char cArrayOk[] = { 'a', 'j', 'o', 'p', 's', 'z' };
221    qsort(cArray, 6, sizeof(char), CompareChar);
222    EXPECT_EQ(strncmp(cArray, cArrayOk, sizeof(cArray)), 0) << "char qsort error!";
223}
224
225int CompareFloat(const void *a, const void *b)
226{
227    float fa = *(float *)a;
228    float fb = *(float *)b;
229    return (fa > fb) ? 1 : -1;
230}
231/**
232* @tc.number    SUB_KERNEL_SYS_QSORT_0300
233* @tc.name      test qsort float
234* @tc.desc      [C- SOFTWARE -0200]
235*/
236HWTEST_F(SysApiTest, testQsortFloat, Function | MediumTest | Level2)
237{
238    float fArray[] = { 1.2f, 10.5f, 3.8f, 99.7f, 0.8f, 6000.0f };
239    float fArrayOk[] = { 0.8f, 1.2f, 3.8f, 10.5f, 99.7f, 6000.0f };
240    qsort(fArray, 6, sizeof(float), CompareFloat);
241    for (int i = 0; i < 6; i++) {
242        EXPECT_FLOAT_EQ(fArray[i], fArrayOk[i]) << "float qsort error!";
243    }
244}
245
246int CompareDouble(const void *a, const void *b)
247{
248    double fa = *(double *)a;
249    double fb = *(double *)b;
250    return (fa > fb) ? 1 : -1;
251}
252/**
253* @tc.number    SUB_KERNEL_SYS_QSORT_0400
254* @tc.name      test qsort double
255* @tc.desc      [C- SOFTWARE -0200]
256*/
257HWTEST_F(SysApiTest, testQsortDouble, Function | MediumTest | Level2)
258{
259    double fArray[] = { 1.78, 1.09, 1.63, -1.11, 1.99, 1.30 };
260    double fArrayOk[] = { -1.11, 1.09, 1.30, 1.63, 1.78, 1.99 };
261    qsort(fArray, 6, sizeof(double), CompareDouble);
262    for (int i = 0; i < 6; i++) {
263        EXPECT_DOUBLE_EQ(fArray[i], fArrayOk[i]) << "double qsort error!";
264    }
265}
266
267void TestRegcomp(int flag, const char *pattern, const char *buf, const char *resOk)
268{
269    regmatch_t pmatch[1];
270    const size_t nmatch = 1;
271    regex_t reg;
272    char res[64];
273    int j = 0;
274    regcomp(&reg, pattern, flag);
275    int status = regexec(&reg, buf, nmatch, pmatch, 0);
276    EXPECT_EQ(status, 0) << "extended flag error !";
277    if (status == REG_NOMATCH) {
278        LOG("no match");
279    } else if (status == 0) {
280        LOG("Match:");
281        for (int i = pmatch[0].rm_so; i < pmatch[0].rm_eo; i++) {
282            putchar(buf[i]);
283            res[j] = buf[i];
284            j++;
285        }
286        res[j] = 0;
287        LOG("\n");
288    }
289    EXPECT_STREQ(res, resOk) << "match result error !";
290    regfree(&reg);
291}
292
293/**
294* @tc.number    SUB_KERNEL_SYS_REGCOMP_0100
295* @tc.name      test regcomp cflags = Extended
296* @tc.desc      [C- SOFTWARE -0200]
297*/
298HWTEST_F(SysApiTest, testRegcompExtended, Function | MediumTest | Level2)
299{
300    TestRegcomp(REG_EXTENDED, "^\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*.\\w+([-.]\\w+)*$",
301                "harmony20000925@abcdef.com", "harmony20000925@abcdef.com");
302}
303
304/**
305* @tc.number    SUB_KERNEL_SYS_REGCOMP_0200
306* @tc.name      test regcomp cflags = ICASE
307* @tc.desc      [C- SOFTWARE -0200]
308*/
309HWTEST_F(SysApiTest, testRegcompIcase, Function | MediumTest | Level2)
310{
311    TestRegcomp(REG_ICASE, "HARMONY[1-9]",
312            "harmony20000925@abcdef.com", "harmony2");
313}
314
315/**
316* @tc.number    SUB_KERNEL_SYS_REGCOMP_0300
317* @tc.name      test regcomp cflags = NEWLINE
318* @tc.desc      [C- SOFTWARE -0200]
319*/
320HWTEST_F(SysApiTest, testRegcompNewline, Function | MediumTest | Level2)
321{
322    TestRegcomp(REG_EXTENDED|REG_NEWLINE, "^addr=([^&]*)",
323            "testohos&sex=girl&age=18\r\naddr=bantian&hobby=movie", "addr=bantian");
324}
325
326/**
327* @tc.number    SUB_KERNEL_SYS_REGCOMP_0400
328* @tc.name      test regcomp cflags = NOSUB
329* @tc.desc      [C- SOFTWARE -0200]
330*/
331HWTEST_F(SysApiTest, testRegcompNosub, Function | MediumTest | Level3)
332{
333    int cflags = REG_ICASE|REG_NOSUB;
334    regex_t reg;
335    const char* buf = "harmony20000925@abcdef.com";
336    const char* pattern2 = "HARMONY[1-9]";
337    regcomp(&reg, pattern2, cflags);
338    int status = regexec(&reg, buf, (size_t)0, nullptr, 0);
339    EXPECT_EQ(status, 0) << "nosub flag error !";
340    regfree(&reg);
341}
342
343/**
344* @tc.number    SUB_KERNEL_SYS_REGERROR_0100
345* @tc.name      test regerror from regcomp
346* @tc.desc      [C- SOFTWARE -0200]
347*/
348HWTEST_F(SysApiTest, testRegerrorComp, Function | MediumTest | Level2)
349{
350    regex_t reg;
351    const char* pattern2 = "^[a-zA-Z0-9]*@[a-zA-Z0-9-_.]*[.]*?";
352    int status = regcomp(&reg, pattern2, REG_EXTENDED);
353    char emsg[1024] = {0};
354    size_t len = regerror(status, nullptr, emsg, sizeof(emsg));
355    EXPECT_TRUE(len == 24) << "len return error !";
356    len = len < sizeof(emsg) ? len : sizeof(emsg) - 1;
357    emsg[len] = '\0';
358    LOG("status = %d; ErrMsg: %s", status, emsg);
359    EXPECT_STREQ("Invalid character range", emsg) << "get regerror message error !";
360}
361
362/**
363* @tc.number    SUB_KERNEL_SYS_REGERROR_0200
364* @tc.name      test regerror from regexec
365* @tc.desc      [C- SOFTWARE -0200]
366*/
367HWTEST_F(SysApiTest, testRegerrorExec, Function | MediumTest | Level2)
368{
369    regex_t reg;
370    const char* buf = "harmony20000925@abcdef.com";
371    const char* pattern2 = "HARMONY[1-9]";
372    regcomp(&reg, pattern2, REG_EXTENDED);
373    int status = regexec(&reg, buf, (size_t) 0, nullptr, 0);
374    char emsg[1024] = {0};
375    size_t len = regerror(status, &reg, emsg, sizeof(emsg));
376    EXPECT_TRUE(len == 9) << "len return error !";
377    len = len < sizeof(emsg) ? len : sizeof(emsg) - 1;
378    emsg[len] = '\0';
379    LOG("ErrMsg: %s", emsg);
380    EXPECT_STREQ("No match", emsg) << "get regerror message error !";
381}
382
383/**
384* @tc.number    SUB_KERNEL_SYS_STRERROR_0100
385* @tc.name      test strerror
386* @tc.desc      [C- SOFTWARE -0200]
387*/
388HWTEST_F(SysApiTest, testStrerror, Function | MediumTest | Level1)
389{
390    for (int i = 0; i < 15; i++) {
391        LOG("%d : %s", i, strerror(i));
392    }
393    EXPECT_STREQ("No error information", strerror(-1)) << "get strerror error!";
394    EXPECT_STREQ("No error information", strerror(0)) << "get strerror error!";
395    EXPECT_STREQ("No such file or directory", strerror(2)) << "get strerror error!";
396    EXPECT_STREQ("No child process", strerror(10)) << "get strerror error!";
397    EXPECT_STREQ("No error information", strerror(65536)) << "get strerror error!";
398}
399
400/**
401* @tc.number    SUB_KERNEL_SYS_STRERROR_L_0100
402* @tc.name      test strerror_l
403* @tc.desc      [C- SOFTWARE -0200]
404*/
405HWTEST_F(SysApiTest, testStrerror_l, Function | MediumTest | Level2)
406{
407    int errnum = 2;
408    locale_t locale = newlocale(LC_ALL, "", (locale_t)0);
409    char *errorStr = strerror_l(errnum, locale);
410    LOG("Error: %s", errorStr);
411    EXPECT_STREQ("No such file or directory", errorStr) << "get strerror error!";
412}
413
414/**
415* @tc.number    SUB_KERNEL_SYS_STRERROR_R_0100
416* @tc.name      test strerror_r
417* @tc.desc      [C- SOFTWARE -0200]
418*/
419HWTEST_F(SysApiTest, testStrerror_r, Function | MediumTest | Level2)
420{
421    int rt;
422    int errnum = 2;
423    char buf[8];
424    rt = strerror_r(errnum, buf, 8);
425    EXPECT_EQ(rt, ERANGE) << "strerror_r return error!";
426    EXPECT_STREQ(buf, "No such") << "get strerror_r error!";
427    char buf2[256];
428    rt = strerror_r(errnum, buf2, 256);
429    EXPECT_EQ(rt, 0) << "strerror_r return error!";
430    EXPECT_STREQ(buf2, "No such file or directory") << "get strerror_r error!";
431    for (int i = 0; i < 256; i++) {
432        buf2[i] = 0;
433    }
434    rt = strerror_r(errnum, buf2, 0);
435    EXPECT_EQ(rt, ERANGE) << "strerror_r return error!";
436    EXPECT_STREQ(buf2, "") << "get strerror_r error!";
437}
438
439/**
440* @tc.number    SUB_KERNEL_SYS_UNAME_0100
441* @tc.name      test uname
442* @tc.desc      [C- SOFTWARE -0200]
443*/
444HWTEST_F(SysApiTest, testUname, Function | MediumTest | Level1)
445{
446    struct utsname sysInfo = {0};
447    int rtVal = uname(&sysInfo);
448    ASSERT_NE(-1, rtVal) << "ErrInfo: get uname error !";
449    EXPECT_STREQ(sysInfo.sysname, SYSINFO_SYSNAME) << "sysname error!";
450    LOG("    system name  : %s", sysInfo.sysname);
451    LOG("    node name    : %s", sysInfo.nodename);
452    LOG("    release      : %s", sysInfo.release);
453    LOG("    version      : %s", sysInfo.version);
454}
455
456/**
457* @tc.number    SUB_KERNEL_SYS_UNAME_0200
458* @tc.name      uname error test
459* @tc.desc      [C- SOFTWARE -0200]
460*/
461HWTEST_F(SysApiTest, testUnameNull, Function | MediumTest | Level3)
462{
463    int i = uname(nullptr);
464    ASSERT_EQ(i, -1) << "Null param return error";
465}
466
467struct Myque {
468    struct Myque *next;
469    struct Myque *prev;
470    char *name;
471};
472int CountQue(Myque *head)
473{
474    Myque *first = head;
475    int i = 0;
476    do {
477        LOG("name=%s", head->name);
478        head = head->next;
479        i++;
480    } while (head != first);
481    LOG("Myque num = %d", i);
482    return i;
483}
484/**
485* @tc.number    SUB_KERNEL_SYS_Remque_0100
486* @tc.name      test remque
487* @tc.desc      [C- SOFTWARE -0200]
488*/
489HWTEST_F(SysApiTest, testRemque, Function | MediumTest | Level2)
490{
491    struct Myque element1 = {0}, element2 = {0}, element3 = {0};
492    element1.name = (char*)"n1";
493    element2.name = (char*)"n2";
494    element3.name = (char*)"n3";
495    insque(&element1, &element1);
496    insque(&element2, &element1);
497    insque(&element3, &element2);
498    EXPECT_EQ(CountQue(&element1), 3) << "queue num error !";
499    EXPECT_TRUE(element1.next == &element2) << "queue num error !";
500
501    remque(&element2);
502    EXPECT_EQ(CountQue(&element1), 2) << "queue num error !";
503    EXPECT_TRUE(element1.next == &element3) << "queue num error !";
504
505    remque(&element3);
506    EXPECT_EQ(CountQue(&element1), 1) << "queue num error !";
507    EXPECT_TRUE(element1.next == &element1) << "queue num error !";
508
509    remque(&element1);
510    EXPECT_EQ(CountQue(&element1), 1) << "queue num error !";
511    EXPECT_TRUE(element1.next == &element1) << "queue num error !";
512}
513
514/**
515* @tc.number    SUB_KERNEL_SYS_SEED48_0100
516* @tc.name      test seed48
517* @tc.desc      [C- SOFTWARE -0200]
518*/
519HWTEST_F(SysApiTest, testSeed48, Function | MediumTest | Level2)
520{
521    unsigned short seed[3] = {1, 10, 100};
522    unsigned short *res = seed48(seed);
523    res = seed48(seed);
524    for (int i = 0; i < 3; i++) {
525        EXPECT_EQ(res[i], seed[i]) << "seed48 test error!";
526    }
527    long d;
528    for (int i = 0; i < 10; i++) {
529        seed48(seed);
530        d = lrand48();
531        EXPECT_EQ(d, 1542287255) << "seed48 test error!";
532    }
533}
534
535
536void VerrLog(const char *format, ...)
537{
538    va_list args;
539    va_start(args, format);
540    verr(0, format, args);
541    va_end(args);
542}
543void VerrxLog(const char *format, ...)
544{
545    va_list args;
546    va_start(args, format);
547    verrx(0, format, args);
548    va_end(args);
549}
550void CheckStdPrint(const char *res)
551{
552    FILE *fp1 = fopen(SYS_TEST_FILE_01, "r");
553
554    ASSERT_FALSE(fp1 == nullptr) << "fopen fail, errno = " << errno;
555    char str[100] = {0};
556    char *gStr = fgets(str, sizeof(str), fp1);
557    printf("gStr = %s\n", gStr);
558    EXPECT_STREQ(gStr, str);
559    EXPECT_STREQ(str, res);
560    fclose(fp1);
561}
562/**
563* @tc.number    SUB_KERNEL_SYS_Verr_0100
564* @tc.name      test verr
565* @tc.desc      [C- SOFTWARE -0200]
566*/
567HWTEST_F(SysApiTest, testVerr, Function | MediumTest | Level2)
568{
569    int pid = fork();
570    if (pid == 0) {
571        FILE *fp = freopen(SYS_TEST_FILE_01, "w", stderr);
572        if (fp == nullptr) {
573            LOG("freopen fail, errno = %d", errno);
574            exit(1);
575        }
576        errno = 2;
577        VerrLog("argument for %s ", "verr");
578        fclose(fp);
579        exit(0);
580    } else {
581        WaitProcExitedOK(pid);
582        CheckStdPrint("ActsSysApiTest.bin: argument for verr : No such file or directory\n");
583    }
584    remove(SYS_TEST_FILE_01);
585}
586
587/**
588* @tc.number    SUB_KERNEL_SYS_Verr_0200
589* @tc.name      test verr null
590* @tc.desc      [C- SOFTWARE -0200]
591*/
592HWTEST_F(SysApiTest, testVerrNull, Function | MediumTest | Level2)
593{
594    int pid = fork();
595    if (pid == 0) {
596        FILE *fp = freopen(SYS_TEST_FILE_01, "w", stderr);
597        if (fp == nullptr) {
598            LOG("freopen fail, errno = %d", errno);
599            exit(1);
600        }
601        errno = 2;
602        VerrLog(nullptr, "verr");
603        fclose(fp);
604        exit(0);
605    } else {
606        WaitProcExitedOK(pid);
607        CheckStdPrint("ActsSysApiTest.bin: No such file or directory\n");
608    }
609    remove(SYS_TEST_FILE_01);
610}
611
612/**
613* @tc.number    SUB_KERNEL_SYS_Verrx_0100
614* @tc.name      test verrx
615* @tc.desc      [C- SOFTWARE -0200]
616*/
617HWTEST_F(SysApiTest, testVerrx, Function | MediumTest | Level2)
618{
619    int pid = fork();
620    if (pid == 0) {
621        FILE *fp = freopen(SYS_TEST_FILE_01, "w", stderr);
622        if (fp == nullptr) {
623            LOG("freopen fail, errno = %d", errno);
624            exit(1);
625        }
626        errno = 2;
627        VerrxLog("argument for %s ", "verrx");
628        fclose(fp);
629        exit(0);
630    } else {
631        WaitProcExitedOK(pid);
632        CheckStdPrint("ActsSysApiTest.bin: argument for verrx \n");
633    }
634    remove(SYS_TEST_FILE_01);
635}
636
637/**
638* @tc.number    SUB_KERNEL_SYS_Verrx_0200
639* @tc.name      test verrx null
640* @tc.desc      [C- SOFTWARE -0200]
641*/
642HWTEST_F(SysApiTest, testVerrxNull, Function | MediumTest | Level2)
643{
644    int pid = fork();
645    if (pid == 0) {
646        FILE *fp = freopen(SYS_TEST_FILE_01, "w", stderr);
647        if (fp == nullptr) {
648            LOG("freopen fail, errno = %d", errno);
649            exit(1);
650        }
651        errno = 2;
652        VerrxLog(nullptr, "verrx");
653        fclose(fp);
654        exit(0);
655    } else {
656        WaitProcExitedOK(pid);
657        CheckStdPrint("ActsSysApiTest.bin: \n");
658    }
659    remove(SYS_TEST_FILE_01);
660}