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 #include "vfs_config.h"
33
34 #define MAX_OPEN_FILE_NUM 16
35 #define PRESSURE_RUN_TIMES 200
36 #define PRESSURE_RUN_TIMES003 150
37 #define READ_WRITE_BUF_SIZE 1024
38 #define PATH_MAX_NAME_LEN PATH_MAX
39 #define MAX_OPEN_DIRS_NUM LOSCFG_MAX_OPEN_DIRS
40 #define TEMP_FILE_PATH TEST_ROOT"/FILE7"
41 #define TEMP_DIR_PATH TEST_ROOT"/DIRE"
42
43 /* *
44 * @tc.number SUB_KERNEL_FS_FRESSURE001
45 * @tc.name open close unlink
46 * @tc.desc [C- SOFTWARE -0200]
47 */
48 LITE_TEST_CASE(PosixFsFuncTestSuite, TestFsPressure001, Function | MediumTest | Level1)
49 {
50 int32_t ret;
51 int32_t fd = -1;
52 char tmpFileName[PATH_MAX_NAME_LEN + 1] = TEST_ROOT"/";
53
54 int32_t len = strlen(TEST_ROOT);
55 for (int32_t i = len + 1; i < PATH_MAX_NAME_LEN - 1; i++) {
56 tmpFileName[i] = 'F';
57 }
58 tmpFileName[PATH_MAX_NAME_LEN - 1] = '\0';
59
60 for (int32_t times = 0; times < PRESSURE_RUN_TIMES; times++) {
61 fd = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_HIGH);
62 ICUNIT_ASSERT_NOT_EQUAL(fd, POSIX_FS_IS_ERROR, fd);
63
64 ret = close(fd);
65 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT1);
66
67 ret = unlink(tmpFileName);
68 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
69 }
70
71 tmpFileName[PATH_MAX_NAME_LEN - 1] = 'E';
72 tmpFileName[PATH_MAX_NAME_LEN] = '\0';
73 fd = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_HIGH);
74 ICUNIT_ASSERT_EQUAL(errno, ENAMETOOLONG, POSIX_FS_IS_ERROR);
75 ICUNIT_ASSERT_EQUAL(fd, POSIX_FS_IS_ERROR, fd);
76
77 return POSIX_FS_NO_ERROR;
78
79 EXIT1:
80 ret = close(fd);
81 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
82 EXIT:
83 ret = unlink(tmpFileName);
84 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
85 return POSIX_FS_NO_ERROR;
86 }
87
88 /* *
89 * @tc.number SUB_KERNEL_FS_PRESSURE002
90 * @tc.name open write lseek read close unlink
91 * @tc.desc [C- SOFTWARE -0200]
92 */
93 LITE_TEST_CASE(PosixFsFuncTestSuite, TestFsPressure002, Function | MediumTest | Level1)
94 {
95 off_t off;
96 int32_t ret;
97 int32_t fd = -1;
98 bool flag = true;
99 const char tmpFileName[TEST_BUF_SIZE] = FILE1;
100 char *writeBuf = (char *)malloc(READ_WRITE_BUF_SIZE * sizeof(char));
101 char *readBuf = (char *)malloc(READ_WRITE_BUF_SIZE * sizeof(char));
102
103 (void)memset_s(writeBuf, READ_WRITE_BUF_SIZE, 'w', READ_WRITE_BUF_SIZE);
104
105 for (int32_t times = 0; times < PRESSURE_RUN_TIMES; times++) {
106 (void)memset_s(readBuf, READ_WRITE_BUF_SIZE, 'r', READ_WRITE_BUF_SIZE);
107 fd = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_HIGH);
108 ICUNIT_ASSERT_NOT_EQUAL(fd, POSIX_FS_IS_ERROR, fd);
109
110 ret = write(fd, writeBuf, READ_WRITE_BUF_SIZE / 2); /* 2, common data for test, no special meaning */
111 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT1);
112 ret = write(fd, writeBuf, READ_WRITE_BUF_SIZE / 2); /* 2, common data for test, no special meaning */
113 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT1);
114
115 off = lseek(fd, 0, SEEK_SET); /* 0, offset distance */
116 ICUNIT_GOTO_NOT_EQUAL(off, POSIX_FS_IS_ERROR, off, EXIT1);
117
118 for (int32_t i = 0; i < 8; i++) { /* 8, number of reads */
119 ret = read(fd, readBuf + i * 128, 128); /* 128, length per read */
120 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT1);
121 }
122
123 for (int32_t i = 0; i < READ_WRITE_BUF_SIZE; i++) {
124 ICUNIT_GOTO_EQUAL(writeBuf[i], readBuf[i], POSIX_FS_IS_ERROR, EXIT1);
125 }
126
127 ret = close(fd);
128 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT1);
129
130 ret = unlink(tmpFileName);
131 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT);
132 }
133
134 return POSIX_FS_NO_ERROR;
135
136 EXIT1:
137 ret = close(fd);
138 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
139 EXIT:
140 ret = unlink(tmpFileName);
141 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
142 return POSIX_FS_NO_ERROR;
143 }
144
145 /* *
146 * @tc.number SUB_KERNEL_FS_ORESSURE003
147 * @tc.name open fstat stat mkdir unlink rmdir close
148 * @tc.desc [C- SOFTWARE -0200]
149 */
150 LITE_TEST_CASE(PosixFsFuncTestSuite, TestFsPressure003, Function | MediumTest | Level1)
151 {
152 int res;
153 int32_t ret;
154 bool flagMkdir = true;
155 struct stat buf = { 0 };
156 int32_t j, k, fd[MAX_OPEN_FILE_NUM];
157 char tmpDirName[TEST_BUF_SIZE] = { 0 };
158 char tmpFileName[TEST_BUF_SIZE] = { 0 };
159
160 for (int32_t times = 0; times < PRESSURE_RUN_TIMES003; times++) {
161 for (j = 0; j < MAX_OPEN_FILE_NUM; j++) {
162 res = sprintf_s(tmpFileName, TEST_BUF_SIZE, "%s%02d", TEMP_FILE_PATH, j);
163 if (res < 0) {
164 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
165 goto EXIT3;
166 }
167 fd[j] = open(tmpFileName, O_CREAT | O_RDWR, TEST_MODE_HIGH);
168 ICUNIT_GOTO_NOT_EQUAL(fd[j], POSIX_FS_IS_ERROR, fd[j], EXIT3);
169 }
170 for (int32_t i = 0; i < MAX_OPEN_FILE_NUM; i++) {
171 ret = fstat(fd[i], &buf);
172 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT3);
173 ICUNIT_GOTO_EQUAL(buf.st_mode & S_IFMT, S_IFREG, POSIX_FS_IS_ERROR, EXIT3);
174 }
175 for (int32_t i = 0; i < MAX_OPEN_FILE_NUM; i++) {
176 ret = close(fd[i]);
177 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT2);
178 }
179 for (int32_t i = 0; i < MAX_OPEN_FILE_NUM; i++) {
180 res = sprintf_s(tmpFileName, TEST_BUF_SIZE, "%s%02d", TEMP_FILE_PATH, i);
181 if (res < 0) {
182 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
183 goto EXIT1;
184 }
185 ret = stat(tmpFileName, &buf);
186 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT1);
187 ICUNIT_GOTO_EQUAL(buf.st_mode & S_IFMT, S_IFREG, POSIX_FS_IS_ERROR, EXIT1);
188 }
189 for (k = 0; k < MAX_OPEN_DIRS_NUM; k++) {
190 res = sprintf_s(tmpDirName, TEST_BUF_SIZE, "%s%02d", TEMP_DIR_PATH, k);
191 if (res < 0) {
192 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
193 goto EXIT1;
194 }
195 ret = mkdir(tmpDirName, TEST_MODE_HIGH);
196 if (ret == POSIX_FS_IS_ERROR) {
197 flagMkdir = false;
198 }
199 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT1);
200 }
201 for (int32_t i = 0; i < MAX_OPEN_DIRS_NUM; i++) {
202 res = sprintf_s(tmpDirName, TEST_BUF_SIZE, "%s%02d", TEMP_DIR_PATH, i);
203 if (res < 0) {
204 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
205 goto EXIT1;
206 }
207 ret = stat(tmpDirName, &buf);
208 ICUNIT_GOTO_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret, EXIT1);
209 ICUNIT_GOTO_EQUAL(buf.st_mode & S_IFMT, S_IFDIR, POSIX_FS_IS_ERROR, EXIT1);
210 }
211 for (int32_t i = 0; i < MAX_OPEN_FILE_NUM; i++) {
212 res = sprintf_s(tmpFileName, TEST_BUF_SIZE, "%s%02d", TEMP_FILE_PATH, i);
213 if (res < 0) {
214 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
215 return POSIX_FS_IS_ERROR;
216 }
217 ret = unlink(tmpFileName);
218 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
219 }
220 for (int32_t i = 0; i < MAX_OPEN_DIRS_NUM; i++) {
221 res = sprintf_s(tmpDirName, TEST_BUF_SIZE, "%s%02d", TEMP_DIR_PATH, i);
222 if (res < 0) {
223 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
224 return POSIX_FS_IS_ERROR;
225 }
226 ret = rmdir(tmpDirName);
227 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
228 }
229 for (int32_t i = 0; i < MAX_OPEN_FILE_NUM; i++) {
230 res = sprintf_s(tmpFileName, TEST_BUF_SIZE, "%s%02d", TEMP_FILE_PATH, i);
231 if (res < 0) {
232 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
233 return POSIX_FS_IS_ERROR;
234 }
235 ret = stat(tmpFileName, &buf);
236 ICUNIT_ASSERT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
237 }
238 for (int32_t i = 0; i < MAX_OPEN_DIRS_NUM; i++) {
239 res = sprintf_s(tmpDirName, TEST_BUF_SIZE, "%s%02d", TEMP_DIR_PATH, i);
240 if (res < 0) {
241 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
242 return POSIX_FS_IS_ERROR;
243 }
244 ret = stat(tmpDirName, &buf);
245 ICUNIT_ASSERT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
246 }
247 }
248 return POSIX_FS_NO_ERROR;
249 EXIT3:
250 for (int32_t m = 0; m < j; m++) {
251 ret = close(fd[m]);
252 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
253 }
254 goto EXIT1;
255 EXIT2:
256 for (int32_t m = j; m < MAX_OPEN_FILE_NUM; m++) {
257 ret = close(fd[m]);
258 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
259 }
260 EXIT1:
261 for (int32_t m = 0; m < j; m++) {
262 res = sprintf_s(tmpFileName, TEST_BUF_SIZE, "%s%02d", TEMP_FILE_PATH, m);
263 if (res < 0) {
264 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
265 return POSIX_FS_IS_ERROR;
266 }
267 ret = unlink(tmpFileName);
268 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
269 }
270 if (flagMkdir == false) {
271 goto EXIT;
272 }
273 return POSIX_FS_NO_ERROR;
274 EXIT:
275 for (int32_t m = 0; m < k; m++) {
276 res = sprintf_s(tmpDirName, TEST_BUF_SIZE, "%s%02d", TEMP_DIR_PATH, m);
277 if (res < 0) {
278 printf("[%s:%d] sprintf_s failed\n", __func__, __LINE__);
279 return POSIX_FS_IS_ERROR;
280 }
281 ret = rmdir(tmpDirName);
282 ICUNIT_ASSERT_NOT_EQUAL(ret, POSIX_FS_IS_ERROR, ret);
283 }
284 return POSIX_FS_NO_ERROR;
285 }
286
PosixFsPressureTest(void)287 void PosixFsPressureTest(void)
288 {
289 RUN_ONE_TESTCASE(TestFsPressure001);
290 RUN_ONE_TESTCASE(TestFsPressure002);
291 RUN_ONE_TESTCASE(TestFsPressure003);
292 }
293