[svn-r27424] Implement support for h5debug for VDS.

Implement support for H5Pencode/decode with VDS properties.
Testing for H5Pencode/decode with VDS.
Relax assertion check for number of elements written to buffer as we do not
check for overlaps in mappings.
Other minor fixes/cleanup.

Tested: ummon

6 files changed, 250 insertions, 50 deletions

diff --git a/src/H5Dvirtual.c b/src/H5Dvirtual.c
index b4a8060..8b8af36 100644
--- a/src/H5Dvirtual.c
+++ b/src/H5Dvirtual.c
@@ -1099,8 +1099,8 @@ H5D__virtual_set_extent_unlim(const H5D_t *dset, hid_t dxpl_id)
 
     /* Sanity check */
     HDassert(dset);
-    storage = &dset->shared->layout.storage.u.virt;
     HDassert(dset->shared->layout.storage.type == H5D_VIRTUAL);
+    storage = &dset->shared->layout.storage.u.virt;
     HDassert((storage->view == H5D_VDS_FIRST_MISSING) || (storage->view == H5D_VDS_LAST_AVAILABLE));
 
     /* Get rank of VDS */
@@ -1956,11 +1956,9 @@ H5D__virtual_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
     } /* end for */
 
     /* Fill unmapped part of buffer with fill value */
