1 /*
2 * Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved.
3 * Copyright (c) 2020-2022 Huawei Device Co., Ltd. All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without modification,
6 * are permitted provided that the following conditions are met:
7 *
8 * 1. Redistributions of source code must retain the above copyright notice, this list of
9 * conditions and the following disclaimer.
10 *
11 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
12 * of conditions and the following disclaimer in the documentation and/or other materials
13 * provided with the distribution.
14 *
15 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
16 * to endorse or promote products derived from this software without specific prior written
17 * permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
21 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
24 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
25 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
26 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
27 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
28 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
29 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 */
31
32 #ifndef __NEED_mode_t
33 #define __NEED_mode_t
34 #endif
35
36 #include "posix_fs_test.h"
37
38 /* *
39 * @tc.desc : register a test suite, this suite is used to test basic flow and interface dependency
40 * @param : subsystem name is utils
41 * @param : module name is utilsFile
42 * @param : test suit name is PosixFsFuncTestSuite
43 */
44 LITE_TEST_SUIT(Posix, PosixFs, PosixFsFuncTestSuite);
45
46 /* *
47 * @tc.setup : setup for all testcases
48 * @return : setup result, TRUE is success, FALSE is fail
49 */
PosixFsFuncTestSuiteSetUp(void)50 static BOOL PosixFsFuncTestSuiteSetUp(void)
51 {
52 return TRUE;
53 }
54
55 /* *
56 * @tc.teardown : teardown for all testcases
57 * @return : teardown result, TRUE is success, FALSE is fail
58 */
PosixFsFuncTestSuiteTearDown(void)59 static BOOL PosixFsFuncTestSuiteTearDown(void)
60 {
61 printf("+-------------------------------------------+\n");
62 return TRUE;
63 }
64
65 /* *
66 * @tc.number SUB_KERNEL_FS_FOPEN_FCLOSE_001
67 * @tc.name fopen and fclose
68 * @tc.desc [C- SOFTWARE -0200]
69 */
70 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose001, Function | MediumTest | Level1)
71 {
72 int ret = 0;
73 FILE *fp = NULL;
74 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
75 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
76
77 ret = fclose(fp);
78 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
79 return 0;
80 }
81
82 /* *
83 * @tc.number SUB_KERNEL_FS_FOPEN_FCLOSE_002
84 * @tc.name fopen and fclose
85 * @tc.desc [C- SOFTWARE -0200]
86 */
87 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose002, Function | MediumTest | Level1)
88 {
89 int ret = 0;
90 FILE *fp = NULL;
91 fp = fopen(TEST_FILE_PTAH_RIGHT, "w+");
92 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
93
94 ret = fclose(fp);
95 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
96 return 0;
97 }
98
99 /* *
100 * @tc.number SUB_KERNEL_FS_FOPEN_FCLOSE_003
101 * @tc.name fopen and fclose
102 * @tc.desc [C- SOFTWARE -0200]
103 */
104 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose003, Function | MediumTest | Level1)
105 {
106 int ret = 0;
107 FILE *fp = NULL;
108 fp = fopen(TEST_FILE_PTAH_RIGHT, "r");
109 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
110
111 ret = fclose(fp);
112 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
113 return 0;
114 }
115
116 /* *
117 * @tc.number SUB_KERNEL_FS_FOPEN_FCLOSE_004
118 * @tc.name fopen and fclose
119 * @tc.desc [C- SOFTWARE -0200]
120 */
121 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose004, Function | MediumTest | Level1)
122 {
123 int ret = 0;
124 FILE *fp = NULL;
125 fp = fopen(TEST_FILE_PTAH_RIGHT, "a");
126 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
127
128 ret = fclose(fp);
129 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
130 return 0;
131 }
132
133 /* *
134 * @tc.number SUB_KERNEL_FS_FOPEN_FCLOSE_005
135 * @tc.name fopen and fclose
136 * @tc.desc [C- SOFTWARE -0200]
137 */
138 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose005, Function | MediumTest | Level1)
139 {
140 FILE *fp = NULL;
141 fp = fopen(TEST_FILE_PTAH_RIGHT, "c");
142 ICUNIT_ASSERT_EQUAL(fp, NULL, 0);
143 return 0;
144 }
145
146 /* *
147 * @tc.number SUB_KERNEL_FS_FOPEN_FCLOSE_006
148 * @tc.name remove the path before fopen and fclose
149 * @tc.desc [C- SOFTWARE -0200]
150 */
151 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose006, Function | MediumTest | Level1)
152 {
153 int ret = 0;
154 FILE *fp = NULL;
155
156 (void)remove(TEST_FILE_PTAH_RIGHT);
157 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
158 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
159
160 ret = fclose(fp);
161 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
162 return 0;
163 }
164
165 /* *
166 * @tc.number SUB_KERNEL_FS_FOPEN_FCLOSE_007
167 * @tc.name remove the path before fopen and fclose
168 * @tc.desc [C- SOFTWARE -0200]
169 */
170 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose007, Function | MediumTest | Level1)
171 {
172 int ret = 0;
173 FILE *fp = NULL;
174
175 (void)remove(TEST_FILE_PTAH_RIGHT);
176 fp = fopen(TEST_FILE_PTAH_RIGHT, "w+");
177 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
178
179 ret = fclose(fp);
180 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
181 return 0;
182 }
183
184 /* *
185 * @tc.number SUB_KERNEL_FS_FOPEN_FCLOSE_008
186 * @tc.name remove the path before fopen and fclose
187 * @tc.desc [C- SOFTWARE -0200]
188 */
189 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose008, Function | MediumTest | Level1)
190 {
191 int ret = 0;
192 FILE *fp = NULL;
193
194 (void)remove(TEST_FILE_PTAH_RIGHT);
195 fp = fopen(TEST_FILE_PTAH_RIGHT, "a+");
196 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
197
198 ret = fclose(fp);
199 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
200 return 0;
201 }
202
203 /* *
204 * @tc.number SUB_KERNEL_FS_FOPEN_FCLOSE_009
205 * @tc.name remove the path before fopen and fclose
206 * @tc.desc [C- SOFTWARE -0200]
207 */
208 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose009, Function | MediumTest | Level1)
209 {
210 int ret = 0;
211 FILE *fp = NULL;
212
213 (void)remove(TEST_FILE_PTAH_RIGHT);
214 fp = fopen(TEST_FILE_PTAH_RIGHT, "a");
215 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
216
217 ret = fclose(fp);
218 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
219 return 0;
220 }
221
222 /* *
223 * @tc.number SUB_KERNEL_FS_FOPEN_FCLOSE_010
224 * @tc.name remove the path before fopen and fclose
225 * @tc.desc [C- SOFTWARE -0200]
226 */
227 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose010, Function | MediumTest | Level1)
228 {
229 int ret = 0;
230 FILE *fp = NULL;
231
232 (void)remove(TEST_FILE_PTAH_RIGHT);
233 fp = fopen(TEST_FILE_PTAH_RIGHT, "wr");
234 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
235
236 ret = fclose(fp);
237 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
238 return 0;
239 }
240
241 /* *
242 * @tc.number SUB_KERNEL_FS_FOPEN_FCLOSE_011
243 * @tc.name wrong input
244 * @tc.desc [C- SOFTWARE -0200]
245 */
246 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFopenFclose011, Function | MediumTest | Level1)
247 {
248 FILE *fp = NULL;
249
250 fp = fopen(TEST_FILE_PTAH_RIGHT, NULL);
251 ICUNIT_ASSERT_EQUAL(fp, NULL, 0);
252 return 0;
253 }
254
255 /* *
256 * @tc.number SUB_KERNEL_FS_FDOPEN_001
257 * @tc.name fdopen
258 * @tc.desc [C- SOFTWARE -0200]
259 */
260 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFdopen001, Function | MediumTest | Level1)
261 {
262 int ret = 0;
263 FILE *fp = NULL;
264 int fd = 0;
265
266 (void)remove(TEST_FILE_PTAH_RIGHT);
267 fd = open(TEST_FILE_PTAH_RIGHT, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
268 ICUNIT_ASSERT_WITHIN_EQUAL(fd, 0, fd, 0);
269
270 fp = fdopen(fd, "w");
271 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
272
273 ret = fclose(fp);
274 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
275 return 0;
276 }
277
278 /* *
279 * @tc.number SUB_KERNEL_FS_FDOPEN_002
280 * @tc.name fdopen
281 * @tc.desc [C- SOFTWARE -0200]
282 */
283 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFdopen002, Function | MediumTest | Level1)
284 {
285 int ret = 0;
286 FILE *fp = NULL;
287 int fd = 0;
288
289 (void)remove(TEST_FILE_PTAH_RIGHT);
290 fd = open(TEST_FILE_PTAH_RIGHT, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
291 ICUNIT_ASSERT_WITHIN_EQUAL(fd, 0, fd, -1);
292
293 fp = fdopen(fd, "w+");
294 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
295
296 ret = fclose(fp);
297 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
298 return 0;
299 }
300
301 /* *
302 * @tc.number SUB_KERNEL_FS_FDOPEN_003
303 * @tc.name fdopen
304 * @tc.desc [C- SOFTWARE -0200]
305 */
306 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFdopen003, Function | MediumTest | Level1)
307 {
308 int ret = 0;
309 FILE *fp = NULL;
310 int fd = 0;
311
312 (void)remove(TEST_FILE_PTAH_RIGHT);
313 fd = open(TEST_FILE_PTAH_RIGHT, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
314 ICUNIT_ASSERT_WITHIN_EQUAL(fd, 0, fd, -1);
315
316 fp = fdopen(fd, "a");
317 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
318
319 ret = fclose(fp);
320 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
321 return 0;
322 }
323
324 #if (LOSCFG_LIBC_MUSL == 1)
325 /* *
326 * @tc.number SUB_KERNEL_FS_FDOPEN_004
327 * @tc.name fdopen
328 * @tc.desc [C- SOFTWARE -0200]
329 */
330 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFdopen004, Function | MediumTest | Level1)
331 {
332 int ret = 0;
333 FILE *fp = NULL;
334 int fd = 0;
335
336 (void)remove(TEST_FILE_PTAH_RIGHT);
337 fd = open(TEST_FILE_PTAH_RIGHT, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
338 ICUNIT_ASSERT_WITHIN_EQUAL(fd, 0, fd, -1);
339
340 fp = fdopen(500, "w"); /* 500 is a wrong fd */
341 // in some fs, may return ok, so return null or not is pass.
342 if (NULL == fp) {
343 close (fd);
344 return 0;
345 }
346
347 fp->fd = fd;
348 ret = fclose(fp);
349 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
350 return 0;
351 }
352 #endif
353 /* *
354 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_001
355 * @tc.name ftell and fseek
356 * @tc.desc [C- SOFTWARE -0200]
357 */
358 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek001, Function | MediumTest | Level1)
359 {
360 FILE *fp = NULL;
361 long off = 0;
362
363 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
364 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
365
366 off = ftell(fp);
367 ICUNIT_GOTO_EQUAL((int)off, 0, (int)off, EXIT);
368
369 EXIT:
370 (void)fclose(fp);
371 return 0;
372 }
373
374 /* *
375 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_002
376 * @tc.name ftell and fseek
377 * @tc.desc [C- SOFTWARE -0200]
378 */
379 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek002, Function | MediumTest | Level1)
380 {
381 int ret = 0;
382 FILE *fp = NULL;
383 long off = 0;
384
385 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
386 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
387
388 ret = fseek(fp, 0L, SEEK_SET);
389 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
390
391 off = ftell(fp);
392 ICUNIT_GOTO_EQUAL((int)off, 0, (int)off, EXIT);
393
394 EXIT:
395 (void)fclose(fp);
396 return 0;
397 }
398
399 /* *
400 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_003
401 * @tc.name ftell and fseek
402 * @tc.desc [C- SOFTWARE -0200]
403 */
404 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek003, Function | MediumTest | Level1)
405 {
406 int ret = 0;
407 FILE *fp = NULL;
408 long off = 0;
409
410 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
411 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
412
413 ret = fseek(fp, TEST_SEEK_SIZE, SEEK_SET);
414 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
415
416 off = ftell(fp);
417 ICUNIT_GOTO_EQUAL((int)off, TEST_SEEK_SIZE, (int)off, EXIT);
418
419 EXIT:
420 (void)fclose(fp);
421 return 0;
422 }
423
424 /* *
425 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_004
426 * @tc.name ftell and fseek
427 * @tc.desc [C- SOFTWARE -0200]
428 */
429 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek004, Function | MediumTest | Level1)
430 {
431 int ret = 0;
432 FILE *fp = NULL;
433 long off = 0;
434
435 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
436 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
437
438 ret = fseek(fp, TEST_SEEK_SIZE, SEEK_END);
439 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
440
441 off = ftell(fp);
442 ICUNIT_GOTO_EQUAL((int)off, TEST_SEEK_SIZE, (int)off, EXIT);
443
444 EXIT:
445 (void)fclose(fp);
446 return 0;
447 }
448
449 /* *
450 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_005
451 * @tc.name ftell and fseek
452 * @tc.desc [C- SOFTWARE -0200]
453 */
454 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek005, Function | MediumTest | Level1)
455 {
456 int ret = 0;
457 FILE *fp = NULL;
458 long off = 0;
459
460 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
461 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
462
463 ret = fseek(fp, TEST_SEEK_SIZE, SEEK_CUR);
464 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
465
466 off = ftell(fp);
467 ICUNIT_GOTO_EQUAL((int)off, TEST_SEEK_SIZE, (int)off, EXIT);
468
469 EXIT:
470 (void)fclose(fp);
471 return 0;
472 }
473
474 #if (LOSCFG_SUPPORT_LITTLEFS == 1)
475 /* *
476 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_006
477 * @tc.name ftell and fseek
478 * @tc.desc [C- SOFTWARE -0200]
479 */
480 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek006, Function | MediumTest | Level1)
481 {
482 int ret = 0;
483 FILE *fp = NULL;
484 long off = 0;
485
486 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
487 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
488
489 ret = fseek(fp, -1L, SEEK_SET);
490 ICUNIT_ASSERT_EQUAL(ret, -1, ret);
491
492 off = ftell(fp);
493 ICUNIT_GOTO_EQUAL((int)off, 0, (int)off, EXIT);
494
495 EXIT:
496 (void)fclose(fp);
497 return 0;
498 }
499
500 /* *
501 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_007
502 * @tc.name ftell and fseek
503 * @tc.desc [C- SOFTWARE -0200]
504 */
505 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek007, Function | MediumTest | Level1)
506 {
507 int ret = 0;
508 FILE *fp = NULL;
509 long off = 0;
510
511 remove(TEST_FILE_PTAH_RIGHT);
512 fp = fopen(TEST_FILE_PTAH_RIGHT, "w+");
513 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
514
515 ret = fseek(fp, -1L, SEEK_CUR);
516 ICUNIT_ASSERT_EQUAL(ret, -1, ret);
517
518 off = ftell(fp);
519 ICUNIT_GOTO_EQUAL((int)off, 0, (int)off, EXIT);
520
521 EXIT:
522 (void)fclose(fp);
523 return 0;
524 }
525
526 /* *
527 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_008
528 * @tc.name ftell and fseek
529 * @tc.desc [C- SOFTWARE -0200]
530 */
531 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek008, Function | MediumTest | Level1)
532 {
533 int ret;
534 FILE *fp = NULL;
535 long off = 0;
536
537 remove(TEST_FILE_PTAH_RIGHT);
538 fp = fopen(TEST_FILE_PTAH_RIGHT, "w+");
539 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
540
541 ret = fseek(fp, -1L, SEEK_END);
542 ICUNIT_ASSERT_EQUAL(ret, -1, ret);
543
544 off = ftell(fp);
545 ICUNIT_GOTO_EQUAL((int)off, 0, (int)off, EXIT);
546
547 EXIT:
548 (void)fclose(fp);
549 return 0;
550 }
551 #endif
552
553 /* *
554 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_009
555 * @tc.name ftell and fseek
556 * @tc.desc [C- SOFTWARE -0200]
557 */
558 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek009, Function | MediumTest | Level1)
559 {
560 FILE *fp = NULL;
561 long off = 0;
562
563 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
564 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
565
566 /* wrong input, fs may return not error, no need to check return value */
567 (void)fseek(fp, TEST_SEEK_SIZE, 5); /* 5, a wrong input */
568
569 off = ftell(fp);
570 ICUNIT_GOTO_EQUAL((int)off, 0, (int)off, EXIT);
571
572 EXIT:
573 (void)fclose(fp);
574 return 0;
575 }
576
577 #if (LOSCFG_LIBC_MUSL == 1)
578 /* *
579 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_010
580 * @tc.name ftell and fseek
581 * @tc.desc [C- SOFTWARE -0200]
582 */
583 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek010, Function | MediumTest | Level1)
584 {
585 int ret = 0;
586 FILE *fp = NULL;
587 int fd;
588
589 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
590 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
591
592 fd = fp->fd;
593
594 fp->fd = 500; /* 500 is a wrong fd */
595
596 ret = fseek(fp, TEST_SEEK_SIZE, SEEK_SET);
597 ICUNIT_ASSERT_EQUAL(ret, -1, ret);
598
599 fp->fd = fd;
600
601 ret = fclose(fp);
602 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
603 return 0;
604 }
605 #endif
606 /* *
607 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_011
608 * @tc.name ftell and fseek
609 * @tc.desc [C- SOFTWARE -0200]
610 */
611 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek011, Function | MediumTest | Level1)
612 {
613 int ret = 0;
614 FILE *fp = NULL;
615 long off = 0;
616
617 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
618 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
619
620 ret = fseek(fp, TEST_SEEK_SIZE, SEEK_SET);
621 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
622
623 ret = fseek(fp, TEST_SEEK_SIZE, SEEK_CUR);
624 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
625
626 off = ftell(fp);
627 ICUNIT_GOTO_EQUAL((int)off, (TEST_SEEK_SIZE + TEST_SEEK_SIZE), (int)off, EXIT);
628
629 EXIT:
630 (void)fclose(fp);
631 return 0;
632 }
633
634
635 /* *
636 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_012
637 * @tc.name ftell and fseek
638 * @tc.desc [C- SOFTWARE -0200]
639 */
640 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek012, Function | MediumTest | Level1)
641 {
642 int ret = 0;
643 FILE *fp = NULL;
644 long off = 0;
645
646 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
647 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
648
649 ret = fseek(fp, (TEST_SEEK_SIZE + TEST_SEEK_SIZE), SEEK_SET);
650 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
651
652 ret = fseek(fp, TEST_SEEK_SIZE, SEEK_SET);
653 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
654
655 off = ftell(fp);
656 ICUNIT_GOTO_EQUAL((int)off, TEST_SEEK_SIZE, (int)off, EXIT);
657
658 EXIT:
659 (void)fclose(fp);
660 return 0;
661 }
662
663 #if (LOSCFG_SUPPORT_LITTLEFS == 1)
664 /* *
665 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_013
666 * @tc.name ftell and fseek
667 * @tc.desc [C- SOFTWARE -0200]
668 */
669 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek013, Function | MediumTest | Level1)
670 {
671 int ret = 0;
672 FILE *fp = NULL;
673 long off = 0;
674
675 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
676 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
677
678 ret = fseek(fp, TEST_SEEK_SIZE, SEEK_SET);
679 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
680 ret = fseek(fp, TEST_SEEK_SIZE, SEEK_END);
681 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
682 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
683
684 off = ftell(fp);
685 ICUNIT_GOTO_EQUAL((int)off, TEST_SEEK_SIZE, (int)off, EXIT);
686
687 EXIT:
688 (void)fclose(fp);
689 return 0;
690 }
691 #endif
692
693 /* *
694 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_014
695 * @tc.name ftell and fseek
696 * @tc.desc [C- SOFTWARE -0200]
697 */
698 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek014, Function | MediumTest | Level1)
699 {
700 int ret = 0;
701 FILE *fp = NULL;
702 long off = 0;
703
704 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
705 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
706
707 ret = fseek(fp, TEST_SEEK_SIZE, SEEK_SET);
708 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
709
710 rewind(fp);
711
712 off = ftell(fp);
713 ICUNIT_GOTO_EQUAL((int)off, 0, (int)off, EXIT);
714
715 EXIT:
716 (void)fclose(fp);
717 return 0;
718 }
719
720 /* *
721 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_015
722 * @tc.name ftell and fseek
723 * @tc.desc [C- SOFTWARE -0200]
724 */
725 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek015, Function | MediumTest | Level1)
726 {
727 int ret = 0;
728 FILE *fp = NULL;
729 long off = 0;
730
731 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
732 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
733
734 ret = fseek(fp, TEST_SEEK_SIZE, SEEK_CUR);
735 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
736
737 rewind(fp);
738
739 off = ftell(fp);
740 ICUNIT_GOTO_EQUAL((int)off, 0, (int)off, EXIT);
741
742 EXIT:
743 (void)fclose(fp);
744 return 0;
745
746 }
747
748 /* *
749 * @tc.number SUB_KERNEL_FS_FTELL_FSEEK_016
750 * @tc.name ftell and fseek
751 * @tc.desc [C- SOFTWARE -0200]
752 */
753 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFtellFseek016, Function | MediumTest | Level1)
754 {
755 int ret;
756 FILE *fp = NULL;
757 long off = 0;
758
759 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
760 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
761
762 ret = fseek(fp, TEST_SEEK_SIZE, SEEK_END);
763 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
764
765 rewind(fp);
766
767 off = ftell(fp);
768 ICUNIT_GOTO_EQUAL((int)off, 0, (int)off, EXIT);
769
770 EXIT:
771 (void)fclose(fp);
772 return 0;
773 }
774
775 /* *
776 * @tc.number SUB_KERNEL_FS_FPUTS_001
777 * @tc.name fputs
778 * @tc.desc [C- SOFTWARE -0200]
779 */
780 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFputs001, Function | MediumTest | Level1)
781 {
782 int ret;
783 FILE *fp = NULL;
784 const char chr1[TEST_BUF_SIZE] = "hello";
785
786 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
787 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
788
789 ret = fputs(chr1, fp);
790 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
791
792 ret = fclose(fp);
793 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
794 return 0;
795 }
796
797 /* *
798 * @tc.number SUB_KERNEL_FS_FPUTS_002
799 * @tc.name fputs
800 * @tc.desc [C- SOFTWARE -0200]
801 */
802 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFputs002, Function | MediumTest | Level1)
803 {
804 int ret;
805 FILE *fp = NULL;
806 const char chr1[TEST_BUF_SIZE] = "hello";
807
808 fp = fopen(TEST_FILE_PTAH_RIGHT, "a");
809 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
810
811 ret = fputs(chr1, fp);
812 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
813
814 ret = fclose(fp);
815 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
816 return 0;
817 }
818
819 /* *
820 * @tc.number SUB_KERNEL_FS_FPUTS_003
821 * @tc.name fputs
822 * @tc.desc [C- SOFTWARE -0200]
823 */
824 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFputs003, Function | MediumTest | Level1)
825 {
826 int ret;
827 FILE *fp = NULL;
828 const char chr1[TEST_BUF_SIZE] = "hello";
829
830 fp = fopen(TEST_FILE_PTAH_RIGHT, "w+");
831 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
832
833 ret = fputs(chr1, fp);
834 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
835
836 ret = fclose(fp);
837 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
838 return 0;
839 }
840
841 /* *
842 * @tc.number SUB_KERNEL_FS_FPUTS_004
843 * @tc.name fputs
844 * @tc.desc [C- SOFTWARE -0200]
845 */
846 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFputs004, Function | MediumTest | Level1)
847 {
848 int ret;
849 FILE *fp = NULL;
850 const char chr1[TEST_BUF_SIZE] = "hello";
851 char str[TEST_BUF_SIZE] = {0};
852
853 fp = fopen(TEST_FILE_PTAH_RIGHT, "w+");
854 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
855
856 ret = fputs(chr1, fp);
857 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
858
859 (void)fseek (fp, 0L, SEEK_SET);
860 ret = fread(str, strlen(chr1) + 1, 1, fp);
861 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
862
863 ret = strcmp(str, "hello");
864 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
865
866 ret = fclose(fp);
867 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
868 return 0;
869 }
870
871 /* *
872 * @tc.number SUB_KERNEL_FS_FPUTS_005
873 * @tc.name fputs
874 * @tc.desc [C- SOFTWARE -0200]
875 */
876 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFputs005, Function | MediumTest | Level1)
877 {
878 int ret;
879 FILE *fp = NULL;
880 const char chr1[TEST_BUF_SIZE] = "hello";
881 int i;
882
883 fp = fopen(TEST_FILE_PTAH_RIGHT, "w+");
884 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
885
886 for (i = 0; i < TEST_LOOPUP_TIME; i++) {
887 ret = fputs(chr1, fp);
888 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
889 }
890
891 ret = ftell(fp);
892 ICUNIT_ASSERT_EQUAL(ret, TEST_LOOPUP_TIME * strlen(chr1), ret);
893
894 ret = fclose(fp);
895 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
896 return 0;
897 }
898
899 /* *
900 * @tc.number SUB_KERNEL_FS_FWRITE_001
901 * @tc.name fread and fwrite
902 * @tc.desc [C- SOFTWARE -0200]
903 */
904 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite001, Function | MediumTest | Level1)
905 {
906 int ret;
907 FILE *fp = NULL;
908
909 const char chr1[TEST_BUF_SIZE] = "hello";
910
911 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
912 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
913
914 ret = fwrite(chr1, strlen(chr1) + 1, 1, fp);
915 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
916
917 ret = fclose(fp);
918 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
919 return 0;
920 }
921
922 /* *
923 * @tc.number SUB_KERNEL_FS_FWRITE_002
924 * @tc.name fread and fwrite
925 * @tc.desc [C- SOFTWARE -0200]
926 */
927 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite002, Function | MediumTest | Level1)
928 {
929 int ret;
930 FILE *fp = NULL;
931
932 fp = fopen(TEST_FILE_PTAH_RIGHT, "w");
933 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
934
935 ret = fwrite(0, 0, 1, fp);
936 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
937
938 ret = fclose(fp);
939 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
940 return 0;
941 }
942
943 /* *
944 * @tc.number SUB_KERNEL_FS_FWRITE_003
945 * @tc.name fread and fwrite
946 * @tc.desc [C- SOFTWARE -0200]
947 */
948 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite003, Function | MediumTest | Level1)
949 {
950 int ret;
951 FILE *fp = NULL;
952 const char chr1[TEST_BUF_SIZE] = "hello";
953
954 fp = fopen(TEST_FILE_PTAH_RIGHT, "r");
955 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
956
957 ret = fread((void *)chr1, strlen(chr1) + 1, 1, fp);
958 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
959
960 ret = fclose(fp);
961 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
962 return 0;
963 }
964
965 /* *
966 * @tc.number SUB_KERNEL_FS_FWRITE_004
967 * @tc.name fread and fwrite
968 * @tc.desc [C- SOFTWARE -0200]
969 */
970 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite004, Function | MediumTest | Level1)
971 {
972 int ret;
973 FILE *fp = NULL;
974
975 fp = fopen(TEST_FILE_PTAH_RIGHT, "r");
976 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
977
978 ret = fread(0, 0, 1, fp);
979 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
980
981 ret = fclose(fp);
982 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
983 return 0;
984 }
985
986 /* *
987 * @tc.number SUB_KERNEL_FS_FWRITE_005
988 * @tc.name fread and fwrite
989 * @tc.desc [C- SOFTWARE -0200]
990 */
991 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite005, Function | MediumTest | Level1)
992 {
993 int ret;
994 FILE *fp = NULL;
995 const char chr1[TEST_BUF_SIZE] = "hello";
996
997 fp = fopen(TEST_FILE_PTAH_RIGHT, "a");
998 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
999
1000 ret = fwrite(chr1, strlen(chr1) + 1, 1, fp);
1001 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1002
1003 ret = fclose(fp);
1004 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1005 return 0;
1006 }
1007
1008 /* *
1009 * @tc.number SUB_KERNEL_FS_FWRITE_006
1010 * @tc.name fread and fwrite
1011 * @tc.desc [C- SOFTWARE -0200]
1012 */
1013 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite006, Function | MediumTest | Level1)
1014 {
1015 int ret;
1016 FILE *fp = NULL;
1017
1018 const char chr1[TEST_BUF_SIZE] = "hello";
1019 const char chr2[TEST_BUF_SIZE] = "world";
1020
1021 char str[TEST_BUF_SIZE] = {0};
1022
1023 fp = fopen(TEST_FILE_PTAH_RIGHT, "w+");
1024 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
1025
1026 ret = fwrite(chr1, strlen(chr1), 1, fp);
1027 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1028
1029 (void)fseek(fp, 0L, SEEK_SET);
1030
1031 ret = fread(str, TEST_RW_SIZE, 1, fp);
1032 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1033
1034 ret = fwrite(chr2, strlen(chr2), 1, fp);
1035 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1036
1037 (void)fseek(fp, 0L, SEEK_SET);
1038 ret = fread(str, TEST_RW_SIZE, 1, fp);
1039 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1040
1041 ret = strcmp(str, "helloworld");
1042 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1043
1044 ret = fclose(fp);
1045 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1046 return 0;
1047
1048 }
1049
1050 /* *
1051 * @tc.number SUB_KERNEL_FS_FWRITE_007
1052 * @tc.name fread and fwrite
1053 * @tc.desc [C- SOFTWARE -0200]
1054 */
1055 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite007, Function | MediumTest | Level1)
1056 {
1057 int ret;
1058 FILE *fp = NULL;
1059
1060 const char chr1[TEST_BUF_SIZE] = "hello";
1061 const char chr2[TEST_BUF_SIZE] = "world";
1062
1063 char str[TEST_BUF_SIZE] = {0};
1064
1065 fp = fopen(TEST_FILE_PTAH_RIGHT, "w+");
1066 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
1067
1068 ret = fwrite(chr1, strlen(chr1), 1, fp);
1069 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1070
1071 ret = fwrite(chr2, strlen(chr2), 1, fp);
1072 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1073
1074 (void)fseek(fp, 0L, SEEK_SET);
1075
1076 ret = fread(str, TEST_RW_SIZE, 1, fp);
1077 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1078
1079 ret = strcmp(str, "helloworld");
1080 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1081
1082 ret = fclose(fp);
1083 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1084 return 0;
1085 }
1086
1087 /* *
1088 * @tc.number SUB_KERNEL_FS_FWRITE_008
1089 * @tc.name fread and fwrite
1090 * @tc.desc [C- SOFTWARE -0200]
1091 */
1092 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite008, Function | MediumTest | Level1)
1093 {
1094 int ret = 0;
1095 FILE *fp = NULL;
1096 int i;
1097
1098 const char chr1[TEST_BUF_SIZE] = "hello";
1099 const char chr2[TEST_BUF_SIZE] = "world";
1100
1101 char str[TEST_BUF_SIZE] = {0};
1102
1103 fp = fopen(TEST_FILE_PTAH_RIGHT, "w+");
1104 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
1105
1106 for (i = 0; i < TEST_LOOPUP_TIME; i++) {
1107 ret = fwrite(chr1, strlen(chr1), 1, fp);
1108 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1109 }
1110
1111 for (i = 0; i < TEST_LOOPUP_TIME; i++) {
1112 ret = fwrite(chr2, strlen(chr2), 1, fp);
1113 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1114 }
1115
1116 (void)fseek(fp, (TEST_LOOPUP_TIME - 2) * strlen(chr1), SEEK_SET); /* 2, means will read chr1 2times */
1117
1118 ret = fread(str, TEST_RW_SIZE, 1, fp);
1119 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1120
1121 ret = strncmp(str, "hellohelloworldworld", TEST_RW_SIZE);
1122 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1123
1124 ret = fclose(fp);
1125 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1126 return 0;
1127 }
1128
1129 /* *
1130 * @tc.number SUB_KERNEL_FS_FWRITE_009
1131 * @tc.name fread and fwrite
1132 * @tc.desc [C- SOFTWARE -0200]
1133 */
1134 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFreadFwrite009, Function | MediumTest | Level1)
1135 {
1136 int ret = 0;
1137 FILE *fp = NULL;
1138 int i;
1139
1140 const char chr1[TEST_BUF_SIZE] = "12345";
1141 char str[TEST_BUF_SIZE] = {0};
1142
1143 fp = fopen(TEST_FILE_PTAH_RIGHT, "w+");
1144 ICUNIT_ASSERT_NOT_EQUAL(fp, NULL, 0);
1145
1146 for (i = 0; i < TEST_LOOPUP_TIME; i++) {
1147 ret = fwrite(chr1, strlen(chr1), 1, fp);
1148 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1149 }
1150
1151 (void)fseek(fp, TEST_SEEK_SIZE, SEEK_SET);
1152
1153 ret = fread(str, TEST_RW_SIZE, 1, fp);
1154 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1155
1156 ret = strncmp(str, "1234512345123451234512345", TEST_RW_SIZE);
1157 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1158
1159 ret = fclose(fp);
1160 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1161 return 0;
1162 }
1163
1164 /* *
1165 * @tc.number SUB_KERNEL_FS_OPENDIR_001
1166 * @tc.name opendir
1167 * @tc.desc [C- SOFTWARE -0200]
1168 */
1169 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsOpendir001, Function | MediumTest | Level1)
1170 {
1171 DIR *dir = NULL;
1172
1173 dir = opendir(TEST_ROOT);
1174 ICUNIT_ASSERT_NOT_EQUAL(dir, NULL, 0);
1175
1176 (void)closedir(dir);
1177
1178 return 0;
1179 }
1180
1181 /* *
1182 * @tc.number SUB_KERNEL_FS_OPENDIR_002
1183 * @tc.name opendir
1184 * @tc.desc [C- SOFTWARE -0200]
1185 */
1186 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsOpendir002, Function | MediumTest | Level1)
1187 {
1188 DIR *dir = NULL;
1189
1190 remove(DIRA);
1191 dir = opendir(DIRA);
1192 ICUNIT_ASSERT_EQUAL(dir, NULL, 0);
1193 return 0;
1194 }
1195
1196 /* *
1197 * @tc.number SUB_KERNEL_FS_OPENDIR_003
1198 * @tc.name opendir
1199 * @tc.desc [C- SOFTWARE -0200]
1200 */
1201 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsOpendir003, Function | MediumTest | Level1)
1202 {
1203 DIR *dir = NULL;
1204
1205 dir = opendir(NULL);
1206 ICUNIT_ASSERT_EQUAL(dir, NULL, 0);
1207
1208 return 0;
1209 }
1210
1211 /* *
1212 * @tc.number SUB_KERNEL_FS_READDIR_001
1213 * @tc.name readdir
1214 * @tc.desc [C- SOFTWARE -0200]
1215 */
1216 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsReaddir001, Function | MediumTest | Level1)
1217 {
1218 DIR *dirp;
1219 struct dirent *dResult;
1220 int ret;
1221
1222 (void)mkdir(DIRA, TEST_MODE_NORMAL);
1223 (void)mkdir(DIRAB, TEST_MODE_NORMAL);
1224
1225 dirp = opendir(DIRA);
1226 ICUNIT_ASSERT_NOT_EQUAL(dirp, NULL, 0);
1227
1228 dResult = readdir(dirp);
1229 ICUNIT_ASSERT_NOT_EQUAL(dResult, NULL, 0);
1230
1231 ret = closedir(dirp);
1232 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1233
1234 (void)rmdir(DIRAB);
1235 (void)rmdir(DIRA);
1236 return 0;
1237 }
1238
1239 /* *
1240 * @tc.number SUB_KERNEL_FS_READDIR_002
1241 * @tc.name readdir
1242 * @tc.desc [C- SOFTWARE -0200]
1243 */
1244 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsReaddir002, Function | MediumTest | Level1)
1245 {
1246 DIR *dirp;
1247 struct dirent *dResult;
1248 off_t tellDir0;
1249 off_t tellDir1;
1250
1251 (void)mkdir(DIRA, TEST_MODE_NORMAL);
1252 (void)mkdir(DIRAB, TEST_MODE_NORMAL);
1253 (void)mkdir(DIRAC, TEST_MODE_NORMAL);
1254
1255 dirp = opendir(DIRA);
1256 ICUNIT_ASSERT_NOT_EQUAL(dirp, NULL, 0);
1257
1258 dResult = readdir(dirp);
1259 ICUNIT_ASSERT_NOT_EQUAL(dResult, NULL, 0);
1260 tellDir0 = dResult->d_off;
1261
1262 dResult = readdir(dirp);
1263 ICUNIT_ASSERT_NOT_EQUAL(dResult, NULL, 0);
1264 tellDir1 = dResult->d_off;
1265 ICUNIT_ASSERT_EQUAL(tellDir0, tellDir1, -1);
1266
1267 (void)rmdir(DIRAC);
1268 (void)rmdir(DIRAB);
1269 (void)rmdir(DIRA);
1270 return 0;
1271 }
1272
1273 /* *
1274 * @tc.number SUB_KERNEL_FS_READDIR_003
1275 * @tc.name readdir
1276 * @tc.desc [C- SOFTWARE -0200]
1277 */
1278 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsReaddir003, Function | MediumTest | Level1)
1279 {
1280 DIR *dirp;
1281 struct dirent *dResult;
1282
1283 dirp = opendir(NULL);
1284 ICUNIT_ASSERT_EQUAL(dirp, NULL, 0);
1285
1286 dResult = readdir(dirp);
1287 ICUNIT_ASSERT_EQUAL(dResult, NULL, 0);
1288
1289 return 0;
1290 }
1291
1292 /* *
1293 * @tc.number SUB_KERNEL_FS_REMOVE_001
1294 * @tc.name remove
1295 * @tc.desc [C- SOFTWARE -0200]
1296 */
1297 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRemove001, Function | MediumTest | Level1)
1298 {
1299 int fd;
1300 int ret = 0;
1301
1302 fd = open(TEST_FILE_PTAH_RIGHT, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
1303 close(fd);
1304 ret = remove(TEST_FILE_PTAH_RIGHT);
1305 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1306 return 0;
1307 }
1308
1309 /* *
1310 * @tc.number SUB_KERNEL_FS_REMOVE_002
1311 * @tc.name remove
1312 * @tc.desc [C- SOFTWARE -0200]
1313 */
1314 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRemove002, Function | MediumTest | Level1)
1315 {
1316 int ret = 0;
1317
1318 ret = mkdir(DIRA, TEST_MODE_NORMAL);
1319 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1320 ret = remove(DIRA);
1321 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1322 return 0;
1323 }
1324
1325 /* *
1326 * @tc.number SUB_KERNEL_FS_REMOVE_003
1327 * @tc.name remove
1328 * @tc.desc [C- SOFTWARE -0200]
1329 */
1330 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRemove003, Function | MediumTest | Level1)
1331 {
1332 int ret = 0;
1333 ret = remove(DIRA);
1334 ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
1335 return 0;
1336 }
1337
1338 /* *
1339 * @tc.number SUB_KERNEL_FS_REMOVE_004
1340 * @tc.name remove
1341 * @tc.desc [C- SOFTWARE -0200]
1342 */
1343 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRemove004, Function | MediumTest | Level1)
1344 {
1345 int ret = 0;
1346
1347 (void)mkdir(DIRA, TEST_MODE_NORMAL);
1348
1349 ret = mkdir(DIRAC, TEST_MODE_NORMAL);
1350 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1351
1352 ret = remove(DIRA);
1353 ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
1354
1355 ret = remove(DIRAC);
1356 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1357
1358 ret = remove(DIRA);
1359 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1360
1361 return 0;
1362 }
1363
1364 /* *
1365 * @tc.number SUB_KERNEL_FS_RMDIR_001
1366 * @tc.name rmdir
1367 * @tc.desc [C- SOFTWARE -0200]
1368 */
1369 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRmdir001, Function | MediumTest | Level1)
1370 {
1371 int ret = 0;
1372
1373 (void)mkdir(DIRA, TEST_MODE_NORMAL);
1374
1375 ret = mkdir(DIRAB, TEST_MODE_NORMAL);
1376 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1377
1378 ret = rmdir(DIRAB);
1379 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1380
1381 ret = rmdir(DIRA);
1382 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1383 return 0;
1384 }
1385
1386 /* *
1387 * @tc.number SUB_KERNEL_FS_RMDIR_002
1388 * @tc.name rmdir
1389 * @tc.desc [C- SOFTWARE -0200]
1390 */
1391 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRmdir002, Function | MediumTest | Level1)
1392 {
1393 int ret = 0;
1394
1395 (void)mkdir(DIRA, TEST_MODE_NORMAL);
1396
1397 ret = mkdir(DIRAB, TEST_MODE_NORMAL);
1398 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1399
1400 ret = mkdir(DIRAC, TEST_MODE_NORMAL);
1401 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1402
1403 ret = rmdir(DIRAB);
1404 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1405
1406 ret = rmdir(DIRAC);
1407 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1408
1409 ret = rmdir(DIRA);
1410 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1411 return 0;
1412 }
1413
1414 /* *
1415 * @tc.number SUB_KERNEL_FS_RMDIR_003
1416 * @tc.name rmdir
1417 * @tc.desc [C- SOFTWARE -0200]
1418 */
1419 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRmdir003, Function | MediumTest | Level1)
1420 {
1421 int ret;
1422
1423 (void)mkdir(DIRA, TEST_MODE_NORMAL);
1424
1425 ret = mkdir(DIRAB, TEST_MODE_NORMAL);
1426 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1427
1428 ret = rmdir(DIRA);
1429 ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
1430
1431 ret = rmdir(DIRAB);
1432 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1433
1434 ret = rmdir(DIRA);
1435 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1436 return 0;
1437 }
1438
1439 /* *
1440 * @tc.number SUB_KERNEL_FS_RMDIR_004
1441 * @tc.name rmdir
1442 * @tc.desc [C- SOFTWARE -0200]
1443 */
1444 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRmdir004, Function | MediumTest | Level1)
1445 {
1446 int ret;
1447
1448 ret = rmdir(NULL);
1449 ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
1450 return 0;
1451 }
1452
1453 /* *
1454 * @tc.number SUB_KERNEL_FS_UNLINK_001
1455 * @tc.name unlink
1456 * @tc.desc [C- SOFTWARE -0200]
1457 */
1458 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsUnlink001, Function | MediumTest | Level1)
1459 {
1460 int ret;
1461 int fd;
1462 char tmpFileName[]= FILE1;
1463
1464 fd = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
1465 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
1466
1467 (void)close(fd);
1468
1469 ret = unlink(tmpFileName);
1470 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1471 return 0;
1472 }
1473
1474 /* *
1475 * @tc.number SUB_KERNEL_FS_UNLINK_002
1476 * @tc.name unlink
1477 * @tc.desc [C- SOFTWARE -0200]
1478 */
1479 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsUnlink002, Function | MediumTest | Level1)
1480 {
1481 int ret;
1482
1483 ret = unlink(NULL);
1484 ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
1485 return 0;
1486 }
1487
1488 /* *
1489 * @tc.number SUB_KERNEL_FS_STAT_001
1490 * @tc.name stat
1491 * @tc.desc [C- SOFTWARE -0200]
1492 */
1493 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsStat001, Function | MediumTest | Level1)
1494 {
1495 struct stat buf;
1496 int fd;
1497 char tmpFileName[]= FILE1;
1498 int ret;
1499
1500 remove(FILE1);
1501 fd = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
1502 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
1503
1504 (void)close(fd);
1505
1506 ret = stat(tmpFileName, &buf);
1507 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1508 return 0;
1509 }
1510
1511 /* *
1512 * @tc.number SUB_KERNEL_FS_STAT_002
1513 * @tc.name stat
1514 * @tc.desc [C- SOFTWARE -0200]
1515 */
1516 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsStat002, Function | MediumTest | Level1)
1517 {
1518 struct stat buf;
1519 int fd = 0;
1520 char tmpFileName[]= FILE1;
1521 int ret;
1522 ssize_t size;
1523 char writeBuf[TEST_BUF_SIZE] = "write test";
1524
1525 remove(FILE1);
1526 fd = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
1527 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
1528
1529 size = write(fd, writeBuf, sizeof(writeBuf));
1530 (void)close(fd);
1531 ICUNIT_ASSERT_NOT_EQUAL(size, -1, size);
1532
1533 ret = stat(tmpFileName, &buf);
1534 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1535 ICUNIT_ASSERT_EQUAL(buf.st_size, sizeof(writeBuf), -1);
1536 return 0;
1537 }
1538
1539 /* *
1540 * @tc.number SUB_KERNEL_FS_STAT_003
1541 * @tc.name stat
1542 * @tc.desc [C- SOFTWARE -0200]
1543 */
1544 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsStat003, Function | MediumTest | Level1)
1545 {
1546 struct stat buf;
1547 int fd;
1548 char tmpFileName[]= FILE1;
1549 int ret;
1550 ssize_t size;
1551 char writeBuf[TEST_BUF_SIZE] = "write test";
1552
1553 (void)memset_s(&buf, sizeof(buf), 0, sizeof(buf));
1554 fd = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
1555 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
1556
1557 size = write(fd, writeBuf, sizeof(writeBuf));
1558 (void)close(fd);
1559 ICUNIT_ASSERT_NOT_EQUAL(size, -1, size);
1560
1561 ret = stat(tmpFileName, &buf);
1562 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1563
1564 ICUNIT_ASSERT_EQUAL(buf.st_rdev, 0, buf.st_rdev);
1565 return 0;
1566 }
1567
1568 /* *
1569 * @tc.number SUB_KERNEL_FS_RENAME_001
1570 * @tc.name rename
1571 * @tc.desc [C- SOFTWARE -0200]
1572 */
1573 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRename001, Function | MediumTest | Level1)
1574 {
1575 int ret;
1576 int fd;
1577
1578 (void)remove(FILE1);
1579 (void)remove(FILE2);
1580
1581 fd = open(FILE1, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
1582 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
1583 (void)close(fd);
1584
1585 ret = rename(FILE1, FILE2);
1586 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1587
1588 ret = remove(FILE1);
1589 ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
1590
1591 ret = remove(FILE2);
1592 ICUNIT_ASSERT_EQUAL(ret, 0, ret);
1593 return 0;
1594 }
1595
1596 /* *
1597 * @tc.number SUB_KERNEL_FS_RENAME_002
1598 * @tc.name rename
1599 * @tc.desc [C- SOFTWARE -0200]
1600 */
1601 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRename002, Function | MediumTest | Level1)
1602 {
1603 int ret;
1604 int fd;
1605
1606 (void)remove(FILE1);
1607
1608 fd = open(FILE1, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
1609 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
1610 (void)close(fd);
1611
1612 ret = rename(FILE1, NULL);
1613 ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
1614
1615 return 0;
1616 }
1617
1618 /* *
1619 * @tc.number SUB_KERNEL_FS_RENAME_003
1620 * @tc.name rename
1621 * @tc.desc [C- SOFTWARE -0200]
1622 */
1623 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsRename003, Function | MediumTest | Level1)
1624 {
1625 int ret;
1626
1627 (void)remove(FILE1);
1628
1629 ret = rename(NULL, FILE1);
1630 ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
1631
1632 return 0;
1633 }
1634
1635 /* *
1636 * @tc.number SUB_KERNEL_FS_OPEN_001
1637 * @tc.name open
1638 * @tc.desc [C- SOFTWARE -0200]
1639 */
1640 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsOpen001, Function | MediumTest | Level1)
1641 {
1642 int fd;
1643
1644 (void)remove(FILE1);
1645
1646 fd = open(FILE1, O_RDWR, TEST_MODE_NORMAL);
1647 ICUNIT_ASSERT_EQUAL(fd, -1, fd);
1648
1649 return 0;
1650 }
1651
1652 /* *
1653 * @tc.number SUB_KERNEL_FS_OPEN_002
1654 * @tc.name open
1655 * @tc.desc [C- SOFTWARE -0200]
1656 */
1657 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsOpen002, Function | MediumTest | Level1)
1658 {
1659 int fd;
1660
1661 (void)remove(FILE_IN_DIRA);
1662 (void)mkdir(DIRA, TEST_MODE_NORMAL);
1663
1664 fd = open(FILE_IN_DIRA, O_CREAT | O_RDWR, TEST_MODE_HIGH);
1665 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
1666 (void)close(fd);
1667
1668 return 0;
1669 }
1670
1671 /* *
1672 * @tc.number SUB_KERNEL_FS_OPEN_004
1673 * @tc.name open
1674 * @tc.desc [C- SOFTWARE -0200]
1675 */
1676 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsOpen003, Function | MediumTest | Level1)
1677 {
1678 int fd;
1679 ssize_t size;
1680 char writeBuf[TEST_BUF_SIZE] = "write test";
1681
1682 (void)remove(FILE1);
1683
1684 fd = open(FILE1, O_CREAT | O_RDONLY, TEST_MODE_NORMAL);
1685 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
1686 size = write(fd, writeBuf, sizeof(writeBuf));
1687 ICUNIT_ASSERT_WITHIN_EQUAL(size, size, 0, -1);
1688 (void)close(fd);
1689
1690 return 0;
1691 }
1692
1693 /* *
1694 * @tc.number SUB_KERNEL_FS_OPEN_004
1695 * @tc.name open
1696 * @tc.desc [C- SOFTWARE -0200]
1697 */
1698 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsOpen004, Function | MediumTest | Level1)
1699 {
1700 int fd;
1701
1702 (void)rmdir(DIRA);
1703 fd = open(FILE_IN_DIRA, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
1704 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
1705
1706 return 0;
1707 }
1708
1709 /* *
1710 * @tc.number SUB_KERNEL_FS_OPEN_005
1711 * @tc.name open
1712 * @tc.desc [C- SOFTWARE -0200]
1713 */
1714 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsOpen005, Function | MediumTest | Level1)
1715 {
1716 int fd;
1717
1718 (void)rmdir(DIRA);
1719 fd = open(NULL, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
1720 ICUNIT_ASSERT_EQUAL(fd, -1, fd);
1721
1722 return 0;
1723 }
1724
1725 /* *
1726 * @tc.number SUB_KERNEL_FS_OPEN_006
1727 * @tc.name open ro + ro
1728 * @tc.desc [C- SOFTWARE -0200]
1729 */
1730 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsOpen006, Function | MediumTest | Level1)
1731 {
1732 int32_t ret;
1733 const char tmpFileName[TEST_BUF_SIZE] = { FILE1 };
1734
1735 int32_t fd = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_HIGH);
1736 ICUNIT_ASSERT_NOT_EQUAL(fd, POSIX_FS_IS_ERROR, fd);
1737
1738 ret = close(fd);
1739 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
1740
1741 int32_t fd1 = open(tmpFileName, O_RDONLY, TEST_MODE_NORMAL);
1742 ICUNIT_ASSERT_NOT_EQUAL(fd, POSIX_FS_IS_ERROR, fd1);
1743
1744 int32_t fd2 = open(tmpFileName, O_RDONLY, TEST_MODE_NORMAL);
1745 ICUNIT_ASSERT_NOT_EQUAL(fd2, POSIX_FS_IS_ERROR, fd2);
1746
1747 int32_t fd3 = open(tmpFileName, O_RDONLY, TEST_MODE_NORMAL);
1748 ICUNIT_ASSERT_NOT_EQUAL(fd3, POSIX_FS_IS_ERROR, fd3);
1749
1750 ret = close(fd1);
1751 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
1752 ret = close(fd2);
1753 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
1754 ret = close(fd3);
1755 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
1756
1757 ret = unlink(tmpFileName);
1758 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
1759
1760 return POSIX_FS_NO_ERROR;
1761 }
1762
1763 /* *
1764 * @tc.number SUB_KERNEL_FS_OPEN_007
1765 * @tc.name open rw + rw
1766 * @tc.desc [C- SOFTWARE -0200]
1767 */
1768 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsOpen007, Function | MediumTest | Level1)
1769 {
1770 int32_t ret;
1771 const char tmpFileName[TEST_BUF_SIZE] = { FILE1 };
1772
1773 int32_t fd = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_HIGH);
1774 ICUNIT_ASSERT_NOT_EQUAL(fd, POSIX_FS_IS_ERROR, fd);
1775
1776 ret = close(fd);
1777 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
1778
1779 int32_t fd1 = open(tmpFileName, O_RDWR, TEST_MODE_NORMAL);
1780 ICUNIT_ASSERT_NOT_EQUAL(fd, POSIX_FS_IS_ERROR, fd1);
1781
1782 int32_t fd2 = open(tmpFileName, O_RDWR, TEST_MODE_NORMAL);
1783 ICUNIT_ASSERT_EQUAL(fd2, POSIX_FS_IS_ERROR, fd2);
1784 ICUNIT_ASSERT_EQUAL(errno, EBUSY, POSIX_FS_IS_ERROR);
1785
1786 ret = close(fd1);
1787 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
1788
1789 ret = unlink(tmpFileName);
1790 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
1791
1792 return POSIX_FS_NO_ERROR;
1793 }
1794
1795 /* *
1796 * @tc.number SUB_KERNEL_FS_OPEN_008
1797 * @tc.name open
1798 * @tc.desc [C- SOFTWARE -0200]
1799 */
1800 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsOpen008, Function | MediumTest | Level1)
1801 {
1802 int32_t ret;
1803 const char tmpFileName[TEST_BUF_SIZE] = { FILE1 };
1804
1805 int32_t fd = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_HIGH);
1806 ICUNIT_ASSERT_NOT_EQUAL(fd, POSIX_FS_IS_ERROR, fd);
1807
1808 ret = close(fd);
1809 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
1810
1811 int32_t fd1 = open(tmpFileName, O_RDONLY, TEST_MODE_NORMAL);
1812 ICUNIT_ASSERT_NOT_EQUAL(fd1, POSIX_FS_IS_ERROR, fd1);
1813
1814 int32_t fd2 = open(tmpFileName, O_RDONLY, TEST_MODE_NORMAL);
1815 ICUNIT_ASSERT_NOT_EQUAL(fd2, POSIX_FS_IS_ERROR, fd2);
1816
1817 ret = close(fd1);
1818 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
1819
1820 ret = close(fd2);
1821 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
1822
1823 fd1 = open(tmpFileName, O_RDWR, TEST_MODE_NORMAL);
1824 ICUNIT_ASSERT_NOT_EQUAL(fd1, POSIX_FS_IS_ERROR, fd1);
1825
1826 fd2 = open(tmpFileName, O_RDWR, TEST_MODE_NORMAL);
1827 ICUNIT_ASSERT_EQUAL(fd2, POSIX_FS_IS_ERROR, fd2);
1828
1829 int32_t fd3 = open(tmpFileName, O_RDWR, TEST_MODE_NORMAL);
1830 ICUNIT_ASSERT_EQUAL(fd3, POSIX_FS_IS_ERROR, fd3);
1831
1832 ret = close(fd1);
1833 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
1834
1835 ret = unlink(tmpFileName);
1836 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
1837
1838 return POSIX_FS_NO_ERROR;
1839 }
1840
1841
1842
1843 /* *
1844 * @tc.number SUB_KERNEL_FS_CLOSE_001
1845 * @tc.name close
1846 * @tc.desc [C- SOFTWARE -0200]
1847 */
1848 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsClose001, Function | MediumTest | Level1)
1849 {
1850 int ret;
1851 int fd;
1852
1853 (void)remove(FILE1);
1854
1855 fd = open(FILE1, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
1856 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
1857
1858 (void)close(fd);
1859 ret = close(fd);
1860 ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
1861 return 0;
1862
1863 }
1864
1865 /* *
1866 * extern lseek is necessary, Otherwise it will cause stacking errors
1867 */
1868 extern off_t lseek(int fd, off_t offset, int whence);
1869
1870 /* *
1871 * @tc.number SUB_KERNEL_FS_WRITE_001
1872 * @tc.name write
1873 * @tc.desc [C- SOFTWARE -0200]
1874 */
1875 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsWrite001, Function | MediumTest | Level1)
1876 {
1877 off_t reLseek;
1878 int fd = 0;
1879 char writeBuf[TEST_BUF_SIZE];
1880 int ret = 0;
1881
1882 for (int i = 0; i < TEST_BUF_SIZE; i++) {
1883 writeBuf[i] = '1';
1884 }
1885
1886 fd = open(FILE1, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
1887 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
1888
1889 ret = write(fd, writeBuf, TEST_RW_SIZE);
1890 ICUNIT_GOTO_NOT_EQUAL(ret, -1, ret, EXIT);
1891
1892 (void)lseek(fd, 0, SEEK_CUR);
1893
1894 ret = write(fd, writeBuf, TEST_RW_SIZE);
1895 ICUNIT_GOTO_NOT_EQUAL(ret, -1, ret, EXIT);
1896
1897 reLseek = lseek(fd, 0, SEEK_CUR);
1898 ICUNIT_GOTO_EQUAL((unsigned int)reLseek, (TEST_RW_SIZE + TEST_RW_SIZE), (unsigned int)reLseek, EXIT);
1899
1900 EXIT:
1901 (void)close(fd);
1902 return 0;
1903 }
1904
1905 /* *
1906 * @tc.number SUB_KERNEL_FS_WRITE_002
1907 * @tc.name write
1908 * @tc.desc [C- SOFTWARE -0200]
1909 */
1910 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsWrite002, Function | MediumTest | Level1)
1911 {
1912 int fd = 0;
1913 char writeBuf[TEST_BUF_SIZE] = "0123456789";
1914 int ret = 0;
1915 struct stat statbuf;
1916 int i;
1917
1918 remove(FILE1);
1919 fd = open(FILE1, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
1920 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
1921
1922 for (i = 0; i < TEST_LOOPUP_TIME; i++) {
1923 ret = write(fd, writeBuf, sizeof(writeBuf));
1924 ICUNIT_GOTO_NOT_EQUAL(ret, -1, ret, EXIT);
1925 }
1926 (void)close(fd);
1927
1928 ret = stat(FILE1, &statbuf);
1929 ICUNIT_ASSERT_NOT_EQUAL(ret, -1, ret);
1930 ICUNIT_ASSERT_EQUAL(statbuf.st_size, sizeof(writeBuf) * TEST_LOOPUP_TIME, -1);
1931 return 0;
1932 EXIT:
1933 (void)close(fd);
1934 return 0;
1935 }
1936
1937 /* *
1938 * @tc.number SUB_KERNEL_FS_WRITE_003
1939 * @tc.name write
1940 * @tc.desc [C- SOFTWARE -0200]
1941 */
1942 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsWrite003, Function | MediumTest | Level1)
1943 {
1944 int fd = 0;
1945 char writeBuf[TEST_BUF_SIZE];
1946 char readBuf[TEST_BUF_SIZE];
1947 int ret = 0;
1948
1949 for (int i = 0; i < TEST_BUF_SIZE; i++) {
1950 writeBuf[i] = '1';
1951 }
1952
1953 fd = open(FILE1, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
1954 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
1955
1956 ret = write(fd, writeBuf, TEST_RW_SIZE);
1957 ICUNIT_GOTO_NOT_EQUAL(ret, -1, ret, EXIT);
1958
1959 (void)lseek(fd, 0, SEEK_CUR);
1960
1961 ret = read(fd, readBuf, TEST_RW_SIZE);
1962 ICUNIT_GOTO_NOT_EQUAL(ret, -1, ret, EXIT);
1963
1964 (void)close(fd);
1965
1966 ret = strncmp(writeBuf, readBuf, TEST_RW_SIZE);
1967 ICUNIT_ASSERT_NOT_EQUAL(ret, 0, ret);
1968 return 0;
1969
1970 EXIT:
1971 (void)close(fd);
1972 return 0;
1973 }
1974
1975
1976 #if (LOSCFG_LIBC_MUSL == 1)
1977 /* *
1978 * @tc.number SUB_KERNEL_FS_DIRNAME_001
1979 * @tc.name dirname basic function test
1980 * @tc.desc [C- SOFTWARE -0200]
1981 */
1982 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsDirname001, Function | MediumTest | Level1)
1983 {
1984 char path[] = FILE0;
1985 char *workDir = dirname((char *)path);
1986 ICUNIT_ASSERT_NOT_EQUAL(workDir, NULL, 0);
1987 ICUNIT_ASSERT_STRING_EQUAL(workDir, ".", 0);
1988 return 0;
1989 }
1990
1991 /* *
1992 * @tc.number SUB_KERNEL_FS_DIRNAME_002
1993 * @tc.name dirname basic function test
1994 * @tc.desc [C- SOFTWARE -0200]
1995 */
1996 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsDirname002, Function | MediumTest | Level1)
1997 {
1998 char path[] = FILE1;
1999 char *workDir = dirname((char *)path);
2000 ICUNIT_ASSERT_NOT_EQUAL(workDir, NULL, 0);
2001 ICUNIT_ASSERT_STRING_EQUAL(workDir, TEST_ROOT, -1);
2002 return 0;
2003 }
2004
2005 /* *
2006 * @tc.number SUB_KERNEL_FS_DIRNAME_003
2007 * @tc.name dirname basic function test
2008 * @tc.desc [C- SOFTWARE -0200]
2009 */
2010 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsDirname003, Function | MediumTest | Level1)
2011 {
2012 // get dir
2013 char path[] = DIRA;
2014 char *workDir = dirname((char *)path);
2015 ICUNIT_ASSERT_NOT_EQUAL(workDir, NULL, 0);
2016 ICUNIT_ASSERT_STRING_EQUAL(workDir, TEST_ROOT, -1);
2017 return 0;
2018 }
2019
2020 /* *
2021 * @tc.number SUB_KERNEL_FS_DIRNAME_004
2022 * @tc.name dirname basic function test for special input
2023 * @tc.desc [C- SOFTWARE -0200]
2024 */
2025 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsDirname004, Function | MediumTest | Level1)
2026 {
2027 // get dir
2028 char *workDir = dirname("");
2029 ICUNIT_ASSERT_NOT_EQUAL(workDir, NULL, 0);
2030 ICUNIT_ASSERT_STRING_EQUAL(workDir ,".", 0);
2031
2032 workDir = dirname(NULL);
2033 ICUNIT_ASSERT_NOT_EQUAL(workDir, NULL, 0);
2034 ICUNIT_ASSERT_STRING_EQUAL(workDir, ".", 0);
2035
2036 workDir = dirname("/");
2037 ICUNIT_ASSERT_NOT_EQUAL(workDir, NULL, 0);
2038 ICUNIT_ASSERT_STRING_EQUAL(workDir, "/", 0);
2039
2040 workDir = dirname("..");
2041 ICUNIT_ASSERT_NOT_EQUAL(workDir, NULL, 0);
2042 ICUNIT_ASSERT_STRING_EQUAL(workDir, ".", 0);
2043
2044 workDir = dirname(".");
2045 ICUNIT_ASSERT_NOT_EQUAL(workDir, NULL, 0);
2046 ICUNIT_ASSERT_STRING_EQUAL(workDir, ".", 0);
2047 return 0;
2048 }
2049
2050 /* *
2051 * @tc.number SUB_KERNEL_FS_FCNTL_001
2052 * @tc.name fcntl
2053 * @tc.desc [C- SOFTWARE -0200]
2054 */
2055 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFcntl001, Function | MediumTest | Level1)
2056 {
2057 int fd = 0;
2058 int flags = 0;
2059 char tmpFileName[]= FILE1;
2060
2061 fd = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
2062 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
2063
2064 flags = fcntl(fd, F_GETFL);
2065 ICUNIT_TRACK_EQUAL(flags, O_CREAT | O_RDWR, 0);
2066
2067 (void)close(fd);
2068
2069 return 0;
2070 }
2071
2072 /* *
2073 * @tc.number SUB_KERNEL_FS_FCNTL_002
2074 * @tc.name fcntl
2075 * @tc.desc [C- SOFTWARE -0200]
2076 */
2077 LITE_TEST_CASE(PosixFsFuncTestSuite, testFsFcntl002, Function | MediumTest | Level1)
2078 {
2079 int fd = 0;
2080 int flags = 0;
2081 char tmpFileName[]= FILE1;
2082
2083 fd = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_NORMAL);
2084 ICUNIT_ASSERT_NOT_EQUAL(fd, -1, fd);
2085
2086 (void)fcntl(fd, F_SETFL, flags | O_APPEND);
2087 flags = fcntl(fd, F_GETFL);
2088 ICUNIT_TRACK_EQUAL(flags, O_CREAT | O_RDWR | O_APPEND, 0);
2089
2090 (void)close(fd);
2091
2092 return 0;
2093 }
2094 #endif
2095
2096 RUN_TEST_SUITE(PosixFsFuncTestSuite);
2097
PosixFsAPITest(void)2098 void PosixFsAPITest(void)
2099 {
2100 RUN_ONE_TESTCASE(testFsFopenFclose001);
2101 RUN_ONE_TESTCASE(testFsFopenFclose002);
2102 RUN_ONE_TESTCASE(testFsFopenFclose003);
2103 RUN_ONE_TESTCASE(testFsFopenFclose004);
2104 RUN_ONE_TESTCASE(testFsFopenFclose005);
2105 RUN_ONE_TESTCASE(testFsFopenFclose006);
2106 RUN_ONE_TESTCASE(testFsFopenFclose007);
2107 RUN_ONE_TESTCASE(testFsFopenFclose008);
2108 RUN_ONE_TESTCASE(testFsFopenFclose009);
2109 RUN_ONE_TESTCASE(testFsFopenFclose010);
2110 RUN_ONE_TESTCASE(testFsFopenFclose011);
2111 RUN_ONE_TESTCASE(testFsFdopen001);
2112 RUN_ONE_TESTCASE(testFsFdopen002);
2113 RUN_ONE_TESTCASE(testFsFdopen003);
2114 RUN_ONE_TESTCASE(testFsFtellFseek001);
2115 RUN_ONE_TESTCASE(testFsFtellFseek002);
2116 RUN_ONE_TESTCASE(testFsFtellFseek003);
2117 RUN_ONE_TESTCASE(testFsFtellFseek004);
2118 RUN_ONE_TESTCASE(testFsFtellFseek005);
2119 RUN_ONE_TESTCASE(testFsFtellFseek009);
2120 RUN_ONE_TESTCASE(testFsFtellFseek011);
2121 RUN_ONE_TESTCASE(testFsFtellFseek012);
2122 RUN_ONE_TESTCASE(testFsFtellFseek014);
2123 RUN_ONE_TESTCASE(testFsFtellFseek015);
2124 RUN_ONE_TESTCASE(testFsFtellFseek016);
2125 RUN_ONE_TESTCASE(testFsFputs001);
2126 RUN_ONE_TESTCASE(testFsFputs002);
2127 RUN_ONE_TESTCASE(testFsFputs003);
2128 RUN_ONE_TESTCASE(testFsFputs004);
2129 RUN_ONE_TESTCASE(testFsFputs005);
2130 RUN_ONE_TESTCASE(testFsFreadFwrite001);
2131 RUN_ONE_TESTCASE(testFsFreadFwrite002);
2132 RUN_ONE_TESTCASE(testFsFreadFwrite003);
2133 RUN_ONE_TESTCASE(testFsFreadFwrite004);
2134 RUN_ONE_TESTCASE(testFsFreadFwrite005);
2135 RUN_ONE_TESTCASE(testFsFreadFwrite006);
2136 RUN_ONE_TESTCASE(testFsFreadFwrite007);
2137 RUN_ONE_TESTCASE(testFsFreadFwrite008);
2138 RUN_ONE_TESTCASE(testFsFreadFwrite009);
2139 RUN_ONE_TESTCASE(testFsOpendir001);
2140 RUN_ONE_TESTCASE(testFsOpendir002);
2141 RUN_ONE_TESTCASE(testFsOpendir003);
2142 RUN_ONE_TESTCASE(testFsReaddir001);
2143 RUN_ONE_TESTCASE(testFsReaddir002);
2144 RUN_ONE_TESTCASE(testFsReaddir003);
2145 RUN_ONE_TESTCASE(testFsRemove001);
2146 RUN_ONE_TESTCASE(testFsRemove002);
2147 RUN_ONE_TESTCASE(testFsRemove003);
2148 RUN_ONE_TESTCASE(testFsRemove004);
2149 RUN_ONE_TESTCASE(testFsRmdir001);
2150 RUN_ONE_TESTCASE(testFsRmdir002);
2151 RUN_ONE_TESTCASE(testFsRmdir003);
2152 RUN_ONE_TESTCASE(testFsRmdir004);
2153 RUN_ONE_TESTCASE(testFsUnlink001);
2154 RUN_ONE_TESTCASE(testFsUnlink002);
2155 RUN_ONE_TESTCASE(testFsRename001);
2156 RUN_ONE_TESTCASE(testFsRename002);
2157 RUN_ONE_TESTCASE(testFsRename003);
2158 RUN_ONE_TESTCASE(testFsStat001);
2159 RUN_ONE_TESTCASE(testFsStat002);
2160 RUN_ONE_TESTCASE(testFsStat003);
2161 RUN_ONE_TESTCASE(testFsOpen001);
2162 RUN_ONE_TESTCASE(testFsOpen002);
2163 RUN_ONE_TESTCASE(testFsOpen003);
2164 RUN_ONE_TESTCASE(testFsOpen004);
2165 RUN_ONE_TESTCASE(testFsOpen005);
2166 #if (LOSCFG_SUPPORT_FATFS == 1)
2167 RUN_ONE_TESTCASE(testFsOpen006);
2168 RUN_ONE_TESTCASE(testFsOpen007);
2169 RUN_ONE_TESTCASE(testFsOpen008);
2170 #endif
2171 RUN_ONE_TESTCASE(testFsClose001);
2172 RUN_ONE_TESTCASE(testFsWrite001);
2173 RUN_ONE_TESTCASE(testFsWrite002);
2174 RUN_ONE_TESTCASE(testFsWrite003);
2175
2176 #if (LOSCFG_SUPPORT_LITTLEFS == 1)
2177 RUN_ONE_TESTCASE(testFsFtellFseek006);
2178 RUN_ONE_TESTCASE(testFsFtellFseek007);
2179 RUN_ONE_TESTCASE(testFsFtellFseek008);
2180 RUN_ONE_TESTCASE(testFsFtellFseek013);
2181 #endif
2182
2183 #if (LOSCFG_LIBC_MUSL == 1)
2184 RUN_ONE_TESTCASE(testFsFdopen004);
2185 RUN_ONE_TESTCASE(testFsFtellFseek010);
2186 RUN_ONE_TESTCASE(testFsDirname001);
2187 RUN_ONE_TESTCASE(testFsDirname002);
2188 RUN_ONE_TESTCASE(testFsDirname003);
2189 RUN_ONE_TESTCASE(testFsDirname004);
2190 RUN_ONE_TESTCASE(testFsFcntl001);
2191 RUN_ONE_TESTCASE(testFsFcntl002);
2192 #endif
2193 }
2194
PosixFsFuncTest()2195 void PosixFsFuncTest()
2196 {
2197 PosixFsAPITest();
2198 PosixFsOpenTest();
2199 PosixFsCloseTest();
2200 PosixFsOpendirTest();
2201 PosixFsClosedirTest();
2202 PosixFsReadTest();
2203 PosixFsWriteTest();
2204 PosixFsReaddirTest();
2205 PosixFsMkdirTest();
2206 PosixFsRmdirTest();
2207 PosixFsLseekTest();
2208 PosixFsUnlinkTest();
2209 PosixFsStatTest();
2210 PosixFsFstatTest();
2211 PosixFsFsyncTest();
2212 PosixFsRenameTest();
2213 #if (LOSCFG_SUPPORT_FATFS == 1)
2214 PosixFsStatfsTest();
2215 #endif
2216 PosixFsFtruncateTest();
2217 PosixFsPreadTest();
2218 PosixFsPwriteTest();
2219 PosixFsAccessTest();
2220 PosixFsFullTest();
2221 PosixFsPressureTest();
2222 return;
2223 }
2224