Clang-format of source files

1 files changed, 83 insertions, 84 deletions

diff --git a/test/trefstr.c b/test/trefstr.c
index c33b5eb..18e357e 100644
--- a/test/trefstr.c
+++ b/test/trefstr.c
@@ -58,23 +58,23 @@ test_refstr_init(void)
 static void
 test_refstr_create(void)
 {
-    H5RS_str_t *rs;     /* Ref-counted string created */
-    unsigned count;     /* Reference count on string */
-    herr_t ret;         /* Generic return value */
+    H5RS_str_t *rs;    /* Ref-counted string created */
+    unsigned    count; /* Reference count on string */
+    herr_t      ret;   /* Generic return value */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Creating & Closing Ref-Counted Strings\n"));
 
     /* Try creating a ref-counted string */
-    rs=H5RS_create("foo");
+    rs = H5RS_create("foo");
     CHECK_PTR(rs, "H5RS_create");
 
     /* Get the reference count on the string */
-    count=H5RS_get_count(rs);
+    count = H5RS_get_count(rs);
     VERIFY(count, 1, "H5RS_get_count");
 
     /* Try closing a real ref-counted string */
-    ret=H5RS_decr(rs);
+    ret = H5RS_decr(rs);
     CHECK(ret, FAIL, "H5RS_decr");
 
 } /* end test_refstr_create() */
@@ -88,39 +88,39 @@ test_refstr_create(void)
 static void
 test_refstr_count(void)
 {
-    H5RS_str_t *rs;     /* Ref-counted string created */
-    unsigned count;     /* Reference count on string */
-    herr_t ret;         /* Generic return value */
+    H5RS_str_t *rs;    /* Ref-counted string created */
+    unsigned    count; /* Reference count on string */
+    herr_t      ret;   /* Generic return value */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Incrementing & Decrementing Ref-Counted Strings\n"));
 
     /* Try creating a ref-counted string */
-    rs=H5RS_create("foo");
+    rs = H5RS_create("foo");
     CHECK_PTR(rs, "H5RS_create");
 
     /* Get the reference count on the string */
-    count=H5RS_get_count(rs);
+    count = H5RS_get_count(rs);
     VERIFY(count, 1, "H5RS_get_count");
 
     /* Increment reference count */
-    ret=H5RS_incr(rs);
+    ret = H5RS_incr(rs);
     CHECK(ret, FAIL, "H5RS_incr");
 
     /* Get the reference count on the string */
-    count=H5RS_get_count(rs);
+    count = H5RS_get_count(rs);
     VERIFY(count, 2, "H5RS_get_count");
 
     /* Decrement reference count for string */
-    ret=H5RS_decr(rs);
+    ret = H5RS_decr(rs);
     CHECK(ret, FAIL, "H5RS_decr");
 
     /* Get the reference count on the string */
-    count=H5RS_get_count(rs);
+    count = H5RS_get_count(rs);
     VERIFY(count, 1, "H5RS_get_count");
 
     /* Decrement reference count for string */
-    ret=H5RS_decr(rs);
+    ret = H5RS_decr(rs);
     CHECK(ret, FAIL, "H5RS_decr");
 
 } /* end test_refstr_count() */
@@ -134,42 +134,42 @@ test_refstr_count(void)
 static void
 test_refstr_dup(void)
 {
-    H5RS_str_t *rs1;    /* Ref-counted string created */
-    H5RS_str_t *rs2;    /* Ref-counted string created */
-    unsigned count;     /* Reference count on string */
-    herr_t ret;         /* Generic return value */
+    H5RS_str_t *rs1;   /* Ref-counted string created */
+    H5RS_str_t *rs2;   /* Ref-counted string created */
+    unsigned    count; /* Reference count on string */
+    herr_t      ret;   /* Generic return value */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Duplicating Ref-Counted Strings\n"));
 
     /* Try creating a ref-counted string */
-    rs1=H5RS_create("foo");
+    rs1 = H5RS_create("foo");
     CHECK_PTR(rs1, "H5RS_create");
 
     /* Get the reference count on the string */
-    count=H5RS_get_count(rs1);
+    count = H5RS_get_count(rs1);
     VERIFY(count, 1, "H5RS_get_count");
 
     /* Duplicate r-string */
-    rs2=H5RS_dup(rs1);
+    rs2 = H5RS_dup(rs1);
     CHECK_PTR(rs2, "H5RS_dup");
 
     /* Get the reference count on the strings */
-    count=H5RS_get_count(rs1);
+    count = H5RS_get_count(rs1);
     VERIFY(count, 2, "H5RS_get_count");
-    count=H5RS_get_count(rs2);
+    count = H5RS_get_count(rs2);
     VERIFY(count, 2, "H5RS_get_count");
 
     /* Decrement reference count for string */
-    ret=H5RS_decr(rs2);
+    ret = H5RS_decr(rs2);
     CHECK(ret, FAIL, "H5RS_decr");
 
     /* Get the reference count on the string */
-    count=H5RS_get_count(rs1);
+    count = H5RS_get_count(rs1);
     VERIFY(count, 1, "H5RS_get_count");
 
     /* Decrement reference count for string */
-    ret=H5RS_decr(rs1);
+    ret = H5RS_decr(rs1);
     CHECK(ret, FAIL, "H5RS_decr");
 
 } /* end test_refstr_dup() */