-    if(tot_nelmts != nelmts) {
+    if(tot_nelmts < nelmts) {
         H5D_fill_value_t fill_status;       /* Fill value status */
 
-        HDassert(tot_nelmts < nelmts);
-
         /* Check the fill value status */
         if(H5P_is_fill_value_defined(&io_info->dset->shared->dcpl_cache.fill, &fill_status) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't tell if fill value defined")
@@ -1994,7 +1992,7 @@ H5D__virtual_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
 
 #ifndef NDEBUG
             /* Make sure the total number of elements written (including fill
-             * values) == nelmts */
+             * values) >= nelmts */
             {
                 hssize_t    select_nelmts;  /* Number of elements in selection */
 
@@ -2002,8 +2000,10 @@ H5D__virtual_read(H5D_io_info_t *io_info, const H5D_type_info_t *type_info,
                 if((select_nelmts = (hssize_t)H5S_GET_SELECT_NPOINTS(fill_space)) < 0)
                     HGOTO_ERROR(H5E_DATASET, H5E_CANTCOUNT, FAIL, "unable to get number of elements in selection")
 
-                /* Verify number of elements is correct */
-                HDassert((tot_nelmts + (hsize_t)select_nelmts) == nelmts);
+                /* Verify number of elements is correct.  Note that since we
+                 * don't check for overlap we can't assert that these are equal
+                 */
+                HDassert((tot_nelmts + (hsize_t)select_nelmts) >= nelmts);
             } /* end block */
 #endif /* NDEBUG */
         } /* end if */
diff --git a/src/H5Olayout.c b/src/H5Olayout.c
index ba3df82..d747512 100644
--- a/src/H5Olayout.c
+++ b/src/H5Olayout.c
@@ -545,11 +545,11 @@ H5O_layout_encode(H5F_t *f, hbool_t H5_ATTR_UNUSED disable_shared, uint8_t *p, c
                 /* Encode each entry */
                 for(i = 0; i < mesg->storage.u.virt.list_nused; i++) {
                     /* Source file name */
-                    (void)HDstrcpy((char *)heap_block_p, mesg->storage.u.virt.list[i].source_file_name);
+                    (void)HDmemcpy((char *)heap_block_p, mesg->storage.u.virt.list[i].source_file_name, str_size[2 * i]);
                     heap_block_p += str_size[2 * i];
 
                     /* Source dataset name */
-                    (void)HDstrcpy((char *)heap_block_p, mesg->storage.u.virt.list[i].source_dset_name);
+                    (void)HDmemcpy((char *)heap_block_p, mesg->storage.u.virt.list[i].source_dset_name, str_size[(2 * i) + 1]);
                     heap_block_p += str_size[(2 * i) + 1];
 
                     /* Source selection */
@@ -948,7 +948,7 @@ H5O_layout_debug(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, const vo
     FILE * stream, int indent, int fwidth)
 {
     const H5O_layout_t     *mesg = (const H5O_layout_t *) _mesg;
-    unsigned                    u;
+    size_t                  u;
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -971,7 +971,7 @@ H5O_layout_debug(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, const vo
                       "Number of dimensions:",
                       (unsigned long)(mesg->u.chunk.ndims));
             HDfprintf(stream, "%*s%-*s {", indent, "", fwidth, "Size:");
-            for(u = 0; u < mesg->u.chunk.ndims; u++)
+            for(u = 0; u < (size_t)mesg->u.chunk.ndims; u++)
                 HDfprintf(stream, "%s%lu", u ? ", " : "", (unsigned long)(mesg->u.chunk.dim[u]));
             HDfprintf(stream, "}\n");
 
@@ -1009,8 +1009,23 @@ H5O_layout_debug(H5F_t H5_ATTR_UNUSED *f, hid_t H5_ATTR_UNUSED dxpl_id, const vo
             break;
 
         case H5D_VIRTUAL:
-            HDassert(0 && "Not yet implemented...");//VDSINC
-
+            HDfprintf(stream, "%*s%-*s %s\n", indent, "", fwidth,
+                      "Type:", "Virtual");
+            HDfprintf(stream, "%*s%-*s %a\n", indent, "", fwidth,
+                      "Global heap address:", mesg->storage.u.virt.serial_list_hobjid.addr);
+            HDfprintf(stream, "%*s%-*s %Zu\n", indent, "", fwidth,
+                      "Global heap index:", mesg->storage.u.virt.serial_list_hobjid.idx);
+            for(u = 0; u < mesg->storage.u.virt.list_nused; u++) {
+                HDfprintf(stream, "%*sMapping %u:\n", indent, "", u);
+                HDfprintf(stream, "%*s%-*s %s\n", indent + 3, "", fwidth - 3,
+                      "Virtual selection:", "<Not yet implemented>");
+                HDfprintf(stream, "%*s%-*s %s\n", indent + 3, "", fwidth - 3,
+                      "Source file name:", mesg->storage.u.virt.list[u].source_file_name);
+                HDfprintf(stream, "%*s%-*s %s\n", indent + 3, "", fwidth - 3,
+                      "Source dataset name:", mesg->storage.u.virt.list[u].source_dset_name);
+                HDfprintf(stream, "%*s%-*s %s\n", indent + 3, "", fwidth - 3,
+                      "Source selection:", "<Not yet implemented>");
+            } /* end for */
             break;
 
         case H5D_LAYOUT_ERROR:
diff --git a/src/H5Pdcpl.c b/src/H5Pdcpl.c
index 39e8e77..29976c2 100644
--- a/src/H5Pdcpl.c
+++ b/src/H5Pdcpl.c
@@ -438,8 +438,12 @@ H5P__dcrt_layout_enc(const void *value, void **_pp, size_t *size)
 {
     const H5O_layout_t *layout = (const H5O_layout_t *)value; /* Create local aliases for values */
     uint8_t **pp = (uint8_t **)_pp;
+    uint8_t *tmp_p;
+    size_t tmp_size;
+    size_t u;               /* Local index variable */
+    herr_t ret_value = SUCCEED;         /* Return value */
 
-    FUNC_ENTER_STATIC_NOERR
+    FUNC_ENTER_STATIC
 
     /* Sanity check */
     HDassert(layout);
@@ -451,19 +455,84 @@ H5P__dcrt_layout_enc(const void *value, void **_pp, size_t *size)
 
         /* If layout is chunked, encode chunking structure */
         if(H5D_CHUNKED == layout->type) {
-            unsigned u;     /* Local index variable */
-
             /* Encode rank */
             *(*pp)++ = (uint8_t)layout->u.chunk.ndims;
 
             /* Encode chunk dims */
             HDcompile_assert(sizeof(uint32_t) == sizeof(layout->u.chunk.dim[0]));
-            for(u = 0; u < layout->u.chunk.ndims; u++)
+            for(u = 0; u < (size_t)layout->u.chunk.ndims; u++)
                 UINT32ENCODE(*pp, layout->u.chunk.dim[u])
         } /* end if */
         else if(H5D_VIRTUAL == layout->type) {
-            HDassert(0 && "Not yet implemented...");//VDSINC
-        } /* end else */
+            uint64_t nentries = (uint64_t)layout->storage.u.virt.list_nused;
+
+            /* Encode number of entries */
+            UINT64ENCODE(*pp, nentries)
+            *size += (size_t)8;
+
+            /* Iterate over entries */
+            for(u = 0; u < layout->storage.u.virt.list_nused; u++) {
+                /* Source file name */
+                tmp_size = HDstrlen(layout->storage.u.virt.list[u].source_file_name) + (size_t)1;
+                (void)HDmemcpy(*pp, layout->storage.u.virt.list[u].source_file_name, tmp_size);
+                *pp += tmp_size;
+                *size += tmp_size;
+
+                /* Source dataset name */
+                tmp_size = HDstrlen(layout->storage.u.virt.list[u].source_dset_name) + (size_t)1;
+                (void)HDmemcpy(*pp, layout->storage.u.virt.list[u].source_dset_name, tmp_size);
+                *pp += tmp_size;
+                *size += tmp_size;
+
+                /* Source selection.  Note that we are not passing the real
+                 * allocated size because we do no know it.  H5P__encode should
+                 * have verified that the buffer is large enough for the entire
+                 * list before we get here. */
+                tmp_size = (size_t)-1;
+                tmp_p = *pp;
+                if(H5S_encode(layout->storage.u.virt.list[u].source_select, pp, &tmp_size) < 0)
+                    HGOTO_ERROR(H5E_PLIST, H5E_CANTENCODE, FAIL, "unable to serialize source selection")
+                *size += (size_t)(*pp - tmp_p);
+
+                /* Virtual dataset selection.  Same notes as above apply. */
+                tmp_size = (size_t)-1;
+                tmp_p = *pp;
+                if(H5S_encode(layout->storage.u.virt.list[u].source_dset.virtual_select, pp, &tmp_size) < 0)
+                    HGOTO_ERROR(H5E_PLIST, H5E_CANTENCODE, FAIL, "unable to serialize virtual selection")
+                *size += (size_t)(*pp - tmp_p);
+            } /* end for */
+        } /* end if */
+    } /* end if */
+    else if(H5D_VIRTUAL == layout->type) {
+        /* Calculate size of virtual layout info */
+        /* number of entries */
+        *size += (size_t)8;
+
+        /* NULL pointer to pass to H5S_encode */
+        tmp_p = NULL;
+
+        /* Iterate over entries */
+        for(u = 0; u < layout->storage.u.virt.list_nused; u++) {
+            /* Source file name */
+            tmp_size = HDstrlen(layout->storage.u.virt.list[u].source_file_name) + (size_t)1;
+            *size += tmp_size;
+
+            /* Source dataset name */
+            tmp_size = HDstrlen(layout->storage.u.virt.list[u].source_dset_name) + (size_t)1;
+            *size += tmp_size;
+
+            /* Source selection */
+            tmp_size = (size_t)0;
+            if(H5S_encode(layout->storage.u.virt.list[u].source_select, &tmp_p, &tmp_size) < 0)
+                HGOTO_ERROR(H5E_PLIST, H5E_CANTENCODE, FAIL, "unable to serialize source selection")
+            *size += tmp_size;
+
+            /* Virtual dataset selection */
+            tmp_size = (size_t)0;
+            if(H5S_encode(layout->storage.u.virt.list[u].source_dset.virtual_select, &tmp_p, &tmp_size) < 0)
+                HGOTO_ERROR(H5E_PLIST, H5E_CANTENCODE, FAIL, "unable to serialize virtual selection")
+            *size += tmp_size;
+        } /* end for */
     } /* end if */
 
     /* Size of layout type */
@@ -475,7 +544,8 @@ H5P__dcrt_layout_enc(const void *value, void **_pp, size_t *size)
         *size += layout->u.chunk.ndims * sizeof(uint32_t);
     } /* end if */
 
-    FUNC_LEAVE_NOAPI(SUCCEED)
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5P__dcrt_layout_enc() */
 
 
@@ -498,7 +568,7 @@ static herr_t
 H5P__dcrt_layout_dec(const void **_pp, void *value)
 {
     const H5O_layout_t *layout;         /* Storage layout */
-    H5O_layout_t chunk_layout;          /* Layout structure for chunk info */
+    H5O_layout_t tmp_layout;            /* Temporary local layout structure */
     H5D_layout_t type;                  /* Layout type */
     const uint8_t **pp = (const uint8_t **)_pp;
     herr_t ret_value = SUCCEED;         /* Return value */
@@ -538,21 +608,111 @@ H5P__dcrt_layout_dec(const void **_pp, void *value)
                     unsigned u;             /* Local index variable */
 
                     /* Initialize to default values */
-                    chunk_layout = H5D_def_layout_chunk_g;
+                    tmp_layout = H5D_def_layout_chunk_g;
 
                     /* Set rank & dimensions */
-                    chunk_layout.u.chunk.ndims = (unsigned)ndims;
+                    tmp_layout.u.chunk.ndims = (unsigned)ndims;
                     for(u = 0; u < ndims; u++)
-                        UINT32DECODE(*pp, chunk_layout.u.chunk.dim[u])
+                        UINT32DECODE(*pp, tmp_layout.u.chunk.dim[u])
 
                     /* Point at the newly set up struct */
-                    layout = &chunk_layout;
+                    layout = &tmp_layout;
                 } /* end else */
             }
             break;
 
         case H5D_VIRTUAL:
-            HDassert(0 && "Not yet implemented...");//VDSINC
+            {
+                uint64_t nentries;              /* Number of VDS mappings */
+
+                /* Decode number of entries */
+                UINT64DECODE(*pp, nentries)
+
+                if(nentries == (uint64_t)0)
+                    /* Just use the default struct */
+                    layout = &H5D_def_layout_virtual_g;
+                else {
+                    size_t tmp_size;
+                    size_t u;           /* Local index variable */
+
+                    /* Initialize to default values */
+                    tmp_layout = H5D_def_layout_virtual_g;
+
+                    /* Allocate entry list */
+                    if(NULL == (tmp_layout.storage.u.virt.list = (H5O_storage_virtual_ent_t *)H5MM_calloc((size_t)nentries * sizeof(H5O_storage_virtual_ent_t))))
+                        HGOTO_ERROR(H5E_PLIST, H5E_CANTALLOC, FAIL, "unable to allocate heap block")
+                    tmp_layout.storage.u.virt.list_nalloc = (size_t)nentries;
+                    tmp_layout.storage.u.virt.list_nused = (size_t)nentries;
+
+                    /* Decode each entry */
+                    for(u = 0; u < (size_t)nentries; u++) {
+                        /* Source file name */
+                        tmp_size = HDstrlen((const char *)*pp) + 1;
+                        if(NULL == (tmp_layout.storage.u.virt.list[u].source_file_name = (char *)H5MM_malloc(tmp_size)))
+                            HGOTO_ERROR(H5E_PLIST, H5E_CANTALLOC, FAIL, "unable to allocate memory for source file name")
+                        (void)HDmemcpy(tmp_layout.storage.u.virt.list[u].source_file_name, *pp, tmp_size);
+                        *pp += tmp_size;
+
+                        /* Source dataset name */
+                        tmp_size = HDstrlen((const char *)*pp) + 1;
+                        if(NULL == (tmp_layout.storage.u.virt.list[u].source_dset_name = (char *)H5MM_malloc(tmp_size)))
+                            HGOTO_ERROR(H5E_PLIST, H5E_CANTALLOC, FAIL, "unable to allocate memory for source dataset name")
+                        (void)HDmemcpy(tmp_layout.storage.u.virt.list[u].source_dset_name, *pp, tmp_size);
+                        *pp += tmp_size;
+
+                        /* Source selection */
+                        if(NULL == (tmp_layout.storage.u.virt.list[u].source_select = H5S_decode(pp)))
+                            HGOTO_ERROR(H5E_PLIST, H5E_CANTDECODE, FAIL, "can't decode source space selection")
+                        tmp_layout.storage.u.virt.list[u].source_space_status = H5O_VIRTUAL_STATUS_USER;
+
+                        /* Virtual selection */
+                        if(NULL == (tmp_layout.storage.u.virt.list[u].source_dset.virtual_select = H5S_decode(pp)))
+                            HGOTO_ERROR(H5E_PLIST, H5E_CANTDECODE, FAIL, "can't decode virtual space selection")
+                        tmp_layout.storage.u.virt.list[u].virtual_space_status = H5O_VIRTUAL_STATUS_USER;
+
+                        /* Parse source file and dataset names for "printf"
+                         * style format specifiers */
+                        if(H5D_virtual_parse_source_name(tmp_layout.storage.u.virt.list[u].source_file_name, &tmp_layout.storage.u.virt.list[u].parsed_source_file_name, &tmp_layout.storage.u.virt.list[u].psfn_static_strlen, &tmp_layout.storage.u.virt.list[u].psfn_nsubs) < 0)
+                            HGOTO_ERROR(H5E_PLIST, H5E_CANTINIT, FAIL, "can't parse source file name")
+                        if(H5D_virtual_parse_source_name(tmp_layout.storage.u.virt.list[u].source_dset_name, &tmp_layout.storage.u.virt.list[u].parsed_source_dset_name, &tmp_layout.storage.u.virt.list[u].psdn_static_strlen, &tmp_layout.storage.u.virt.list[u].psdn_nsubs) < 0)
+                            HGOTO_ERROR(H5E_PLIST, H5E_CANTINIT, FAIL, "can't parse source dataset name")
+
+                        /* Set source names in source_dset struct */
+                        if((tmp_layout.storage.u.virt.list[u].psfn_nsubs == 0)
+                                && (tmp_layout.storage.u.virt.list[u].psdn_nsubs == 0)) {
+                            if(tmp_layout.storage.u.virt.list[u].parsed_source_file_name)
+                                tmp_layout.storage.u.virt.list[u].source_dset.file_name = tmp_layout.storage.u.virt.list[u].parsed_source_file_name->name_segment;
+                            else
+                                tmp_layout.storage.u.virt.list[u].source_dset.file_name = tmp_layout.storage.u.virt.list[u].source_file_name;
+                            if(tmp_layout.storage.u.virt.list[u].parsed_source_dset_name)
+                                tmp_layout.storage.u.virt.list[u].source_dset.dset_name = tmp_layout.storage.u.virt.list[u].parsed_source_dset_name->name_segment;
+                            else
+                                tmp_layout.storage.u.virt.list[u].source_dset.dset_name = tmp_layout.storage.u.virt.list[u].source_dset_name;
+                        } /* end if */
+
+                        /* unlim_dim fields */
+                        tmp_layout.storage.u.virt.list[u].unlim_dim_source = H5S_get_select_unlim_dim(tmp_layout.storage.u.virt.list[u].source_select);
+                        tmp_layout.storage.u.virt.list[u].unlim_dim_virtual = H5S_get_select_unlim_dim(tmp_layout.storage.u.virt.list[u].source_dset.virtual_select);
+                        tmp_layout.storage.u.virt.list[u].unlim_extent_source = HSIZE_UNDEF;
+                        tmp_layout.storage.u.virt.list[u].unlim_extent_virtual = HSIZE_UNDEF;
+                        tmp_layout.storage.u.virt.list[u].clip_size_source = HSIZE_UNDEF;
+                        tmp_layout.storage.u.virt.list[u].clip_size_virtual = HSIZE_UNDEF;
+
+                        /* Clipped selections */
+                        if(tmp_layout.storage.u.virt.list[u].unlim_dim_virtual < 0) {
+                            tmp_layout.storage.u.virt.list[u].source_dset.clipped_source_select = tmp_layout.storage.u.virt.list[u].source_select;
+                            tmp_layout.storage.u.virt.list[u].source_dset.clipped_virtual_select = tmp_layout.storage.u.virt.list[u].source_dset.virtual_select;
+                        } /* end if */
+
+                        /* Update min_dims */
+                        if(H5D_virtual_update_min_dims(&tmp_layout, u) < 0)
+                            HGOTO_ERROR(H5E_PLIST, H5E_CANTINIT, FAIL, "unable to update virtual dataset minimum dimensions")
+                    } /* end for */
+
+                    /* Point at the newly set up struct */
+                    layout = &tmp_layout;
+                } /* end else */
+            } /* end block */
             break;
 
         case H5D_LAYOUT_ERROR:
diff --git a/src/H5S.c b/src/H5S.c
index 79e996e..6a6f45a 100644
--- a/src/H5S.c
+++ b/src/H5S.c
@@ -53,8 +53,6 @@
 /* Local Prototypes */
 /********************/
 static htri_t H5S_is_simple(const H5S_t *sdim);
-static herr_t H5S_encode(H5S_t *obj, unsigned char *buf, size_t *nalloc);
-static H5S_t *H5S_decode(const unsigned char *buf);
 
 
 /*********************/
@@ -1506,7 +1504,7 @@ H5Sencode(hid_t obj_id, void *buf, size_t *nalloc)
     if (NULL==(dspace=(H5S_t *)H5I_object_verify(obj_id, H5I_DATASPACE)))
 	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
 
-    if(H5S_encode(dspace, (unsigned char *)buf, nalloc)<0)
+    if(H5S_encode(dspace, (unsigned char **)&buf, nalloc)<0)
 	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL, "can't encode datatype")
 
 done:
@@ -1530,8 +1528,8 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static herr_t
-H5S_encode(H5S_t *obj, unsigned char *buf, size_t *nalloc)
+herr_t
+H5S_encode(H5S_t *obj, unsigned char **p, size_t *nalloc)
 {
     size_t      extent_size;    /* Size of serialized dataspace extent */
     hssize_t    sselect_size;   /* Signed size of serialized dataspace selection */
@@ -1556,28 +1554,28 @@ H5S_encode(H5S_t *obj, unsigned char *buf, size_t *nalloc)
 
     /* Verify the size of buffer.  If it's not big enough, simply return the
      * right size without filling the buffer. */
-    if(!buf || *nalloc < (extent_size + select_size + 1 + 1 + 1 + 4))
+    if(!*p || *nalloc < (extent_size + select_size + 1 + 1 + 1 + 4))
         *nalloc = extent_size + select_size + 1 + 1 + 1 + 4;
     else {
         /* Encode the type of the information */
-        *buf++ = H5O_SDSPACE_ID;
+        *(*p)++ = H5O_SDSPACE_ID;
 
         /* Encode the version of the dataspace information */
-        *buf++ = H5S_ENCODE_VERSION;
+        *(*p)++ = H5S_ENCODE_VERSION;
 
         /* Encode the "size of size" information */
-        *buf++ = (unsigned char)H5F_SIZEOF_SIZE(f);
+        *(*p)++ = (unsigned char)H5F_SIZEOF_SIZE(f);
 
         /* Encode size of extent information. Pointer is actually moved in this macro. */
-        UINT32ENCODE(buf, extent_size);
+        UINT32ENCODE(*p, extent_size);
 
         /* Encode the extent part of dataspace */
-        if(H5O_msg_encode(f, H5O_SDSPACE_ID, TRUE, buf, obj) < 0)
+        if(H5O_msg_encode(f, H5O_SDSPACE_ID, TRUE, *p, obj) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTENCODE, FAIL, "can't encode extent space")
-        buf += extent_size;
+        *p += extent_size;
 
         /* Encode the selection part of dataspace.  */
-        if(H5S_SELECT_SERIALIZE(f, obj, &buf) < 0)
+        if(H5S_SELECT_SERIALIZE(f, obj, p) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTENCODE, FAIL, "can't encode select space")
     } /* end else */
 
@@ -1618,7 +1616,7 @@ H5Sdecode(const void *buf)
     if(buf == NULL)
 	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "empty buffer")
 
-    if((ds = H5S_decode((const unsigned char *)buf)) == NULL)
+    if((ds = H5S_decode((const unsigned char **)&buf)) == NULL)
 	HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDECODE, FAIL, "can't decode object")
 
     /* Register the type and return the ID */
@@ -1646,8 +1644,8 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-static H5S_t*
-H5S_decode(const unsigned char *buf)
+H5S_t*
+H5S_decode(const unsigned char **p)
 {
     H5S_t       *ds;
     H5S_extent_t *extent;
@@ -1659,28 +1657,28 @@ H5S_decode(const unsigned char *buf)
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Decode the type of the information */
-    if(*buf++ != H5O_SDSPACE_ID)
+    if(*(*p)++ != H5O_SDSPACE_ID)
 	HGOTO_ERROR(H5E_DATASPACE, H5E_BADMESG, NULL, "not an encoded dataspace")
 
     /* Decode the version of the dataspace information */
-    if(*buf++ != H5S_ENCODE_VERSION)
+    if(*(*p)++ != H5S_ENCODE_VERSION)
 	HGOTO_ERROR(H5E_DATASPACE, H5E_VERSION, NULL, "unknown version of encoded dataspace")
 
     /* Decode the "size of size" information */
-    sizeof_size = *buf++;
+    sizeof_size = *(*p)++;
 
     /* Allocate "fake" file structure */
     if(NULL == (f = H5F_fake_alloc(sizeof_size)))
 	HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate fake file struct")
 
     /* Decode size of extent information */
-    UINT32DECODE(buf, extent_size);
+    UINT32DECODE(*p, extent_size);
 
     /* Decode the extent part of dataspace */
     /* (pass mostly bogus file pointer and bogus DXPL) */
-    if((extent = (H5S_extent_t *)H5O_msg_decode(f, H5P_DEFAULT, NULL, H5O_SDSPACE_ID, buf))==NULL)
+    if((extent = (H5S_extent_t *)H5O_msg_decode(f, H5P_DEFAULT, NULL, H5O_SDSPACE_ID, *p))==NULL)
 	HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDECODE, NULL, "can't decode object")
-    buf += extent_size;
+    *p += extent_size;
 
     /* Copy the extent into dataspace structure */
     if((ds = H5FL_CALLOC(H5S_t))==NULL)
@@ -1696,7 +1694,7 @@ H5S_decode(const unsigned char *buf)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSET, NULL, "unable to set all selection")
 
     /* Decode the select part of dataspace.  I believe this part always exists. */
