[svn-r29360] Purpose: Adding test

Description:
    Added several tests for packet table that were missing from the
    previous update.
Platforms tested:
    Linux/32 2.6 (jam)
    Linux/64 (platypus)
    Darwin (osx1010test)

1 files changed, 601 insertions, 5 deletions

diff --git a/hl/test/test_packet_vlen.c b/hl/test/test_packet_vlen.c
index 10051fa..b3b2fce 100644
--- a/hl/test/test_packet_vlen.c
+++ b/hl/test/test_packet_vlen.c
@@ -23,6 +23,7 @@
 
 #define NRECORDS 5
 #define TEST_FILE_NAME "test_packet_table_vlen.h5"
+#define TESTFL_FILE_NAME "testfl_packet_table_vlen.h5"
 #define PT_VLEN_ATOMIC "Dataset with VL of Atomic types"
 #define PT_VLEN_COMP "Dataset with VL of Compound Types"
 #define PT_COMP_VLEN "Dataset with Compound Type of VL types"
@@ -91,7 +92,7 @@ static int test_VLof_atomic(void)
 	goto error;
 
     /* Create a packet table that uses a vlen datatype of an atomic type */
-    ptable = H5PTcreate_fl(fid, PT_VLEN_ATOMIC, vltype, (hsize_t)1, 0);
+    ptable = H5PTcreate(fid, PT_VLEN_ATOMIC, vltype, (hsize_t)1, H5P_DEFAULT);
 
     /* Ensure that PT is created successfully */
     if (ptable == H5I_INVALID_HID)
@@ -222,7 +223,7 @@ static int test_VLof_comptype(void)
 	goto error;
 
     /* Create a packet table that uses a vlen datatype of compound datatype */
-    ptable = H5PTcreate_fl(fid, PT_VLEN_COMP, vltype, (hsize_t)1, 0);
+    ptable = H5PTcreate(fid, PT_VLEN_COMP, vltype, (hsize_t)1, H5P_DEFAULT);
 
     /* Ensure that PT is created successfully */
     if (ptable == H5I_INVALID_HID)
@@ -388,7 +389,7 @@ static int test_compound_VL_VLtype(void)
 	goto error;
 
     /* Create a packet table that uses a compound datatype of vlen datatype */
-    ptable = H5PTcreate_fl(fid, PT_COMP_VLEN, comp_vlvl, (hsize_t)1, 0);
+    ptable = H5PTcreate(fid, PT_COMP_VLEN, comp_vlvl, (hsize_t)1, H5P_DEFAULT);
 
     /* Ensure that PT is created successfully */
     if (ptable == H5I_INVALID_HID)
@@ -541,7 +542,7 @@ static int test_VLof_VLtype(void)
 	goto error;
 
     /* Create a packet table that uses a vlen datatype of vlen datatype */
-    ptable = H5PTcreate_fl(fid, PT_VLEN_VLEN, vlofvl, (hsize_t)1, 0);
+    ptable = H5PTcreate(fid, PT_VLEN_VLEN, vlofvl, (hsize_t)1, H5P_DEFAULT);
 
     /* Ensure that PT is created successfully */
     if (ptable == H5I_INVALID_HID)
@@ -669,7 +670,7 @@ static int test_H5PTis_varlen(void)
 	goto error;
 
     /* Create a new table */
-    ptable = H5PTcreate_fl(fid, "Fixed-length Packet Table", H5T_STD_I32BE, (hsize_t)100, -1);
+    ptable = H5PTcreate(fid, PT_FIXED_LEN, H5T_STD_I32BE, (hsize_t)100, H5P_DEFAULT);
 
     /* Ensure that PT is created successfully */
     if (ptable == H5I_INVALID_HID)
@@ -1039,6 +1040,564 @@ error: /* An error has occurred.  Clean up and exit. */
     return FAIL;
 } /* test_accessors */
 
