bug-gnulib
[Top][All Lists]
Advanced

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

rename, renameat test


From: Bruno Haible
Subject: rename, renameat test
Date: Sat, 13 Nov 2010 00:48:41 +0100
User-agent: KMail/1.9.9

Hi Eric,

On a RHEL 5 system I was seeing these test failures:

  test-rename.h:119: assertion failed
  FAIL: test-rename
  test-rename.h:119: assertion failed
  FAIL: test-renameat

In the way the test case is currently written, I have to read from the top,
100 lines of assertions, to understand what the current situation on the
file system is, what the previous func() invocation intended to do, and
what may be the reason of the failure.

Reading 100 (or 400) lines of such code is tedious, I wouldn't want to do
it once again, and therefore would like to ask for permission to add
comments and structure to this test.

Here's a "git diff -w" diff. Really only comments and braces have been added.
OK to commit?


diff --git a/tests/test-rename.h b/tests/test-rename.h
index 9a3f4ec..9753052 100644
--- a/tests/test-rename.h
+++ b/tests/test-rename.h
@@ -31,45 +31,82 @@ test_rename (int (*func) (char const *, char const *), bool 
print)
   ASSERT (close (fd) == 0);
   ASSERT (mkdir (BASE "dir", 0700) == 0);
 
+  /* Files present here:
+       {BASE}file
+       {BASE}dir/
+   */
+
   /* Obvious errors.  */
 
-  errno = 0; /* Missing source.  */
+  { /* Missing source.  */
+    {
+      errno = 0;
   ASSERT (func (BASE "missing", BASE "missing") == -1);
   ASSERT (errno == ENOENT);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "missing/", BASE "missing") == -1);
   ASSERT (errno == ENOENT);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "missing", BASE "missing/") == -1);
   ASSERT (errno == ENOENT);
-  errno = 0; /* Empty operand.  */
+    }
+  }
+  { /* Empty operand.  */
+    {
+      errno = 0;
   ASSERT (func ("", BASE "missing") == -1);
   ASSERT (errno == ENOENT);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "file", "") == -1);
   ASSERT (errno == ENOENT);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "", "") == -1);
   ASSERT (errno == ENOENT);
+    }
+  }
 
   /* Files.  */
-  errno = 0; /* Trailing slash.  */
+
+  { /* Trailing slash.  */
+    {
+      errno = 0;
   ASSERT (func (BASE "file", BASE "file2/") == -1);
   ASSERT (errno == ENOENT || errno == ENOTDIR);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "file/", BASE "file2") == -1);
   ASSERT (errno == ENOTDIR);
+    }
+    {
   errno = 0;
   ASSERT (stat (BASE "file2", &st) == -1);
   ASSERT (errno == ENOENT);
-  ASSERT (func (BASE "file", BASE "file2") == 0); /* Simple rename.  */
+    }
+  }
+  { /* Simple rename.  */
+    ASSERT (func (BASE "file", BASE "file2") == 0);
   errno = 0;
   ASSERT (stat (BASE "file", &st) == -1);
   ASSERT (errno == ENOENT);
   memset (&st, 0, sizeof st);
   ASSERT (stat (BASE "file2", &st) == 0);
   ASSERT (st.st_size == 2);
-  ASSERT (close (creat (BASE "file", 0600)) == 0); /* Overwrite.  */
+  }
+  /* Files present here:
+       {BASE}file2
+       {BASE}dir/
+   */
+  { /* Overwrite.  */
+    ASSERT (close (creat (BASE "file", 0600)) == 0);
   errno = 0;
   ASSERT (func (BASE "file2", BASE "file/") == -1);
   ASSERT (errno == ENOTDIR);
@@ -80,119 +117,318 @@ test_rename (int (*func) (char const *, char const *), 
bool print)
   errno = 0;
   ASSERT (stat (BASE "file2", &st) == -1);
   ASSERT (errno == ENOENT);
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}dir/
+   */
 
   /* Directories.  */
