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 QUERY_TIMES    50
22 #define FILE_SEEK_OFFSET_10 10
23 #define FILE_SEEK_OFFSET_20 20
24 #define FILE_SEEK_OFFSET_50 50
25 #define FILE_SEEK_OFFSET_MINUS_10 (-10)
26 #define FILE_SEEK_OFFSET_MINUS_20 (-20)
27 #define FILE_SEEK_OFFSET_MINUS_50 (-50)
28 #define LENGTH_OF_READ_BUF 36
29 
30 static const char* g_def = "utils_file_operation implement.";
31 
32 /**
33  * @tc.desc      : register a test suite, this suite is used to test basic flow and interface dependency
34  * @param        : subsystem name is utils
35  * @param        : module name is utilsFile
36  * @param        : test suit name is UtilsFileFuncTestSuite
37  */
38 LITE_TEST_SUIT(utils, utilsFile, UtilsFileFuncTestSuite);
39 
40 /**
41  * @tc.setup     : setup for all testcases
42  * @return       : setup result, TRUE is success, FALSE is fail
43  */
UtilsFileFuncTestSuiteSetUp(void)44 static BOOL UtilsFileFuncTestSuiteSetUp(void)
45 {
46     return TRUE;
47 }
48 
49 /**
50  * @tc.teardown  : teardown for all testcases
51  * @return       : teardown result, TRUE is success, FALSE is fail
52  */
UtilsFileFuncTestSuiteTearDown(void)53 static BOOL UtilsFileFuncTestSuiteTearDown(void)
54 {
55     printf("+-------------------------------------------+\n");
56     return TRUE;
57 }
58 
59 /**
60  * @tc.number    : SUB_UTILS_FILE_OPERATION_0100
61  * @tc.name      : File operation for file create and close with parameter RDONLY
62  * @tc.desc      : [C- SOFTWARE -0200]
63  */
64 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileCreateAndClose001, Function | MediumTest | Level1)
65 {
66     char* fileName = "testfile101";
67     int fd = UtilsFileOpen(fileName, O_RDONLY_FS | O_CREAT_FS, 0);
68     TEST_ASSERT_GREATER_THAN_INT(0, fd);
69     int ret = UtilsFileClose(fd);
70     TEST_ASSERT_EQUAL_INT(0, ret);
71     UtilsFileDelete(fileName);
72 };
73 
74 /**
75  * @tc.number    : SUB_UTILS_FILE_OPERATION_0200
76  * @tc.name      : File operation for file create and close with parameter WRONLY
77  * @tc.desc      : [C- SOFTWARE -0200]
78  */
79 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileCreateAndClose002, Function | MediumTest | Level1)
80 {
81     char* fileName = "testfile102";
82     int fd = UtilsFileOpen(fileName, O_WRONLY_FS | O_CREAT_FS, 0);
83     TEST_ASSERT_GREATER_THAN_INT(0, fd);
84     int ret = UtilsFileClose(fd);
85     TEST_ASSERT_EQUAL_INT(0, ret);
86     UtilsFileDelete(fileName);
87 };
88 
89 /**
90  * @tc.number    : SUB_UTILS_FILE_OPERATION_0300
91  * @tc.name      : File operation for file create and close with parameter RDWR
92  * @tc.desc      : [C- SOFTWARE -0200]
93  */
94 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileCreateAndClose003, Function | MediumTest | Level1)
95 {
96     char* fileName = "testfile103";
97     int fd = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
98     TEST_ASSERT_GREATER_THAN_INT(0, fd);
99     int ret = UtilsFileClose(fd);
100     TEST_ASSERT_EQUAL_INT(0, ret);
101     UtilsFileDelete(fileName);
102 };
103 
104 /**
105  * @tc.number    : SUB_UTILS_FILE_OPERATION_0400
106  * @tc.name      : File operation for file open and close with parameter RDONLY
107  * @tc.desc      : [C- SOFTWARE -0200]
108  */
109 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileOpenAndClose001, Function | MediumTest | Level1)
110 {
111     char* fileName = "testfile104";
112     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
113     UtilsFileClose(fd0);
114     int fd = UtilsFileOpen(fileName, O_RDONLY_FS, 0);
115     TEST_ASSERT_GREATER_THAN_INT(0, fd);
116     int ret = UtilsFileClose(fd);
117     TEST_ASSERT_EQUAL_INT(0, ret);
118     UtilsFileDelete(fileName);
119 };
120 
121 /**
122  * @tc.number    : SUB_UTILS_FILE_OPERATION_0500
123  * @tc.name      : File operation for file open and close with parameter WRONLY
124  * @tc.desc      : [C- SOFTWARE -0200]
125  */
126 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileOpenAndClose002, Function | MediumTest | Level1)
127 {
128     char* fileName = "testfile105";
129     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
130     UtilsFileClose(fd0);
131     int fd = UtilsFileOpen(fileName, O_WRONLY_FS, 0);
132     TEST_ASSERT_GREATER_THAN_INT(0, fd);
133     int ret = UtilsFileClose(fd);
134     TEST_ASSERT_EQUAL_INT(0, ret);
135     UtilsFileDelete(fileName);
136 };
137 
138 /**
139  * @tc.number    : SUB_UTILS_FILE_OPERATION_0600
140  * @tc.name      : File operation for file open and close with parameter RDWR
141  * @tc.desc      : [C- SOFTWARE -0200]
142  */
143 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileOpenAndClose003, Function | MediumTest | Level1)
144 {
145     char* fileName = "testfile106";
146     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
147     UtilsFileClose(fd0);
148     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
149     TEST_ASSERT_GREATER_THAN_INT(0, fd);
150     int ret = UtilsFileClose(fd);
151     TEST_ASSERT_EQUAL_INT(0, ret);
152     UtilsFileDelete(fileName);
153 };
154 
155 /**
156  * @tc.number    : SUB_UTILS_FILE_OPERATION_0700
157  * @tc.name      : File operation for file open and close with parameter TRUNC
158  * @tc.desc      : [C- SOFTWARE -0200]
159  */
160 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileOpenAndClose004, Function | MediumTest | Level1)
161 {
162     char* fileName = "testfile107";
163     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
164     UtilsFileClose(fd0);
165     int fd = UtilsFileOpen(fileName, O_RDWR_FS | O_TRUNC_FS, 0);
166     TEST_ASSERT_GREATER_THAN_INT(0, fd);
167     int ret = UtilsFileClose(fd);
168     TEST_ASSERT_EQUAL_INT(0, ret);
169     UtilsFileDelete(fileName);
170 };
171 
172 /**
173  * @tc.number    : SUB_UTILS_FILE_OPERATION_0800
174  * @tc.name      : File operation for file open and close with parameter APPEND
175  * @tc.desc      : [C- SOFTWARE -0200]
176  */
177 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileOpenAndClose005, Function | MediumTest | Level1)
178 {
179     char* fileName = "testfile108";
180     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
181     UtilsFileClose(fd0);
182     int fd = UtilsFileOpen(fileName, O_RDWR_FS | O_APPEND_FS, 0);
183     TEST_ASSERT_GREATER_THAN_INT(0, fd);
184     int ret = UtilsFileClose(fd);
185     TEST_ASSERT_EQUAL_INT(0, ret);
186     UtilsFileDelete(fileName);
187 };
188 
189 /**
190  * @tc.number    : SUB_UTILS_FILE_OPERATION_0900
191  * @tc.name      : File operation for file create and close with parameter RDONLY and EXCL
192  * @tc.desc      : [C- SOFTWARE -0200]
193  */
194 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileCreateAndClose004, Function | MediumTest | Level1)
195 {
196     char* fileName = "testfile109";
197     int fd = UtilsFileOpen(fileName, O_RDONLY_FS | O_CREAT_FS | O_EXCL_FS, 0);
198     TEST_ASSERT_GREATER_THAN_INT(0, fd);
199     int ret = UtilsFileClose(fd);
200     TEST_ASSERT_EQUAL_INT(0, ret);
201     int fd1 = UtilsFileOpen(fileName, O_RDONLY_FS | O_CREAT_FS | O_EXCL_FS, 0);
202     TEST_ASSERT_EQUAL_INT(-1, fd1);
203     int ret1 = UtilsFileClose(fd1);
204     TEST_ASSERT_EQUAL_INT(-1, ret1);
205     UtilsFileDelete(fileName);
206 };
207 
208 /**
209  * @tc.number    : SUB_UTILS_FILE_OPERATION_1000
210  * @tc.name      : File operation for file create and close with parameter WRONLY and EXCL
211  * @tc.desc      : [C- SOFTWARE -0200]
212  */
213 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileCreateAndClose005, Function | MediumTest | Level1)
214 {
215     char* fileName = "testfile110";
216     int fd = UtilsFileOpen(fileName, O_WRONLY_FS | O_CREAT_FS | O_EXCL_FS, 0);
217     TEST_ASSERT_GREATER_THAN_INT(0, fd);
218     int ret = UtilsFileClose(fd);
219     TEST_ASSERT_EQUAL_INT(0, ret);
220     int fd1 = UtilsFileOpen(fileName, O_WRONLY_FS | O_CREAT_FS | O_EXCL_FS, 0);
221     TEST_ASSERT_EQUAL_INT(-1, fd1);
222     int ret1 = UtilsFileClose(fd1);
223     TEST_ASSERT_EQUAL_INT(-1, ret1);
224     UtilsFileDelete(fileName);
225 };
226 
227 /**
228  * @tc.number    : SUB_UTILS_FILE_OPERATION_1100
229  * @tc.name      : File operation for file create and close with parameter RDWR and EXCL
230  * @tc.desc      : [C- SOFTWARE -0200]
231  */
232 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileCreatAndClose006, Function | MediumTest | Level1)
233 {
234     char* fileName = "testfile111";
235     int fd = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS | O_EXCL_FS, 0);
236     TEST_ASSERT_GREATER_THAN_INT(0, fd);
237     int ret = UtilsFileClose(fd);
238     TEST_ASSERT_EQUAL_INT(0, ret);
239     int fd1 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS | O_EXCL_FS, 0);
240     TEST_ASSERT_EQUAL_INT(-1, fd1);
241     int ret1 = UtilsFileClose(fd1);
242     TEST_ASSERT_EQUAL_INT(-1, ret1);
243     UtilsFileDelete(fileName);
244 };
245 
246 /**
247  * @tc.number    : SUB_UTILS_FILE_OPERATION_1200
248  * @tc.name      : File operation for file create and close with parameter TRUNC and EXCL
249  * @tc.desc      : [C- SOFTWARE -0200]
250  */
251 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileCreateAndClose007, Function | MediumTest | Level1)
252 {
253     char* fileName = "testfile112";
254     int fd = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS | O_EXCL_FS | O_TRUNC_FS, 0);
255     TEST_ASSERT_GREATER_THAN_INT(0, fd);
256     int ret = UtilsFileClose(fd);
257     TEST_ASSERT_EQUAL_INT(0, ret);
258     int fd1 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS | O_EXCL_FS | O_TRUNC_FS, 0);
259     TEST_ASSERT_EQUAL_INT(-1, fd1);
260     int ret1 = UtilsFileClose(fd1);
261     TEST_ASSERT_EQUAL_INT(-1, ret1);
262     UtilsFileDelete(fileName);
263 };
264 
265 /**
266  * @tc.number    : SUB_UTILS_FILE_OPERATION_1300
267  * @tc.name      : File operation for file create and close with parameter APPEND and EXCL
268  * @tc.desc      : [C- SOFTWARE -0200]
269  */
270 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileCreateAndClose008, Function | MediumTest | Level1)
271 {
272     char* fileName = "testfile113";
273     int fd = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS | O_EXCL_FS | O_APPEND_FS, 0);
274     TEST_ASSERT_GREATER_THAN_INT(0, fd);
275     int ret = UtilsFileClose(fd);
276     TEST_ASSERT_EQUAL_INT(0, ret);
277     int fd1 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS | O_EXCL_FS | O_APPEND_FS, 0);
278     TEST_ASSERT_EQUAL_INT(-1, fd1);
279     int ret1 = UtilsFileClose(fd1);
280     TEST_ASSERT_EQUAL_INT(-1, ret1);
281     UtilsFileDelete(fileName);
282 };
283 
284 /**
285  * @tc.number    : SUB_UTILS_FILE_OPERATION_1400
286  * @tc.name      : File operation for file write
287  * @tc.desc      : [C- SOFTWARE -0200]
288  */
289 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileWrite001, Function | MediumTest | Level1)
290 {
291     char* fileName = "testfile114";
292     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
293     UtilsFileClose(fd0);
294     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
295     int ret = UtilsFileWrite(fd, g_def, strlen(g_def));
296     TEST_ASSERT_GREATER_THAN_INT(0, ret);
297     UtilsFileClose(fd);
298     UtilsFileDelete(fileName);
299 };
300 
301 /**
302  * @tc.number    : SUB_UTILS_FILE_OPERATION_1500
303  * @tc.name      : File write operation with parameter APPEND and TRUNC
304  * @tc.desc      : [C- SOFTWARE -0200]
305  */
306 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileWrite002, Function | MediumTest | Level1)
307 {
308     char* fileName = "testfile115";
309     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
310     UtilsFileWrite(fd0, g_def, strlen(g_def));
311     UtilsFileClose(fd0);
312     int fd = UtilsFileOpen(fileName, O_RDWR_FS | O_APPEND_FS, 0);
313     int ret = UtilsFileWrite(fd, g_def, strlen(g_def));
314     TEST_ASSERT_GREATER_THAN_INT(0, ret);
315     UtilsFileClose(fd);
316     int fd1 = UtilsFileOpen(fileName, O_RDWR_FS | O_TRUNC_FS, 0);
317     int ret1 = UtilsFileWrite(fd1, g_def, strlen(g_def));
318     TEST_ASSERT_GREATER_THAN_INT(0, ret1);
319     UtilsFileClose(fd1);
320     UtilsFileDelete(fileName);
321 };
322 
323 /**
324  * @tc.number    : SUB_UTILS_FILE_OPERATION_1600
325  * @tc.name      : Create file with long file name
326  * @tc.desc      : [C- SOFTWARE -0200]
327  */
328 LITE_TEST_CASE(UtilsFileFuncTestSuite, testCreateLongNameFile, Function | MediumTest | Level1)
329 {
330     char* fileName = "testLongFileName116-Ab123456789";
331     int fd = UtilsFileOpen(fileName, O_RDONLY_FS | O_CREAT_FS, 0);
332     TEST_ASSERT_GREATER_THAN_INT(0, fd);
333     UtilsFileClose(fd);
334     UtilsFileDelete(fileName);
335 };
336 
337 /**
338  * @tc.number    : SUB_UTILS_FILE_OPERATION_1800
339  * @tc.name      : Open none exist file
340  * @tc.desc      : [C- SOFTWARE -0200]
341  */
342 LITE_TEST_CASE(UtilsFileFuncTestSuite, testOpenNotExistFile, Function | MediumTest | Level1)
343 {
344     char* fileName = "fileNotExist118";
345     int fd = UtilsFileOpen(fileName, O_RDONLY_FS, 0);
346     TEST_ASSERT_EQUAL_INT(-1, fd);
347 };
348 
349 /**
350  * @tc.number    : SUB_UTILS_FILE_OPERATION_1900
351  * @tc.name      : Write none exist file
352  * @tc.desc      : [C- SOFTWARE -0200]
353  */
354 LITE_TEST_CASE(UtilsFileFuncTestSuite, testWriteNotExistFile, Function | MediumTest | Level1)
355 {
356     int fd = 1073;
357     int ret = UtilsFileWrite(fd, g_def, strlen(g_def));
358     TEST_ASSERT_EQUAL_INT(-1, ret);
359 };
360 
361 /**
362  * @tc.number    : SUB_UTILS_FILE_OPERATION_2000
363  * @tc.name      : Close none exist file
364  * @tc.desc      : [C- SOFTWARE -0200]
365  */
366 LITE_TEST_CASE(UtilsFileFuncTestSuite, testCloseNotExistFile, Function | MediumTest | Level1)
367 {
368     int fd = 1073;
369     int ret = UtilsFileClose(fd);
370     TEST_ASSERT_EQUAL_INT(-1, ret);
371 };
372 
373 /**
374  * @tc.number    : SUB_UTILS_FILE_OPERATION_2100
375  * @tc.name      : Create file with invalid long file name
376  * @tc.desc      : [C- SOFTWARE -0200]
377  */
378 LITE_TEST_CASE(UtilsFileFuncTestSuite, testCreateInvalidlongNameFile, Function | MediumTest | Level1)
379 {
380     char* fileName = "copyLongFileName403-Abcdefg123456789Abcdefg123456789Abcdefg123456789\
381                     Abcdefg123456789Abcdefg123456789";
382     int fd = UtilsFileOpen(fileName, O_RDONLY_FS | O_CREAT_FS, 0);
383     TEST_ASSERT_EQUAL_INT(-1, fd);
384 };
385 
386 /**
387  * @tc.number    : SUB_UTILS_FILE_OPERATION_2200
388  * @tc.name      : File operation for fileseek moved offset 20 from begin
389  * @tc.desc      : [C- SOFTWARE -0200]
390  */
391 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileSeek001, Function | MediumTest | Level1)
392 {
393     char* fileName = "testfile201";
394     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
395     UtilsFileWrite(fd0, g_def, strlen(g_def));
396     UtilsFileClose(fd0);
397     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
398     int ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_20, SEEK_SET_FS);
399     TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
400     UtilsFileClose(fd);
401     UtilsFileDelete(fileName);
402 };
403 
404 /**
405  * @tc.number    : SUB_UTILS_FILE_OPERATION_2300
406  * @tc.name      : File operation for fileseek moved offset 20 from current
407  * @tc.desc      : [C- SOFTWARE -0200]
408  */
409 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileSeek002, Function | MediumTest | Level1)
410 {
411     char* fileName = "testfile202";
412     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
413     UtilsFileWrite(fd0, g_def, strlen(g_def));
414     UtilsFileClose(fd0);
415     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
416     int ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_20, SEEK_CUR_FS);
417     TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
418     UtilsFileClose(fd);
419     UtilsFileDelete(fileName);
420 };
421 
422 /**
423  * @tc.number    : SUB_UTILS_FILE_OPERATION_2400
424  * @tc.name      : File operation for fileseek moved offset 20 backward from end
425  * @tc.desc      : [C- SOFTWARE -0200]
426  */
427 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileSeek003, Function | MediumTest | Level1)
428 {
429     char* fileName = "testfile203";
430     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
431     UtilsFileWrite(fd0, g_def, strlen(g_def));
432     UtilsFileClose(fd0);
433     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
434     int ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_MINUS_20, SEEK_END_FS);
435     TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
436     UtilsFileClose(fd);
437     UtilsFileDelete(fileName);
438 };
439 
440 /**
441  * @tc.number    : SUB_UTILS_FILE_OPERATION_2500
442  * @tc.name      : File operation for fileseek moved offset 50 from begin
443  * @tc.desc      : [C- SOFTWARE -0200]
444  */
445 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileSeek004, Function | MediumTest | Level1)
446 {
447     char* fileName = "testfile204";
448     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
449     UtilsFileWrite(fd0, g_def, strlen(g_def));
450     UtilsFileClose(fd0);
451     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
452     int ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_50, SEEK_SET_FS);
453     TEST_ASSERT_EQUAL_INT(-1, ret);
454     UtilsFileClose(fd);
455     UtilsFileDelete(fileName);
456 };
457 
458 /**
459  * @tc.number    : SUB_UTILS_FILE_OPERATION_2600
460  * @tc.name      : File operation for fileseek moved offset 50 from current
461  * @tc.desc      : [C- SOFTWARE -0200]
462  */
463 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileSeek005, Function | MediumTest | Level1)
464 {
465     char* fileName = "testfile205";
466     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
467     UtilsFileWrite(fd0, g_def, strlen(g_def));
468     UtilsFileClose(fd0);
469     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
470     int ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_50, SEEK_CUR_FS);
471     TEST_ASSERT_EQUAL_INT(-1, ret);
472     UtilsFileClose(fd);
473     UtilsFileDelete(fileName);
474 };
475 
476 /**
477  * @tc.number    : SUB_UTILS_FILE_OPERATION_2700
478  * @tc.name      : File operation for fileseek moved offset 50 backward from end
479  * @tc.desc      : [C- SOFTWARE -0200]
480  */
481 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileSeek006, Function | MediumTest | Level1)
482 {
483     char* fileName = "testfile206";
484     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
485     UtilsFileWrite(fd0, g_def, strlen(g_def));
486     UtilsFileClose(fd0);
487     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
488     int ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_MINUS_50, SEEK_END_FS);
489     TEST_ASSERT_EQUAL_INT(-1, ret);
490     UtilsFileClose(fd);
491     UtilsFileDelete(fileName);
492 };
493 
494 /**
495  * @tc.number    : SUB_UTILS_FILE_OPERATION_2800
496  * @tc.name      : File operation for fileseek moved offset 20 from begin, then moved offset 10 from current
497  * @tc.desc      : [C- SOFTWARE -0200]
498  */
499 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileSeek007, Function | MediumTest | Level1)
500 {
501     char* fileName = "testfile207";
502     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
503     UtilsFileWrite(fd0, g_def, strlen(g_def));
504     UtilsFileClose(fd0);
505     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
506     int ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_20, SEEK_SET_FS);
507     ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_10, SEEK_CUR_FS);
508     TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
509     UtilsFileClose(fd);
510     UtilsFileDelete(fileName);
511 };
512 
513 /**
514  * @tc.number    : SUB_UTILS_FILE_OPERATION_2900
515  * @tc.name      : File operation for fileseek moved offset 20 from begin, then moved offset 10 backward from current
516  * @tc.desc      : [C- SOFTWARE -0200]
517  */
518 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileSeek008, Function | MediumTest | Level1)
519 {
520     char* fileName = "testfile208";
521     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
522     UtilsFileWrite(fd0, g_def, strlen(g_def));
523     UtilsFileClose(fd0);
524     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
525     int ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_20, SEEK_SET_FS);
526     ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_MINUS_10, SEEK_CUR_FS);
527     TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
528     UtilsFileClose(fd);
529     UtilsFileDelete(fileName);
530 };
531 
532 /**
533  * @tc.number    : SUB_UTILS_FILE_OPERATION_3000
534  * @tc.name      : File operation for fileseek moved offset 20 from begin, then moved offset 50 from current
535  * @tc.desc      : [C- SOFTWARE -0200]
536  */
537 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileSeek009, Function | MediumTest | Level1)
538 {
539     char* fileName = "testfile209";
540     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
541     UtilsFileWrite(fd0, g_def, strlen(g_def));
542     UtilsFileClose(fd0);
543     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
544     int ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_20, SEEK_SET_FS);
545     ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_50, SEEK_CUR_FS);
546     TEST_ASSERT_EQUAL_INT(-1, ret);
547     UtilsFileClose(fd);
548     UtilsFileDelete(fileName);
549 };
550 
551 /**
552  * @tc.number    : SUB_UTILS_FILE_OPERATION_3100
553  * @tc.name      : File operation for fileseek moved offset 20 from begin, then moved offset 50 backward from current
554  * @tc.desc      : [C- SOFTWARE -0200]
555  */
556 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileSeek010, Function | MediumTest | Level1)
557 {
558     char* fileName = "testfile210";
559     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
560     UtilsFileWrite(fd0, g_def, strlen(g_def));
561     UtilsFileClose(fd0);
562     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
563     int ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_20, SEEK_SET_FS);
564     ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_MINUS_50, SEEK_CUR_FS);
565     TEST_ASSERT_EQUAL_INT(-1, ret);
566     UtilsFileClose(fd);
567     UtilsFileDelete(fileName);
568 };
569 
570 /**
571  * @tc.number    : SUB_UTILS_FILE_OPERATION_3200
572  * @tc.name      : File operation for fileseek moved multiples times
573  * @tc.desc      : [C- SOFTWARE -0200]
574  */
575 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileSeek011, Function | MediumTest | Level1)
576 {
577     char* fileName = "testfile211";
578     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
579     UtilsFileWrite(fd0, g_def, strlen(g_def));
580     UtilsFileClose(fd0);
581     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
582     int ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_20, SEEK_SET_FS);
583     ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_MINUS_50, SEEK_CUR_FS);
584     ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_MINUS_10, SEEK_CUR_FS);
585     TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
586     UtilsFileClose(fd);
587     UtilsFileDelete(fileName);
588 };
589 
590 /**
591  * @tc.number    : SUB_UTILS_FILE_OPERATION_3300
592  * @tc.name      : File seek for none exist file
593  * @tc.desc      : [C- SOFTWARE -0200]
594  */
595 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileSeekForNotExistFile, Function | MediumTest | Level1)
596 {
597     int fd = 1073;
598     int ret = UtilsFileSeek(fd, FILE_SEEK_OFFSET_20, SEEK_SET_FS);
599     TEST_ASSERT_EQUAL_INT(-1, ret);
600 };
601 
602 /**
603  * @tc.number    : SUB_UTILS_FILE_OPERATION_3400
604  * @tc.name      : Obtaining file size
605  * @tc.desc      : [C- SOFTWARE -0200]
606  */
607 LITE_TEST_CASE(UtilsFileFuncTestSuite, testObtainFileSize, Function | MediumTest | Level1)
608 {
609     char* fileName = "testfile301";
610     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
611     UtilsFileWrite(fd0, g_def, strlen(g_def));
612     UtilsFileClose(fd0);
613     unsigned int fileLen = 0;
614     int ret = UtilsFileStat(fileName, &fileLen);
615     TEST_ASSERT_EQUAL_INT(0, ret);
616     UtilsFileDelete(fileName);
617 };
618 
619 /**
620  * @tc.number    : SUB_UTILS_FILE_OPERATION_3500
621  * @tc.name      : Obtaining size for none exist file
622  * @tc.desc      : [C- SOFTWARE -0200]
623  */
624 LITE_TEST_CASE(UtilsFileFuncTestSuite, testObtainSizeForNotExistFile, Function | MediumTest | Level1)
625 {
626     char* fileName = "fileNotExist302";
627     unsigned int fileLen = 0;
628     int ret = UtilsFileStat(fileName, &fileLen);
629     TEST_ASSERT_EQUAL_INT(-1, ret);
630 };
631 
632 /**
633  * @tc.number    : SUB_UTILS_FILE_OPERATION_3600
634  * @tc.name      : File operation for file read
635  * @tc.desc      : [C- SOFTWARE -0200]
636  */
637 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileRead, Function | MediumTest | Level1)
638 {
639     char* fileName = "testfile303";
640     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
641     UtilsFileWrite(fd0, g_def, strlen(g_def));
642     UtilsFileClose(fd0);
643     char buf[LENGTH_OF_READ_BUF] = {0};
644     int fd = UtilsFileOpen(fileName, O_RDWR_FS, 0);
645     int ret = UtilsFileRead(fd, buf, LENGTH_OF_READ_BUF);
646     TEST_ASSERT_GREATER_OR_EQUAL_INT(0, ret);
647     UtilsFileClose(fd);
648     UtilsFileDelete(fileName);
649 };
650 
651 /**
652  * @tc.number    : SUB_UTILS_FILE_OPERATION_3700
653  * @tc.name      : Read none exist file
654  * @tc.desc      : [C- SOFTWARE -0200]
655  */
656 LITE_TEST_CASE(UtilsFileFuncTestSuite, testReadNotExistFile, Function | MediumTest | Level1)
657 {
658     char buf[LENGTH_OF_READ_BUF] = {0};
659     int fd = 1073;
660     int ret = UtilsFileRead(fd, buf, LENGTH_OF_READ_BUF);
661     TEST_ASSERT_EQUAL_INT(-1, ret);
662 };
663 
664 /**
665  * @tc.number    : SUB_UTILS_FILE_OPERATION_3800
666  * @tc.name      : Obtaining size for file with long file name
667  * @tc.desc      : [C- SOFTWARE -0200]
668  */
669 LITE_TEST_CASE(UtilsFileFuncTestSuite, testObtainLongNameFileSize, Function | MediumTest | Level1)
670 {
671     char* fileName = "testLongFileName305-Ab123456789";
672     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
673     UtilsFileWrite(fd0, g_def, strlen(g_def));
674     UtilsFileClose(fd0);
675     unsigned int fileLen = 0;
676     int ret = UtilsFileStat(fileName, &fileLen);
677     TEST_ASSERT_EQUAL_INT(0, ret);
678     UtilsFileDelete(fileName);
679 };
680 
681 /**
682  * @tc.number    : SUB_UTILS_FILE_OPERATION_4000
683  * @tc.name      : File operation for file copy
684  * @tc.desc      : [C- SOFTWARE -0200]
685  */
686 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileCopy, Function | MediumTest | Level1)
687 {
688     char* fileName = "testfile401";
689     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
690     UtilsFileWrite(fd0, g_def, strlen(g_def));
691     UtilsFileClose(fd0);
692     char* fileNameCopy = "copyFile401";
693     int ret = UtilsFileCopy(fileName, fileNameCopy);
694     TEST_ASSERT_EQUAL_INT(0, ret);
695     UtilsFileDelete(fileName);
696     UtilsFileDelete(fileNameCopy);
697 };
698 
699 /**
700  * @tc.number    : SUB_UTILS_FILE_OPERATION_4100
701  * @tc.name      : Copy none exist file
702  * @tc.desc      : [C- SOFTWARE -0200]
703  */
704 LITE_TEST_CASE(UtilsFileFuncTestSuite, testCopyNotExistFile, Function | MediumTest | Level1)
705 {
706     char* fileName = "fileNotExist402";
707     char* fileNameCopy = "copyFile402";
708     int ret = UtilsFileCopy(fileName, fileNameCopy);
709     TEST_ASSERT_EQUAL_INT(-1, ret);
710 };
711 
712 /**
713  * @tc.number    : SUB_UTILS_FILE_OPERATION_4200
714  * @tc.name      : Copy file with long file name
715  * @tc.desc      : [C- SOFTWARE -0200]
716  */
717 LITE_TEST_CASE(UtilsFileFuncTestSuite, testCopyLongNameFile, Function | MediumTest | Level1)
718 {
719     char* fileName = "testLongFileName403-Ab123456789";
720     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
721     UtilsFileWrite(fd0, g_def, strlen(g_def));
722     UtilsFileClose(fd0);
723     char* fileNameCopy = "copyLongFileName403-Ab123456789";
724     int ret = UtilsFileCopy(fileName, fileNameCopy);
725     TEST_ASSERT_EQUAL_INT(0, ret);
726     UtilsFileDelete(fileName);
727     UtilsFileDelete(fileNameCopy);
728 };
729 
730 /**
731  * @tc.number    : SUB_UTILS_FILE_OPERATION_4400
732  * @tc.name      : File operation for file move
733  * @tc.desc      : [C- SOFTWARE -0200]
734  */
735 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileMove, Function | MediumTest | Level1)
736 {
737     char* fileName = "testfile501";
738     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
739     UtilsFileWrite(fd0, g_def, strlen(g_def));
740     UtilsFileClose(fd0);
741     char* fileNameMove = "moveFile501";
742     int ret = UtilsFileMove(fileName, fileNameMove);
743     TEST_ASSERT_EQUAL_INT(0, ret);
744     UtilsFileDelete(fileNameMove);
745 };
746 
747 /**
748  * @tc.number    : SUB_UTILS_FILE_OPERATION_4500
749  * @tc.name      : Move none exist file
750  * @tc.desc      : [C- SOFTWARE -0200]
751  */
752 LITE_TEST_CASE(UtilsFileFuncTestSuite, testMoveNotExistFile, Function | MediumTest | Level1)
753 {
754     char* fileName = "fileNotExist502";
755     char* fileNameMove = "moveFile502";
756     int ret = UtilsFileMove(fileName, fileNameMove);
757     TEST_ASSERT_EQUAL_INT(-1, ret);
758 };
759 
760 /**
761  * @tc.number    : SUB_UTILS_FILE_OPERATION_4600
762  * @tc.name      : Move file with long file name
763  * @tc.desc      : [C- SOFTWARE -0200]
764  */
765 LITE_TEST_CASE(UtilsFileFuncTestSuite, testMoveLongNameFile, Function | MediumTest | Level1)
766 {
767     char* fileName = "testLongFileName503-Ab123456789";
768     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
769     UtilsFileWrite(fd0, g_def, strlen(g_def));
770     UtilsFileClose(fd0);
771     char* fileNameMove = "moveLongFileName503-Ab123456789";
772     int ret = UtilsFileMove(fileName, fileNameMove);
773     TEST_ASSERT_EQUAL_INT(0, ret);
774     UtilsFileDelete(fileNameMove);
775 };
776 
777 /**
778  * @tc.number    : SUB_UTILS_FILE_OPERATION_4800
779  * @tc.name      : File operation for file delete
780  * @tc.desc      : [C- SOFTWARE -0200]
781  */
782 LITE_TEST_CASE(UtilsFileFuncTestSuite, testFileDelete, Function | MediumTest | Level1)
783 {
784     char* fileName = "deleteFile601";
785     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
786     UtilsFileWrite(fd0, g_def, strlen(g_def));
787     UtilsFileClose(fd0);
788     int ret = UtilsFileDelete(fileName);
789     TEST_ASSERT_EQUAL_INT(0, ret);
790 };
791 
792 /**
793  * @tc.number    : SUB_UTILS_FILE_OPERATION_4900
794  * @tc.name      : Delete none exist file
795  * @tc.desc      : [C- SOFTWARE -0200]
796  */
797 LITE_TEST_CASE(UtilsFileFuncTestSuite, testDeleteNotExistFile, Function | MediumTest | Level1)
798 {
799     char* fileName = "fileNotExist602";
800     int ret = UtilsFileDelete(fileName);
801     TEST_ASSERT_EQUAL_INT(-1, ret);
802 };
803 
804 /**
805  * @tc.number    : SUB_UTILS_FILE_OPERATION_5000
806  * @tc.name      : Delete file with long file name
807  * @tc.desc      : [C- SOFTWARE -0200]
808  */
809 LITE_TEST_CASE(UtilsFileFuncTestSuite, testDeleteLongNameFile, Function | MediumTest | Level1)
810 {
811     char* fileName = "deleteLongFileName603-Ab1234567";
812     int fd0 = UtilsFileOpen(fileName, O_RDWR_FS | O_CREAT_FS, 0);
813     UtilsFileWrite(fd0, g_def, strlen(g_def));
814     UtilsFileClose(fd0);
815     int ret = UtilsFileDelete(fileName);
816     TEST_ASSERT_EQUAL_INT(0, ret);
817 };
818 
819 RUN_TEST_SUITE(UtilsFileFuncTestSuite);
820