1 /*
2 * Copyright (c) 2022 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 <sys/stat.h>
17 #include <sys/wait.h>
18 #include <stdlib.h>
19 #include "functionalext.h"
20
21 typedef void (*TEST_FUN)();
22 const int32_t NUM_ZERO = 0;
23 const int32_t NUM_TEN = 10;
24 const int32_t NUM_TWENTY = 20;
25
26 /**
27 * @tc.name : fread_0100
28 * @tc.desc : Verify that the number of data read is less than the number of data in the file
29 * @tc.level : Level 0
30 */
fread_0100(void)31 void fread_0100(void)
32 {
33 char abc[100] = {0};
34 const char *wrstring = "starttowritehelloworld";
35 const char *ptr = "/data/Freadtest.txt";
36 FILE *fptr = fopen(ptr, "w+");
37 EXPECT_PTRNE("fread_0100", fptr, NULL);
38
39 fwrite(wrstring, sizeof(char), strlen(wrstring), fptr);
40 fseek(fptr, 0, SEEK_SET);
41
42 size_t rsize = fread(abc, 1, 10, fptr);
43 EXPECT_EQ("fread_0100", rsize, 10);
44 EXPECT_STREQ("fread_0100", abc, "starttowri");
45
46 fclose(fptr);
47 remove(ptr);
48 }
49
50 /**
51 * @tc.name : fread_0200
52 * @tc.desc : Verify that the number of data read is greater than the number of data in the file
53 * @tc.level : Level 1
54 */
fread_0200(void)55 void fread_0200(void)
56 {
57 char abc[100] = {0};
58 const char *wrstring = "startwritehelloworld";
59 const char *ptr = "/data/Freadtest.txt";
60
61 FILE *fptr = fopen(ptr, "w+");
62 EXPECT_PTRNE("fread_0200", fptr, NULL);
63
64 fwrite(wrstring, sizeof(char), strlen(wrstring), fptr);
65 fseek(fptr, 0, SEEK_SET);
66
67 size_t rsize = fread(abc, 1, 25, fptr);
68 EXPECT_EQ("fread_0200", rsize, 20);
69 EXPECT_STREQ("fread_0200", abc, wrstring);
70
71 fclose(fptr);
72 remove(ptr);
73 }
74
75 /**
76 * @tc.name : fread_0300
77 * @tc.desc : Verify that the number of data read is greater than the number of data in the file
78 * (the file pointer is at the end)
79 * @tc.level : Level 2
80 */
fread_0300(void)81 void fread_0300(void)
82 {
83 char abc[100] = {0};
84 const char *wrstring = "startwritehelloworld";
85 const char *ptr = "/data/Freadtest.txt";
86 FILE *fptr = fopen(ptr, "w+");
87 EXPECT_PTRNE("fread_0200", fptr, NULL);
88
89 fwrite(wrstring, sizeof(char), strlen(wrstring), fptr);
90 fseek(fptr, 0, SEEK_END);
91 size_t rsize = fread(abc, 1, 10, fptr);
92 EXPECT_EQ("fread_0300", rsize, 0);
93
94 fclose(fptr);
95 remove(ptr);
96 }
97
98 /**
99 * @tc.name : fread_0400
100 * @tc.desc : Verify that the size parameter is invalid and cannot read the specified file content
101 * @tc.level : Level 2
102 */
fread_0400(void)103 void fread_0400(void)
104 {
105 char abc[100] = {0};
106 const char *wrstring = "startwritehelloworld";
107 const char *ptr = "/data/Freadtest.txt";
108 FILE *fptr = fopen(ptr, "w+");
109 EXPECT_PTRNE("fread_0200", fptr, NULL);
110
111 fwrite(wrstring, sizeof(char), strlen(wrstring), fptr);
112 fseek(fptr, 0, SEEK_END);
113
114 size_t rsize = fread(abc, 0, 10, fptr);
115 EXPECT_EQ("fread_0400", rsize, 0);
116
117 fclose(fptr);
118 remove(ptr);
119 }
120
121 /**
122 * @tc.name : fread_0500
123 * @tc.desc : Verify that the return value of syscall have been processed correctly
124 * @tc.level : Level 2
125 */
126 #define FREAD_0500_BUFSZ (4097)
fread_0500(void)127 void fread_0500(void)
128 {
129 pid_t pid = fork();
130 if (pid == -1) {
131 perror("fread_0500 fork:");
132 exit(-1);
133 }
134
135 /* child */
136 if (pid == 0) {
137 /* make sure parent opening the status file */
138 sleep(1);
139 exit(-1);
140 }
141
142 char buf[FREAD_0500_BUFSZ] = {0};
143 sprintf(buf, "/proc/%d/status", pid);
144 FILE *fStatus = fopen(buf, "rb");
145 EXPECT_PTRNE("fread_0500", fStatus, NULL);
146
147 /* wait child exit, and status file of child will disappear */
148 int status = 0;
149 pid_t w = wait(&status);
150
151 /* read >4K data from file, check if return correctly */
152 size_t rsize = fread(buf, 1, FREAD_0500_BUFSZ, fStatus);
153 EXPECT_EQ("fread_0500", rsize, 0);
154 fclose(fStatus);
155 }
156
157 #define ARRAY_SIZE_1026 (1026)
158 #define BUFFER_SIZE_1026 (1026)
159 #define READ_LENGTH (20)
160 #define SEEK_OFFSET (1006)
161 #define BUFFER_SIZE_1024 (1024)
162 #define ZERO (0)
163
fread_0600()164 void fread_0600()
165 {
166 char myArray[ARRAY_SIZE_1026] = {};
167 memset(myArray, '3', ARRAY_SIZE_1026);
168 myArray[ARRAY_SIZE_1026 - 2] = '1';
169 myArray[ARRAY_SIZE_1026 - 1] = '2';
170
171 // 使用fmemopen获取FILE*指针
172 FILE *fp = fmemopen(myArray, sizeof(myArray), "r");
173 if (fp == NULL) {
174 t_error("fmemopen failed");
175 }
176
177 // 使用fread读取FILE*指针
178 char *buffer = (char *)malloc((BUFFER_SIZE_1026 + 1) * sizeof(char));
179 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
180 char result1[READ_LENGTH + 1] = {};
181 memset(result1, '3', READ_LENGTH);
182 result1[READ_LENGTH] = '\0';
183
184 char result2[READ_LENGTH + 1] = {};
185 memset(result2, '3', READ_LENGTH);
186 result2[READ_LENGTH - 2] = '1';
187 result2[READ_LENGTH - 1] = '2';
188 result2[READ_LENGTH] = '\0';
189
190 char result3[BUFFER_SIZE_1024 + 1] = {};
191 memset(result3, '3', BUFFER_SIZE_1024 * sizeof(char));
192 result3[BUFFER_SIZE_1024] = '\0';
193
194 // read 20 bytes from fp
195 fseek(fp, ZERO, SEEK_SET);
196 size_t bytesRead = fread(buffer, 1, READ_LENGTH, fp);
197 buffer[bytesRead] = '\0';
198 EXPECT_STREQ("fread_0600 point 1", buffer, result1);
199
200 // read 20 bytes from fp
201 fseek(fp, ZERO, SEEK_SET);
202 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
203 bytesRead = fread(buffer, READ_LENGTH, 1, fp);
204 buffer[READ_LENGTH] = '\0';
205 EXPECT_STREQ("fread_0600 point 2", buffer, result1);
206
207 // read 20 bytes from fp, start from 1006
208 fseek(fp, SEEK_OFFSET, SEEK_SET);
209 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
210 bytesRead = fread(buffer, 1, READ_LENGTH, fp);
211 buffer[bytesRead] = '\0';
212 EXPECT_STREQ("fread_0600 point 3 from 1006", buffer, result2);
213
214 // read 1024 bytes from fp
215 fseek(fp, ZERO, SEEK_SET);
216 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
217 bytesRead = fread(buffer, 1, BUFFER_SIZE_1024, fp);
218 buffer[bytesRead] = '\0';
219 EXPECT_STREQ("fread_0600 point 4 read 1024", buffer, result3);
220
221 // read 1026 bytes from fp
222 fseek(fp, ZERO, SEEK_SET);
223 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
224 bytesRead = fread(buffer, 1, BUFFER_SIZE_1026, fp);
225 buffer[bytesRead] = '\0';
226 EXPECT_STREQ("fread_0600 point 5 read 1026", buffer, myArray);
227
228 free(buffer);
229 fclose(fp);
230 }
231
fread_0700()232 void fread_0700()
233 {
234 char myArray[ARRAY_SIZE_1026] = {};
235 memset(myArray, '3', ARRAY_SIZE_1026);
236 myArray[ARRAY_SIZE_1026 - 2] = '1';
237 myArray[ARRAY_SIZE_1026 - 1] = '2';
238
239 // 使用fmemopen获取FILE*指针
240 FILE *fp = fmemopen(myArray, sizeof(myArray), "r");
241 if (fp == NULL) {
242 t_error("fmemopen failed");
243 }
244
245 char *fpBuffer = (char *)malloc((BUFFER_SIZE_1026 + 1) * sizeof(char));
246 int result = setvbuf(fp, fpBuffer, _IOFBF, BUFFER_SIZE_1026);
247 if (result != ZERO) {
248 t_error("fread_0700 servbuf failed errno=", errno);
249 }
250
251 // 使用fread读取FILE*指针
252 char *buffer = (char *)malloc((BUFFER_SIZE_1026 + 1) * sizeof(char));
253 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
254 char result1[READ_LENGTH + 1] = {};
255 memset(result1, '3', READ_LENGTH);
256 result1[READ_LENGTH] = '\0';
257
258 char result2[READ_LENGTH + 1] = {};
259 memset(result2, '3', READ_LENGTH);
260 result2[READ_LENGTH - 2] = '1';
261 result2[READ_LENGTH - 1] = '2';
262 result2[READ_LENGTH] = '\0';
263
264 char result3[BUFFER_SIZE_1024 + 1] = {};
265 memset(result3, '3', BUFFER_SIZE_1024 * sizeof(char));
266 result3[BUFFER_SIZE_1024] = '\0';
267
268 // read 20 bytes from fp
269 fseek(fp, ZERO, SEEK_SET);
270 size_t bytesRead = fread(buffer, 1, READ_LENGTH, fp);
271 buffer[bytesRead] = '\0';
272 EXPECT_STREQ("fread_0700 point 1", buffer, result1);
273
274 // read 20 bytes from fp
275 fseek(fp, ZERO, SEEK_SET);
276 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
277 bytesRead = fread(buffer, READ_LENGTH, 1, fp);
278 buffer[READ_LENGTH] = '\0';
279 EXPECT_STREQ("fread_0700 point 2", buffer, result1);
280
281 // read 20 bytes from fp, start from 1006
282 fseek(fp, SEEK_OFFSET, SEEK_SET);
283 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
284 bytesRead = fread(buffer, 1, READ_LENGTH, fp);
285 buffer[bytesRead] = '\0';
286 EXPECT_STREQ("fread_0700 point 3 from 1006", buffer, result2);
287
288 // read 1024 bytes from fp
289 fseek(fp, ZERO, SEEK_SET);
290 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
291 bytesRead = fread(buffer, 1, BUFFER_SIZE_1024, fp);
292 buffer[bytesRead] = '\0';
293 EXPECT_STREQ("fread_0700 point 4 read 1024", buffer, result3);
294
295 // read 1026 bytes from fp
296 fseek(fp, ZERO, SEEK_SET);
297 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
298 bytesRead = fread(buffer, 1, BUFFER_SIZE_1026, fp);
299 buffer[bytesRead] = '\0';
300 EXPECT_STREQ("fread_0700 point 5 read 1026", buffer, myArray);
301
302 free(buffer);
303 fclose(fp);
304 free(fpBuffer);
305 }
306
fread_0800()307 void fread_0800()
308 {
309 char myArray[ARRAY_SIZE_1026] = {};
310 memset(myArray, '3', ARRAY_SIZE_1026);
311 myArray[ARRAY_SIZE_1026 - 2] = '1';
312 myArray[ARRAY_SIZE_1026 - 1] = '2';
313
314 // 使用fmemopen获取FILE*指针
315 FILE *fp = fmemopen(myArray, sizeof(myArray), "r");
316 if (fp == NULL) {
317 t_error("fmemopen failed");
318 }
319
320 int result = setvbuf(fp, NULL, _IONBF, 0);
321 if (result != ZERO) {
322 t_error("fread_0700 servbuf failed errno=", errno);
323 }
324
325 // 使用fread读取FILE*指针
326 char *buffer = (char *)malloc((BUFFER_SIZE_1026 + 1) * sizeof(char));
327 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
328 char result1[READ_LENGTH + 1] = {};
329 memset(result1, '3', READ_LENGTH);
330 result1[READ_LENGTH] = '\0';
331
332 char result2[READ_LENGTH + 1] = {};
333 memset(result2, '3', READ_LENGTH);
334 result2[READ_LENGTH - 2] = '1';
335 result2[READ_LENGTH - 1] = '2';
336 result2[READ_LENGTH] = '\0';
337
338 char result3[BUFFER_SIZE_1024 + 1] = {};
339 memset(result3, '3', BUFFER_SIZE_1024 * sizeof(char));
340 result3[BUFFER_SIZE_1024] = '\0';
341
342 // read 20 bytes from fp
343 fseek(fp, ZERO, SEEK_SET);
344 size_t bytesRead = fread(buffer, 1, READ_LENGTH, fp);
345 buffer[bytesRead] = '\0';
346 EXPECT_STREQ("fread_0700 point 1", buffer, result1);
347
348 // read 20 bytes from fp
349 fseek(fp, ZERO, SEEK_SET);
350 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
351 bytesRead = fread(buffer, READ_LENGTH, 1, fp);
352 buffer[READ_LENGTH] = '\0';
353 EXPECT_STREQ("fread_0700 point 2", buffer, result1);
354
355 // read 20 bytes from fp, start from 1006
356 fseek(fp, SEEK_OFFSET, SEEK_SET);
357 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
358 bytesRead = fread(buffer, 1, READ_LENGTH, fp);
359 buffer[bytesRead] = '\0';
360 EXPECT_STREQ("fread_0700 point 3 from 1006", buffer, result2);
361
362 // read 1024 bytes from fp
363 fseek(fp, ZERO, SEEK_SET);
364 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
365 bytesRead = fread(buffer, 1, BUFFER_SIZE_1024, fp);
366 buffer[bytesRead] = '\0';
367 EXPECT_STREQ("fread_0700 point 4 read 1024", buffer, result3);
368
369 // read 1026 bytes from fp
370 fseek(fp, ZERO, SEEK_SET);
371 memset(buffer, ZERO, BUFFER_SIZE_1026 * sizeof(char));
372 bytesRead = fread(buffer, 1, BUFFER_SIZE_1026, fp);
373 buffer[bytesRead] = '\0';
374 EXPECT_STREQ("fread_0700 point 5 read 1026", buffer, myArray);
375
376 free(buffer);
377 fclose(fp);
378 }
379
380 TEST_FUN G_Fun_Array[] = {
381 fread_0100,
382 fread_0200,
383 fread_0300,
384 fread_0400,
385 fread_0500,
386 fread_0600,
387 fread_0700,
388 fread_0800,
389 };
390
main(int argc,char * argv[])391 int main(int argc, char *argv[])
392 {
393 int num = sizeof(G_Fun_Array) / sizeof(TEST_FUN);
394 for (int pos = 0; pos < num; ++pos) {
395 G_Fun_Array[pos]();
396 }
397
398 return t_status;
399 }
400