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 : Create file after max files opened
61 * @tc.desc : [C- SOFTWARE -0200]
62 */
63 LITE_TEST_CASE(UtilsFileReliTestSuite, testCreateFileAfterMaxFilesOpened, 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 int j = i + 1;
69 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
70 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
71 if (size < 0) {
72 TEST_ASSERT_EQUAL_INT(0, 1);
73 }
74 fd32[i] = UtilsFileOpen(fileName32, O_RDWR_FS | O_CREAT_FS, 0);
75 TEST_ASSERT_GREATER_THAN_INT(0, fd32[i]);
76 }
77 // Open the 33th file
78 char* fileName33 = "testReli101-33";
79 int fd33 = UtilsFileOpen(fileName33, O_RDWR_FS | O_CREAT_FS, 0);
80 TEST_ASSERT_EQUAL_INT(-1, fd33);
81 // Close file
82 UtilsFileClose(fd32[0]);
83 fd33 = UtilsFileOpen(fileName33, O_RDWR_FS | O_CREAT_FS, 0);
84 TEST_ASSERT_GREATER_THAN_INT(0, fd33);
85 UtilsFileClose(fd33);
86 // Delete all files
87 for (int i = 1; i < MAX_NUM_OF_OPENED_FILES; i++) {
88 UtilsFileClose(fd32[i]);
89 }
90 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++) {
91 int j = i + 1;
92 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
93 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
94 if (size < 0) {
95 TEST_ASSERT_EQUAL_INT(0, 1);
96 }
97 UtilsFileDelete(fileName32);
98 }
99 UtilsFileDelete(fileName33);
100 };
101
102 /**
103 * @tc.number : SUB_UTILS_FILE_OPERATION_5300
104 * @tc.name : Delete file after max files opened
105 * @tc.desc : [C- SOFTWARE -0200]
106 */
107 LITE_TEST_CASE(UtilsFileReliTestSuite, testDeleteFileAfterMaxFilesOpened, Function | MediumTest | Level1)
108 {
109 // Open 32 files
110 int fd32[MAX_NUM_OF_OPENED_FILES] = {0};
111 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++) {
112 int j = i + 1;
113 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
114 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
115 if (size < 0) {
116 TEST_ASSERT_EQUAL_INT(0, 1);
117 }
118 fd32[i] = UtilsFileOpen(fileName32, O_RDWR_FS | O_CREAT_FS, 0);
119 UtilsFileWrite(fd32[i], g_def, strlen(g_def));
120 }
121 // Delete file
122 char* fileName1 = "testReli101-1";
123 UtilsFileClose(fd32[0]);
124 int ret = UtilsFileDelete(fileName1);
125 TEST_ASSERT_EQUAL_INT(0, ret);
126 // Delete all files
127 for (int i = 1; i < MAX_NUM_OF_OPENED_FILES; i++) {
128 UtilsFileClose(fd32[i]);
129 }
130 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++) {
131 int j = i + 1;
132 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
133 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
134 if (size < 0) {
135 TEST_ASSERT_EQUAL_INT(0, 1);
136 }
137 UtilsFileDelete(fileName32);
138 }
139 };
140
141 /**
142 * @tc.number : SUB_UTILS_FILE_OPERATION_5400
143 * @tc.name : Copy file after max files opened
144 * @tc.desc : [C- SOFTWARE -0200]
145 */
146 LITE_TEST_CASE(UtilsFileReliTestSuite, testCopyFileAfterMaxFilesOpened, Function | MediumTest | Level1)
147 {
148 // Open 32 files
149 int fd32[MAX_NUM_OF_OPENED_FILES] = {0};
150 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++) {
151 int j = i + 1;
152 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
153 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
154 if (size < 0) {
155 TEST_ASSERT_EQUAL_INT(0, 1);
156 }
157 fd32[i] = UtilsFileOpen(fileName32, O_RDWR_FS | O_CREAT_FS, 0);
158 UtilsFileWrite(fd32[i], g_def, strlen(g_def));
159 }
160 // Copy file
161 char* fileName1 = "testReli101-1";
162 char* fileNameCopy = "testReliCopy";
163 int ret = UtilsFileCopy(fileName1, fileNameCopy);
164 TEST_ASSERT_EQUAL_INT(-1, ret);
165 // Close first file
166 UtilsFileClose(fd32[0]);
167 ret = UtilsFileCopy(fileName1, fileNameCopy);
168 TEST_ASSERT_EQUAL_INT(-1, ret);
169 // Close second file
170 UtilsFileClose(fd32[1]);
171 ret = UtilsFileCopy(fileName1, fileNameCopy);
172 TEST_ASSERT_EQUAL_INT(0, ret);
173 // Delete all files
174 for (int i = 2; i < MAX_NUM_OF_OPENED_FILES; i++) {
175 UtilsFileClose(fd32[i]);
176 }
177 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++) {
178 int j = i + 1;
179 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
180 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
181 if (size < 0) {
182 TEST_ASSERT_EQUAL_INT(0, 1);
183 }
184 UtilsFileDelete(fileName32);
185 }
186 UtilsFileDelete(fileNameCopy);
187 };
188
189 /**
190 * @tc.number : SUB_UTILS_FILE_OPERATION_5500
191 * @tc.name : Move file after max files opened
192 * @tc.desc : [C- SOFTWARE -0200]
193 */
194 LITE_TEST_CASE(UtilsFileReliTestSuite, testMoveFileAfterMaxFilesOpened, Function | MediumTest | Level1)
195 {
196 // Open 32 files
197 int fd32[MAX_NUM_OF_OPENED_FILES] = {0};
198 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++) {
199 int j = i + 1;
200 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
201 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
202 if (size < 0) {
203 TEST_ASSERT_EQUAL_INT(0, 1);
204 }
205 fd32[i] = UtilsFileOpen(fileName32, O_RDWR_FS | O_CREAT_FS, 0);
206 UtilsFileWrite(fd32[i], g_def, strlen(g_def));
207 }
208 // Move file
209 char* fileName1 = "testReli101-1";
210 char* fileNameMove = "testReliMove";
211 int ret = UtilsFileMove(fileName1, fileNameMove);
212 TEST_ASSERT_EQUAL_INT(-1, ret);
213 // Close first file
214 UtilsFileClose(fd32[0]);
215 ret = UtilsFileMove(fileName1, fileNameMove);
216 TEST_ASSERT_EQUAL_INT(-1, ret);
217 // Close second file
218 UtilsFileClose(fd32[1]);
219 ret = UtilsFileMove(fileName1, fileNameMove);
220 TEST_ASSERT_EQUAL_INT(0, ret);
221 // Delete all files
222 for (int i = 2; i < MAX_NUM_OF_OPENED_FILES; i++) {
223 UtilsFileClose(fd32[i]);
224 }
225 for (int i = 0; i < MAX_NUM_OF_OPENED_FILES; i++) {
226 int j = i + 1;
227 char fileName32[LENGTH_OF_FILE_NAME_BUF] = {0};
228 int size = sprintf_s(fileName32, sizeof(fileName32), "%s%d", "testReli101-", j);
229 if (size < 0) {
230 TEST_ASSERT_EQUAL_INT(0, 1);
231 }
232 UtilsFileDelete(fileName32);
233 }
234 UtilsFileDelete(fileNameMove);
235 };
236
237 /**
238 * @tc.number : SUB_UTILS_FILE_OPERATION_5600
239 * @tc.name : File operation flow for copied file
240 * @tc.desc : [C- SOFTWARE -0200]
241 */
242 LITE_TEST_CASE(UtilsFileReliTestSuite, testFileOperFlow001, Function | MediumTest | Level1)
243 {
244 char* fileName1 = "testReli102a";
245 char* fileName2 = "testReli102b";
246 // Create file
247 int fd1 = UtilsFileOpen(fileName1, O_RDWR_FS | O_CREAT_FS, 0);
248 UtilsFileWrite(fd1, g_def, strlen(g_def));
249 UtilsFileClose(fd1);
250 // Copy file
251 UtilsFileCopy(fileName1, fileName2);
252 // File operation for copied file
253 unsigned int fileLen = 0;
254 int ret = UtilsFileStat(fileName2, &fileLen);
255 TEST_ASSERT_EQUAL_INT(0, ret);
256 int fd2 = UtilsFileOpen(fileName2, O_RDWR_FS | O_APPEND_FS, 0);
257 TEST_ASSERT_GREATER_THAN_INT(0, fd2);
258 ret = UtilsFileWrite(fd2, g_def, strlen(g_def));
259 TEST_ASSERT_GREATER_THAN_INT(0, ret);
260 ret = UtilsFileSeek(fd2, FILE_SEEK_OFFSET_20, SEEK_SET_FS);
261 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
262 char buf[LENGTH_OF_READ_BUF] = {0};
263 ret = UtilsFileRead(fd2, buf, LENGTH_OF_READ_BUF);
264 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
265 ret = UtilsFileClose(fd2);
266 TEST_ASSERT_EQUAL_INT(0, ret);
267 // Delete all files
268 ret = UtilsFileDelete(fileName1);
269 TEST_ASSERT_EQUAL_INT(0, ret);
270 ret = UtilsFileDelete(fileName2);
271 TEST_ASSERT_EQUAL_INT(0, ret);
272 };
273
274 /**
275 * @tc.number : SUB_UTILS_FILE_OPERATION_5700
276 * @tc.name : File operation flow for moved file
277 * @tc.desc : [C- SOFTWARE -0200]
278 */
279 LITE_TEST_CASE(UtilsFileReliTestSuite, testFileOperFlow002, Function | MediumTest | Level1)
280 {
281 char* fileName1 = "testReli102a";
282 char* fileName2 = "testReli102b";
283 char* fileName3 = "testReli102c";
284 // Create file
285 int fd1 = UtilsFileOpen(fileName1, O_RDWR_FS | O_CREAT_FS, 0);
286 UtilsFileWrite(fd1, g_def, strlen(g_def));
287 UtilsFileClose(fd1);
288 // Copy file
289 UtilsFileCopy(fileName1, fileName2);
290 // Move the copied file
291 int ret = UtilsFileMove(fileName2, fileName3);
292 TEST_ASSERT_EQUAL_INT(0, ret);
293 // File operation for moved file
294 unsigned int fileLen = 0;
295 ret = UtilsFileStat(fileName3, &fileLen);
296 TEST_ASSERT_EQUAL_INT(0, ret);
297 int fd2 = UtilsFileOpen(fileName3, O_RDWR_FS | O_APPEND_FS, 0);
298 TEST_ASSERT_GREATER_THAN_INT(0, fd2);
299 ret = UtilsFileWrite(fd2, g_def, strlen(g_def));
300 TEST_ASSERT_GREATER_THAN_INT(0, ret);
301 ret = UtilsFileSeek(fd2, FILE_SEEK_OFFSET_20, SEEK_SET_FS);
302 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
303 char buf[LENGTH_OF_READ_BUF] = {0};
304 ret = UtilsFileRead(fd2, buf, LENGTH_OF_READ_BUF);
305 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
306 ret = UtilsFileClose(fd2);
307 TEST_ASSERT_EQUAL_INT(0, ret);
308 // Delete all files
309 ret = UtilsFileDelete(fileName1);
310 TEST_ASSERT_EQUAL_INT(0, ret);
311 ret = UtilsFileDelete(fileName2);
312 TEST_ASSERT_EQUAL_INT(-1, ret);
313 ret = UtilsFileDelete(fileName3);
314 TEST_ASSERT_EQUAL_INT(0, ret);
315 };
316
317 /**
318 * @tc.number : SUB_UTILS_FILE_OPERATION_5800
319 * @tc.name : File operation flow for copied empty file
320 * @tc.desc : [C- SOFTWARE -0200]
321 */
322 LITE_TEST_CASE(UtilsFileReliTestSuite, testEmptyFileOperFlow001, Function | MediumTest | Level1)
323 {
324 char* fileName1 = "testReli103a";
325 char* fileName2 = "testReli103b";
326 // Create an empty file
327 int fd1 = UtilsFileOpen(fileName1, O_RDWR_FS | O_CREAT_FS, 0);
328 UtilsFileClose(fd1);
329 // Copy file
330 int ret = UtilsFileCopy(fileName1, fileName2);
331 TEST_ASSERT_EQUAL_INT(0, ret);
332 // File operation for copied file
333 unsigned int fileLen = 0;
334 ret = UtilsFileStat(fileName2, &fileLen);
335 TEST_ASSERT_EQUAL_INT(0, ret);
336 int fd2 = UtilsFileOpen(fileName2, O_RDWR_FS, 0);
337 TEST_ASSERT_GREATER_THAN_INT(0, fd2);
338 ret = UtilsFileSeek(fd2, FILE_SEEK_OFFSET_0, SEEK_SET_FS);
339 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
340 char buf[LENGTH_OF_READ_BUF] = {0};
341 ret = UtilsFileRead(fd2, buf, LENGTH_OF_READ_BUF);
342 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
343 ret = UtilsFileClose(fd2);
344 TEST_ASSERT_EQUAL_INT(0, ret);
345 // Delete all files
346 ret = UtilsFileDelete(fileName1);
347 TEST_ASSERT_EQUAL_INT(0, ret);
348 ret = UtilsFileDelete(fileName2);
349 TEST_ASSERT_EQUAL_INT(0, ret);
350 };
351
352 /**
353 * @tc.number : SUB_UTILS_FILE_OPERATION_5900
354 * @tc.name : File operation flow for moved empty file
355 * @tc.desc : [C- SOFTWARE -0200]
356 */
357 LITE_TEST_CASE(UtilsFileReliTestSuite, testEmptyFileOperFlow002, Function | MediumTest | Level1)
358 {
359 char* fileName1 = "testReli103a";
360 char* fileName2 = "testReli103b";
361 char* fileName3 = "testReli103c";
362 // Create an empty file
363 int fd1 = UtilsFileOpen(fileName1, O_RDWR_FS | O_CREAT_FS, 0);
364 UtilsFileClose(fd1);
365 // Copy file
366 UtilsFileCopy(fileName1, fileName2);
367 // Move the copied file
368 int ret = UtilsFileMove(fileName2, fileName3);
369 TEST_ASSERT_EQUAL_INT(0, ret);
370 // File operation for moved file
371 unsigned int fileLen = 0;
372 ret = UtilsFileStat(fileName3, &fileLen);
373 TEST_ASSERT_EQUAL_INT(0, ret);
374 int fd2 = UtilsFileOpen(fileName3, O_RDWR_FS, 0);
375 TEST_ASSERT_GREATER_THAN_INT(0, fd2);
376 ret = UtilsFileSeek(fd2, FILE_SEEK_OFFSET_0, SEEK_SET_FS);
377 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
378 char buf[LENGTH_OF_READ_BUF] = {0};
379 ret = UtilsFileRead(fd2, buf, LENGTH_OF_READ_BUF);
380 TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
381 ret = UtilsFileClose(fd2);
382 TEST_ASSERT_EQUAL_INT(0, ret);
383 // Delete all files
384 ret = UtilsFileDelete(fileName1);
385 TEST_ASSERT_EQUAL_INT(0, ret);
386 ret = UtilsFileDelete(fileName2);
387 TEST_ASSERT_EQUAL_INT(-1, ret);
388 ret = UtilsFileDelete(fileName3);
389 TEST_ASSERT_EQUAL_INT(0, ret);
390 };
391
392 RUN_TEST_SUITE(UtilsFileReliTestSuite);
393