1 /*
2 * Copyright (c) 2020-2021 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 "ohos_types.h"
17 #include <securec.h>
18 #include "hctest.h"
19 #include "utils_file.h"
20
21 #define FILE_SEEK_OFFSET_0 0
22 #define FILE_SEEK_OFFSET_20 20
23 #define FILE_SEEK_OFFSET_MINUS_20 (-20)
24 #define MAX_NUM_OF_OPENED_FILES 32
25 #define LENGTH_OF_READ_BUF 36
26 #define FILE_INDEX_31 31
27 #define LENGTH_OF_FILE_NAME_BUF 32
28
29 static const char* g_def = "utils_file_operation implement.";
30
31 /**
32 * @tc.desc : register a test suite, this suite is used to test basic flow and interface dependency
33 * @param : subsystem name is utils
34 * @param : module name is utilsFile
35 * @param : test suit name is UtilsFileReliTestSuite
36 */
37 LITE_TEST_SUIT(utils, utilsFile, UtilsFileReliTestSuite);
38
39 /**
40 * @tc.setup : setup for all testcases
41 * @return : setup result, TRUE is success, FALSE is fail
42 */
UtilsFileReliTestSuiteSetUp(void)43 static BOOL UtilsFileReliTestSuiteSetUp(void)
44 {
45 return TRUE;
46 }
47
48 /**
49 * @tc.teardown : teardown for all testcases
50 * @return : teardown result, TRUE is success, FALSE is fail
51 */
UtilsFileReliTestSuiteTearDown(void)52 static BOOL UtilsFileReliTestSuiteTearDown(void)
53 {
54 printf("+-------------------------------------------+\n");
55 return TRUE;
56 }
57
58 /**
59 * @tc.number : SUB_UTILS_FILE_OPERATION_5200
60 * @tc.name : Creat file after max files opened
61 * @tc.desc : [C- SOFTWARE -0200]
62 */
63 LITE_TEST_CASE(UtilsFileReliTestSuite, testCreatFileAfterMaxFilesOpened, Function | MediumTest | Level1)
64 {
65 // Open 32 files
66 int fd32[MAX_NUM_OF_OPENED_FILES] = {0};
67 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++)
68 {
69 int j = i + 1;
70 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
71 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
72 if (size < 0) {
73 TEST_ASSERT_EQUAL_INT(0, 1);
74 }
75 fd32[i] = UtilsFileOpen(fileName32, O_RDWR_FS | O_CREAT_FS, 0);
76 TEST_ASSERT_GREATER_THAN_INT(0, fd32[i]);
77 }
78 // Open the 33th file
79 char* fileName33 = "testReli101-33";
80 int fd33 = UtilsFileOpen(fileName33, O_RDWR_FS | O_CREAT_FS, 0);
81 TEST_ASSERT_EQUAL_INT(-1, fd33);
82 // Close file
83 UtilsFileClose(fd32[0]);
84 fd33 = UtilsFileOpen(fileName33, O_RDWR_FS | O_CREAT_FS, 0);
85 TEST_ASSERT_GREATER_THAN_INT(0, fd33);
86 UtilsFileClose(fd33);
87 // Delete all files
88 for (int i = 1; i < MAX_NUM_OF_OPENED_FILES; i++)
89 {
90 UtilsFileClose(fd32[i]);
91 }
92 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++)
93 {
94 int j = i + 1;
95 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
96 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
97 if (size < 0) {
98 TEST_ASSERT_EQUAL_INT(0, 1);
99 }
100 UtilsFileDelete(fileName32);
101 }
102 UtilsFileDelete(fileName33);
103 };
104
105 /**
106 * @tc.number : SUB_UTILS_FILE_OPERATION_5300
107 * @tc.name : Delete file after max files opened
108 * @tc.desc : [C- SOFTWARE -0200]
109 */
110 LITE_TEST_CASE(UtilsFileReliTestSuite, testDeleteFileAfterMaxFilesOpened, Function | MediumTest | Level1)
111 {
112 // Open 32 files
113 int fd32[MAX_NUM_OF_OPENED_FILES] = {0};
114 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++)
115 {
116 int j = i + 1;
117 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
118 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
119 if (size < 0) {
120 TEST_ASSERT_EQUAL_INT(0, 1);
121 }
122 fd32[i] = UtilsFileOpen(fileName32, O_RDWR_FS | O_CREAT_FS, 0);
123 UtilsFileWrite(fd32[i], g_def, strlen(g_def));
124 }
125 // Delete file
126 char* fileName1 = "testReli101-1";
127 UtilsFileClose(fd32[0]);
128 int ret = UtilsFileDelete(fileName1);
129 TEST_ASSERT_EQUAL_INT(0, ret);
130 // Delete all files
131 for (int i = 1; i < MAX_NUM_OF_OPENED_FILES; i++)
132 {
133 UtilsFileClose(fd32[i]);
134 }
135 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++)
136 {
137 int j = i + 1;
138 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
139 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
140 if (size < 0) {
141 TEST_ASSERT_EQUAL_INT(0, 1);
142 }
143 UtilsFileDelete(fileName32);
144 }
145 };
146
147 /**
148 * @tc.number : SUB_UTILS_FILE_OPERATION_5400
149 * @tc.name : Copy file after max files opened
150 * @tc.desc : [C- SOFTWARE -0200]
151 */
152 LITE_TEST_CASE(UtilsFileReliTestSuite, testCopyFileAfterMaxFilesOpened, Function | MediumTest | Level1)
153 {
154 // Open 32 files
155 int fd32[MAX_NUM_OF_OPENED_FILES] = {0};
156 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++)
157 {
158 int j = i + 1;
159 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
160 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
161 if (size < 0) {
162 TEST_ASSERT_EQUAL_INT(0, 1);
163 }
164 fd32[i] = UtilsFileOpen(fileName32, O_RDWR_FS | O_CREAT_FS, 0);
165 UtilsFileWrite(fd32[i], g_def, strlen(g_def));
166 }
167 // Copy file
168 char* fileName1 = "testReli101-1";
169 char* fileNameCopy = "testReliCopy";
170 int ret = UtilsFileCopy(fileName1, fileNameCopy);
171 TEST_ASSERT_EQUAL_INT(-1, ret);
172 // Close first file
173 UtilsFileClose(fd32[0]);
174 ret = UtilsFileCopy(fileName1, fileNameCopy);
175 TEST_ASSERT_EQUAL_INT(-1, ret);
176 // Close second file
177 UtilsFileClose(fd32[1]);
178 ret = UtilsFileCopy(fileName1, fileNameCopy);
179 TEST_ASSERT_EQUAL_INT(0, ret);
180 // Delete all files
181 for (int i = 2; i < MAX_NUM_OF_OPENED_FILES; i++)
182 {
183 UtilsFileClose(fd32[i]);
184 }
185 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++)
186 {
187 int j = i + 1;
188 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
189 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
190 if (size < 0) {
191 TEST_ASSERT_EQUAL_INT(0, 1);
192 }
193 UtilsFileDelete(fileName32);
194 }
195 UtilsFileDelete(fileNameCopy);
196 };
197
198 /**
199 * @tc.number : SUB_UTILS_FILE_OPERATION_5500
200 * @tc.name : Move file after max files opened
201 * @tc.desc : [C- SOFTWARE -0200]
202 */
203 LITE_TEST_CASE(UtilsFileReliTestSuite, testMoveFileAfterMaxFilesOpened, Function | MediumTest | Level1)
204 {
205 // Open 32 files
206 int fd32[MAX_NUM_OF_OPENED_FILES] = {0};
207 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++)
208 {
209 int j = i + 1;
210 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
211 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
212 if (size < 0) {
213 TEST_ASSERT_EQUAL_INT(0, 1);
214 }
215 fd32[i] = UtilsFileOpen(fileName32, O_RDWR_FS | O_CREAT_FS, 0);
216 UtilsFileWrite(fd32[i], g_def, strlen(g_def));
217 }
218 // Move file
219 char* fileName1 = "testReli101-1";
220 char* fileNameMove = "testReliMove";
221 int ret = UtilsFileMove(fileName1, fileNameMove);
222 TEST_ASSERT_EQUAL_INT(-1, ret);
223 // Close first file
224 UtilsFileClose(fd32[0]);
225 ret = UtilsFileMove(fileName1, fileNameMove);
226 TEST_ASSERT_EQUAL_INT(-1, ret);
227 // Close second file
228 UtilsFileClose(fd32[1]);
229 ret = UtilsFileMove(fileName1, fileNameMove);
230 TEST_ASSERT_EQUAL_INT(0, ret);
231 // Delete all files
232 for (int i = 2; i < MAX_NUM_OF_OPENED_FILES; i++)
233 {
234 UtilsFileClose(fd32[i]);
235 }
236 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++)
237 {
238 int j = i + 1;
239 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
240 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
241 if (size < 0) {
242 TEST_ASSERT_EQUAL_INT(0, 1);
243 }
244 UtilsFileDelete(fileName32);
245 }
246 UtilsFileDelete(fileNameMove);
247 };
248
249 /**
250 * @tc.number : SUB_UTILS_FILE_OPERATION_5600
251 * @tc.name : File operation flow for copied file
252 * @tc.desc : [C- SOFTWARE -0200]
253 */
254 LITE_TEST_CASE(UtilsFileReliTestSuite, testFileOperFlow001, Function | MediumTest | Level1)
255 {
256 char* fileName1 = "testReli102a";
257 char* fileName2 = "testReli102b";
258 // Creat file
259 int fd1 = UtilsFileOpen(fileName1, O_RDWR_FS | O_CREAT_FS, 0);
260 UtilsFileWrite(fd1, g_def, strlen(g_def));
261 UtilsFileClose(fd1);
262 // Copy file
263 UtilsFileCopy(fileName1, fileName2);
264 // File operation for copied file
265 unsigned int fileLen = 0;
266 int ret = UtilsFileStat(fileName2, &fileLen);
267 TEST_ASSERT_EQUAL_INT(0, ret);
268 int fd2 = UtilsFileOpen(fileName2, O_RDWR_FS | O_APPEND_FS, 0);
269 TEST_ASSERT_GREATER_THAN_INT(0, fd2);
270 ret = UtilsFileWrite(fd2, g_def, strlen(g_def));
271 TEST_ASSERT_GREATER_THAN_INT(0, ret);
272 ret = UtilsFileSeek(fd2, FILE_SEEK_OFFSET_20, SEEK_SET_FS);
273 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
274 char buf[LENGTH_OF_READ_BUF] = {0};
275 ret = UtilsFileRead(fd2, buf, LENGTH_OF_READ_BUF);
276 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
277 ret = UtilsFileClose(fd2);
278 TEST_ASSERT_EQUAL_INT(0, ret);
279 // Delete all files
280 ret = UtilsFileDelete(fileName1);
281 TEST_ASSERT_EQUAL_INT(0, ret);
282 ret = UtilsFileDelete(fileName2);
283 TEST_ASSERT_EQUAL_INT(0, ret);
284 };
285
286 /**
287 * @tc.number : SUB_UTILS_FILE_OPERATION_5700
288 * @tc.name : File operation flow for moved file
289 * @tc.desc : [C- SOFTWARE -0200]
290 */
291 LITE_TEST_CASE(UtilsFileReliTestSuite, testFileOperFlow002, Function | MediumTest | Level1)
292 {
293 char* fileName1 = "testReli102a";
294 char* fileName2 = "testReli102b";
295 char* fileName3 = "testReli102c";
296 // Creat file
297 int fd1 = UtilsFileOpen(fileName1, O_RDWR_FS | O_CREAT_FS, 0);
298 UtilsFileWrite(fd1, g_def, strlen(g_def));
299 UtilsFileClose(fd1);
300 // Copy file
301 UtilsFileCopy(fileName1, fileName2);
302 // Move the copied file
303 int ret = UtilsFileMove(fileName2, fileName3);
304 TEST_ASSERT_EQUAL_INT(0, ret);
305 // File operation for moved file
306 unsigned int fileLen = 0;
307 ret = UtilsFileStat(fileName3, &fileLen);
308 TEST_ASSERT_EQUAL_INT(0, ret);
309 int fd2 = UtilsFileOpen(fileName3, O_RDWR_FS | O_APPEND_FS, 0);
310 TEST_ASSERT_GREATER_THAN_INT(0, fd2);
311 ret = UtilsFileWrite(fd2, g_def, strlen(g_def));
312 TEST_ASSERT_GREATER_THAN_INT(0, ret);
313 ret = UtilsFileSeek(fd2, FILE_SEEK_OFFSET_20, SEEK_SET_FS);
314 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
315 char buf[LENGTH_OF_READ_BUF] = {0};
316 ret = UtilsFileRead(fd2, buf, LENGTH_OF_READ_BUF);
317 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
318 ret = UtilsFileClose(fd2);
319 TEST_ASSERT_EQUAL_INT(0, ret);
320 // Delete all files
321 ret = UtilsFileDelete(fileName1);
322 TEST_ASSERT_EQUAL_INT(0, ret);
323 ret = UtilsFileDelete(fileName2);
324 TEST_ASSERT_EQUAL_INT(-1, ret);
325 ret = UtilsFileDelete(fileName3);
326 TEST_ASSERT_EQUAL_INT(0, ret);
327 };
328
329 /**
330 * @tc.number : SUB_UTILS_FILE_OPERATION_5800
331 * @tc.name : File operation flow for copied empty file
332 * @tc.desc : [C- SOFTWARE -0200]
333 */
334 LITE_TEST_CASE(UtilsFileReliTestSuite, testEmptyFileOperFlow001, Function | MediumTest | Level1)
335 {
336 char* fileName1 = "testReli103a";
337 char* fileName2 = "testReli103b";
338 // Creat an empty file
339 int fd1 = UtilsFileOpen(fileName1, O_RDWR_FS | O_CREAT_FS, 0);
340 UtilsFileClose(fd1);
341 // Copy file
342 int ret = UtilsFileCopy(fileName1, fileName2);
343 TEST_ASSERT_EQUAL_INT(0, ret);
344 // File operation for copied file
345 unsigned int fileLen = 0;
346 ret = UtilsFileStat(fileName2, &fileLen);
347 TEST_ASSERT_EQUAL_INT(0, ret);
348 int fd2 = UtilsFileOpen(fileName2, O_RDWR_FS, 0);
349 TEST_ASSERT_GREATER_THAN_INT(0, fd2);
350 ret = UtilsFileSeek(fd2, FILE_SEEK_OFFSET_0, SEEK_SET_FS);
351 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
352 char buf[LENGTH_OF_READ_BUF] = {0};
353 ret = UtilsFileRead(fd2, buf, LENGTH_OF_READ_BUF);
354 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
355 ret = UtilsFileClose(fd2);
356 TEST_ASSERT_EQUAL_INT(0, ret);
357 // Delete all files
358 ret = UtilsFileDelete(fileName1);
359 TEST_ASSERT_EQUAL_INT(0, ret);
360 ret = UtilsFileDelete(fileName2);
361 TEST_ASSERT_EQUAL_INT(0, ret);
362 };
363
364 /**
365 * @tc.number : SUB_UTILS_FILE_OPERATION_5900
366 * @tc.name : File operation flow for moved empty file
367 * @tc.desc : [C- SOFTWARE -0200]
368 */
369 LITE_TEST_CASE(UtilsFileReliTestSuite, testEmptyFileOperFlow002, Function | MediumTest | Level1)
370 {
371 char* fileName1 = "testReli103a";
372 char* fileName2 = "testReli103b";
373 char* fileName3 = "testReli103c";
374 // Creat an empty file
375 int fd1 = UtilsFileOpen(fileName1, O_RDWR_FS | O_CREAT_FS, 0);
376 UtilsFileClose(fd1);
377 // Copy file
378 UtilsFileCopy(fileName1, fileName2);
379 // Move the copied file
380 int ret = UtilsFileMove(fileName2, fileName3);
381 TEST_ASSERT_EQUAL_INT(0, ret);
382 // File operation for moved file
383 unsigned int fileLen = 0;
384 ret = UtilsFileStat(fileName3, &fileLen);
385 TEST_ASSERT_EQUAL_INT(0, ret);
386 int fd2 = UtilsFileOpen(fileName3, O_RDWR_FS, 0);
387 TEST_ASSERT_GREATER_THAN_INT(0, fd2);
388 ret = UtilsFileSeek(fd2, FILE_SEEK_OFFSET_0, SEEK_SET_FS);
389 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
390 char buf[LENGTH_OF_READ_BUF] = {0};
391 ret = UtilsFileRead(fd2, buf, LENGTH_OF_READ_BUF);
392 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
393 ret = UtilsFileClose(fd2);
394 TEST_ASSERT_EQUAL_INT(0, ret);
395 // Delete all files
396 ret = UtilsFileDelete(fileName1);
397 TEST_ASSERT_EQUAL_INT(0, ret);
398 ret = UtilsFileDelete(fileName2);
399 TEST_ASSERT_EQUAL_INT(-1, ret);
400 ret = UtilsFileDelete(fileName3);
401 TEST_ASSERT_EQUAL_INT(0, ret);
402 };
403
404 RUN_TEST_SUITE(UtilsFileReliTestSuite);
405