-  ASSERT (func (BASE "dir", BASE "dir2/") == 0); /* Simple rename.  */
+
+  { /* Simple rename.  */
+    {
+      ASSERT (func (BASE "dir", BASE "dir2/") == 0);
   errno = 0;
   ASSERT (stat (BASE "dir", &st) == -1);
   ASSERT (errno == ENOENT);
   ASSERT (stat (BASE "dir2", &st) == 0);
+    }
+    /* Files present here:
+         {BASE}file
+         {BASE}dir2/
+     */
+    {
   ASSERT (func (BASE "dir2/", BASE "dir") == 0);
   ASSERT (stat (BASE "dir", &st) == 0);
   errno = 0;
   ASSERT (stat (BASE "dir2", &st) == -1);
   ASSERT (errno == ENOENT);
+    }
+    /* Files present here:
+         {BASE}file
+         {BASE}dir/
+     */
+    {
   ASSERT (func (BASE "dir", BASE "dir2") == 0);
   errno = 0;
   ASSERT (stat (BASE "dir", &st) == -1);
   ASSERT (errno == ENOENT);
   ASSERT (stat (BASE "dir2", &st) == 0);
-  ASSERT (mkdir (BASE "dir", 0700) == 0); /* Empty onto empty.  */
+    }
+    /* Files present here:
+         {BASE}file
+         {BASE}dir2/
+     */
+    { /* Empty onto empty.  */
+      ASSERT (mkdir (BASE "dir", 0700) == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+           {BASE}dir2/
+       */
   ASSERT (func (BASE "dir2", BASE "dir") == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+       */
   ASSERT (mkdir (BASE "dir2", 0700) == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+           {BASE}dir2/
+       */
   ASSERT (func (BASE "dir2", BASE "dir/") == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+       */
   ASSERT (mkdir (BASE "dir2", 0700) == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+           {BASE}dir2/
+       */
   ASSERT (func (BASE "dir2/", BASE "dir") == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+       */
   ASSERT (mkdir (BASE "dir2", 0700) == 0);
-  ASSERT (close (creat (BASE "dir/file", 0600)) == 0); /* Empty onto full.  */
+    }
+    /* Files present here:
+         {BASE}file
+         {BASE}dir/
+         {BASE}dir2/
+     */
+    { /* Empty onto full.  */
+      ASSERT (close (creat (BASE "dir/file", 0600)) == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+           {BASE}dir/file
+           {BASE}dir2/
+       */
+      {
   errno = 0;
   ASSERT (func (BASE "dir2", BASE "dir") == -1);
   ASSERT (errno == EEXIST || errno == ENOTEMPTY);
+      }
+      {
   errno = 0;
   ASSERT (func (BASE "dir2/", BASE "dir") == -1);
   ASSERT (errno == EEXIST || errno == ENOTEMPTY);
+      }
+      {
   errno = 0;
   ASSERT (func (BASE "dir2", BASE "dir/") == -1);
   ASSERT (errno == EEXIST || errno == ENOTEMPTY);
-  ASSERT (func (BASE "dir", BASE "dir2") == 0); /* Full onto empty.  */
+      }
+    }
+    { /* Full onto empty.  */
+      ASSERT (func (BASE "dir", BASE "dir2") == 0);
   errno = 0;
   ASSERT (stat (BASE "dir", &st) == -1);
   ASSERT (errno == ENOENT);
   ASSERT (stat (BASE "dir2/file", &st) == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir2/
+           {BASE}dir2/file
+       */
   ASSERT (mkdir (BASE "dir", 0700) == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+           {BASE}dir2/
+           {BASE}dir2/file
+       */
+      {
   ASSERT (func (BASE "dir2/", BASE "dir") == 0);
   ASSERT (stat (BASE "dir/file", &st) == 0);
   errno = 0;
   ASSERT (stat (BASE "dir2", &st) == -1);
   ASSERT (errno == ENOENT);
+      }
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+           {BASE}dir/file
+       */
   ASSERT (mkdir (BASE "dir2", 0700) == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+           {BASE}dir/file
+           {BASE}dir2/
+       */
+      {
   ASSERT (func (BASE "dir", BASE "dir2/") == 0);
   errno = 0;
   ASSERT (stat (BASE "dir", &st) == -1);
   ASSERT (errno == ENOENT);
   ASSERT (stat (BASE "dir2/file", &st) == 0);
+      }
+      /* Files present here:
+           {BASE}file
+           {BASE}dir2/
+           {BASE}dir2/file
+       */
   ASSERT (unlink (BASE "dir2/file") == 0);
-  errno = 0; /* Reject trailing dot.  */
+    }
+    /* Files present here:
+         {BASE}file
+         {BASE}dir2/
+     */
+    { /* Reject trailing dot.  */
+      {
+        errno = 0;
   ASSERT (func (BASE "dir2", BASE "dir/.") == -1);
   ASSERT (errno == EINVAL || errno == ENOENT);
+      }
   ASSERT (mkdir (BASE "dir", 0700) == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+           {BASE}dir2/
+       */
+      {
   errno = 0;
   ASSERT (func (BASE "dir2", BASE "dir/.") == -1);
   ASSERT (errno == EINVAL || errno == EBUSY || errno == EISDIR
           || errno == ENOTEMPTY);
+      }
+      {
   errno = 0;
   ASSERT (func (BASE "dir2/.", BASE "dir") == -1);
   ASSERT (errno == EINVAL || errno == EBUSY);
+      }
   ASSERT (rmdir (BASE "dir") == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir2/
+       */
+      {
   errno = 0;
   ASSERT (func (BASE "dir2", BASE "dir/.//") == -1);
   ASSERT (errno == EINVAL || errno == ENOENT);
+      }
   ASSERT (mkdir (BASE "dir", 0700) == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+           {BASE}dir2/
+       */
+      {
   errno = 0;
   ASSERT (func (BASE "dir2", BASE "dir/.//") == -1);
   ASSERT (errno == EINVAL || errno == EBUSY || errno == EISDIR
           || errno == ENOTEMPTY);
+      }
+      {
   errno = 0;
   ASSERT (func (BASE "dir2/.//", BASE "dir") == -1);
   ASSERT (errno == EINVAL || errno == EBUSY);
+      }
   ASSERT (rmdir (BASE "dir2") == 0);
-  errno = 0; /* Move into subdir.  */
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+       */
+    }
+    { /* Move into subdir.  */
+      {
+        errno = 0;
   ASSERT (func (BASE "dir", BASE "dir/sub") == -1);
   ASSERT (errno == EINVAL || errno == EACCES);
+      }
+      {
   errno = 0;
   ASSERT (stat (BASE "dir/sub", &st) == -1);
   ASSERT (errno == ENOENT);
+      }
   ASSERT (mkdir (BASE "dir/sub", 0700) == 0);
+      /* Files present here:
+           {BASE}file
+           {BASE}dir/
+           {BASE}dir/sub/
+       */
+      {
   errno = 0;
   ASSERT (func (BASE "dir", BASE "dir/sub") == -1);
   ASSERT (errno == EINVAL);
   ASSERT (stat (BASE "dir/sub", &st) == 0);
+      }
   ASSERT (rmdir (BASE "dir/sub") == 0);
+    }
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}dir/
+   */
 
   /* Mixing file and directory.  */
-  errno = 0; /* File onto dir.  */
+
+  {
+    { /* File onto dir.  */
+      {
+        errno = 0;
   ASSERT (func (BASE "file", BASE "dir") == -1);
   ASSERT (errno == EISDIR || errno == ENOTDIR);
+      }
+      {
   errno = 0;
   ASSERT (func (BASE "file", BASE "dir/") == -1);
   ASSERT (errno == EISDIR || errno == ENOTDIR);
-  errno = 0; /* Dir onto file.  */
+      }
+    }
+    { /* Dir onto file.  */
+      {
+        errno = 0;
   ASSERT (func (BASE "dir", BASE "file") == -1);
   ASSERT (errno == ENOTDIR);
+      }
+      {
   errno = 0;
   ASSERT (func (BASE "dir/", BASE "file") == -1);
   ASSERT (errno == ENOTDIR);
+      }
+    }
+  }
 
   /* Hard links.  */
-  ASSERT (func (BASE "file", BASE "file") == 0); /* File onto self.  */
+
+  { /* File onto self.  */
+    ASSERT (func (BASE "file", BASE "file") == 0);
   memset (&st, 0, sizeof st);
   ASSERT (stat (BASE "file", &st) == 0);
   ASSERT (st.st_size == 2);
-  ASSERT (func (BASE "dir", BASE "dir") == 0); /* Empty dir onto self.  */
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}dir/
+   */
+  { /* Empty dir onto self.  */
+    ASSERT (func (BASE "dir", BASE "dir") == 0);
   ASSERT (stat (BASE "dir", &st) == 0);
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}dir/
+   */
   ASSERT (close (creat (BASE "dir/file", 0600)) == 0);
-  ASSERT (func (BASE "dir", BASE "dir") == 0); /* Full dir onto self.  */
+  /* Files present here:
+       {BASE}file
+       {BASE}dir/
+       {BASE}dir/file
+   */
+  { /* Full dir onto self.  */
+    ASSERT (func (BASE "dir", BASE "dir") == 0);
+  }
   ASSERT (unlink (BASE "dir/file") == 0);
+  /* Files present here:
+       {BASE}file
+       {BASE}dir/
+   */
   {
     /*  Not all file systems support link.  Mingw doesn't have
         reliable st_nlink on hard links, but our implementation does
@@ -234,16 +470,33 @@ test_rename (int (*func) (char const *, char const *), 
bool print)
       }
     ASSERT (ret == 0);
   }
-  ASSERT (func (BASE "file", BASE "file2") == 0); /* File onto hard link.  */
+  /* Files present here:
+       {BASE}file
+       {BASE}file2       (hard link to file)
+       {BASE}dir/
+   */
+  { /* File onto hard link.  */
+    ASSERT (func (BASE "file", BASE "file2") == 0);
   memset (&st, 0, sizeof st);
   ASSERT (stat (BASE "file", &st) == 0);
   ASSERT (st.st_size == 2);
   memset (&st, 0, sizeof st);
   ASSERT (stat (BASE "file2", &st) == 0);
   ASSERT (st.st_size == 2);
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}file2
+       {BASE}dir/
+   */
   ASSERT (unlink (BASE "file2") == 0);
+  /* Files present here:
+       {BASE}file
+       {BASE}dir/
+   */
 
   /* Symlinks.  */
+
   if (symlink (BASE "file", BASE "link1"))
     {
       if (print)
@@ -253,7 +506,13 @@ test_rename (int (*func) (char const *, char const *), 
bool print)
       ASSERT (rmdir (BASE "dir") == 0);
       return 77;
     }
-  ASSERT (func (BASE "link1", BASE "link2") == 0); /* Simple rename.  */
+  /* Files present here:
+       {BASE}file
+       {BASE}link1 -> {BASE}file
+       {BASE}dir/
+   */
+  { /* Simple rename.  */
+    ASSERT (func (BASE "link1", BASE "link2") == 0);
   ASSERT (stat (BASE "file", &st) == 0);
   errno = 0;
   ASSERT (lstat (BASE "link1", &st) == -1);
@@ -261,7 +520,21 @@ test_rename (int (*func) (char const *, char const *), 
bool print)
   memset (&st, 0, sizeof st);
   ASSERT (lstat (BASE "link2", &st) == 0);
   ASSERT (S_ISLNK (st.st_mode));
-  ASSERT (symlink (BASE "nowhere", BASE "link1") == 0); /* Overwrite.  */
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}link2 -> {BASE}file
+       {BASE}dir/
+   */
+  { /* Overwrite.  */
+    ASSERT (symlink (BASE "nowhere", BASE "link1") == 0);
+    /* Files present here:
+         {BASE}file
+         {BASE}link1 -> {BASE}nowhere
+         {BASE}link2 -> {BASE}file
+         {BASE}dir/
+     */
+    {
   ASSERT (func (BASE "link2", BASE "link1") == 0);
   memset (&st, 0, sizeof st);
   ASSERT (stat (BASE "link1", &st) == 0);
@@ -269,40 +542,122 @@ test_rename (int (*func) (char const *, char const *), 
bool print)
   errno = 0;
   ASSERT (lstat (BASE "link2", &st) == -1);
   ASSERT (errno == ENOENT);
-  ASSERT (symlink (BASE "link2", BASE "link2") == 0); /* Symlink loop.  */
+    }
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}link1 -> {BASE}file
+       {BASE}dir/
+   */
+  { /* Symlink loop.  */
+    ASSERT (symlink (BASE "link2", BASE "link2") == 0);
+    /* Files present here:
+         {BASE}file
+         {BASE}link1 -> {BASE}file
+         {BASE}link2 -> {BASE}link2
+         {BASE}dir/
+     */
+    {
   ASSERT (func (BASE "link2", BASE "link2") == 0);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "link2/", BASE "link2") == -1);
   ASSERT (errno == ELOOP || errno == ENOTDIR);
+    }
   ASSERT (func (BASE "link2", BASE "link3") == 0);
+    /* Files present here:
+         {BASE}file
+         {BASE}link1 -> {BASE}file
+         {BASE}link3 -> {BASE}link2
+         {BASE}dir/
+     */
   ASSERT (unlink (BASE "link3") == 0);
-  ASSERT (symlink (BASE "nowhere", BASE "link2") == 0); /* Dangling link.  */
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}link1 -> {BASE}file
+       {BASE}dir/
+   */
+  { /* Dangling link.  */
+    ASSERT (symlink (BASE "nowhere", BASE "link2") == 0);
+    /* Files present here:
+         {BASE}file
+         {BASE}link1 -> {BASE}file
+         {BASE}link2 -> {BASE}nowhere
+         {BASE}dir/
+     */
+    {
   ASSERT (func (BASE "link2", BASE "link3") == 0);
   errno = 0;
   ASSERT (lstat (BASE "link2", &st) == -1);
   ASSERT (errno == ENOENT);
   memset (&st, 0, sizeof st);
   ASSERT (lstat (BASE "link3", &st) == 0);
-  errno = 0; /* Trailing slash on dangling.  */
+    }
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}link1 -> {BASE}file
+       {BASE}link3 -> {BASE}nowhere
+       {BASE}dir/
+   */
+  { /* Trailing slash on dangling.  */
+    {
+      errno = 0;
   ASSERT (func (BASE "link3/", BASE "link2") == -1);
   ASSERT (errno == ENOENT || errno == ENOTDIR);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "link3", BASE "link2/") == -1);
   ASSERT (errno == ENOENT || errno == ENOTDIR);
+    }
+    {
   errno = 0;
   ASSERT (lstat (BASE "link2", &st) == -1);
   ASSERT (errno == ENOENT);
+    }
   memset (&st, 0, sizeof st);
   ASSERT (lstat (BASE "link3", &st) == 0);
-  errno = 0; /* Trailing slash on link to file.  */
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}link1 -> {BASE}file
+       {BASE}link3 -> {BASE}nowhere
+       {BASE}dir/
+   */
+  { /* Trailing slash on link to file.  */
+    {
+      errno = 0;
   ASSERT (func (BASE "link1/", BASE "link2") == -1);
   ASSERT (errno == ENOTDIR);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "link1", BASE "link3/") == -1);
   ASSERT (errno == ENOENT || errno == ENOTDIR);
+    }
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}link1 -> {BASE}file
+       {BASE}link3 -> {BASE}nowhere
+       {BASE}dir/
+   */
 
   /* Mixing symlink and file.  */
-  ASSERT (close (creat (BASE "file2", 0600)) == 0); /* File onto link.  */
+
+  { /* File onto link.  */
+    ASSERT (close (creat (BASE "file2", 0600)) == 0);
+    /* Files present here:
+         {BASE}file
+         {BASE}file2
+         {BASE}link1 -> {BASE}file
+         {BASE}link3 -> {BASE}nowhere
+         {BASE}dir/
+     */
+    {
   ASSERT (func (BASE "file2", BASE "link3") == 0);
   errno = 0;
   ASSERT (stat (BASE "file2", &st) == -1);
@@ -310,9 +665,37 @@ test_rename (int (*func) (char const *, char const *), 
bool print)
   memset (&st, 0, sizeof st);
   ASSERT (lstat (BASE "link3", &st) == 0);
   ASSERT (S_ISREG (st.st_mode));
+    }
+    /* Files present here:
+         {BASE}file
+         {BASE}link1 -> {BASE}file
+         {BASE}link3
+         {BASE}dir/
+     */
   ASSERT (unlink (BASE "link3") == 0);
-  ASSERT (symlink (BASE "nowhere", BASE "link2") == 0); /* Link onto file.  */
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}link1 -> {BASE}file
+       {BASE}dir/
+   */
+  { /* Link onto file.  */
+    ASSERT (symlink (BASE "nowhere", BASE "link2") == 0);
+    /* Files present here:
+         {BASE}file
+         {BASE}link1 -> {BASE}file
+         {BASE}link2 -> {BASE}nowhere
+         {BASE}dir/
+     */
   ASSERT (close (creat (BASE "file2", 0600)) == 0);
+    /* Files present here:
+         {BASE}file
+         {BASE}file2
+         {BASE}link1 -> {BASE}file
+         {BASE}link2 -> {BASE}nowhere
+         {BASE}dir/
+     */
+    {
   ASSERT (func (BASE "link2", BASE "file2") == 0);
   errno = 0;
   ASSERT (lstat (BASE "link2", &st) == -1);
@@ -320,16 +703,37 @@ test_rename (int (*func) (char const *, char const *), 
bool print)
   memset (&st, 0, sizeof st);
   ASSERT (lstat (BASE "file2", &st) == 0);
   ASSERT (S_ISLNK (st.st_mode));
+    }
+    /* Files present here:
+         {BASE}file
+         {BASE}file2 -> {BASE}nowhere
+         {BASE}link1 -> {BASE}file
+         {BASE}dir/
+     */
   ASSERT (unlink (BASE "file2") == 0);
-  errno = 0; /* Trailing slash.  */
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}link1 -> {BASE}file
+       {BASE}dir/
+   */
+  { /* Trailing slash.  */
+    {
+      errno = 0;
   ASSERT (func (BASE "file/", BASE "link1") == -1);
   ASSERT (errno == ENOTDIR);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "file", BASE "link1/") == -1);
   ASSERT (errno == ENOTDIR || errno == ENOENT);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "link1/", BASE "file") == -1);
   ASSERT (errno == ENOTDIR);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "link1", BASE "file/") == -1);
   ASSERT (errno == ENOTDIR || errno == ENOENT);
@@ -339,23 +743,44 @@ test_rename (int (*func) (char const *, char const *), 
bool print)
   memset (&st, 0, sizeof st);
   ASSERT (lstat (BASE "link1", &st) == 0);
   ASSERT (S_ISLNK (st.st_mode));
+    }
+  /* Files present here:
+       {BASE}file
+       {BASE}link1 -> {BASE}file
+       {BASE}dir/
+   */
 
   /* Mixing symlink and directory.  */
-  errno = 0; /* Directory onto link.  */
+
+  { /* Directory onto link.  */
+    {
+      errno = 0;
   ASSERT (func (BASE "dir", BASE "link1") == -1);
   ASSERT (errno == ENOTDIR);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "dir/", BASE "link1") == -1);
   ASSERT (errno == ENOTDIR);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "dir", BASE "link1/") == -1);
   ASSERT (errno == ENOTDIR);
-  errno = 0; /* Link onto directory.  */
+    }
+  }
+  { /* Link onto directory.  */
+    {
+      errno = 0;
   ASSERT (func (BASE "link1", BASE "dir") == -1);
   ASSERT (errno == EISDIR || errno == ENOTDIR);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "link1", BASE "dir/") == -1);
   ASSERT (errno == EISDIR || errno == ENOTDIR);
