Commit | Line | Data |
---|---|---|
6aeb981f CV |
1 | #include <stdio.h> |
2 | #include <stdlib.h> | |
3 | #include <string.h> | |
4 | #include <sys/errno.h> | |
5 | #include <sys/types.h> | |
6 | #include <sys/fcntl.h> | |
7 | #include <sys/stat.h> | |
8 | #include <sys/time.h> | |
b257a0d3 AC |
9 | #include <errno.h> |
10 | #include <sys/wait.h> | |
4d074752 | 11 | #include <unistd.h> |
b257a0d3 | 12 | /* TESTS : |
6aeb981f CV |
13 | * - open(const char *pathname, int flags, mode_t mode); |
14 | 1) Attempt to create file that already exists - EEXIST | |
15 | 2) Attempt to open a directory for writing - EISDIR | |
16 | 3) Pathname does not exist - ENOENT | |
17 | 4) Open for write but no write permission - EACCES | |
18 | ||
19 | read(int fd, void *buf, size_t count); | |
20 | 1) Read using invalid file descriptor - EBADF | |
21 | ||
22 | write(int fd, const void *buf, size_t count); | |
23 | 1) Write using invalid file descriptor - EBADF | |
24 | 2) Attempt to write to read-only file - EBADF | |
25 | ||
26 | lseek(int fildes, off_t offset, int whence); | |
27 | 1) Seeking on an invalid file descriptor - EBADF | |
28 | 2) Invalid "whence" (3rd param) value - EINVAL | |
29 | ||
30 | close(int fd); | |
31 | 1) Attempt to close an invalid file descriptor - EBADF | |
32 | ||
33 | stat(const char *file_name, struct stat *buf); | |
34 | 1) Pathname is a null string - ENOENT | |
35 | 2) Pathname does not exist - ENOENT | |
36 | ||
37 | fstat(int filedes, struct stat *buf); | |
38 | 1) Attempt to stat using an invalid file descriptor - EBADF | |
39 | ||
40 | isatty (int desc); | |
41 | Not applicable. We will test that it returns 1 when expected and a case | |
42 | where it should return 0. | |
43 | ||
44 | rename(const char *oldpath, const char *newpath); | |
45 | 1) newpath is an existing directory, but oldpath is not a directory. - EISDIR | |
46 | 2) newpath is a non-empty directory. - ENOTEMPTY or EEXIST | |
47 | 3) newpath is a subdirectory of old path. - EINVAL | |
48 | 4) oldpath does not exist. - ENOENT | |
49 | ||
50 | unlink(const char *pathname); | |
51 | 1) pathname does not have write access. - EACCES | |
52 | 2) pathname does not exist. - ENOENT | |
53 | ||
54 | time(time_t *t); | |
55 | Not applicable. | |
56 | ||
57 | system (const char * string); | |
9f5a4cef HZ |
58 | 1) See if shell available - returns 0 |
59 | 2) See if shell available - returns !0 | |
60 | 3) Execute simple shell command - returns 0 | |
61 | 4) Invalid string/command. - returns 127. */ | |
62 | ||
b257a0d3 | 63 | static const char *strerrno (int err); |
6aeb981f | 64 | |
b44b82af | 65 | /* Note that OUTDIR is defined by the test suite. */ |
6aeb981f CV |
66 | #define FILENAME "foo.fileio.test" |
67 | #define RENAMED "bar.fileio.test" | |
68 | #define NONEXISTANT "nofoo.fileio.test" | |
69 | #define NOWRITE "nowrt.fileio.test" | |
6aeb981f CV |
70 | #define TESTDIR1 "dir1.fileio.test" |
71 | #define TESTDIR2 "dir2.fileio.test" | |
72 | #define TESTSUBDIR "dir1.fileio.test/subdir.fileio.test" | |
73 | ||
74 | #define STRING "Hello World" | |
75 | ||
e1c2defa NS |
76 | static void stop () {} |
77 | ||
6aeb981f CV |
78 | int |
79 | test_open () | |
80 | { | |
81 | int ret; | |
82 | ||
83 | /* Test opening */ | |
84 | errno = 0; | |
b44b82af | 85 | ret = open (OUTDIR FILENAME, O_CREAT | O_TRUNC | O_RDWR, S_IWUSR | S_IRUSR); |
6aeb981f CV |
86 | printf ("open 1: ret = %d, errno = %d %s\n", ret, errno, |
87 | ret >= 0 ? "OK" : ""); | |
e1c2defa | 88 | |
6aeb981f CV |
89 | if (ret >= 0) |
90 | close (ret); | |
e1c2defa | 91 | stop (); |
6aeb981f CV |
92 | /* Creating an already existing file (created by fileio.exp) */ |
93 | errno = 0; | |
b44b82af | 94 | ret = open (OUTDIR FILENAME, O_CREAT | O_EXCL | O_WRONLY, S_IWUSR | S_IRUSR); |
6aeb981f | 95 | printf ("open 2: ret = %d, errno = %d %s\n", ret, errno, |
b257a0d3 | 96 | strerrno (errno)); |
6aeb981f CV |
97 | if (ret >= 0) |
98 | close (ret); | |
e1c2defa | 99 | stop (); |
6aeb981f CV |
100 | /* Open directory (for writing) */ |
101 | errno = 0; | |
102 | ret = open (".", O_WRONLY); | |
103 | printf ("open 3: ret = %d, errno = %d %s\n", ret, errno, | |
b257a0d3 | 104 | strerrno (errno)); |
6aeb981f CV |
105 | if (ret >= 0) |
106 | close (ret); | |
e1c2defa | 107 | stop (); |
6aeb981f CV |
108 | /* Opening nonexistant file */ |
109 | errno = 0; | |
110 | ret = open (NONEXISTANT, O_RDONLY); | |
111 | printf ("open 4: ret = %d, errno = %d %s\n", ret, errno, | |
b257a0d3 | 112 | strerrno (errno)); |
6aeb981f CV |
113 | if (ret >= 0) |
114 | close (ret); | |
e1c2defa | 115 | stop (); |
6aeb981f CV |
116 | /* Open for write but no write permission */ |
117 | errno = 0; | |
b44b82af | 118 | ret = open (OUTDIR NOWRITE, O_CREAT | O_RDONLY, S_IRUSR); |
6aeb981f CV |
119 | if (ret >= 0) |
120 | { | |
121 | close (ret); | |
e1c2defa | 122 | stop (); |
6aeb981f | 123 | errno = 0; |
b44b82af | 124 | ret = open (OUTDIR NOWRITE, O_WRONLY); |
6aeb981f | 125 | printf ("open 5: ret = %d, errno = %d %s\n", ret, errno, |
b257a0d3 | 126 | strerrno (errno)); |
6aeb981f CV |
127 | if (ret >= 0) |
128 | close (ret); | |
129 | } | |
130 | else | |
e1c2defa NS |
131 | { |
132 | stop (); | |
133 | printf ("open 5: ret = %d, errno = %d\n", ret, errno); | |
134 | } | |
135 | stop (); | |
6aeb981f CV |
136 | } |
137 | ||
138 | int | |
139 | test_write () | |
140 | { | |
141 | int fd, ret; | |
142 | ||
143 | /* Test writing */ | |
144 | errno = 0; | |
b44b82af | 145 | fd = open (OUTDIR FILENAME, O_WRONLY); |
6aeb981f CV |
146 | if (fd >= 0) |
147 | { | |
148 | errno = 0; | |
149 | ret = write (fd, STRING, strlen (STRING)); | |
150 | printf ("write 1: ret = %d, errno = %d %s\n", ret, errno, | |
151 | ret == strlen (STRING) ? "OK" : ""); | |
152 | close (fd); | |
153 | } | |
154 | else | |
155 | printf ("write 1: ret = %d, errno = %d\n", ret, errno); | |
e1c2defa | 156 | stop (); |
6aeb981f CV |
157 | /* Write using invalid file descriptor */ |
158 | errno = 0; | |
159 | ret = write (999, STRING, strlen (STRING)); | |
160 | printf ("write 2: ret = %d, errno = %d, %s\n", ret, errno, | |
b257a0d3 | 161 | strerrno (errno)); |
e1c2defa | 162 | stop (); |
6aeb981f CV |
163 | /* Write to a read-only file */ |
164 | errno = 0; | |
b44b82af | 165 | fd = open (OUTDIR FILENAME, O_RDONLY); |
6aeb981f CV |
166 | if (fd >= 0) |
167 | { | |
168 | errno = 0; | |
169 | ret = write (fd, STRING, strlen (STRING)); | |
170 | printf ("write 3: ret = %d, errno = %d %s\n", ret, errno, | |
b257a0d3 | 171 | strerrno (errno)); |
6aeb981f CV |
172 | } |
173 | else | |
174 | printf ("write 3: ret = %d, errno = %d\n", ret, errno); | |
e1c2defa | 175 | stop (); |
6aeb981f CV |
176 | } |
177 | ||
178 | int | |
179 | test_read () | |
180 | { | |
181 | int fd, ret; | |
182 | char buf[16]; | |
183 | ||
184 | /* Test reading */ | |
185 | errno = 0; | |
b44b82af | 186 | fd = open (OUTDIR FILENAME, O_RDONLY); |
6aeb981f CV |
187 | if (fd >= 0) |
188 | { | |
189 | memset (buf, 0, 16); | |
190 | errno = 0; | |
191 | ret = read (fd, buf, 16); | |
192 | buf[15] = '\0'; /* Don't trust anybody... */ | |
193 | if (ret == strlen (STRING)) | |
194 | printf ("read 1: %s %s\n", buf, !strcmp (buf, STRING) ? "OK" : ""); | |
195 | else | |
196 | printf ("read 1: ret = %d, errno = %d\n", ret, errno); | |
197 | close (fd); | |
198 | } | |
199 | else | |
200 | printf ("read 1: ret = %d, errno = %d\n", ret, errno); | |
e1c2defa | 201 | stop (); |
6aeb981f CV |
202 | /* Read using invalid file descriptor */ |
203 | errno = 0; | |
204 | ret = read (999, buf, 16); | |
205 | printf ("read 2: ret = %d, errno = %d %s\n", ret, errno, | |
b257a0d3 | 206 | strerrno (errno)); |
e1c2defa | 207 | stop (); |
6aeb981f CV |
208 | } |
209 | ||
210 | int | |
211 | test_lseek () | |
212 | { | |
213 | int fd; | |
b257a0d3 | 214 | off_t ret = 0; |
6aeb981f CV |
215 | |
216 | /* Test seeking */ | |
217 | errno = 0; | |
b44b82af | 218 | fd = open (OUTDIR FILENAME, O_RDONLY); |
6aeb981f CV |
219 | if (fd >= 0) |
220 | { | |
221 | errno = 0; | |
222 | ret = lseek (fd, 0, SEEK_CUR); | |
b257a0d3 | 223 | printf ("lseek 1: ret = %ld, errno = %d, %s\n", (long) ret, errno, |
6aeb981f | 224 | ret == 0 ? "OK" : ""); |
e1c2defa | 225 | stop (); |
6aeb981f CV |
226 | errno = 0; |
227 | ret = lseek (fd, 0, SEEK_END); | |
b257a0d3 | 228 | printf ("lseek 2: ret = %ld, errno = %d, %s\n", (long) ret, errno, |
6aeb981f | 229 | ret == 11 ? "OK" : ""); |
e1c2defa | 230 | stop (); |
6aeb981f CV |
231 | errno = 0; |
232 | ret = lseek (fd, 3, SEEK_SET); | |
b257a0d3 | 233 | printf ("lseek 3: ret = %ld, errno = %d, %s\n", (long) ret, errno, |
6aeb981f CV |
234 | ret == 3 ? "OK" : ""); |
235 | close (fd); | |
236 | } | |
237 | else | |
238 | { | |
209f53f5 | 239 | printf ("lseek 1: ret = %ld, errno = %d %s\n", (long) ret, errno, |
e1c2defa NS |
240 | strerrno (errno)); |
241 | stop (); | |
209f53f5 | 242 | printf ("lseek 2: ret = %ld, errno = %d %s\n", (long) ret, errno, |
e1c2defa NS |
243 | strerrno (errno)); |
244 | stop (); | |
209f53f5 | 245 | printf ("lseek 3: ret = %ld, errno = %d %s\n", (long) ret, errno, |
e1c2defa | 246 | strerrno (errno)); |
6aeb981f CV |
247 | } |
248 | /* Seeking on an invalid file descriptor */ | |
e1c2defa | 249 | stop (); |
6aeb981f CV |
250 | } |
251 | ||
252 | int | |
253 | test_close () | |
254 | { | |
255 | int fd, ret; | |
256 | ||
257 | /* Test close */ | |
258 | errno = 0; | |
b44b82af | 259 | fd = open (OUTDIR FILENAME, O_RDONLY); |
6aeb981f CV |
260 | if (fd >= 0) |
261 | { | |
262 | errno = 0; | |
263 | ret = close (fd); | |
b257a0d3 | 264 | printf ("close 1: ret = %d, errno = %d, %s\n", ret, errno, |
6aeb981f CV |
265 | ret == 0 ? "OK" : ""); |
266 | } | |
267 | else | |
268 | printf ("close 1: ret = %d, errno = %d\n", ret, errno); | |
e1c2defa | 269 | stop (); |
6aeb981f CV |
270 | /* Close an invalid file descriptor */ |
271 | errno = 0; | |
272 | ret = close (999); | |
b257a0d3 AC |
273 | printf ("close 2: ret = %d, errno = %d, %s\n", ret, errno, |
274 | strerrno (errno)); | |
e1c2defa | 275 | stop (); |
6aeb981f CV |
276 | } |
277 | ||
278 | int | |
279 | test_stat () | |
280 | { | |
281 | int ret; | |
282 | struct stat st; | |
283 | ||
284 | /* Test stat */ | |
285 | errno = 0; | |
b44b82af | 286 | ret = stat (OUTDIR FILENAME, &st); |
6aeb981f CV |
287 | if (!ret) |
288 | printf ("stat 1: ret = %d, errno = %d %s\n", ret, errno, | |
289 | st.st_size == 11 ? "OK" : ""); | |
290 | else | |
291 | printf ("stat 1: ret = %d, errno = %d\n", ret, errno); | |
e1c2defa | 292 | stop (); |
6aeb981f CV |
293 | /* NULL pathname */ |
294 | errno = 0; | |
295 | ret = stat (NULL, &st); | |
296 | printf ("stat 2: ret = %d, errno = %d %s\n", ret, errno, | |
b257a0d3 | 297 | strerrno (errno)); |
e1c2defa | 298 | stop (); |
6aeb981f CV |
299 | /* Empty pathname */ |
300 | errno = 0; | |
301 | ret = stat ("", &st); | |
302 | printf ("stat 3: ret = %d, errno = %d %s\n", ret, errno, | |
b257a0d3 | 303 | strerrno (errno)); |
e1c2defa | 304 | stop (); |
6aeb981f CV |
305 | /* Nonexistant file */ |
306 | errno = 0; | |
307 | ret = stat (NONEXISTANT, &st); | |
308 | printf ("stat 4: ret = %d, errno = %d %s\n", ret, errno, | |
b257a0d3 | 309 | strerrno (errno)); |
e1c2defa | 310 | stop (); |
6aeb981f CV |
311 | } |
312 | ||
313 | int | |
314 | test_fstat () | |
315 | { | |
316 | int fd, ret; | |
317 | struct stat st; | |
318 | ||
319 | /* Test fstat */ | |
320 | errno = 0; | |
b44b82af | 321 | fd = open (OUTDIR FILENAME, O_RDONLY); |
6aeb981f CV |
322 | if (fd >= 0) |
323 | { | |
324 | errno = 0; | |
325 | ret = fstat (fd, &st); | |
326 | if (!ret) | |
327 | printf ("fstat 1: ret = %d, errno = %d %s\n", ret, errno, | |
328 | st.st_size == 11 ? "OK" : ""); | |
329 | else | |
330 | printf ("fstat 1: ret = %d, errno = %d\n", ret, errno); | |
331 | close (fd); | |
332 | } | |
333 | else | |
334 | printf ("fstat 1: ret = %d, errno = %d\n", ret, errno); | |
e1c2defa | 335 | stop (); |
6aeb981f CV |
336 | /* Fstat using invalid file descriptor */ |
337 | errno = 0; | |
338 | ret = fstat (999, &st); | |
339 | printf ("fstat 2: ret = %d, errno = %d %s\n", ret, errno, | |
b257a0d3 | 340 | strerrno (errno)); |
e1c2defa | 341 | stop (); |
6aeb981f CV |
342 | } |
343 | ||
344 | int | |
345 | test_isatty () | |
346 | { | |
347 | int fd; | |
348 | ||
349 | /* Check std I/O */ | |
350 | printf ("isatty 1: stdin %s\n", isatty (0) ? "yes OK" : "no"); | |
e1c2defa | 351 | stop (); |
6aeb981f | 352 | printf ("isatty 2: stdout %s\n", isatty (1) ? "yes OK" : "no"); |
e1c2defa | 353 | stop (); |
6aeb981f | 354 | printf ("isatty 3: stderr %s\n", isatty (2) ? "yes OK" : "no"); |
e1c2defa | 355 | stop (); |
6aeb981f CV |
356 | /* Check invalid fd */ |
357 | printf ("isatty 4: invalid %s\n", isatty (999) ? "yes" : "no OK"); | |
e1c2defa | 358 | stop (); |
6aeb981f | 359 | /* Check open file */ |
b44b82af | 360 | fd = open (OUTDIR FILENAME, O_RDONLY); |
6aeb981f CV |
361 | if (fd >= 0) |
362 | { | |
363 | printf ("isatty 5: file %s\n", isatty (fd) ? "yes" : "no OK"); | |
364 | close (fd); | |
365 | } | |
366 | else | |
367 | printf ("isatty 5: file couldn't open\n"); | |
e1c2defa | 368 | stop (); |
6aeb981f CV |
369 | } |
370 | ||
b257a0d3 | 371 | |
b44b82af TT |
372 | char sys[1512]; |
373 | ||
6aeb981f CV |
374 | int |
375 | test_system () | |
376 | { | |
377 | /* | |
378 | * Requires test framework to switch on "set remote system-call-allowed 1" | |
379 | */ | |
380 | int ret; | |
6aeb981f | 381 | |
9f5a4cef HZ |
382 | /* Test for shell ('set remote system-call-allowed' is disabled |
383 | by default). */ | |
384 | ret = system (NULL); | |
385 | printf ("system 1: ret = %d %s\n", ret, ret == 0 ? "OK" : ""); | |
386 | stop (); | |
387 | /* Test for shell again (the testsuite will have enabled it now). */ | |
5600ea19 | 388 | ret = system (NULL); |
9f5a4cef | 389 | printf ("system 2: ret = %d %s\n", ret, ret != 0 ? "OK" : ""); |
5600ea19 | 390 | stop (); |
6aeb981f | 391 | /* This test prepares the directory for test_rename() */ |
b44b82af | 392 | sprintf (sys, "mkdir -p %s/%s %s/%s", OUTDIR, TESTSUBDIR, OUTDIR, TESTDIR2); |
6aeb981f CV |
393 | ret = system (sys); |
394 | if (ret == 127) | |
9f5a4cef | 395 | printf ("system 3: ret = %d /bin/sh unavailable???\n", ret); |
6aeb981f | 396 | else |
9f5a4cef | 397 | printf ("system 3: ret = %d %s\n", ret, ret == 0 ? "OK" : ""); |
e1c2defa | 398 | stop (); |
6aeb981f CV |
399 | /* Invalid command (just guessing ;-) ) */ |
400 | ret = system ("wrtzlpfrmpft"); | |
9f5a4cef HZ |
401 | printf ("system 4: ret = %d %s\n", ret, |
402 | WEXITSTATUS (ret) == 127 ? "OK" : ""); | |
e1c2defa | 403 | stop (); |
6aeb981f CV |
404 | } |
405 | ||
406 | int | |
407 | test_rename () | |
408 | { | |
409 | int ret; | |
410 | struct stat st; | |
411 | ||
412 | /* Test rename */ | |
413 | errno = 0; | |
b44b82af | 414 | ret = rename (OUTDIR FILENAME, OUTDIR RENAMED); |
6aeb981f CV |
415 | if (!ret) |
416 | { | |
417 | errno = 0; | |
418 | ret = stat (FILENAME, &st); | |
419 | if (ret && errno == ENOENT) | |
420 | { | |
421 | errno = 0; | |
b44b82af | 422 | ret = stat (OUTDIR RENAMED, &st); |
6aeb981f | 423 | printf ("rename 1: ret = %d, errno = %d %s\n", ret, errno, |
b257a0d3 | 424 | strerrno (errno)); |
6aeb981f CV |
425 | errno = 0; |
426 | } | |
427 | else | |
428 | printf ("rename 1: ret = %d, errno = %d\n", ret, errno); | |
429 | } | |
430 | else | |
431 | printf ("rename 1: ret = %d, errno = %d\n", ret, errno); | |
e1c2defa | 432 | stop (); |
6aeb981f CV |
433 | /* newpath is existing directory, oldpath is not a directory */ |
434 | errno = 0; | |
b44b82af | 435 | ret = rename (OUTDIR RENAMED, OUTDIR TESTDIR2); |
6aeb981f | 436 | printf ("rename 2: ret = %d, errno = %d %s\n", ret, errno, |
b257a0d3 | 437 | strerrno (errno)); |
e1c2defa | 438 | stop (); |
6aeb981f CV |
439 | /* newpath is a non-empty directory */ |
440 | errno = 0; | |
b44b82af | 441 | ret = rename (OUTDIR TESTDIR2, OUTDIR TESTDIR1); |
6aeb981f | 442 | printf ("rename 3: ret = %d, errno = %d %s\n", ret, errno, |
b257a0d3 | 443 | strerrno (errno)); |
e1c2defa | 444 | stop (); |
6aeb981f CV |
445 | /* newpath is a subdirectory of old path */ |
446 | errno = 0; | |
b44b82af | 447 | ret = rename (OUTDIR TESTDIR1, OUTDIR TESTSUBDIR); |
6aeb981f | 448 | printf ("rename 4: ret = %d, errno = %d %s\n", ret, errno, |
b257a0d3 | 449 | strerrno (errno)); |
e1c2defa | 450 | stop (); |
6aeb981f CV |
451 | /* oldpath does not exist */ |
452 | errno = 0; | |
b44b82af | 453 | ret = rename (OUTDIR NONEXISTANT, OUTDIR FILENAME); |
6aeb981f | 454 | printf ("rename 5: ret = %d, errno = %d %s\n", ret, errno, |
b257a0d3 | 455 | strerrno (errno)); |
e1c2defa | 456 | stop (); |
6aeb981f CV |
457 | } |
458 | ||
b44b82af TT |
459 | char name[1256]; |
460 | ||
6aeb981f CV |
461 | int |
462 | test_unlink () | |
463 | { | |
464 | int ret; | |
6aeb981f CV |
465 | |
466 | /* Test unlink */ | |
467 | errno = 0; | |
b44b82af | 468 | ret = unlink (OUTDIR RENAMED); |
6aeb981f | 469 | printf ("unlink 1: ret = %d, errno = %d %s\n", ret, errno, |
b257a0d3 | 470 | strerrno (errno)); |
e1c2defa | 471 | stop (); |
6aeb981f | 472 | /* No write access */ |
b44b82af | 473 | sprintf (name, "%s/%s/%s", OUTDIR, TESTDIR2, FILENAME); |
6aeb981f CV |
474 | errno = 0; |
475 | ret = open (name, O_CREAT | O_RDONLY, S_IRUSR | S_IWUSR); | |
476 | if (ret >= 0) | |
477 | { | |
b44b82af | 478 | sprintf (sys, "chmod -w %s/%s", OUTDIR, TESTDIR2); |
6aeb981f CV |
479 | ret = system (sys); |
480 | if (!ret) | |
481 | { | |
482 | errno = 0; | |
483 | ret = unlink (name); | |
484 | printf ("unlink 2: ret = %d, errno = %d %s\n", ret, errno, | |
b257a0d3 | 485 | strerrno (errno)); |
6aeb981f CV |
486 | } |
487 | else | |
209f53f5 | 488 | printf ("unlink 2: ret = %d chmod failed, errno= %d\n", ret, errno); |
6aeb981f CV |
489 | } |
490 | else | |
491 | printf ("unlink 2: ret = %d, errno = %d\n", ret, errno); | |
e1c2defa | 492 | stop (); |
6aeb981f CV |
493 | /* pathname doesn't exist */ |
494 | errno = 0; | |
b44b82af | 495 | ret = unlink (OUTDIR NONEXISTANT); |
6aeb981f | 496 | printf ("unlink 3: ret = %d, errno = %d %s\n", ret, errno, |
b257a0d3 | 497 | strerrno (errno)); |
e1c2defa | 498 | stop (); |
6aeb981f CV |
499 | } |
500 | ||
501 | int | |
502 | test_time () | |
503 | { | |
504 | time_t ret, t; | |
505 | ||
506 | errno = 0; | |
507 | ret = time (&t); | |
b257a0d3 | 508 | printf ("time 1: ret = %ld, errno = %d, t = %ld %s\n", (long) ret, errno, (long) t, ret == t ? "OK" : ""); |
e1c2defa | 509 | stop (); |
6aeb981f CV |
510 | errno = 0; |
511 | ret = time (NULL); | |
b257a0d3 AC |
512 | printf ("time 2: ret = %ld, errno = %d, t = %ld %s\n", |
513 | (long) ret, errno, (long) t, ret >= t && ret < t + 10 ? "OK" : ""); | |
e1c2defa | 514 | stop (); |
b257a0d3 AC |
515 | } |
516 | ||
517 | static const char * | |
518 | strerrno (int err) | |
519 | { | |
520 | switch (err) | |
521 | { | |
522 | case 0: return "OK"; | |
523 | #ifdef EACCES | |
524 | case EACCES: return "EACCES"; | |
525 | #endif | |
526 | #ifdef EBADF | |
527 | case EBADF: return "EBADF"; | |
528 | #endif | |
529 | #ifdef EEXIST | |
530 | case EEXIST: return "EEXIST"; | |
531 | #endif | |
532 | #ifdef EFAULT | |
533 | case EFAULT: return "EFAULT"; | |
534 | #endif | |
535 | #ifdef EINVAL | |
536 | case EINVAL: return "EINVAL"; | |
537 | #endif | |
538 | #ifdef EISDIR | |
539 | case EISDIR: return "EISDIR"; | |
540 | #endif | |
541 | #ifdef ENOENT | |
542 | case ENOENT: return "ENOENT"; | |
543 | #endif | |
544 | #ifdef ENOTEMPTY | |
545 | case ENOTEMPTY: return "ENOTEMPTY"; | |
60ad077b AC |
546 | #endif |
547 | #ifdef EBUSY | |
548 | case EBUSY: return "EBUSY"; | |
b257a0d3 AC |
549 | #endif |
550 | default: return "E??"; | |
551 | } | |
6aeb981f CV |
552 | } |
553 | ||
554 | int | |
555 | main () | |
556 | { | |
557 | /* Don't change the order of the calls. They partly depend on each other */ | |
558 | test_open (); | |
559 | test_write (); | |
560 | test_read (); | |
561 | test_lseek (); | |
562 | test_close (); | |
563 | test_stat (); | |
564 | test_fstat (); | |
565 | test_isatty (); | |
566 | test_system (); | |
567 | test_rename (); | |
568 | test_unlink (); | |
569 | test_time (); | |
570 | return 0; | |
571 | } |