Brings H5RS changes from develop

1 files changed, 208 insertions, 38 deletions

diff --git a/test/trefstr.c b/test/trefstr.c
index 049384f..a3f568a 100644
--- a/test/trefstr.c
+++ b/test/trefstr.c
@@ -265,7 +265,9 @@ test_refstr_wrap(void)
     /* Get pointer to raw string in ref-counted string */
     s = H5RS_get_str(rs);
     CHECK_PTR(s, "H5RS_get_str");
-    CHECK(s, buf, "wrapping");
+    if (s == buf)
+        TestErrPrintf("%d: Should not have gotten the same pointer from reference-counted string!\n",
+                      __LINE__);
     cmp = HDstrcmp(s, buf);
     if (cmp <= 0)
         TestErrPrintf("%d: string comparison incorrect!\n", __LINE__);
@@ -280,60 +282,225 @@ test_refstr_wrap(void)
 
 /****************************************************************
 **
-**  test_refstr_own(): Test basic H5RS (ref-counted strings) code.
-**      Tests transferring ownership of dynamically allocated strings
-**      to ref-counted strings.
+**  test_refstr_asprintf_cat(): Test basic H5RS (ref-counted strings) code.
+**      Tests appending printf-formatted output to ref-counted strings.
 **
 ****************************************************************/
 static void
