Land part 2 of clang-format changes

Change-Id: Ia84cc24c8924e6d22d02ac15f611c10e26db99b4
Signed-off-by: Nigel Babu <nigelb@redhat.com>

27 files changed, 3806 insertions, 3732 deletions

diff --git a/tests/basic/ctime/ctime-glfs-init.c b/tests/basic/ctime/ctime-glfs-init.c
index 57a3dc7820e..e4f197b8f30 100644
--- a/tests/basic/ctime/ctime-glfs-init.c
+++ b/tests/basic/ctime/ctime-glfs-init.c
@@ -10,58 +10,59 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(msg) do { \
-        fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \
-        } while (0)
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int         ret      = 0;
-        char       *hostname = NULL;
-        char       *volname  = NULL;
-        char       *logfile  = NULL;
-        glfs_t     *fs       = NULL;
+    int ret = 0;
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    glfs_t *fs = NULL;
 
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
 
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
 
-        fs = glfs_new (volname);
-        if (!fs) {
-                LOG_ERR ("glfs_new failed");
-                return -1;
-        }
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return -1;
+    }
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_volfile_server failed");
-                goto err;
-        }
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile_server failed");
+        goto err;
+    }
 
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_logging failed");
-                goto err;
-        }
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto err;
+    }
 
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                LOG_ERR ("glfs_init failed");
-                goto err;
-        }
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto err;
+    }
 
-        glfs_fini (fs);
-        fs = NULL;
-        return 0;
+    glfs_fini(fs);
+    fs = NULL;
+    return 0;
 err:
-        glfs_fini (fs);
-        fs = NULL;
+    glfs_fini(fs);
+    fs = NULL;
 
-        return -1;
+    return -1;
 }
diff --git a/tests/basic/ec/ec-fast-fgetxattr.c b/tests/basic/ec/ec-fast-fgetxattr.c
index b40dda65de5..bf982151861 100644
--- a/tests/basic/ec/ec-fast-fgetxattr.c
+++ b/tests/basic/ec/ec-fast-fgetxattr.c
@@ -12,123 +12,118 @@
 int cbk_complete = 0;
 ssize_t cbk_ret_val = 0;
 int
-fill_iov (struct iovec *iov, char fillchar, int count)
+fill_iov(struct iovec *iov, char fillchar, int count)
 {
-        int ret = -1;
-
-        iov->iov_base = malloc (count + 1);
-        if (iov->iov_base == NULL) {
-                return ret;
-        } else {
-                iov->iov_len = count;
-                ret = 0;
-        }
-        memset (iov->iov_base, fillchar, count);
-        memset (iov->iov_base + count, '\0', 1);
+    int ret = -1;
 
+    iov->iov_base = malloc(count + 1);
+    if (iov->iov_base == NULL) {
         return ret;
+    } else {
+        iov->iov_len = count;
+        ret = 0;
+    }
+    memset(iov->iov_base, fillchar, count);
+    memset(iov->iov_base + count, '\0', 1);
+
+    return ret;
 }
 
 void