+/**************************************************************************
+	Test set for deprecated function H5PTcreate_fl
+	Each test in this set is the same as the corresponding one in the
+	set for H5PTcreate, as of Mar 2016
+
+**************************************************************************/
+
+/*-------------------------------------------------------------------------
+ * testfl_VLof_atomic(): Test that a packet table with VL datatypes of atomic
+ *	datatypes can be created and written correctly. (HDFFV-442)
+ *
+ * 2016/01/27 -BMR
+ *-------------------------------------------------------------------------
+ */
+static int testfl_VLof_atomic(void)
+{
+    hid_t   fid=H5I_INVALID_HID;	/* Test file identifier */
+    hid_t   ptable=H5I_INVALID_HID;	/* Packet table identifier */
+    hid_t   vltype=H5I_INVALID_HID;	/* Variable length datatype */
+    hsize_t count;		/* Number of records in the table */
+    int     ii, jj;		/* Loop variables */
+    hvl_t   writeBuf[NRECORDS];	/* Buffer to hold data to be written */
+    hvl_t   readBuf[NRECORDS];	/* Buffer to hold read data */
+    char    msg[80];		/* For error message */
+    herr_t  ret;		/* Returned status from a callee */
+
+    TESTING3("        with vlen of atomic");
+
+    /* Allocate and initialize VL data to write (copied from C test) */
+    for (ii=0; ii<NRECORDS; ii++) {
+        writeBuf[ii].p = HDmalloc((ii+1)*sizeof(unsigned int));
+        if (writeBuf[ii].p == NULL) {
+            fprintf(stderr, "Cannot allocate memory for VL data! ii=%u\n",ii);
+            goto error;
+	}
+        writeBuf[ii].len = ii+1;
+        for (jj=0; jj<(ii+1); jj++)
+	    ((unsigned int *)writeBuf[ii].p)[jj] = ii * 10 + jj;
+    } /* end for */
+
+    /* Open the file */
+    fid = H5Fopen(TESTFL_FILE_NAME, H5F_ACC_RDWR, H5P_DEFAULT);
+    if (fid < 0)
+	goto error;
+
+    /* Create a vlen type that uses an atomic datatype as its base type */
+    vltype = H5Tvlen_create (H5T_NATIVE_UINT);
+    if (vltype < 0)
+	goto error;
+
+    /* Create a packet table that uses a vlen datatype of an atomic type */
+    ptable = H5PTcreate_fl(fid, PT_VLEN_ATOMIC, vltype, (hsize_t)1, 0);
+
+    /* Ensure that PT is created successfully */
+    if (ptable == H5I_INVALID_HID)
+	goto error;
+
+    /* Close the vlen datatype */
+    if (H5Tclose(vltype) < 0)
+	goto error;
+
+    /* Write the entire buffer to the packet table */
+    ret = H5PTappend(ptable, (size_t)NRECORDS, writeBuf);
+    if (ret < 0)
+	goto error;
+
+    /* Get the number of packets in the packet table, should be NRECORDS. */
+    ret = H5PTget_num_packets(ptable, &count);
+    if (ret < 0)
+	goto error;
+
+    sprintf(msg, "The number of packets in the packet table must be %u\n", NRECORDS);
+    VERIFY(count == NRECORDS, msg);
+
+    /* Read all five packets back */
+    ret = H5PTread_packets(ptable, (hsize_t)0, (size_t)NRECORDS, (void*)readBuf );
+    if (ret < 0)
+	goto error;
+
+    for (ii = 0; ii < NRECORDS; ii++)
+        for (jj=0; jj<(ii+1); jj++)
+        {
+	    if (((unsigned int *)readBuf[ii].p)[jj] != ((unsigned int *)writeBuf[ii].p)[jj]) {
+		printf("Packet %d's value should be %d\n", ii, ((unsigned int *)writeBuf[ii].p)[jj]);
+		printf("Packet %d's value in readBuf is %d\n", ii, ((unsigned int *)readBuf[ii].p)[jj]);
+	    }
+        }
+
+    /* Free the buffers */
+    ret = H5PTfree_vlen_buff(ptable, NRECORDS, readBuf );
+    if (ret < 0)
+	goto error;
+    ret = H5PTfree_vlen_buff(ptable, NRECORDS, writeBuf);
+    if (ret < 0)
+	goto error;
+
+    /* Close the packet table */
+    ret = H5PTclose(ptable);
+    if (ret < 0)
+	goto error;
+
+    /* Close the file */
+    if (H5Fclose(fid) < 0)
+	goto error;
+
+    PASSED();
+    return SUCCEED;
+
+error: /* An error has occurred.  Clean up and exit. */
+    if (H5PTis_valid(ptable) > 0) H5PTclose(ptable);
+    if (fid > 0) H5Fclose(fid);
+    H5PTfree_vlen_buff(ptable, NRECORDS, readBuf);
+    H5PTfree_vlen_buff(ptable, NRECORDS, writeBuf);
+    H5_FAILED();
+    return FAIL;
+} /* testfl_VLof_atomic */
+
+/*-------------------------------------------------------------------------
+ * testfl_VLof_comptype(): Test that a packet table with VL datatypes of
+ *	compound datatypes can be created and written correctly. (HDFFV-442)
+ *
+ * 2016/01/27 -BMR
+ *-------------------------------------------------------------------------
+ */
+static int testfl_VLof_comptype(void)
+{
+    /* Struct that the VL sequences are composed of */
+    typedef struct {
+        int i;
+        float f;
+    } VLcomp_t;
+    hid_t   fid=H5I_INVALID_HID;	/* Test file identifier */
+    hid_t   ptable=H5I_INVALID_HID;	/* Packet table identifier */
+    hid_t   vltype=H5I_INVALID_HID;	/* Variable length datatype */
+    hid_t   cmptype=H5I_INVALID_HID;	/* Compound datatype */
+    hvl_t   writeBuf[NRECORDS];	/* Buffer to hold data to be written */
+    hvl_t   readBuf[NRECORDS];	/* Buffer to hold read data */
+    hsize_t count;		/* Number of records in the table */
+    int     ii, jj;		/* Loop variables */
+    char    msg[80];		/* For error message */
+    herr_t ret;
+
+    TESTING3("        with vlen of compound datatypes");
+
+    /* Allocate and initialize VL data to write (copied from C test) */
+    for (ii=0; ii<NRECORDS; ii++) {
+        writeBuf[ii].p = HDmalloc((ii+1)*sizeof(VLcomp_t));
+        if(writeBuf[ii].p == NULL) {
+            fprintf(stderr, "Cannot allocate memory for VL data! ii=%u\n",ii);
+            goto error;
+	}
+        writeBuf[ii].len = ii+1;
+        for (jj=0; jj<(ii+1); jj++) {
+            ((VLcomp_t *)writeBuf[ii].p)[jj].i = ii+jj;
+            ((VLcomp_t *)writeBuf[ii].p)[jj].f = (float)((ii+jj)/3.0F);
+          } /* end for */
+    } /* end for */
+
+    /* Open the file */
+    fid = H5Fopen(TESTFL_FILE_NAME, H5F_ACC_RDWR, H5P_DEFAULT);
+    if (fid < 0)
+	goto error;
+
+    /* Create the base compound type */
+    cmptype = H5Tcreate(H5T_COMPOUND, sizeof(VLcomp_t));
+    if (cmptype < 0)
+	goto error;
+
+    /* Insert fields */
+    ret = H5Tinsert(cmptype, "i", HOFFSET(VLcomp_t, i), H5T_NATIVE_INT);
+    if (ret < 0)
+	goto error;
+    ret = H5Tinsert(cmptype, "f", HOFFSET(VLcomp_t, f), H5T_NATIVE_FLOAT);
+    if (ret < 0)
+	goto error;
+
+    /* Create a variable length type that uses the VLcomp_t as its base type */
+    vltype = H5Tvlen_create(cmptype);
+    if (vltype < 0)
+	goto error;
+
+    /* Create a packet table that uses a vlen datatype of compound datatype */
+    ptable = H5PTcreate_fl(fid, PT_VLEN_COMP, vltype, (hsize_t)1, 0);
+
+    /* Ensure that PT is created successfully */
+    if (ptable == H5I_INVALID_HID)
+	goto error;
+
+    /* Close the vlen datatype */
+    if (H5Tclose(vltype) < 0)
+	goto error;
+
+    /* Write the entire buffer to the packet table */
+    ret = H5PTappend(ptable, (size_t)5, writeBuf );
+    if (ret < 0)
+	goto error;
+
+    /* Get the number of packets in the packet table, should be NRECORDS. */
+    ret = H5PTget_num_packets(ptable, &count);
+    if (ret < 0)
+	goto error;
+
+    sprintf(msg, "The number of packets in the packet table must be %u\n", NRECORDS);
+    VERIFY(count == NRECORDS, msg);
+
+    /* Read all five packets back */
+    ret = H5PTread_packets(ptable, (hsize_t)0, (size_t)5, (void*)readBuf );
+    if (ret < 0)
+	goto error;
+
+    /* Compare data read in */
+    for (ii = 0; ii < NRECORDS; ii++) {
+        if (writeBuf[ii].len != readBuf[ii].len) {
+            fprintf(stderr, "%d: VL data length don't match!, writeBuf[%d].len=%d, readBuf[%d].len=%d\n",__LINE__,(int)ii,(int)writeBuf[ii].len,(int)ii,(int)readBuf[ii].len);
+	    continue;
+	} /* write len != read len */
+
+        for (jj=0; jj<(ii+1); jj++) {
+            if (((unsigned int *)writeBuf[ii].p)[jj] != ((unsigned int *)readBuf[ii].p)[jj] ) {
+                fprintf(stderr, "VL data values don't match!, writeBuf[ii].p[%d]=%d, readBuf[ii].p[%d]=%d\n",(int)jj, (int)((unsigned int *)writeBuf[ii].p)[jj], (int)jj, (int)((unsigned int *)readBuf[ii].p)[jj]);
+                continue;
+	    } /* write value != read value */
+	}
+    } /* end for */
+
+    /* Free the buffers */
+    ret = H5PTfree_vlen_buff(ptable, NRECORDS, readBuf);
+    if (ret < 0)
+	goto error;
+    ret = H5PTfree_vlen_buff(ptable, NRECORDS, writeBuf);
+    if (ret < 0)
+	goto error;
+
+    /* Close the packet table */
+    ret = H5PTclose(ptable);
+    if (ret < 0)
+	goto error;
+
+    /* Close the file */
+    if (H5Fclose(fid) < 0)
+	goto error;
+
+    PASSED();
+    return SUCCEED;
+
+error: /* An error has occurred.  Clean up and exit. */
+    if (H5PTis_valid(ptable) > 0) H5PTclose(ptable);
+    if (fid > 0) H5Fclose(fid);
+    H5PTfree_vlen_buff(ptable, NRECORDS, readBuf);
+    H5PTfree_vlen_buff(ptable, NRECORDS, writeBuf);
+    H5_FAILED();
+    return FAIL;
+} /* testfl_VLof_comptype */
+
+/*-------------------------------------------------------------------------
+ * testfl_compound_VL_VL(): Test that a packet table of compound datatypes
+ *	containing VL datatypes can be created and written
+ *	correctly. (HDFFV-442)
+ *
+ * 2016/01/27 -BMR
+ *-------------------------------------------------------------------------
+ */
+static int testfl_compound_VL_VLtype(void)
+{
+    /* Struct that the VL sequences are composed of */
+    typedef struct {
+        int i;
+        float f;
+	hvl_t v;
+    } compVLVL_t;
+    hid_t   fid=H5I_INVALID_HID;	/* Test file identifier */
+    hid_t   space=H5I_INVALID_HID;	/* Dataspace identifier */
+    hid_t   ptable=H5I_INVALID_HID;	/* Packet table identifier */
+    hid_t   vlatomic=H5I_INVALID_HID;	/* Variable length datatype */
+    hid_t   vlofvl=H5I_INVALID_HID;	/* Variable length datatype */
+    hid_t   comp_vlvl=H5I_INVALID_HID;	/* ID of a compound datatype containing 
+					   a VL of VL of atomic datatype */
+    hsize_t dims1[] = {NRECORDS};
+    hsize_t count;		/* Number of records in the table */
+    compVLVL_t writeBuf[NRECORDS];/* Buffer to hold data to be written */
+    compVLVL_t readBuf[NRECORDS]; /* Buffer to hold read data */
+    hvl_t   *t1, *t2;
+    int  ii, jj, kk;		/* Loop variables */
+    char    msg[80];		/* For error message */
+    herr_t  ret;		/* Returned status from a callee */
+
+    TESTING3("        with compound datatype containing vlen datatype");
+
+    /* Allocate and initialize VL data to write (copied from C test) */
+    for (ii=0; ii<NRECORDS; ii++) {
+        writeBuf[ii].i = ii*10;
+        writeBuf[ii].f = (float)((ii*20)/3.0F);
+        writeBuf[ii].v.p = HDmalloc((ii+L1_INCM)*sizeof(hvl_t));
+        if (writeBuf[ii].v.p == NULL) {
+            fprintf(stderr, "Cannot allocate memory for VL data! ii=%d\n",ii);
+            goto error;
+	}
+        writeBuf[ii].v.len=ii+L1_INCM;
+        for (t1=(hvl_t *)((writeBuf[ii].v).p), jj=0; jj<(ii+L1_INCM); jj++, t1++)
+	{
+            t1->p = HDmalloc((jj+L2_INCM)*sizeof(unsigned int));
+	    if (t1->p == NULL) {
+		fprintf(stderr, "Cannot allocate memory for VL data! ii=%d\n",ii);
+		goto error;
+	    }
+            t1->len = jj+L2_INCM;
+            for (kk=0; kk<jj+L2_INCM; kk++)
+                ((unsigned int*)t1->p)[kk] = ii*100 + jj*10 + kk;
+        }
+    } /* end for */
+
+    /* Open the file */
+    fid = H5Fopen(TESTFL_FILE_NAME, H5F_ACC_RDWR, H5P_DEFAULT);
+    if (fid < 0)
+	goto error;
+
+    /* Create dataspace for datasets */
+    space = H5Screate_simple(SPACE3_RANK, dims1, NULL);
+    if (space < 0)
+	goto error;
+
+    /* Create a VL datatype of an atomic type */
+    vlatomic = H5Tvlen_create (H5T_NATIVE_UINT);
+    if (vlatomic < 0)
+	goto error;
+
+    /* Create a VL datatype of the VL of atomic datatype */
+    vlofvl = H5Tvlen_create (vlatomic);
+    if (vlofvl < 0)
+	goto error;
+
+    /* Create the base compound type */
+    comp_vlvl = H5Tcreate(H5T_COMPOUND, sizeof(compVLVL_t));
+    if (comp_vlvl < 0)
+	goto error;
+
+    /* Insert fields: atomic, atomic, vlen */
+    ret = H5Tinsert(comp_vlvl, "i", HOFFSET(compVLVL_t, i), H5T_NATIVE_INT);
+    if (ret < 0)
+	goto error;
+    ret = H5Tinsert(comp_vlvl, "f", HOFFSET(compVLVL_t, f), H5T_NATIVE_FLOAT);
+    if (ret < 0)
+	goto error;
+    ret = H5Tinsert(comp_vlvl, "v", HOFFSET(compVLVL_t, v), vlofvl);
+    if (ret < 0)
+	goto error;
+
+    /* Create a packet table that uses a compound datatype of vlen datatype */
+    ptable = H5PTcreate_fl(fid, PT_COMP_VLEN, comp_vlvl, (hsize_t)1, 0);
+
+    /* Ensure that PT is created successfully */
+    if (ptable == H5I_INVALID_HID)
+	goto error;
+
+    /* Close the vlen datatype */
+    if (H5Tclose(comp_vlvl) < 0)
+	goto error;
+
+    /* Write the entire buffer to the packet table */
+    ret = H5PTappend(ptable, (size_t)NRECORDS, writeBuf );
+    if (ret < 0)
+	goto error;
+
+    /* Get the number of packets in the packet table, should be NRECORDS. */
+    ret = H5PTget_num_packets(ptable, &count);
+    if (ret < 0)
+	goto error;
+
+    sprintf(msg, "The number of packets in the packet table must be %u\n", NRECORDS);
+    VERIFY(count == NRECORDS, msg);
+
+    /* Read all five packets back */
+    ret = H5PTread_packets(ptable, (hsize_t)0, (size_t)NRECORDS, (void*)readBuf );
+    if (ret < 0)
+	goto error;
+
+    /* Compare data read in */
+    for (ii = 0; ii < NRECORDS; ii++) {
+        if (writeBuf[ii].i != readBuf[ii].i) {
+            fprintf(stderr, "Integer components don't match!, writeBuf[%d].i=%d, readBuf[%d].i=%d\n",(int)ii,(int)writeBuf[ii].i,(int)ii,(int)readBuf[ii].i);
+            continue;
+        } /* end if */
+        if (!H5_FLT_ABS_EQUAL(writeBuf[ii].f,readBuf[ii].f)) {
+            fprintf(stderr, "Float components don't match!, writeBuf[%d].f=%f, readBuf[%d].f=%f\n",(int)ii,(double)writeBuf[ii].f,(int)ii,(double)readBuf[ii].f);
+            continue;
+        } /* end if */
+
+        if (writeBuf[ii].v.len != readBuf[ii].v.len) {
+            fprintf(stderr, "%d: VL data length don't match!, writeBuf[%d].v.len=%d, readBuf[%d].v.len=%d\n",__LINE__,(int)ii,(int)writeBuf[ii].v.len,(int)ii,(int)readBuf[ii].v.len);
+            continue;
+        } /* end if */
+
+        for (t1=(hvl_t *)(writeBuf[ii].v.p), t2=(hvl_t *)(readBuf[ii].v.p), jj=0; (size_t)jj<readBuf[ii].v.len; jj++, t1++, t2++) {
+            if (t1->len != t2->len) {
+                fprintf(stderr, "%d: VL data length don't match!, ii=%d, jj=%d, t1->len=%d, t2->len=%d\n",__LINE__,(int)ii,(int)jj,(int)t1->len,(int)t2->len);
+                continue;
+            } /* end if */
+            for (kk=0; (size_t)kk<t2->len; kk++) {
+                if (((unsigned int *)t1->p)[kk] != ((unsigned int *)t2->p)[kk] ) {
+                    fprintf(stderr, "VL data values don't match!, t1->p[%d]=%d, t2->p[%d]=%d\n",(int)kk, (int)((unsigned int *)t1->p)[kk], (int)kk, (int)((unsigned int *)t2->p)[kk]);
+                    continue;
+                } /* end if */
+            } /* end for */
+        } /* end for */
+    } /* end for */
+
+    /* Free the buffers */
+    ret = H5PTfree_vlen_buff(ptable, NRECORDS, readBuf);
+    if (ret < 0)
+	goto error;
+    ret = H5PTfree_vlen_buff(ptable, NRECORDS, writeBuf);
+    if (ret < 0)
+	goto error;
+
+    /* Close the packet table */
+    ret = H5PTclose(ptable);
+    if (ret < 0)
+	goto error;
+
+    /* Release datatypes */
+    if (H5Tclose(vlatomic) < 0)
+	goto error;
+    if (H5Tclose(vlofvl) < 0)
+	goto error;
+
+    /* Close the file */
+    if (H5Fclose(fid) < 0)
+	goto error;
+
+    PASSED();
+    return SUCCEED;
+
+error: /* An error has occurred.  Clean up and exit. */
+    if (H5PTis_valid(ptable) > 0) H5PTclose(ptable);
+    if (fid > 0) H5Fclose(fid);
+    H5PTfree_vlen_buff(ptable, NRECORDS, readBuf);
+    H5PTfree_vlen_buff(ptable, NRECORDS, writeBuf);
+    H5_FAILED();
+    return FAIL;
+} /* testfl_compound_VL_VLtype */
+
+/*-------------------------------------------------------------------------
+ * testfl_VLof_VLtype(): Test that a packet table of VL datatype with VL
+ *	datatypes of atomic datatypes can be created and written
+ *	correctly. (HDFFV-442)
+ *
+ * 2016/01/27 -BMR
+ *-------------------------------------------------------------------------
+ */
+static int testfl_VLof_VLtype(void)
+{
+    hid_t   fid=H5I_INVALID_HID;	/* Test file identifier */
+    hid_t   ptable=H5I_INVALID_HID;	/* Packet table identifier */
+    hid_t   vlatomic=H5I_INVALID_HID;	/* Variable length datatype */
+    hid_t   vlofvl=H5I_INVALID_HID;	/* VL datatype of VL datatypes */
+    hsize_t count;		/* Number of records in the table */
+    hvl_t   *t1;		/* pointer to advance */
+    int     ii, jj, kk;		/* Loop variables */
+    hvl_t   writeBuf[NRECORDS];	/* Buffer to hold data to be written */
+    hvl_t   readBuf[NRECORDS];	/* Buffer to hold read data */
+    char    msg[80];		/* For error message */
+    herr_t  ret;		/* Returned status from a callee */
+
+    TESTING3("        with vlen datatype of vlen datatype");
+
+    /* Allocate and initialize VL data to write (copied from C test) */
+    for (ii=0; ii< NRECORDS; ii++) {
+        writeBuf[ii].p = HDmalloc((ii+1)*sizeof(hvl_t));
+        if (writeBuf[ii].p == NULL) {
+            fprintf(stderr, "Cannot allocate memory for VL data! ii=%u\n",ii);
+            goto error;
+        } /* end if */
+        writeBuf[ii].len = ii+1;
+        for (t1=(hvl_t *)(writeBuf[ii].p), jj=0; jj<(ii+1); jj++, t1++)
+	{
+            t1->p = HDmalloc((jj+1)*sizeof(unsigned int));
+	    if (t1->p == NULL) {
+		fprintf(stderr, "Cannot allocate memory for VL data! ii=%u\n",ii);
+		goto error;
+	    }
+            t1->len = jj+1;
+            for (kk=0; kk<(jj+1); kk++)
+                ((unsigned int *)t1->p)[kk] = ii*100+jj*10+kk;
+        } /* end for */
+    } /* end for */
+
+    /* Open the file */
+    fid = H5Fopen(TESTFL_FILE_NAME, H5F_ACC_RDWR, H5P_DEFAULT);
+    if (fid < 0)
+	goto error;
+
+    /* Create a VL datatype of an atomic type */
+    vlatomic = H5Tvlen_create (H5T_NATIVE_UINT);
+    if (vlatomic < 0)
+	goto error;
+
+    vlofvl = H5Tvlen_create (vlatomic);
+    if (vlofvl < 0)
+	goto error;
+
+    /* Create a packet table that uses a vlen datatype of vlen datatype */
+    ptable = H5PTcreate_fl(fid, PT_VLEN_VLEN, vlofvl, (hsize_t)1, 0);
+
+    /* Ensure that PT is created successfully */
+    if (ptable == H5I_INVALID_HID)
+	goto error;
+
+    /* Close the vlen datatype */
+    if (H5Tclose(vlofvl) < 0)
+	goto error;
+
+    /* Write the entire buffer to the packet table */
+    ret = H5PTappend(ptable, (size_t)5, writeBuf );
+    if (ret < 0)
+	goto error;
+
+    /* Get the number of packets in the packet table, should be NRECORDS. */
+    ret = H5PTget_num_packets(ptable, &count);
+    if (ret < 0)
+	goto error;
+
+    sprintf(msg, "The number of packets in the packet table must be %u\n", NRECORDS);
+    VERIFY(count == NRECORDS, msg);
+
+    /* Read all five packets back */
+    ret = H5PTread_packets(ptable, (hsize_t)0, (size_t)5, (void*)readBuf );
+    if (ret < 0)
+	goto error;
+
+    /* Free the buffers */
+    ret = H5PTfree_vlen_buff(ptable, NRECORDS, readBuf);
+    if (ret < 0)
+	goto error;
+    ret = H5PTfree_vlen_buff(ptable, NRECORDS, writeBuf);
+    if (ret < 0)
+	goto error;
+
+    /* Close the packet table */
+    ret = H5PTclose(ptable);
+    if (ret < 0)
+	goto error;
+
+    /* Close the file */
+    if (H5Fclose(fid) < 0)
+	goto error;
+
+    PASSED();
+    return SUCCEED;
+
+error: /* An error has occurred.  Clean up and exit. */
+    if (H5PTis_valid(ptable) > 0) H5PTclose(ptable);
+    if (fid > 0) H5Fclose(fid);
+    H5PTfree_vlen_buff(ptable, NRECORDS, readBuf);
+    H5PTfree_vlen_buff(ptable, NRECORDS, writeBuf);
+    H5_FAILED();
+    return FAIL;
+} /* testfl_VLof_VLtype */
+
 /*-------------------------------------------------------------------------
  * test_packet_table_with_varlen(): Invokes individual tests to ensure that
  *	packet tables with variable length are created and written correctly
@@ -1094,5 +1653,42 @@ int test_packet_table_with_varlen(void)
     if (test_accessors() < 0)
 	status = FAIL;
 
+
+/**************************************************************************
+	Calling test functions for deprecated function H5PTcreate_fl
+	Mar 2016, -BMR
+
+**************************************************************************/
+
+    /* Create a file using default properties */
+    fid = H5Fcreate(TESTFL_FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    if (fid < 0)
+	return FAIL;
+
+    /* Close the file.  The file will be opened by each test function below */
+    if (H5Fclose(fid) < 0)
+	return FAIL;
+
+    HDputs("Testing packet table with various variable-length datatypes - H5PTcreate_fl");
+
+    /* If any test fails, move on to subsequent test, but status will indicate
+       there is a failure. */
+
+    /* Test variable length of a simple type */
+    if (testfl_VLof_atomic() < 0)
+	status = FAIL;
+
+    /* Test variable length of a compound type */
+    if (testfl_VLof_comptype() < 0)
+	status = FAIL;
+
+    /* Test compound type with variable length */
+    if (testfl_compound_VL_VLtype() < 0)
+	status = FAIL;
+
+    /* Test variable length of a variable length */
+    if (testfl_VLof_VLtype() < 0)
+	status = FAIL;
+
     return(status);
 }