+    }
+    {
   errno = 0;
   ASSERT (func (BASE "link1/", BASE "dir") == -1);
   ASSERT (errno == ENOTDIR);
@@ -365,6 +790,13 @@ test_rename (int (*func) (char const *, char const *), 
bool print)
   memset (&st, 0, sizeof st);
   ASSERT (lstat (BASE "dir", &st) == 0);
   ASSERT (S_ISDIR (st.st_mode));
+    }
+  }
+  /* Files present here:
+       {BASE}file
+       {BASE}link1 -> {BASE}file
+       {BASE}dir/
+   */
 
   /* POSIX requires rename("link-to-dir/","other") to rename "dir" and
      leave "link-to-dir" dangling, but GNU rejects this.  POSIX
@@ -376,6 +808,12 @@ test_rename (int (*func) (char const *, char const *), 
bool print)
   {
     int result;
     ASSERT (symlink (BASE "dir2", BASE "link2") == 0);
+    /* Files present here:
+         {BASE}file
+         {BASE}link1 -> {BASE}file
+         {BASE}link2 -> {BASE}dir2
+         {BASE}dir/
+     */
     errno = 0;
     result = func (BASE "dir", BASE "link2/");
     if (result == 0)
@@ -390,6 +828,13 @@ test_rename (int (*func) (char const *, char const *), 
bool print)
         memset (&st, 0, sizeof st);
         ASSERT (lstat (BASE "link2", &st) == 0);
         ASSERT (S_ISLNK (st.st_mode));