-    if(H5S_SELECT_DESERIALIZE(f, &ds, &buf) < 0)
+    if(H5S_SELECT_DESERIALIZE(f, &ds, p) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDECODE, NULL, "can't decode space selection")
 
     /* Set return value */
diff --git a/src/H5Sprivate.h b/src/H5Sprivate.h
index 7658f76..91e4513 100644
--- a/src/H5Sprivate.h
+++ b/src/H5Sprivate.h
@@ -194,6 +194,8 @@ H5_DLL H5S_t *H5S_create(H5S_class_t type);
 H5_DLL H5S_t *H5S_create_simple(unsigned rank, const hsize_t dims[/*rank*/],
     const hsize_t maxdims[/*rank*/]);
 H5_DLL herr_t H5S_set_latest_version(H5S_t *ds);
+H5_DLL herr_t H5S_encode(H5S_t *obj, unsigned char **p, size_t *nalloc);
+H5_DLL H5S_t *H5S_decode(const unsigned char **p);
 H5_DLL herr_t H5S_debug(H5F_t *f, hid_t dxpl_id, const void *_mesg, FILE *stream,
     int indent, int fwidth);
 #ifndef H5_NO_DEPRECATED_SYMBOLS
diff --git a/test/vds.c b/test/vds.c
index 62b444f..573af9e 100644
--- a/test/vds.c
+++ b/test/vds.c
@@ -25,6 +25,7 @@
 typedef enum {
     TEST_API_BASIC,
     TEST_API_COPY_PLIST,
+    TEST_API_ENCDEC_PLIST,
     TEST_API_CREATE_DSET,
     TEST_API_REOPEN_DSET,
     TEST_API_REOPEN_FILE,
@@ -45,7 +46,6 @@ const char *FILENAME[] = {
 #define TEST_IO_DIFFERENT_FILE  0x02u
 #define TEST_IO_REOPEN_VIRT     0x04u
 #define TEST_IO_NTESTS          0x08u
-//VDSINC add close source, virtual file
 
 #define LIST_DOUBLE_SIZE (H5D_VIRTUAL_DEF_LIST_SIZE + 1)
 
@@ -331,6 +331,7 @@ test_api_get_ex_dcpl(test_api_config_t config, hid_t fapl, hid_t dcpl,
 {
     hid_t       file = -1;      /* File */
     hid_t       dset = -1;      /* Virtual dataset */
+    void        *plist_buf = NULL; /* Serialized property list buffer */
 
     HDassert((config >= TEST_API_BASIC) && (config < TEST_API_NTESTS));
     HDassert(fapl >= 0);
@@ -386,6 +387,25 @@ test_api_get_ex_dcpl(test_api_config_t config, hid_t fapl, hid_t dcpl,
         if((*ex_dcpl = H5Pcopy(dcpl)) < 0)
             TEST_ERROR
     } /* end if */
+    else if(config == TEST_API_ENCDEC_PLIST) {
+        size_t plist_buf_size;
+
+        /* Encode property list to plist_buf */
+        if(H5Pencode(dcpl, NULL, &plist_buf_size) < 0)
+            TEST_ERROR
+        if(NULL == (plist_buf = HDmalloc(plist_buf_size)))
+            TEST_ERROR
+        if(H5Pencode(dcpl, plist_buf, &plist_buf_size) < 0)
+            TEST_ERROR
+
+        /* Decode serialized property list to *ex_dcpl */
+        if((*ex_dcpl = H5Pdecode(plist_buf)) < 0)
+            TEST_ERROR
+
+        /* Free plist_buf */
+        HDfree(plist_buf);
+        plist_buf = NULL;
+    } /* end if */
     else {
         /* Simply copy the id to ex_dcpl and increment the ref count so ex_dcpl
          * can be closed */
@@ -403,6 +423,8 @@ error:
         if(dset >= 0)
             (void)H5Dclose(dset);
     } H5E_END_TRY;
+    if(plist_buf)
+        HDfree(plist_buf);
 
     return -1;
 } /* end test_api_get_ex_dcpl() */
@@ -440,6 +462,9 @@ test_api(test_api_config_t config, hid_t fapl)
         case TEST_API_COPY_PLIST:
             TESTING("virtual dataset API functions with copied plists")
             break;
+        case TEST_API_ENCDEC_PLIST:
+            TESTING("virtual dataset API functions with encoded and decoded plists")
+            break;
         case TEST_API_CREATE_DSET:
             TESTING("virtual dataset create")
             break;