-test_refstr_own(void)
+test_refstr_asprintf_cat(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 */
+    const char *s;        /* Pointer to raw string in ref-counted string */
+    char        buf[256]; /* Buffer to compare against */
+    int         cmp;      /* Comparison value */
+    herr_t      ret;      /* Generic return value */
 
     /* Output message about test being performed */
-    MESSAGE(5, ("Testing Transferring Ref-Counted Strings\n"));
+    MESSAGE(5, ("Testing Printf-formatted Output to Ref-Counted Strings\n"));
 
-    /* Initialize buffer */
-    s = (char *)H5FL_BLK_MALLOC(str_buf, HDstrlen("foo") + 1);
-    CHECK_PTR(s, "H5FL_BLK_MALLOC");
-    HDstrcpy(s, "foo");
+    /* Wrap ref-counted string around existing buffer */
+    rs = H5RS_create(NULL);
+    CHECK_PTR(rs, "H5RS_create");
 
-    /* Transfer ownership of dynamically allocated string to ref-counted string */
-    rs = H5RS_own(s);
-    CHECK_PTR(rs, "H5RS_own");
+    /* Print initial output to ref-counted string */
+    ret = H5RS_asprintf_cat(rs, "%d-%s", (int)10, "foo");
+    CHECK(ret, FAIL, "H5RS_asprintf_cat");
 
     /* Get pointer to raw string in ref-counted string */
-    t = H5RS_get_str(rs);
-    CHECK_PTR(t, "H5RS_get_str");
-    CHECK_PTR_EQ(t, s, "transferring");
-    cmp = HDstrcmp(s, t);
+    s = H5RS_get_str(rs);
+    CHECK_PTR(s, "H5RS_get_str");
+    HDsprintf(buf, "%d-%s", (int)10, "foo");
+    cmp = HDstrcmp(s, buf);
     VERIFY(cmp, 0, "HDstrcmp");
 
-    /* Increment reference count (should NOT duplicate string) */
-    ret = H5RS_incr(rs);
-    CHECK(ret, FAIL, "H5RS_incr");
+    /* Append more output to ref-counted string */
+    ret = H5RS_asprintf_cat(rs, "-%f", (double)20.0);
+    CHECK(ret, FAIL, "H5RS_asprintf_cat");
 
-    /* Change the buffer initially wrapped */
-    *s = 'F';
+    /* Get pointer to raw string in ref-counted string */
+    s = H5RS_get_str(rs);
+    CHECK_PTR(s, "H5RS_get_str");
+    HDsprintf(buf, "%d-%s-%f", (int)10, "foo", (double)20.0);
+    cmp = HDstrcmp(s, buf);
+    VERIFY(cmp, 0, "HDstrcmp");
+
+    /* Decrement reference count for string */
+    ret = H5RS_decr(rs);
+    CHECK(ret, FAIL, "H5RS_decr");
+
+} /* end test_refstr_asprintf_cat() */
+
+/****************************************************************
+**
+**  test_refstr_acat(): Test basic H5RS (ref-counted strings) code.
+**      Tests appending strings to ref-counted strings.
+**
+****************************************************************/
+static void
+test_refstr_acat(void)
+{
+    H5RS_str_t *rs;                     /* Ref-counted string created */
+    const char *s;                      /* Pointer to raw string in ref-counted string */
+    char        buf[256];               /* Buffer to compare against */
+    char *      large_str, *large_str2; /* Large strings to append */
+    int         cmp;                    /* Comparison value */
+    herr_t      ret;                    /* Generic return value */
+
+    /* Output message about test being performed */
+    MESSAGE(5, ("Testing Appending Strings to Ref-Counted Strings\n"));
+
+    /* Wrap ref-counted string around existing buffer */
+    rs = H5RS_create(NULL);
+    CHECK_PTR(rs, "H5RS_create");
+
+    /* Append first string to ref-counted string */
+    ret = H5RS_acat(rs, "foo");
+    CHECK(ret, FAIL, "H5RS_acat");
 
     /* Get pointer to raw string in ref-counted string */
-    t = H5RS_get_str(rs);
-    CHECK_PTR(t, "H5RS_get_str");
-    CHECK_PTR_EQ(t, s, "transferring");
-    cmp = HDstrcmp(t, s);
+    s = H5RS_get_str(rs);
+    CHECK_PTR(s, "H5RS_get_str");
+    HDsprintf(buf, "%s", "foo");
+    cmp = HDstrcmp(s, buf);
+    VERIFY(cmp, 0, "HDstrcmp");
+
+    /* Append another string to ref-counted string */
+    ret = H5RS_acat(rs, "bar");
+    CHECK(ret, FAIL, "H5RS_acat");
+
+    /* Get pointer to raw string in ref-counted string */
+    s = H5RS_get_str(rs);
+    CHECK_PTR(s, "H5RS_get_str");
+    HDsprintf(buf, "%s", "foobar");
+    cmp = HDstrcmp(s, buf);
+    VERIFY(cmp, 0, "HDstrcmp");
+
+    /* Append a large string to ref-counted string */
+    large_str = HDmalloc(1024);
+    CHECK_PTR(large_str, "HDmalloc");
+    HDmemset(large_str, 'a', 1024);
+    large_str[1023] = '\0';
+    ret             = H5RS_acat(rs, large_str);
+    CHECK(ret, FAIL, "H5RS_acat");
+
+    /* Get pointer to raw string in ref-counted string */
+    s = H5RS_get_str(rs);
+    CHECK_PTR(s, "H5RS_get_str");
+    HDsprintf(buf, "%s", "foobar");
+    large_str2 = HDmalloc(1024 + 6);
+    CHECK_PTR(large_str2, "HDmalloc");
+    HDstrcpy(large_str2, "foobar");
+    HDmemset(&large_str2[6], 'a', 1024);
+    large_str2[1029] = '\0';
+    cmp              = HDstrcmp(s, large_str2);
     VERIFY(cmp, 0, "HDstrcmp");
 
     /* Decrement reference count for string */
     ret = H5RS_decr(rs);
     CHECK(ret, FAIL, "H5RS_decr");
+
+    /* Free large strings */
+    HDfree(large_str);
+    HDfree(large_str2);
+} /* end test_refstr_acat() */
+
+/****************************************************************
+**
+**  test_refstr_ancat(): Test basic H5RS (ref-counted strings) code.
+**      Tests appending length-limited strings to ref-counted strings.
+**
+****************************************************************/
+static void
+test_refstr_ancat(void)
+{
+    H5RS_str_t *rs;       /* Ref-counted string created */
+    const char *s;        /* Pointer to raw string in ref-counted string */
+    char        buf[256]; /* Buffer to compare against */
+    int         cmp;      /* Comparison value */
+    herr_t      ret;      /* Generic return value */
+
+    /* Output message about test being performed */
+    MESSAGE(5, ("Testing Appending Strings to Ref-Counted Strings\n"));
+
+    /* Wrap ref-counted string around existing buffer */
+    rs = H5RS_create(NULL);
+    CHECK_PTR(rs, "H5RS_create");
+
+    /* Append first string to ref-counted string */
+    ret = H5RS_ancat(rs, "foo", 2);
+    CHECK(ret, FAIL, "H5RS_ancat");
+
+    /* Get pointer to raw string in ref-counted string */
+    s = H5RS_get_str(rs);
+    CHECK_PTR(s, "H5RS_get_str");
+    HDstrcpy(buf, "fo");
+    cmp = HDstrcmp(s, buf);
+    VERIFY(cmp, 0, "HDstrcmp");
+
+    /* Append another string to ref-counted string */
+    ret = H5RS_ancat(rs, "bar", 2);
+    CHECK(ret, FAIL, "H5RS_ancat");
+
+    /* Get pointer to raw string in ref-counted string */
+    s = H5RS_get_str(rs);
+    CHECK_PTR(s, "H5RS_get_str");
+    HDstrcpy(buf, "foba");
+    cmp = HDstrcmp(s, buf);
+    VERIFY(cmp, 0, "HDstrcmp");
+
+    /* Decrement reference count for string */
     ret = H5RS_decr(rs);
     CHECK(ret, FAIL, "H5RS_decr");
+} /* end test_refstr_ancat() */
+
+/****************************************************************
+**
+**  test_refstr_aputc(): Test basic H5RS (ref-counted strings) code.
+**      Tests appending characters to ref-counted strings.
+**
+****************************************************************/
+static void
+test_refstr_aputc(void)
+{
+    H5RS_str_t *rs;       /* Ref-counted string created */
+    const char *s;        /* Pointer to raw string in ref-counted string */
+    char        buf[256]; /* Buffer to compare against */
+    int         cmp;      /* Comparison value */
+    herr_t      ret;      /* Generic return value */
+
+    /* Output message about test being performed */
+    MESSAGE(5, ("Testing Appending Strings to Ref-Counted Strings\n"));
 
-} /* end test_refstr_own() */
+    /* Wrap ref-counted string around existing buffer */
+    rs = H5RS_create(NULL);
+    CHECK_PTR(rs, "H5RS_create");
+
+    /* Append first character to ref-counted string */
+    ret = H5RS_aputc(rs, 'f');
+    CHECK(ret, FAIL, "H5RS_ancat");
+
+    /* Get pointer to raw string in ref-counted string */
+    s = H5RS_get_str(rs);
+    CHECK_PTR(s, "H5RS_get_str");
+    HDstrcpy(buf, "f");
+    cmp = HDstrcmp(s, buf);
+    VERIFY(cmp, 0, "HDstrcmp");
+
+    /* Append another character to ref-counted string */
+    ret = H5RS_aputc(rs, 'o');
+    CHECK(ret, FAIL, "H5RS_ancat");
+
+    /* Get pointer to raw string in ref-counted string */
+    s = H5RS_get_str(rs);
+    CHECK_PTR(s, "H5RS_get_str");
+    HDstrcpy(buf, "fo");
+    cmp = HDstrcmp(s, buf);
+    VERIFY(cmp, 0, "HDstrcmp");
+
+    /* Decrement reference count for string */
+    ret = H5RS_decr(rs);
+    CHECK(ret, FAIL, "H5RS_decr");
+} /* end test_refstr_aputc() */
 
 /****************************************************************
 **
@@ -361,12 +528,15 @@ 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_asprintf_cat(); /* Test ref-counted string printf-formatted output */
+    test_refstr_acat();         /* Test ref-counted string appends */
+    test_refstr_ancat();        /* Test ref-counted length-limited string appends */
+    test_refstr_aputc();        /* Test ref-counted character appends */
 
     /* Finalize ref-counted strings testing data */
     test_refstr_finalize();