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