+        /* Files present here:
+             {BASE}file
+             {BASE}link1 -> {BASE}file
+             {BASE}link2 -> {BASE}dir2
+             {BASE}dir2/
+         */
+        {
         ASSERT (func (BASE "link2/", BASE "dir") == 0);
         memset (&st, 0, sizeof st);
         ASSERT (lstat (BASE "dir", &st) == 0);
@@ -401,6 +846,7 @@ test_rename (int (*func) (char const *, char const *), bool 
print)
         ASSERT (lstat (BASE "link2", &st) == 0);
         ASSERT (S_ISLNK (st.st_mode));
       }
+      }
     else
       {
         /* GNU.  */
@@ -417,6 +863,12 @@ test_rename (int (*func) (char const *, char const *), 
bool print)
         ASSERT (S_ISLNK (st.st_mode));
         ASSERT (unlink (BASE "link2") == 0);
         ASSERT (symlink (BASE "dir", BASE "link2") == 0);
+        /* Files present here:
+             {BASE}file
+             {BASE}link1 -> {BASE}file
+             {BASE}link2 -> {BASE}dir
+             {BASE}dir/
+         */
         errno = 0; /* OpenBSD notices that link2/ and dir are the same.  */
         result = func (BASE "link2/", BASE "dir");
         if (result) /* GNU/Linux rejects attempts to use link2/.  */
@@ -435,6 +887,12 @@ test_rename (int (*func) (char const *, char const *), 
bool print)
         ASSERT (S_ISLNK (st.st_mode));
       }
   }
+  /* Files present here:
+       {BASE}file
+       {BASE}link1 -> {BASE}file
+       {BASE}link2 -> {BASE}dir or {BASE}dir2
+       {BASE}dir/
+   */
 
   /* Clean up.  */
   ASSERT (unlink (BASE "file") == 0);



reply via email to

[Prev in Thread] Current Thread [Next in Thread]