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
compare(const void *p, const void *q)30 int 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 */
clearerr_0100(void)39 void 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 */
feof_0100(void)61 void 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 */
ferror_0100(void)83 void 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 */
fgetc_0100(void)105 void 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 */
fgets_0100(void)127 void 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 */
fprintf_0100(void)150 void 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 */
fputc_0100(void)173 void 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 */
fputs_0100(void)195 void 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 */
fread_0600(void)217 void 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 */
fscanf_0100(void)240 void 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 */
fseek_0100(void)263 void 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 */
fseeko_0100(void)286 void 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 */
ftell_0100(void)308 void 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 */
fwrite_0100(void)330 void 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 */
getc_0100(void)353 void 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 */
pclose_0100(void)375 void 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 */
rewind_0100(void)397 void 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 */
setvbuf_0100(void)419 void 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 */
wcsnrtombs_0100(void)442 void 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 */
unsetenv_0100(void)470 void 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 */
readdir_0100(void)492 void 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 */
pthread_join_0100(void)514 void 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 */
pthread_kill_0100(void)538 void 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 */
pthread_setschedparam_0100(void)562 void 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, ¶m);
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
main(int argc, char *argv[])582 int 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 }