source: trunk/src/sed/gnulib-tests/test-rename.h@ 3669

Last change on this file since 3669 was 3611, checked in by bird, 10 months ago

vendor/sed/current: GNU sed 4.9 (sed-4.9.tar.xz sha256:6e226b732e1cd739464ad6862bd1a1aba42d7982922da7a53519631d24975181)
File size: 25.6 KB
Line 
1/* Test of rename() function.
2 Copyright (C) 2009-2022 Free Software Foundation, Inc.
3
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <https://www.gnu.org/licenses/>. */
16
17/* This file is designed to test both rename(a,b) and
18 renameat(AT_FDCWD,a,AT_FDCWD,b). FUNC is the function to test.
19 Assumes that BASE and ASSERT are already defined, and that
20 appropriate headers are already included. If PRINT, warn before
21 skipping symlink tests with status 77. */
22
23/* Tests whether a file, given by a file name without slashes, exists in
24 the current directory, by scanning the directory entries. */
25static bool
26dentry_exists (const char *filename)
27{
28 bool exists = false;
29 DIR *dir = opendir (".");
30
31 ASSERT (dir != NULL);
32 for (;;)
33 {
34 struct dirent *d = readdir (dir);
35 if (d == NULL)
36 break;
37 if (strcmp (d->d_name, filename) == 0)
38 {
39 exists = true;
40 break;
41 }
42 }
43 ASSERT (closedir (dir) == 0);
44 return exists;
45}
46
47/* Asserts that a specific file, given by a file name without slashes, does
48 not exist in the current directory. */
49static void
50assert_nonexistent (const char *filename)
51{
52 struct stat st;
53
54 /* The usual way to test the presence of a file is via stat() or lstat(). */
55 errno = 0;
56 if (stat (filename, &st) == -1)
57 ASSERT (errno == ENOENT);
58 else
59 {
60 /* But after renaming a directory over an empty directory on an NFS-
61 mounted file system, on Linux 2.6.18, for a period of 30 seconds the
62 old directory name is "present" according to stat() but "nonexistent"
63 according to dentry_exists(). */
64 ASSERT (!dentry_exists (filename));
65 /* Remove the old directory name, so that subsequent mkdir calls
66 succeed. */
67 (void) rmdir (filename);
68 }
69}
70
71static int
72test_rename (int (*func) (char const *, char const *), bool print)
73{
74 /* Setup. */
75 struct stat st;
76 int fd = creat (BASE "file", 0600);
77 ASSERT (0 <= fd);
78 ASSERT (write (fd, "hi", 2) == 2);
79 ASSERT (close (fd) == 0);
80 ASSERT (mkdir (BASE "dir", 0700) == 0);
81
82 /* Files present here:
83 {BASE}file
84 {BASE}dir/
85 */
86
87 /* Obvious errors. */
88
89 { /* Missing source. */
90 {
91 errno = 0;
92 ASSERT (func (BASE "missing", BASE "missing") == -1);
93 ASSERT (errno == ENOENT);
94 }
95 {
96 errno = 0;
97 ASSERT (func (BASE "missing/", BASE "missing") == -1);
98 ASSERT (errno == ENOENT);
99 }
100 {
101 errno = 0;
102 ASSERT (func (BASE "missing", BASE "missing/") == -1);
103 ASSERT (errno == ENOENT);
104 }
105 }
106 { /* Empty operand. */
107 {
108 errno = 0;
109 ASSERT (func ("", BASE "missing") == -1);
110 ASSERT (errno == ENOENT);
111 }
112 {
113 errno = 0;
114 ASSERT (func (BASE "file", "") == -1);
115 ASSERT (errno == ENOENT);
116 }
117 {
118 errno = 0;
119 ASSERT (func (BASE "", "") == -1);
120 ASSERT (errno == ENOENT);
121 }
122 }
123
124 /* Files. */
125
126 { /* Trailing slash. */
127 {
128 errno = 0;
129 ASSERT (func (BASE "file", BASE "file2/") == -1);
130 ASSERT (errno == ENOENT || errno == ENOTDIR);
131 }
132 {
133 errno = 0;
134 ASSERT (func (BASE "file/", BASE "file2") == -1);
135 ASSERT (errno == ENOTDIR);
136 }
137 {
138 errno = 0;
139 ASSERT (stat (BASE "file2", &st) == -1);
140 ASSERT (errno == ENOENT);
141 }
142 }
143 { /* Simple rename. */
144 ASSERT (func (BASE "file", BASE "file2") == 0);
145 errno = 0;
146 ASSERT (stat (BASE "file", &st) == -1);
147 ASSERT (errno == ENOENT);
148 memset (&st, 0, sizeof st);
149 ASSERT (stat (BASE "file2", &st) == 0);
150 ASSERT (st.st_size == 2);
151 }
152 /* Files present here:
153 {BASE}file2
154 {BASE}dir/
155 */
156 { /* Overwrite. */
157 ASSERT (close (creat (BASE "file", 0600)) == 0);
158 errno = 0;
159 ASSERT (func (BASE "file2", BASE "file/") == -1);
160 ASSERT (errno == ENOTDIR);
161 ASSERT (func (BASE "file2", BASE "file") == 0);
162 memset (&st, 0, sizeof st);
163 ASSERT (stat (BASE "file", &st) == 0);
164 ASSERT (st.st_size == 2);
165 errno = 0;
166 ASSERT (stat (BASE "file2", &st) == -1);
167 ASSERT (errno == ENOENT);
168 }
169 /* Files present here:
170 {BASE}file
171 {BASE}dir/
172 */
173
174 /* Directories. */
175
176 { /* Simple rename. */
177 {
178 ASSERT (func (BASE "dir", BASE "dir2/") == 0);
179 errno = 0;
180 ASSERT (stat (BASE "dir", &st) == -1);
181 ASSERT (errno == ENOENT);
182 ASSERT (stat (BASE "dir2", &st) == 0);
183 }
184 /* Files present here:
185 {BASE}file
186 {BASE}dir2/
187 */
188 {
189 ASSERT (func (BASE "dir2/", BASE "dir") == 0);
190 ASSERT (stat (BASE "dir", &st) == 0);
191 errno = 0;
192 ASSERT (stat (BASE "dir2", &st) == -1);
193 ASSERT (errno == ENOENT);
194 }
195 /* Files present here:
196 {BASE}file
197 {BASE}dir/
198 */
199 {
200 ASSERT (func (BASE "dir", BASE "dir2") == 0);
201 errno = 0;
202 ASSERT (stat (BASE "dir", &st) == -1);
203 ASSERT (errno == ENOENT);
204 ASSERT (stat (BASE "dir2", &st) == 0);
205 }
206 /* Files present here:
207 {BASE}file
208 {BASE}dir2/
209 */
210 { /* Empty onto empty. */
211 ASSERT (mkdir (BASE "dir", 0700) == 0);
212 /* Files present here:
213 {BASE}file
214 {BASE}dir/
215 {BASE}dir2/
216 */
217 ASSERT (func (BASE "dir2", BASE "dir") == 0);
218 /* Files present here:
219 {BASE}file
220 {BASE}dir/
221 */
222 ASSERT (mkdir (BASE "dir2", 0700) == 0);
223 /* Files present here:
224 {BASE}file
225 {BASE}dir/
226 {BASE}dir2/
227 */
228 ASSERT (func (BASE "dir2", BASE "dir/") == 0);
229 /* Files present here:
230 {BASE}file
231 {BASE}dir/
232 */
233 ASSERT (mkdir (BASE "dir2", 0700) == 0);
234 /* Files present here:
235 {BASE}file
236 {BASE}dir/
237 {BASE}dir2/
238 */
239 ASSERT (func (BASE "dir2/", BASE "dir") == 0);
240 /* Files present here:
241 {BASE}file
242 {BASE}dir/
243 */
244 ASSERT (mkdir (BASE "dir2", 0700) == 0);
245 }
246 /* Files present here:
247 {BASE}file
248 {BASE}dir/
249 {BASE}dir2/
250 */
251 { /* Empty onto full. */
252 ASSERT (close (creat (BASE "dir/file", 0600)) == 0);
253 /* Files present here:
254 {BASE}file
255 {BASE}dir/
256 {BASE}dir/file
257 {BASE}dir2/
258 */
259 {
260 errno = 0;
261 ASSERT (func (BASE "dir2", BASE "dir") == -1);
262 ASSERT (errno == EEXIST || errno == ENOTEMPTY);
263 }
264 {
265 errno = 0;
266 ASSERT (func (BASE "dir2/", BASE "dir") == -1);
267 ASSERT (errno == EEXIST || errno == ENOTEMPTY);
268 }
269 {
270 errno = 0;
271 ASSERT (func (BASE "dir2", BASE "dir/") == -1);
272 ASSERT (errno == EEXIST || errno == ENOTEMPTY);
273 }
274 }
275 { /* Full onto empty. */
276 ASSERT (func (BASE "dir", BASE "dir2") == 0);
277 assert_nonexistent (BASE "dir");
278 ASSERT (stat (BASE "dir2/file", &st) == 0);
279 /* Files present here:
280 {BASE}file
281 {BASE}dir2/
282 {BASE}dir2/file
283 */
284 ASSERT (mkdir (BASE "dir", 0700) == 0);
285 /* Files present here:
286 {BASE}file
287 {BASE}dir/
288 {BASE}dir2/
289 {BASE}dir2/file
290 */
291 {
292 ASSERT (func (BASE "dir2/", BASE "dir") == 0);
293 ASSERT (stat (BASE "dir/file", &st) == 0);
294 errno = 0;
295 ASSERT (stat (BASE "dir2", &st) == -1);
296 ASSERT (errno == ENOENT);
297 }
298 /* Files present here:
299 {BASE}file
300 {BASE}dir/
301 {BASE}dir/file
302 */
303 ASSERT (mkdir (BASE "dir2", 0700) == 0);
304 /* Files present here:
305 {BASE}file
306 {BASE}dir/
307 {BASE}dir/file
308 {BASE}dir2/
309 */
310 {
311 ASSERT (func (BASE "dir", BASE "dir2/") == 0);
312 assert_nonexistent (BASE "dir");
313 ASSERT (stat (BASE "dir2/file", &st) == 0);
314 }
315 /* Files present here:
316 {BASE}file
317 {BASE}dir2/
318 {BASE}dir2/file
319 */
320 ASSERT (unlink (BASE "dir2/file") == 0);
321 }
322 /* Files present here:
323 {BASE}file
324 {BASE}dir2/
325 */
326 { /* Reject trailing dot. */
327 {
328 errno = 0;
329 ASSERT (func (BASE "dir2", BASE "dir/.") == -1);
330 ASSERT (errno == EINVAL || errno == ENOENT);
331 }
332 ASSERT (mkdir (BASE "dir", 0700) == 0);
333 /* Files present here:
334 {BASE}file
335 {BASE}dir/
336 {BASE}dir2/
337 */
338 {
339 errno = 0;
340 ASSERT (func (BASE "dir2", BASE "dir/.") == -1);
341 ASSERT (errno == EINVAL || errno == EBUSY || errno == EISDIR
342 || errno == ENOTEMPTY || errno == EEXIST
343 || errno == ENOENT /* WSL */);
344 }
345 {
346 errno = 0;
347 ASSERT (func (BASE "dir2/.", BASE "dir") == -1);
348 ASSERT (errno == EINVAL || errno == EBUSY || errno == EEXIST
349 || errno == ENOENT /* WSL */);
350 }
351 ASSERT (rmdir (BASE "dir") == 0);
352 /* Files present here:
353 {BASE}file
354 {BASE}dir2/
355 */
356 {
357 errno = 0;
358 ASSERT (func (BASE "dir2", BASE "dir/.//") == -1);
359 ASSERT (errno == EINVAL || errno == ENOENT);
360 }
361 ASSERT (mkdir (BASE "dir", 0700) == 0);
362 /* Files present here:
363 {BASE}file
364 {BASE}dir/
365 {BASE}dir2/
366 */
367 {
368 errno = 0;
369 ASSERT (func (BASE "dir2", BASE "dir/.//") == -1);
370 ASSERT (errno == EINVAL || errno == EBUSY || errno == EISDIR
371 || errno == ENOTEMPTY || errno == EEXIST
372 || errno == ENOENT /* WSL */);
373 }
374 {
375 errno = 0;
376 ASSERT (func (BASE "dir2/.//", BASE "dir") == -1);
377 ASSERT (errno == EINVAL || errno == EBUSY || errno == EEXIST
378 || errno == ENOENT /* WSL */);
379 }
380 ASSERT (rmdir (BASE "dir2") == 0);
381 /* Files present here:
382 {BASE}file
383 {BASE}dir/
384 */
385 }
386 { /* Move into subdir. */
387 {
388 errno = 0;
389 ASSERT (func (BASE "dir", BASE "dir/sub") == -1);
390 ASSERT (errno == EINVAL || errno == EACCES);
391 }
392 {
393 errno = 0;
394 ASSERT (stat (BASE "dir/sub", &st) == -1);
395 ASSERT (errno == ENOENT);
396 }
397 ASSERT (mkdir (BASE "dir/sub", 0700) == 0);
398 /* Files present here:
399 {BASE}file
400 {BASE}dir/
401 {BASE}dir/sub/
402 */
403 {
404 errno = 0;
405 ASSERT (func (BASE "dir", BASE "dir/sub") == -1);
406 ASSERT (errno == EINVAL);
407 ASSERT (stat (BASE "dir/sub", &st) == 0);
408 }
409 ASSERT (rmdir (BASE "dir/sub") == 0);
410 }
411 }
412 /* Files present here:
413 {BASE}file
414 {BASE}dir/
415 */
416
417 /* Mixing file and directory. */
418
419 {
420 { /* File onto dir. */
421 {
422 errno = 0;
423 ASSERT (func (BASE "file", BASE "dir") == -1);
424 ASSERT (errno == EISDIR || errno == ENOTDIR);
425 }
426 {
427 errno = 0;
428 ASSERT (func (BASE "file", BASE "dir/") == -1);
429 ASSERT (errno == EISDIR || errno == ENOTDIR);
430 }
431 }
432 { /* Dir onto file. */
433 {
434 errno = 0;
435 ASSERT (func (BASE "dir", BASE "file") == -1);
436 ASSERT (errno == ENOTDIR);
437 }
438 {
439 errno = 0;
440 ASSERT (func (BASE "dir/", BASE "file") == -1);
441 ASSERT (errno == ENOTDIR);
442 }
443 }
444 }
445
446 /* Hard links. */
447
448 { /* File onto self. */
449 ASSERT (func (BASE "file", BASE "file") == 0);
450 memset (&st, 0, sizeof st);
451 ASSERT (stat (BASE "file", &st) == 0);
452 ASSERT (st.st_size == 2);
453 }
454 /* Files present here:
455 {BASE}file
456 {BASE}dir/
457 */
458 { /* Empty dir onto self. */
459 ASSERT (func (BASE "dir", BASE "dir") == 0);
460 ASSERT (stat (BASE "dir", &st) == 0);
461 }
462 /* Files present here:
463 {BASE}file
464 {BASE}dir/
465 */
466 ASSERT (close (creat (BASE "dir/file", 0600)) == 0);
467 /* Files present here:
468 {BASE}file
469 {BASE}dir/
470 {BASE}dir/file
471 */
472 { /* Full dir onto self. */
473 ASSERT (func (BASE "dir", BASE "dir") == 0);
474 }
475 ASSERT (unlink (BASE "dir/file") == 0);
476 /* Files present here:
477 {BASE}file
478 {BASE}dir/
479 */
480 {
481 /* Not all file systems support link. Mingw doesn't have
482 reliable st_nlink on hard links, but our implementation does
483 fail with EPERM on poor file systems, and we can detect the
484 inferior stat() via st_ino. Cygwin 1.5.x copies rather than
485 links files on those file systems, but there, st_nlink and
486 st_ino are reliable. */
487 int ret = link (BASE "file", BASE "file2");
488 if (!ret)
489 {
490 memset (&st, 0, sizeof st);
491 ASSERT (stat (BASE "file2", &st) == 0);
492 if (st.st_ino && st.st_nlink != 2)
493 {
494 ASSERT (unlink (BASE "file2") == 0);
495 errno = EPERM;
496 ret = -1;
497 }
498 }
499 if (ret == -1)
500 {
501 /* If the device does not support hard links, errno is
502 EPERM on Linux, EOPNOTSUPP on FreeBSD. */
503 switch (errno)
504 {
505 case EPERM:
506 case EOPNOTSUPP:
507 if (print)
508 fputs ("skipping test: "
509 "hard links not supported on this file system\n",
510 stderr);
511 ASSERT (unlink (BASE "file") == 0);
512 ASSERT (rmdir (BASE "dir") == 0);
513 return 77;
514 default:
515 perror ("link");
516 return 1;
517 }
518 }
519 ASSERT (ret == 0);
520 }
521 /* Files present here:
522 {BASE}file
523 {BASE}file2 (hard link to file)
524 {BASE}dir/
525 */
526 { /* File onto hard link. */
527 ASSERT (func (BASE "file", BASE "file2") == 0);
528 memset (&st, 0, sizeof st);
529 if (stat (BASE "file", &st) != 0)
530 {
531 /* This can happen on NetBSD. */
532 ASSERT (errno == ENOENT);
533 ASSERT (link (BASE "file2", BASE "file") == 0);
534 ASSERT (stat (BASE "file", &st) == 0);
535 }
536 ASSERT (st.st_size == 2);
537 memset (&st, 0, sizeof st);
538 ASSERT (stat (BASE "file2", &st) == 0);
539 ASSERT (st.st_size == 2);
540 }
541 /* Files present here:
542 {BASE}file
543 {BASE}file2
544 {BASE}dir/
545 */
546 ASSERT (unlink (BASE "file2") == 0);
547 /* Files present here:
548 {BASE}file
549 {BASE}dir/
550 */
551
552 /* Symlinks. */
553
554 if (symlink (BASE "file", BASE "link1"))
555 {
556 if (print)
557 fputs ("skipping test: symlinks not supported on this file system\n",
558 stderr);
559 ASSERT (unlink (BASE "file") == 0);
560 ASSERT (rmdir (BASE "dir") == 0);
561 return 77;
562 }
563 /* Files present here:
564 {BASE}file
565 {BASE}link1 -> {BASE}file
566 {BASE}dir/
567 */
568 { /* Simple rename. */
569 ASSERT (func (BASE "link1", BASE "link2") == 0);
570 ASSERT (stat (BASE "file", &st) == 0);
571 errno = 0;
572 ASSERT (lstat (BASE "link1", &st) == -1);
573 ASSERT (errno == ENOENT);
574 memset (&st, 0, sizeof st);
575 ASSERT (lstat (BASE "link2", &st) == 0);
576 ASSERT (S_ISLNK (st.st_mode));
577 }
578 /* Files present here:
579 {BASE}file
580 {BASE}link2 -> {BASE}file
581 {BASE}dir/
582 */
583 { /* Overwrite. */
584 ASSERT (symlink (BASE "nowhere", BASE "link1") == 0);
585 /* Files present here:
586 {BASE}file
587 {BASE}link1 -> {BASE}nowhere
588 {BASE}link2 -> {BASE}file
589 {BASE}dir/
590 */
591 {
592 ASSERT (func (BASE "link2", BASE "link1") == 0);
593 memset (&st, 0, sizeof st);
594 ASSERT (stat (BASE "link1", &st) == 0);
595 ASSERT (st.st_size == 2);
596 errno = 0;
597 ASSERT (lstat (BASE "link2", &st) == -1);
598 ASSERT (errno == ENOENT);
599 }
600 }
601 /* Files present here:
602 {BASE}file
603 {BASE}link1 -> {BASE}file
604 {BASE}dir/
605 */
606 { /* Symlink loop. */
607 ASSERT (symlink (BASE "link2", BASE "link2") == 0);
608 /* Files present here:
609 {BASE}file
610 {BASE}link1 -> {BASE}file
611 {BASE}link2 -> {BASE}link2
612 {BASE}dir/
613 */
614 {
615 ASSERT (func (BASE "link2", BASE "link2") == 0);
616 }
617 {
618 errno = 0;
619 ASSERT (func (BASE "link2/", BASE "link2") == -1);
620 ASSERT (errno == ELOOP || errno == ENOTDIR);
621 }
622 ASSERT (func (BASE "link2", BASE "link3") == 0);
623 /* Files present here:
624 {BASE}file
625 {BASE}link1 -> {BASE}file
626 {BASE}link3 -> {BASE}link2
627 {BASE}dir/
628 */
629 ASSERT (unlink (BASE "link3") == 0);
630 }
631 /* Files present here:
632 {BASE}file
633 {BASE}link1 -> {BASE}file
634 {BASE}dir/
635 */
636 { /* Dangling link. */
637 ASSERT (symlink (BASE "nowhere", BASE "link2") == 0);
638 /* Files present here:
639 {BASE}file
640 {BASE}link1 -> {BASE}file
641 {BASE}link2 -> {BASE}nowhere
642 {BASE}dir/
643 */
644 {
645 ASSERT (func (BASE "link2", BASE "link3") == 0);
646 errno = 0;
647 ASSERT (lstat (BASE "link2", &st) == -1);
648 ASSERT (errno == ENOENT);
649 memset (&st, 0, sizeof st);
650 ASSERT (lstat (BASE "link3", &st) == 0);
651 }
652 }
653 /* Files present here:
654 {BASE}file
655 {BASE}link1 -> {BASE}file
656 {BASE}link3 -> {BASE}nowhere
657 {BASE}dir/
658 */
659 { /* Trailing slash on dangling. */
660 {
661 errno = 0;
662 ASSERT (func (BASE "link3/", BASE "link2") == -1);
663 ASSERT (errno == ENOENT || errno == ENOTDIR);
664 }
665 {
666 errno = 0;
667 ASSERT (func (BASE "link3", BASE "link2/") == -1);
668 ASSERT (errno == ENOENT || errno == ENOTDIR);
669 }
670 {
671 errno = 0;
672 ASSERT (lstat (BASE "link2", &st) == -1);
673 ASSERT (errno == ENOENT);
674 }
675 memset (&st, 0, sizeof st);
676 ASSERT (lstat (BASE "link3", &st) == 0);
677 }
678 /* Files present here:
679 {BASE}file
680 {BASE}link1 -> {BASE}file
681 {BASE}link3 -> {BASE}nowhere
682 {BASE}dir/
683 */
684 { /* Trailing slash on link to file. */
685 {
686 errno = 0;
687 ASSERT (func (BASE "link1/", BASE "link2") == -1);
688 ASSERT (errno == ENOTDIR);
689 }
690 {
691 errno = 0;
692 ASSERT (func (BASE "link1", BASE "link3/") == -1);
693 ASSERT (errno == ENOENT || errno == ENOTDIR);
694 }
695 }
696 /* Files present here:
697 {BASE}file
698 {BASE}link1 -> {BASE}file
699 {BASE}link3 -> {BASE}nowhere
700 {BASE}dir/
701 */
702
703 /* Mixing symlink and file. */
704
705 { /* File onto link. */
706 ASSERT (close (creat (BASE "file2", 0600)) == 0);
707 /* Files present here:
708 {BASE}file
709 {BASE}file2
710 {BASE}link1 -> {BASE}file
711 {BASE}link3 -> {BASE}nowhere
712 {BASE}dir/
713 */
714 {
715 ASSERT (func (BASE "file2", BASE "link3") == 0);
716 errno = 0;
717 ASSERT (stat (BASE "file2", &st) == -1);
718 ASSERT (errno == ENOENT);
719 memset (&st, 0, sizeof st);
720 ASSERT (lstat (BASE "link3", &st) == 0);
721 ASSERT (S_ISREG (st.st_mode));
722 }
723 /* Files present here:
724 {BASE}file
725 {BASE}link1 -> {BASE}file
726 {BASE}link3
727 {BASE}dir/
728 */
729 ASSERT (unlink (BASE "link3") == 0);
730 }
731 /* Files present here:
732 {BASE}file
733 {BASE}link1 -> {BASE}file
734 {BASE}dir/
735 */
736 { /* Link onto file. */
737 ASSERT (symlink (BASE "nowhere", BASE "link2") == 0);
738 /* Files present here:
739 {BASE}file
740 {BASE}link1 -> {BASE}file
741 {BASE}link2 -> {BASE}nowhere
742 {BASE}dir/
743 */
744 ASSERT (close (creat (BASE "file2", 0600)) == 0);
745 /* Files present here:
746 {BASE}file
747 {BASE}file2
748 {BASE}link1 -> {BASE}file
749 {BASE}link2 -> {BASE}nowhere
750 {BASE}dir/
751 */
752 {
753 ASSERT (func (BASE "link2", BASE "file2") == 0);
754 errno = 0;
755 ASSERT (lstat (BASE "link2", &st) == -1);
756 ASSERT (errno == ENOENT);
757 memset (&st, 0, sizeof st);
758 ASSERT (lstat (BASE "file2", &st) == 0);
759 ASSERT (S_ISLNK (st.st_mode));
760 }
761 /* Files present here:
762 {BASE}file
763 {BASE}file2 -> {BASE}nowhere
764 {BASE}link1 -> {BASE}file
765 {BASE}dir/
766 */
767 ASSERT (unlink (BASE "file2") == 0);
768 }
769 /* Files present here:
770 {BASE}file
771 {BASE}link1 -> {BASE}file
772 {BASE}dir/
773 */
774 { /* Trailing slash. */
775 {
776 errno = 0;
777 ASSERT (func (BASE "file/", BASE "link1") == -1);
778 ASSERT (errno == ENOTDIR);
779 }
780 {
781 errno = 0;
782 ASSERT (func (BASE "file", BASE "link1/") == -1);
783 ASSERT (errno == ENOTDIR || errno == ENOENT);
784 }
785 {
786 errno = 0;
787 ASSERT (func (BASE "link1/", BASE "file") == -1);
788 ASSERT (errno == ENOTDIR);
789 }
790 {
791 errno = 0;
792 ASSERT (func (BASE "link1", BASE "file/") == -1);
793 ASSERT (errno == ENOTDIR || errno == ENOENT);
794 memset (&st, 0, sizeof st);
795 ASSERT (lstat (BASE "file", &st) == 0);
796 ASSERT (S_ISREG (st.st_mode));
797 memset (&st, 0, sizeof st);
798 ASSERT (lstat (BASE "link1", &st) == 0);
799 ASSERT (S_ISLNK (st.st_mode));
800 }
801 }
802 /* Files present here:
803 {BASE}file
804 {BASE}link1 -> {BASE}file
805 {BASE}dir/
806 */
807
808 /* Mixing symlink and directory. */
809
810 { /* Directory onto link. */
811 {
812 errno = 0;
813 ASSERT (func (BASE "dir", BASE "link1") == -1);
814 ASSERT (errno == ENOTDIR);
815 }
816 {
817 errno = 0;
818 ASSERT (func (BASE "dir/", BASE "link1") == -1);
819 ASSERT (errno == ENOTDIR);
820 }
821 {
822 errno = 0;
823 ASSERT (func (BASE "dir", BASE "link1/") == -1);
824 ASSERT (errno == ENOTDIR);
825 }
826 }
827 { /* Link onto directory. */
828 {
829 errno = 0;
830 ASSERT (func (BASE "link1", BASE "dir") == -1);
831 ASSERT (errno == EISDIR || errno == ENOTDIR);
832 }
833 {
834 errno = 0;
835 ASSERT (func (BASE "link1", BASE "dir/") == -1);
836 ASSERT (errno == EISDIR || errno == ENOTDIR);
837 }
838 {
839 errno = 0;
840 ASSERT (func (BASE "link1/", BASE "dir") == -1);
841 ASSERT (errno == ENOTDIR);
842 memset (&st, 0, sizeof st);
843 ASSERT (lstat (BASE "link1", &st) == 0);
844 ASSERT (S_ISLNK (st.st_mode));
845 memset (&st, 0, sizeof st);
846 ASSERT (lstat (BASE "dir", &st) == 0);
847 ASSERT (S_ISDIR (st.st_mode));
848 }
849 }
850 /* Files present here:
851 {BASE}file
852 {BASE}link1 -> {BASE}file
853 {BASE}dir/
854 */
855
856 /* POSIX requires rename("link-to-dir/","other") to rename "dir" and
857 leave "link-to-dir" dangling, but GNU rejects this. POSIX
858 requires rename("dir","dangling/") to create the directory so
859 that "dangling/" now resolves, but GNU rejects this. While we
860 prefer GNU behavior, we don't enforce it. However, we do test
861 that the system either follows POSIX in both cases, or follows
862 GNU. */
863 {
864 int result;
865 ASSERT (symlink (BASE "dir2", BASE "link2") == 0);
866 /* Files present here:
867 {BASE}file
868 {BASE}link1 -> {BASE}file
869 {BASE}link2 -> {BASE}dir2
870 {BASE}dir/
871 */
872 errno = 0;
873 result = func (BASE "dir", BASE "link2/");
874 if (result == 0)
875 {
876 /* POSIX. */
877 errno = 0;
878 ASSERT (lstat (BASE "dir", &st) == -1);
879 ASSERT (errno == ENOENT);
880 memset (&st, 0, sizeof st);
881 ASSERT (lstat (BASE "dir2", &st) == 0);
882 ASSERT (S_ISDIR (st.st_mode));
883 memset (&st, 0, sizeof st);
884 ASSERT (lstat (BASE "link2", &st) == 0);
885 ASSERT (S_ISLNK (st.st_mode));
886 /* Files present here:
887 {BASE}file
888 {BASE}link1 -> {BASE}file
889 {BASE}link2 -> {BASE}dir2
890 {BASE}dir2/
891 */
892 {
893 ASSERT (func (BASE "link2/", BASE "dir") == 0);
894 memset (&st, 0, sizeof st);
895 ASSERT (lstat (BASE "dir", &st) == 0);
896 ASSERT (S_ISDIR (st.st_mode));
897 errno = 0;
898 ASSERT (lstat (BASE "dir2", &st) == -1);
899 ASSERT (errno == ENOENT);
900 memset (&st, 0, sizeof st);
901 ASSERT (lstat (BASE "link2", &st) == 0);
902 ASSERT (S_ISLNK (st.st_mode));
903 }
904 }
905 else
906 {
907 /* GNU. */
908 ASSERT (result == -1);
909 ASSERT (errno == ENOTDIR);
910 memset (&st, 0, sizeof st);
911 ASSERT (lstat (BASE "dir", &st) == 0);
912 ASSERT (S_ISDIR (st.st_mode));
913 errno = 0;
914 ASSERT (lstat (BASE "dir2", &st) == -1);
915 ASSERT (errno == ENOENT);
916 memset (&st, 0, sizeof st);
917 ASSERT (lstat (BASE "link2", &st) == 0);
918 ASSERT (S_ISLNK (st.st_mode));
919 ASSERT (unlink (BASE "link2") == 0);
920 ASSERT (symlink (BASE "dir", BASE "link2") == 0);
921 /* Files present here:
922 {BASE}file
923 {BASE}link1 -> {BASE}file
924 {BASE}link2 -> {BASE}dir
925 {BASE}dir/
926 */
927 errno = 0; /* OpenBSD notices that link2/ and dir are the same. */
928 result = func (BASE "link2/", BASE "dir");
929 if (result) /* GNU/Linux rejects attempts to use link2/. */
930 {
931 ASSERT (result == -1);
932 ASSERT (errno == ENOTDIR || errno == EISDIR);
933 }
934 memset (&st, 0, sizeof st);
935 ASSERT (lstat (BASE "dir", &st) == 0);
936 ASSERT (S_ISDIR (st.st_mode));
937 errno = 0;
938 ASSERT (lstat (BASE "dir2", &st) == -1);
939 ASSERT (errno == ENOENT);
940 memset (&st, 0, sizeof st);
941 ASSERT (lstat (BASE "link2", &st) == 0);
942 ASSERT (S_ISLNK (st.st_mode));
943 }
944 }
945 /* Files present here:
946 {BASE}file
947 {BASE}link1 -> {BASE}file
948 {BASE}link2 -> {BASE}dir or {BASE}dir2
949 {BASE}dir/
950 */
951
952 /* Clean up. */
953 ASSERT (unlink (BASE "file") == 0);
954 ASSERT (rmdir (BASE "dir") == 0);
955 ASSERT (unlink (BASE "link1") == 0);
956 ASSERT (unlink (BASE "link2") == 0);
957
958 return 0;
959}
Note: See TracBrowser for help on using the repository browser.