1 /*
2 * Copyright (c) 2023-2023 Huawei Device Co., Ltd. All rights reserved.
3 *
4 * Redistribution and use in source and binary forms, with or without modification,
5 * are permitted provided that the following conditions are met:
6 *
7 * 1. Redistributions of source code must retain the above copyright notice, this list of
8 * conditions and the following disclaimer.
9 *
10 * 2. Redistributions in binary form must reproduce the above copyright notice, this list
11 * of conditions and the following disclaimer in the documentation and/or other materials
12 * provided with the distribution.
13 *
14 * 3. Neither the name of the copyright holder nor the names of its contributors may be used
15 * to endorse or promote products derived from this software without specific prior written
16 * permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
20 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
21 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
22 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
23 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
24 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
25 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
26 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
27 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
28 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 #include "posix_fs_test.h"
32
33 #define TEST_OPEN_DIR_NUM 16
34 #define TEST_OPEN_FILE_NUM 16
35 #define WRITE_BUF_SIZE 128
36 #define READ_WRITE_BUF_SIZE 1024
37 #define TEMP_DIRE TEST_ROOT"/e"
38 #define TEMP_DIRE_FILE TEST_ROOT"/e/eFile"
39 #define TEMP_DIRF TEST_ROOT"/f"
40 #define TEMP_DIRF_DIR TEST_ROOT"/f/fDir"
41 #define TEST_DIRG TEST_ROOT"/g"
42
43 /* *
44 * @tc.number SUB_KERNEL_FS_FULL001
45 * @tc.name open close unlink
46 * @tc.desc [C- SOFTWARE -0200]
47 */
48 LITE_TEST_CASE(PosixFsFuncTestSuite, TestFsFull001, Function | MediumTest | Level1)
49 {
50 int32_t ret;
51 int32_t fd1 = -1;
52 int32_t fd2 = -1;
53 const char tmpFileName[TEST_BUF_SIZE] = { FILE1 };
54
55 fd1 = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_HIGH);
56 ICUNIT_ASSERT_NOT_EQUAL(fd1, POSIX_FS_IS_ERROR, fd1);
57
58 #if (LOSCFG_SUPPORT_FATFS == 1)
59 fd2 = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_HIGH);
60 ICUNIT_ASSERT_EQUAL(fd2, POSIX_FS_IS_ERROR, fd2);
61 #endif
62
63 ret = close(fd1);
64 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
65
66 fd2 = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_HIGH);
67 ICUNIT_ASSERT_NOT_EQUAL(fd2, POSIX_FS_IS_ERROR, fd2);
68
69 ret = close(fd2);
70 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
71
72 ret = unlink(tmpFileName);
73 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
74
75 return POSIX_FS_NO_ERROR;
76 }
77
78 /* *
79 * @tc.number SUB_KERNEL_FS_FULL002
80 * @tc.name open write read lseek read close unlink
81 * @tc.desc [C- SOFTWARE -0200]
82 */
83 LITE_TEST_CASE(PosixFsFuncTestSuite, TestFsFull002, Function | MediumTest | Level1)
84 {
85 off_t off;
86 int32_t ret;
87 int32_t fd = -1;
88 const char tmpFileName[TEST_BUF_SIZE] = { FILE1 };
89 char *writeBuf = (char *)malloc(READ_WRITE_BUF_SIZE * sizeof(char));
90 char *readBuf = (char *)malloc(READ_WRITE_BUF_SIZE * sizeof(char));
91
92 (void)memset_s(writeBuf, READ_WRITE_BUF_SIZE, 'w', READ_WRITE_BUF_SIZE);
93 (void)memset_s(readBuf, READ_WRITE_BUF_SIZE, 'r', READ_WRITE_BUF_SIZE);
94
95 fd = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_HIGH);
96 ICUNIT_ASSERT_NOT_EQUAL(fd, POSIX_FS_IS_ERROR, fd);
97
98 ret = write(fd, writeBuf, READ_WRITE_BUF_SIZE / 2); /* 2, number of writes */
99 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
100 ret = write(fd, writeBuf, READ_WRITE_BUF_SIZE / 2); /* 2, number of writes */
101 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
102
103 off = lseek(fd, 0, SEEK_SET); /* 0, offset distance */
104 ICUNIT_GOTO_NOT_EQUAL(off, POSIX_FS_IS_ERROR, off, EXIT);
105
106 for (int32_t i = 0; i < 8; i++) { /* 8, number of reads */
107 ret = read(fd, readBuf + i * 128, 128); /* 128, 128, length per read */
108 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
109 }
110
111 for (int32_t j = 0; j < READ_WRITE_BUF_SIZE; j++) {
112 ICUNIT_GOTO_EQUAL(writeBuf[j], readBuf[j], POSIX_FS_IS_ERROR, EXIT);
113 }
114
115 EXIT:
116 ret = close(fd);
117 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
118
119 ret = unlink(tmpFileName);
120 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
121
122 return POSIX_FS_NO_ERROR;
123 }
124
125 /* *
126 * @tc.number SUB_KERNEL_FS_FULL003
127 * @tc.name mkdir opendir closedir rmdir fstat
128 * @tc.desc [C- SOFTWARE -0200]
129 */
130 LITE_TEST_CASE(PosixFsFuncTestSuite, TestFsFull003, Function | MediumTest | Level1)
131 {
132 int res;
133 DIR *dir = NULL;
134 int32_t index = 0;
135 bool flag = true;
136 struct dirent *dirmsg = NULL;
137 struct stat buf = { 0 };
138 int32_t i, fd[TEST_OPEN_FILE_NUM];
139 char tmpFileName[TEST_BUF_SIZE] = { 0 };
140 char fileName[TEST_BUF_SIZE] = { 0 };
141
142 int32_t ret = mkdir(TEMP_DIRE, TEST_MODE_NORMAL);
143 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
144 for (i = 0; i < TEST_OPEN_FILE_NUM; i++) {
145 res = sprintf_s(tmpFileName, TEST_BUF_SIZE, "%s%02d", TEMP_DIRE_FILE, i);
146 if (res < 0) {
147 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
148 goto EXIT1;
149 }
150 fd[i] = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_HIGH);
151 flag = fd[i] == -1 ? false : true;
152 ICUNIT_GOTO_NOT_EQUAL(fd[i], POSIX_FS_IS_ERROR, fd[i], EXIT1);
153 }
154 dir = opendir(TEMP_DIRE);
155 flag = dir == NULL ? false : true;
156 ICUNIT_GOTO_NOT_EQUAL(dir, NULL, POSIX_FS_IS_ERROR, EXIT1);
157 while ((dirmsg = readdir(dir)) != NULL) {
158 res = sprintf_s(fileName, TEST_BUF_SIZE, "%s%02d", "eFile", index);
159 if (res < 0) {
160 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
161 goto EXIT1;
162 }
163 ret = strcmp(dirmsg->d_name, fileName);
164 ICUNIT_GOTO_EQUAL(ret, POSIX_FS_NO_ERROR, ret, EXIT1);
165 ret = fstat(fd[index], &buf);
166 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT1);
167 ICUNIT_GOTO_EQUAL(buf.st_mode & S_IFMT, S_IFREG, POSIX_FS_IS_ERROR, EXIT1);
168 index++;
169 }
170 ICUNIT_GOTO_EQUAL(index, TEST_OPEN_FILE_NUM, POSIX_FS_IS_ERROR, EXIT1);
171 EXIT1:
172 for (int32_t j = 0; j < i; j++) {
173 res = sprintf_s(tmpFileName, TEST_BUF_SIZE, "%s%02d", TEMP_DIRE_FILE, j);
174 if (res < 0) {
175 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
176 return POSIX_FS_IS_ERROR;
177 }
178 ret = close(fd[j]);
179 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
180 ret = unlink(tmpFileName);
181 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
182 }
183 if (flag == false) {
184 goto EXIT;
185 }
186 ret = closedir(dir);
187 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
188 EXIT:
189 ret = rmdir(TEMP_DIRE);
190 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
191 return POSIX_FS_NO_ERROR;
192 }
193
194 /* *
195 * @tc.number SUB_KERNEL_FS_FULL004
196 * @tc.name mkdir readdir opendir stat closedir rmdir
197 * @tc.desc [C- SOFTWARE -0200]
198 */
199 LITE_TEST_CASE(PosixFsFuncTestSuite, TestFsFull004, Function | MediumTest | Level1)
200 {
201 int res;
202 int32_t i;
203 int32_t index = 0;
204 DIR *dir = NULL;
205 struct dirent *dirmsg = NULL;
206 struct stat buf = { 0 };
207 char dirName[TEST_BUF_SIZE] = { 0 };
208 char tmpDirName[TEST_BUF_SIZE] = { 0 };
209
210 int32_t ret = mkdir(TEMP_DIRF, TEST_MODE_HIGH);
211 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
212 for (i = 0; i < TEST_OPEN_DIR_NUM; i++) {
213 res = sprintf_s(tmpDirName, TEST_BUF_SIZE, "%s%02d", TEMP_DIRF_DIR, i);
214 if (res < 0) {
215 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
216 goto EXIT;
217 }
218 ret = mkdir(tmpDirName, TEST_MODE_HIGH);
219 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
220 }
221
222 dir = opendir(TEMP_DIRF);
223 ICUNIT_GOTO_NOT_EQUAL(dir, NULL, POSIX_FS_IS_ERROR, EXIT1);
224 while ((dirmsg = readdir(dir)) != NULL) {
225 res = sprintf_s(dirName, TEST_BUF_SIZE, "%s%02d", "fDir", index);
226 if (res < 0) {
227 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
228 goto EXIT1;
229 }
230 ret = strcmp(dirmsg->d_name, dirName);
231 ICUNIT_GOTO_EQUAL(ret, POSIX_FS_NO_ERROR, ret, EXIT1);
232 res = sprintf_s(tmpDirName, TEST_BUF_SIZE, "%s%02d", TEMP_DIRF_DIR, index);
233 if (res < 0) {
234 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
235 goto EXIT1;
236 }
237 ret = stat(tmpDirName, &buf);
238 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT1);
239 ICUNIT_GOTO_EQUAL(buf.st_mode & S_IFMT, S_IFDIR, POSIX_FS_IS_ERROR, EXIT1);
240 index++;
241 }
242 ICUNIT_GOTO_EQUAL(index, TEST_OPEN_DIR_NUM, POSIX_FS_IS_ERROR, EXIT1);
243 EXIT1:
244 ret = closedir(dir);
245 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
246 EXIT:
247 for (int32_t j = 0; j < i; j++) {
248 res = sprintf_s(tmpDirName, TEST_BUF_SIZE, "%s%02d", TEMP_DIRF_DIR, j);
249 if (res < 0) {
250 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
251 return POSIX_FS_IS_ERROR;
252 }
253 ret = rmdir(tmpDirName);
254 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
255 }
256 ret = rmdir(TEMP_DIRF);
257 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
258 return POSIX_FS_NO_ERROR;
259 }
260
261 /* *
262 * @tc.number SUB_KERNEL_FS_FULL005
263 * @tc.name read write lseek close unlink
264 * @tc.desc [C- SOFTWARE -0200]
265 */
266 LITE_TEST_CASE(PosixFsFuncTestSuite, TestFsFull005, Function | MediumTest | Level1)
267 {
268 off_t off;
269 int32_t ret;
270 int32_t fd = -1;
271 bool flag = true;
272 char readBuf = 'r';
273 const char tmpFileName[TEST_BUF_SIZE] = { FILE1 };
274 char *writeBuf = (char*)malloc(WRITE_BUF_SIZE * sizeof(char));
275
276 (void)memset_s(writeBuf, WRITE_BUF_SIZE, 'w', WRITE_BUF_SIZE);
277
278 fd = open(tmpFileName, O_CREAT | O_RDWR);
279 ICUNIT_ASSERT_NOT_EQUAL(fd, POSIX_FS_IS_ERROR, fd);
280
281 ret = write(fd, writeBuf, WRITE_BUF_SIZE);
282 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
283
284 off = lseek(fd, 0, SEEK_SET);
285 ICUNIT_GOTO_NOT_EQUAL(off, POSIX_FS_IS_ERROR, off, EXIT);
286
287 for (int i = 1; i <= TEST_OPEN_FILE_NUM; i++) {
288 ret = read(fd, &readBuf, 1);
289 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
290 if (readBuf != 'w') {
291 flag = false;
292 break;
293 }
294 readBuf = 'r';
295 off = lseek(fd, 7, SEEK_CUR); /* 7, offset distance */
296 ICUNIT_GOTO_NOT_EQUAL(off, POSIX_FS_IS_ERROR, off, EXIT);
297 }
298
299 EXIT:
300 ret = close(fd);
301 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
302
303 ret = unlink(tmpFileName);
304 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
305
306 return POSIX_FS_NO_ERROR;
307 }
308
309 /* *
310 * @tc.number SUB_KERNEL_FS_FULL006
311 * @tc.name open fstat close unlink
312 * @tc.desc [C- SOFTWARE -0200]
313 */
314 LITE_TEST_CASE(PosixFsFuncTestSuite, TestFsFull006, Function | MediumTest | Level1)
315 {
316 int32_t ret;
317 struct stat buf = { 0 };
318 const char tmpFileName[TEST_BUF_SIZE] = { FILE1 };
319
320 int32_t fd = open(tmpFileName, O_CREAT | O_RDWR);
321 ICUNIT_ASSERT_NOT_EQUAL(fd, POSIX_FS_IS_ERROR, fd);
322
323 ret = fstat(fd, &buf);
324 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
325 ICUNIT_GOTO_EQUAL(buf.st_mode & S_IFMT, S_IFREG, POSIX_FS_IS_ERROR, EXIT);
326
327 EXIT:
328 ret = close(fd);
329 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
330
331 ret = unlink(tmpFileName);
332 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
333
334 return POSIX_FS_NO_ERROR;
335 }
336
337 /* *
338 * @tc.number SUB_KERNEL_FS_FULL007
339 * @tc.name open stat close unlink
340 * @tc.desc [C- SOFTWARE -0200]
341 */
342 LITE_TEST_CASE(PosixFsFuncTestSuite, TestFsFull007, Function | MediumTest | Level1)
343 {
344 int32_t ret;
345 struct stat buf = { 0 };
346 const char tmpFileName[TEST_BUF_SIZE] = { FILE1 };
347
348 int32_t fd = open(tmpFileName, O_CREAT | O_RDWR);
349 ICUNIT_ASSERT_NOT_EQUAL(fd, POSIX_FS_IS_ERROR, fd);
350
351 ret = stat(tmpFileName, &buf);
352 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
353 ICUNIT_GOTO_EQUAL(buf.st_mode & S_IFMT, S_IFREG, POSIX_FS_IS_ERROR, EXIT);
354
355 EXIT:
356 ret = close(fd);
357 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
358
359 ret = unlink(tmpFileName);
360 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
361
362 ret = stat(tmpFileName, &buf);
363 ICUNIT_ASSERT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
364
365 return POSIX_FS_NO_ERROR;
366 }
367
368 /* *
369 * @tc.number SUB_KERNEL_FS_FULL008
370 * @tc.name mkdir stat rmdir
371 * @tc.desc [C- SOFTWARE -0200]
372 */
373 LITE_TEST_CASE(PosixFsFuncTestSuite, TestFsFull008, Function | MediumTest | Level1)
374 {
375 char dirName[TEST_BUF_SIZE] = { TEST_DIRG };
376 struct stat buf = { 0 };
377
378 int32_t ret = mkdir(dirName, TEST_MODE_HIGH);
379 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
380
381 ret = stat(dirName, &buf);
382 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT1);
383 ICUNIT_GOTO_EQUAL(buf.st_mode & S_IFMT, S_IFDIR, POSIX_FS_IS_ERROR, EXIT1);
384
385 ret = rmdir(dirName);
386 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT1);
387
388 ret = stat(dirName, &buf);
389 ICUNIT_GOTO_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
390
391 return POSIX_FS_NO_ERROR;
392
393 EXIT1:
394 ret = rmdir(dirName);
395 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
396 EXIT:
397 return POSIX_FS_IS_ERROR;
398 }
399
400 /* *
401 * @tc.number SUB_KERNEL_FS_FULL009
402 * @tc.name open close stat rename unlink
403 * @tc.desc [C- SOFTWARE -0200]
404 */
405 LITE_TEST_CASE(PosixFsFuncTestSuite, TestFsFull009, Function | MediumTest | Level1)
406 {
407 int32_t ret;
408 struct stat buf = { 0 };
409 char tmpFileName1[TEST_BUF_SIZE] = { FILE5 };
410 char tmpFileName2[TEST_BUF_SIZE] = { FILE6 };
411
412 int32_t fd = open(tmpFileName1, O_CREAT | O_RDWR, TEST_MODE_HIGH);
413 ICUNIT_ASSERT_NOT_EQUAL(fd, POSIX_FS_IS_ERROR, fd);
414
415 ret = close(fd);
416 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT1);
417
418 ret = stat(tmpFileName1, &buf);
419 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
420 ICUNIT_GOTO_EQUAL(buf.st_mode & S_IFMT, S_IFREG, POSIX_FS_IS_ERROR, EXIT);
421
422 ret = rename(tmpFileName1, tmpFileName2);
423 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
424
425 ret = stat(tmpFileName1, &buf);
426 ICUNIT_GOTO_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
427
428 ret = stat(tmpFileName2, &buf);
429 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
430 ICUNIT_GOTO_EQUAL(buf.st_mode & S_IFMT, S_IFREG, POSIX_FS_IS_ERROR, EXIT);
431
432 ret = unlink(tmpFileName1);
433 ICUNIT_ASSERT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
434
435 ret = unlink(tmpFileName2);
436 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
437
438 return POSIX_FS_NO_ERROR;
439
440 EXIT1:
441 ret = close(fd);
442 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
443 EXIT:
444 ret = unlink(tmpFileName1);
445 ICUNIT_ASSERT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
446
447 return POSIX_FS_NO_ERROR;
448 }
449
PosixFsFullTest(void)450 void PosixFsFullTest(void)
451 {
452 RUN_ONE_TESTCASE(TestFsFull001);
453 RUN_ONE_TESTCASE(TestFsFull002);
454 #if (LOSCFG_SUPPORT_FATFS == 1)
455 RUN_ONE_TESTCASE(TestFsFull003);
456 RUN_ONE_TESTCASE(TestFsFull004);
457 #endif
458 RUN_ONE_TESTCASE(TestFsFull005);
459 RUN_ONE_TESTCASE(TestFsFull006);
460 RUN_ONE_TESTCASE(TestFsFull007);
461 RUN_ONE_TESTCASE(TestFsFull008);
462 RUN_ONE_TESTCASE(TestFsFull009);
463 }
464