@@ -183,42 +183,42 @@ test_refstr_dup(void)
 static void
 test_refstr_cmp(void)
 {
-    H5RS_str_t *rs1;    /* Ref-counted string created */
-    H5RS_str_t *rs2;    /* Ref-counted string created */
-    int cmp;            /* Comparison value */
-    ssize_t len;        /* Length of string */
-    herr_t ret;         /* Generic return value */
+    H5RS_str_t *rs1; /* Ref-counted string created */
+    H5RS_str_t *rs2; /* Ref-counted string created */
+    int         cmp; /* Comparison value */
+    ssize_t     len; /* Length of string */
+    herr_t      ret; /* Generic return value */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Comparing Ref-Counted Strings\n"));
 
     /* Create first reference counted string */
-    rs1=H5RS_create("foo");
+    rs1 = H5RS_create("foo");
     CHECK_PTR(rs1, "H5RS_create");
 
     /* Create second reference counted string */
-    rs2=H5RS_create("foo2");
+    rs2 = H5RS_create("foo2");
     CHECK_PTR(rs2, "H5RS_create");
 
     /* Compare the strings in various ways */
-    cmp=H5RS_cmp(rs1,rs1);
+    cmp = H5RS_cmp(rs1, rs1);
     VERIFY(cmp, 0, "H5RS_cmp");
-    cmp=H5RS_cmp(rs2,rs2);
+    cmp = H5RS_cmp(rs2, rs2);
     VERIFY(cmp, 0, "H5RS_cmp");
-    cmp=H5RS_cmp(rs1,rs2);
-    if(cmp>=0)
-        TestErrPrintf("%d: string comparison incorrect!\n",__LINE__);
+    cmp = H5RS_cmp(rs1, rs2);
+    if (cmp >= 0)
+        TestErrPrintf("%d: string comparison incorrect!\n", __LINE__);
 
     /* Check the lengths of the strings also */
-    len=H5RS_len(rs1);
+    len = H5RS_len(rs1);
     VERIFY(len, 3, "H5RS_len");
-    len=H5RS_len(rs2);
+    len = H5RS_len(rs2);
     VERIFY(len, 4, "H5RS_len");
 
     /* Decrement reference count for strings */
-    ret=H5RS_decr(rs2);
+    ret = H5RS_decr(rs2);
     CHECK(ret, FAIL, "H5RS_decr");
-    ret=H5RS_decr(rs1);
+    ret = H5RS_decr(rs1);
     CHECK(ret, FAIL, "H5RS_decr");
 
 } /* end test_refstr_cmp() */
@@ -232,48 +232,48 @@ test_refstr_cmp(void)
 static void
 test_refstr_wrap(void)
 {
-    H5RS_str_t *rs;     /* Ref-counted string created */
-    const char *s;      /* Pointer to raw string in ref-counted string */
-    char buf[16];       /* Buffer to wrap */
-    int cmp;            /* Comparison value */
-    herr_t ret;         /* Generic return value */
+    H5RS_str_t *rs;      /* Ref-counted string created */
+    const char *s;       /* Pointer to raw string in ref-counted string */
+    char        buf[16]; /* Buffer to wrap */
+    int         cmp;     /* Comparison value */
+    herr_t      ret;     /* Generic return value */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Wrapping Ref-Counted Strings\n"));
 
     /* Initialize buffer */
-    HDstrcpy(buf,"foo");
+    HDstrcpy(buf, "foo");
 
     /* Wrap ref-counted string around existing buffer */
-    rs=H5RS_wrap(buf);
+    rs = H5RS_wrap(buf);
     CHECK_PTR(rs, "H5RS_wrap");
 
     /* Get pointer to raw string in ref-counted string */
-    s=H5RS_get_str(rs);
+    s = H5RS_get_str(rs);
     CHECK_PTR(s, "H5RS_get_str");
     CHECK_PTR_EQ(s, buf, "wrapping");
-    cmp=HDstrcmp(s,buf);
+    cmp = HDstrcmp(s, buf);
     VERIFY(cmp, 0, "HDstrcmp");
 
     /* Increment reference count (should duplicate string) */
-    ret=H5RS_incr(rs);
+    ret = H5RS_incr(rs);
     CHECK(ret, FAIL, "H5RS_incr");
 
     /* Change the buffer initially wrapped */
-    buf[0]='F';
+    buf[0] = 'F';
 
     /* Get pointer to raw string in ref-counted string */
-    s=H5RS_get_str(rs);
+    s = H5RS_get_str(rs);
     CHECK_PTR(s, "H5RS_get_str");
     CHECK(s, buf, "wrapping");
-    cmp=HDstrcmp(s,buf);
-    if(cmp<=0)
-        TestErrPrintf("%d: string comparison incorrect!\n",__LINE__);
+    cmp = HDstrcmp(s, buf);
+    if (cmp <= 0)
+        TestErrPrintf("%d: string comparison incorrect!\n", __LINE__);
 
     /* Decrement reference count for string */
-    ret=H5RS_decr(rs);
+    ret = H5RS_decr(rs);
     CHECK(ret, FAIL, "H5RS_decr");
-    ret=H5RS_decr(rs);
+    ret = H5RS_decr(rs);
     CHECK(ret, FAIL, "H5RS_decr");
 
 } /* end test_refstr_wrap() */
