1/*
2 * Copyright (c) 2024 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 <errno.h>
17#include <signal.h>
18#include <pthread.h>
19#include <sys/wait.h>
20#include "stdio.h"
21#include <pthread.h>
22#include <limits.h>
23#include <locale.h>
24#include <wchar.h>
25#include <stdlib.h>
26#include <dirent.h>
27#include <utime.h>
28#include "functionalext.h"
29
30int compare(const void *p, const void *q)
31{
32    return (*(int *)p - *(int *)q);
33}
34/**
35 * @tc.name      : clearerr_0100
36 * @tc.desc      : Verify clearerr with invalid parameter
37 * @tc.level     : Level 2
38 */
39void clearerr_0100(void)
40{
41    pid_t pid = fork();
42    if (pid == -1) {
43        t_error("clearerr_0100: Error forking process");
44    } else if (pid == 0) {
45        clearerr(NULL);
46    } else {
47        int status;
48        waitpid(pid, &status, 0);
49        if (WIFSIGNALED(status)) {
50            int sig = WTERMSIG(status);
51            EXPECT_EQ("clearerr_0200", SIGABRT, sig);
52        }
53    }
54}
55
56/**
57 * @tc.name      : feof_0100
58 * @tc.desc      : Verify clearerr with invalid parameter
59 * @tc.level     : Level 2
60 */
61void feof_0100(void)
62{
63    pid_t pid = fork();
64    if (pid == -1) {
65        t_error("feof_0100: Error forking process");
66    } else if (pid == 0) {
67        feof(NULL);
68    } else {
69        int status;
70        waitpid(pid, &status, 0);
71        if (WIFSIGNALED(status)) {
72            int sig = WTERMSIG(status);
73            EXPECT_EQ("feof_0100", SIGABRT, sig);
74        }
75    }
76}
77
78/**
79 * @tc.name      : ferror_0100
80 * @tc.desc      : Verify clearerr with invalid parameter
81 * @tc.level     : Level 2
82 */
83void ferror_0100(void)
84{
85    pid_t pid = fork();
86    if (pid == -1) {
87        t_error("ferror_0100: Error forking process");
88    } else if (pid == 0) {
89        ferror(NULL);
90    } else {
91        int status;
92        waitpid(pid, &status, 0);
93        if (WIFSIGNALED(status)) {
94            int sig = WTERMSIG(status);
95            EXPECT_EQ("ferror_0100", SIGABRT, sig);
96        }
97    }
98}
99
100/**
101 * @tc.name      : fgetc_0100
102 * @tc.desc      : Verify clearerr with invalid parameter
103 * @tc.level     : Level 2
104 */
105void fgetc_0100(void)
106{
107    pid_t pid = fork();
108    if (pid == -1) {
109        t_error("fgetc_0100: Error forking process");
110    } else if (pid == 0) {
111        fgetc(NULL);
112    } else {
113        int status;
114        waitpid(pid, &status, 0);
115        if (WIFSIGNALED(status)) {
116            int sig = WTERMSIG(status);
117            EXPECT_EQ("fgetc_0100", SIGABRT, sig);
118        }
119    }
120}
121
122/**
123 * @tc.name      : fgets_0100
124 * @tc.desc      : Verify clearerr with invalid parameter
125 * @tc.level     : Level 2
126 */
127void fgets_0100(void)
128{
129    pid_t pid = fork();
130    if (pid == -1) {
131        t_error("fgets_0100: Error forking process");
132    } else if (pid == 0) {
133        char buffer[32];
134        fgets(buffer, sizeof(buffer), NULL);
135    } else {
136        int status;
137        waitpid(pid, &status, 0);
138        if (WIFSIGNALED(status)) {
139            int sig = WTERMSIG(status);
140            EXPECT_EQ("fgets_0100", SIGABRT, sig);
141        }
142    }
143}
144
145/**
146 * @tc.name      : fprintf_0100
147 * @tc.desc      : Verify clearerr with invalid parameter
148 * @tc.level     : Level 2
149 */
150void fprintf_0100(void)
151{
152    pid_t pid = fork();
153    if (pid == -1) {
154        t_error("fprintf_0100: Error forking process");
155    } else if (pid == 0) {
156        char str[] = "test";
157        fprintf(NULL, "%s", str);
158    } else {
159        int status;
160        waitpid(pid, &status, 0);
161        if (WIFSIGNALED(status)) {
162            int sig = WTERMSIG(status);
163            EXPECT_EQ("fprintf_0100", SIGABRT, sig);
164        }
165    }
166}
167
168/**
169 * @tc.name      : fputc_0100
170 * @tc.desc      : Verify clearerr with invalid parameter
171 * @tc.level     : Level 2
172 */
173void fputc_0100(void)
174{
175    pid_t pid = fork();
176    if (pid == -1) {
177        t_error("fputc_0100: Error forking process");
178    } else if (pid == 0) {
179        fputc('a', NULL);
180    } else {
181        int status;
182        waitpid(pid, &status, 0);
183        if (WIFSIGNALED(status)) {
184            int sig = WTERMSIG(status);
185            EXPECT_EQ("fputc_0100", SIGABRT, sig);
186        }
187    }
188}
189
190/**
191 * @tc.name      : fputs_0100
192 * @tc.desc      : Verify clearerr with invalid parameter
193 * @tc.level     : Level 2
194 */
195void fputs_0100(void)
196{
197    pid_t pid = fork();
198    if (pid == -1) {
199        t_error("fputs_0100: Error forking process");
200    } else if (pid == 0) {
201        fputs("", NULL);
202    } else {
203        int status;
204        waitpid(pid, &status, 0);
205        if (WIFSIGNALED(status)) {
206            int sig = WTERMSIG(status);
207            EXPECT_EQ("fputs_0100", SIGABRT, sig);
208        }
209    }
210}
211
212/**
213 * @tc.name      : fread_0600
214 * @tc.desc      : Verify clearerr with invalid parameter
215 * @tc.level     : Level 2
216 */
217void fread_0600(void)
218{
219    pid_t pid = fork();
220    if (pid == -1) {
221        t_error("fread_0600: Error forking process");
222    } else if (pid == 0) {
223        char buffer[1024];
224        fread(buffer, sizeof(char), sizeof(buffer), NULL);
225    } else {
226        int status;
227        waitpid(pid, &status, 0);
228        if (WIFSIGNALED(status)) {
229            int sig = WTERMSIG(status);
230            EXPECT_EQ("fread_0600", SIGABRT, sig);
231        }
232    }
233}
234
235/**
236 * @tc.name      : fscanf_0100
237 * @tc.desc      : Verify clearerr with invalid parameter
238 * @tc.level     : Level 2
239 */
240void fscanf_0100(void)
241{
242    pid_t pid = fork();
243    if (pid == -1) {
244        t_error("fscanf_0100: Error forking process");
245    } else if (pid == 0) {
246        char buffer[1024];
247        fscanf(NULL, "%s", buffer);
248    } else {
249        int status;
250        waitpid(pid, &status, 0);
251        if (WIFSIGNALED(status)) {
252            int sig = WTERMSIG(status);
253            EXPECT_EQ("fscanf_0100", SIGABRT, sig);
254        }
255    }
256}
257
258/**
259 * @tc.name      : fseek_0100
260 * @tc.desc      : Verify clearerr with invalid parameter
261 * @tc.level     : Level 2
262 */
263void fseek_0100(void)
264{
265    pid_t pid = fork();
266    if (pid == -1) {
267        t_error("fseek_0100: Error forking process");
268    } else if (pid == 0) {
269        char buffer[1024];
270        fseek(NULL, 0L, SEEK_END);
271    } else {
272        int status;
273        waitpid(pid, &status, 0);
274        if (WIFSIGNALED(status)) {
275            int sig = WTERMSIG(status);
276            EXPECT_EQ("fseek_0100", SIGABRT, sig);
277        }
278    }
279}
280
281/**
282 * @tc.name      : fseeko_0100
283 * @tc.desc      : Verify clearerr with invalid parameter
284 * @tc.level     : Level 2
285 */
286void fseeko_0100(void)
287{
288    pid_t pid = fork();
289    if (pid == -1) {
290        t_error("fseeko_0100: Error forking process");
291    } else if (pid == 0) {
292        fseeko(NULL, 0L, SEEK_END);
293    } else {
294        int status;
295        waitpid(pid, &status, 0);
296        if (WIFSIGNALED(status)) {
297            int sig = WTERMSIG(status);
298            EXPECT_EQ("fseeko_0100", SIGABRT, sig);
299        }
300    }
301}
302
303/**
304 * @tc.name      : ftell_0100
305 * @tc.desc      : Verify clearerr with invalid parameter
306 * @tc.level     : Level 2
307 */
308void ftell_0100(void)
309{
310    pid_t pid = fork();
311    if (pid == -1) {
312        t_error("ftell_0100: Error forking process");
313    } else if (pid == 0) {
314        ftell(NULL);
315    } else {
316        int status;
317        waitpid(pid, &status, 0);
318        if (WIFSIGNALED(status)) {
319            int sig = WTERMSIG(status);
320            EXPECT_EQ("ftell_0100", SIGABRT, sig);
321        }
322    }
323}
324
325/**
326 * @tc.name      : fwrite_0100
327 * @tc.desc      : Verify clearerr with invalid parameter
328 * @tc.level     : Level 2
329 */
330void fwrite_0100(void)
331{
332    pid_t pid = fork();
333    if (pid == -1) {
334        t_error("fwrite_0100: Error forking process");
335    } else if (pid == 0) {
336        char buf[] = "this is test";
337        fwrite(buf, sizeof(char), strlen(buf), NULL);
338    } else {
339        int status;
340        waitpid(pid, &status, 0);
341        if (WIFSIGNALED(status)) {
342            int sig = WTERMSIG(status);
343            EXPECT_EQ("fwrite_0100", SIGABRT, sig);
344        }
345    }
346}
347
348/**
349 * @tc.name      : getc_0100
350 * @tc.desc      : Verify clearerr with invalid parameter
351 * @tc.level     : Level 2
352 */
353void getc_0100(void)
354{
355    pid_t pid = fork();
356    if (pid == -1) {
357        t_error("getc_0100: Error forking process");
358    } else if (pid == 0) {
359        getc(NULL);
360    } else {
361        int status;
362        waitpid(pid, &status, 0);
363        if (WIFSIGNALED(status)) {
364            int sig = WTERMSIG(status);
365            EXPECT_EQ("getc_0100", SIGABRT, sig);
366        }
367    }
368}
369
370/**
371 * @tc.name      : pclose_0100
372 * @tc.desc      : Verify clearerr with invalid parameter
373 * @tc.level     : Level 2
374 */
375void pclose_0100(void)
376{
377    pid_t pid = fork();
378    if (pid == -1) {
379        t_error("pclose_0100: Error forking process");
380    } else if (pid == 0) {
381        pclose(NULL);
382    } else {
383        int status;
384        waitpid(pid, &status, 0);
385        if (WIFSIGNALED(status)) {
386            int sig = WTERMSIG(status);
387            EXPECT_EQ("pclose_0100", SIGABRT, sig);
388        }
389    }
390}
391
392/**
393 * @tc.name      : rewind_0100
394 * @tc.desc      : Verify clearerr with invalid parameter
395 * @tc.level     : Level 2
396 */
397void rewind_0100(void)
398{
399    pid_t pid = fork();
400    if (pid == -1) {
401        t_error("rewind_0100: Error forking process");
402    } else if (pid == 0) {
403        rewind(NULL);
404    } else {
405        int status;
406        waitpid(pid, &status, 0);
407        if (WIFSIGNALED(status)) {
408            int sig = WTERMSIG(status);
409            EXPECT_EQ("rewind_0100", SIGABRT, sig);
410        }
411    }
412}
413
414/**
415 * @tc.name      : setvbuf_0100
416 * @tc.desc      : Verify clearerr with invalid parameter
417 * @tc.level     : Level 2
418 */
419void setvbuf_0100(void)
420{
421    pid_t pid = fork();
422    if (pid == -1) {
423        t_error("setvbuf_0100: Error forking process");
424    } else if (pid == 0) {
425        char buff[1024] = {0};
426        setvbuf(NULL, buff, -1, 1024);
427    } else {
428        int status;
429        waitpid(pid, &status, 0);
430        if (WIFSIGNALED(status)) {
431            int sig = WTERMSIG(status);
432            EXPECT_EQ("setvbuf_0100", SIGABRT, sig);
433        }
434    }
435}
436
437/**
438 * @tc.name      : wcsnrtombs_0100
439 * @tc.desc      : Verify clearerr with invalid parameter
440 * @tc.level     : Level 2
441 */
442void wcsnrtombs_0100(void)
443{
444    pid_t pid = fork();
445    if (pid == -1) {
446        t_error("wcsnrtombs_0100: Error forking process");
447    } else if (pid == 0) {
448        char buffer[32];
449        mbstate_t mbs;
450        size_t wn = 4;
451        size_t n = 4;
452        mbrlen(NULL, 0, &mbs);
453        memset(buffer, 0, sizeof(buffer));
454        wcsnrtombs(buffer, NULL, wn, n, &mbs);
455    } else {
456        int status;
457        waitpid(pid, &status, 0);
458        if (WIFSIGNALED(status)) {
459            int sig = WTERMSIG(status);
460            EXPECT_EQ("wcsnrtombs_0100", SIGABRT, sig);
461        }
462    }
463}
464
465/**
466 * @tc.name      : unsetenv_0100
467 * @tc.desc      : Verify clearerr with invalid parameter
468 * @tc.level     : Level 2
469 */
470void unsetenv_0100(void)
471{
472    pid_t pid = fork();
473    if (pid == -1) {
474        t_error("unsetenv_0100: Error forking process");
475    } else if (pid == 0) {
476        unsetenv(NULL);
477    } else {
478        int status;
479        waitpid(pid, &status, 0);
480        if (WIFSIGNALED(status)) {
481            int sig = WTERMSIG(status);
482            EXPECT_EQ("unsetenv_0100", SIGABRT, sig);
483        }
484    }
485}
486
487/**
488 * @tc.name      : readdir_0100
489 * @tc.desc      : Verify clearerr with invalid parameter
490 * @tc.level     : Level 2
491 */
492void readdir_0100(void)
493{
494    pid_t pid = fork();
495    if (pid == -1) {
496        t_error("readdir_0100: Error forking process");
497    } else if (pid == 0) {
498        readdir(NULL);
499    } else {
500        int status;
501        waitpid(pid, &status, 0);
502        if (WIFSIGNALED(status)) {
503            int sig = WTERMSIG(status);
504            EXPECT_EQ("readdir_0100", SIGABRT, sig);
505        }
506    }
507}
508
509/**
510 * @tc.name      : pthread_join_0100
511 * @tc.desc      : Verify clearerr with invalid parameter
512 * @tc.level     : Level 2
513 */
514void pthread_join_0100(void)
515{
516    pid_t pid = fork();
517    if (pid == -1) {
518        t_error("pthread_join_0100: Error forking process");
519    } else if (pid == 0) {
520        pthread_t invalid_thread = 0;
521        void *res;
522        pthread_join(invalid_thread, &res);
523    } else {
524        int status;
525        waitpid(pid, &status, 0);
526        if (WIFSIGNALED(status)) {
527            int sig = WTERMSIG(status);
528            EXPECT_EQ("pthread_join_0100", SIGABRT, sig);
529        }
530    }
531}
532
533/**
534 * @tc.name      : pthread_kill_0100
535 * @tc.desc      : Verify clearerr with invalid parameter
536 * @tc.level     : Level 2
537 */
538void pthread_kill_0100(void)
539{
540    pid_t pid = fork();
541    if (pid == -1) {
542        t_error("pthread_kill_0100: Error forking process");
543    } else if (pid == 0) {
544        pthread_t invalid_thread = 0;
545        int valid_sig = SIGTERM;
546        pthread_kill(invalid_thread, valid_sig);
547    } else {
548        int status;
549        waitpid(pid, &status, 0);
550        if (WIFSIGNALED(status)) {
551            int sig = WTERMSIG(status);
552            EXPECT_EQ("pthread_kill_0100", SIGABRT, sig);
553        }
554    }
555}
556
557/**
558 * @tc.name      : pthread_setschedparam_0100
559 * @tc.desc      : Verify clearerr with invalid parameter
560 * @tc.level     : Level 2
561 */
562void pthread_setschedparam_0100(void)
563{
564    pid_t pid = fork();
565    if (pid == -1) {
566        t_error("pthread_setschedparam_0100: Error forking process");
567    } else if (pid == 0) {
568        pthread_t invalid_thread = 0;
569        struct sched_param param;
570        param.sched_priority = 1;
571        pthread_setschedparam(invalid_thread, SCHED_FIFO, &param);
572    } else {
573        int status;
574        waitpid(pid, &status, 0);
575        if (WIFSIGNALED(status)) {
576            int sig = WTERMSIG(status);
577            EXPECT_EQ("pthread_setschedparam_0100", SIGABRT, sig);
578        }
579    }
580}
581
582int main(int argc, char *argv[])
583{
584    clearerr_0100();
585    feof_0100();
586    ferror_0100();
587    fgetc_0100();
588    fgets_0100();
589    fprintf_0100();
590    fputc_0100();
591    fputs_0100();
592    fread_0600();
593    fscanf_0100();
594    fseek_0100();
595    fseeko_0100();
596    ftell_0100();
597    fwrite_0100();
598    getc_0100();
599    pclose_0100();
600    rewind_0100();
601    setvbuf_0100();
602
603    wcsnrtombs_0100();
604    unsetenv_0100();
605    readdir_0100();
606    pthread_join_0100();
607    pthread_kill_0100();
608    pthread_setschedparam_0100();
609    return t_status;
610}