-write_async_cbk (glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
-                 struct stat *poststat, void *cookie)
+write_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                struct stat *poststat, void *cookie)
 {
-
-        if (ret < 0) {
-                fprintf (stderr, "glfs_write failed");
-        }
-        cbk_ret_val = ret;
-        cbk_complete = 1;
+    if (ret < 0) {
+        fprintf(stderr, "glfs_write failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
 }
 
 int
-write_async (glfs_t *fs, glfs_fd_t *glfd, int char_count)
+write_async(glfs_t *fs, glfs_fd_t *glfd, int char_count)
 {
-        ssize_t         ret          = -1;
-        int             flags        = O_RDWR;
-        struct iovec    iov          = {0};
-
-
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    struct iovec iov = {0};
 
-        ret = fill_iov (&iov, 'a', char_count);
-        if (ret) {
-                fprintf (stderr, "failed to create iov");
-                goto out;
-        }
+    ret = fill_iov(&iov, 'a', char_count);
+    if (ret) {
+        fprintf(stderr, "failed to create iov");
+        goto out;
+    }
 
-        ret = glfs_pwritev_async (glfd, &iov, 1, 0, flags, write_async_cbk,
-                                  NULL);
+    ret = glfs_pwritev_async(glfd, &iov, 1, 0, flags, write_async_cbk, NULL);
 out:
-        if (ret < 0) {
-                fprintf (stderr, "glfs_pwritev async failed");
-        }
-        return ret;
-
+    if (ret < 0) {
+        fprintf(stderr, "glfs_pwritev async failed");
+    }
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        glfs_fd_t *fd = NULL;
-        int        ret = 1;
-        char       buf[1024] = {0};
-
-        if (argc != 4) {
-                fprintf (stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]);
-                return 1;
-        }
-
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_set_logging (fs, "/tmp/ec-fgetxattr.log", 7);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_logging: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_init (fs);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_init: returned %d\n", ret);
-                goto out;
-        }
-
-        fd = glfs_open (fs, argv[3], O_RDWR | O_TRUNC);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto out;
-        }
-
-        ret = write_async (fs, fd, 16);
-        if (ret) {
-                fprintf (stderr, "write_async failed\n");
-        }
-
-        sleep (1);
-        ret = glfs_fgetxattr (fd, "trusted.glusterfs.abc", buf, sizeof buf);
-        while (cbk_complete != 1) {
-                /* ret will be -ve as xattr doesn't exist, and fgetxattr should
-                 * return waaaayyy before writev */
-                ret = 0;
-                sleep (1);
-        }
-        if (cbk_ret_val < 0) {
-                fprintf (stderr, "cbk_ret_val is -ve\n");
-                ret = -1;
-        }
-        glfs_close(fd);
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    int ret = 1;
+    char buf[1024] = {0};
+
+    if (argc != 4) {
+        fprintf(stderr, "Syntax: %s <host> <volname> <file>\n", argv[0]);
+        return 1;
+    }
+
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_set_logging(fs, "/tmp/ec-fgetxattr.log", 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
+
+    fd = glfs_open(fs, argv[3], O_RDWR | O_TRUNC);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
+
+    ret = write_async(fs, fd, 16);
+    if (ret) {
+        fprintf(stderr, "write_async failed\n");
+    }
+
+    sleep(1);
+    ret = glfs_fgetxattr(fd, "trusted.glusterfs.abc", buf, sizeof buf);
+    while (cbk_complete != 1) {
+        /* ret will be -ve as xattr doesn't exist, and fgetxattr should
+         * return waaaayyy before writev */
+        ret = 0;
+        sleep(1);
+    }
+    if (cbk_ret_val < 0) {
+        fprintf(stderr, "cbk_ret_val is -ve\n");
+        ret = -1;
+    }
+    glfs_close(fd);
 
 out:
-        unlink ("/tmp/ec-fgetxattr.log");
-        glfs_fini (fs);
+    unlink("/tmp/ec-fgetxattr.log");
+    glfs_fini(fs);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/basic/ec/seek.c b/tests/basic/ec/seek.c
index 67036ad4e75..54fa6f463af 100644
--- a/tests/basic/ec/seek.c
+++ b/tests/basic/ec/seek.c
@@ -15,171 +15,168 @@ static char buffer[65536];
 static int
 parse_int(const char *text, size_t *value)
 {
-        char *ptr;
-        size_t val;
+    char *ptr;
+    size_t val;
 
-        val = strtoul(text, &ptr, 0);
-        if (*ptr != 0) {
-                return 0;
-        }
+    val = strtoul(text, &ptr, 0);
+    if (*ptr != 0) {
+        return 0;
+    }
 
-        *value = val;
+    *value = val;
 
-        return 1;
+    return 1;
 }
 
 static int
 fill_area(int fd, off_t offset, size_t size)
 {
-        size_t len;
-        ssize_t res;
-
-        while (size > 0) {
-                len = sizeof(buffer);
-                if (len > size) {
-                        len = size;
-                }
-                res = pwrite(fd, buffer, len, offset);
-                if (res < 0) {
-                        fprintf(stderr,
-                                "pwrite(%d, %p, %lu, %lu) failed: %d\n",
-                                fd, buffer, size, offset, errno);
-                        return 0;
-                }
-                if (res != len) {
-                        fprintf(stderr,
-                                "pwrite(%d, %p, %lu, %lu) didn't wrote all "
-                                "data: %lu/%lu\n",
-                                fd, buffer, size, offset, res, len);
-                        return 0;
-                }
-                offset += len;
-                size -= len;
+    size_t len;
+    ssize_t res;
+
+    while (size > 0) {
+        len = sizeof(buffer);
+        if (len > size) {
+            len = size;
+        }
+        res = pwrite(fd, buffer, len, offset);
+        if (res < 0) {
+            fprintf(stderr, "pwrite(%d, %p, %lu, %lu) failed: %d\n", fd, buffer,
+                    size, offset, errno);
+            return 0;
+        }
+        if (res != len) {
+            fprintf(stderr,
+                    "pwrite(%d, %p, %lu, %lu) didn't wrote all "
+                    "data: %lu/%lu\n",
+                    fd, buffer, size, offset, res, len);
+            return 0;
         }
+        offset += len;
+        size -= len;
+    }
 
-        return 1;
+    return 1;
 }
 
 static void
 syntax(void)
 {
-        fprintf(stderr, "Syntax: seek create <path> <offset> <size> [...]\n");
-        fprintf(stderr, "        seek scan <path> data|hole <offset>\n");
+    fprintf(stderr, "Syntax: seek create <path> <offset> <size> [...]\n");
+    fprintf(stderr, "        seek scan <path> data|hole <offset>\n");
 }
 
 static int
 seek_create(const char *path, int argc, char *argv[])
 {
-        size_t off, size;
-        int fd;
-        int ret = 1;
-
-        fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644);
-        if (fd < 0) {
-                fprintf(stderr, "Failed to create the file\n");
-                goto out;
+    size_t off, size;
+    int fd;
+    int ret = 1;
+
+    fd = open(path, O_CREAT | O_TRUNC | O_RDWR, 0644);
+    if (fd < 0) {
+        fprintf(stderr, "Failed to create the file\n");
+        goto out;
+    }
+
+    while (argc > 0) {
+        if (!parse_int(argv[0], &off) || !parse_int(argv[1], &size)) {
+            syntax();
+            goto out_close;
         }
-
-        while (argc > 0) {
-                if (!parse_int(argv[0], &off) ||
-                    !parse_int(argv[1], &size)) {
-                        syntax();
-                        goto out_close;
-                }
-                if (!fill_area(fd, off, size)) {
-                        goto out_close;
-                }
-                argv += 2;
-                argc -= 2;
+        if (!fill_area(fd, off, size)) {
+            goto out_close;
         }
+        argv += 2;
+        argc -= 2;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out_close:
-        close(fd);
+    close(fd);
 out:
-        return ret;
+    return ret;
 }
 
 static int
 seek_scan(const char *path, const char *type, const char *pos)
 {
-        size_t off, res;
-        int fd, whence;
-        int ret = 1;
-
-        if (strcmp(type, "data") == 0) {
-                whence = SEEK_DATA;
-        } else if (strcmp(type, "hole") == 0) {
-                whence = SEEK_HOLE;
-        } else {
-                syntax();
-                goto out;
-        }
-
-        if (!parse_int(pos, &off)) {
-                syntax();
-                goto out;
+    size_t off, res;
+    int fd, whence;
+    int ret = 1;
+
+    if (strcmp(type, "data") == 0) {
+        whence = SEEK_DATA;
+    } else if (strcmp(type, "hole") == 0) {
+        whence = SEEK_HOLE;
+    } else {
+        syntax();
+        goto out;
+    }
+
+    if (!parse_int(pos, &off)) {
+        syntax();
+        goto out;
+    }
+
+    fd = open(path, O_RDWR);
+    if (fd < 0) {
+        fprintf(stderr, "Failed to open the file\n");
+        goto out;
+    }
+
+    res = lseek(fd, off, whence);
+    if (res == (off_t)-1) {
+        if (errno != ENXIO) {
+            fprintf(stderr, "seek(%d, %lu, %d) failed: %d\n", fd, off, whence,
+                    errno);
+            goto out_close;
         }
+        fprintf(stdout, "ENXIO\n");
+    } else {
+        fprintf(stdout, "%lu\n", res);
+    }
 
-        fd = open(path, O_RDWR);
-        if (fd < 0) {
-                fprintf(stderr, "Failed to open the file\n");
-                goto out;
-        }
-
-        res = lseek(fd, off, whence);
-        if (res == (off_t)-1) {
-                if (errno != ENXIO) {
-                        fprintf(stderr, "seek(%d, %lu, %d) failed: %d\n", fd,
-                                off, whence, errno);
-                        goto out_close;
-                }
-                fprintf(stdout, "ENXIO\n");
-        } else {
-                fprintf(stdout, "%lu\n", res);
-        }
-
-        ret = 0;
+    ret = 0;
 
 out_close:
-        close(fd);
+    close(fd);
 out:
-        return ret;
+    return ret;
 }
 
 int
 main(int argc, char *argv[])
 {
-        int ret = 1;
+    int ret = 1;
 
-        memset(buffer, 0x55, sizeof(buffer));
+    memset(buffer, 0x55, sizeof(buffer));
 
-        if (argc < 3) {
-                syntax();
-                goto out;
-        }
+    if (argc < 3) {
+        syntax();
+        goto out;
+    }
 
-        if (strcmp(argv[1], "create") == 0) {
-                if (((argc - 3) & 1) != 0) {
-                        syntax();
-                        goto out;
-                }
-                ret = seek_create(argv[2], argc - 3, argv + 3);
-        } else if (strcmp(argv[1], "scan") == 0) {
-                if (argc != 5) {
-                        syntax();
-                        goto out;
-                }
-                ret = seek_scan(argv[2], argv[3], argv[4]);
-        } else {
-                syntax();
-                goto out;
+    if (strcmp(argv[1], "create") == 0) {
+        if (((argc - 3) & 1) != 0) {
+            syntax();
+            goto out;
+        }
+        ret = seek_create(argv[2], argc - 3, argv + 3);
+    } else if (strcmp(argv[1], "scan") == 0) {
+        if (argc != 5) {
+            syntax();
+            goto out;
         }
+        ret = seek_scan(argv[2], argv[3], argv[4]);
+    } else {
+        syntax();
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        return ret;
+    return ret;
 }
-
diff --git a/tests/basic/fops-sanity.c b/tests/basic/fops-sanity.c
index 1e2ccde6bd8..aff72d89ca1 100644
--- a/tests/basic/fops-sanity.c
+++ b/tests/basic/fops-sanity.c
@@ -34,858 +34,904 @@
 #endif
 
 /* for fd based fops after unlink */
-int fd_based_fops_1 (char *filename);
+int
+fd_based_fops_1(char *filename);
 /* for fd based fops before unlink */
-int fd_based_fops_2 (char *filename);
+int
+fd_based_fops_2(char *filename);
 /* fops based on fd after dup */
-int dup_fd_based_fops (char *filename);
+int
+dup_fd_based_fops(char *filename);
 /* for fops based on path */
-int path_based_fops (char *filename);
+int
+path_based_fops(char *filename);
 /* for fops which operate on directory */
-int dir_based_fops (char *filename);
+int
+dir_based_fops(char *filename);
 /* for fops which operate in link files (symlinks) */
-int link_based_fops (char *filename);
+int
+link_based_fops(char *filename);
 /* to test open syscall with open modes available. */
-int test_open_modes (char *filename);
+int
+test_open_modes(char *filename);
 /* generic function which does open write and read. */
-int generic_open_read_write (char *filename, int flag, mode_t mode);
+int
+generic_open_read_write(char *filename, int flag, mode_t mode);
 
-#define OPEN_MODE   0666
+#define OPEN_MODE 0666
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int   ret           = -1;
-        int   result        = 0;
-        char  filename[255] = {0,};
-
-        if (argc > 1)
-                strcpy(filename, argv[1]);
-        else
-                strcpy(filename, "temp-xattr-test-file");
-
-        ret = fd_based_fops_1 (strcat(filename, "_1"));
-        if (ret < 0) {
-                fprintf (stderr, "fd based file operation 1 failed\n");
-                result |= ret;
-        } else {
-                fprintf (stdout, "fd based file operation 1 passed\n");
-        }
-
-        ret = fd_based_fops_2 (strcat(filename, "_2"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "fd based file operation 2 failed\n");
-        } else {
-                fprintf (stdout, "fd based file operation 2 passed\n");
-        }
-
-        ret = dup_fd_based_fops (strcat (filename, "_3"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "dup fd based file operation failed\n");
-        } else {
-                fprintf (stdout, "dup fd based file operation passed\n");
-        }
-
-        ret = path_based_fops (strcat (filename, "_4"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "path based file operation failed\n");
-        } else {
-                fprintf (stdout, "path based file operation passed\n");
-        }
-
-        ret = dir_based_fops (strcat (filename, "_5"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "directory based file operation failed\n");
-        } else {
-                fprintf (stdout, "directory based file operation passed\n");
-        }
-
-        ret = link_based_fops (strcat (filename, "_5"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "link based file operation failed\n");
-        } else {
-                fprintf (stdout, "link based file operation passed\n");
-        }
-
-        ret = test_open_modes (strcat (filename, "_5"));
-        if (ret < 0) {
-                result |= ret;
-                fprintf (stderr, "testing modes of `open' call failed\n");
-        } else {
-                fprintf (stdout, "testing modes of `open' call passed\n");
-        }
-        return result;
+    int ret = -1;
+    int result = 0;
+    char filename[255] = {
+        0,
+    };
+
+    if (argc > 1)
+        strcpy(filename, argv[1]);
+    else
+        strcpy(filename, "temp-xattr-test-file");
+
+    ret = fd_based_fops_1(strcat(filename, "_1"));
+    if (ret < 0) {
+        fprintf(stderr, "fd based file operation 1 failed\n");
+        result |= ret;
+    } else {
+        fprintf(stdout, "fd based file operation 1 passed\n");
+    }
+
+    ret = fd_based_fops_2(strcat(filename, "_2"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "fd based file operation 2 failed\n");
+    } else {
+        fprintf(stdout, "fd based file operation 2 passed\n");
+    }
+
+    ret = dup_fd_based_fops(strcat(filename, "_3"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "dup fd based file operation failed\n");
+    } else {
+        fprintf(stdout, "dup fd based file operation passed\n");
+    }
+
+    ret = path_based_fops(strcat(filename, "_4"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "path based file operation failed\n");
+    } else {
+        fprintf(stdout, "path based file operation passed\n");
+    }
+
+    ret = dir_based_fops(strcat(filename, "_5"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "directory based file operation failed\n");
+    } else {
+        fprintf(stdout, "directory based file operation passed\n");
+    }
+
+    ret = link_based_fops(strcat(filename, "_5"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "link based file operation failed\n");
+    } else {
+        fprintf(stdout, "link based file operation passed\n");
+    }
+
+    ret = test_open_modes(strcat(filename, "_5"));
+    if (ret < 0) {
+        result |= ret;
+        fprintf(stderr, "testing modes of `open' call failed\n");
+    } else {
+        fprintf(stdout, "testing modes of `open' call passed\n");
+    }
+    return result;
 }
 
 /* Execute all possible fops on a fd which is unlinked */
 int
-fd_based_fops_1 (char *filename)
+fd_based_fops_1(char *filename)
 {
-        int         fd        = 0;
-        int         ret       = -1;
-        int         result    = 0;
-        struct stat stbuf     = {0,};
-        char        wstr[50]  = {0,};
-        char        rstr[50]  = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT, OPEN_MODE);
-        if (fd < 0) {
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                return ret;
-        }
-
-        ret = unlink (filename);
-        if (ret < 0) {
-                fprintf (stderr, "unlink failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (wstr, "This is my string\n");
-        ret = write (fd, wstr, strlen(wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = read (fd, rstr, strlen(wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                fprintf (stderr, "read returning junk\n");
-                result |= ret;
-        }
-
-        ret = ftruncate (fd, 0);
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fstat (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fdatasync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-/*
- *      These metadata operations fail at the moment because kernel doesn't
- *      pass the client fd in the operation.
- *      The following bug tracks this change.
- *      https://bugzilla.redhat.com/show_bug.cgi?id=1084422
- *      ret = fchmod (fd, 0640);
- *      if (ret < 0) {
- *              fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = fchown (fd, 10001, 10001);
- *      if (ret < 0) {
- *              fprintf (stderr, "fchown failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0);
- *      if (ret < 0) {
- *              fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = flistxattr (fd, NULL, 0);
- *      if (ret <= 0) {
- *              fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0);
- *      if (ret <= 0) {
- *              fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
-
- *      ret = fremovexattr (fd, "trusted.xattr-test");
- *      if (ret < 0) {
- *              fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
- *              result |= ret;
- *      }
- */
-
-        if (fd)
-                close(fd);
-        return result;
+    int fd = 0;
+    int ret = -1;
+    int result = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT, OPEN_MODE);
+    if (fd < 0) {
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        return ret;
+    }
+
+    ret = unlink(filename);
+    if (ret < 0) {
+        fprintf(stderr, "unlink failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(wstr, "This is my string\n");
+    ret = write(fd, wstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = read(fd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        fprintf(stderr, "read returning junk\n");
+        result |= ret;
+    }
+
+    ret = ftruncate(fd, 0);
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fstat(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fdatasync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    /*
+     *      These metadata operations fail at the moment because kernel doesn't
+     *      pass the client fd in the operation.
+     *      The following bug tracks this change.
+     *      https://bugzilla.redhat.com/show_bug.cgi?id=1084422
+     *      ret = fchmod (fd, 0640);
+     *      if (ret < 0) {
+     *              fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = fchown (fd, 10001, 10001);
+     *      if (ret < 0) {
+     *              fprintf (stderr, "fchown failed : %s\n", strerror (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0);
+     *      if (ret < 0) {
+     *              fprintf (stderr, "fsetxattr failed : %s\n", strerror
+     (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = flistxattr (fd, NULL, 0);
+     *      if (ret <= 0) {
+     *              fprintf (stderr, "flistxattr failed : %s\n", strerror
+     (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0);
+     *      if (ret <= 0) {
+     *              fprintf (stderr, "fgetxattr failed : %s\n", strerror
+     (errno));
+     *              result |= ret;
+     *      }
+
+     *      ret = fremovexattr (fd, "trusted.xattr-test");
+     *      if (ret < 0) {
+     *              fprintf (stderr, "fremovexattr failed : %s\n", strerror
+     (errno));
+     *              result |= ret;
+     *      }
+     */
+
+    if (fd)
+        close(fd);
+    return result;
 }
 
-
 int
-fd_based_fops_2 (char *filename)
+fd_based_fops_2(char *filename)
 {
-        int     fd              = 0;
-        int     ret             = -1;
-        int     result          = 0;
-        struct stat stbuf       = {0,};
-        char        wstr[50]    = {0,};
-        char        rstr[50]    = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT, OPEN_MODE);
-        if (fd < 0) {
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                return ret;
-        }
-
-        ret = ftruncate (fd, 0);
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (wstr, "This is my second string\n");
-        ret = write (fd, wstr, strlen (wstr));
-        if (ret < 0) {
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = read (fd, rstr, strlen (wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                fprintf (stderr, "read returning junk\n");
-                result |= ret;
-        }
-
-        ret = fstat (fd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fchmod (fd, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fchown (fd, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "fchown failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsetxattr (fd, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fdatasync (fd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = flistxattr (fd, NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fgetxattr (fd, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fremovexattr (fd, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        if (fd)
-                close (fd);
-        unlink (filename);
-
-        return result;
+    int fd = 0;
+    int ret = -1;
+    int result = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT, OPEN_MODE);
+    if (fd < 0) {
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        return ret;
+    }
+
+    ret = ftruncate(fd, 0);
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(wstr, "This is my second string\n");
+    ret = write(fd, wstr, strlen(wstr));
+    if (ret < 0) {
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = read(fd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        fprintf(stderr, "read returning junk\n");
+        result |= ret;
+    }
+
+    ret = fstat(fd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fchmod(fd, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "fchmod failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fchown(fd, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "fchown failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsetxattr(fd, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fdatasync(fd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = flistxattr(fd, NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "flistxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fgetxattr(fd, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fremovexattr(fd, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    if (fd)
+        close(fd);
+    unlink(filename);
+
+    return result;
 }
 
 int
-path_based_fops (char *filename)
+path_based_fops(char *filename)
 {
-        int         ret              = -1;
-        int         fd               = 0;
-        int         result           = 0;
-        struct stat stbuf            = {0,};
-        char        newfilename[255] = {0,};
-        char        *hardlink        = "linkfile-hard.txt";
-        char        *symlnk          = "linkfile-soft.txt";
-        char        buf[1024]        = {0,};
-
-        fd = creat (filename, 0644);
-        if (fd < 0) {
-                fprintf (stderr, "creat failed: %s\n", strerror (errno));
-                return ret;
-        }
-
-        ret = truncate (filename, 0);
-        if (ret < 0) {
-                fprintf (stderr, "truncate failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = stat (filename, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "stat failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = chmod (filename, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = chown (filename, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "chown failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = setxattr (filename, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "setxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = listxattr (filename, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "listxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = getxattr (filename, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "getxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = removexattr (filename, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "removexattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = access (filename, R_OK|W_OK);
-        if (ret < 0) {
-                fprintf (stderr, "access failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = link (filename, hardlink);
-        if (ret < 0) {
-                fprintf (stderr, "link failed: %s\n", strerror(errno));
-                result |= ret;
-        }
-        unlink(hardlink);
-
-        ret = symlink (filename, symlnk);
-        if (ret < 0) {
-                fprintf (stderr, "symlink failed: %s\n", strerror(errno));
-                result |= ret;
-        }
-
-        ret = readlink (symlnk, buf, sizeof(buf));
-        if (ret < 0) {
-                fprintf (stderr, "readlink failed: %s\n", strerror(errno));
-                result |= ret;
-        }
-        unlink(symlnk);
-
-        /* Create a character special file */
-        ret = mknod ("cspecial", S_IFCHR|S_IRWXU|S_IRWXG, makedev(2,3));
-        if (ret < 0) {
-                fprintf (stderr, "cpsecial mknod failed: %s\n",
-                         strerror(errno));
-                result |= ret;
-        }
-        unlink("cspecial");
-
-        ret = mknod ("bspecial", S_IFBLK|S_IRWXU|S_IRWXG, makedev(4,5));
-        if (ret < 0) {
-                fprintf (stderr, "bspecial mknod failed: %s\n",
-                         strerror(errno));
-                result |= ret;
-        }
-        unlink("bspecial");
+    int ret = -1;
+    int fd = 0;
+    int result = 0;
+    struct stat stbuf = {
+        0,
+    };
+    char newfilename[255] = {
+        0,
+    };
+    char *hardlink = "linkfile-hard.txt";
+    char *symlnk = "linkfile-soft.txt";
+    char buf[1024] = {
+        0,
+    };
+
+    fd = creat(filename, 0644);
+    if (fd < 0) {
+        fprintf(stderr, "creat failed: %s\n", strerror(errno));
+        return ret;
+    }
+
+    ret = truncate(filename, 0);
+    if (ret < 0) {
+        fprintf(stderr, "truncate failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = stat(filename, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = chmod(filename, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = chown(filename, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "chown failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = setxattr(filename, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "setxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = listxattr(filename, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "listxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = getxattr(filename, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "getxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = removexattr(filename, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "removexattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = access(filename, R_OK | W_OK);
+    if (ret < 0) {
+        fprintf(stderr, "access failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = link(filename, hardlink);
+    if (ret < 0) {
+        fprintf(stderr, "link failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink(hardlink);
+
+    ret = symlink(filename, symlnk);
+    if (ret < 0) {
+        fprintf(stderr, "symlink failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = readlink(symlnk, buf, sizeof(buf));
+    if (ret < 0) {
+        fprintf(stderr, "readlink failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink(symlnk);
+
+    /* Create a character special file */
+    ret = mknod("cspecial", S_IFCHR | S_IRWXU | S_IRWXG, makedev(2, 3));
+    if (ret < 0) {
+        fprintf(stderr, "cpsecial mknod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink("cspecial");
+
+    ret = mknod("bspecial", S_IFBLK | S_IRWXU | S_IRWXG, makedev(4, 5));
+    if (ret < 0) {
+        fprintf(stderr, "bspecial mknod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink("bspecial");
 
 #ifdef linux
-        ret = mknod ("fifo", S_IFIFO|S_IRWXU|S_IRWXG, 0);
+    ret = mknod("fifo", S_IFIFO | S_IRWXU | S_IRWXG, 0);
 #else
-        ret = mkfifo ("fifo", 0);
+    ret = mkfifo("fifo", 0);
 #endif
-        if (ret < 0) {
-                fprintf (stderr, "fifo mknod failed: %s\n",
-                         strerror(errno));
-                result |= ret;
-        }
-        unlink("fifo");
+    if (ret < 0) {
+        fprintf(stderr, "fifo mknod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink("fifo");
 
 #ifdef linux
-        ret = mknod ("sock", S_IFSOCK|S_IRWXU|S_IRWXG, 0);
-        if (ret < 0) {
-                fprintf (stderr, "sock mknod failed: %s\n",
-                         strerror(errno));
-                result |= ret;
-        }
+    ret = mknod("sock", S_IFSOCK | S_IRWXU | S_IRWXG, 0);
+    if (ret < 0) {
+        fprintf(stderr, "sock mknod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
 #else
-        {
-                int s;
-                const char *pathname = "sock";
-                struct sockaddr_un addr;
-
-                s = socket(PF_LOCAL, SOCK_STREAM, 0);
-                memset(&addr, 0, sizeof(addr));
-                strncpy(addr.sun_path, pathname, sizeof(addr.sun_path));
-                ret = bind(s, (const struct sockaddr *)&addr, SUN_LEN(&addr));
-                if (ret < 0) {
-                        fprintf (stderr, "fifo mknod failed: %s\n",
-                                 strerror(errno));
-                        result |= ret;
-                }
-                close(s);
-        }
-#endif
-        unlink("sock");
+    {
+        int s;
+        const char *pathname = "sock";
+        struct sockaddr_un addr;
 
-        strcpy (newfilename, filename);
-        strcat(newfilename, "_new");
-        ret = rename (filename, newfilename);
+        s = socket(PF_LOCAL, SOCK_STREAM, 0);
+        memset(&addr, 0, sizeof(addr));
+        strncpy(addr.sun_path, pathname, sizeof(addr.sun_path));
+        ret = bind(s, (const struct sockaddr *)&addr, SUN_LEN(&addr));
         if (ret < 0) {
-                fprintf (stderr, "rename failed: %s\n", strerror (errno));
-                result |= ret;
+            fprintf(stderr, "fifo mknod failed: %s\n", strerror(errno));
+            result |= ret;
         }
-        unlink (newfilename);
-
-        if (fd)
-                close (fd);
-
-        unlink (filename);
-        return result;
+        close(s);
+    }
+#endif
+    unlink("sock");
+
+    strcpy(newfilename, filename);
+    strcat(newfilename, "_new");
+    ret = rename(filename, newfilename);
+    if (ret < 0) {
+        fprintf(stderr, "rename failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+    unlink(newfilename);
+
+    if (fd)
+        close(fd);
+
+    unlink(filename);
+    return result;
 }
 
 int
-dup_fd_based_fops (char *filename)
+dup_fd_based_fops(char *filename)
 {
-        int         fd        = 0;
-        int         result    = 0;
-        int         newfd     = 0;
-        int         ret       = -1;
-        struct stat stbuf     = {0,};
-        char        wstr[50]  = {0,};
-        char        rstr[50]  = {0,};
-
-        fd = open (filename, O_RDWR|O_CREAT, OPEN_MODE);
-        if (fd < 0) {
-                fprintf (stderr, "open failed : %s\n", strerror (errno));
-                return ret;
-        }
-
-        newfd = dup (fd);
-        if (newfd < 0) {
-                fprintf (stderr, "dup failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        close (fd);
-
-        strcpy (wstr, "This is my string\n");
-        ret = write (newfd, wstr, strlen(wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "write failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lseek (newfd, 0, SEEK_SET);
-        if (ret < 0) {
-                fprintf (stderr, "lseek failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = read (newfd, rstr, strlen(wstr));
-        if (ret <= 0) {
-                fprintf (stderr, "read failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = memcmp (rstr, wstr, strlen (wstr));
-        if (ret != 0) {
-                fprintf (stderr, "read returning junk\n");
-                result |= ret;
-        }
-
-        ret = ftruncate (newfd, 0);
-        if (ret < 0) {
-                fprintf (stderr, "ftruncate failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fstat (newfd, &stbuf);
-        if (ret < 0) {
-                fprintf (stderr, "fstat failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fchmod (newfd, 0640);
-        if (ret < 0) {
-                fprintf (stderr, "fchmod failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fchown (newfd, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "fchown failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsync (newfd);
-        if (ret < 0) {
-                fprintf (stderr, "fsync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fsetxattr (newfd, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "fsetxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fdatasync (newfd);
-        if (ret < 0) {
-                fprintf (stderr, "fdatasync failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = flistxattr (newfd, NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "flistxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fgetxattr (newfd, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                fprintf (stderr, "fgetxattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = fremovexattr (newfd, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "fremovexattr failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        if (newfd)
-                close (newfd);
-        ret = unlink (filename);
-        if (ret < 0) {
-                fprintf (stderr, "unlink failed : %s\n", strerror (errno));
-                result |= ret;
-        }
-        return result;
+    int fd = 0;
+    int result = 0;
+    int newfd = 0;
+    int ret = -1;
+    struct stat stbuf = {
+        0,
+    };
+    char wstr[50] = {
+        0,
+    };
+    char rstr[50] = {
+        0,
+    };
+
+    fd = open(filename, O_RDWR | O_CREAT, OPEN_MODE);
+    if (fd < 0) {
+        fprintf(stderr, "open failed : %s\n", strerror(errno));
+        return ret;
+    }
+
+    newfd = dup(fd);
+    if (newfd < 0) {
+        fprintf(stderr, "dup failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    close(fd);
+
+    strcpy(wstr, "This is my string\n");
+    ret = write(newfd, wstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "write failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lseek(newfd, 0, SEEK_SET);
+    if (ret < 0) {
+        fprintf(stderr, "lseek failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = read(newfd, rstr, strlen(wstr));
+    if (ret <= 0) {
+        fprintf(stderr, "read failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = memcmp(rstr, wstr, strlen(wstr));
+    if (ret != 0) {
+        fprintf(stderr, "read returning junk\n");
+        result |= ret;
+    }
+
+    ret = ftruncate(newfd, 0);
+    if (ret < 0) {
+        fprintf(stderr, "ftruncate failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fstat(newfd, &stbuf);
+    if (ret < 0) {
+        fprintf(stderr, "fstat failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fchmod(newfd, 0640);
+    if (ret < 0) {
+        fprintf(stderr, "fchmod failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fchown(newfd, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "fchown failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsync(newfd);
+    if (ret < 0) {
+        fprintf(stderr, "fsync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fsetxattr(newfd, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "fsetxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fdatasync(newfd);
+    if (ret < 0) {
+        fprintf(stderr, "fdatasync failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = flistxattr(newfd, NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "flistxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fgetxattr(newfd, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        fprintf(stderr, "fgetxattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = fremovexattr(newfd, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "fremovexattr failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    if (newfd)
+        close(newfd);
+    ret = unlink(filename);
+    if (ret < 0) {
+        fprintf(stderr, "unlink failed : %s\n", strerror(errno));
+        result |= ret;
+    }
+    return result;
 }
 
 int
-dir_based_fops (char *dirname)
+dir_based_fops(char *dirname)
 {
-        int            ret           = -1;
-        int            result        = 0;
-        DIR           *dp            = NULL;
-        char           buff[255]     = {0,};
-        struct dirent *dbuff         = {0,};
-        struct stat    stbuff        = {0,};
-        char           newdname[255] = {0,};
-        char          *cwd           = NULL;
-
-        ret = mkdir (dirname, 0755);
-        if (ret < 0) {
-                fprintf (stderr, "mkdir failed: %s\n", strerror (errno));
-                return ret;
-        }
-
-        dp = opendir (dirname);
-        if (dp == NULL) {
-                fprintf (stderr, "opendir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        dbuff = readdir (dp);
-        if (NULL == dbuff) {
-                fprintf (stderr, "readdir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = closedir (dp);
-        if (ret < 0) {
-                fprintf (stderr, "closedir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = stat (dirname, &stbuff);
-        if (ret < 0) {
-                fprintf (stderr, "stat failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = chmod (dirname, 0744);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = chown (dirname, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "chmod failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = setxattr (dirname, "trusted.xattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "setxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = listxattr (dirname, NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "listxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = getxattr (dirname, "trusted.xattr-test", NULL, 0);
-        if (ret <= 0) {
-                ret = -1;
-                fprintf (stderr, "getxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = removexattr (dirname, "trusted.xattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "removexattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (newdname, dirname);
-        strcat (newdname, "/../");
-        ret = chdir (newdname);
-        if (ret < 0) {
-                fprintf (stderr, "chdir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        cwd = getcwd (buff, 255);
-        if (NULL == cwd) {
-                fprintf (stderr, "getcwd failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (newdname, dirname);
-        strcat (newdname, "new");
-        ret = rename (dirname, newdname);
-        if (ret < 0) {
-                fprintf (stderr, "rename failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = rmdir (newdname);
-        if (ret < 0) {
-                fprintf (stderr, "rmdir failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        rmdir (dirname);
-        return result;
+    int ret = -1;
+    int result = 0;
+    DIR *dp = NULL;
+    char buff[255] = {
+        0,
+    };
+    struct dirent *dbuff = {
+        0,
+    };
+    struct stat stbuff = {
+        0,
+    };
+    char newdname[255] = {
+        0,
+    };
+    char *cwd = NULL;
+
+    ret = mkdir(dirname, 0755);
+    if (ret < 0) {
+        fprintf(stderr, "mkdir failed: %s\n", strerror(errno));
+        return ret;
+    }
+
+    dp = opendir(dirname);
+    if (dp == NULL) {
+        fprintf(stderr, "opendir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    dbuff = readdir(dp);
+    if (NULL == dbuff) {
+        fprintf(stderr, "readdir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = closedir(dp);
+    if (ret < 0) {
+        fprintf(stderr, "closedir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = stat(dirname, &stbuff);
+    if (ret < 0) {
+        fprintf(stderr, "stat failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = chmod(dirname, 0744);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = chown(dirname, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "chmod failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = setxattr(dirname, "trusted.xattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "setxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = listxattr(dirname, NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "listxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = getxattr(dirname, "trusted.xattr-test", NULL, 0);
+    if (ret <= 0) {
+        ret = -1;
+        fprintf(stderr, "getxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = removexattr(dirname, "trusted.xattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "removexattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(newdname, dirname);
+    strcat(newdname, "/../");
+    ret = chdir(newdname);
+    if (ret < 0) {
+        fprintf(stderr, "chdir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    cwd = getcwd(buff, 255);
+    if (NULL == cwd) {
+        fprintf(stderr, "getcwd failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(newdname, dirname);
+    strcat(newdname, "new");
+    ret = rename(dirname, newdname);
+    if (ret < 0) {
+        fprintf(stderr, "rename failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = rmdir(newdname);
+    if (ret < 0) {
+        fprintf(stderr, "rmdir failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    rmdir(dirname);
+    return result;
 }
 
 int
-link_based_fops (char *filename)
+link_based_fops(char *filename)
 {
-        int         ret           = -1;
-        int         result        = 0;
-        int         fd            = 0;
-        char        newname[255]  = {0,};
-        char        linkname[255] = {0,};
-        struct stat lstbuf        = {0,};
-
-        fd = creat (filename, 0644);
-        if (fd < 0) {
-                fd = 0;
-                fprintf (stderr, "creat failed: %s\n", strerror (errno));
-                return ret;
-        }
-
-        strcpy (newname, filename);
-        strcat (newname, "_hlink");
-        ret = link (filename, newname);
-        if (ret < 0) {
-                fprintf (stderr, "link failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = unlink (filename);
-        if (ret < 0) {
-                fprintf (stderr, "unlink failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        strcpy (linkname, filename);
-        strcat (linkname, "_slink");
-        ret = symlink (newname, linkname);
-        if (ret < 0) {
-                fprintf (stderr, "symlink failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lstat (linkname, &lstbuf);
-        if (ret < 0) {
-                fprintf (stderr, "lstbuf failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lchown (linkname, 10001, 10001);
-        if (ret < 0) {
-                fprintf (stderr, "lchown failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lsetxattr (linkname, "trusted.lxattr-test", "working", 8, 0);
-        if (ret < 0) {
-                fprintf (stderr, "lsetxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = llistxattr (linkname, NULL, 0);
-        if (ret < 0) {
-                ret = -1;
-                fprintf (stderr, "llistxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lgetxattr (linkname, "trusted.lxattr-test", NULL, 0);
-        if (ret < 0) {
-                ret = -1;
-                fprintf (stderr, "lgetxattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        ret = lremovexattr (linkname, "trusted.lxattr-test");
-        if (ret < 0) {
-                fprintf (stderr, "lremovexattr failed: %s\n", strerror (errno));
-                result |= ret;
-        }
-
-        if (fd)
-                close(fd);
-        unlink (linkname);
-        unlink (newname);
-        return result;
+    int ret = -1;
+    int result = 0;
+    int fd = 0;
+    char newname[255] = {
+        0,
+    };
+    char linkname[255] = {
+        0,
+    };
+    struct stat lstbuf = {
+        0,
+    };
+
+    fd = creat(filename, 0644);
+    if (fd < 0) {
+        fd = 0;
+        fprintf(stderr, "creat failed: %s\n", strerror(errno));
+        return ret;
+    }
+
+    strcpy(newname, filename);
+    strcat(newname, "_hlink");
+    ret = link(filename, newname);
+    if (ret < 0) {
+        fprintf(stderr, "link failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = unlink(filename);
+    if (ret < 0) {
+        fprintf(stderr, "unlink failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    strcpy(linkname, filename);
+    strcat(linkname, "_slink");
+    ret = symlink(newname, linkname);
+    if (ret < 0) {
+        fprintf(stderr, "symlink failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lstat(linkname, &lstbuf);
+    if (ret < 0) {
+        fprintf(stderr, "lstbuf failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lchown(linkname, 10001, 10001);
+    if (ret < 0) {
+        fprintf(stderr, "lchown failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lsetxattr(linkname, "trusted.lxattr-test", "working", 8, 0);
+    if (ret < 0) {
+        fprintf(stderr, "lsetxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = llistxattr(linkname, NULL, 0);
+    if (ret < 0) {
+        ret = -1;
+        fprintf(stderr, "llistxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lgetxattr(linkname, "trusted.lxattr-test", NULL, 0);
+    if (ret < 0) {
+        ret = -1;
+        fprintf(stderr, "lgetxattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    ret = lremovexattr(linkname, "trusted.lxattr-test");
+    if (ret < 0) {
+        fprintf(stderr, "lremovexattr failed: %s\n", strerror(errno));
+        result |= ret;
+    }
+
+    if (fd)
+        close(fd);
+    unlink(linkname);
+    unlink(newname);
+    return result;
 }
 
 int
-test_open_modes (char *filename)
+test_open_modes(char *filename)
 {
-        int ret         = -1;
-        int result      = 0;
-
-        ret = generic_open_read_write (filename, O_CREAT|O_WRONLY, OPEN_MODE);
-        if (ret != 0) {
-               fprintf (stderr, "flag O_CREAT|O_WRONLY failed: \n");
-               result |= ret;
-        }
-
-        ret = generic_open_read_write (filename, O_CREAT|O_RDWR, OPEN_MODE);
-        if (ret != 0) {
-               fprintf (stderr, "flag O_CREAT|O_RDWR failed\n");
-               result |= ret;
-        }
-
-        ret = generic_open_read_write (filename, O_CREAT|O_RDONLY, OPEN_MODE);
-        if (ret != 0) {
-                fprintf (stderr, "flag O_CREAT|O_RDONLY failed\n");
-                result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_WRONLY, 0);
-        if (ret != 0) {
-               fprintf (stderr, "flag O_WRONLY failed\n");
-               result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_RDWR, 0);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_RDWR failed\n");
-               result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_RDONLY, 0);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_RDONLY failed\n");
-               result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_TRUNC|O_WRONLY, 0);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_TRUNC|O_WRONLY failed\n");
-               result |= ret;
-        }
+    int ret = -1;
+    int result = 0;
+
+    ret = generic_open_read_write(filename, O_CREAT | O_WRONLY, OPEN_MODE);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_CREAT|O_WRONLY failed: \n");
+        result |= ret;
+    }
+
+    ret = generic_open_read_write(filename, O_CREAT | O_RDWR, OPEN_MODE);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_CREAT|O_RDWR failed\n");
+        result |= ret;
+    }
+
+    ret = generic_open_read_write(filename, O_CREAT | O_RDONLY, OPEN_MODE);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_CREAT|O_RDONLY failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_WRONLY, 0);
+    if (ret != 0) {
+        fprintf(stderr, "flag O_WRONLY failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_RDWR, 0);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_RDWR failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_RDONLY, 0);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_RDONLY failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_TRUNC | O_WRONLY, 0);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_TRUNC|O_WRONLY failed\n");
+        result |= ret;
+    }
 
 #if 0 /* undefined behaviour, unable to reliably test */
         ret = creat (filename, 0644);
@@ -897,87 +943,90 @@ test_open_modes (char *filename)
         }
 #endif
 
-        ret = generic_open_read_write (filename, O_CREAT|O_RDWR|O_SYNC,
-                                       OPEN_MODE);
-        if (0 != ret) {
-               fprintf (stderr, "flag O_CREAT|O_RDWR|O_SYNC failed\n");
-               result |= ret;
-        }
-
-        ret = creat (filename, 0644);
-        close (ret);
-        ret = generic_open_read_write (filename, O_CREAT|O_EXCL, OPEN_MODE);
-        if (0 != ret) {
-                fprintf (stderr, "flag O_CREAT|O_EXCL failed\n");
-                result |= ret;
-        }
-
-        return result;
+    ret = generic_open_read_write(filename, O_CREAT | O_RDWR | O_SYNC,
+                                  OPEN_MODE);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_CREAT|O_RDWR|O_SYNC failed\n");
+        result |= ret;
+    }
+
+    ret = creat(filename, 0644);
+    close(ret);
+    ret = generic_open_read_write(filename, O_CREAT | O_EXCL, OPEN_MODE);
+    if (0 != ret) {
+        fprintf(stderr, "flag O_CREAT|O_EXCL failed\n");
+        result |= ret;
+    }
+
+    return result;
 }
 
 int
-generic_open_read_write (char *filename, int flag, mode_t mode)
+generic_open_read_write(char *filename, int flag, mode_t mode)
 {
-        int  fd          = 0;
-        int  ret         = -1;
-        char wstring[50] = {0,};
-        char rstring[50] = {0,};
-
-        fd = open (filename, flag, mode);
-        if (fd < 0) {
-                if (flag == (O_CREAT|O_EXCL) && errno == EEXIST) {
-                        unlink (filename);
-                        return 0;
-                }
-                else {
-                        fprintf (stderr, "open failed: %s\n", strerror (errno));
-                        return -1;
-                }
-        }
-
-        strcpy (wstring, "My string to write\n");
-        ret = write (fd, wstring, strlen(wstring));
-        if (ret <= 0) {
-                if (errno != EBADF) {
-                        fprintf (stderr, "write failed: %s\n", strerror (errno));
-                        close (fd);
-                        unlink(filename);
-                        return ret;
-                }
-        }
-
-        ret = lseek (fd, 0, SEEK_SET);
-        if (ret < 0) {
-                close (fd);
-                unlink(filename);
-                return ret;
-        }
-
-        ret = read (fd, rstring, strlen(wstring));
-        if (ret < 0 && flag != (O_CREAT|O_WRONLY) && flag != O_WRONLY && \
-            flag != (O_TRUNC|O_WRONLY)) {
-                close (fd);
-                unlink (filename);
-                return ret;
-        }
-
-        /* Compare the rstring with wstring. But we do not want to return
-         * error when the flag is either O_RDONLY, O_CREAT|O_RDONLY or
-         * O_TRUNC|O_RDONLY. Because in that case we are not writing
-         * anything to the file.*/
-
-        ret = memcmp (wstring, rstring, strlen (wstring));
-        if (0 != ret && flag != (O_TRUNC|O_WRONLY) && flag != O_WRONLY && \
-                                 flag != (O_CREAT|O_WRONLY) && !(flag == \
-                                 (O_CREAT|O_RDONLY) || flag == O_RDONLY \
-                                  || flag == (O_TRUNC|O_RDONLY))) {
-                fprintf (stderr, "read is returning junk\n");
-                close (fd);
-                unlink (filename);
-                return ret;
-        }
-
-        close (fd);
-        unlink (filename);
-        return 0;
+    int fd = 0;
+    int ret = -1;
+    char wstring[50] = {
+        0,
+    };
+    char rstring[50] = {
+        0,
+    };
+
+    fd = open(filename, flag, mode);
+    if (fd < 0) {
+        if (flag == (O_CREAT | O_EXCL) && errno == EEXIST) {
+            unlink(filename);
+            return 0;
+        } else {
+            fprintf(stderr, "open failed: %s\n", strerror(errno));
+            return -1;
+        }
+    }
+
+    strcpy(wstring, "My string to write\n");
+    ret = write(fd, wstring, strlen(wstring));
+    if (ret <= 0) {
+        if (errno != EBADF) {
+            fprintf(stderr, "write failed: %s\n", strerror(errno));
+            close(fd);
+            unlink(filename);
+            return ret;
+        }
+    }
+
+    ret = lseek(fd, 0, SEEK_SET);
+    if (ret < 0) {
+        close(fd);
+        unlink(filename);
+        return ret;
+    }
+
+    ret = read(fd, rstring, strlen(wstring));
+    if (ret < 0 && flag != (O_CREAT | O_WRONLY) && flag != O_WRONLY &&
+        flag != (O_TRUNC | O_WRONLY)) {
+        close(fd);
+        unlink(filename);
+        return ret;
+    }
+
+    /* Compare the rstring with wstring. But we do not want to return
+     * error when the flag is either O_RDONLY, O_CREAT|O_RDONLY or
+     * O_TRUNC|O_RDONLY. Because in that case we are not writing
+     * anything to the file.*/
+
+    ret = memcmp(wstring, rstring, strlen(wstring));
+    if (0 != ret && flag != (O_TRUNC | O_WRONLY) && flag != O_WRONLY &&
+        flag != (O_CREAT | O_WRONLY) &&
+        !(flag == (O_CREAT | O_RDONLY) || flag == O_RDONLY ||
+          flag == (O_TRUNC | O_RDONLY))) {
+        fprintf(stderr, "read is returning junk\n");
+        close(fd);
+        unlink(filename);
+        return ret;
+    }
+
+    close(fd);
+    unlink(filename);
+    return 0;
 }
diff --git a/tests/basic/fuse/seek.c b/tests/basic/fuse/seek.c
index e4db41c03d7..30943ad0f33 100644
--- a/tests/basic/fuse/seek.c
+++ b/tests/basic/fuse/seek.c
@@ -17,64 +17,66 @@
 #include <unistd.h>
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        int          ret        = EXIT_SUCCESS;
-        int          fd         = -1;
-        char        *filename   = NULL;
-        struct stat  st         = { 0, };
-        off_t        hole_start = 0;
-        off_t        hole_end   = 0;
+    int ret = EXIT_SUCCESS;
+    int fd = -1;
+    char *filename = NULL;
+    struct stat st = {
+        0,
+    };
+    off_t hole_start = 0;
+    off_t hole_end = 0;
 
-        if (argc != 2) {
-                fprintf (stderr, "Invalid argument, use %s <file>\n", argv[0]);
-                return EXIT_FAILURE;
-        }
-
-        filename = argv[1];
+    if (argc != 2) {
+        fprintf(stderr, "Invalid argument, use %s <file>\n", argv[0]);
+        return EXIT_FAILURE;
+    }
 
-        fd = open (filename, O_RDONLY);
-        if (fd <= 0) {
-                perror ("open");
-                return EXIT_FAILURE;
-        }
+    filename = argv[1];
 
-        if (fstat (fd, &st)) {
-                perror ("fstat");
-                return EXIT_FAILURE;
-        }
+    fd = open(filename, O_RDONLY);
+    if (fd <= 0) {
+        perror("open");
+        return EXIT_FAILURE;
+    }
 
-        while (hole_end < st.st_size) {
-                hole_start = lseek (fd, hole_end, SEEK_HOLE);
-                if (hole_start == -1 && errno == ENXIO) {
-                        /* no more holes */
-                        break;
-                } else if (hole_start == -1 && errno == ENOTSUP) {
-                        /* SEEK_HOLE is not supported */
-                        perror ("lseek(SEEK_HOLE)");
-                        ret = EXIT_FAILURE;
-                        break;
-                } else if (hole_start == -1) {
-			perror ("no more holes");
-			break;
-		}
+    if (fstat(fd, &st)) {
+        perror("fstat");
+        return EXIT_FAILURE;
+    }
 
-                hole_end = lseek (fd, hole_start, SEEK_DATA);
-                if (hole_end == -1 && errno == ENXIO) {
-                        /* no more data */
-                        break;
-                } else if (hole_end == -1 && errno == ENOTSUP) {
-                        /* SEEK_DATA is not supported */
-                        perror ("lseek(SEEK_DATA)");
-                        ret = EXIT_FAILURE;
-                        break;
-                }
+    while (hole_end < st.st_size) {
+        hole_start = lseek(fd, hole_end, SEEK_HOLE);
+        if (hole_start == -1 && errno == ENXIO) {
+            /* no more holes */
+            break;
+        } else if (hole_start == -1 && errno == ENOTSUP) {
+            /* SEEK_HOLE is not supported */
+            perror("lseek(SEEK_HOLE)");
+            ret = EXIT_FAILURE;
+            break;
+        } else if (hole_start == -1) {
+            perror("no more holes");
+            break;
+        }
 
-                printf ("HOLE found: %ld - %ld%s\n", hole_start, hole_end,
-                         (hole_end == st.st_size) ? " (EOF)" : "");
+        hole_end = lseek(fd, hole_start, SEEK_DATA);
+        if (hole_end == -1 && errno == ENXIO) {
+            /* no more data */
+            break;
+        } else if (hole_end == -1 && errno == ENOTSUP) {
+            /* SEEK_DATA is not supported */
+            perror("lseek(SEEK_DATA)");
+            ret = EXIT_FAILURE;
+            break;
         }
 
-        close (fd);
+        printf("HOLE found: %ld - %ld%s\n", hole_start, hole_end,
+               (hole_end == st.st_size) ? " (EOF)" : "");
+    }
+
+    close(fd);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/basic/gfapi/anonymous_fd_read_write.c b/tests/basic/gfapi/anonymous_fd_read_write.c
index 6945dd634f0..fc276ca4310 100644
--- a/tests/basic/gfapi/anonymous_fd_read_write.c
+++ b/tests/basic/gfapi/anonymous_fd_read_write.c
@@ -9,95 +9,98 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int                     ret            = 0;
-        glfs_t                  *fs            = NULL;
-        struct glfs_object      *root = NULL, *file_obj = NULL;
-        struct stat             sb             = {0, };
-        char                    readbuf[32], writebuf[32];
-        char                    *filename      = "file.txt";
-        char                    *logfile       = NULL;
-        char                    *volname       = NULL;
-        char                    *hostname      = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                ret = -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (root == NULL) {
-                fprintf (stderr, "glfs_h_lookupat: error on lookup of / ,%s\n",
-                         strerror (errno));
-                goto out;
-        }
-
-        file_obj = glfs_h_creat (fs, root, filename, O_CREAT, 0644, &sb);
-        if (file_obj == NULL) {
-                fprintf (stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n",
-                         filename, root, strerror (errno));
-                goto out;
-        }
-
-        /* test read/write based on anonymous fd */
-        memcpy (writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
-
-        ret = glfs_h_anonymous_write (fs, file_obj, writebuf, 32, 0);
-        if (ret < 0)
-                LOG_ERR ("glfs_h_anonymous_write", ret);
-
-        ret = glfs_h_anonymous_read (fs, file_obj, readbuf, 32, 0);
-        if (ret < 0)
-                LOG_ERR ("glfs_h_anonymous_read", ret);
-
-        if (memcmp (readbuf, writebuf, 32)) {
-                fprintf (stderr, "Failed to read what I wrote: %s %s\n", readbuf,
-                         writebuf);
-                ret = -1;
-                goto out;
-        }
-
-        ret = 0;
+    int ret = 0;
+    glfs_t *fs = NULL;
+    struct glfs_object *root = NULL, *file_obj = NULL;
+    struct stat sb = {
+        0,
+    };
+    char readbuf[32], writebuf[32];
+    char *filename = "file.txt";
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        ret = -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (root == NULL) {
+        fprintf(stderr, "glfs_h_lookupat: error on lookup of / ,%s\n",
+                strerror(errno));
+        goto out;
+    }
+
+    file_obj = glfs_h_creat(fs, root, filename, O_CREAT, 0644, &sb);
+    if (file_obj == NULL) {
+        fprintf(stderr, "glfs_h_creat: error on create of %s: from (%p),%s\n",
+                filename, root, strerror(errno));
+        goto out;
+    }
+
+    /* test read/write based on anonymous fd */
+    memcpy(writebuf, "abcdefghijklmnopqrstuvwxyz012345", 32);
+
+    ret = glfs_h_anonymous_write(fs, file_obj, writebuf, 32, 0);
+    if (ret < 0)
+        LOG_ERR("glfs_h_anonymous_write", ret);
+
+    ret = glfs_h_anonymous_read(fs, file_obj, readbuf, 32, 0);
+    if (ret < 0)
+        LOG_ERR("glfs_h_anonymous_read", ret);
+
+    if (memcmp(readbuf, writebuf, 32)) {
+        fprintf(stderr, "Failed to read what I wrote: %s %s\n", readbuf,
+                writebuf);
+        ret = -1;
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (file_obj)
-                glfs_h_close (file_obj);
-
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
-        }
-        if (ret)
-                exit(1);
-        exit(0);
+    if (file_obj)
+        glfs_h_close(file_obj);
+
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d \n", ret);
+    }
+    if (ret)
+        exit(1);
+    exit(0);
 }
diff --git a/tests/basic/gfapi/bug-1241104.c b/tests/basic/gfapi/bug-1241104.c
index 311323f672a..78c87595a71 100644
--- a/tests/basic/gfapi/bug-1241104.c
+++ b/tests/basic/gfapi/bug-1241104.c
@@ -12,81 +12,82 @@
 
 int gfapi = 1;
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        int        ret = 0, i, status = 0;
-        glfs_fd_t *fd = NULL;
-        char      *filename = "file_tmp";
-        char      *volname = NULL;
-        char      *logfile = NULL;
-        char      *hostname = NULL;
-        struct flock lock = {0, };
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644);
-        if (fd <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_creat", ret);
-        }
-        fprintf (stderr, "glfs-create fd - %d\n", fd);
-
-	/* validate locks for negative range */
-        lock.l_type = F_WRLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 10;
-        lock.l_len = -9;
-
-        ret = glfs_posix_lock (fd, F_SETLK, &lock);
-        LOG_ERR ("glfs_posix_lock", ret);
+    glfs_t *fs = NULL;
+    int ret = 0, i, status = 0;
+    glfs_fd_t *fd = NULL;
+    char *filename = "file_tmp";
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+    struct flock lock = {
+        0,
+    };
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    fd = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644);
+    if (fd <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_creat", ret);
+    }
+    fprintf(stderr, "glfs-create fd - %d\n", fd);
+
+    /* validate locks for negative range */
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 10;
+    lock.l_len = -9;
+
+    ret = glfs_posix_lock(fd, F_SETLK, &lock);
+    LOG_ERR("glfs_posix_lock", ret);
 
 err:
-        glfs_close(fd);
-        LOG_ERR ("glfs_close", ret);
+    glfs_close(fd);
+    LOG_ERR("glfs_close", ret);
 
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
-        }
-
-        if (ret)
-                exit(1);
-        exit(0);
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d \n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/bug1283983.c b/tests/basic/gfapi/bug1283983.c
index 3334b290d9e..b920013d0e0 100644
--- a/tests/basic/gfapi/bug1283983.c
+++ b/tests/basic/gfapi/bug1283983.c
@@ -10,114 +10,113 @@
 #include <glusterfs/api/glfs-handles.h>
 int gfapi = 1;
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error ret(%d), errno(%d)\n", \
-                         func, ret, errno); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
-#define LOG_IF_NO_ERR(func, ret) do { \
-        if (ret == 0) {            \
-                fprintf (stderr, "%s : hasn't returned error %d\n", \
-                         func, ret); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error ret(%d), errno(%d)\n", func,  \
+                    ret, errno);                                               \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
+#define LOG_IF_NO_ERR(func, ret)                                               \
+    do {                                                                       \
+        if (ret == 0) {                                                        \
+            fprintf(stderr, "%s : hasn't returned error %d\n", func, ret);     \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t                   *fs = NULL;
-        int                       ret = 0, i;
-        glfs_fd_t                *fd = NULL;
-        char                     *filename = "/a1";
-        char                     *filename2 = "/a2";
-        struct stat               sb = {0, };
-        struct glfs_upcall       *cbk = NULL;
-        char                     *logfile = NULL;
-        char                     *volname = NULL;
-        int                       cnt = 1;
-        struct glfs_upcall_inode *in_arg = NULL;
-        struct glfs_object       *root = NULL, *leaf = NULL;
-
-        fprintf (stderr, "Starting libgfapi_fini\n");
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
+    glfs_t *fs = NULL;
+    int ret = 0, i;
+    glfs_fd_t *fd = NULL;
+    char *filename = "/a1";
+    char *filename2 = "/a2";
+    struct stat sb = {
+        0,
+    };
+    struct glfs_upcall *cbk = NULL;
+    char *logfile = NULL;
+    char *volname = NULL;
+    int cnt = 1;
+    struct glfs_upcall_inode *in_arg = NULL;
+    struct glfs_object *root = NULL, *leaf = NULL;
+
+    fprintf(stderr, "Starting libgfapi_fini\n");
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1] volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    sleep(2);
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (!root) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat root", ret);
+    }
+    leaf = glfs_h_lookupat(fs, root, filename, &sb, 0);
+    if (!leaf) {
+        ret = -1;
+        LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret);
+    }
+
+    leaf = glfs_h_creat(fs, root, filename, O_RDWR, 0644, &sb);
+    if (!leaf) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat leaf", ret);
+    }
+    fprintf(stderr, "glfs_h_create leaf - %p\n", leaf);
+
+    leaf = glfs_h_lookupat(fs, root, filename2, &sb, 0);
+    if (!leaf) {
+        ret = -1;
+        LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret);
+    }
+
+    ret = glfs_h_rename(fs, root, filename, root, filename2);
+    LOG_ERR("glfs_rename", ret);
+
+    while (cnt++ < 5) {
+        ret = glfs_h_poll_upcall(fs, &cbk);
+        LOG_ERR("glfs_h_poll_upcall", ret);
+
+        /* There should not be any upcalls sent */
+        if (glfs_upcall_get_reason(cbk) != GLFS_UPCALL_EVENT_NULL) {
+            fprintf(stderr, "Error: Upcall received(%d)\n",
+                    glfs_upcall_get_reason(cbk));
+            exit(1);
         }
 
-        hostname = argv[1]
-        volname = argv[2];
-        logfile = argv[3];
+        glfs_free(cbk);
+    }
 
+    ret = glfs_fini(fs);
+    LOG_ERR("glfs_fini", ret);
 
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        sleep (2);
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (!root) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat root", ret);
-        }
-        leaf = glfs_h_lookupat (fs, root, filename, &sb, 0);
-        if (!leaf) {
-                ret = -1;
-                LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret);
-        }
-
-        leaf = glfs_h_creat (fs, root, filename, O_RDWR, 0644, &sb);
-        if (!leaf) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat leaf", ret);
-        }
-        fprintf (stderr, "glfs_h_create leaf - %p\n", leaf);
-
-        leaf = glfs_h_lookupat (fs, root, filename2, &sb, 0);
-        if (!leaf) {
-                ret = -1;
-                LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret);
-        }
-
-        ret = glfs_h_rename (fs, root, filename, root, filename2);
-        LOG_ERR("glfs_rename", ret);
-
-        while (cnt++ < 5) {
-                ret = glfs_h_poll_upcall(fs, &cbk);
-                LOG_ERR ("glfs_h_poll_upcall", ret);
-
-                /* There should not be any upcalls sent */
-                if (glfs_upcall_get_reason(cbk) != GLFS_UPCALL_EVENT_NULL) {
-                        fprintf (stderr, "Error: Upcall received(%d)\n",
-                                 glfs_upcall_get_reason(cbk));
-                        exit (1);
-                }
-
-                glfs_free (cbk);
-        }
-
-        ret = glfs_fini(fs);
-        LOG_ERR("glfs_fini", ret);
-
-        fprintf (stderr, "End of libgfapi_fini\n");
+    fprintf(stderr, "End of libgfapi_fini\n");
 
-        exit(0);
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/bug1291259.c b/tests/basic/gfapi/bug1291259.c
index 26fc1e01449..cd7bc65268b 100644
--- a/tests/basic/gfapi/bug1291259.c
+++ b/tests/basic/gfapi/bug1291259.c
@@ -10,174 +10,172 @@
 #include <glusterfs/api/glfs-handles.h>
 int gfapi = 1;
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error ret(%d), errno(%d)\n", \
-                         func, ret, errno); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
-#define LOG_IF_NO_ERR(func, ret) do { \
-        if (ret == 0) {            \
-                fprintf (stderr, "%s : hasn't returned error %d\n", \
-                         func, ret); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error ret(%d), errno(%d)\n", func,  \
+                    ret, errno);                                               \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
+#define LOG_IF_NO_ERR(func, ret)                                               \
+    do {                                                                       \
+        if (ret == 0) {                                                        \
+            fprintf(stderr, "%s : hasn't returned error %d\n", func, ret);     \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 #define GLAPI_UUID_LENGTH 16
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t                     *fs = NULL;
-        glfs_t                     *fs2 = NULL;
-        int                         ret = 0, i;
-        glfs_fd_t                  *fd = NULL;
-        char                       *filename = "/a1";
-        char                       *filename2 = "/a2";
-        struct                      stat sb = {0, };
-        char                       *logfile = NULL;
-        char                       *volname = NULL;
-        char                       *hostname = NULL;
-        int                         cnt = 1;
-        int                         upcall_received = 0;
-        struct glfs_upcall         *cbk = NULL;
-        struct glfs_object         *root = NULL, *leaf = NULL;
-        unsigned char               globjhdl[GFAPI_HANDLE_LENGTH];
-        unsigned char               globjhdl2[GFAPI_HANDLE_LENGTH];
-
-        fprintf (stderr, "Starting libgfapi_fini\n");
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
+    glfs_t *fs = NULL;
+    glfs_t *fs2 = NULL;
+    int ret = 0, i;
+    glfs_fd_t *fd = NULL;
+    char *filename = "/a1";
+    char *filename2 = "/a2";
+    struct stat sb = {
+        0,
+    };
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+    int cnt = 1;
+    int upcall_received = 0;
+    struct glfs_upcall *cbk = NULL;
+    struct glfs_object *root = NULL, *leaf = NULL;
+    unsigned char globjhdl[GFAPI_HANDLE_LENGTH];
+    unsigned char globjhdl2[GFAPI_HANDLE_LENGTH];
+
+    fprintf(stderr, "Starting libgfapi_fini\n");
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    /* This does not block, but enables caching of events. Real
+     * applications like NFS-Ganesha run this in a thread before activity
+     * on the fs (through this instance) happens. */
+    ret = glfs_h_poll_upcall(fs, &cbk);
+    LOG_ERR("glfs_h_poll_upcall", ret);
+
+    fs2 = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs2, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs2, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs2);
+    LOG_ERR("glfs_init", ret);
+
+    sleep(2);
+    root = glfs_h_lookupat(fs, NULL, "/", &sb, 0);
+    if (!root) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat root", ret);
+    }
+    leaf = glfs_h_lookupat(fs, root, filename, &sb, 0);
+    if (!leaf) {
+        ret = -1;
+        LOG_IF_NO_ERR("glfs_h_lookupat leaf", ret);
+    }
+
+    root = glfs_h_lookupat(fs2, NULL, "/", &sb, 0);
+    if (!root) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat root", ret);
+    }
+    leaf = glfs_h_creat(fs2, root, filename, O_RDWR, 0644, &sb);
+    if (!leaf) {
+        ret = -1;
+        LOG_ERR("glfs_h_lookupat leaf", ret);
+    }
+    fprintf(stderr, "glfs_h_create leaf - %p\n", leaf);
+
+    while (cnt++ < 5 && !upcall_received) {
+        enum glfs_upcall_reason reason = 0;
+        struct glfs_upcall_inode *in_arg = NULL;
 
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
+        ret = glfs_h_poll_upcall(fs, &cbk);
+        LOG_ERR("glfs_h_poll_upcall", ret);
+        if (ret)
+            goto retry;
 
+        reason = glfs_upcall_get_reason(cbk);
+        fprintf(stderr, "Upcall received(%d)\n", reason);
 
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
+        if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
+            struct glfs_object *object = NULL;
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
+            in_arg = glfs_upcall_get_event(cbk);
+            object = glfs_upcall_inode_get_object(in_arg);
 
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
+            ret = glfs_h_extract_handle(root, globjhdl + GLAPI_UUID_LENGTH,
+                                        GFAPI_HANDLE_LENGTH);
+            LOG_ERR("glfs_h_extract_handle", (ret != 16));
 
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
+            ret = glfs_h_extract_handle(object, globjhdl2 + GLAPI_UUID_LENGTH,
+                                        GFAPI_HANDLE_LENGTH);
+            LOG_ERR("glfs_h_extract_handle", (ret != 16));
 
-        /* This does not block, but enables caching of events. Real
-         * applications like NFS-Ganesha run this in a thread before activity
-         * on the fs (through this instance) happens. */
-        ret = glfs_h_poll_upcall(fs, &cbk);
-        LOG_ERR ("glfs_h_poll_upcall", ret);
-
-        fs2 = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
+            if (memcmp(globjhdl + GLAPI_UUID_LENGTH,
+                       globjhdl2 + GLAPI_UUID_LENGTH, 16)) {
+                fprintf(stderr, "Error: gfid mismatch\n");
+                exit(1);
+            }
+            upcall_received = 1;
         }
 
-        ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs2, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs2);
-        LOG_ERR("glfs_init", ret);
+    retry:
+        if (!upcall_received)
+            sleep(1); /* glfs_h_poll_upcall() does not block */
 
-        sleep (2);
-        root = glfs_h_lookupat (fs, NULL, "/", &sb, 0);
-        if (!root) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat root", ret);
-        }
-        leaf = glfs_h_lookupat (fs, root, filename, &sb, 0);
-        if (!leaf) {
-                ret = -1;
-                LOG_IF_NO_ERR ("glfs_h_lookupat leaf", ret);
-        }
-
-        root = glfs_h_lookupat (fs2, NULL, "/", &sb, 0);
-        if (!root) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat root", ret);
-        }
-        leaf = glfs_h_creat (fs2, root, filename, O_RDWR, 0644, &sb);
-        if (!leaf) {
-                ret = -1;
-                LOG_ERR ("glfs_h_lookupat leaf", ret);
-        }
-        fprintf (stderr, "glfs_h_create leaf - %p\n", leaf);
-
-        while (cnt++ < 5 && !upcall_received) {
-                enum glfs_upcall_reason     reason = 0;
-                struct glfs_upcall_inode   *in_arg = NULL;
-
-                ret = glfs_h_poll_upcall(fs, &cbk);
-                LOG_ERR ("glfs_h_poll_upcall", ret);
-                if (ret)
-                        goto retry;
-
-                reason = glfs_upcall_get_reason (cbk);
-                fprintf (stderr, "Upcall received(%d)\n", reason);
-
-                if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
-                        struct glfs_object *object = NULL;
-
-                        in_arg = glfs_upcall_get_event (cbk);
-                        object = glfs_upcall_inode_get_object (in_arg);
-
-                        ret = glfs_h_extract_handle (root,
-                                                     globjhdl+GLAPI_UUID_LENGTH,
-                                                     GFAPI_HANDLE_LENGTH);
-                        LOG_ERR("glfs_h_extract_handle", (ret != 16));
-
-                        ret = glfs_h_extract_handle (object,
-                                                  globjhdl2+GLAPI_UUID_LENGTH,
-                                                  GFAPI_HANDLE_LENGTH);
-                        LOG_ERR("glfs_h_extract_handle", (ret != 16));
-
-                        if (memcmp (globjhdl+GLAPI_UUID_LENGTH,
-                                    globjhdl2+GLAPI_UUID_LENGTH, 16)) {
-                                fprintf (stderr, "Error: gfid mismatch\n");
-                                exit (1);
-                        }
-                        upcall_received = 1;
-                }
-
-retry:
-                if (!upcall_received)
-                        sleep (1); /* glfs_h_poll_upcall() does not block */
-
-                if (!ret) {
-                        glfs_free (cbk);
-                        cbk = NULL;
-                }
+        if (!ret) {
+            glfs_free(cbk);
+            cbk = NULL;
         }
+    }
 
-        if (!upcall_received) {
-                fprintf (stderr, "Error: Upcall not received\n");
-                exit (1);
-        }
+    if (!upcall_received) {
+        fprintf(stderr, "Error: Upcall not received\n");
+        exit(1);
+    }
 
-        ret = glfs_fini(fs);
-        LOG_ERR("glfs_fini", ret);
+    ret = glfs_fini(fs);
+    LOG_ERR("glfs_fini", ret);
 
-        fprintf (stderr, "End of libgfapi_fini\n");
+    fprintf(stderr, "End of libgfapi_fini\n");
 
-        exit(0);
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/bug1613098.c b/tests/basic/gfapi/bug1613098.c
index cdb69fdedfa..ee67e97a034 100644
--- a/tests/basic/gfapi/bug1613098.c
+++ b/tests/basic/gfapi/bug1613098.c
@@ -6,90 +6,91 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define ACL_TYPE_ACCESS	(0x8000)
+#define ACL_TYPE_ACCESS (0x8000)
 
-#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \
-        if (ret < 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto label; \
-        } \
-        } while (0)
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int             ret = -1;
-        int             flags = O_RDWR|O_SYNC;
-        glfs_t         *fs = NULL;
-        glfs_fd_t      *fd = NULL;
-        char           *volname = NULL;
-        char           *logfile = NULL;
-        const char     *filename = "file_tmp";
-        struct glfs_object *object = NULL;
-        acl_t          acl = NULL;
-        struct stat    sb;
-
-        if (argc != 3) {
-                fprintf (stderr, "Invalid argument\n");
-                return 1;
-        }
-
-        volname = argv[1];
-        logfile = argv[2];
-
-        fs = glfs_new (volname);
-        if (!fs)
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_new", ret, out);
-
-        ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out);
-
-        ret = glfs_init (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out);
-
-        fd = glfs_creat(fs, filename, flags, 0044);
-        if (fd == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", ret, out);
-        }
-        glfs_close(fd);
-
-        object = glfs_h_lookupat(fs, NULL, filename, NULL, 0);
-        if (object == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_h_lookupat", ret, out);
-        }
-
-        ret = glfs_chown(fs, filename, 99, 99);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_chown", ret, out);
-
-        ret = glfs_setfsuid(99);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_setfsuid", ret, out);
-
-        ret = glfs_setfsgid(99);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_setfsgid", ret, out);
-
-        acl = glfs_h_acl_get(fs, object, ACL_TYPE_ACCESS);
-        if (acl == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_h_acl_get", ret, out);
-        }
-
-        ret = glfs_h_acl_set(fs, object, ACL_TYPE_ACCESS, acl);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_h_acl_get", ret, out);
+    int ret = -1;
+    int flags = O_RDWR | O_SYNC;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    const char *filename = "file_tmp";
+    struct glfs_object *object = NULL;
+    acl_t acl = NULL;
+    struct stat sb;
+
+    if (argc != 3) {
+        fprintf(stderr, "Invalid argument\n");
+        return 1;
+    }
+
+    volname = argv[1];
+    logfile = argv[2];
+
+    fs = glfs_new(volname);
+    if (!fs)
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out);
+
+    ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
+
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
+
+    fd = glfs_creat(fs, filename, flags, 0044);
+    if (fd == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out);
+    }
+    glfs_close(fd);
+
+    object = glfs_h_lookupat(fs, NULL, filename, NULL, 0);
+    if (object == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", ret, out);
+    }
+
+    ret = glfs_chown(fs, filename, 99, 99);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_chown", ret, out);
+
+    ret = glfs_setfsuid(99);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsuid", ret, out);
+
+    ret = glfs_setfsgid(99);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_setfsgid", ret, out);
+
+    acl = glfs_h_acl_get(fs, object, ACL_TYPE_ACCESS);
+    if (acl == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out);
+    }
+
+    ret = glfs_h_acl_set(fs, object, ACL_TYPE_ACCESS, acl);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_h_acl_get", ret, out);
 out:
-        glfs_setfsuid(0);
-        glfs_setfsgid(0);
+    glfs_setfsuid(0);
+    glfs_setfsgid(0);
 
-        if (object)
-                glfs_h_close(object);
+    if (object)
+        glfs_h_close(object);
 
-        if (fs)
-                glfs_fini(fs);
+    if (fs)
+        glfs_fini(fs);
 
-        return ret;
+    return ret;
 }
diff --git a/tests/basic/gfapi/gfapi-async-calls-test.c b/tests/basic/gfapi/gfapi-async-calls-test.c
index b9f29a44ac0..5a291c3c76b 100644
--- a/tests/basic/gfapi/gfapi-async-calls-test.c
+++ b/tests/basic/gfapi/gfapi-async-calls-test.c
@@ -9,170 +9,164 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(msg) do { \
-        fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \
-        } while (0)
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
 
 int cbk_complete = 0;
 int cbk_ret_val = -1;
 
 int
-fill_iov (struct iovec *iov, char fillchar, int count)
+fill_iov(struct iovec *iov, char fillchar, int count)
 {
-        int ret = -1;
-
-        iov->iov_base = malloc (count + 1);
-        if (iov->iov_base == NULL) {
-                return ret;
-        } else {
-                iov->iov_len = count;
-                ret = 0;
-        }
-        memset (iov->iov_base, fillchar, count);
-        memset (iov->iov_base + count, '\0', 1);
+    int ret = -1;
 
+    iov->iov_base = malloc(count + 1);
+    if (iov->iov_base == NULL) {
         return ret;
+    } else {
+        iov->iov_len = count;
+        ret = 0;
+    }
+    memset(iov->iov_base, fillchar, count);
+    memset(iov->iov_base + count, '\0', 1);
+
+    return ret;
 }
 
 glfs_t *
-init_glfs (const char *hostname, const char *volname,
-           const char *logfile)
+init_glfs(const char *hostname, const char *volname, const char *logfile)
 {
-        int     ret     = -1;
-        glfs_t *fs      = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                LOG_ERR ("glfs_new failed");
-                return NULL;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_volfile_server failed");
-                goto out;
-        }
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_logging failed");
-                goto out;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                LOG_ERR ("glfs_init failed");
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return NULL;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile_server failed");
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret) {
-                glfs_fini (fs);
-                fs = NULL;
-        }
+    if (ret) {
+        glfs_fini(fs);
+        fs = NULL;
+    }
 
-        return fs;
+    return fs;
 }
 
 void
-write_async_cbk (glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
-                 struct stat *poststat, void *cookie)
+write_async_cbk(glfs_fd_t *fd, ssize_t ret, struct stat *prestat,
+                struct stat *poststat, void *cookie)
 {
-
-        if (ret < 0) {
-                LOG_ERR ("glfs_write failed");
-        }
-        cbk_ret_val = ret;
-        cbk_complete = 1;
+    if (ret < 0) {
+        LOG_ERR("glfs_write failed");
+    }
+    cbk_ret_val = ret;
+    cbk_complete = 1;
 }
 
 int
-write_async (glfs_t *fs, glfs_fd_t *glfd, int char_count)
+write_async(glfs_t *fs, glfs_fd_t *glfd, int char_count)
 {
-        ssize_t         ret          = -1;
-        int             flags        = O_RDWR;
-        const char     *buff         = "This is from my prog\n";
-        struct iovec    iov          = {0};
-        void           *write_cookie = NULL;
-        void           *read_cookie  = NULL;
-
-
-
-        ret = fill_iov (&iov, 'a', char_count);
-        if (ret) {
-                LOG_ERR ("failed to create iov");
-                goto out;
-        }
-
-        write_cookie = strdup ("write_cookie");
-        ret = glfs_pwritev_async (glfd, &iov, 1, 0, flags, write_async_cbk,
-                                  &write_cookie);
+    ssize_t ret = -1;
+    int flags = O_RDWR;
+    const char *buff = "This is from my prog\n";
+    struct iovec iov = {0};
+    void *write_cookie = NULL;
+    void *read_cookie = NULL;
+
+    ret = fill_iov(&iov, 'a', char_count);
+    if (ret) {
+        LOG_ERR("failed to create iov");
+        goto out;
+    }
+
+    write_cookie = strdup("write_cookie");
+    ret = glfs_pwritev_async(glfd, &iov, 1, 0, flags, write_async_cbk,
+                             &write_cookie);
 out:
-        if (ret < 0) {
-                LOG_ERR ("glfs_pwritev async failed");
-        }
-        return ret;
-
+    if (ret < 0) {
+        LOG_ERR("glfs_pwritev async failed");
+    }
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int         ret      = 0;
-        char       *hostname = NULL;
-        char       *volname  = NULL;
-        char       *logfile  = NULL;
-        glfs_t     *fs       = NULL;
-        const char *filename = "glfs_test.txt";
-        int         flags    = (O_RDWR|O_CREAT);
-        glfs_fd_t  *glfd     = NULL;
-        int         count    = 200;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = init_glfs (hostname, volname, logfile);
-        if (fs == NULL) {
-                LOG_ERR ("init_glfs failed");
-                return -1;
-        }
-
-        glfd = glfs_creat (fs, filename, flags, 0644);
-        if (glfd == NULL) {
-                LOG_ERR ("glfs_creat failed");
-                exit(1);
-        }
-
-        ret = write_async (fs, glfd, count);
-        if (ret) {
-                LOG_ERR ("glfs_test_function failed");
-                exit(1);
-        }
-
-        while (cbk_complete != 1) {
-                sleep(1);
-        }
-
-        ret = glfs_close (glfd);
-        if (ret < 0) {
-                LOG_ERR ("glfs close  failed");
-        }
-
-        /*
-         * skipping fini
-         */
-
-        if (cbk_ret_val == count)
-                return 0;
-        else
-                return -1;
+    int ret = 0;
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    glfs_t *fs = NULL;
+    const char *filename = "glfs_test.txt";
+    int flags = (O_RDWR | O_CREAT);
+    glfs_fd_t *glfd = NULL;
+    int count = 200;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = init_glfs(hostname, volname, logfile);
+    if (fs == NULL) {
+        LOG_ERR("init_glfs failed");
+        return -1;
+    }
+
+    glfd = glfs_creat(fs, filename, flags, 0644);
+    if (glfd == NULL) {
+        LOG_ERR("glfs_creat failed");
+        exit(1);
+    }
+
+    ret = write_async(fs, glfd, count);
+    if (ret) {
+        LOG_ERR("glfs_test_function failed");
+        exit(1);
+    }
+
+    while (cbk_complete != 1) {
+        sleep(1);
+    }
+
+    ret = glfs_close(glfd);
+    if (ret < 0) {
+        LOG_ERR("glfs close  failed");
+    }
+
+    /*
+     * skipping fini
+     */
+
+    if (cbk_ret_val == count)
+        return 0;
+    else
+        return -1;
 }
-
-
diff --git a/tests/basic/gfapi/gfapi-dup.c b/tests/basic/gfapi/gfapi-dup.c
index 96f133eae33..028108e4590 100644
--- a/tests/basic/gfapi/gfapi-dup.c
+++ b/tests/basic/gfapi/gfapi-dup.c
@@ -4,81 +4,81 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \
-        if (ret < 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto label; \
-        } \
-        } while (0)
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int             ret = -1;
-        int             flags = O_RDWR|O_SYNC;
-        glfs_t         *fs = NULL;
-        glfs_fd_t      *fd1 = NULL;
-        glfs_fd_t      *fd2 = NULL;
-        char           *volname = NULL;
-        char           *logfile = NULL;
-        char           *hostname = NULL;
-        const char     *filename = "file_tmp";
-        const char     *buff = "An opinion should be the result of thought, "
-                                "not a substitute for it.";
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                return 1;
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs)
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_new", ret, out);
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out);
-
-        ret = glfs_init (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out);
-
-        fd1 = glfs_creat(fs, filename, flags, 0644);
-        if (fd1 == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", ret, out);
-        }
-
-        ret = glfs_write (fd1, buff, strlen (buff), flags);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_write", ret, out);
-
-        fd2 = glfs_dup(fd1);
-        if (fd2 == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_dup", ret, out);
-        }
-
-        ret = glfs_lseek (fd2, 0, SEEK_SET);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_lseek", ret, out);
+    int ret = -1;
+    int flags = O_RDWR | O_SYNC;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+    const char *filename = "file_tmp";
+    const char *buff =
+        "An opinion should be the result of thought, "
+        "not a substitute for it.";
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        return 1;
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs)
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out);
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
+
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
+
+    fd1 = glfs_creat(fs, filename, flags, 0644);
+    if (fd1 == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out);
+    }
+
+    ret = glfs_write(fd1, buff, strlen(buff), flags);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_write", ret, out);
+
+    fd2 = glfs_dup(fd1);
+    if (fd2 == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_dup", ret, out);
+    }
+
+    ret = glfs_lseek(fd2, 0, SEEK_SET);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_lseek", ret, out);
 
 out:
-        if (fd1 != NULL)
-                glfs_close(fd1);
-        if (fd2 != NULL)
-                glfs_close(fd2);
-        if (fs) {
-                ret = glfs_fini(fs);
-                if (ret)
-                        fprintf (stderr, "glfs_fini(fs) returned %d\n", ret);
-        }
-
-        return ret;
+    if (fd1 != NULL)
+        glfs_close(fd1);
+    if (fd2 != NULL)
+        glfs_close(fd2);
+    if (fs) {
+        ret = glfs_fini(fs);
+        if (ret)
+            fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
+    }
+
+    return ret;
 }
-
-
diff --git a/tests/basic/gfapi/gfapi-load-volfile.c b/tests/basic/gfapi/gfapi-load-volfile.c
index 79502f7a44f..fbfc6045cd7 100644
--- a/tests/basic/gfapi/gfapi-load-volfile.c
+++ b/tests/basic/gfapi/gfapi-load-volfile.c
@@ -16,50 +16,50 @@
 void
 usage(FILE *output)
 {
-	fprintf(output, "Usage: " PROGNAME " <volfile>\n");
+    fprintf(output, "Usage: " PROGNAME " <volfile>\n");
 }
 
 void
 main(int argc, char **argv)
 {
-	int ret = 0;
-	glfs_t *fs = NULL;
+    int ret = 0;
+    glfs_t *fs = NULL;
 
-	if (argc != 2) {
-		usage(stderr);
-		exit(EXIT_FAILURE);
-	}
+    if (argc != 2) {
+        usage(stderr);
+        exit(EXIT_FAILURE);
+    }
 
-	if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "-h")) {
-		usage(stdout);
-		exit(EXIT_SUCCESS);
-	}
+    if (!strcmp(argv[1], "-h") || !strcmp(argv[1], "-h")) {
+        usage(stdout);
+        exit(EXIT_SUCCESS);
+    }
 
-	fs = glfs_new(PROGNAME);
-	if (!fs) {
-		perror("glfs_new failed");
-		exit(EXIT_FAILURE);
-	}
+    fs = glfs_new(PROGNAME);
+    if (!fs) {
+        perror("glfs_new failed");
+        exit(EXIT_FAILURE);
+    }
 
-	glfs_set_logging(fs, PROGNAME ".log", 9);
+    glfs_set_logging(fs, PROGNAME ".log", 9);
 
-	ret = glfs_set_volfile(fs, argv[1]);
-	if (ret) {
-		perror("glfs_set_volfile failed");
-		ret = EXIT_FAILURE;
-		goto out;
-	}
+    ret = glfs_set_volfile(fs, argv[1]);
+    if (ret) {
+        perror("glfs_set_volfile failed");
+        ret = EXIT_FAILURE;
+        goto out;
+    }
 
-	ret = glfs_init(fs);
-	if (ret) {
-		perror("glfs_init failed");
-		ret = EXIT_FAILURE;
-		goto out;
-	}
+    ret = glfs_init(fs);
+    if (ret) {
+        perror("glfs_init failed");
+        ret = EXIT_FAILURE;
+        goto out;
+    }
 
-	ret = EXIT_SUCCESS;
+    ret = EXIT_SUCCESS;
 out:
-	glfs_fini(fs);
+    glfs_fini(fs);
 
-	exit(ret);
+    exit(ret);
 }
diff --git a/tests/basic/gfapi/gfapi-ssl-test.c b/tests/basic/gfapi/gfapi-ssl-test.c
index 41126bdc6db..a27b5233702 100644
--- a/tests/basic/gfapi/gfapi-ssl-test.c
+++ b/tests/basic/gfapi/gfapi-ssl-test.c
@@ -9,118 +9,116 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(msg) do { \
-        fprintf (stderr, "%s : Error (%s)\n", msg, strerror (errno)); \
-        } while (0)
+#define LOG_ERR(msg)                                                           \
+    do {                                                                       \
+        fprintf(stderr, "%s : Error (%s)\n", msg, strerror(errno));            \
+    } while (0)
 
 glfs_t *
-init_glfs (const char *hostname, const char *volname,
-           const char *logfile)
+init_glfs(const char *hostname, const char *volname, const char *logfile)
 {
-        int     ret     = -1;
-        glfs_t *fs      = NULL;
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                LOG_ERR ("glfs_new failed");
-                return NULL;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_volfile_server failed");
-                goto out;
-        }
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                LOG_ERR ("glfs_set_logging failed");
-                goto out;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                LOG_ERR ("glfs_init failed");
-                goto out;
-        }
-
-        ret = 0;
+    int ret = -1;
+    glfs_t *fs = NULL;
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        LOG_ERR("glfs_new failed");
+        return NULL;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_volfile_server failed");
+        goto out;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        LOG_ERR("glfs_set_logging failed");
+        goto out;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        LOG_ERR("glfs_init failed");
+        goto out;
+    }
+
+    ret = 0;
 out:
-        if (ret) {
-                glfs_fini (fs);
-                fs = NULL;
-        }
+    if (ret) {
+        glfs_fini(fs);
+        fs = NULL;
+    }
 
-        return fs;
+    return fs;
 }
 
 int
-glfs_test_function (const char *hostname, const char *volname,
-                    const char *logfile)
+glfs_test_function(const char *hostname, const char *volname,
+                   const char *logfile)
 {
-        int             ret      = -1;
-        int             flags    = O_CREAT | O_RDWR;
-        glfs_t         *fs       = NULL;
-        glfs_fd_t      *glfd     = NULL;
-        const char     *buff     = "This is from my prog\n";
-        const char     *filename = "glfs_test.txt";
-
-        fs = init_glfs (hostname, volname, logfile);
-        if (fs == NULL) {
-                LOG_ERR ("init_glfs failed");
-                return -1;
-        }
-
-        glfd = glfs_creat (fs, filename, flags, 0644);
-        if (glfd == NULL) {
-                LOG_ERR ("glfs_creat failed");
-                goto out;
-        }
-
-        ret = glfs_write (glfd, buff, strlen (buff), flags);
-        if (ret < 0) {
-                LOG_ERR ("glfs_write failed");
-                goto out;
-        }
-
-        ret = glfs_close (glfd);
-        if (ret < 0) {
-                LOG_ERR ("glfs_write failed");
-                goto out;
-        }
+    int ret = -1;
+    int flags = O_CREAT | O_RDWR;
+    glfs_t *fs = NULL;
+    glfs_fd_t *glfd = NULL;
+    const char *buff = "This is from my prog\n";
+    const char *filename = "glfs_test.txt";
+
+    fs = init_glfs(hostname, volname, logfile);
+    if (fs == NULL) {
+        LOG_ERR("init_glfs failed");
+        return -1;
+    }
+
+    glfd = glfs_creat(fs, filename, flags, 0644);
+    if (glfd == NULL) {
+        LOG_ERR("glfs_creat failed");
+        goto out;
+    }
+
+    ret = glfs_write(glfd, buff, strlen(buff), flags);
+    if (ret < 0) {
+        LOG_ERR("glfs_write failed");
+        goto out;
+    }
+
+    ret = glfs_close(glfd);
+    if (ret < 0) {
+        LOG_ERR("glfs_write failed");
+        goto out;
+    }
 
 out:
-        ret = glfs_fini (fs);
-        if (ret) {
-                LOG_ERR ("glfs_fini failed");
-        }
+    ret = glfs_fini(fs);
+    if (ret) {
+        LOG_ERR("glfs_fini failed");
+    }
 
-        return ret;
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int   ret = 0;
-        char *hostname = NULL;
-        char *volname = NULL;
-        char *logfile = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        ret = glfs_test_function (hostname, volname, logfile);
-        if (ret) {
-                LOG_ERR ("glfs_test_function failed");
-        }
-
-        return ret;
+    int ret = 0;
+    char *hostname = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    ret = glfs_test_function(hostname, volname, logfile);
+    if (ret) {
+        LOG_ERR("glfs_test_function failed");
+    }
+
+    return ret;
 }
-
-
diff --git a/tests/basic/gfapi/gfapi-trunc.c b/tests/basic/gfapi/gfapi-trunc.c
index af187e50c78..769f6cfa1d9 100644
--- a/tests/basic/gfapi/gfapi-trunc.c
+++ b/tests/basic/gfapi/gfapi-trunc.c
@@ -5,86 +5,85 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \
-        if (ret < 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto label; \
-        } \
-        } while (0)
-
-#define WRITE_SIZE      4096
-#define TRUNC_SIZE      1234
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define WRITE_SIZE 4096
+#define TRUNC_SIZE 1234
 /* Make sure TRUNC_SIZE is smaller than WRITE_SIZE at compile time. */
-typedef char _size_check[WRITE_SIZE-TRUNC_SIZE];
+typedef char _size_check[WRITE_SIZE - TRUNC_SIZE];
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int             ret = -1;
-        int             flags = O_RDWR|O_SYNC;
-        glfs_t         *fs = NULL;
-        glfs_fd_t      *fd1 = NULL;
-        char           *volname = NULL;
-        char           *logfile = NULL;
-        const char     *filename = "file_tmp";
-        const char     buff[WRITE_SIZE];
-        struct stat    sb;
-
-        if (argc != 3) {
-                fprintf (stderr, "Invalid argument\n");
-                return 1;
-        }
-
-        volname = argv[1];
-        logfile = argv[2];
-
-        fs = glfs_new (volname);
-        if (!fs)
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_new", ret, out);
-
-        ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out);
-
-        ret = glfs_init (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out);
-
-        fd1 = glfs_creat(fs, filename, flags, 0644);
-        if (fd1 == NULL) {
-                ret = -1;
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", ret, out);
-        }
-
-        ret = glfs_write (fd1, buff, WRITE_SIZE, flags);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_write", ret, out);
-
-        ret = glfs_truncate (fs, filename, TRUNC_SIZE);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_truncate", ret, out);
-
-        ret = glfs_fstat (fd1, &sb);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_fstat", ret, out);
-
-        if (sb.st_size != TRUNC_SIZE) {
-                fprintf (stderr, "wrong size %jd should be %jd\n",
-                         (intmax_t)sb.st_size, (intmax_t)2048);
-                ret = -1;
-        }
+    int ret = -1;
+    int flags = O_RDWR | O_SYNC;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd1 = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    const char *filename = "file_tmp";
+    const char buff[WRITE_SIZE];
+    struct stat sb;
+
+    if (argc != 3) {
+        fprintf(stderr, "Invalid argument\n");
+        return 1;
+    }
+
+    volname = argv[1];
+    logfile = argv[2];
+
+    fs = glfs_new(volname);
+    if (!fs)
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_new", ret, out);
+
+    ret = glfs_set_volfile_server(fs, "tcp", "localhost", 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
+
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
+
+    fd1 = glfs_creat(fs, filename, flags, 0644);
+    if (fd1 == NULL) {
+        ret = -1;
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_creat", ret, out);
+    }
+
+    ret = glfs_write(fd1, buff, WRITE_SIZE, flags);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_write", ret, out);
+
+    ret = glfs_truncate(fs, filename, TRUNC_SIZE);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_truncate", ret, out);
+
+    ret = glfs_fstat(fd1, &sb);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_fstat", ret, out);
+
+    if (sb.st_size != TRUNC_SIZE) {
+        fprintf(stderr, "wrong size %jd should be %jd\n", (intmax_t)sb.st_size,
+                (intmax_t)2048);
+        ret = -1;
+    }
 
 out:
-        if (fd1 != NULL)
-                glfs_close(fd1);
-        if (fs) {
-                /*
-                 * If this fails (as it does on Special Snowflake NetBSD for no
-                 * good reason), it shouldn't affect the result of the test.
-                 */
-                (void) glfs_fini(fs);
-        }
-
-        return ret;
+    if (fd1 != NULL)
+        glfs_close(fd1);
+    if (fs) {
+        /*
+         * If this fails (as it does on Special Snowflake NetBSD for no
+         * good reason), it shouldn't affect the result of the test.
+         */
+        (void)glfs_fini(fs);
+    }
+
+    return ret;
 }
-
-
diff --git a/tests/basic/gfapi/glfd-lkowner.c b/tests/basic/gfapi/glfd-lkowner.c
index 031a076683c..ec0429dc3c4 100644
--- a/tests/basic/gfapi/glfd-lkowner.c
+++ b/tests/basic/gfapi/glfd-lkowner.c
@@ -13,200 +13,202 @@
 
 int gfapi = 1;
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-               fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 char lownera[8] = "lownera", lownerb[8] = "lownerb";
 char lownerc[8] = "lownerc";
 
-int lock_test (glfs_fd_t *glfd1, glfs_fd_t *glfd2, bool should_fail,
-               int l1_start, int l1_len, char *l1_owner, int lo1_len,
-               int l2_start, int l2_len, char *l2_owner, int lo2_len)
+int
+lock_test(glfs_fd_t *glfd1, glfs_fd_t *glfd2, bool should_fail, int l1_start,
+          int l1_len, char *l1_owner, int lo1_len, int l2_start, int l2_len,
+          char *l2_owner, int lo2_len)
 {
-        int ret = -1, f_ret = -1;
-        struct flock lock1 = {0, }, lock2 = {0, };
+    int ret = -1, f_ret = -1;
+    struct flock lock1 =
+                     {
+                         0,
+                     },
+                 lock2 = {
+                     0,
+                 };
 
 lock1:
-        if (!glfd1)
-                goto lock2;
+    if (!glfd1)
+        goto lock2;
 
-        /* lock on glfd1 */
-        lock1.l_type = F_WRLCK;
-        lock1.l_whence = SEEK_SET;
-        lock1.l_start = l1_start;
-        lock1.l_len = l1_len;
+    /* lock on glfd1 */
+    lock1.l_type = F_WRLCK;
+    lock1.l_whence = SEEK_SET;
+    lock1.l_start = l1_start;
+    lock1.l_len = l1_len;
 
-        ret = glfs_fd_set_lkowner (glfd1, l1_owner, lo1_len);
-        LOG_ERR ("glfs_fd_set_lkowner on glfd1", ret);
+    ret = glfs_fd_set_lkowner(glfd1, l1_owner, lo1_len);
+    LOG_ERR("glfs_fd_set_lkowner on glfd1", ret);
 
-        ret = glfs_posix_lock (glfd1, F_SETLK, &lock1);
-        LOG_ERR ("glfs_posix_lock on glfd1", ret);
+    ret = glfs_posix_lock(glfd1, F_SETLK, &lock1);
+    LOG_ERR("glfs_posix_lock on glfd1", ret);
 
 lock2:
-        if (!glfd2)
-                goto out;
-
-        /* lock on glfd2 */
-        lock2.l_type = F_WRLCK;
-        lock2.l_whence = SEEK_SET;
-        lock2.l_start = l2_start;
-        lock2.l_len = l2_len;
-
-        ret = glfs_fd_set_lkowner (glfd2, l2_owner, lo2_len);
-        LOG_ERR ("glfs_fd_set_lkowner on glfd2", ret);
-
-        ret = glfs_posix_lock (glfd2, F_SETLK, &lock2);
-
-        if (should_fail && ret) {
-                f_ret = 0;
-        } else if (!ret && !should_fail) {
-                f_ret = 0;
-        } else {
-                f_ret = -1;
-        }
+    if (!glfd2)
+        goto out;
+
+    /* lock on glfd2 */
+    lock2.l_type = F_WRLCK;
+    lock2.l_whence = SEEK_SET;
+    lock2.l_start = l2_start;
+    lock2.l_len = l2_len;
+
+    ret = glfs_fd_set_lkowner(glfd2, l2_owner, lo2_len);
+    LOG_ERR("glfs_fd_set_lkowner on glfd2", ret);
+
+    ret = glfs_posix_lock(glfd2, F_SETLK, &lock2);
+
+    if (should_fail && ret) {
+        f_ret = 0;
+    } else if (!ret && !should_fail) {
+        f_ret = 0;
+    } else {
+        f_ret = -1;
+    }
 out:
-        fprintf (stderr, "Lock test on glfd1 (start(%d), len(%d),"
-                         " lk_owner(%s)) and glfd2 (start(%d), len(%d), "
-                         "lk_owner(%s)) - expected(%s) - result(%s)\n",
-                         l1_start, l1_len, l1_owner, l2_start, l2_len, l2_owner,
-                         (should_fail ? "FAIL" : "SUCCESS"),
-                         (ret ? "FAIL" : "SUCCESS"));
-        return f_ret;
+    fprintf(stderr,
+            "Lock test on glfd1 (start(%d), len(%d),"
+            " lk_owner(%s)) and glfd2 (start(%d), len(%d), "
+            "lk_owner(%s)) - expected(%s) - result(%s)\n",
+            l1_start, l1_len, l1_owner, l2_start, l2_len, l2_owner,
+            (should_fail ? "FAIL" : "SUCCESS"), (ret ? "FAIL" : "SUCCESS"));
+    return f_ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        int        ret = 0, i, status = 0;
-        glfs_fd_t *fd1 = NULL;
-        glfs_fd_t *fd2 = NULL;
-        glfs_fd_t *fd3 = NULL;
-        char      *filename = "file_tmp";
-        char      *volname = NULL;
-        char      *logfile = NULL;
-        char      *hostname = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        fd1 = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644);
-        if (fd1 <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_creat", ret);
-        }
-        fprintf (stderr, "glfs-create fd1 - %d\n", fd1);
-
-        fd2 = glfs_dup(fd1);
-        fprintf (stderr, "glfs-dup fd2 - %d\n", fd2);
-
-        fd3 = glfs_open(fs, filename, O_RDWR|O_SYNC);
-        if (fd2 <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_open", ret);
-        }
-        fprintf (stderr, "glfs-open fd3 - %d\n", fd3);
-
-        /* TEST 1: Conflicting ranges, same lk_owner
-         * lock1 (0, 10, lownera)
-         * lock2 (5, 10, lownera)
-         * Expected: should not fail but get merged
-         */
-        ret = lock_test (fd1, fd2, false, 0, 10, lownera, 8,
-                         5, 10, lownera, 8);
-        LOG_ERR ("==== glfs_lock_test_1", ret);
-
-        /* TEST 2: Conflicting ranges, different lk_owner
-         * lock1 (0, 10, lownera) - already taken
-         * lock2 (5, 10, lownerb)
-         * Expected: should fail and not get merged
-         */
-        ret = lock_test (NULL, fd2, true, 0, 10, lownera, 8,
-                         5, 10, lownerb, 8);
-        LOG_ERR ("==== glfs_lock_test_2", ret);
-
-        /* TEST 3: Different ranges, same lk_owner
-         * lock1 (0, 10, lownera) - already taken
-         * lock2 (30, 10, lownera)
-         * Expected: should not fail
-         */
-        ret = lock_test (NULL, fd2, false, 0, 10, lownera, 8,
-                         30, 10, lownera, 8);
-        LOG_ERR ("==== glfs_lock_test_3", ret);
-
-        /* TEST 4: Conflicting ranges, different lk_owner
-         * lock1 (0, 10, lownera) - already taken
-         * lock2 (50, 10, lownerb)
-         * Expected: should not fail
-         */
-        ret = lock_test (NULL, fd2, false, 0, 10, lownera, 8,
-                         50, 10, lownerb, 8);
-        LOG_ERR ("==== glfs_lock_test_4", ret);
-
-        /* TEST 5: Close fd1 & retry TEST2
-         * lock1 (not applicable)
-         * lock2 (5, 10, lownerb)
-         * Expected: should succeed now
-         */
-        ret = glfs_close(fd1);
-        LOG_ERR ("glfs_close", ret);
-
-        ret = lock_test (NULL, fd2, false, 0, 10, lownera, 8,
-                         5, 10, lownerb, 8);
-        LOG_ERR ("==== glfs_lock_test_5", ret);
-
-        /* TEST 6: Check closing fd1 doesn't flush fd2 locks
-         * retry TEST 4 but with fd2 and fd3.
-         * lock1 (50, 10, lownerb) - already taken
-         * lock2 (55, 10, lownerc)
-         * Expected: should fail
-         */
-        ret = lock_test (NULL, fd3, true, 50, 10, lownerb, 8,
-                         55, 10, lownerc, 8);
-        LOG_ERR ("==== glfs_lock_test_6", ret);
+    glfs_t *fs = NULL;
+    int ret = 0, i, status = 0;
+    glfs_fd_t *fd1 = NULL;
+    glfs_fd_t *fd2 = NULL;
+    glfs_fd_t *fd3 = NULL;
+    char *filename = "file_tmp";
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    fd1 = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644);
+    if (fd1 <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_creat", ret);
+    }
+    fprintf(stderr, "glfs-create fd1 - %d\n", fd1);
+
+    fd2 = glfs_dup(fd1);
+    fprintf(stderr, "glfs-dup fd2 - %d\n", fd2);
+
+    fd3 = glfs_open(fs, filename, O_RDWR | O_SYNC);
+    if (fd2 <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_open", ret);
+    }
+    fprintf(stderr, "glfs-open fd3 - %d\n", fd3);
+
+    /* TEST 1: Conflicting ranges, same lk_owner
+     * lock1 (0, 10, lownera)
+     * lock2 (5, 10, lownera)
+     * Expected: should not fail but get merged
+     */
+    ret = lock_test(fd1, fd2, false, 0, 10, lownera, 8, 5, 10, lownera, 8);
+    LOG_ERR("==== glfs_lock_test_1", ret);
+
+    /* TEST 2: Conflicting ranges, different lk_owner
+     * lock1 (0, 10, lownera) - already taken
+     * lock2 (5, 10, lownerb)
+     * Expected: should fail and not get merged
+     */
+    ret = lock_test(NULL, fd2, true, 0, 10, lownera, 8, 5, 10, lownerb, 8);
+    LOG_ERR("==== glfs_lock_test_2", ret);
+
+    /* TEST 3: Different ranges, same lk_owner
+     * lock1 (0, 10, lownera) - already taken
+     * lock2 (30, 10, lownera)
+     * Expected: should not fail
+     */
+    ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 30, 10, lownera, 8);
+    LOG_ERR("==== glfs_lock_test_3", ret);
+
+    /* TEST 4: Conflicting ranges, different lk_owner
+     * lock1 (0, 10, lownera) - already taken
+     * lock2 (50, 10, lownerb)
+     * Expected: should not fail
+     */
+    ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 50, 10, lownerb, 8);
+    LOG_ERR("==== glfs_lock_test_4", ret);
+
+    /* TEST 5: Close fd1 & retry TEST2
+     * lock1 (not applicable)
+     * lock2 (5, 10, lownerb)
+     * Expected: should succeed now
+     */
+    ret = glfs_close(fd1);
+    LOG_ERR("glfs_close", ret);
+
+    ret = lock_test(NULL, fd2, false, 0, 10, lownera, 8, 5, 10, lownerb, 8);
+    LOG_ERR("==== glfs_lock_test_5", ret);
+
+    /* TEST 6: Check closing fd1 doesn't flush fd2 locks
+     * retry TEST 4 but with fd2 and fd3.
+     * lock1 (50, 10, lownerb) - already taken
+     * lock2 (55, 10, lownerc)
+     * Expected: should fail
+     */
+    ret = lock_test(NULL, fd3, true, 50, 10, lownerb, 8, 55, 10, lownerc, 8);
+    LOG_ERR("==== glfs_lock_test_6", ret);
 
 err:
-        ret = glfs_close(fd2);
-        LOG_ERR ("glfs_close", ret);
+    ret = glfs_close(fd2);
+    LOG_ERR("glfs_close", ret);
 
-        ret = glfs_close(fd3);
-        LOG_ERR ("glfs_close", ret);
+    ret = glfs_close(fd3);
+    LOG_ERR("glfs_close", ret);
 
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d\n", ret);
-        }
-
-        if (ret)
-                exit(1);
-        exit(0);
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
 }
diff --git a/tests/basic/gfapi/glfs_sysrq.c b/tests/basic/gfapi/glfs_sysrq.c
index c843c2a3559..13e06be6df2 100644
--- a/tests/basic/gfapi/glfs_sysrq.c
+++ b/tests/basic/gfapi/glfs_sysrq.c
@@ -10,52 +10,51 @@
 #include <glusterfs/api/glfs.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        /* cmdline arguments */
-        char   *host    = NULL;
-        char   *volume  = NULL;
-        char   *logfile = NULL;
-
-        /* other variables */
-        glfs_t *fs      = NULL;
-        int     ret     = 0;
-
-        if (argc != 4) {
-                fprintf (stderr, "Usage: %s <host> <volume> <logfile>\n",
-                         argv[0]);
-                return -1;
-        }
-
-        host = argv[1];
-        volume = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volume);
-        if (!fs) {
-                return -1;
-        }
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        if (ret < 0) {
-                return -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", host, 24007);
-        if (ret < 0) {
-                return -1;
-        }
-
-        ret = glfs_init (fs);
-        if (ret < 0) {
-                return -1;
-        }
-
-        /* checking of the results is easier in the script running this test */
-        glfs_sysrq (fs, GLFS_SYSRQ_HELP);
-        glfs_sysrq (fs, GLFS_SYSRQ_STATEDUMP);
-
-        glfs_fini (fs);
-
-        return 0;
+    /* cmdline arguments */
+    char *host = NULL;
+    char *volume = NULL;
+    char *logfile = NULL;
+
+    /* other variables */
+    glfs_t *fs = NULL;
+    int ret = 0;
+
+    if (argc != 4) {
+        fprintf(stderr, "Usage: %s <host> <volume> <logfile>\n", argv[0]);
+        return -1;
+    }
+
+    host = argv[1];
+    volume = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volume);
+    if (!fs) {
+        return -1;
+    }
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    if (ret < 0) {
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", host, 24007);
+    if (ret < 0) {
+        return -1;
+    }
+
+    ret = glfs_init(fs);
+    if (ret < 0) {
+        return -1;
+    }
+
+    /* checking of the results is easier in the script running this test */
+    glfs_sysrq(fs, GLFS_SYSRQ_HELP);
+    glfs_sysrq(fs, GLFS_SYSRQ_STATEDUMP);
+
+    glfs_fini(fs);
+
+    return 0;
 }
diff --git a/tests/basic/gfapi/glfs_xreaddirplus_r.c b/tests/basic/gfapi/glfs_xreaddirplus_r.c
index 17f4d1b1d57..0c4c79123eb 100644
--- a/tests/basic/gfapi/glfs_xreaddirplus_r.c
+++ b/tests/basic/gfapi/glfs_xreaddirplus_r.c
@@ -6,237 +6,237 @@
 #include <glusterfs/api/glfs-handles.h>
 #include <time.h>
 
-#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label) do { \
-        if (ret < 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto label; \
-        } \
-        } while (0)
-
-#define VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR(func, bool_var, ret, label) do { \
-        if (!bool_var) {            \
-                fprintf (stderr, "%s : returned error (%s)\n", \
-                         func, strerror (errno)); \
-                ret = -1;                         \
-                goto label; \
-        } \
-        } while (0)
+#define VALIDATE_AND_GOTO_LABEL_ON_ERROR(func, ret, label)                     \
+    do {                                                                       \
+        if (ret < 0) {                                                         \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
+
+#define VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR(func, bool_var, ret, label)      \
+    do {                                                                       \
+        if (!bool_var) {                                                       \
+            fprintf(stderr, "%s : returned error (%s)\n", func,                \
+                    strerror(errno));                                          \
+            ret = -1;                                                          \
+            goto label;                                                        \
+        }                                                                      \
+    } while (0)
 
 #define MAX_FILES_CREATE 10
-#define MAXPATHNAME      512
+#define MAXPATHNAME 512
 
 void
-assimilatetime (struct timespec *ts, struct timespec ts_st,
-                struct timespec ts_ed)
+assimilatetime(struct timespec *ts, struct timespec ts_st,
+               struct timespec ts_ed)
 {
-        if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) {
-                ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1;
-                ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec;
-        } else {
-                ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec;
-                ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec;
-        }
-
-        if (ts->tv_nsec > 1000000000) {
-                ts->tv_nsec = ts->tv_nsec - 1000000000;
-                ts->tv_sec += 1;
-        }
-
-        return;
+    if ((ts_ed.tv_nsec - ts_st.tv_nsec) < 0) {
+        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec - 1;
+        ts->tv_nsec += 1000000000 + ts_ed.tv_nsec - ts_st.tv_nsec;
+    } else {
+        ts->tv_sec += ts_ed.tv_sec - ts_st.tv_sec;
+        ts->tv_nsec += ts_ed.tv_nsec - ts_st.tv_nsec;
+    }
+
+    if (ts->tv_nsec > 1000000000) {
+        ts->tv_nsec = ts->tv_nsec - 1000000000;
+        ts->tv_sec += 1;
+    }
+
+    return;
 }
 
 /*
  * Returns '%' difference between ts1 & ts2
  */
 int
-comparetime (struct timespec ts1, struct timespec ts2)
+comparetime(struct timespec ts1, struct timespec ts2)
 {
-        uint64_t ts1_n, ts2_n;
-        int pct = 0;
+    uint64_t ts1_n, ts2_n;
+    int pct = 0;
 
-        ts1_n = (ts1.tv_sec * 1000000000) + ts1.tv_nsec;
-        ts2_n = (ts2.tv_sec * 1000000000) + ts2.tv_nsec;
+    ts1_n = (ts1.tv_sec * 1000000000) + ts1.tv_nsec;
+    ts2_n = (ts2.tv_sec * 1000000000) + ts2.tv_nsec;
 
-        pct = ((ts1_n - ts2_n)*100)/ts1_n;
+    pct = ((ts1_n - ts2_n) * 100) / ts1_n;
 
-        return pct;
+    return pct;
 }
 
 int
-old_readdir (glfs_t *fs)
+old_readdir(glfs_t *fs)
 {
-        struct glfs_object     *root = NULL;
-        struct glfs_fd         *fd = NULL;
-        struct stat            *sb = NULL;
-        char buf[512];
-        struct dirent          *entry = NULL;
-        int                     ret = -1;
-        struct glfs_object     *glhandle = NULL;
-
-        if (!fs)
-                return -1;
-
-        root = glfs_h_lookupat (fs, NULL, "/", sb, 0);
-        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_h_lookupat", !!root, ret, out);
-
-        fd = glfs_opendir (fs, "/");
-        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_opendir", !!fd, ret, out);
-
-        while (glfs_readdir_r (fd, (struct dirent *)buf, &entry), entry) {
-                if (strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) {
-                        glhandle = glfs_h_lookupat (fs, root, "/", sb, 0);
-                        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_h_lookupat", !!glhandle, ret, out);
-                }
+    struct glfs_object *root = NULL;
+    struct glfs_fd *fd = NULL;
+    struct stat *sb = NULL;
+    char buf[512];
+    struct dirent *entry = NULL;
+    int ret = -1;
+    struct glfs_object *glhandle = NULL;
+
+    if (!fs)
+        return -1;
+
+    root = glfs_h_lookupat(fs, NULL, "/", sb, 0);
+    VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", !!root, ret, out);
+
+    fd = glfs_opendir(fs, "/");
+    VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_opendir", !!fd, ret, out);
+
+    while (glfs_readdir_r(fd, (struct dirent *)buf, &entry), entry) {
+        if (strcmp(entry->d_name, ".") && strcmp(entry->d_name, "..")) {
+            glhandle = glfs_h_lookupat(fs, root, "/", sb, 0);
+            VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_h_lookupat", !!glhandle,
+                                                  ret, out);
         }
+    }
 
-        glfs_closedir (fd);
+    glfs_closedir(fd);
 
-        ret  = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-new_xreaddirplus (glfs_t *fs)
+new_xreaddirplus(glfs_t *fs)
 {
-        struct glfs_fd         *fd = NULL;
-        struct stat            *sb = NULL;
-        int                     ret = -1;
-        uint32_t                rflags = (GFAPI_XREADDIRP_STAT |
-                                          GFAPI_XREADDIRP_HANDLE);
-        struct glfs_xreaddirp_stat   *xstat = NULL;
-        struct dirent           de;
-        struct dirent          *pde = NULL;
-        struct glfs_object     *glhandle = NULL;
-
-        if (!fs)
-                return -1;
-
-        fd = glfs_opendir (fs, "/");
-        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_opendir", !!fd, ret, out);
-
-        ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde);
-        while (ret > 0 && pde != NULL) {
-                if (xstat) {
-                        sb = glfs_xreaddirplus_get_stat (xstat);
-                        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_xreaddirplus_get_stat", !!sb, ret, out);
-
-                        if (strcmp(de.d_name, ".") && strcmp(de.d_name, "..")) {
-                                glhandle = glfs_xreaddirplus_get_object (xstat);
-                                VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_xreaddirplus_get_object", !!glhandle, ret, out);
-                        }
-                }
-
-                if (xstat) {
-                        glfs_free(xstat);
-                        xstat = NULL;
-                }
+    struct glfs_fd *fd = NULL;
+    struct stat *sb = NULL;
+    int ret = -1;
+    uint32_t rflags = (GFAPI_XREADDIRP_STAT | GFAPI_XREADDIRP_HANDLE);
+    struct glfs_xreaddirp_stat *xstat = NULL;
+    struct dirent de;
+    struct dirent *pde = NULL;
+    struct glfs_object *glhandle = NULL;
+
+    if (!fs)
+        return -1;
+
+    fd = glfs_opendir(fs, "/");
+    VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_opendir", !!fd, ret, out);
+
+    ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde);
+    while (ret > 0 && pde != NULL) {
+        if (xstat) {
+            sb = glfs_xreaddirplus_get_stat(xstat);
+            VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_xreaddirplus_get_stat",
+                                                  !!sb, ret, out);
+
+            if (strcmp(de.d_name, ".") && strcmp(de.d_name, "..")) {
+                glhandle = glfs_xreaddirplus_get_object(xstat);
+                VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR(
+                    "glfs_xreaddirplus_get_object", !!glhandle, ret, out);
+            }
+        }
 
-                ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde);
+        if (xstat) {
+            glfs_free(xstat);
+            xstat = NULL;
+        }
 
-                VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_xreaddirp_r", ret, out);
+        ret = glfs_xreaddirplus_r(fd, rflags, &xstat, &de, &pde);
 
-        }
+        VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_xreaddirp_r", ret, out);
+    }
 
-        if (xstat)
-                glfs_free(xstat);
+    if (xstat)
+        glfs_free(xstat);
 
-        ret  = 0;
+    ret = 0;
 out:
-        return ret;
+    return ret;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int                     ret = -1;
-        glfs_t                 *fs = NULL;
-        char                   *volname = NULL;
-        char                   *logfile = NULL;
-        char                   *hostname = NULL;
-        char                   *my_file = "file_";
-        char                    my_file_name[MAXPATHNAME];
-        uint32_t                flags = O_RDWR|O_SYNC;
-        struct glfs_fd         *fd = NULL;
-        int                     i = 0;
-        int                     pct = 0;
-        struct timespec         timestamp = {0, 0}, st_timestamp, ed_timestamp;
-        struct timespec         otimestamp = {0, 0}, ost_timestamp, oed_timestamp;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                return 1;
-        }
+    int ret = -1;
+    glfs_t *fs = NULL;
+    char *volname = NULL;
+    char *logfile = NULL;
+    char *hostname = NULL;
+    char *my_file = "file_";
+    char my_file_name[MAXPATHNAME];
+    uint32_t flags = O_RDWR | O_SYNC;
+    struct glfs_fd *fd = NULL;
+    int i = 0;
+    int pct = 0;
+    struct timespec timestamp = {0, 0}, st_timestamp, ed_timestamp;
+    struct timespec otimestamp = {0, 0}, ost_timestamp, oed_timestamp;
 
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        return 1;
+    }
 
-        fs = glfs_new (volname);
-        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_new", !!fs, ret, out);
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_volfile_server", ret, out);
+    fs = glfs_new(volname);
+    VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_new", !!fs, ret, out);
 
-        ret = glfs_set_logging (fs, logfile, 7);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_set_logging", ret, out);
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_volfile_server", ret, out);
 
-        ret = glfs_init (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("glfs_init", ret, out);
+    ret = glfs_set_logging(fs, logfile, 7);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_set_logging", ret, out);
 
-        for (i = 0; i < MAX_FILES_CREATE; i++) {
-                sprintf (my_file_name, "%s%d", my_file, i);
+    ret = glfs_init(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("glfs_init", ret, out);
 
-                fd = glfs_creat(fs, my_file_name, flags, 0644);
-                VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR ("glfs_creat", !!fd, ret, out);
+    for (i = 0; i < MAX_FILES_CREATE; i++) {
+        sprintf(my_file_name, "%s%d", my_file, i);
 
-                glfs_close (fd);
-        }
+        fd = glfs_creat(fs, my_file_name, flags, 0644);
+        VALIDATE_BOOL_AND_GOTO_LABEL_ON_ERROR("glfs_creat", !!fd, ret, out);
 
-        /* measure performance using old readdir call and new xreaddirplus call and compare */
-        ret = clock_gettime (CLOCK_REALTIME, &ost_timestamp);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out);
+        glfs_close(fd);
+    }
 
-        ret = old_readdir (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("old_readdir", ret, out);
+    /* measure performance using old readdir call and new xreaddirplus call and
+     * compare */
+    ret = clock_gettime(CLOCK_REALTIME, &ost_timestamp);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
 
-        ret = clock_gettime (CLOCK_REALTIME, &oed_timestamp);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out);
+    ret = old_readdir(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("old_readdir", ret, out);
 
-        assimilatetime (&otimestamp, ost_timestamp, oed_timestamp);
+    ret = clock_gettime(CLOCK_REALTIME, &oed_timestamp);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
 
-        printf ("\tOverall time using readdir:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                otimestamp.tv_sec, otimestamp.tv_nsec);
+    assimilatetime(&otimestamp, ost_timestamp, oed_timestamp);
 
+    printf("\tOverall time using readdir:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
+           otimestamp.tv_sec, otimestamp.tv_nsec);
 
-        ret = clock_gettime (CLOCK_REALTIME, &st_timestamp);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out);
+    ret = clock_gettime(CLOCK_REALTIME, &st_timestamp);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
 
-        ret = new_xreaddirplus (fs);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("new_xreaddirplus", ret, out);
+    ret = new_xreaddirplus(fs);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("new_xreaddirplus", ret, out);
 
-        ret = clock_gettime (CLOCK_REALTIME, &ed_timestamp);
-        VALIDATE_AND_GOTO_LABEL_ON_ERROR ("clock_gettime", ret, out);
+    ret = clock_gettime(CLOCK_REALTIME, &ed_timestamp);
+    VALIDATE_AND_GOTO_LABEL_ON_ERROR("clock_gettime", ret, out);
 
-        assimilatetime (&timestamp, st_timestamp, ed_timestamp);
+    assimilatetime(&timestamp, st_timestamp, ed_timestamp);
 
-        printf ("\tOverall time using xreaddirplus:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
-                timestamp.tv_sec, timestamp.tv_nsec);
+    printf("\tOverall time using xreaddirplus:\n\t\tSecs:%ld\n\t\tnSecs:%ld\n",
+           timestamp.tv_sec, timestamp.tv_nsec);
 
+    pct = comparetime(otimestamp, timestamp);
+    printf("There is improvement by %d%%\n", pct);
 
-        pct = comparetime (otimestamp, timestamp);
-        printf ("There is improvement by %d%%\n", pct);
-
-        ret = 0;
+    ret = 0;
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                if (ret)
-                        fprintf (stderr, "glfs_fini(fs) returned %d\n", ret);
-        }
+    if (fs) {
+        ret = glfs_fini(fs);
+        if (ret)
+            fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
+    }
 
-        return ret;
+    return ret;
 }
-
-
diff --git a/tests/basic/gfapi/libgfapi-fini-hang.c b/tests/basic/gfapi/libgfapi-fini-hang.c
index e192751f295..37800e3188b 100644
--- a/tests/basic/gfapi/libgfapi-fini-hang.c
+++ b/tests/basic/gfapi/libgfapi-fini-hang.c
@@ -8,56 +8,55 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d\n", func, ret); \
-                exit(1); \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-} while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d\n", func, ret);            \
+            exit(1);                                                           \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        int        ret = 0, i;
-        glfs_fd_t *fd = NULL;
-        char       readbuf[32];
-        char      *logname = NULL;
-        char      *hostname = NULL;
-        char      *volname = NULL;
-
-        fprintf (stderr, "Starting libgfapi_fini\n");
-
-        if (argc < 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logname = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                exit(1);
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 0);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logname, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        /* Do not call glfs_init.
-         * glfs_fini() shouldn't hang in that case*/
-        ret = glfs_fini(fs);
-        LOG_ERR("glfs_fini", ret);
-        fprintf (stderr, "End of libgfapi_fini\n");
-
-        exit(0);
+    glfs_t *fs = NULL;
+    int ret = 0, i;
+    glfs_fd_t *fd = NULL;
+    char readbuf[32];
+    char *logname = NULL;
+    char *hostname = NULL;
+    char *volname = NULL;
+
+    fprintf(stderr, "Starting libgfapi_fini\n");
+
+    if (argc < 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logname = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        exit(1);
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 0);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logname, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    /* Do not call glfs_init.
+     * glfs_fini() shouldn't hang in that case*/
+    ret = glfs_fini(fs);
+    LOG_ERR("glfs_fini", ret);
+    fprintf(stderr, "End of libgfapi_fini\n");
+
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/mandatory-lock-optimal.c b/tests/basic/gfapi/mandatory-lock-optimal.c
index 4142258c06d..34fef8d0b80 100644
--- a/tests/basic/gfapi/mandatory-lock-optimal.c
+++ b/tests/basic/gfapi/mandatory-lock-optimal.c
@@ -1,11 +1,13 @@
 /* Pre-requisites:-
  *
- * 1. Make sure that performance translators are switched off while running this test.
+ * 1. Make sure that performance translators are switched off while running this
+ * test.
  * 2. Perform the following volume set operation:
  *    # gluster volume set <VOLNAME> locks.mandatory-locking optimal
  * 3. For installation under non-standard paths, export LD_LIBRARY_PATH to
  *    automatically load exact libgfapi.so and compile this C file as follows:
- *    $ gcc mandatory-lock-optimal.c -lgfapi -I <include path for api/glfs.h> -L <include path for libgfapi shared library>
+ *    $ gcc mandatory-lock-optimal.c -lgfapi -I <include path for api/glfs.h> -L
+ * <include path for libgfapi shared library>
  */
 
 #include <errno.h>
@@ -70,434 +72,461 @@ off_t offset;
    Expected result : First write should fail with EAGAIN.
                      Second write should pass. */
 
-#define LOG_ERR(func, err) do {                                                         \
-        if (!fp)                                                                        \
-                fprintf (stderr, "\n%s : returned error (%s)\n", func, strerror (err)); \
-        else                                                                            \
-                fprintf (fp, "\n%s : returned error (%s)\n", func, strerror (err));     \
-        cleanup_and_exit (err);                                                         \
-} while (0)
-
-void cleanup_and_exit (int exit_status) {
-        if (exit_status || test_count != TOTAL_TEST_COUNT) {
-                fprintf (fp, "\nAborting due to some test failures.\n");
-                exit_status = 1;
-        } else
-                fprintf (fp, "\nAll tests ran successfully.\n");
-        if (fp)
-                fclose (fp);
-        if (fd)
-                glfs_close (fd);
-        if (fd1)
-                glfs_close (fd1);
-        if (fd2)
-                glfs_close (fd2);
-
-        glfs_unlink (fs1, fname);
-
-        if (fs1)
-                glfs_fini (fs1);
-        if (fs2)
-                glfs_fini (fs2);
-
-        exit (exit_status);
+#define LOG_ERR(func, err)                                                     \
+    do {                                                                       \
+        if (!fp)                                                               \
+            fprintf(stderr, "\n%s : returned error (%s)\n", func,              \
+                    strerror(err));                                            \
+        else                                                                   \
+            fprintf(fp, "\n%s : returned error (%s)\n", func, strerror(err));  \
+        cleanup_and_exit(err);                                                 \
+    } while (0)
+
+void
+cleanup_and_exit(int exit_status)
+{
+    if (exit_status || test_count != TOTAL_TEST_COUNT) {
+        fprintf(fp, "\nAborting due to some test failures.\n");
+        exit_status = 1;
+    } else
+        fprintf(fp, "\nAll tests ran successfully.\n");
+    if (fp)
+        fclose(fp);
+    if (fd)
+        glfs_close(fd);
+    if (fd1)
+        glfs_close(fd1);
+    if (fd2)
+        glfs_close(fd2);
+
+    glfs_unlink(fs1, fname);
+
+    if (fs1)
+        glfs_fini(fs1);
+    if (fs2)
+        glfs_fini(fs2);
+
+    exit(exit_status);
 }
 
-glfs_t *new_client_create (char *hostname, char *volname, char *logfile_name) {
-        glfs_t *fs = NULL;
+glfs_t *
+new_client_create(char *hostname, char *volname, char *logfile_name)
+{
+    glfs_t *fs = NULL;
 
-        fs = glfs_new (volname);
-        if (!fs)
-                LOG_ERR ("glfs_new", errno);
+    fs = glfs_new(volname);
+    if (!fs)
+        LOG_ERR("glfs_new", errno);
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        if (ret)
-                LOG_ERR ("glfs_set_volfile_server", errno);
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    if (ret)
+        LOG_ERR("glfs_set_volfile_server", errno);
 
-        ret = glfs_set_logging (fs, logfile_name, 7);
-        if (ret)
-                LOG_ERR ("glfs_set_logging", errno);
+    ret = glfs_set_logging(fs, logfile_name, 7);
+    if (ret)
+        LOG_ERR("glfs_set_logging", errno);
 
-        ret = glfs_init (fs);
-        if (ret)
-                LOG_ERR ("glfs_init", errno);
+    ret = glfs_init(fs);
+    if (ret)
+        LOG_ERR("glfs_init", errno);
 
-        return fs;
+    return fs;
 }
 
-void run_test_1 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
-
-        fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
-
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
-
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
-
-        fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
-
-        /* On successful read, 0 is returned as there is no content inside the
-         * file
-         */
-        ret = glfs_read (fd2, buf1, 10, 0);
-        if (ret)
-                LOG_ERR ("glfs_read", errno);
-
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
-
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
-
-        test_count++;
-        fprintf (fp, "OK\n", i);
+void
+run_test_1(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
+
+    /* On successful read, 0 is returned as there is no content inside the
+     * file
+     */
+    ret = glfs_read(fd2, buf1, 10, 0);
+    if (ret)
+        LOG_ERR("glfs_read", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_2 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
+void
+run_test_2(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
 
-        fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
 
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
 
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
 
-        fd2 = glfs_open (fs2, fname, O_WRONLY | O_NONBLOCK);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
+    fd2 = glfs_open(fs2, fname, O_WRONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
 
-        ret = glfs_write (fd2, buf2, 10, 0);
-        if (ret == 10 || errno != EAGAIN)
-                LOG_ERR ("glfs_write", errno);
+    ret = glfs_write(fd2, buf2, 10, 0);
+    if (ret == 10 || errno != EAGAIN)
+        LOG_ERR("glfs_write", errno);
 
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
 
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
 
-        test_count++;
-        fprintf (fp, "OK\n", i);
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_3 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
-
-        fd1 = glfs_open (fs1, fname, O_WRONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
-
-        lock.l_type = F_WRLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
-
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
-
-        fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
-
-        /* Still there is no content inside file. So following read should
-         * return 0
-         */
-        ret = glfs_read (fd2, buf1, 10, 0);
-        if (ret)
-                LOG_ERR ("glfs_read", errno);
-
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
-
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
-
-        test_count++;
-        fprintf (fp, "OK\n", i);
+void
+run_test_3(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_WRONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
+
+    /* Still there is no content inside file. So following read should
+     * return 0
+     */
+    ret = glfs_read(fd2, buf1, 10, 0);
+    if (ret)
+        LOG_ERR("glfs_read", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_4 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
+void
+run_test_4(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
 
-        fd1 = glfs_open (fs1, fname, O_WRONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
+    fd1 = glfs_open(fs1, fname, O_WRONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
 
-        lock.l_type = F_WRLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
+    lock.l_type = F_WRLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
 
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
 
-        fd2 = glfs_open (fs2, fname, O_WRONLY | O_NONBLOCK);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
+    fd2 = glfs_open(fs2, fname, O_WRONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
 
-        ret = glfs_write (fd2, buf2, 10, 0);
-        if (ret != 10)
-                LOG_ERR ("glfs_write", errno);
+    ret = glfs_write(fd2, buf2, 10, 0);
+    if (ret != 10)
+        LOG_ERR("glfs_write", errno);
 
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
 
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
 
-        test_count++;
-        fprintf (fp, "OK\n", i);
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_5 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
+void
+run_test_5(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
 
-        fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
 
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
 
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
 
-        fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
 
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
 
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
 
-        test_count++;
-        fprintf (fp, "OK\n", i);
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_6 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
+void
+run_test_6(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
 
-        fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
 
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
 
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
 
-        fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC);
-        if (fd2)
-                LOG_ERR ("glfs_open", errno);
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK | O_TRUNC);
+    if (fd2)
+        LOG_ERR("glfs_open", errno);
 
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
 
-        test_count++;
-        fprintf (fp, "OK\n", i);
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_7 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
+void
+run_test_7(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
 
-        fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
 
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 5L;
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 5L;
 
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
 
-        fd2 = glfs_open (fs2, fname, O_RDWR | O_NONBLOCK);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
+    fd2 = glfs_open(fs2, fname, O_RDWR | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
 
-        ret = glfs_ftruncate (fd2, 4, NULL, NULL);
-        if (ret == 0 || errno != EAGAIN)
-                LOG_ERR ("glfs_ftruncate", errno);
+    ret = glfs_ftruncate(fd2, 4, NULL, NULL);
+    if (ret == 0 || errno != EAGAIN)
+        LOG_ERR("glfs_ftruncate", errno);
 
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
 
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
 
-        test_count++;
-        fprintf (fp, "OK\n", i);
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-void run_test_8 (int i) {
-        fprintf (fp, "\nRunning Test-%d . . . ", i);
-
-        fd1 = glfs_open (fs1, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd1)
-                LOG_ERR ("glfs_open", errno);
-
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0L;
-        lock.l_len = 10L;
-
-        ret = glfs_file_lock (fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
-
-        fd2 = glfs_open (fs2, fname, O_RDONLY | O_NONBLOCK);
-        if (!fd2)
-                LOG_ERR ("glfs_open", errno);
-
-        lock.l_type = F_RDLCK;
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 5L;
-        lock.l_len = 2L;
-
-        ret = glfs_file_lock (fd2, F_SETLK, &lock, GLFS_LK_MANDATORY);
-        if (ret)
-                LOG_ERR ("glfs_file_lock", errno);
-
-        fd3 = glfs_open (fs3, fname, O_RDWR | O_NONBLOCK);
-        if (!fd3)
-                LOG_ERR ("glfs_open", errno);
-
-        offset = glfs_lseek (fd3, 5L, SEEK_SET);
-        if (offset != 5)
-                LOG_ERR ("glfs_lseek", errno);
-
-        ret = glfs_write (fd3, buf2, 10, 0);
-        if (ret == 10 || errno != EAGAIN)
-                LOG_ERR ("glfs_write", errno);
-
-        offset = glfs_lseek (fd3, 8L, SEEK_SET);
-        if (offset != 8)
-                LOG_ERR ("glfs_lseek", errno);
-
-        ret = glfs_write (fd3, buf2, 10, 0);
-        if (ret != 10)
-                LOG_ERR ("glfs_write", errno);
-
-        ret = glfs_close (fd1);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd1 = NULL;
-
-        ret = glfs_close (fd2);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd2 = NULL;
-
-        ret = glfs_close (fd3);
-        if (ret)
-                LOG_ERR ("glfs_close", errno);
-        fd3 = NULL;
-
-        test_count++;
-        fprintf (fp, "OK\n", i);
+void
+run_test_8(int i)
+{
+    fprintf(fp, "\nRunning Test-%d . . . ", i);
+
+    fd1 = glfs_open(fs1, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd1)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0L;
+    lock.l_len = 10L;
+
+    ret = glfs_file_lock(fd1, F_SETLK, &lock, GLFS_LK_ADVISORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd2 = glfs_open(fs2, fname, O_RDONLY | O_NONBLOCK);
+    if (!fd2)
+        LOG_ERR("glfs_open", errno);
+
+    lock.l_type = F_RDLCK;
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 5L;
+    lock.l_len = 2L;
+
+    ret = glfs_file_lock(fd2, F_SETLK, &lock, GLFS_LK_MANDATORY);
+    if (ret)
+        LOG_ERR("glfs_file_lock", errno);
+
+    fd3 = glfs_open(fs3, fname, O_RDWR | O_NONBLOCK);
+    if (!fd3)
+        LOG_ERR("glfs_open", errno);
+
+    offset = glfs_lseek(fd3, 5L, SEEK_SET);
+    if (offset != 5)
+        LOG_ERR("glfs_lseek", errno);
+
+    ret = glfs_write(fd3, buf2, 10, 0);
+    if (ret == 10 || errno != EAGAIN)
+        LOG_ERR("glfs_write", errno);
+
+    offset = glfs_lseek(fd3, 8L, SEEK_SET);
+    if (offset != 8)
+        LOG_ERR("glfs_lseek", errno);
+
+    ret = glfs_write(fd3, buf2, 10, 0);
+    if (ret != 10)
+        LOG_ERR("glfs_write", errno);
+
+    ret = glfs_close(fd1);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd1 = NULL;
+
+    ret = glfs_close(fd2);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd2 = NULL;
+
+    ret = glfs_close(fd3);
+    if (ret)
+        LOG_ERR("glfs_close", errno);
+    fd3 = NULL;
+
+    test_count++;
+    fprintf(fp, "OK\n", i);
 }
 
-int main (int argc, char *argv[]) {
-        char logfile[50];
-
-        if (argc != 4) {
-                fprintf (stderr, "Usage: %s <server ip/hostname> <volume name> <test log directory>\n", argv[0]);
-                return 0;
-        }
-
-        sprintf (logfile, "%s/%s", argv[3], "mandatory-lock-optimal-test.log");
-        fp = fopen (logfile, "w");
-        if (!fp) {
-                fprintf (stderr, "\n%s\n", logfile);
-                LOG_ERR ("Log file creation", errno);
-        }
-
-        sprintf (logfile, "%s/%s", argv[3], "glfs-client-1.log");
-        fs1 = new_client_create (argv[1], argv[2], logfile);
-        if (!fs1)
-                LOG_ERR ("client-1 creation", EINVAL);
-
-        sprintf (logfile, "%s/%s", argv[3], "glfs-client-2.log");
-        fs2 = new_client_create (argv[1], argv[2], logfile);
-        if (!fs2)
-                LOG_ERR ("client-2 creation", EINVAL);
-
-        sprintf (logfile, "%s/%s", argv[3], "glfs-client-3.log");
-        fs3 = new_client_create (argv[1], argv[2], logfile);
-        if (!fs3)
-                LOG_ERR ("client-3 creation", EINVAL);
-
-        fd = glfs_creat (fs1, fname, O_RDWR, 0644);
-        if (!fd)
-                LOG_ERR ("glfs_creat", errno);
-
-        test_count = 0;
-
-        run_test_1 (1);
-        run_test_2 (2);
-        run_test_3 (3);
-        run_test_4 (4);
-        run_test_5 (5);
-        run_test_6 (6);
-        run_test_7 (7);
-        run_test_8 (8);
-
-        cleanup_and_exit (0);
+int
+main(int argc, char *argv[])
+{
+    char logfile[50];
 
+    if (argc != 4) {
+        fprintf(stderr,
+                "Usage: %s <server ip/hostname> <volume name> <test log "
+                "directory>\n",
+                argv[0]);
         return 0;
+    }
+
+    sprintf(logfile, "%s/%s", argv[3], "mandatory-lock-optimal-test.log");
+    fp = fopen(logfile, "w");
+    if (!fp) {
+        fprintf(stderr, "\n%s\n", logfile);
+        LOG_ERR("Log file creation", errno);
+    }
+
+    sprintf(logfile, "%s/%s", argv[3], "glfs-client-1.log");
+    fs1 = new_client_create(argv[1], argv[2], logfile);
+    if (!fs1)
+        LOG_ERR("client-1 creation", EINVAL);
+
+    sprintf(logfile, "%s/%s", argv[3], "glfs-client-2.log");
+    fs2 = new_client_create(argv[1], argv[2], logfile);
+    if (!fs2)
+        LOG_ERR("client-2 creation", EINVAL);
+
+    sprintf(logfile, "%s/%s", argv[3], "glfs-client-3.log");
+    fs3 = new_client_create(argv[1], argv[2], logfile);
+    if (!fs3)
+        LOG_ERR("client-3 creation", EINVAL);
+
+    fd = glfs_creat(fs1, fname, O_RDWR, 0644);
+    if (!fd)
+        LOG_ERR("glfs_creat", errno);
+
+    test_count = 0;
+
+    run_test_1(1);
+    run_test_2(2);
+    run_test_3(3);
+    run_test_4(4);
+    run_test_5(5);
+    run_test_6(6);
+    run_test_7(7);
+    run_test_8(8);
+
+    cleanup_and_exit(0);
+
+    return 0;
 }
diff --git a/tests/basic/gfapi/seek.c b/tests/basic/gfapi/seek.c
index fb2f6361bf3..85ea9b88141 100644
--- a/tests/basic/gfapi/seek.c
+++ b/tests/basic/gfapi/seek.c
@@ -18,80 +18,82 @@
 #include <glusterfs/api/glfs-handles.h>
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        glfs_t      *fs       = NULL;
-        int          ret      = 0;
-        glfs_fd_t   *fd       = NULL;
-        char        *filename = NULL;
-        char        *volname  = NULL;
-        char        *hostname = NULL;
-        struct stat  st       = { 0, };
-        off_t        hole_start = 0;
-        off_t        hole_end   = 0;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument, use %s <hostname> <vol> <file>\n",
-                                 argv[0]);
-                exit (1);
+    glfs_t *fs = NULL;
+    int ret = 0;
+    glfs_fd_t *fd = NULL;
+    char *filename = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+    struct stat st = {
+        0,
+    };
+    off_t hole_start = 0;
+    off_t hole_end = 0;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument, use %s <hostname> <vol> <file>\n",
+                argv[0]);
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    filename = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        perror("glfs_new() returned NULL");
+        return 1;
+    }
+
+    if (glfs_set_volfile_server(fs, "tcp", hostname, 24007)) {
+        perror("glfs_set_volfile_server");
+        return 1;
+    }
+
+    if (glfs_init(fs)) {
+        perror("glfs_init");
+        return 1;
+    }
+
+    fd = glfs_open(fs, filename, O_RDONLY);
+    if (fd <= 0) {
+        perror("glfs_open");
+        return 1;
+    }
+
+    if (glfs_fstat(fd, &st)) {
+        perror("glfs_fstat");
+        return 1;
+    }
+
+    while (hole_end < st.st_size) {
+        hole_start = glfs_lseek(fd, hole_end, SEEK_HOLE);
+        if (hole_start == -1 && errno == ENXIO)
+            /* no more holes */
+            break;
+        if (hole_start == -1) {
+            perror("no more holes");
+            break;
         }
 
-        hostname = argv[1];
-        volname = argv[2];
-        filename = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                perror ("glfs_new() returned NULL");
-                return 1;
-        }
-
-        if (glfs_set_volfile_server (fs, "tcp", hostname, 24007)) {
-                perror ("glfs_set_volfile_server");
-                return 1;
+        hole_end = glfs_lseek(fd, hole_start, SEEK_DATA);
+        if (hole_end == -1 && errno == ENXIO) {
+            /* no more data */
+            break;
         }
 
-        if (glfs_init (fs)) {
-                perror ("glfs_init");
-                return 1;
-        }
+        printf("HOLE found: %ld - %ld%s\n", hole_start, hole_end,
+               (hole_end == st.st_size) ? " (EOF)" : "");
+    }
 
-        fd = glfs_open (fs, filename, O_RDONLY);
-        if (fd <= 0) {
-                perror ("glfs_open");
-                return 1;
-        }
+    glfs_close(fd);
 
-        if (glfs_fstat (fd, &st)) {
-                perror ("glfs_fstat");
-                return 1;
-        }
-
-        while (hole_end < st.st_size) {
-                hole_start = glfs_lseek (fd, hole_end, SEEK_HOLE);
-                if (hole_start == -1 && errno == ENXIO)
-                        /* no more holes */
-                        break;
-                if (hole_start == -1) {
-			perror ("no more holes");
-			break;
-		}
-
-                hole_end = glfs_lseek (fd, hole_start, SEEK_DATA);
-                if (hole_end == -1 && errno == ENXIO) {
-                        /* no more data */
-                        break;
-                }
-
-                printf ("HOLE found: %ld - %ld%s\n", hole_start, hole_end,
-                         (hole_end == st.st_size) ? " (EOF)" : "");
-        }
-
-        glfs_close (fd);
-
-        if (fs) {
-                glfs_fini (fs);
-        }
+    if (fs) {
+        glfs_fini(fs);
+    }
 
-        return ret;
+    return ret;
 }
diff --git a/tests/basic/gfapi/upcall-cache-invalidate.c b/tests/basic/gfapi/upcall-cache-invalidate.c
index 2014bb9dccf..078286a8956 100644
--- a/tests/basic/gfapi/upcall-cache-invalidate.c
+++ b/tests/basic/gfapi/upcall-cache-invalidate.c
@@ -9,204 +9,201 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t                   *fs = NULL;
-        glfs_t                   *fs2 = NULL;
-        glfs_t                   *fs_tmp = NULL;
-        glfs_t                   *fs_tmp2 = NULL;
-        int                       ret = 0, i;
-        glfs_fd_t                *fd = NULL;
-        glfs_fd_t                *fd2 = NULL;
-        glfs_fd_t                *fd_tmp = NULL;
-        glfs_fd_t                *fd_tmp2 = NULL;
-        char                      readbuf[32];
-        char                     *filename = "file_tmp";
-        char                     *writebuf = NULL;
-        char                     *vol_id  = NULL;
-        unsigned int              cnt = 1;
-        struct glfs_upcall       *cbk = NULL;
-        char                     *logfile = NULL;
-        char                     *volname = NULL;
-        char                     *hostname = NULL;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
+    glfs_t *fs = NULL;
+    glfs_t *fs2 = NULL;
+    glfs_t *fs_tmp = NULL;
+    glfs_t *fs_tmp2 = NULL;
+    int ret = 0, i;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd2 = NULL;
+    glfs_fd_t *fd_tmp = NULL;
+    glfs_fd_t *fd_tmp2 = NULL;
+    char readbuf[32];
+    char *filename = "file_tmp";
+    char *writebuf = NULL;
+    char *vol_id = NULL;
+    unsigned int cnt = 1;
+    struct glfs_upcall *cbk = NULL;
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    /* This does not block, but enables caching of events. Real
+     * applications like NFS-Ganesha run this in a thread before activity
+     * on the fs (through this instance) happens. */
+    ret = glfs_h_poll_upcall(fs_tmp, &cbk);
+    LOG_ERR("glfs_h_poll_upcall", ret);
+
+    fs2 = glfs_new(volname);
+    if (!fs2) {
+        fprintf(stderr, "glfs_new fs2: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs2, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server-fs2", ret);
+
+    ret = glfs_set_logging(fs2, logfile, 7);
+    LOG_ERR("glfs_set_logging-fs2", ret);
+
+    ret = glfs_init(fs2);
+    LOG_ERR("glfs_init-fs2", ret);
+
+    fd = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644);
+    if (fd <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_creat", ret);
+    }
+    fprintf(stderr, "glfs-create fd - %d\n", fd);
+
+    fd2 = glfs_open(fs2, filename, O_SYNC | O_RDWR | O_CREAT);
+    if (fd2 <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_open-fs2", ret);
+    }
+    fprintf(stderr, "glfs-open fd2 - %d\n", fd2);
+
+    do {
+        if (cnt % 2) {
+            fd_tmp = fd;
+            fs_tmp = fs;
+            fd_tmp2 = fd2;
+            fs_tmp2 = fs2;
+        } else {
+            fd_tmp = fd2;
+            fs_tmp = fs2;
+            fd_tmp2 = fd;
+            fs_tmp2 = fs;
         }
 
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return -1;
+        /* WRITE on fd_tmp */
+        writebuf = malloc(10);
+        if (writebuf) {
+            memcpy(writebuf, "abcd", 4);
+            ret = glfs_write(fd_tmp, writebuf, 4, 0);
+            if (ret <= 0) {
+                ret = -1;
+                LOG_ERR("glfs_write", ret);
+            } else {
+                fprintf(stderr, "glfs_write succeeded\n");
+            }
+            free(writebuf);
+        } else {
+            fprintf(stderr, "Could not allocate writebuf\n");
+            return -1;
         }
 
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
+        /* READ on fd_tmp2 */
+        ret = glfs_lseek(fd_tmp2, 0, SEEK_SET);
+        LOG_ERR("glfs_lseek", ret);
 
-        /* This does not block, but enables caching of events. Real
-         * applications like NFS-Ganesha run this in a thread before activity
-         * on the fs (through this instance) happens. */
-        ret = glfs_h_poll_upcall(fs_tmp, &cbk);
-        LOG_ERR ("glfs_h_poll_upcall", ret);
+        memset(readbuf, 0, sizeof(readbuf));
+        ret = glfs_pread(fd_tmp2, readbuf, 4, 0, 0, NULL);
 
-        fs2 = glfs_new (volname);
-        if (!fs2) {
-                fprintf (stderr, "glfs_new fs2: returned NULL\n");
-                return 1;
+        if (ret <= 0) {
+            ret = -1;
+            LOG_ERR("glfs_pread", ret);
+        } else {
+            fprintf(stderr, "glfs_read: %s\n", readbuf);
         }
 
-        ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server-fs2", ret);
-
-        ret = glfs_set_logging (fs2, logfile, 7);
-        LOG_ERR("glfs_set_logging-fs2", ret);
-
-        ret = glfs_init (fs2);
-        LOG_ERR("glfs_init-fs2", ret);
-
-        fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644);
-        if (fd <= 0) {
+        /* Open() fops seem to be not performed on server side until
+         * there are I/Os on that fd
+         */
+        if (cnt > 2) {
+            struct glfs_upcall_inode *in_arg = NULL;
+            enum glfs_upcall_reason reason = 0;
+            struct glfs_object *object = NULL;
+            uint64_t flags = 0;
+            uint64_t expire = 0;
+
+            ret = glfs_h_poll_upcall(fs_tmp, &cbk);
+            LOG_ERR("glfs_h_poll_upcall", ret);
+
+            reason = glfs_upcall_get_reason(cbk);
+
+            /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */
+            if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
+                in_arg = glfs_upcall_get_event(cbk);
+
+                object = glfs_upcall_inode_get_object(in_arg);
+                flags = glfs_upcall_inode_get_flags(in_arg);
+                expire = glfs_upcall_inode_get_expire(in_arg);
+
+                fprintf(stderr,
+                        " upcall event type - %d,"
+                        " object(%p), flags(%d), "
+                        " expire_time_attr(%d)\n",
+                        reason, object, flags, expire);
+            } else {
+                fprintf(stderr, "Didn't receive upcall notify event");
                 ret = -1;
-                LOG_ERR ("glfs_creat", ret);
-        }
-        fprintf (stderr, "glfs-create fd - %d\n", fd);
+                goto err;
+            }
 
-        fd2 = glfs_open(fs2, filename, O_SYNC|O_RDWR|O_CREAT);
-        if (fd2 <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_open-fs2", ret);
+            glfs_free(cbk);
         }
-        fprintf (stderr, "glfs-open fd2 - %d\n", fd2);
-
-        do {
-                if (cnt%2) {
-                        fd_tmp = fd;
-                        fs_tmp = fs;
-                        fd_tmp2 = fd2;
-                        fs_tmp2 = fs2;
-                } else {
-                        fd_tmp = fd2;
-                        fs_tmp = fs2;
-                        fd_tmp2 = fd;
-                        fs_tmp2 = fs;
-                }
-
-                /* WRITE on fd_tmp */
-                writebuf = malloc(10);
-                if (writebuf) {
-                        memcpy (writebuf, "abcd", 4);
-                        ret = glfs_write (fd_tmp, writebuf, 4, 0);
-                        if (ret <= 0)   {
-                                ret = -1;
-                                LOG_ERR ("glfs_write", ret);
-                        } else {
-                                fprintf (stderr,
-                                         "glfs_write succeeded\n");
-                        }
-                        free(writebuf);
-                } else {
-                        fprintf (stderr,
-                                 "Could not allocate writebuf\n");
-                        return -1;
-                }
-
-                /* READ on fd_tmp2 */
-                ret = glfs_lseek (fd_tmp2, 0, SEEK_SET);
-                LOG_ERR ("glfs_lseek", ret);
-
-                memset (readbuf, 0, sizeof(readbuf));
-                ret = glfs_pread (fd_tmp2, readbuf, 4, 0, 0, NULL);
-
-                if (ret <= 0) {
-                        ret = -1;
-                        LOG_ERR ("glfs_pread", ret);
-                } else {
-                        fprintf (stderr, "glfs_read: %s\n", readbuf);
-                }
-
-                /* Open() fops seem to be not performed on server side until
-                 * there are I/Os on that fd
-                 */
-                if (cnt > 2) {
-                        struct glfs_upcall_inode *in_arg = NULL;
-                        enum glfs_upcall_reason   reason = 0;
-                        struct glfs_object       *object = NULL;
-                        uint64_t                  flags = 0;
-                        uint64_t                  expire = 0;
-
-                        ret = glfs_h_poll_upcall(fs_tmp, &cbk);
-                        LOG_ERR ("glfs_h_poll_upcall", ret);
-
-                        reason = glfs_upcall_get_reason (cbk);
-
-                        /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */
-                        if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
-                                in_arg = glfs_upcall_get_event (cbk);
-
-                                object = glfs_upcall_inode_get_object (in_arg);
-                                flags = glfs_upcall_inode_get_flags (in_arg);
-                                expire = glfs_upcall_inode_get_expire (in_arg);
-
-                                fprintf (stderr, " upcall event type - %d,"
-                                         " object(%p), flags(%d), "
-                                         " expire_time_attr(%d)\n" ,
-                                         reason, object, flags, expire);
-                        } else {
-                                fprintf (stderr,
-                                         "Didn't receive upcall notify event");
-                                ret = -1;
-                                goto err;
-                        }
-
-                        glfs_free (cbk);
-                }
-
-                sleep(5);
-        } while (++cnt < 5);
+
+        sleep(5);
+    } while (++cnt < 5);
 
 err:
-        glfs_close(fd);
-        LOG_ERR ("glfs_close", ret);
+    glfs_close(fd);
+    LOG_ERR("glfs_close", ret);
 
-        glfs_close(fd2);
-        LOG_ERR ("glfs_close-fd2", ret);
+    glfs_close(fd2);
+    LOG_ERR("glfs_close-fd2", ret);
 
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d \n", ret);
-        }
-
-        if (fs2) {
-                ret = glfs_fini(fs2);
-                fprintf (stderr, "glfs_fini(fs2) returned %d \n", ret);
-        }
-
-        if (ret)
-                exit(1);
-        exit(0);
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d \n", ret);
+    }
+
+    if (fs2) {
+        ret = glfs_fini(fs2);
+        fprintf(stderr, "glfs_fini(fs2) returned %d \n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
 }
-
-
diff --git a/tests/basic/gfapi/upcall-register-api.c b/tests/basic/gfapi/upcall-register-api.c
index 994069c0446..78594dbb108 100644
--- a/tests/basic/gfapi/upcall-register-api.c
+++ b/tests/basic/gfapi/upcall-register-api.c
@@ -9,273 +9,278 @@
 #include <glusterfs/api/glfs.h>
 #include <glusterfs/api/glfs-handles.h>
 
-#define LOG_ERR(func, ret) do { \
-        if (ret != 0) {            \
-                fprintf (stderr, "%s : returned error %d (%s)\n", \
-                         func, ret, strerror (errno)); \
-                goto out; \
-        } else { \
-                fprintf (stderr, "%s : returned %d\n", func, ret); \
-        } \
-        } while (0)
+#define LOG_ERR(func, ret)                                                     \
+    do {                                                                       \
+        if (ret != 0) {                                                        \
+            fprintf(stderr, "%s : returned error %d (%s)\n", func, ret,        \
+                    strerror(errno));                                          \
+            goto out;                                                          \
+        } else {                                                               \
+            fprintf(stderr, "%s : returned %d\n", func, ret);                  \
+        }                                                                      \
+    } while (0)
 
 int upcall_recv = 0;
 
-void up_async_invalidate (struct glfs_upcall *up_arg, void *data)
+void
+up_async_invalidate(struct glfs_upcall *up_arg, void *data)
 {
-        struct glfs_upcall_inode *in_arg = NULL;
-        enum glfs_upcall_reason   reason = 0;
-        struct glfs_object       *object = NULL;
-        uint64_t                  flags = 0;
-        uint64_t                  expire = 0;
+    struct glfs_upcall_inode *in_arg = NULL;
+    enum glfs_upcall_reason reason = 0;
+    struct glfs_object *object = NULL;
+    uint64_t flags = 0;
+    uint64_t expire = 0;
 
-        if (!up_arg)
-                return;
-
-        reason = glfs_upcall_get_reason (up_arg);
-
-        /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */
-
-        if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
-                in_arg = glfs_upcall_get_event (up_arg);
-
-                object = glfs_upcall_inode_get_object (in_arg);
-                flags = glfs_upcall_inode_get_flags (in_arg);
-                expire = glfs_upcall_inode_get_expire (in_arg);
-
-                fprintf (stderr, " upcall event type - %d,"
-                                 " object(%p), flags(%d), "
-                                 " expire_time_attr(%d)\n" ,
-                                 reason, object, flags, expire);
-                upcall_recv++;
-        }
-
-        glfs_free (up_arg);
+    if (!up_arg)
         return;
-}
 
-int perform_io (glfs_t *fs, glfs_t *fs2, int cnt)
-{
-        glfs_t                   *fs_tmp = NULL;
-        glfs_t                   *fs_tmp2 = NULL;
-        glfs_fd_t                *fd_tmp = NULL;
-        glfs_fd_t                *fd_tmp2 = NULL;
-        char                      readbuf[32];
-        char                     *writebuf = NULL;
-        glfs_fd_t                *fd = NULL;
-        glfs_fd_t                *fd2 = NULL;
-        char                     *filename = "file_tmp";
-        int                       ret = -1;
-
-        if (!fs || !fs2)
-                return -1;
-
-        /* Create file from fs and open it from fs2 */
-        fd = glfs_creat(fs, filename, O_RDWR|O_SYNC, 0644);
-        if (fd <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_creat", ret);
-        }
+    reason = glfs_upcall_get_reason(up_arg);
 
-        fd2 = glfs_open(fs2, filename, O_SYNC|O_RDWR|O_CREAT);
-        if (fd2 <= 0) {
-                ret = -1;
-                LOG_ERR ("glfs_open-fs2", ret);
-        }
+    /* Expect 'GLFS_INODE_INVALIDATE' upcall event. */
 
-        do {
-                if (cnt%2) {
-                        fd_tmp = fd;
-                        fs_tmp = fs;
-                        fd_tmp2 = fd2;
-                        fs_tmp2 = fs2;
-                } else {
-                        fd_tmp = fd2;
-                        fs_tmp = fs2;
-                        fd_tmp2 = fd;
-                        fs_tmp2 = fs;
-                }
-
-                /* WRITE on fd_tmp */
-                writebuf = malloc(10);
-                if (writebuf) {
-                        memcpy (writebuf, "abcd", 4);
-                        ret = glfs_write (fd_tmp, writebuf, 4, 0);
-                        if (ret <= 0)   {
-                                ret = -1;
-                                LOG_ERR ("glfs_write", ret);
-                        }
-                        free(writebuf);
-                } else {
-                        fprintf (stderr,
-                                 "Could not allocate writebuf\n");
-                        return -1;
-                }
-
-                /* READ on fd_tmp2 */
-                ret = glfs_lseek (fd_tmp2, 0, SEEK_SET);
-                LOG_ERR ("glfs_lseek", ret);
-
-                memset (readbuf, 0, sizeof(readbuf));
-                ret = glfs_pread (fd_tmp2, readbuf, 4, 0, 0, NULL);
-
-                if (ret <= 0) {
-                        ret = -1;
-                        LOG_ERR ("glfs_pread", ret);
-                }
-
-                sleep(2);
-        } while (--cnt > 0);
+    if (reason == GLFS_UPCALL_INODE_INVALIDATE) {
+        in_arg = glfs_upcall_get_event(up_arg);
 
-        sleep(2);
+        object = glfs_upcall_inode_get_object(in_arg);
+        flags = glfs_upcall_inode_get_flags(in_arg);
+        expire = glfs_upcall_inode_get_expire(in_arg);
 
-        ret = 0;
-err:
-        glfs_close(fd);
+        fprintf(stderr,
+                " upcall event type - %d,"
+                " object(%p), flags(%d), "
+                " expire_time_attr(%d)\n",
+                reason, object, flags, expire);
+        upcall_recv++;
+    }
 
-        glfs_close(fd2);
-
-out:
-        return ret;
+    glfs_free(up_arg);
+    return;
 }
 
 int
-main (int argc, char *argv[])
+perform_io(glfs_t *fs, glfs_t *fs2, int cnt)
 {
-        glfs_t                   *fs = NULL;
-        glfs_t                   *fs2 = NULL;
-        int                       ret = 0, i;
-        char                     *vol_id  = NULL;
-        unsigned int              cnt = 5;
-        struct glfs_upcall       *cbk = NULL;
-        char                     *logfile = NULL;
-        char                     *volname = NULL;
-        char                     *hostname = NULL;
-        int                      up_events = GLFS_EVENT_ANY;
-
-        if (argc != 4) {
-                fprintf (stderr, "Invalid argument\n");
-                exit(1);
-        }
-
-        hostname = argv[1];
-        volname = argv[2];
-        logfile = argv[3];
-
-        /* Initialize fs */
-        fs = glfs_new (volname);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return -1;
-        }
-
-        ret = glfs_set_volfile_server (fs, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server", ret);
-
-        ret = glfs_set_logging (fs, logfile, 7);
-        LOG_ERR("glfs_set_logging", ret);
-
-        ret = glfs_init (fs);
-        LOG_ERR("glfs_init", ret);
-
-        /* Initialize fs2 */
-        fs2 = glfs_new (volname);
-        if (!fs2) {
-                fprintf (stderr, "glfs_new fs2: returned NULL\n");
-                return 1;
-        }
-
-        ret = glfs_set_volfile_server (fs2, "tcp", hostname, 24007);
-        LOG_ERR("glfs_set_volfile_server-fs2", ret);
-
-        ret = glfs_set_logging (fs2, logfile, 7);
-        LOG_ERR("glfs_set_logging-fs2", ret);
-
-        ret = glfs_init (fs2);
-        LOG_ERR("glfs_init-fs2", ret);
-
-        /* Register Upcalls */
-        ret = glfs_upcall_register (fs, up_events, up_async_invalidate, NULL);
-
-        /* Check if the return mask contains the event */
-        if (!(ret & GLFS_EVENT_INODE_INVALIDATE)) {
-                fprintf (stderr, "glfs_upcall_register return doesn't contain"
-                         " upcall event\n");
-                return -1;
-        }
-
-        ret = glfs_upcall_register (fs2, up_events, up_async_invalidate, NULL);
-
-        /* Check if the return mask contains the event */
-        if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
-                fprintf (stderr, "glfs_upcall_register return doesn't contain"
-                         " upcall event\n");
-                return -1;
+    glfs_t *fs_tmp = NULL;
+    glfs_t *fs_tmp2 = NULL;
+    glfs_fd_t *fd_tmp = NULL;
+    glfs_fd_t *fd_tmp2 = NULL;
+    char readbuf[32];
+    char *writebuf = NULL;
+    glfs_fd_t *fd = NULL;
+    glfs_fd_t *fd2 = NULL;
+    char *filename = "file_tmp";
+    int ret = -1;
+
+    if (!fs || !fs2)
+        return -1;
+
+    /* Create file from fs and open it from fs2 */
+    fd = glfs_creat(fs, filename, O_RDWR | O_SYNC, 0644);
+    if (fd <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_creat", ret);
+    }
+
+    fd2 = glfs_open(fs2, filename, O_SYNC | O_RDWR | O_CREAT);
+    if (fd2 <= 0) {
+        ret = -1;
+        LOG_ERR("glfs_open-fs2", ret);
+    }
+
+    do {
+        if (cnt % 2) {
+            fd_tmp = fd;
+            fs_tmp = fs;
+            fd_tmp2 = fd2;
+            fs_tmp2 = fs2;
+        } else {
+            fd_tmp = fd2;
+            fs_tmp = fs2;
+            fd_tmp2 = fd;
+            fs_tmp2 = fs;
         }
 
-        /* Perform I/O */
-        ret = perform_io (fs, fs2, cnt);
-        LOG_ERR("perform_io", ret);
-
-        if (upcall_recv == 0) {
-                fprintf (stderr, "Upcalls are not received.\n");
+        /* WRITE on fd_tmp */
+        writebuf = malloc(10);
+        if (writebuf) {
+            memcpy(writebuf, "abcd", 4);
+            ret = glfs_write(fd_tmp, writebuf, 4, 0);
+            if (ret <= 0) {
                 ret = -1;
+                LOG_ERR("glfs_write", ret);
+            }
+            free(writebuf);
         } else {
-                fprintf (stderr, "Received %d upcalls as expected\n",
-                         upcall_recv);
-                ret = 0;
+            fprintf(stderr, "Could not allocate writebuf\n");
+            return -1;
         }
 
-        sleep(5); /* to flush out previous upcalls if any */
+        /* READ on fd_tmp2 */
+        ret = glfs_lseek(fd_tmp2, 0, SEEK_SET);
+        LOG_ERR("glfs_lseek", ret);
 
-        /* Now unregister and check there are no upcall events received */
-        ret = glfs_upcall_unregister (fs, up_events);
+        memset(readbuf, 0, sizeof(readbuf));
+        ret = glfs_pread(fd_tmp2, readbuf, 4, 0, 0, NULL);
 
-        /* Check if the return mask contains the event */
-        if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
-                fprintf (stderr, "glfs_upcall_register return doesn't contain"
-                         " upcall event\n");
-                return -1;
+        if (ret <= 0) {
+            ret = -1;
+            LOG_ERR("glfs_pread", ret);
         }
 
-        ret = glfs_upcall_unregister (fs2, up_events);
+        sleep(2);
+    } while (--cnt > 0);
 
-        /* Check if the return mask contains the event */
-        if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
-                fprintf (stderr, "glfs_upcall_register return doesn't contain"
-                         " upcall event\n");
-                return -1;
-        }
+    sleep(2);
 
-        upcall_recv = 0;
+    ret = 0;
+err:
+    glfs_close(fd);
 
-        ret = perform_io (fs, fs2, cnt);
-        LOG_ERR("perform_io", ret);
-
-        if (upcall_recv != 0) {
-                fprintf (stderr, "%d upcalls received even after unregister.\n",
-                         upcall_recv);
-                ret = -1;
-        } else {
-                fprintf (stderr, "Post unregister, no upcalls received as"
-                         " expected\n");
-                ret = 0;
-        }
+    glfs_close(fd2);
 
 out:
-        if (fs) {
-                ret = glfs_fini(fs);
-                fprintf (stderr, "glfs_fini(fs) returned %d\n", ret);
-        }
-
-        if (fs2) {
-                ret = glfs_fini(fs2);
-                fprintf (stderr, "glfs_fini(fs2) returned %d\n", ret);
-        }
-
-        if (ret)
-                exit(1);
-        exit(0);
+    return ret;
 }
 
+int
+main(int argc, char *argv[])
+{
+    glfs_t *fs = NULL;
+    glfs_t *fs2 = NULL;
+    int ret = 0, i;
+    char *vol_id = NULL;
+    unsigned int cnt = 5;
+    struct glfs_upcall *cbk = NULL;
+    char *logfile = NULL;
+    char *volname = NULL;
+    char *hostname = NULL;
+    int up_events = GLFS_EVENT_ANY;
+
+    if (argc != 4) {
+        fprintf(stderr, "Invalid argument\n");
+        exit(1);
+    }
+
+    hostname = argv[1];
+    volname = argv[2];
+    logfile = argv[3];
+
+    /* Initialize fs */
+    fs = glfs_new(volname);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return -1;
+    }
+
+    ret = glfs_set_volfile_server(fs, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server", ret);
+
+    ret = glfs_set_logging(fs, logfile, 7);
+    LOG_ERR("glfs_set_logging", ret);
+
+    ret = glfs_init(fs);
+    LOG_ERR("glfs_init", ret);
+
+    /* Initialize fs2 */
+    fs2 = glfs_new(volname);
+    if (!fs2) {
+        fprintf(stderr, "glfs_new fs2: returned NULL\n");
+        return 1;
+    }
+
+    ret = glfs_set_volfile_server(fs2, "tcp", hostname, 24007);
+    LOG_ERR("glfs_set_volfile_server-fs2", ret);
+
+    ret = glfs_set_logging(fs2, logfile, 7);
+    LOG_ERR("glfs_set_logging-fs2", ret);
+
+    ret = glfs_init(fs2);
+    LOG_ERR("glfs_init-fs2", ret);
+
+    /* Register Upcalls */
+    ret = glfs_upcall_register(fs, up_events, up_async_invalidate, NULL);
+
+    /* Check if the return mask contains the event */
+    if (!(ret & GLFS_EVENT_INODE_INVALIDATE)) {
+        fprintf(stderr,
+                "glfs_upcall_register return doesn't contain"
+                " upcall event\n");
+        return -1;
+    }
+
+    ret = glfs_upcall_register(fs2, up_events, up_async_invalidate, NULL);
+
+    /* Check if the return mask contains the event */
+    if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
+        fprintf(stderr,
+                "glfs_upcall_register return doesn't contain"
+                " upcall event\n");
+        return -1;
+    }
+
+    /* Perform I/O */
+    ret = perform_io(fs, fs2, cnt);
+    LOG_ERR("perform_io", ret);
+
+    if (upcall_recv == 0) {
+        fprintf(stderr, "Upcalls are not received.\n");
+        ret = -1;
+    } else {
+        fprintf(stderr, "Received %d upcalls as expected\n", upcall_recv);
+        ret = 0;
+    }
+
+    sleep(5); /* to flush out previous upcalls if any */
+
+    /* Now unregister and check there are no upcall events received */
+    ret = glfs_upcall_unregister(fs, up_events);
+
+    /* Check if the return mask contains the event */
+    if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
+        fprintf(stderr,
+                "glfs_upcall_register return doesn't contain"
+                " upcall event\n");
+        return -1;
+    }
+
+    ret = glfs_upcall_unregister(fs2, up_events);
+
+    /* Check if the return mask contains the event */
+    if ((ret < 0) || !(ret & GLFS_EVENT_INODE_INVALIDATE)) {
+        fprintf(stderr,
+                "glfs_upcall_register return doesn't contain"
+                " upcall event\n");
+        return -1;
+    }
+
+    upcall_recv = 0;
+
+    ret = perform_io(fs, fs2, cnt);
+    LOG_ERR("perform_io", ret);
+
+    if (upcall_recv != 0) {
+        fprintf(stderr, "%d upcalls received even after unregister.\n",
+                upcall_recv);
+        ret = -1;
+    } else {
+        fprintf(stderr,
+                "Post unregister, no upcalls received as"
+                " expected\n");
+        ret = 0;
+    }
 
+out:
+    if (fs) {
+        ret = glfs_fini(fs);
+        fprintf(stderr, "glfs_fini(fs) returned %d\n", ret);
+    }
+
+    if (fs2) {
+        ret = glfs_fini(fs2);
+        fprintf(stderr, "glfs_fini(fs2) returned %d\n", ret);
+    }
+
+    if (ret)
+        exit(1);
+    exit(0);
+}
diff --git a/tests/basic/logchecks.c b/tests/basic/logchecks.c
index a40278b0d77..86891057230 100644
--- a/tests/basic/logchecks.c
+++ b/tests/basic/logchecks.c
@@ -18,191 +18,197 @@
 #include "logchecks-messages.h"
 #include "../../libglusterfs/src/logging.h"
 
-glusterfs_ctx_t   *ctx = NULL;
+glusterfs_ctx_t *ctx = NULL;
 
-#define TEST_FILENAME           "/tmp/logchecks.log"
-#define GF_LOG_CONTROL_FILE     "/etc/glusterfs/logger.conf"
+#define TEST_FILENAME "/tmp/logchecks.log"
+#define GF_LOG_CONTROL_FILE "/etc/glusterfs/logger.conf"
 
 int
 go_log_vargs(gf_loglevel_t level, const char *fmt, ...)
 {
-        va_list  ap;
+    va_list ap;
 
-        va_start (ap, fmt);
-        gf_msg_vplain (level, fmt, ap);
-        va_end (ap);
+    va_start(ap, fmt);
+    gf_msg_vplain(level, fmt, ap);
+    va_end(ap);
 
-        return 0;
+    return 0;
 }
 
 int
-go_log (void)
+go_log(void)
 {
-        /*** gf_msg ***/
-        gf_msg ("logchecks", GF_LOG_INFO, 0, logchecks_msg_1);
-        gf_msg ("logchecks", GF_LOG_INFO, 22, logchecks_msg_2, 42, "Forty-Two",
-                42);
-        /* change criticality */
-        gf_msg ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_3);
-        gf_msg ("logchecks", GF_LOG_CRITICAL, 22, logchecks_msg_4, 42,
-                "Forty-Two", 42);
-
-        /*** msg_nomem ***/
-        gf_msg_nomem ("logchecks", GF_LOG_ALERT, 555);
-        gf_msg_nomem ("logchecks", GF_LOG_INFO, 555);
-
-        /*** msg_plain ***/
-        gf_msg_plain (GF_LOG_INFO, "Informational: gf_msg_plain with"
-                        " args %d:%s:%x", 42, "Forty-Two", 42);
-        gf_msg_plain (GF_LOG_ALERT, "Alert: gf_msg_plain with"
-                        " args %d:%s:%x", 42, "Forty-Two", 42);
-
-        /*** msg_vplain ***/
-        go_log_vargs (GF_LOG_INFO, "Informational: gf_msg_vplain: No args!!!");
-        go_log_vargs (GF_LOG_INFO, "Informational: gf_msg_vplain: Some"
-                        " args %d:%s:%x", 42, "Forty-Two", 42);
-        go_log_vargs (GF_LOG_INFO, "Critical: gf_msg_vplain: No args!!!");
-        go_log_vargs (GF_LOG_INFO, "Critical: gf_msg_vplain: Some"
-                        " args %d:%s:%x", 42, "Forty-Two", 42);
-
-        /*** msg_plain_nomem ***/
-        gf_msg_plain_nomem (GF_LOG_INFO, "Informational: gf_msg_plain_nomem");
-        gf_msg_plain_nomem (GF_LOG_ALERT, "Alert: gf_msg_plain_nomem");
-
-        /*** msg_backtrace_nomem ***/
-        // TODO: Need to create a stack depth and then call
-        gf_msg_backtrace_nomem (GF_LOG_INFO, 5);
-        gf_msg_backtrace_nomem (GF_LOG_ALERT, 5);
-
-        /*** gf_msg_callingfn ***/
-        // TODO: Need to create a stack depth and then call
-        gf_msg_callingfn ("logchecks", GF_LOG_INFO, 0, logchecks_msg_7);
-        gf_msg_callingfn ("logchecks", GF_LOG_INFO, 0, logchecks_msg_8, 42,
-                          "Forty-Two", 42);
-        gf_msg_callingfn ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_9);
-        gf_msg_callingfn ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_10, 42,
-                          "Forty-Two", 42);
-
-        /*** gf_msg_debug ***/
-        gf_msg_debug ("logchecks", 0, "Debug: Hello World!!!");
-        gf_msg_debug ("logchecks", 22, "Debug: With args %d:%s:%x", 42,
-                      "Forty-Two", 42);
-
-        /*** gf_msg_trace ***/
-        gf_msg_trace ("logchecks", 0, "Trace: Hello World!!!");
-        gf_msg_trace ("logchecks", 22, "Trace: With args %d:%s:%x", 42,
-                      "Forty-Two", 42);
-
-        /*** gf_msg_backtrace ***/
-        // TODO: Test with lower callstr values to check truncation
-
-        return 0;
+    /*** gf_msg ***/
+    gf_msg("logchecks", GF_LOG_INFO, 0, logchecks_msg_1);
+    gf_msg("logchecks", GF_LOG_INFO, 22, logchecks_msg_2, 42, "Forty-Two", 42);
+    /* change criticality */
+    gf_msg("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_3);
+    gf_msg("logchecks", GF_LOG_CRITICAL, 22, logchecks_msg_4, 42, "Forty-Two",
+           42);
+
+    /*** msg_nomem ***/
+    gf_msg_nomem("logchecks", GF_LOG_ALERT, 555);
+    gf_msg_nomem("logchecks", GF_LOG_INFO, 555);
+
+    /*** msg_plain ***/
+    gf_msg_plain(GF_LOG_INFO,
+                 "Informational: gf_msg_plain with"
+                 " args %d:%s:%x",
+                 42, "Forty-Two", 42);
+    gf_msg_plain(GF_LOG_ALERT,
+                 "Alert: gf_msg_plain with"
+                 " args %d:%s:%x",
+                 42, "Forty-Two", 42);
+
+    /*** msg_vplain ***/
+    go_log_vargs(GF_LOG_INFO, "Informational: gf_msg_vplain: No args!!!");
+    go_log_vargs(GF_LOG_INFO,
+                 "Informational: gf_msg_vplain: Some"
+                 " args %d:%s:%x",
+                 42, "Forty-Two", 42);
+    go_log_vargs(GF_LOG_INFO, "Critical: gf_msg_vplain: No args!!!");
+    go_log_vargs(GF_LOG_INFO,
+                 "Critical: gf_msg_vplain: Some"
+                 " args %d:%s:%x",
+                 42, "Forty-Two", 42);
+
+    /*** msg_plain_nomem ***/
+    gf_msg_plain_nomem(GF_LOG_INFO, "Informational: gf_msg_plain_nomem");
+    gf_msg_plain_nomem(GF_LOG_ALERT, "Alert: gf_msg_plain_nomem");
+
+    /*** msg_backtrace_nomem ***/
+    // TODO: Need to create a stack depth and then call
+    gf_msg_backtrace_nomem(GF_LOG_INFO, 5);
+    gf_msg_backtrace_nomem(GF_LOG_ALERT, 5);
+
+    /*** gf_msg_callingfn ***/
+    // TODO: Need to create a stack depth and then call
+    gf_msg_callingfn("logchecks", GF_LOG_INFO, 0, logchecks_msg_7);
+    gf_msg_callingfn("logchecks", GF_LOG_INFO, 0, logchecks_msg_8, 42,
+                     "Forty-Two", 42);
+    gf_msg_callingfn("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_9);
+    gf_msg_callingfn("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_10, 42,
+                     "Forty-Two", 42);
+
+    /*** gf_msg_debug ***/
+    gf_msg_debug("logchecks", 0, "Debug: Hello World!!!");
+    gf_msg_debug("logchecks", 22, "Debug: With args %d:%s:%x", 42, "Forty-Two",
+                 42);
+
+    /*** gf_msg_trace ***/
+    gf_msg_trace("logchecks", 0, "Trace: Hello World!!!");
+    gf_msg_trace("logchecks", 22, "Trace: With args %d:%s:%x", 42, "Forty-Two",
+                 42);
+
+    /*** gf_msg_backtrace ***/
+    // TODO: Test with lower callstr values to check truncation
+
+    return 0;
 }
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        int                ret = -1;
-
-        unlink (GF_LOG_CONTROL_FILE);
-        creat (GF_LOG_CONTROL_FILE, O_RDONLY);
-        ctx = glusterfs_ctx_new ();
-        if (!ctx)
-                return -1;
-
-        ret = glusterfs_globals_init (ctx);
-        if (ret) {
-                printf ("Error from glusterfs_globals_init [%s]\n",
-                        strerror (errno));
-                return ret;
-        }
-
-        /* Pre init test, message should not be printed */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_19);
-
-        THIS->ctx = ctx;
-
-        /* TEST 1: messages before initializing the log, goes to stderr
-         * and syslog based on criticality */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_12);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 2: messages post initialization, goes to glusterlog and
-         * syslog based on severity */
-        ret = gf_log_init(ctx, TEST_FILENAME, "logchecks");
-        if (ret != 0) {
-                printf ("Error from gf_log_init [%s]\n", strerror (errno));
-                return -1;
-        }
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_13);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 3: Test rotation */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_logrotate (0);
-        gf_msg ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_5);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 4: Check flush, nothing noticeable should occur :) */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_flush ();
-        gf_msg ("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_6);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 5: Change format */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_logformat (gf_logformat_traditional);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 6: Change level */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_loglevel (ctx, GF_LOG_CRITICAL);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* Reset to run with syslog */
-        gf_log_set_logformat (gf_logformat_withmsgid);
-        gf_log_set_loglevel (ctx, GF_LOG_INFO);
-
-        /* Run tests with logger changed to syslog */
-        /* TEST 7: No more gluster logs */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_logger (gf_logger_syslog);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_16);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 8: Change format */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_logformat (gf_logformat_traditional);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        /* TEST 9: Change level */
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-        gf_log_set_loglevel (ctx, GF_LOG_CRITICAL);
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15);
-        go_log ();
-        gf_msg ("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
-
-        // TODO: signal crash prints, but not yet feasible here
-        // TODO: Graph printing
-        // TODO: Multi threaded logging
-
-        /* Close out the logging */
-        gf_log_fini (ctx);
-        gf_log_globals_fini ();
-
-        unlink (GF_LOG_CONTROL_FILE);
-        unlink (TEST_FILENAME);
-
-        return 0;
+    int ret = -1;
+
+    unlink(GF_LOG_CONTROL_FILE);
+    creat(GF_LOG_CONTROL_FILE, O_RDONLY);
+    ctx = glusterfs_ctx_new();
+    if (!ctx)
+        return -1;
+
+    ret = glusterfs_globals_init(ctx);
+    if (ret) {
+        printf("Error from glusterfs_globals_init [%s]\n", strerror(errno));
+        return ret;
+    }
+
+    /* Pre init test, message should not be printed */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_19);
+
+    THIS->ctx = ctx;
+
+    /* TEST 1: messages before initializing the log, goes to stderr
+     * and syslog based on criticality */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_12);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 2: messages post initialization, goes to glusterlog and
+     * syslog based on severity */
+    ret = gf_log_init(ctx, TEST_FILENAME, "logchecks");
+    if (ret != 0) {
+        printf("Error from gf_log_init [%s]\n", strerror(errno));
+        return -1;
+    }
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_13);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 3: Test rotation */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_logrotate(0);
+    gf_msg("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_5);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 4: Check flush, nothing noticeable should occur :) */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_flush();
+    gf_msg("logchecks", GF_LOG_CRITICAL, 0, logchecks_msg_6);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 5: Change format */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_logformat(gf_logformat_traditional);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 6: Change level */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_loglevel(ctx, GF_LOG_CRITICAL);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* Reset to run with syslog */
+    gf_log_set_logformat(gf_logformat_withmsgid);
+    gf_log_set_loglevel(ctx, GF_LOG_INFO);
+
+    /* Run tests with logger changed to syslog */
+    /* TEST 7: No more gluster logs */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_logger(gf_logger_syslog);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_16);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 8: Change format */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_logformat(gf_logformat_traditional);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_14);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    /* TEST 9: Change level */
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+    gf_log_set_loglevel(ctx, GF_LOG_CRITICAL);
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_15);
+    go_log();
+    gf_msg("logchecks", GF_LOG_ALERT, 0, logchecks_msg_11);
+
+    // TODO: signal crash prints, but not yet feasible here
+    // TODO: Graph printing
+    // TODO: Multi threaded logging
+
+    /* Close out the logging */
+    gf_log_fini(ctx);
+    gf_log_globals_fini();
+
+    unlink(GF_LOG_CONTROL_FILE);
+    unlink(TEST_FILENAME);
+
+    return 0;
 }
diff --git a/tests/basic/posix/zero-fill-enospace.c b/tests/basic/posix/zero-fill-enospace.c
index 7c0d31128b3..1371ff59a5f 100644
--- a/tests/basic/posix/zero-fill-enospace.c
+++ b/tests/basic/posix/zero-fill-enospace.c
@@ -3,62 +3,64 @@
 #include <glusterfs/api/glfs-handles.h>
 
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-        glfs_t    *fs = NULL;
-        glfs_fd_t *fd = NULL;
-        int        ret = 1;
-        int        size = 0;
+    glfs_t *fs = NULL;
+    glfs_fd_t *fd = NULL;
+    int ret = 1;
+    int size = 0;
 
-        if (argc != 6) {
-                fprintf (stderr, "Syntax: %s <host> <volname> <file-path> <log-file> <size>\n", argv[0]);
-                return 1;
-        }
+    if (argc != 6) {
+        fprintf(stderr,
+                "Syntax: %s <host> <volname> <file-path> <log-file> <size>\n",
+                argv[0]);
+        return 1;
+    }
 
-        fs = glfs_new (argv[2]);
-        if (!fs) {
-                fprintf (stderr, "glfs_new: returned NULL\n");
-                return 1;
-        }
+    fs = glfs_new(argv[2]);
+    if (!fs) {
+        fprintf(stderr, "glfs_new: returned NULL\n");
+        return 1;
+    }
 
-        ret = glfs_set_volfile_server (fs, "tcp", argv[1], 24007);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_volfile_server: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_set_logging (fs, argv[4], 7);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_set_logging: returned %d\n", ret);
-                goto out;
-        }
-        ret = glfs_init (fs);
-        if (ret != 0) {
-                fprintf (stderr, "glfs_init: returned %d\n", ret);
-                goto out;
-        }
+    ret = glfs_set_volfile_server(fs, "tcp", argv[1], 24007);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_volfile_server: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_set_logging(fs, argv[4], 7);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_set_logging: returned %d\n", ret);
+        goto out;
+    }
+    ret = glfs_init(fs);
+    if (ret != 0) {
+        fprintf(stderr, "glfs_init: returned %d\n", ret);
+        goto out;
+    }
 
-        fd = glfs_open (fs, argv[3], O_RDWR);
-        if (fd == NULL) {
-                fprintf (stderr, "glfs_open: returned NULL\n");
-                goto out;
-        }
+    fd = glfs_open(fs, argv[3], O_RDWR);
+    if (fd == NULL) {
+        fprintf(stderr, "glfs_open: returned NULL\n");
+        goto out;
+    }
 
-        size = atoi(argv[5]);
-        if (size < 0) {
-                fprintf (stderr, "Wrong size %s", argv[5]);
-                goto out;
-        }
-        ret = glfs_zerofill (fd, 0, atoi(argv[5]));
-        if (ret <= 0) {
-                fprintf (stderr, "glfs_zerofill: returned %d\n", ret);
-                goto out;
-        }
+    size = atoi(argv[5]);
+    if (size < 0) {
+        fprintf(stderr, "Wrong size %s", argv[5]);
+        goto out;
+    }
+    ret = glfs_zerofill(fd, 0, atoi(argv[5]));
+    if (ret <= 0) {
+        fprintf(stderr, "glfs_zerofill: returned %d\n", ret);
+        goto out;
+    }
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (fd)
-                glfs_close(fd);
-        glfs_fini (fs);
-        return ret;
+    if (fd)
+        glfs_close(fd);
+    glfs_fini(fs);
+    return ret;
 }
diff --git a/tests/basic/quota.c b/tests/basic/quota.c
index f69b0ea9bc5..809ceb8e54c 100644
--- a/tests/basic/quota.c
+++ b/tests/basic/quota.c
@@ -8,83 +8,82 @@
 #include <unistd.h>
 
 ssize_t
-nwrite (int fd, const void *buf, size_t count)
+nwrite(int fd, const void *buf, size_t count)
 {
-        ssize_t  ret        = 0;
-        ssize_t  written    = 0;
+    ssize_t ret = 0;
+    ssize_t written = 0;
 
-        for (written = 0; written != count; written += ret) {
-                ret = write (fd, buf + written, count - written);
-                if (ret < 0) {
-                        if (errno == EINTR)
-                                ret = 0;
-                        else
-                                goto out;
-                }
+    for (written = 0; written != count; written += ret) {
+        ret = write(fd, buf + written, count - written);
+        if (ret < 0) {
+            if (errno == EINTR)
+                ret = 0;
+            else
+                goto out;
         }
+    }
 
-        ret = written;
+    ret = written;
 out:
-        return ret;
+    return ret;
 }
 
 int
-file_write (char *filename, int bs, int count)
+file_write(char *filename, int bs, int count)
 {
-        int  fd              = 0;
-        int  ret             = -1;
-        int  i               = 0;
-        char *buf            = NULL;
+    int fd = 0;
+    int ret = -1;
+    int i = 0;
+    char *buf = NULL;
 
-        bs = bs * 1024;
+    bs = bs * 1024;
 
-        buf = (char *) malloc (bs);
-        if (buf == NULL)
-                goto out;
+    buf = (char *)malloc(bs);
+    if (buf == NULL)
+        goto out;
 
-        memset (buf, 0, bs);
+    memset(buf, 0, bs);
 
-        fd = open (filename, O_RDWR|O_CREAT|O_SYNC, 0600);
-        while (i < count) {
-                ret = nwrite(fd, buf, bs);
-                if (ret == -1) {
-                        close (fd);
-                        goto out;
-                }
-                i++;
+    fd = open(filename, O_RDWR | O_CREAT | O_SYNC, 0600);
+    while (i < count) {
+        ret = nwrite(fd, buf, bs);
+        if (ret == -1) {
+            close(fd);
+            goto out;
         }
+        i++;
+    }
 
-        ret = fdatasync(fd);
-        if (ret) {
-                close (fd);
-                goto out;
-        }
+    ret = fdatasync(fd);
+    if (ret) {
+        close(fd);
+        goto out;
+    }
 
-        ret = close(fd);
-        if (ret)
-                goto out;
+    ret = close(fd);
+    if (ret)
+        goto out;
 
-        ret = 0;
+    ret = 0;
 
 out:
-        if (buf)
-                free (buf);
-        return ret;
+    if (buf)
+        free(buf);
+    return ret;
 }
 
 int
-main (int argc, char **argv)
+main(int argc, char **argv)
 {
-        if (argc != 4) {
-                printf("Usage: %s <filename> <block size in k> <count>\n",
-                        argv[0]);
-                return EXIT_FAILURE;
-        }
+    if (argc != 4) {
+        printf("Usage: %s <filename> <block size in k> <count>\n", argv[0]);
+        return EXIT_FAILURE;
+    }
 
-        if (file_write (argv[1], atoi(argv[2]), atoi(argv[3])) < 0) {
-                perror ("write failed");
-                return EXIT_FAILURE;
-        }
+    if (file_write(argv[1], atoi(argv[2]), atoi(argv[3])) < 0) {
+        perror("write failed");
+        return EXIT_FAILURE;
+    }
 
-        return EXIT_SUCCESS;
+    return EXIT_SUCCESS;
 }
diff --git a/tests/basic/tier/file_lock.c b/tests/basic/tier/file_lock.c
index 730cca92e42..20fdbc0f668 100644
--- a/tests/basic/tier/file_lock.c
+++ b/tests/basic/tier/file_lock.c
@@ -3,73 +3,70 @@
 #include <unistd.h>
 #include <fcntl.h>
 
-
-void usage (void)
+void
+usage(void)
 {
-
-        printf ("Usage: testlock <filepath> [R|W]\n");
-        return;
+    printf("Usage: testlock <filepath> [R|W]\n");
+    return;
 }
 
-
-int main (int argc, char *argv[])
+int
+main(int argc, char *argv[])
 {
-        char *file_path = NULL;
-        int fd = -1;
-        struct flock lock = {0};
-        int ret = -1;
-        int c = 0;
-
-        if (argc != 3) {
-                usage ();
-                exit (1);
-        }
-
-        file_path = argv[1];
-        fd = open (file_path, O_RDWR);
-
-        if (-1 == fd) {
-                printf ("Failed to open file %s. %m\n", file_path);
-                exit (1);
-        }
-
-        /* TODO: Check for invalid input*/
-
-        if (!strcmp (argv[2], "W")) {
-                lock.l_type = F_WRLCK;
-                printf("Taking write lock\n");
-
-        } else {
-                lock.l_type = F_RDLCK;
-                printf("Taking read lock\n");
-        }
-
-        lock.l_whence = SEEK_SET;
-        lock.l_start = 0;
-        lock.l_len = 0;
-        lock.l_pid = getpid ();
-
-
-        printf ("Acquiring lock on %s\n", file_path);
-        ret = fcntl (fd, F_SETLK, &lock);
-        if (ret) {
-                printf ("Failed to acquire lock on %s (%m)\n", file_path);
-                close (fd);
-                exit (1);
-        }
-
-        sleep(10);
-
-        /*Unlock*/
-
-        printf ("Releasing lock on %s\n", file_path);
-        lock.l_type = F_UNLCK;
-        ret = fcntl (fd, F_SETLK, &lock);
-        if (ret) {
-                printf ("Failed to release lock on %s (%m)\n", file_path);
-        }
-
-        close (fd);
-        return ret;
-
+    char *file_path = NULL;
+    int fd = -1;
+    struct flock lock = {0};
+    int ret = -1;
+    int c = 0;
+
+    if (argc != 3) {
+        usage();
+        exit(1);
+    }
+
+    file_path = argv[1];
+    fd = open(file_path, O_RDWR);
+
+    if (-1 == fd) {
+        printf("Failed to open file %s. %m\n", file_path);
+        exit(1);
+    }
+
+    /* TODO: Check for invalid input*/
+
+    if (!strcmp(argv[2], "W")) {
+        lock.l_type = F_WRLCK;
+        printf("Taking write lock\n");
+
+    } else {
+        lock.l_type = F_RDLCK;
+        printf("Taking read lock\n");
+    }
+
+    lock.l_whence = SEEK_SET;
+    lock.l_start = 0;
+    lock.l_len = 0;
+    lock.l_pid = getpid();
+
+    printf("Acquiring lock on %s\n", file_path);
+    ret = fcntl(fd, F_SETLK, &lock);
+    if (ret) {
+        printf("Failed to acquire lock on %s (%m)\n", file_path);
+        close(fd);
+        exit(1);
+    }
+
+    sleep(10);
+
+    /*Unlock*/
+
+    printf("Releasing lock on %s\n", file_path);
+    lock.l_type = F_UNLCK;
+    ret = fcntl(fd, F_SETLK, &lock);
+    if (ret) {
+        printf("Failed to release lock on %s (%m)\n", file_path);
+    }
+
+    close(fd);
+    return ret;
 }