@@ -288,49 +288,49 @@ test_refstr_wrap(void)
 static void
 test_refstr_own(void)
 {
-    H5RS_str_t *rs;     /* Ref-counted string created */
-    char *s;            /* Pointer to string to transfer */
-    const char *t;      /* Temporary pointers to string */
-    int cmp;            /* Comparison value */
-    herr_t ret;         /* Generic return value */
+    H5RS_str_t *rs;  /* Ref-counted string created */
+    char *      s;   /* Pointer to string to transfer */
+    const char *t;   /* Temporary pointers to string */
+    int         cmp; /* Comparison value */
+    herr_t      ret; /* Generic return value */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Transferring Ref-Counted Strings\n"));
 
     /* Initialize buffer */
-    s = (char *)H5FL_BLK_MALLOC(str_buf,HDstrlen("foo") + 1);
+    s = (char *)H5FL_BLK_MALLOC(str_buf, HDstrlen("foo") + 1);
     CHECK_PTR(s, "H5FL_BLK_MALLOC");
     HDstrcpy(s, "foo");
 
     /* Transfer ownership of dynamically allocated string to ref-counted string */
-    rs=H5RS_own(s);
+    rs = H5RS_own(s);
     CHECK_PTR(rs, "H5RS_own");
 
     /* Get pointer to raw string in ref-counted string */
-    t=H5RS_get_str(rs);
+    t = H5RS_get_str(rs);
     CHECK_PTR(t, "H5RS_get_str");
     CHECK_PTR_EQ(t, s, "transferring");
-    cmp=HDstrcmp(s,t);
+    cmp = HDstrcmp(s, t);
     VERIFY(cmp, 0, "HDstrcmp");
 
     /* Increment reference count (should NOT duplicate string) */
-    ret=H5RS_incr(rs);
+    ret = H5RS_incr(rs);
     CHECK(ret, FAIL, "H5RS_incr");
 
     /* Change the buffer initially wrapped */
-    *s='F';
+    *s = 'F';
 
     /* Get pointer to raw string in ref-counted string */
-    t=H5RS_get_str(rs);
+    t = H5RS_get_str(rs);
     CHECK_PTR(t, "H5RS_get_str");
     CHECK_PTR_EQ(t, s, "transferring");
-    cmp=HDstrcmp(t,s);
+    cmp = HDstrcmp(t, s);
     VERIFY(cmp, 0, "HDstrcmp");
 
     /* Decrement reference count for string */
-    ret=H5RS_decr(rs);
+    ret = H5RS_decr(rs);
     CHECK(ret, FAIL, "H5RS_decr");
-    ret=H5RS_decr(rs);
+    ret = H5RS_decr(rs);
     CHECK(ret, FAIL, "H5RS_decr");
 
 } /* end test_refstr_own() */
@@ -361,14 +361,13 @@ test_refstr(void)
     test_refstr_init();
 
     /* Actual ref-counted strings tests */
-    test_refstr_create();       /* Test ref-counted string creation */
-    test_refstr_count();        /* Test ref-counted string counting */
-    test_refstr_dup();          /* Test ref-counted string duplication */
-    test_refstr_cmp();          /* Test ref-counted string comparison */
-    test_refstr_wrap();         /* Test ref-counted string wrapping */
-    test_refstr_own();          /* Test ref-counted string ownership transfer */
+    test_refstr_create(); /* Test ref-counted string creation */
+    test_refstr_count();  /* Test ref-counted string counting */
+    test_refstr_dup();    /* Test ref-counted string duplication */
+    test_refstr_cmp();    /* Test ref-counted string comparison */
+    test_refstr_wrap();   /* Test ref-counted string wrapping */
+    test_refstr_own();    /* Test ref-counted string ownership transfer */
 
     /* Finalize ref-counted strings testing data */
     test_refstr_finalize();
-}   /* end test_refstr() */
-
+} /* end test_refstr() */