Merge pull request #1419 in HDFFV/hdf5 from ~JAKE.SMITH/hdf5:dset_ohdr_minimize_110 to hdf5_1_10

Minimized dataset object headers

* commit 'e1d865a11d7864f4c0733aa22a8c96f0f015ef75':
  Remove "bad" statements from end of TEST_ERROR.     Formerly arguments to FAIL_PUTS_ERROR.
  Add semicolon at end of TEST_ERROR() invocation for consistency.
  Change FAIL_PUTS_ERROR to TEST_ERROR. Remove VOL-related merge cruft.
  Change H5Dcreate() to H5Dcreate2(). Fix return value (int -> void).
  Change H5Acreate to H5Acreate2
  Remove unnecessary s
  Incoporate minimized dataset headers code and tests.

22 files changed, 3188 insertions, 1475 deletions

diff --git a/src/H5Dint.c b/src/H5Dint.c
index e6c990d..ea4245b 100644
--- a/src/H5Dint.c
+++ b/src/H5Dint.c
@@ -25,6 +25,7 @@
 #include "H5Dpkg.h"           /* Datasets */
 #include "H5CXprivate.h"      /* API Contexts */
 #include "H5Eprivate.h"       /* Error handling */
+#include "H5Fprivate.h"       /* Files */
 #include "H5FLprivate.h"      /* Free Lists */
 #include "H5FOprivate.h"      /* File objects */
 #include "H5Iprivate.h"       /* IDs */
@@ -60,6 +61,9 @@ static herr_t H5D__init_storage(const H5D_io_info_t *io_info, hbool_t full_overw
         hsize_t old_dim[]);
 static herr_t H5D__append_flush_setup(H5D_t *dset, hid_t dapl_id);
 static herr_t H5D__close_cb(H5D_t *dataset);
+static herr_t H5D__use_minimized_dset_headers(H5F_t *file, H5D_t *dset, hbool_t *minimize);
+static herr_t H5D__prepare_minimized_oh(H5F_t *file, H5D_t *dset, H5O_loc_t *oloc);
+static size_t H5D__calculate_minimum_header_size(H5F_t *file, H5D_t *dset, H5O_t *ohdr);
 
 /*********************/
 /* Package Variables */
@@ -620,6 +624,211 @@ done:
 
 
 /*-------------------------------------------------------------------------
+ * Function:   H5D__use_minimized_dset_headers
+ *
+ * Purpose:    Compartmentalize check for file- or dcpl-set values indicating
+ *             to create a "minimized" dataset object header.
+ *             Upon success, write resulting value to out pointer `minimize`.
+ *
+ * Return:     Success: SUCCEED (0) (non-negative value)
+ *             Failure: FAIL (-1) (negative value)
+ *
+ * Programmer: Jacob Smith
+ *             16 August 2018
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D__use_minimized_dset_headers(H5F_t *file, H5D_t *dset, hbool_t *minimize)
+{
+    H5P_genplist_t *plist     = NULL;
+    herr_t          ret_value = SUCCEED;
+
+    FUNC_ENTER_STATIC
+
+    HDassert(file);
+    HDassert(dset);
+    HDassert(minimize);
+
+    plist = H5P_object_verify(dset->shared->dcpl_id, H5P_DATASET_CREATE);
+    if(NULL == plist)
+        HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "problem getting dcpl")
+    if(H5P_get(plist, H5D_CRT_MIN_DSET_HDR_SIZE_NAME, minimize) == FAIL)
+        HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get minimize value from dcpl")
+
+    if(FALSE == *minimize)
+        *minimize = H5F_get_min_dset_ohdr(file);
+
+done:
+    if(FAIL == ret_value)
+        *minimize = FALSE;
+    FUNC_LEAVE_NOAPI(ret_value);
+} /* H5D__use_minimized_dset_headers */
+
+
+/*-------------------------------------------------------------------------
+ * Function:   H5D__calculate_minimium_header_size
+ *
+ * Purpose:    Calculate the size required for the minimized object header.
+ *
+ * Return:     Success: Positive value > 0
+ *             Failure: 0
+ *
+ * Programmer: Jacob Smith
+ *             16 August 2018
+ *-------------------------------------------------------------------------
+ */
+static size_t
+H5D__calculate_minimum_header_size(H5F_t *file, H5D_t *dset, H5O_t *ohdr)
+{
+    H5T_t      *type             = NULL;
+    H5O_fill_t *fill_prop        = NULL;
+    hbool_t     use_at_least_v18 = FALSE;
+    const char  continuation[1]  = ""; /* requred for work-around */
+    size_t      get_value        = 0;
+    size_t      ret_value        = 0;
+
+    FUNC_ENTER_STATIC
+
+    HDassert(file);
+    HDassert(dset);
+    HDassert(ohdr);
+
+    type = dset->shared->type;
+    fill_prop = &(dset->shared->dcpl_cache.fill);
+    use_at_least_v18 = (H5F_LOW_BOUND(file) >= H5F_LIBVER_V18);
+
+    /* Datatype message size */
+    get_value = H5O_msg_size_oh(file, ohdr, H5O_DTYPE_ID, type, 0);
+    if (get_value == 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, 0, "Can't get size of datatype message")
+    ret_value += get_value;
+
+    /* Shared Dataspace message size */
+    get_value = H5O_msg_size_oh(file, ohdr, H5O_SDSPACE_ID, dset->shared->space, 0);
+    if (get_value == 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, 0, "can't get size of dataspace message")
+    ret_value += get_value;
+
+    /* "Layout" message size */
+    get_value = H5O_msg_size_oh(file, ohdr, H5O_LAYOUT_ID, &dset->shared->layout, 0);
+    if (get_value == 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, 0, "can't get size of layout message")
+    ret_value += get_value;
+
+    /* Fill Value message size */
+    get_value = H5O_msg_size_oh(file, ohdr, H5O_FILL_NEW_ID, fill_prop, 0);
+    if (get_value == 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, 0, "can't get size of fill value message")
+    ret_value += get_value;
+
+    /* "Continuation" message size */
+    /* message pointer "continuation" is unused by raw get function, however,
+     * a null pointer would be intercepted by an assert in H5O_msg_size_oh().
+     */
+    get_value = H5O_msg_size_oh(file, ohdr, H5O_CONT_ID, continuation, 0);
+    if (get_value == 0)
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, 0, "can't get size of continuation message")
+    ret_value += get_value;
+
+    /* Fill Value (backwards compatability) message size */
+    if(fill_prop->buf && !use_at_least_v18) {
+        H5O_fill_t old_fill_prop; /* Copy for writing "old" fill value */
+
+        /* Shallow copy the fill value property */
+        /* guards against shared component modification */
+        HDmemcpy(&old_fill_prop, fill_prop, sizeof(old_fill_prop));
+
+        if (H5O_msg_reset_share(H5O_FILL_ID, &old_fill_prop) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, 0, "can't reset the copied fill property")
+
+        get_value = H5O_msg_size_oh(file, ohdr, H5O_FILL_ID, &old_fill_prop, 0);
+        if (get_value == 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, 0, "can't get size of fill value (backwards compat) message")
+        ret_value += get_value;
+    }
+
+    /* Filter/Pipeline message size */
+    if(H5D_CHUNKED == dset->shared->layout.type) {
+        H5O_pline_t *pline = &dset->shared->dcpl_cache.pline;
+        if(pline->nused > 0) {
+            get_value = H5O_msg_size_oh(file, ohdr, H5O_PLINE_ID, pline, 0);
+            if (get_value == 0)
+                HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, 0, "can't get size of filter message")
+            ret_value += get_value;
+        }
+    }
+
+    /* External File Link message size */
+    if(dset->shared->dcpl_cache.efl.nused > 0) {
+        get_value = H5O_msg_size_oh(file, ohdr, H5O_EFL_ID, &dset->shared->dcpl_cache.efl, 0);
+        if (get_value == 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, 0, "can't get size of external file link message")
+        ret_value += get_value;
+    }
+
+    /* Modification Time message size */
+    if(H5O_HDR_STORE_TIMES & H5O_OH_GET_FLAGS(ohdr)) {
+        HDassert(H5O_OH_GET_VERSION(ohdr) >= 1); /* 1 :: H5O_VERSION_1 (H5Opkg.h) */
+
+        if(H5O_OH_GET_VERSION(ohdr) == 1) {
+            /* v1 object headers store modification time as a message */
+            time_t mtime;
+            get_value = H5O_msg_size_oh(file, ohdr, H5O_MTIME_NEW_ID, &mtime, 0);
+            if (get_value == 0)
+                HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, 0, "can't get size of modification time message")
+            ret_value += get_value;
+        }
+    }
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value);
+} /* H5D__calculate_minimum_header_size */
+
+
+/*-------------------------------------------------------------------------
+ * Function:   H5D__prepare_minimized_oh
+ *
+ * Purpose:    Create an object header (H5O_t) allocated with the smallest
+ *             possible size.
+ *
+ * Return:     Success: SUCCEED (0) (non-negative value)
+ *             Failure: FAIL (-1) (negative value)
+ *
+ * Programmer: Jacob Smith
+ *             16 August 2018
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5D__prepare_minimized_oh(H5F_t *file, H5D_t *dset, H5O_loc_t *oloc)
+{
+    H5O_t  *oh        = NULL;
+    size_t  ohdr_size = 0;
+    herr_t  ret_value = SUCCEED;
+
+    FUNC_ENTER_STATIC
+
+    HDassert(file);
+    HDassert(dset);
+    HDassert(oloc);
+
+    oh = H5O__create_ohdr(file, dset->shared->dcpl_id);
+    if(NULL == oh)
+        HGOTO_ERROR(H5E_OHDR, H5E_BADVALUE, FAIL, "can't instantiate object header")
+
+    ohdr_size = H5D__calculate_minimum_header_size(file, dset, oh);
+    if (ohdr_size == 0)
+       HGOTO_ERROR(H5E_OHDR, H5E_BADVALUE, FAIL, "computed header size is invalid")
+
+    /* Special allocation of space for compact datsets is handled by the call here. */
+    if(H5O__apply_ohdr(file, oh, dset->shared->dcpl_id, ohdr_size, (size_t)1, oloc) == FAIL)
+        HGOTO_ERROR(H5E_OHDR, H5E_BADVALUE, FAIL, "can't apply object header to file")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value);
+} /* H5D__prepare_minimized_oh */
+
+
+/*-------------------------------------------------------------------------
  * Function: H5D__update_oh_info
  *
  * Purpose:  Create and fill object header for dataset
@@ -641,6 +850,7 @@ H5D__update_oh_info(H5F_t *file, H5D_t *dset, hid_t dapl_id)
     hbool_t             fill_changed = FALSE;   /* Flag indicating the fill value was changed */
     hbool_t             layout_init = FALSE;    /* Flag to indicate that chunk information was initialized */
     hbool_t             use_at_least_v18;       /* Flag indicating to use at least v18 format versions */
+    hbool_t             use_minimized_header = FALSE; /* Flag to use minimized dataset object headers */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_STATIC
@@ -709,13 +919,24 @@ H5D__update_oh_info(H5F_t *file, H5D_t *dset, hid_t dapl_id)
             HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't set fill value info")
     } /* end if */
 
-    /* Add the dataset's raw data size to the size of the header, if the raw data will be stored as compact */
-    if(layout->type == H5D_COMPACT)
-        ohdr_size += layout->storage.u.compact.size;
+    if(H5D__use_minimized_dset_headers(file, dset, &use_minimized_header) == FAIL)
+        HGOTO_ERROR(H5E_ARGS, H5E_CANTGET, FAIL, "can't get minimize settings")
+
+    if(TRUE == use_minimized_header) {
+        if(H5D__prepare_minimized_oh(file, dset, oloc) == FAIL)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't create minimized dataset object header")
+    } else {
+        /* Add the dataset's raw data size to the size of the header, if the
+         * raw data will be stored as compact
+         */
+        if(H5D_COMPACT == layout->type)
+            ohdr_size += layout->storage.u.compact.size;
+
+        /* Create an object header for the dataset */
+        if(H5O_create(file, ohdr_size, (size_t)1, dset->shared->dcpl_id, oloc/*out*/) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to create dataset object header")
+    } /* if using default/minimized object headers */
 
-    /* Create an object header for the dataset */
-    if(H5O_create(file, ohdr_size, (size_t)1, dset->shared->dcpl_id, oloc/*out*/) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to create dataset object header")
     HDassert(file == dset->oloc.file);
 
     /* Pin the object header */
diff --git a/src/H5Dprivate.h b/src/H5Dprivate.h
index cbee0de..ccbae9d 100644
--- a/src/H5Dprivate.h
+++ b/src/H5Dprivate.h
@@ -45,6 +45,7 @@
 #define H5D_CRT_FILL_VALUE_NAME    "fill_value"          /* Fill value */
 #define H5D_CRT_ALLOC_TIME_STATE_NAME "alloc_time_state" /* Space allocation time state */
 #define H5D_CRT_EXT_FILE_LIST_NAME "efl"                 /* External file list */
+#define H5D_CRT_MIN_DSET_HDR_SIZE_NAME "dset_oh_minimize" /* Minimize dataset object header */
 
 /* ========  Dataset access property names ======== */
 #define H5D_ACS_DATA_CACHE_NUM_SLOTS_NAME   "rdcc_nslots"    /* Size of raw data chunk cache(slots) */
diff --git a/src/H5F.c b/src/H5F.c
index 07290fd..69d3e79 100644
--- a/src/H5F.c
+++ b/src/H5F.c
@@ -1720,3 +1720,87 @@ H5Fincrement_filesize(hid_t file_id, hsize_t increment)
 done:
     FUNC_LEAVE_API(ret_value)
 } /* H5Fincrement_filesize() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5Fget_dset_no_attrs_hint
+ *
+ * Purpose:
+ *
+ *     Get the file-level setting to create minimized dataset object headers.
+ *     Result is stored at pointer `minimize`.
+ *
+ * Return:
+ *
+ *     Success: SUCCEED (0) (non-negative value)
+ *     Failure: FAIL (-1) (negative value)
+ *
+ * Programmer:
+ *
+ *     Jacob Smith
+ *     15 August 2018
+ *
+ * Changes: None.
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Fget_dset_no_attrs_hint(hid_t file_id, hbool_t *minimize)
+{
+    H5F_t  *file      = NULL;    /* File object for file ID */
+    herr_t          ret_value = SUCCEED;
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE2("e", "i*b", file_id, minimize);
+
+    if(NULL == minimize)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "out pointer 'minimize' cannot be NULL")
+
+    file = (H5F_t *)H5I_object_verify(file_id, H5I_FILE);
+    if(NULL == file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "invalid file identifier")
+
+    *minimize = H5F_GET_MIN_DSET_OHDR(file);
+
+done:
+    FUNC_LEAVE_API(ret_value)
+} /* H5Fget_dset_no_attrs_hint */
+
+
+/*-------------------------------------------------------------------------
+ * Function: H5Fset_dset_no_attrs_hint
+ *
+ * Purpose:
+ *
+ *     Set the file-level setting to create minimized dataset object headers.
+ *
+ * Return:
+ *
+ *     Success: SUCCEED (0) (non-negative value)
+ *     Failure: FAIL (-1) (negative value)
+ *
+ * Programmer:
+ *
+ *     Jacob Smith
+ *     15 August 2018
+ *
+ * Changes: None.
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Fset_dset_no_attrs_hint(hid_t file_id, hbool_t minimize)
+{
+    H5F_t  *file      = NULL;    /* File object for file ID */
+    herr_t  ret_value = SUCCEED;
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE2("e", "ib", file_id, minimize);
+
+    file = (H5F_t *)H5I_object_verify(file_id, H5I_FILE);
+    if(NULL == file)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "invalid file identifier")
+
+    H5F_SET_MIN_DSET_OHDR(file, minimize);
+
+done:
+    FUNC_LEAVE_API(ret_value)
+} /* H5Fset_dset_no_attrs_hint */
diff --git a/src/H5Fint.c b/src/H5Fint.c
index 82e2ca6..253ec3c 100644
--- a/src/H5Fint.c
+++ b/src/H5Fint.c
@@ -483,6 +483,30 @@ done:
 } /* end H5F_get_objects_cb() */
 
 
+/*-------------------------------------------------------------------------
+ * Function:    H5F_set_min_dset_ohdr
+ *
+ * Purpose:     Set the crt_dset_ohdr_flag field with a new value.
+ *
+ * Return:      SUCCEED/FAIL
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5F_set_min_dset_ohdr(H5F_t *f, hbool_t minimize)
+{
+    /* Use FUNC_ENTER_NOAPI_NOINIT_NOERR here to avoid performance issues */
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
+
+    /* Sanity check */
+    HDassert(f);
+    HDassert(f->shared);
+
+    f->shared->crt_dset_min_ohdr_flag = minimize;
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* H5F_set_min_dset_ohdr() */
+
+
 /*--------------------------------------------------------------------------
  * Function:    H5F__build_name
  *
diff --git a/src/H5Fpkg.h b/src/H5Fpkg.h
index aa915db..663f84e 100644
--- a/src/H5Fpkg.h
+++ b/src/H5Fpkg.h
@@ -351,6 +351,7 @@ struct H5F_file_t {
 
     /* Object flush info */
     H5F_object_flush_t 	object_flush;	    /* Information for object flush callback */
+    hbool_t crt_dset_min_ohdr_flag; /* flag to create minimized dataset object headers */
 };
 
 /*
diff --git a/src/H5Fprivate.h b/src/H5Fprivate.h
index 370e80b..0c2f5f2 100644
--- a/src/H5Fprivate.h
+++ b/src/H5Fprivate.h
@@ -331,6 +331,8 @@ typedef struct H5F_t H5F_t;
 #define H5F_POINT_OF_NO_RETURN(F) ((F)->shared->fs.point_of_no_return)
 #define H5F_FIRST_ALLOC_DEALLOC(F) ((F)->shared->first_alloc_dealloc)
 #define H5F_EOA_PRE_FSM_FSALLOC(F) ((F)->shared->eoa_pre_fsm_fsalloc)
+#define H5F_GET_MIN_DSET_OHDR(F) ((F)->shared->crt_dset_min_ohdr_flag)
+#define H5F_SET_MIN_DSET_OHDR(F, V) ((F)->shared->crt_dset_min_ohdr_flag = (V))
 #else /* H5F_MODULE */
 #define H5F_LOW_BOUND(F)        (H5F_get_low_bound(F))
 #define H5F_HIGH_BOUND(F)       (H5F_get_high_bound(F))
@@ -388,6 +390,8 @@ typedef struct H5F_t H5F_t;
 #define H5F_POINT_OF_NO_RETURN(F) (H5F_get_point_of_no_return(F))
 #define H5F_FIRST_ALLOC_DEALLOC(F) (H5F_get_first_alloc_dealloc(F))
 #define H5F_EOA_PRE_FSM_FSALLOC(F) (H5F_get_eoa_pre_fsm_fsalloc(F))
+#define H5F_GET_MIN_DSET_OHDR(F) (H5F_get_min_dset_ohdr(F))
+#define H5F_SET_MIN_DSET_OHDR(F, V) (H5F_set_min_dset_ohdr((F), (V)))
 #endif /* H5F_MODULE */
 
 
@@ -741,6 +745,8 @@ H5_DLL hsize_t H5F_get_pgend_meta_thres(const H5F_t *f);
 H5_DLL hbool_t H5F_get_point_of_no_return(const H5F_t *f);
 H5_DLL hbool_t H5F_get_first_alloc_dealloc(const H5F_t *f);
 H5_DLL haddr_t H5F_get_eoa_pre_fsm_fsalloc(const H5F_t *f);
+H5_DLL hbool_t H5F_get_min_dset_ohdr(const H5F_t *f);
+H5_DLL herr_t H5F_set_min_dset_ohdr(H5F_t *f, hbool_t minimize);
 
 /* Functions than retrieve values set/cached from the superblock/FCPL */
 H5_DLL haddr_t H5F_get_base_addr(const H5F_t *f);
diff --git a/src/H5Fpublic.h b/src/H5Fpublic.h
index 73c59f5..6274eb0 100644
--- a/src/H5Fpublic.h
+++ b/src/H5Fpublic.h
@@ -273,6 +273,8 @@ H5_DLL herr_t H5Freset_page_buffering_stats(hid_t file_id);
 H5_DLL herr_t H5Fget_page_buffering_stats(hid_t file_id, unsigned accesses[2],
     unsigned hits[2], unsigned misses[2], unsigned evictions[2], unsigned bypasses[2]);
 H5_DLL herr_t H5Fget_mdc_image_info(hid_t file_id, haddr_t *image_addr, hsize_t *image_size);
+H5_DLL herr_t H5Fget_dset_no_attrs_hint(hid_t file_id, hbool_t *minimize);
+H5_DLL herr_t H5Fset_dset_no_attrs_hint(hid_t file_id, hbool_t minimize);
 
 #ifdef H5_HAVE_PARALLEL
 H5_DLL herr_t H5Fset_mpi_atomicity(hid_t file_id, hbool_t flag);
diff --git a/src/H5Fquery.c b/src/H5Fquery.c
index be24072..e02e402 100644
--- a/src/H5Fquery.c
+++ b/src/H5Fquery.c
@@ -514,6 +514,25 @@ H5F_sym_leaf_k(const H5F_t *f)
 
 
 /*-------------------------------------------------------------------------
+ * Function: H5F_get_min_dset_ohdr
+ *
+ * Purpose:  Get the setting flag for minimized dataset object headers
+ *
+ * Return:   TRUE/FALSE as set in file
+ *-------------------------------------------------------------------------
+ */
+hbool_t
+H5F_get_min_dset_ohdr(const H5F_t *f)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
+
+    HDassert(f);
+
+    FUNC_LEAVE_NOAPI(f->shared->crt_dset_min_ohdr_flag)
+} /* end H5F_get_min_dset_ohdr */
+
+
+/*-------------------------------------------------------------------------
  * Function: H5F_Kvalue
  *
  * Purpose:  Replaced a macro to retrieve a B-tree key value for a certain
diff --git a/src/H5Oint.c b/src/H5Oint.c
index 49d7835..38d73c0 100644
--- a/src/H5Oint.c
+++ b/src/H5Oint.c
@@ -285,52 +285,137 @@ H5O_create(H5F_t *f, size_t size_hint, size_t initial_rc, hid_t ocpl_id,
 {
     H5P_genplist_t  *oc_plist;          /* Object creation property list */
     H5O_t      *oh = NULL;              /* Object header created */
+    herr_t      ret_value = SUCCEED;    /* return value */
     haddr_t     oh_addr;                /* Address of initial object header */
     size_t      oh_size;                /* Size of initial object header */
-    uint8_t	oh_flags;		/* Object header's initial status flags */
-    unsigned    insert_flags = H5AC__NO_FLAGS_SET; /* Flags for inserting object header into cache */
-    hbool_t     store_msg_crt_idx;      /* Whether to always store message creation indices for this file */
-    herr_t      ret_value = SUCCEED;    /* return value */
+    uint8_t    oh_flags;               /* Object header's initial status flags */
+    unsigned    insert_flags = H5AC__NO_FLAGS_SET; /* Flags for inserting objec t header into cache */
+    hbool_t     store_msg_crt_idx;      /* Whether to always store message crea tion indices for this file */
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    /* check args */
     HDassert(f);
     HDassert(loc);
     HDassert(TRUE == H5P_isa_class(ocpl_id, H5P_OBJECT_CREATE));
 
+    /* create object header in freelist
+     * header version is set internally
+     */
+    oh = H5O__create_ohdr(f, ocpl_id);
+    if(NULL == oh)
+        HGOTO_ERROR(H5E_OHDR, H5E_BADVALUE, FAIL, "Can't instantiate object header")
+
+    /* apply object header information to file
+     */
+    if(H5O__apply_ohdr(f, oh, ocpl_id, size_hint, initial_rc, loc) < 0)
+        HGOTO_ERROR(H5E_OHDR, H5E_BADVALUE, FAIL, "Can't apply object header to file")
+
+done:
+    if((FAIL == ret_value) && (NULL != oh) && (H5O__free(oh) < 0))
+        HDONE_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "can't delete object header")
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5O_create() */
+
+
+/*-----------------------------------------------------------------------------
+ * Function:   H5O__create_ohdr
+ *
+ * Purpose:    Create the object header, set version and flags.
+ *
+ * Return:     Success: Pointer to the newly-crated header object.
+ *             Failure: NULL
+ *
+ * Programmer: Jacob Smith
+ *             2018 August 17
+ *
+ *-----------------------------------------------------------------------------
+ */
+H5O_t *
+H5O__create_ohdr(H5F_t *f, hid_t ocpl_id)
+{
+    H5P_genplist_t *oc_plist;
+    H5O_t          *oh = NULL;        /* Object header in Freelist */
+    uint8_t         oh_flags;         /* Initial status flags */
+    H5O_t          *ret_value = NULL;
+
+    FUNC_ENTER_NOAPI(NULL)
+
+    HDassert(f);
+    HDassert(TRUE == H5P_isa_class(ocpl_id, H5P_OBJECT_CREATE));
+
     /* Check for invalid access request */
     if(0 == (H5F_INTENT(f) & H5F_ACC_RDWR))
-        HGOTO_ERROR(H5E_OHDR, H5E_BADVALUE, FAIL, "no write intent on file")
+        HGOTO_ERROR(H5E_OHDR, H5E_BADVALUE, NULL, "no write intent on file")
 
     /* Make certain we allocate at least a reasonable size for the object header */
-    size_hint = H5O_ALIGN_F(f, MAX(H5O_MIN_SIZE, size_hint));
+    oh = H5FL_CALLOC(H5O_t);
+    if(NULL == oh)
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
 
-    /* Get the property list */
-    if(NULL == (oc_plist = (H5P_genplist_t *)H5I_object(ocpl_id)))
-        HGOTO_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a property list")
+    oc_plist = (H5P_genplist_t *)H5I_object(ocpl_id);
+    if(NULL == oc_plist)
+        HGOTO_ERROR(H5E_PLIST, H5E_BADTYPE, NULL, "not a property list")
 
     /* Get any object header status flags set by properties */
     if(H5P_get(oc_plist, H5O_CRT_OHDR_FLAGS_NAME, &oh_flags) < 0)
-        HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get object header flags")
+        HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "can't get object header flags")
 
-    /* Allocate the object header and zero out header fields */
-    if(NULL == (oh = H5FL_CALLOC(H5O_t)))
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
+    if(H5O_set_version(f, oh, oh_flags, H5F_STORE_MSG_CRT_IDX(f)) < 0)
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTSET, NULL, "can't set version of object header")
+
+    oh->flags = oh_flags;
+
+    ret_value = oh;
+
+done:
+    if((NULL == ret_value) && (NULL != oh) && (H5O__free(oh) < 0))
+        HDONE_ERROR(H5E_OHDR, H5E_CANTFREE, NULL, "can't delete object header")
 
-    /* Initialize file-specific information for object header */
-    store_msg_crt_idx = H5F_STORE_MSG_CRT_IDX(f);
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5O__create_ohdr() */
+
+
+/*-----------------------------------------------------------------------------
+ * Function:   H5O__apply_ohdr
+ *
+ * Purpose:    Initialize and set the object header in the file.
+ *             Record some information at `loc_out`.
+ *
+ * Return:     Success: SUCCEED (0) (non-negative value)
+ *             Failure: FAIL (-1) (negative value)
+ *
+ * Programmer: Jacob Smith
+ *             2018 August 17
+ *
+ *-----------------------------------------------------------------------------
+ */
+herr_t
+H5O__apply_ohdr(H5F_t *f, H5O_t *oh, hid_t ocpl_id, size_t size_hint, size_t initial_rc, H5O_loc_t *loc_out)
+{
+    haddr_t         oh_addr;
+    size_t          oh_size;
+    H5P_genplist_t *oc_plist     = NULL;
+    unsigned        insert_flags = H5AC__NO_FLAGS_SET;
+    herr_t          ret_value    = SUCCEED;
 
-    if(H5O_set_version(f, oh, oh_flags, store_msg_crt_idx) < 0)
-        HGOTO_ERROR(H5E_OHDR, H5E_CANTSET, FAIL, "can't set version of objecdt header")
+    FUNC_ENTER_NOAPI(FAIL)
+
+    HDassert(f);
+    HDassert(loc_out);
+    HDassert(oh);
+    HDassert(TRUE == H5P_isa_class(ocpl_id, H5P_OBJECT_CREATE));
+
+    /* Allocate at least a reasonable size for the object header */
+    size_hint = H5O_ALIGN_F(f, MAX(H5O_MIN_SIZE, size_hint));
 
     oh->sizeof_size = H5F_SIZEOF_SIZE(f);
     oh->sizeof_addr = H5F_SIZEOF_ADDR(f);
-    oh->swmr_write = !!(H5F_INTENT(f) & H5F_ACC_SWMR_WRITE);
+    oh->swmr_write = !!(H5F_INTENT(f) & H5F_ACC_SWMR_WRITE); /* strange casting for proper type */
 #ifdef H5O_ENABLE_BAD_MESG_COUNT
     /* Check whether the "bad message count" property is set */
     if(H5P_exist_plist(oc_plist, H5O_BAD_MESG_COUNT_NAME) > 0) {
-        /* Retrieve bad message count flag */
+        /* Get bad message count flag from property list */
         if(H5P_get(oc_plist, H5O_BAD_MESG_COUNT_NAME, &oh->store_bad_mesg_count) < 0)
             HGOTO_ERROR(H5E_OHDR, H5E_CANTGET, FAIL, "can't get bad message count flag")
     }
@@ -341,12 +426,14 @@ H5O_create(H5F_t *f, size_t size_hint, size_t initial_rc, hid_t ocpl_id,
         /* Create virtual entry, for use as proxy */
         if(NULL == (oh->proxy = H5AC_proxy_entry_create()))
             HGOTO_ERROR(H5E_OHDR, H5E_CANTCREATE, FAIL, "can't create object header proxy")
-    }
-    else
+    } else {
         oh->proxy = NULL;
+    }
 
     /* Set initial status flags */
-    oh->flags = oh_flags;
+    oc_plist = (H5P_genplist_t *)H5I_object(ocpl_id);
+    if(NULL == oc_plist)
+        HGOTO_ERROR(H5E_PLIST, H5E_BADTYPE, FAIL, "not a property list")
 
     /* Initialize version-specific fields */
     if(oh->version > H5O_VERSION_1) {
@@ -356,10 +443,7 @@ H5O_create(H5F_t *f, size_t size_hint, size_t initial_rc, hid_t ocpl_id,
         else
             oh->atime = oh->mtime = oh->ctime = oh->btime = 0;
 
-        /* Make certain attribute creation order tracking is enabled if
-         *      attributes can be shared in this file.
-         */
-        if(store_msg_crt_idx)
+        if(H5F_STORE_MSG_CRT_IDX(f)) /* flag to record message creation indices */
             oh->flags |= H5O_HDR_ATTR_CRT_ORDER_TRACKED;
 
         /* Retrieve attribute storage phase change values from property list */
@@ -383,11 +467,10 @@ H5O_create(H5F_t *f, size_t size_hint, size_t initial_rc, hid_t ocpl_id,
             oh->flags |= H5O_HDR_CHUNK0_4;
         else if(size_hint > 255)
             oh->flags |= H5O_HDR_CHUNK0_2;
-    } /* end if */
-    else {
+    } else {
         /* Reset unused time fields */
         oh->atime = oh->mtime = oh->ctime = oh->btime = 0;
-    } /* end else */
+    } /* end if/else header version > 1 */
 
     /* Compute total size of initial object header */
     /* (i.e. object header prefix and first chunk) */
@@ -452,20 +535,16 @@ H5O_create(H5F_t *f, size_t size_hint, size_t initial_rc, hid_t ocpl_id,
     H5_END_TAG
 
     /* Set up object location */
-    loc->file = f;
-    loc->addr = oh_addr;
+    loc_out->file = f;
+    loc_out->addr = oh_addr;
 
     /* Open it */
-    if(H5O_open(loc) < 0)
+    if(H5O_open(loc_out) < 0)
         HGOTO_ERROR(H5E_OHDR, H5E_CANTOPENOBJ, FAIL, "unable to open object header")
 
 done:
-    if(ret_value < 0 && oh)
-        if(H5O__free(oh) < 0)
-            HDONE_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to destroy object header data")
-
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5O_create() */
+} /* end H5O__apply_ohdr() */
 
 
 /*-------------------------------------------------------------------------
@@ -2420,6 +2499,63 @@ H5O_get_oh_addr(const H5O_t *oh)
 
 
 /*-------------------------------------------------------------------------
+ * Function:   H5O_get_oh_flags
+ *
+ * Programmer: Jacob Smith
+ *             2018 August 17
+ *
+ *-------------------------------------------------------------------------
+ */
+uint8_t
+H5O_get_oh_flags(const H5O_t *oh)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    HDassert(oh);
+    FUNC_LEAVE_NOAPI(oh->flags); /* flags can be 0 */
+} /* H5O_get_oh_flags() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:   H5O_get_oh_mtime
+ *
+ * Purpose:    Retrieve an object's modification time. Assumes that the
+ *              caller has verified that accessing this variable is appropriate
+ *              to the header in question.
+ *
+ * Programmer: Jacob Smith
+ *             2018 August 17
+ *
+ *-------------------------------------------------------------------------
+ */
+time_t
+H5O_get_oh_mtime(const H5O_t *oh)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    HDassert(oh);
+    HDassert(oh->mtime);
+    FUNC_LEAVE_NOAPI(oh->mtime);
+} /* H5O_get_oh_mtime() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:   H5O_get_oh_version
+ *
+ * Programmer: Jacob Smith
+ *             2018 August 17
+ *
+ *-------------------------------------------------------------------------
+ */
+uint8_t
+H5O_get_oh_version(const H5O_t *oh)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    HDassert(oh);
+    HDassert(oh->version);
+    FUNC_LEAVE_NOAPI(oh->version);
+} /* H5O_get_oh_version() */
+
+
+/*-------------------------------------------------------------------------
  * Function:	H5O_get_rc_and_type
  *
  * Purpose:	Retrieve an object's reference count and type
diff --git a/src/H5Oprivate.h b/src/H5Oprivate.h
index 10063d5..7868123 100644
--- a/src/H5Oprivate.h
+++ b/src/H5Oprivate.h
@@ -120,8 +120,14 @@ typedef struct H5O_mesg_t H5O_mesg_t;
 /* If the module using this macro is allowed access to the private variables, access them directly */
 #ifdef H5O_MODULE
 #define H5O_OH_GET_ADDR(O)    ((O)->chunk[0].addr)
+#define H5O_OH_GET_VERSION ((O)->version)
+#define H5O_OH_GET_FLAGS(O)   ((O)->flags)
+#define H5O_OH_GET_MTIME(O)   ((O)->mtime)
 #else /* H5O_MODULE */
 #define H5O_OH_GET_ADDR(O)    (H5O_get_oh_addr(O))
+#define H5O_OH_GET_VERSION(O) (H5O_get_oh_version(O))
+#define H5O_OH_GET_FLAGS(O)   (H5O_get_oh_flags(O))
+#define H5O_OH_GET_MTIME(O)   (H5O_get_oh_mtime(O))
 #endif /* H5O_MODULE */
 
 /* Set the fields in a shared message structure */
@@ -865,6 +871,9 @@ struct H5P_genplist_t;
 H5_DLL herr_t H5O_init(void);
 H5_DLL herr_t H5O_create(H5F_t *f, size_t size_hint, size_t initial_rc,
     hid_t ocpl_id, H5O_loc_t *loc/*out*/);
+H5_DLL H5O_t *H5O__create_ohdr(H5F_t *f, hid_t ocpl_id);
+H5_DLL herr_t H5O__apply_ohdr(H5F_t *f, H5O_t *oh, hid_t ocpl_id,
+    size_t size_hint, size_t initial_rc, H5O_loc_t *loc_out);
 H5_DLL herr_t H5O_open(H5O_loc_t *loc);
 H5_DLL herr_t H5O_close(H5O_loc_t *loc, hbool_t *file_closed/*out*/);
 H5_DLL int H5O_link(const H5O_loc_t *loc, int adjust);
@@ -888,6 +897,9 @@ H5_DLL hid_t H5O_open_name(const H5G_loc_t *loc, const char *name, hbool_t app_r
 H5_DLL herr_t H5O_get_nlinks(const H5O_loc_t *loc, hsize_t *nlinks);
 H5_DLL void *H5O_obj_create(H5F_t *f, H5O_type_t obj_type, void *crt_info, H5G_loc_t *obj_loc);
 H5_DLL haddr_t H5O_get_oh_addr(const H5O_t *oh);
+H5_DLL uint8_t H5O_get_oh_flags(const H5O_t *oh);
+H5_DLL time_t H5O_get_oh_mtime(const H5O_t *oh);
+H5_DLL uint8_t H5O_get_oh_version(const H5O_t *oh);
 H5_DLL herr_t H5O_get_rc_and_type(const H5O_loc_t *oloc, unsigned *rc, H5O_type_t *otype);
 H5_DLL H5AC_proxy_entry_t *H5O_get_proxy(const H5O_t *oh);
 
diff --git a/src/H5Pdcpl.c b/src/H5Pdcpl.c
index d995b1e..6211b5b 100644
--- a/src/H5Pdcpl.c
+++ b/src/H5Pdcpl.c
@@ -119,6 +119,11 @@
 #define H5D_CRT_EXT_FILE_LIST_COPY H5P__dcrt_ext_file_list_copy
 #define H5D_CRT_EXT_FILE_LIST_CMP  H5P__dcrt_ext_file_list_cmp
 #define H5D_CRT_EXT_FILE_LIST_CLOSE H5P__dcrt_ext_file_list_close
+/* Definitions for dataset object header minimization */
+#define H5D_CRT_MIN_DSET_HDR_SIZE_SIZE sizeof(hbool_t)
+#define H5D_CRT_MIN_DSET_HDR_SIZE_DEF  FALSE
+#define H5D_CRT_MIN_DSET_HDR_SIZE_ENC  H5P__encode_hbool_t
+#define H5D_CRT_MIN_DSET_HDR_SIZE_DEC  H5P__decode_hbool_t
 
 
 /******************/
@@ -211,6 +216,7 @@ static const H5O_layout_t H5D_def_layout_g = H5D_CRT_LAYOUT_DEF;        /* Defau
 static const H5O_fill_t H5D_def_fill_g = H5D_CRT_FILL_VALUE_DEF;        /* Default fill value */
 static const unsigned H5D_def_alloc_time_state_g = H5D_CRT_ALLOC_TIME_STATE_DEF;  /* Default allocation time state */
 static const H5O_efl_t H5D_def_efl_g = H5D_CRT_EXT_FILE_LIST_DEF;                 /* Default external file list */
+static const unsigned H5O_ohdr_min_g = H5D_CRT_MIN_DSET_HDR_SIZE_DEF; /* Default object header minimization */
 
 /* Defaults for each type of layout */
 #ifdef H5_HAVE_C99_DESIGNATED_INITIALIZER
@@ -270,6 +276,12 @@ H5P__dcrt_reg_prop(H5P_genclass_t *pclass)
             H5D_CRT_EXT_FILE_LIST_DEL, H5D_CRT_EXT_FILE_LIST_COPY, H5D_CRT_EXT_FILE_LIST_CMP, H5D_CRT_EXT_FILE_LIST_CLOSE) < 0)
        HGOTO_ERROR(H5E_PLIST, H5E_CANTINSERT, FAIL, "can't insert property into class")
 
+    /* Register the object header minimization property */
+    if(H5P_register_real(pclass, H5D_CRT_MIN_DSET_HDR_SIZE_NAME, H5D_CRT_MIN_DSET_HDR_SIZE_SIZE, &H5O_ohdr_min_g,
+            NULL, NULL, NULL, H5D_CRT_MIN_DSET_HDR_SIZE_ENC, H5D_CRT_MIN_DSET_HDR_SIZE_DEC,
+            NULL, NULL, NULL, NULL) < 0)
+       HGOTO_ERROR(H5E_PLIST, H5E_CANTINSERT, FAIL, "can't insert property into class")
+
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5P__dcrt_reg_prop() */
@@ -3754,3 +3766,95 @@ done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Pget_fill_time() */
 
+
+/*-----------------------------------------------------------------------------
+ * Function: H5Pget_dset_no_attrs_hint
+ *
+ * Purpose:
+ *
+ *     Access the flag for whether or not datasets created by the given dcpl
+ *     will be created with a "minimized" object header.
+ *
+ * Return:
+ *
+ *     Failure: Negative value (FAIL)
+ *     Success: Non-negative value (SUCCEED)
+ *
+ * Programmer: Jacob Smith
+ *             2018 August 14
+ *
+ * Modifications: None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+herr_t
+H5Pget_dset_no_attrs_hint(hid_t dcpl_id, hbool_t *minimize)
+{
+    hbool_t         setting   = FALSE;
+    H5P_genplist_t *plist     = NULL;
+    herr_t          ret_value = SUCCEED;
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE2("e", "i*b", dcpl_id, minimize);
+
+    if(NULL == minimize)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "receiving pointer cannot be NULL")
+
+    plist = H5P_object_verify(dcpl_id, H5P_DATASET_CREATE);
+    if(NULL == plist)
+        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "can't find object for ID")
+
+    if(H5P_peek(plist, H5D_CRT_MIN_DSET_HDR_SIZE_NAME, &setting) < 0)
+        HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get dset oh minimize flag value")
+
+    *minimize = setting;
+
+done:
+    FUNC_LEAVE_API(ret_value)
+} /* H5Pget_dset_no_attrs_hint() */
+
+
+/*-----------------------------------------------------------------------------
+ * Function: H5Pset_dset_no_attrs_hint
+ *
+ * Purpose:
+ *
+ *     Set the dcpl to minimize (or explicitly to not minimized) dataset object
+ *     headers upon creation.
+ *
+ * Return:
+ *
+ *     Failure: Negative value (FAIL)
+ *     Success: Non-negative value (SUCCEED)
+ *
+ * Programmer: Jacob Smith
+ *             2018 August 14
+ *
+ * Modifications: None.
+ *
+ *-----------------------------------------------------------------------------
+ */
+herr_t
+H5Pset_dset_no_attrs_hint(hid_t dcpl_id, hbool_t minimize)
+{
+    H5P_genplist_t *plist     = NULL;
+    hbool_t         prev_set  = FALSE;
+    herr_t          ret_value = SUCCEED;
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE2("e", "ib", dcpl_id, minimize);
+
+    plist = H5P_object_verify(dcpl_id, H5P_DATASET_CREATE);
+    if(NULL == plist)
+        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "can't find object for ID")
+
+    if(H5P_peek(plist, H5D_CRT_MIN_DSET_HDR_SIZE_NAME, &prev_set) < 0)
+        HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get extant dset oh minimize flag value")
+
+    if(H5P_poke(plist, H5D_CRT_MIN_DSET_HDR_SIZE_NAME, &minimize) < 0)
+        HGOTO_ERROR(H5E_PLIST, H5E_CANTSET, FAIL, "can't get dset oh minimize flag value")
+
+done:
+    FUNC_LEAVE_API(ret_value)
+} /* H5Pset_dset_no_attrs_hint() */
+
diff --git a/src/H5Ppublic.h b/src/H5Ppublic.h
index 9f7fdab..b566085 100644
--- a/src/H5Ppublic.h
+++ b/src/H5Ppublic.h
@@ -407,6 +407,8 @@ H5_DLL herr_t H5Pget_alloc_time(hid_t plist_id, H5D_alloc_time_t
 H5_DLL herr_t H5Pset_fill_time(hid_t plist_id, H5D_fill_time_t fill_time);
 H5_DLL herr_t H5Pget_fill_time(hid_t plist_id, H5D_fill_time_t
     *fill_time/*out*/);
+H5_DLL herr_t H5Pget_dset_no_attrs_hint(hid_t dcpl_id, hbool_t *minimize);
+H5_DLL herr_t H5Pset_dset_no_attrs_hint(hid_t dcpl_id, hbool_t minimize);
 
 /* Dataset access property list (DAPL) routines */
 H5_DLL herr_t H5Pset_chunk_cache(hid_t dapl_id, size_t rdcc_nslots,
diff --git a/test/CMakeTests.cmake b/test/CMakeTests.cmake
index 616999f..ba64964 100644
--- a/test/CMakeTests.cmake
+++ b/test/CMakeTests.cmake
@@ -359,6 +359,9 @@ set (test_CLEANFILES
     lheap.h5
     fheap.h5
     ohdr.h5
+    ohdr_min_a.h5
+    ohdr_min_b.h5
+    min_dset_ohdr_testfile.h5
     stab.h5
     extern_*.h5
     extern_*.raw
diff --git a/test/Makefile.am b/test/Makefile.am
index 5b210a9..6a057c1 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -165,6 +165,7 @@ CHECK_CLEANFILES+=accum.h5 cmpd_dset.h5 compact_dataset.h5 dataset.h5 dset_offse
     extend.h5 istore.h5 extlinks*.h5 frspace.h5 links*.h5 \
     sys_file1 tfile[1-7].h5 th5s[1-4].h5 lheap.h5 fheap.h5 ohdr.h5 \
     stab.h5 extern_[1-5].h5 extern_[1-4][rw].raw gheap[0-4].h5 \
+    ohdr_min_a.h5 ohdr_min_b.h5 min_dset_ohdr_testfile.h5 \
     dt_arith[1-2] links.h5 links[0-6]*.h5 extlinks[0-15].h5 tmp \
     big.data big[0-9][0-9][0-9][0-9][0-9].h5  \
     stdio.h5 sec2.h5 dtypes[0-9].h5 dtypes1[0].h5 dt_arith[1-2].h5 tattr.h5 \
diff --git a/test/dsets.c b/test/dsets.c
index 5bcf551..2634632 100644
--- a/test/dsets.c
+++ b/test/dsets.c
@@ -87,6 +87,8 @@ const char *FILENAME[] = {
     NULL
 };
 
+#define OHMIN_FILENAME_A "ohdr_min_a"
+
 #define FILENAME_BUF_SIZE       1024
 #define KB                      1024
 
@@ -346,7 +348,7 @@ filter_count(unsigned int flags, size_t H5_ATTR_UNUSED cd_nelmts,
         count_nbytes_written += nbytes;
 
     return nbytes;
-}
+} /* end filter_count() */
 
 
 /*-------------------------------------------------------------------------
@@ -493,7 +495,7 @@ test_create(hid_t file)
 
  error:
     return -1;
-}
+} /* end test_create() */
 
 
 /*-------------------------------------------------------------------------
@@ -629,7 +631,7 @@ error:
     if(tconv_buf)
         HDfree(tconv_buf);
     return -1;
-}
+} /* end test_simple_io() */
 
 
 /*-------------------------------------------------------------------------
@@ -735,7 +737,7 @@ error:
     if(f > 0)
         HDclose(f);
     return -1;
-}
+} /* end test_userblock_offset() */
 
 
 /*-------------------------------------------------------------------------
@@ -928,7 +930,7 @@ test_compact_io(hid_t fapl)
     } H5E_END_TRY;
 
     return -1;
-}
+} /* end test_compact_io() */
 
 
 /*-------------------------------------------------------------------------
@@ -1343,7 +1345,7 @@ test_conv_buffer(hid_t fid)
 
 error:
   return -1;
-}
+} /* end test_conv_buffer() */
 
 
 /*-------------------------------------------------------------------------
@@ -1427,7 +1429,7 @@ error:
     } H5E_END_TRY;
 
     return -1;
-}
+} /* end test_tconv() */
 
 /* This message derives from H5Z */
 const H5Z_class2_t H5Z_BOGUS[1] = {{
@@ -1460,7 +1462,7 @@ can_apply_bogus(hid_t H5_ATTR_UNUSED dcpl_id, hid_t type_id, hid_t H5_ATTR_UNUSE
         return 1;
     else
         return -1;
-}
+} /* end can_apply_bogus() */
 
 
 /*-------------------------------------------------------------------------
@@ -1478,7 +1480,7 @@ filter_bogus(unsigned int H5_ATTR_UNUSED flags, size_t H5_ATTR_UNUSED cd_nelmts,
       size_t H5_ATTR_UNUSED *buf_size, void H5_ATTR_UNUSED **buf)
 {
     return nbytes;
-}
+} /* end filter_bogus() */
 
 
 /*-------------------------------------------------------------------------
@@ -1578,7 +1580,7 @@ filter_bogus2(unsigned int flags, size_t cd_nelmts,
     /* Filter is "no op" */
     else
         return(nbytes);
-}
+} /* end filter_bogus2() */
 
 
 /*-------------------------------------------------------------------------
@@ -1596,7 +1598,7 @@ filter_bogus3(unsigned int H5_ATTR_UNUSED flags, size_t H5_ATTR_UNUSED cd_nelmts
       size_t H5_ATTR_UNUSED *buf_size, void H5_ATTR_UNUSED **buf)
 {
     return 0;
-}
+} /* end filter_bogus3() */
 
 /* This message derives from H5Z */
 const H5Z_class2_t H5Z_CORRUPT[1] = {{
@@ -1685,7 +1687,7 @@ filter_cb_cont(H5Z_filter_t filter, void H5_ATTR_UNUSED *buf, size_t H5_ATTR_UNU
        return H5Z_CB_CONT;
     else
         return H5Z_CB_FAIL;
-}
+} /* end filter_cb_cont() */
 
 
 /*-------------------------------------------------------------------------
@@ -1704,7 +1706,7 @@ filter_cb_fail(H5Z_filter_t filter, void H5_ATTR_UNUSED *buf, size_t H5_ATTR_UNU
        return H5Z_CB_FAIL;
     else
        return H5Z_CB_CONT;
-}
+} /* end filter_cb_fail() */
 
 
 /*-------------------------------------------------------------------------
@@ -2053,7 +2055,7 @@ error:
     if(tconv_buf)
         HDfree (tconv_buf);
     return -1;
-}
+} /* end test_filter_internal() */
 
 /*-------------------------------------------------------------------------
  * Function:  test_filter_noencoder
@@ -2171,7 +2173,7 @@ error:
         H5Fclose(file_id);
 
     return -1;
-}
+} /* end test_filter_noencoder() */
 #endif /* H5_HAVE_FILTER_SZIP */
 
 /*-------------------------------------------------------------------------
@@ -2241,7 +2243,7 @@ test_get_filter_info(void)
 
 error:
   return -1;
-}
+} /* end test_get_filter_info() */
 
 /*-------------------------------------------------------------------------
  * Function:  test_filters
@@ -2516,7 +2518,7 @@ H5_ATTR_UNUSED
 
 error:
     return -1;
-}
+} /* end test_filters() */
 
 
 /*-------------------------------------------------------------------------
@@ -2856,7 +2858,7 @@ test_onebyte_shuffle(hid_t file)
 
 error:
     return -1;
-}
+} /* end test_onebyte_shuffle() */
 
 
 /*-------------------------------------------------------------------------
@@ -2974,7 +2976,7 @@ test_nbit_int(hid_t file)
 
 error:
     return -1;
-}
+} /* end test_nbit_int() */
 
 
 /*-------------------------------------------------------------------------
@@ -3092,7 +3094,7 @@ test_nbit_float(hid_t file)
 
 error:
     return -1;
-}
+} /* end test_nbit_float() */
 
 
 /*-------------------------------------------------------------------------
@@ -3224,7 +3226,7 @@ test_nbit_double(hid_t file)
 
 error:
     return -1;
-}
+} /* end test_nbit_double() */
 
 
 /*-------------------------------------------------------------------------
@@ -3351,7 +3353,7 @@ test_nbit_array(hid_t file)
 
 error:
     return -1;
-}
+} /* end test_nbit_array() */
 
 
 /*-------------------------------------------------------------------------
@@ -3568,7 +3570,7 @@ test_nbit_compound(hid_t file)
 
 error:
     return -1;
-}
+} /* end test_nbit_compound() */
 
 
 /*-------------------------------------------------------------------------
@@ -3913,7 +3915,7 @@ out:
 
 error:
     return -1;
-}
+} /* end test_nbit_compound_2() */
 
 
 /*-------------------------------------------------------------------------
@@ -4093,7 +4095,7 @@ test_nbit_compound_3(hid_t file)
 
 error:
     return -1;
-}
+} /* end test_nbit_compound_3() */
 
 
 /*-------------------------------------------------------------------------
@@ -4260,7 +4262,7 @@ test_nbit_int_size(hid_t file)
    return 0;
 error:
     return -1;
-}
+} /* end test_nbit_int_size() */
 
 
 /*-------------------------------------------------------------------------
@@ -4457,7 +4459,7 @@ test_nbit_flt_size(hid_t file)
    return 0;
 error:
     return -1;
-}
+} /* end test_nbit_flt_size() */
 
 /*-------------------------------------------------------------------------
  * Function:    test_scaleoffset_int
@@ -4568,7 +4570,7 @@ test_scaleoffset_int(hid_t file)
     return 0;
 error:
     return -1;
-}
+} /* end test_scaleoffset_int() */
 
 
 /*-------------------------------------------------------------------------
@@ -4696,7 +4698,7 @@ test_scaleoffset_int_2(hid_t file)
     return 0;
 error:
     return -1;
-}
+} /* end test_scaleoffset_int_2() */
 
 
 /*-------------------------------------------------------------------------
@@ -4809,7 +4811,7 @@ test_scaleoffset_float(hid_t file)
     return 0;
 error:
     return -1;
-}
+} /* end test_scaleoffset_float() */
 
 
 /*-------------------------------------------------------------------------
@@ -4938,7 +4940,7 @@ test_scaleoffset_float_2(hid_t file)
     return 0;
 error:
     return -1;
-}
+} /* end test_scaleoffset_float_2() */
 
 
 /*-------------------------------------------------------------------------
@@ -5051,7 +5053,7 @@ test_scaleoffset_double(hid_t file)
     return 0;
 error:
     return -1;
-}
+} /* end test_scaleoffset_double() */
 
 
 /*-------------------------------------------------------------------------
@@ -5181,7 +5183,7 @@ test_scaleoffset_double_2(hid_t file)
     return 0;
 error:
     return -1;
-}
+} /* end test_scaleoffset_double_2() */
 
 
 /*-------------------------------------------------------------------------
@@ -5248,7 +5250,7 @@ test_multiopen (hid_t file)
     H5Pclose(dcpl);
     } H5E_END_TRY;
     return -1;
-}
+} /* end test_multiopen () */
 
 
 /*-------------------------------------------------------------------------
@@ -5344,7 +5346,7 @@ test_types(hid_t file)
     H5Dclose(dset);
     } H5E_END_TRY;
     return -1;
-}
+} /* end test_types() */
 
 /* This message derives from H5Z */
 const H5Z_class2_t H5Z_CAN_APPLY_TEST[1] = {{
@@ -6583,7 +6585,7 @@ error:
             HDfree(buf);
     } H5E_END_TRY;
     return -1;
-}
+} /* end auxread_fdata() */
 
 
 /*-------------------------------------------------------------------------
@@ -10034,7 +10036,7 @@ error:
     H5Fclose(fid);
     } H5E_END_TRY;
     return -1;
-} /* test_idx_compatible */
+} /* end test_idx_compatible() */
 
 /*-------------------------------------------------------------------------
  *
@@ -10174,7 +10176,7 @@ error:
         H5Fclose(fid);
     } H5E_END_TRY;
     return -1;
-} /* test_unfiltered_edge_chunks */
+} /* end test_unfiltered_edge_chunks() */
 
 
 /*-------------------------------------------------------------------------
@@ -10871,7 +10873,7 @@ error:
         H5Sclose(msid);
     } H5E_END_TRY;
     return -1;
-} /* test_farray_hdr_fd() */
+} /* end test_farray_hdr_fd() */
 
 
 /*-------------------------------------------------------------------------
@@ -10991,7 +10993,7 @@ error:
         H5Sclose(msid);
     } H5E_END_TRY;
     return -1;
-} /* test_bt2_hdr_fd() */
+} /* end test_bt2_hdr_fd() */
 
 
 /*-------------------------------------------------------------------------
@@ -12189,7 +12191,7 @@ scatter_error_cb_fail(void **src_buf/*out*/, size_t *src_buf_bytes_used/*out*/,
     *src_buf_bytes_used = nelmts * sizeof(scatter_info->src_buf[0]);
 
     return FAIL;
-}
+} /* end scatter_error_cb_fail() */
 
 static herr_t
 scatter_error_cb_null(void **src_buf/*out*/, size_t *src_buf_bytes_used/*out*/,
@@ -12207,7 +12209,7 @@ scatter_error_cb_null(void **src_buf/*out*/, size_t *src_buf_bytes_used/*out*/,
     *src_buf_bytes_used = nelmts * sizeof(scatter_info->src_buf[0]);
 
     return SUCCEED;
-}
+} /* end scatter_error_cb_null() */
 
 static herr_t
 scatter_error_cb_unalign(void **src_buf/*out*/, size_t *src_buf_bytes_used/*out*/,
@@ -12218,7 +12220,7 @@ scatter_error_cb_unalign(void **src_buf/*out*/, size_t *src_buf_bytes_used/*out*
     *src_buf_bytes_used = *(size_t *)_src_buf_bytes_used;
 
     return SUCCEED;
-}
+} /* end scatter_error_cb_unalign() */
 
 static herr_t
 test_scatter_error(void)
@@ -12381,7 +12383,7 @@ gather_error_cb_fail(const void H5_ATTR_UNUSED *dst_buf,
     size_t H5_ATTR_UNUSED dst_buf_bytes_used, void H5_ATTR_UNUSED *op_data)
 {
     return FAIL;
-}
+} /* end gather_error_cb_fail() */
 
 static herr_t
 test_gather_error(void)
@@ -12594,7 +12596,8 @@ static herr_t dls_01_read_stuff( hid_t fid );
 static herr_t dls_01_main( void );
 
 static herr_t
-dls_01_setup_file( hid_t fid ) {
+dls_01_setup_file( hid_t fid )
+{
 
     int status = 0;
     hid_t sid = 0, did = 0, tid = 0, dcpl = 0;
@@ -12639,10 +12642,11 @@ error:
 
     return -1;
 
-} /* dls_01_setup_file */
+} /* end dls_01_setup_file() */
 
 static herr_t
-dls_01_write_data( hid_t fid, char* buffer ) {
+dls_01_write_data( hid_t fid, char* buffer )
+{
 
     int status = 0;
     hid_t did = 0, tid = 0;
@@ -12675,10 +12679,11 @@ error:
 
     return -1;
 
-} /* dls_01_write_data */
+} /* end dls_01_write_data() */
 
 static herr_t
-dls_01_read_stuff( hid_t fid ) {
+dls_01_read_stuff( hid_t fid )
+{
 
     int status = 0;
     hid_t did = 0;
@@ -12699,10 +12704,11 @@ error:
 
     return -1;
 
-} /* dls_01_read_stuff() */
+} /* end dls_01_read_stuff() */
 
 static herr_t
-dls_01_main( void ) {
+dls_01_main( void )
+{
 
     char filename[512];
     int status = 0;
@@ -12768,7 +12774,7 @@ error:
 
     return -1;
 
-} /* dls_01_main() */
+} /* end dls_01_main() */
 
 /*-------------------------------------------------------------------------
  * Function:    test_compact_open_close_dirty
@@ -12886,7 +12892,7 @@ error:
         H5Fclose(fid);
     } H5E_END_TRY;
     return -1;
-} /* test_compact_open_close_dirty() */
+} /* end test_compact_open_close_dirty() */
 
 
 /*-------------------------------------------------------------------------
@@ -13034,7 +13040,125 @@ test_versionbounds(void)
         H5Fclose(vfile);
     } H5E_END_TRY;
     return FAIL;
-} /* test_versionbounds() */
+} /* end test_versionbounds() */
+
+
+/*-----------------------------------------------------------------------------
+ * Function:   test_object_header_minimization_dcpl
+ *
+ * Purpose:    Test the "datset object header minimization" property as part of
+ *             the DCPL.
+ *
+ * Return:     Success/pass:   0
+ *             Failure/error: -1
+ *
+ * Programmer: Jacob Smith
+ *             2018 August 15
+ *
+ * Changes:    None.
+ *-----------------------------------------------------------------------------
+ */
+static herr_t
+test_object_header_minimization_dcpl(void)
+{
+    hid_t    dcpl_id  = -1;
+    hid_t    file_id  = -1;
+    char     filename[FILENAME_BUF_SIZE] = "";
+    hbool_t  minimize = FALSE;
+    herr_t   ret;
+
+    TESTING("dcpl flags to minimize dataset object header");
+
+    /*********/
+    /* SETUP */
+    /*********/
+
+    if(NULL == h5_fixname(OHMIN_FILENAME_A, H5P_DEFAULT, filename, sizeof(filename)))
+        TEST_ERROR("unable to prepare filename");
+
+    file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    if (file_id == H5I_INVALID_HID)
+        TEST_ERROR
+
+    dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
+    if (dcpl_id == H5I_INVALID_HID)
+        TEST_ERROR
+
+    /*********/
+    /* TESTS */
+    /*********/
+
+    /* default value (not set explicitly)
+     */
+    if (H5Pget_dset_no_attrs_hint(dcpl_id, &minimize) == FAIL)
+        TEST_ERROR
+    if (FALSE != minimize)
+        TEST_ERROR
+
+    /* FALSE-set value
+     */
+    if (H5Pset_dset_no_attrs_hint(dcpl_id, FALSE) == FAIL)
+        TEST_ERROR
+    if (H5Pget_dset_no_attrs_hint(dcpl_id, &minimize) == FAIL)
+        TEST_ERROR
+    if (FALSE != minimize)
+        TEST_ERROR
+
+    /* TRUE-set value
+     */
+    if (H5Pset_dset_no_attrs_hint(dcpl_id, TRUE) == FAIL)
+        TEST_ERROR
+    if (H5Pget_dset_no_attrs_hint(dcpl_id, &minimize) == FAIL)
+        TEST_ERROR
+    if (TRUE != minimize)
+        TEST_ERROR
+
+    /* error cases
+     */
+    H5E_BEGIN_TRY {
+        ret = H5Pget_dset_no_attrs_hint(-1, &minimize);
+    } H5E_END_TRY;
+    if (ret == SUCCEED)
+        TEST_ERROR
+
+    H5E_BEGIN_TRY {
+        ret = H5Pset_dset_no_attrs_hint(-1, FALSE);
+    } H5E_END_TRY;
+    if (ret == SUCCEED)
+        TEST_ERROR
+
+    H5E_BEGIN_TRY {
+        ret = H5Pset_dset_no_attrs_hint(-1, TRUE);
+    } H5E_END_TRY;
+    if (ret == SUCCEED)
+        TEST_ERROR
+
+    H5E_BEGIN_TRY {
+        ret = H5Pget_dset_no_attrs_hint(dcpl_id, NULL);
+    } H5E_END_TRY;
+    if (ret == SUCCEED)
+        TEST_ERROR
+
+    /************/
+    /* TEARDOWN */
+    /************/
+
+    if (H5Fclose(file_id) == FAIL)
+        TEST_ERROR
+
+    if (H5Pclose(dcpl_id) == FAIL)
+        TEST_ERROR
+
+    PASSED();
+    return SUCCEED;
+
+error:
+    H5E_BEGIN_TRY {
+        H5Pclose(dcpl_id);
+        H5Fclose(file_id);
+    } H5E_END_TRY;
+    return FAIL;
+} /* end test_object_header_minimization_dcpl() */
 
 
 /*-------------------------------------------------------------------------
@@ -13058,6 +13182,7 @@ main(void)
     hid_t    fcpl = -1, fcpl2 = -1;
     unsigned new_format;
     unsigned paged;
+    unsigned minimized_ohdr;
     int      mdc_nelmts;
     size_t   rdcc_nelmts;
     size_t   rdcc_nbytes;
@@ -13113,113 +13238,122 @@ main(void)
         if(!contig_addr_vfd && paged)
             continue;
 
-        /* Test with old & new format groups */
-        for(new_format = FALSE; new_format <= TRUE; new_format++) {
-            hid_t my_fapl, my_fcpl;
-
-            /* Set the FAPL for the type of format */
-            if(new_format) {
-                my_fapl = fapl2;
-                if(paged) {
-                    my_fcpl = fcpl2;
-                    puts("\nTesting with new file format and paged aggregation");
-                } else {
-                    my_fcpl = fcpl;
-                    puts("\nTesting with new file format and non-paged aggregation");
-                }
-            } /* end if */
-            else {
-                my_fapl = fapl;
-                if(paged) {
-                    my_fcpl = fcpl2;
-                    puts("Testing with old file format and paged aggregation:");
-                } else {
-                    my_fcpl = fcpl;
-                    puts("Testing with old file format and non-paged aggregation:");
-                }
-            } /* end else */
+        for(minimized_ohdr = FALSE; minimized_ohdr <= TRUE; minimized_ohdr++) {
+
+            /* Test with old & new format groups */
+            for(new_format = FALSE; new_format <= TRUE; new_format++) {
+                hid_t my_fapl, my_fcpl;
+
+                /* Set the FAPL for the type of format */
+                if(new_format) {
+                    my_fapl = fapl2;
+                    if(paged) {
+                        my_fcpl = fcpl2;
+                        puts("\nTesting with new file format and paged aggregation");
+                    } else {
+                        my_fcpl = fcpl;
+                        puts("\nTesting with new file format and non-paged aggregation");
+                    }
+                } /* end if */
+                else {
+                    my_fapl = fapl;
+                    if(paged) {
+                        my_fcpl = fcpl2;
+                        puts("Testing with old file format and paged aggregation:");
+                    } else {
+                        my_fcpl = fcpl;
+                        puts("Testing with old file format and non-paged aggregation:");
+                    }
+                } /* end else */
 
-            /* Create the file for this test */
-            if((file = H5Fcreate(filename, H5F_ACC_TRUNC, my_fcpl, my_fapl)) < 0)
-                goto error;
+                /* Create the file for this test */
+                if((file = H5Fcreate(filename, H5F_ACC_TRUNC, my_fcpl, my_fapl)) < 0)
+                    goto error;
 
-            /* Cause the library to emit initial messages */
-            if((grp = H5Gcreate2(file, "emit diagnostics", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
-                goto error;
-            if(H5Oset_comment(grp, "Causes diagnostic messages to be emitted") < 0)
-                goto error;
-            if(H5Gclose(grp) < 0)
-                goto error;
+                if (TRUE == minimized_ohdr) {
+                    if (0 > H5Fset_dset_no_attrs_hint(file, TRUE))
+                        goto error;
+                    puts("(minimized dataset object headers with file setting)");
+                }
+
+                /* Cause the library to emit initial messages */
+                if((grp = H5Gcreate2(file, "emit diagnostics", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+                    goto error;
+                if(H5Oset_comment(grp, "Causes diagnostic messages to be emitted") < 0)
+                    goto error;
+                if(H5Gclose(grp) < 0)
+                    goto error;
 
-            nerrors += (test_create(file) < 0             ? 1 : 0);
-            nerrors += (test_simple_io(envval, my_fapl) < 0        ? 1 : 0);
-            nerrors += (test_compact_io(my_fapl) < 0          ? 1 : 0);
-            nerrors += (test_max_compact(my_fapl) < 0        ? 1 : 0);
-            nerrors += (test_compact_open_close_dirty(my_fapl) < 0     ? 1 : 0);
-            nerrors += (test_conv_buffer(file) < 0            ? 1 : 0);
-            nerrors += (test_tconv(file) < 0            ? 1 : 0);
-            nerrors += (test_filters(file, my_fapl) < 0        ? 1 : 0);
-            nerrors += (test_onebyte_shuffle(file) < 0         ? 1 : 0);
-            nerrors += (test_nbit_int(file) < 0                 ? 1 : 0);
-            nerrors += (test_nbit_float(file) < 0                     ? 1 : 0);
-            nerrors += (test_nbit_double(file) < 0                     ? 1 : 0);
-            nerrors += (test_nbit_array(file) < 0                 ? 1 : 0);
-            nerrors += (test_nbit_compound(file) < 0         ? 1 : 0);
-            nerrors += (test_nbit_compound_2(file) < 0         ? 1 : 0);
-            nerrors += (test_nbit_compound_3(file) < 0         ? 1 : 0);
-            nerrors += (test_nbit_int_size(file) < 0         ? 1 : 0);
-            nerrors += (test_nbit_flt_size(file) < 0         ? 1 : 0);
-            nerrors += (test_scaleoffset_int(file) < 0         ? 1 : 0);
-            nerrors += (test_scaleoffset_int_2(file) < 0             ? 1 : 0);
-            nerrors += (test_scaleoffset_float(file) < 0             ? 1 : 0);
-            nerrors += (test_scaleoffset_float_2(file) < 0             ? 1 : 0);
-            nerrors += (test_scaleoffset_double(file) < 0             ? 1 : 0);
-            nerrors += (test_scaleoffset_double_2(file) < 0     ? 1 : 0);
-            nerrors += (test_multiopen (file) < 0                ? 1 : 0);
-            nerrors += (test_types(file) < 0                       ? 1 : 0);
-            nerrors += (test_userblock_offset(envval, my_fapl, new_format) < 0  ? 1 : 0);
-            nerrors += (test_missing_filter(file) < 0        ? 1 : 0);
-            nerrors += (test_can_apply(file) < 0                ? 1 : 0);
-            nerrors += (test_can_apply2(file) < 0                ? 1 : 0);
-            nerrors += (test_set_local(my_fapl) < 0                ? 1 : 0);
-            nerrors += (test_can_apply_szip(file) < 0        ? 1 : 0);
-            nerrors += (test_compare_dcpl(file) < 0                ? 1 : 0);
-            nerrors += (test_copy_dcpl(file, my_fapl) < 0            ? 1 : 0);
-            nerrors += (test_filter_delete(file) < 0        ? 1 : 0);
-            nerrors += (test_filters_endianess() < 0            ? 1 : 0);
-            nerrors += (test_zero_dims(file) < 0                ? 1 : 0);
-            nerrors += (test_missing_chunk(file) < 0        ? 1 : 0);
-            nerrors += (test_random_chunks(my_fapl) < 0        ? 1 : 0);
+                nerrors += (test_create(file) < 0             ? 1 : 0);
+                nerrors += (test_simple_io(envval, my_fapl) < 0        ? 1 : 0);
+                nerrors += (test_compact_io(my_fapl) < 0          ? 1 : 0);
+                nerrors += (test_max_compact(my_fapl) < 0        ? 1 : 0);
+                nerrors += (test_compact_open_close_dirty(my_fapl) < 0     ? 1 : 0);
+                nerrors += (test_conv_buffer(file) < 0            ? 1 : 0);
+                nerrors += (test_tconv(file) < 0            ? 1 : 0);
+                nerrors += (test_filters(file, my_fapl) < 0        ? 1 : 0);
+                nerrors += (test_onebyte_shuffle(file) < 0         ? 1 : 0);
+                nerrors += (test_nbit_int(file) < 0                 ? 1 : 0);
+                nerrors += (test_nbit_float(file) < 0                     ? 1 : 0);
+                nerrors += (test_nbit_double(file) < 0                     ? 1 : 0);
+                nerrors += (test_nbit_array(file) < 0                 ? 1 : 0);
+                nerrors += (test_nbit_compound(file) < 0         ? 1 : 0);
+                nerrors += (test_nbit_compound_2(file) < 0         ? 1 : 0);
+                nerrors += (test_nbit_compound_3(file) < 0         ? 1 : 0);
+                nerrors += (test_nbit_int_size(file) < 0         ? 1 : 0);
+                nerrors += (test_nbit_flt_size(file) < 0         ? 1 : 0);
+                nerrors += (test_scaleoffset_int(file) < 0         ? 1 : 0);
+                nerrors += (test_scaleoffset_int_2(file) < 0             ? 1 : 0);
+                nerrors += (test_scaleoffset_float(file) < 0             ? 1 : 0);
+                nerrors += (test_scaleoffset_float_2(file) < 0             ? 1 : 0);
+                nerrors += (test_scaleoffset_double(file) < 0             ? 1 : 0);
+                nerrors += (test_scaleoffset_double_2(file) < 0     ? 1 : 0);
+                nerrors += (test_multiopen (file) < 0                ? 1 : 0);
+                nerrors += (test_types(file) < 0                       ? 1 : 0);
+                nerrors += (test_userblock_offset(envval, my_fapl, new_format) < 0  ? 1 : 0);
+                nerrors += (test_missing_filter(file) < 0        ? 1 : 0);
+                nerrors += (test_can_apply(file) < 0                ? 1 : 0);
+                nerrors += (test_can_apply2(file) < 0                ? 1 : 0);
+                nerrors += (test_set_local(my_fapl) < 0                ? 1 : 0);
+                nerrors += (test_can_apply_szip(file) < 0        ? 1 : 0);
+                nerrors += (test_compare_dcpl(file) < 0                ? 1 : 0);
+                nerrors += (test_copy_dcpl(file, my_fapl) < 0            ? 1 : 0);
+                nerrors += (test_filter_delete(file) < 0        ? 1 : 0);
+                nerrors += (test_filters_endianess() < 0            ? 1 : 0);
+                nerrors += (test_zero_dims(file) < 0                ? 1 : 0);
+                nerrors += (test_missing_chunk(file) < 0        ? 1 : 0);
+                nerrors += (test_random_chunks(my_fapl) < 0        ? 1 : 0);
 
 #ifndef H5_NO_DEPRECATED_SYMBOLS
-            nerrors += (test_deprec(file) < 0            ? 1 : 0);
+                nerrors += (test_deprec(file) < 0            ? 1 : 0);
 #endif /* H5_NO_DEPRECATED_SYMBOLS */
 
-            nerrors += (test_huge_chunks(my_fapl) < 0        ? 1 : 0);
-            nerrors += (test_chunk_cache(my_fapl) < 0        ? 1 : 0);
-            nerrors += (test_big_chunks_bypass_cache(my_fapl) < 0   ? 1 : 0);
-            nerrors += (test_chunk_fast(envval, my_fapl) < 0    ? 1 : 0);
-            nerrors += (test_reopen_chunk_fast(my_fapl) < 0        ? 1 : 0);
-            nerrors += (test_chunk_fast_bug1(my_fapl) < 0           ? 1 : 0);
-            nerrors += (test_chunk_expand(my_fapl) < 0        ? 1 : 0);
-            nerrors += (test_layout_extend(my_fapl) < 0        ? 1 : 0);
-            nerrors += (test_fixed_array(my_fapl) < 0        ? 1 : 0);
-            nerrors += (test_idx_compatible() < 0            ? 1 : 0);
-            nerrors += (test_unfiltered_edge_chunks(my_fapl) < 0    ? 1 : 0);
-            nerrors += (test_single_chunk(my_fapl) < 0              ? 1 : 0);
-            nerrors += (test_large_chunk_shrink(my_fapl) < 0        ? 1 : 0);
-            nerrors += (test_zero_dim_dset(my_fapl) < 0             ? 1 : 0);
-            nerrors += (test_storage_size(my_fapl) < 0              ? 1 : 0);
-            nerrors += (test_power2up(my_fapl) < 0                  ? 1 : 0);
-
-            nerrors += (test_swmr_non_latest(envval, my_fapl) < 0   ? 1 : 0);
-            nerrors += (test_earray_hdr_fd(envval, my_fapl) < 0     ? 1 : 0);
-            nerrors += (test_farray_hdr_fd(envval, my_fapl) < 0     ? 1 : 0);
-            nerrors += (test_bt2_hdr_fd(envval, my_fapl) < 0        ? 1 : 0);
-
-            if(H5Fclose(file) < 0)
-                goto error;
-        } /* end for new_format */
+                nerrors += (test_huge_chunks(my_fapl) < 0        ? 1 : 0);
+                nerrors += (test_chunk_cache(my_fapl) < 0        ? 1 : 0);
+                nerrors += (test_big_chunks_bypass_cache(my_fapl) < 0   ? 1 : 0);
+                nerrors += (test_chunk_fast(envval, my_fapl) < 0    ? 1 : 0);
+                nerrors += (test_reopen_chunk_fast(my_fapl) < 0        ? 1 : 0);
+                nerrors += (test_chunk_fast_bug1(my_fapl) < 0           ? 1 : 0);
+                nerrors += (test_chunk_expand(my_fapl) < 0        ? 1 : 0);
+                nerrors += (test_layout_extend(my_fapl) < 0        ? 1 : 0);
+                nerrors += (test_fixed_array(my_fapl) < 0        ? 1 : 0);
+                nerrors += (test_idx_compatible() < 0            ? 1 : 0);
+                nerrors += (test_unfiltered_edge_chunks(my_fapl) < 0    ? 1 : 0);
+                nerrors += (test_single_chunk(my_fapl) < 0              ? 1 : 0);
+                nerrors += (test_large_chunk_shrink(my_fapl) < 0        ? 1 : 0);
+                nerrors += (test_zero_dim_dset(my_fapl) < 0             ? 1 : 0);
+                nerrors += (test_storage_size(my_fapl) < 0              ? 1 : 0);
+                nerrors += (test_power2up(my_fapl) < 0                  ? 1 : 0);
+
+                nerrors += (test_swmr_non_latest(envval, my_fapl) < 0   ? 1 : 0);
+                nerrors += (test_earray_hdr_fd(envval, my_fapl) < 0     ? 1 : 0);
+                nerrors += (test_farray_hdr_fd(envval, my_fapl) < 0     ? 1 : 0);
+                nerrors += (test_bt2_hdr_fd(envval, my_fapl) < 0        ? 1 : 0);
+
+                if(H5Fclose(file) < 0)
+                    goto error;
+            } /* end for new_format */
+        } /* end for minimized_ohdr */
     } /* end for paged */
 
     /* Close property lists */
@@ -13236,6 +13370,8 @@ main(void)
     /* Tests version bounds using its own file */
     nerrors += (test_versionbounds() < 0                    ? 1 : 0);
 
+    nerrors += (test_object_header_minimization_dcpl() < 0 ? 1 : 0);
+
     /* Run misc tests */
     nerrors += dls_01_main();
 
@@ -13251,12 +13387,12 @@ main(void)
 #endif /* H5_HAVE_FILTER_SZIP */
     h5_cleanup(FILENAME, fapl);
 
-    return 0;
+    return EXIT_SUCCESS;
 
 error:
     nerrors = MAX(1, nerrors);
     printf("***** %d DATASET TEST%s FAILED! *****\n",
             nerrors, 1 == nerrors ? "" : "S");
-    return 1;
-}
+    return EXIT_FAILURE;
+} /* end main() */
 
diff --git a/test/enc_dec_plist.c b/test/enc_dec_plist.c
index 36db2d0..cee38f3 100644
--- a/test/enc_dec_plist.c
+++ b/test/enc_dec_plist.c
@@ -146,6 +146,9 @@ main(void)
     if((H5Pset_fill_value(dcpl, H5T_NATIVE_DOUBLE, &fill)) < 0)
         FAIL_STACK_ERROR
 
+    if((H5Pset_dset_no_attrs_hint(dcpl, FALSE)) < 0)
+        FAIL_STACK_ERROR
+
     max_size[0] = 100;
     if((H5Pset_external(dcpl, "ext1.data", (off_t)0, 
                          (hsize_t)(max_size[0] * sizeof(int)/4))) < 0)
diff --git a/test/gen_plist.c b/test/gen_plist.c
index 62693bd..d8096e3 100644
--- a/test/gen_plist.c
+++ b/test/gen_plist.c
@@ -125,6 +125,9 @@ main(void)
     if((ret = H5Pset_fill_value(dcpl1, H5T_STD_I32BE, &fill)) < 0)
         assert(ret > 0);
 
+    if((ret = H5Pset_dset_no_attrs_hint(dcpl1, FALSE)) < 0)
+        assert(ret > 0);
+
     max_size[0] = 100;
     if((ret = H5Pset_external(dcpl1, "ext1.data", (off_t)0, 
                          (hsize_t)(max_size[0] * sizeof(int)/4))) < 0)
diff --git a/test/links.c b/test/links.c
index fb2c75a..63b125f 100644
--- a/test/links.c
+++ b/test/links.c
@@ -315,6 +315,8 @@ typedef struct {
     const obj_visit_t *info;    /* Pointer to the object visit structure to use */
 } ovisit_ud_t;
 
+static hid_t dcpl_g; /* for [un]minimized dataset object headers */
+
 
 
 /*-------------------------------------------------------------------------
@@ -377,7 +379,7 @@ mklinks(hid_t fapl, hbool_t new_format)
     if(H5Gclose(grp) < 0) TEST_ERROR
 
     /* Create a dataset */
-    if((d1 = H5Dcreate2(file, "d1", H5T_NATIVE_INT, scalar, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
+    if((d1 = H5Dcreate2(file, "d1", H5T_NATIVE_INT, scalar, H5P_DEFAULT, dcpl_g, H5P_DEFAULT)) < 0) TEST_ERROR
     if(H5Dclose(d1) < 0) TEST_ERROR
 
     /* Create a hard link */
@@ -451,8 +453,8 @@ new_links(hid_t fapl, hbool_t new_format)
     if((grp2_b = H5Gcreate2(file_b, "grp2", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* Create datasets */
-    if((dset1 = H5Dcreate2(file_a, "dataset1", H5T_NATIVE_INT, scalar, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
-    if((dset2 = H5Dcreate2(grp1_a, "dataset2", H5T_NATIVE_INT, scalar, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
+    if((dset1 = H5Dcreate2(file_a, "dataset1", H5T_NATIVE_INT, scalar, H5P_DEFAULT, dcpl_g, H5P_DEFAULT)) < 0) TEST_ERROR
+    if((dset2 = H5Dcreate2(grp1_a, "dataset2", H5T_NATIVE_INT, scalar, H5P_DEFAULT, dcpl_g, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* Create links within a file.  Both of source and destination use
      * H5L_SAME_LOC.  Both hard and soft links should fail. */
@@ -545,7 +547,7 @@ cklinks(hid_t fapl, hbool_t new_format)
     if(H5Oget_info_by_name2(file, "grp1/hard", &oinfo2, H5O_INFO_BASIC, H5P_DEFAULT) < 0) FAIL_STACK_ERROR
     if(H5O_TYPE_DATASET != oinfo2.type) {
 	H5_FAILED();
-	printf("    %d: Unexpected object type should have been a dataset\n", __LINE__);
+	HDprintf("    %d: Unexpected object type should have been a dataset\n", __LINE__);
 	TEST_ERROR
     } /* end if */
     if(H5F_addr_ne(oinfo1.addr, oinfo2.addr)) {
@@ -580,7 +582,7 @@ cklinks(hid_t fapl, hbool_t new_format)
     if(H5Oget_info_by_name2(file, "grp1/soft", &oinfo2, H5O_INFO_BASIC, H5P_DEFAULT) < 0) FAIL_STACK_ERROR
     if(H5O_TYPE_DATASET != oinfo2.type) {
 	H5_FAILED();
-	printf("    %d: Unexpected object type should have been a dataset\n", __LINE__);
+	HDprintf("    %d: Unexpected object type should have been a dataset\n", __LINE__);
 	TEST_ERROR
     } /* end if */
     if(H5F_addr_ne(oinfo1.addr, oinfo2.addr)) {
@@ -609,12 +611,12 @@ cklinks(hid_t fapl, hbool_t new_format)
     if(H5Lget_info(file, "grp1/dangle", &linfo2, H5P_DEFAULT) < 0) FAIL_STACK_ERROR
     if(H5L_TYPE_SOFT != linfo2.type) {
 	H5_FAILED();
-	printf("    %d: Unexpected object type should have been a symbolic link\n", __LINE__);
+	HDprintf("    %d: Unexpected object type should have been a symbolic link\n", __LINE__);
 	TEST_ERROR
     } /* end if */
     if(H5Lget_val(file, "grp1/dangle", linkval, sizeof linkval, H5P_DEFAULT) < 0) {
 	H5_FAILED();
-	printf("    %d: Can't retrieve link value\n", __LINE__);
+	HDprintf("    %d: Can't retrieve link value\n", __LINE__);
 	TEST_ERROR
     } /* end if */
     if(HDstrcmp(linkval, "foobar")) {
@@ -1014,7 +1016,7 @@ test_lcpl(hid_t fapl, hbool_t new_format)
     if((space_id=H5Screate_simple(2 ,dims, NULL)) < 0) TEST_ERROR
 
     /* Create a dataset using the default LCPL */
-    if((dset_id = H5Dcreate2(file_id, "/dataset", H5T_NATIVE_INT, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
+    if((dset_id = H5Dcreate2(file_id, "/dataset", H5T_NATIVE_INT, space_id, H5P_DEFAULT, dcpl_g, H5P_DEFAULT)) < 0) TEST_ERROR
     if(H5Dclose(dset_id) < 0) TEST_ERROR
 
     /* Check that its character encoding is the default */
@@ -1043,7 +1045,7 @@ test_lcpl(hid_t fapl, hbool_t new_format)
     if(linfo.cset != H5T_CSET_UTF8) TEST_ERROR
 
     /* Create a dataset using the new LCPL */
-    if((dset_id = H5Dcreate2(file_id, "/dataset2", H5T_NATIVE_INT, space_id, lcpl_id, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
+    if((dset_id = H5Dcreate2(file_id, "/dataset2", H5T_NATIVE_INT, space_id, lcpl_id, dcpl_g, H5P_DEFAULT)) < 0) TEST_ERROR
     if(H5Dclose(dset_id) < 0) TEST_ERROR
 
     /* Check that its character encoding is UTF-8 */
@@ -2602,7 +2604,7 @@ external_link_toomany(hid_t fapl, hbool_t new_format)
     } H5E_END_TRY;
     if (gid >= 0) {
 	H5_FAILED();
-	printf("%d:    Should have failed for sequence of too many nested links.", __LINE__);
+	HDprintf("%d:    Should have failed for sequence of too many nested links.", __LINE__);
 	goto error;
     }
 
@@ -3758,7 +3760,7 @@ external_set_elink_fapl2(hid_t fapl, hbool_t new_format)
     if((space = H5Screate_simple(2, dims, NULL)) < 0) TEST_ERROR
 
     /* Create dataset creation property list */
-    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0) TEST_ERROR;
+    if((dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g)) < 0) TEST_ERROR;
     if(H5Pset_alloc_time(dcpl, H5D_ALLOC_TIME_LATE) < 0) TEST_ERROR;
 
     /* create "Dataset" in group "A" of target file */
@@ -6100,7 +6102,7 @@ external_link_closing(hid_t fapl, hbool_t new_format)
     /* Test creating each kind of object */
     if((gid = H5Gcreate2(fid1, "elink/elink/elink/group1", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
     if(H5Tcommit2(fid1, "elink/elink/elink/type1", tid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT) < 0) TEST_ERROR
-    if((did = H5Dcreate2(fid1, "elink/elink/elink/dataset1", tid2, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
+    if((did = H5Dcreate2(fid1, "elink/elink/elink/dataset1", tid2, sid, H5P_DEFAULT, dcpl_g, H5P_DEFAULT)) < 0) TEST_ERROR
 
     /* Close objects */
     if(H5Gclose(gid) < 0) TEST_ERROR
@@ -7298,7 +7300,7 @@ external_open_twice(hid_t fapl, hbool_t new_format)
     if((space = H5Screate(H5S_SCALAR)) < 0)
         TEST_ERROR
     if((oid1 = H5Dcreate2(fid2, "dset", H5T_NATIVE_INT, space, H5P_DEFAULT,
-            H5P_DEFAULT, H5P_DEFAULT)) < 0)
+            dcpl_g, H5P_DEFAULT)) < 0)
         TEST_ERROR
     if(H5Dclose(oid1) < 0)
         TEST_ERROR
@@ -7514,7 +7516,7 @@ external_link_with_committed_datatype(hid_t fapl, hbool_t new_format)
     if((sid2 = H5Screate_simple(2, dims, NULL)) < 0)
         FAIL_STACK_ERROR
 
-    if((dcpl = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+    if((dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g)) < 0)
         FAIL_STACK_ERROR
     if(H5Pset_chunk(dcpl, 2, chunks) < 0)
         FAIL_STACK_ERROR
@@ -9058,7 +9060,7 @@ lapl_nlinks(hid_t fapl, hbool_t new_format)
     dims[0] = 2;
     dims[1] = 2;
     if((sid = H5Screate_simple(2, dims, NULL)) < 0) TEST_ERROR
-    if((did = H5Dcreate2(gid, "dataset", H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
+    if((did = H5Dcreate2(gid, "dataset", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl_g, H5P_DEFAULT)) < 0) TEST_ERROR
     if(H5Dclose(did) < 0) TEST_ERROR
 
     /* Close group */
@@ -9170,7 +9172,7 @@ linkinfo(hid_t fapl, hbool_t new_format)
     if(H5Lcreate_soft("group", fid, "softlink", H5P_DEFAULT, H5P_DEFAULT) < 0) FAIL_STACK_ERROR
 
     if((sid = H5Screate(H5S_SCALAR)) < 0) TEST_ERROR
-    if((did = H5Dcreate2(fid, "dataset", H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
+    if((did = H5Dcreate2(fid, "dataset", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl_g, H5P_DEFAULT)) < 0) TEST_ERROR
 
     if(H5Lcreate_ud(fid, "ud_link", (H5L_type_t)UD_PLIST_TYPE, NULL, (size_t)0, H5P_DEFAULT, H5P_DEFAULT) < 0) TEST_ERROR
     if(H5Lcreate_external("file_name", "obj_path", fid, "ext_link", H5P_DEFAULT, H5P_DEFAULT) < 0) TEST_ERROR
@@ -9335,13 +9337,13 @@ build_visit_file(hid_t fapl)
     /* Create dataset in each group */
     if((sid = H5Screate(H5S_SCALAR)) < 0) TEST_ERROR
 
-    if((did = H5Dcreate2(fid, "/Dataset_zero", H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
+    if((did = H5Dcreate2(fid, "/Dataset_zero", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl_g, H5P_DEFAULT)) < 0) TEST_ERROR
     if(H5Dclose(did) < 0) TEST_ERROR
 
-    if((did = H5Dcreate2(fid, "/Group1/Dataset_one", H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
+    if((did = H5Dcreate2(fid, "/Group1/Dataset_one", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl_g, H5P_DEFAULT)) < 0) TEST_ERROR
     if(H5Dclose(did) < 0) TEST_ERROR
 
-    if((did = H5Dcreate2(fid, "/Group1/Group2/Dataset_two", H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
+    if((did = H5Dcreate2(fid, "/Group1/Group2/Dataset_two", H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl_g, H5P_DEFAULT)) < 0) TEST_ERROR
     if(H5Dclose(did) < 0) TEST_ERROR
 
     if(H5Sclose(sid) < 0) TEST_ERROR
@@ -14890,6 +14892,7 @@ main(void)
     hid_t	fapl, fapl2;    /* File access property lists */
     int	nerrors = 0;
     unsigned new_format;    /* Whether to use the new format or not */
+    unsigned minimize_dset_oh; /* Whether to minimize dataset object headers */
     unsigned efc;           /* Whether to use the external file cache */
     const char  *env_h5_drvr;      /* File Driver value from environment */
 
@@ -14900,166 +14903,185 @@ main(void)
     h5_reset();
     fapl = h5_fileaccess();
 
-    /* Copy the file access property list */
+    /* fapl2 uses "latest version bounds" */
     if((fapl2 = H5Pcopy(fapl)) < 0) TEST_ERROR
-
-    /* Set the "use the latest version of the format" bounds for creating objects in the file */
     if(H5Pset_libver_bounds(fapl2, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0) TEST_ERROR
 
-    /* Loop over using new group format */
-    for(new_format = FALSE; new_format <= TRUE; new_format++) {
-        hid_t my_fapl;
+    for (minimize_dset_oh = 0; minimize_dset_oh <= 1; minimize_dset_oh++) {
+        if (minimize_dset_oh) {
+            HDprintf("\n-Testing with minimzed dataset object headers-\n");
+            dcpl_g = H5Pcreate(H5P_DATASET_CREATE);
+            if (0 > dcpl_g) TEST_ERROR
+        } else {
+            HDprintf("\n-Testing with unminimzed dataset object headers-\n");
+            dcpl_g = H5P_DEFAULT;
+        }
 
-        /* Check for FAPL to use */
-        if(new_format)
-            my_fapl = fapl2;
-        else
-            my_fapl = fapl;
-
-        /* General tests... (on both old & new format groups */
-        nerrors += mklinks(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += cklinks(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += new_links(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += ck_new_links(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += long_links(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += toomany(my_fapl, new_format) < 0 ? 1 : 0;
-
-        /* Test new H5L link creation routine */
-        nerrors += test_lcpl(my_fapl, new_format);
-        nerrors += test_move(my_fapl, new_format);
-        nerrors += test_copy(my_fapl, new_format);
-        nerrors += test_move_preserves(my_fapl, new_format);
+        for(new_format = FALSE; new_format <= TRUE; new_format++) {
+            hid_t my_fapl;
+
+            /* Check for FAPL to use */
+            if(new_format) {
+                my_fapl = fapl2;
+                HDprintf("\n--Testing with 'new format'--\n");
+            } else {
+                my_fapl = fapl;
+                HDprintf("\n--Testing with 'old format'--\n");
+            }
+
+            /* always enter tests without external cache */
+            if(H5Pset_elink_file_cache_size(my_fapl, 0) < 0)
+                TEST_ERROR
+
+            /* General tests... (on both old & new format groups */
+            nerrors += mklinks(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += cklinks(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += new_links(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += ck_new_links(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += long_links(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += toomany(my_fapl, new_format) < 0 ? 1 : 0;
+
+            /* Test new H5L link creation routine */
+            nerrors += test_lcpl(my_fapl, new_format);
+            nerrors += test_move(my_fapl, new_format);
+            nerrors += test_copy(my_fapl, new_format);
+            nerrors += test_move_preserves(my_fapl, new_format);
 #ifndef H5_NO_DEPRECATED_SYMBOLS
-        nerrors += test_deprec(my_fapl, new_format);
+            nerrors += test_deprec(my_fapl, new_format);
 #endif /* H5_NO_DEPRECATED_SYMBOLS */
 
-        /* tests for external link */
-        /* Test external file cache first, so it sees the default efc setting on
-         * the fapl */
-        nerrors += external_file_cache(my_fapl, new_format) < 0 ? 1 : 0;
-
-        /* This test cannot run with the EFC because it assumes that an
-         * intermediate file is not held open */
-        nerrors += external_link_mult(my_fapl, new_format) < 0 ? 1 : 0;
-
-        /* This test cannot run with the EFC because the EFC cannot currently
-         * reopen a cached file with a different intent */
-        nerrors += external_set_elink_acc_flags(env_h5_drvr, my_fapl, new_format) < 0 ? 1 : 0;
-
-        /* Try external link tests both with and without the external file cache
-         */
-        for(efc = FALSE; efc <= TRUE; efc++) {
-            if(efc) {
-                if(H5Pset_elink_file_cache_size(my_fapl, 8) < 0)
-                    TEST_ERROR
-                printf("\n---Testing with external file cache---\n");
-            } /* end if */
-            else {
-                if(H5Pset_elink_file_cache_size(my_fapl, 0) < 0)
-                    TEST_ERROR
-                printf("\n---Testing without external file cache---\n");
-            } /* end else */
+            /* tests for external link */
+            /* Test external file cache first, so it sees the default efc setting on
+             * the fapl */
+            nerrors += external_file_cache(my_fapl, new_format) < 0 ? 1 : 0;
+
+            /* This test cannot run with the EFC because it assumes that an
+             * intermediate file is not held open */
+            nerrors += external_link_mult(my_fapl, new_format) < 0 ? 1 : 0;
+
+            /* This test cannot run with the EFC because the EFC cannot currently
+             * reopen a cached file with a different intent */
+            nerrors += external_set_elink_acc_flags(env_h5_drvr, my_fapl, new_format) < 0 ? 1 : 0;
+
+            /* Try external link tests both with and without the external file cache
+             */
+            for(efc = FALSE; efc <= TRUE; efc++) {
+                if(efc) {
+                    if(H5Pset_elink_file_cache_size(my_fapl, 8) < 0)
+                        TEST_ERROR
+                    HDprintf("\n---Testing with external file cache---\n");
+                } /* end if */
+                else {
+                    if(H5Pset_elink_file_cache_size(my_fapl, 0) < 0)
+                        TEST_ERROR
+                    HDprintf("\n---Testing without external file cache---\n");
+                } /* end else */
 
-            nerrors += external_link_root(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_path(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_self(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_pingpong(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_toomany(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_dangling(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_recursive(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_query(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_unlink_compact(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_unlink_dense(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_move(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_ride(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_closing(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_endian(new_format) < 0 ? 1 : 0;
-            nerrors += external_link_strong(my_fapl, new_format) < 0 ? 1 : 0;
-
-            nerrors += external_link_prefix(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_abs_mainpath(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_rel_mainpath(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_cwd(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_abstar(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_abstar_cur(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_reltar(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_chdir(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_set_elink_fapl1(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_set_elink_fapl2(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_set_elink_fapl3(new_format) < 0 ? 1 : 0;
-            nerrors += external_set_elink_cb(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_root(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_path(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_self(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_pingpong(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_toomany(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_dangling(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_recursive(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_query(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_unlink_compact(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_unlink_dense(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_move(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_ride(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_closing(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_endian(new_format) < 0 ? 1 : 0;
+                nerrors += external_link_strong(my_fapl, new_format) < 0 ? 1 : 0;
+
+                nerrors += external_link_prefix(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_abs_mainpath(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_rel_mainpath(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_cwd(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_abstar(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_abstar_cur(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_reltar(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_chdir(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_set_elink_fapl1(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_set_elink_fapl2(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_set_elink_fapl3(new_format) < 0 ? 1 : 0;
+                nerrors += external_set_elink_cb(my_fapl, new_format) < 0 ? 1 : 0;
 #ifdef H5_HAVE_WINDOW_PATH
-            nerrors += external_link_win1(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_win2(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_win3(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_win4(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_win5(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_win6(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_win7(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_win8(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_link_win9(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_win1(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_win2(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_win3(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_win4(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_win5(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_win6(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_win7(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_win8(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_link_win9(my_fapl, new_format) < 0 ? 1 : 0;
 #endif
-            nerrors += external_symlink(env_h5_drvr, my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_copy_invalid_object(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_dont_fail_to_source(my_fapl, new_format) < 0 ? 1 : 0;
-            nerrors += external_open_twice(my_fapl, new_format) < 0 ? 1 : 0;
-	    nerrors += external_link_with_committed_datatype(my_fapl, new_format) < 0 ? 1 : 0;
-        } /* end for */
-
-        /* These tests assume that external links are a form of UD links,
-         * so assume that everything that passed for external links
-         * above has already been tested for UD links.
-         */
-        if(new_format == TRUE) {
-            nerrors += ud_hard_links(fapl2) < 0 ? 1 : 0;     /* requires new format groups */
-            nerrors += ud_link_reregister(fapl2) < 0 ? 1 : 0;        /* requires new format groups */
-        } /* end if */
-        nerrors += ud_callbacks(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += ud_link_errors(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += lapl_udata(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += lapl_nlinks(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += linkinfo(my_fapl, new_format) < 0 ? 1 : 0;
-
-        /* Misc. extra tests, useful for both new & old format files */
-        nerrors += link_visit(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += link_visit_by_name(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += obj_visit(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += obj_visit_by_name(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += obj_visit_stop(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += link_filters(my_fapl, new_format) < 0 ? 1 : 0;
-        nerrors += obj_exists(my_fapl, new_format) < 0 ? 1 : 0;
-
-        /* Keep this test last, it's testing files that are used above */
-        /* do not do this for files used by external link tests */
-        nerrors += check_all_closed(my_fapl, new_format, EXTSTOP) < 0 ? 1 : 0;
-    } /* end for */
-
-    /* New group revision feature tests */
-    nerrors += corder_create_empty(fapl2) < 0 ? 1 : 0;
+                nerrors += external_symlink(env_h5_drvr, my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_copy_invalid_object(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_dont_fail_to_source(my_fapl, new_format) < 0 ? 1 : 0;
+                nerrors += external_open_twice(my_fapl, new_format) < 0 ? 1 : 0;
+	        nerrors += external_link_with_committed_datatype(my_fapl, new_format) < 0 ? 1 : 0;
+            } /* for with/without external file cache (efc) */
+
+            /* These tests assume that external links are a form of UD links,
+             * so assume that everything that passed for external links
+             * above has already been tested for UD links.
+             */
+            if(new_format == TRUE) {
+                nerrors += ud_hard_links(fapl2) < 0 ? 1 : 0;     /* requires new format groups */
+                nerrors += ud_link_reregister(fapl2) < 0 ? 1 : 0;        /* requires new format groups */
+            } /* end if */
+            nerrors += ud_callbacks(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += ud_link_errors(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += lapl_udata(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += lapl_nlinks(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += linkinfo(my_fapl, new_format) < 0 ? 1 : 0;
+
+            /* Misc. extra tests, useful for both new & old format files */
+            nerrors += link_visit(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += link_visit_by_name(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += obj_visit(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += obj_visit_by_name(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += obj_visit_stop(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += link_filters(my_fapl, new_format) < 0 ? 1 : 0;
+            nerrors += obj_exists(my_fapl, new_format) < 0 ? 1 : 0;
+
+            /* Keep this test last, it's testing files that are used above */
+            /* do not do this for files used by external link tests */
+            nerrors += check_all_closed(my_fapl, new_format, EXTSTOP) < 0 ? 1 : 0;
+        } /* for new/old format */
+
+        /* New group revision feature tests */
+        nerrors += corder_create_empty(fapl2) < 0 ? 1 : 0;
 /* XXX: when creation order indexing is fully working, go back and add checks
 *      to these tests to make certain that the creation order values are
 *      correct.
 */
-    nerrors += corder_create_compact(fapl2) < 0 ? 1 : 0;
-    nerrors += corder_create_dense(fapl2) < 0 ? 1 : 0;
-    nerrors += corder_transition(fapl2) < 0 ? 1 : 0;
-    nerrors += corder_delete(fapl2) < 0 ? 1 : 0;
-    nerrors += link_info_by_idx(fapl2) < 0 ? 1 : 0;
-    nerrors += delete_by_idx(fapl2) < 0 ? 1 : 0;
-    nerrors += link_iterate(fapl2) < 0 ? 1 : 0;
-    nerrors += open_by_idx(fapl2) < 0 ? 1 : 0;
-    nerrors += object_info(fapl2) < 0 ? 1 : 0;
-    nerrors += group_info(fapl2) < 0 ? 1 : 0;
-    nerrors += timestamps(fapl2) < 0 ? 1 : 0;
-
-    /* Test new API calls on old-style groups */
-    nerrors += link_info_by_idx_old(fapl) < 0 ? 1 : 0;
-    nerrors += delete_by_idx_old(fapl) < 0 ? 1 : 0;
-    nerrors += link_iterate_old(fapl) < 0 ? 1 : 0;
-    nerrors += open_by_idx_old(fapl) < 0 ? 1 : 0;
-    nerrors += object_info_old(fapl) < 0 ? 1 : 0;
-    nerrors += group_info_old(fapl) < 0 ? 1 : 0;
-
+        nerrors += corder_create_compact(fapl2) < 0 ? 1 : 0;
+        nerrors += corder_create_dense(fapl2) < 0 ? 1 : 0;
+        nerrors += corder_transition(fapl2) < 0 ? 1 : 0;
+        nerrors += corder_delete(fapl2) < 0 ? 1 : 0;
+        nerrors += link_info_by_idx(fapl2) < 0 ? 1 : 0;
+        nerrors += delete_by_idx(fapl2) < 0 ? 1 : 0;
+        nerrors += link_iterate(fapl2) < 0 ? 1 : 0;
+        nerrors += open_by_idx(fapl2) < 0 ? 1 : 0;
+        nerrors += object_info(fapl2) < 0 ? 1 : 0;
+        nerrors += group_info(fapl2) < 0 ? 1 : 0;
+        nerrors += timestamps(fapl2) < 0 ? 1 : 0;
+
+        /* Test new API calls on old-style groups */
+        nerrors += link_info_by_idx_old(fapl) < 0 ? 1 : 0;
+        nerrors += delete_by_idx_old(fapl) < 0 ? 1 : 0;
+        nerrors += link_iterate_old(fapl) < 0 ? 1 : 0;
+        nerrors += open_by_idx_old(fapl) < 0 ? 1 : 0;
+        nerrors += object_info_old(fapl) < 0 ? 1 : 0;
+        nerrors += group_info_old(fapl) < 0 ? 1 : 0;
+
+        if (minimize_dset_oh) {
+            if (H5Pclose(dcpl_g) < 0) TEST_ERROR;
+            dcpl_g = -1;
+        }
+    } /* for [un]minimized dataset object headers */
     /* Close 2nd FAPL */
     H5Pclose(fapl2);
 
@@ -15075,11 +15097,11 @@ main(void)
 
     /* Results */
     if(nerrors) {
-        printf("***** %d LINK TEST%s FAILED! *****\n",
+        HDprintf("***** %d LINK TEST%s FAILED! *****\n",
                 nerrors, 1 == nerrors ? "" : "S");
         HDexit(EXIT_FAILURE);
     }
-    printf("All link tests passed.\n");
+    HDprintf("All link tests passed.\n");
 
     /* clean up symlink created by external link tests */
     HDremove(SYMLINK1);
diff --git a/test/ohdr.c b/test/ohdr.c
index 669b1e0..318169f 100644
--- a/test/ohdr.c
+++ b/test/ohdr.c
@@ -35,9 +35,16 @@
 
 const char *FILENAME[] = {
     "ohdr",
+    "ohdr_min_a",
+    "ohdr_min_b",
     NULL
 };
 
+/* used for object header size comparison */
+#define EQ 1
+#define LT 2
+#define GT 3
+
 /* The tbogus.h5 is generated from gen_bogus.c in HDF5 'test' directory.
  * To get this data file, define H5O_ENABLE_BOGUS in src/H5Oprivate, rebuild
  * the library and simply compile gen_bogus.c with that HDF5 library and run it.
@@ -50,6 +57,885 @@ const char *FILENAME[] = {
 #define OBJ_VERSION_LATEST 2
 
 /*
+ * Set an attribute with the given information.
+ * If the out parameter `attr_id` is negative, a new attribute will be
+ * created with the given information. Else, it will attempt to update the
+ * attribute with the new value.
+ *
+ * `dataspace_id` ignored if `attribute_id` >= 0
+ */
+static herr_t
+put_attribute(hid_t loc_id, const char *attrname, const void *attrvalue, hid_t datatype_id, hid_t dataspace_id, hid_t *attribute_id)
+{
+    if((*attribute_id) < 0) {
+        hid_t id = -1;
+        id = H5Acreate2(loc_id, attrname, datatype_id, dataspace_id, H5P_DEFAULT, H5P_DEFAULT);
+        if(id < 0)
+            return FAIL;
+        *attribute_id = id;
+    }
+    return H5Awrite(*attribute_id, datatype_id, attrvalue);
+} /* put_attribute */
+
+/*
+ * Count the number of attributes attached to an object.
+ * Returns negative in event of error.
+ */
+static int
+count_attributes(hid_t dset_id)
+{
+    H5O_info_t info;
+
+    if(H5Oget_info2(dset_id, &info, H5O_INFO_ALL) < 0)
+        return -1;
+    else
+        return (int)info.num_attrs; /* should never exceed int bounds */
+} /* count_attributes */
+
+/*
+ * Get the total space used by the object header.
+ * Used by oh_compare()
+ * On success, stores size in `size_out` pointer.
+ */
+static herr_t
+_oh_getsize(hid_t did, hsize_t *size_out)
+{
+    H5O_info_t info;
+    if(FAIL == H5Oget_info2(did, &info, H5O_INFO_HDR))
+        return FAIL;
+    *size_out = info.hdr.space.total;
+    return SUCCEED;
+} /* _oh_getsize */
+
+/*
+ * Compare the TOTAL space used by datasets' object headers.
+ * Returns negative value if an error occurred,
+ * else positive #defined indicator value EQ, LT, GT.
+ */
+static int
+oh_compare(hid_t did1, hid_t did2)
+{
+    hsize_t space1 = 0;
+    hsize_t space2 = 0;
+
+    if(FAIL == _oh_getsize(did1, &space1))
+        return -1;
+    if(FAIL == _oh_getsize(did2, &space2))
+        return -2;
+
+    if(space1 < space2)
+        return LT;
+    else if(space1 > space2)
+        return GT;
+    else
+        return EQ;
+} /* oh_compare() */
+
+/*
+ * Demonstrate attribute addition to datasets.
+ * Conduct additions side-by-side with a standard datataset and one with
+ * minimized dataset object headers.
+ */
+static herr_t
+test_minimized_dset_ohdr_attribute_addition(hid_t fapl_id)
+{
+    hsize_t array_10[1]      = {10}; /* dataspace extent */
+    char    buffer[10]       = "";   /* to inspect string attribute */
+    int     a_out            = 0;
+    char    filename[512]    = "";
+    hid_t   int_type_id      = -1;
+    hid_t   char_type_id     = -1;
+    hid_t   dcpl_id          = -1;
+    hid_t   dspace_id        = -1;
+    hid_t   dspace_scalar_id = -1;
+    hid_t   dset_id          = -1;
+    hid_t   mindset_id       = -1;
+    hid_t   attr_1_id        = -1;
+    hid_t   attr_1a_id       = -1;
+    hid_t   attr_2_id        = -1;
+    hid_t   attr_2a_id       = -1;
+    hid_t   attr_3_id        = -1;
+    hid_t   attr_3a_id       = -1;
+    hid_t   file_id          = -1;
+    herr_t  ret;
+    int     count = 0;
+
+    TESTING("minimized dset object headers attribute additions")
+
+    /*********
+     * SETUP *
+     *********/
+
+    if(h5_fixname(FILENAME[1], H5P_DEFAULT, filename, sizeof(filename)) == NULL)
+        TEST_ERROR
+
+    dspace_id = H5Screate_simple(1, array_10, NULL);
+    if(dspace_id < 0) TEST_ERROR
+
+    dspace_scalar_id = H5Screate(H5S_SCALAR);
+    if(dspace_scalar_id < 0) TEST_ERROR
+
+    char_type_id = H5Tcopy(H5T_NATIVE_CHAR);
+    if(char_type_id < 0) TEST_ERROR
+
+    int_type_id = H5Tcopy(H5T_NATIVE_INT);
+    if(int_type_id < 0) TEST_ERROR
+
+    dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
+    if(dcpl_id < 0) TEST_ERROR
+
+    ret = H5Pset_dset_no_attrs_hint(dcpl_id, TRUE);
+    if(ret < 0) TEST_ERROR
+
+    file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
+    if(file_id < 0) TEST_ERROR
+
+    H5E_BEGIN_TRY {
+        count = count_attributes(dset_id);
+    } H5E_END_TRY;
+    if(count != -1) TEST_ERROR
+
+    dset_id = H5Dcreate2(file_id, "dataset", int_type_id, dspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    if(dset_id < 0) TEST_ERROR
+
+    mindset_id  = H5Dcreate2(file_id, "mindataset", int_type_id, dspace_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT);
+    if(mindset_id < 0) TEST_ERROR
+
+    /********************
+     * TEST/DEMONSTRATE *
+     ********************/
+
+    /* -------------------
+     * no attributes added
+     */
+
+    count = count_attributes(dset_id);
+    if(count != 0) TEST_ERROR
+    count = count_attributes(mindset_id);
+    if(count != 0) TEST_ERROR
+
+    /* -----------------
+     * add one attribute
+     */
+    ret = put_attribute(dset_id, "PURPOSE", "DEMO", char_type_id, dspace_id, &attr_1_id);
+    if(ret < 0) TEST_ERROR
+
+    ret = put_attribute(mindset_id, "PURPOSE", "DEMO", char_type_id, dspace_id, &attr_1a_id);
+    if(ret < 0) TEST_ERROR
+
+    count = count_attributes(dset_id);
+    if(count != 1) TEST_ERROR
+    count = count_attributes(mindset_id);
+    if(count != 1) TEST_ERROR
+
+    ret = H5Aread(attr_1_id, char_type_id, buffer);
+    if(ret < 0) TEST_ERROR
+    if(HDstrcmp("DEMO", buffer)) TEST_ERROR
+
+    ret = H5Aread(attr_1a_id, char_type_id, buffer);
+    if(ret < 0) TEST_ERROR
+    if(HDstrcmp("DEMO", buffer)) TEST_ERROR
+
+    /* -----------------
+     * modify one attribute
+     */
+
+    ret = put_attribute(dset_id, "PURPOSE", "REWRITE", char_type_id, -1, &attr_1_id);
+    if(ret < 0) TEST_ERROR
+
+    ret = put_attribute(mindset_id, "PURPOSE", "REWRITE", char_type_id, -1, &attr_1a_id);
+    if(ret < 0) TEST_ERROR
+
+    count = count_attributes(dset_id);
+    if(count != 1) TEST_ERROR
+    count = count_attributes(mindset_id);
+    if(count != 1) TEST_ERROR
+
+    ret = H5Aread(attr_1_id, char_type_id, buffer);
+    if(ret < 0) TEST_ERROR
+    if(HDstrcmp("REWRITE", buffer)) TEST_ERROR
+
+    ret = H5Aread(attr_1a_id, char_type_id, buffer);
+    if(ret < 0) TEST_ERROR
+    if(HDstrcmp("REWRITE", buffer)) TEST_ERROR
+
+    /* -----------------
+     * add second attribute
+     */
+
+    a_out = 5;
+    ret = put_attribute(dset_id, "RANK", &a_out, int_type_id, dspace_scalar_id, &attr_2_id);
+    if(ret < 0) TEST_ERROR
+
+    a_out = 3;
+    ret = put_attribute(mindset_id, "RANK", &a_out, int_type_id, dspace_scalar_id, &attr_2a_id);
+    if(ret < 0) TEST_ERROR
+
+    count = count_attributes(dset_id);
+    if(count != 2) TEST_ERROR
+    count = count_attributes(mindset_id);
+    if(count != 2) TEST_ERROR
+
+    ret = H5Aread(attr_2_id, int_type_id, &a_out);
+    if(ret < 0) TEST_ERROR
+    if(a_out != 5) TEST_ERROR
+
+    ret = H5Aread(attr_2a_id, int_type_id, &a_out);
+    if(ret < 0) TEST_ERROR
+    if(a_out != 3) TEST_ERROR
+
+    /* -----------------
+     * add third attribute
+     */
+
+    a_out = -86;
+    ret = put_attribute(dset_id, "FLAVOR", &a_out, int_type_id, dspace_scalar_id, &attr_3_id);
+    if(ret < 0) TEST_ERROR
+
+    a_out = 2185;
+    ret = put_attribute(mindset_id, "FLAVOR", &a_out, int_type_id, dspace_scalar_id, &attr_3a_id);
+    if(ret < 0) TEST_ERROR
+
+    count = count_attributes(dset_id);
+    if(count != 3) TEST_ERROR
+    count = count_attributes(mindset_id);
+    if(count != 3) TEST_ERROR
+
+    ret = H5Aread(attr_3_id, int_type_id, &a_out);
+    if(ret < 0) TEST_ERROR
+    if(a_out != -86) TEST_ERROR
+
+    ret = H5Aread(attr_3a_id, int_type_id, &a_out);
+    if(ret < 0) TEST_ERROR
+    if(a_out != 2185) TEST_ERROR
+
+    /************
+     * TEARDOWN *
+     ************/
+
+    if(H5Tclose(int_type_id) < 0) TEST_ERROR
+    if(H5Tclose(char_type_id) < 0) TEST_ERROR
+    if(H5Pclose(dcpl_id) < 0) TEST_ERROR
+    if(H5Sclose(dspace_id) < 0) TEST_ERROR
+    if(H5Dclose(dset_id) < 0) TEST_ERROR
+    if(H5Dclose(mindset_id) < 0) TEST_ERROR
+    if(H5Aclose(attr_1_id) < 0) TEST_ERROR
+    if(H5Aclose(attr_1a_id) < 0) TEST_ERROR
+    if(H5Aclose(attr_2_id) < 0) TEST_ERROR
+    if(H5Aclose(attr_2a_id) < 0) TEST_ERROR
+    if(H5Aclose(attr_3_id) < 0) TEST_ERROR
+    if(H5Aclose(attr_3a_id) < 0) TEST_ERROR
+    if(H5Fclose(file_id) < 0) TEST_ERROR
+
+    PASSED()
+    return SUCCEED;
+
+error :
+    H5E_BEGIN_TRY {
+        (void)H5Tclose(int_type_id);
+        (void)H5Tclose(char_type_id);
+        (void)H5Pclose(dcpl_id);
+        (void)H5Sclose(dspace_id);
+        (void)H5Dclose(dset_id);
+        (void)H5Dclose(mindset_id);
+        (void)H5Aclose(attr_1_id);
+        (void)H5Aclose(attr_1a_id);
+        (void)H5Aclose(attr_2_id);
+        (void)H5Aclose(attr_2a_id);
+        (void)H5Aclose(attr_3_id);
+        (void)H5Aclose(attr_3a_id);
+        (void)H5Fclose(file_id);
+    } H5E_END_TRY;
+    return FAIL;
+} /* test_minimized_dset_ohdr_attribute_addition */
+
+/*
+ * Compare header sizes against when headers have been minimized.
+ * Repeats tests with headers "compact" and normal.
+ */
+static herr_t
+test_minimized_dset_ohdr_size_comparisons(hid_t fapl_id)
+{
+    hsize_t  array_10[1] = {10}; /* dataspace extents */
+    unsigned compact     = 0;
+
+    /* IDs that are file-agnostic */
+    hid_t dspace_id     = -1;
+    hid_t int_type_id   = -1;
+    hid_t dcpl_minimize = -1;
+    hid_t dcpl_dontmin  = -1;
+    hid_t dcpl_default  = -1;
+
+    /* IDs for non-minimized file open */
+    hid_t file_f_id   = -1; /* lower 'f' for standard file setting */
+    hid_t dset_f_x_id = -1; /* 'x' for default */
+    hid_t dset_f_N_id = -1; /* 'N' for explcit non-minimized dset */
+    hid_t dset_f_Y_id = -1; /* 'Y' for minimized dset */
+
+    /* IDs for minimized file open */
+    hid_t file_F_id   = -1; /* upper 'F' for minimized file setting */
+    hid_t dset_F_x_id = -1; /* 'x' for default */
+    hid_t dset_F_N_id = -1; /* 'N' for explcit non-minimized dset */
+    hid_t dset_F_Y_id = -1; /* 'Y' for minimized dset */
+
+    char filename_a[512] = "";
+    char filename_b[512] = "";
+
+    herr_t ret;
+
+    /* dataset suffixes:
+     *                | default | minimize | don't minimize (dcpl-set)
+     * ---------------+---------+----------+---------------
+     * file-default   |   f_x   |   f_Y    |   f_N
+     * ---------------+---------+----------+---------------
+     * file-minimized |   F_x   |   F_Y    |   F_N
+     */
+
+    TESTING("minimized dset object headers size comparisons");
+
+    /*********
+     * SETUP *
+     *********/
+
+    if(h5_fixname(FILENAME[1], H5P_DEFAULT, filename_a, sizeof(filename_a)) == NULL)
+        TEST_ERROR
+
+    if(h5_fixname(FILENAME[2], H5P_DEFAULT, filename_b, sizeof(filename_b)) == NULL)
+        TEST_ERROR
+
+    for (compact = 0; compact < 2; compact++) { /* 0 or 1 */
+        dcpl_default = H5Pcreate(H5P_DATASET_CREATE);
+        if(dcpl_default < 0) TEST_ERROR
+
+        dcpl_minimize = H5Pcreate(H5P_DATASET_CREATE);
+        if(dcpl_minimize < 0) TEST_ERROR
+        ret = H5Pset_dset_no_attrs_hint(dcpl_minimize, TRUE);
+        if(ret < 0) TEST_ERROR
+
+        dcpl_dontmin = H5Pcreate(H5P_DATASET_CREATE);
+        if(dcpl_dontmin < 0) TEST_ERROR
+        ret = H5Pset_dset_no_attrs_hint(dcpl_dontmin, FALSE);
+        if(ret < 0) TEST_ERROR
+
+        if(compact) {
+            HDprintf("...compact ");
+            ret = H5Pset_layout(dcpl_default, H5D_COMPACT);
+            if(ret < 0) TEST_ERROR
+            ret = H5Pset_layout(dcpl_minimize, H5D_COMPACT);
+            if(ret < 0) TEST_ERROR
+            ret = H5Pset_layout(dcpl_dontmin, H5D_COMPACT);
+            if(ret < 0) TEST_ERROR
+        } else
+            HDprintf("...not compact ");
+
+        dspace_id = H5Screate_simple(1, array_10, NULL);
+        if(dspace_id < 0) TEST_ERROR
+
+        int_type_id = H5Tcopy(H5T_NATIVE_INT);
+        if(int_type_id < 0) TEST_ERROR
+
+        file_f_id = H5Fcreate(filename_a, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
+        if(file_f_id < 0) TEST_ERROR
+
+        dset_f_x_id = H5Dcreate2(file_f_id, "default", int_type_id, dspace_id, H5P_DEFAULT, dcpl_default, H5P_DEFAULT);
+        if(dset_f_x_id < 0) TEST_ERROR
+
+        dset_f_N_id = H5Dcreate2(file_f_id, "dsetNOT", int_type_id, dspace_id, H5P_DEFAULT, dcpl_dontmin, H5P_DEFAULT);
+        if(dset_f_N_id < 0) TEST_ERROR
+
+        dset_f_Y_id = H5Dcreate2(file_f_id, "dsetMIN", int_type_id, dspace_id, H5P_DEFAULT, dcpl_minimize, H5P_DEFAULT);
+        if(dset_f_x_id < 0) TEST_ERROR
+
+        file_F_id = H5Fcreate(filename_b, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
+        if(file_F_id < 0) TEST_ERROR
+        ret = H5Fset_dset_no_attrs_hint(file_F_id, TRUE);
+        if(ret < 0) TEST_ERROR
+
+        dset_F_x_id = H5Dcreate2(file_F_id, "default", int_type_id, dspace_id, H5P_DEFAULT, dcpl_default, H5P_DEFAULT);
+        if(dset_F_x_id < 0) TEST_ERROR
+
+        dset_F_N_id = H5Dcreate2(file_F_id, "dsetNOT", int_type_id, dspace_id, H5P_DEFAULT, dcpl_dontmin, H5P_DEFAULT);
+        if(dset_F_N_id < 0) TEST_ERROR
+
+        dset_F_Y_id = H5Dcreate2(file_F_id, "dsetMIN", int_type_id, dspace_id, H5P_DEFAULT, dcpl_minimize, H5P_DEFAULT);
+        if(dset_F_Y_id < 0) TEST_ERROR
+
+        /*********
+         * TESTS *
+         *********/
+
+        if(oh_compare(dset_f_x_id, dset_f_x_id) != EQ) TEST_ERROR /* identity */
+
+        if(oh_compare(dset_f_x_id, dset_f_N_id) != EQ) TEST_ERROR
+        if(oh_compare(dset_f_x_id, dset_f_Y_id) != GT) TEST_ERROR
+        if(oh_compare(dset_f_N_id, dset_f_Y_id) != GT) TEST_ERROR
+
+        if(oh_compare(dset_F_x_id, dset_F_N_id) != EQ) TEST_ERROR
+        if(oh_compare(dset_F_x_id, dset_F_Y_id) != EQ) TEST_ERROR
+        if(oh_compare(dset_F_N_id, dset_F_Y_id) != EQ) TEST_ERROR
+
+        if(oh_compare(dset_F_x_id, dset_f_Y_id) != EQ) TEST_ERROR
+        if(oh_compare(dset_F_x_id, dset_f_x_id) != LT) TEST_ERROR
+
+        /************
+         * TEARDOWN *
+         ************/
+
+        if(H5Sclose(dspace_id) < 0) TEST_ERROR
+        if(H5Tclose(int_type_id) < 0) TEST_ERROR
+        if(H5Pclose(dcpl_default) < 0) TEST_ERROR
+        if(H5Pclose(dcpl_minimize) < 0) TEST_ERROR
+        if(H5Pclose(dcpl_dontmin) < 0) TEST_ERROR
+
+        if(H5Fclose(file_f_id) < 0) TEST_ERROR
+        if(H5Dclose(dset_f_x_id) < 0) TEST_ERROR
+        if(H5Dclose(dset_f_N_id) < 0) TEST_ERROR
+        if(H5Dclose(dset_f_Y_id) < 0) TEST_ERROR
+
+        if(H5Fclose(file_F_id) < 0) TEST_ERROR
+        if(H5Dclose(dset_F_x_id) < 0) TEST_ERROR
+        if(H5Dclose(dset_F_N_id) < 0) TEST_ERROR
+        if(H5Dclose(dset_F_Y_id) < 0) TEST_ERROR
+
+    } /* compact and non-compact */
+
+    PASSED()
+    return SUCCEED;
+
+error :
+    H5E_BEGIN_TRY {
+        (void)H5Pclose(dcpl_default);
+        (void)H5Pclose(dcpl_minimize);
+        (void)H5Pclose(dcpl_dontmin);
+        (void)H5Sclose(dspace_id);
+        (void)H5Tclose(int_type_id);
+
+        (void)H5Fclose(file_f_id);
+        (void)H5Dclose(dset_f_x_id);
+        (void)H5Dclose(dset_f_N_id);
+        (void)H5Dclose(dset_f_Y_id);
+
+        (void)H5Fclose(file_F_id);
+        (void)H5Dclose(dset_F_x_id);
+        (void)H5Dclose(dset_F_N_id);
+        (void)H5Dclose(dset_F_Y_id);
+    } H5E_END_TRY;
+    return FAIL;
+} /* test_minimized_dset_ohdr_size_comparisons */
+
+/*
+ * Test minimized dataset object header with filter/pipeline message
+ */
+static herr_t
+test_minimized_dset_ohdr_with_filter(hid_t fapl_id)
+{
+    char           filename[512]   = "";
+    const hsize_t  extents[1]      = {1024}; /* extents of dataspace */
+    const unsigned filter_values[] = {0};  /* TBD */
+    const hsize_t  chunk_dim[]     = {32};  /* needed for filter */
+    const int      ndims           = 1;
+    hid_t          dspace_id       = -1;
+    hid_t          dtype_id        = -1;
+    hid_t          dcpl_xZ_id      = -1;
+    hid_t          dcpl_mx_id      = -1;
+    hid_t          dcpl_mZ_id      = -1;
+    hid_t          dset_xx_id      = -1;
+    hid_t          dset_xZ_id      = -1;
+    hid_t          dset_mx_id      = -1;
+    hid_t          dset_mZ_id      = -1;
+    hid_t          file_id         = -1;
+    herr_t         ret;
+
+    /* dcpl suffixes:
+     *           | default | minimize
+     * ----------+---------+---------
+     * no filter |    xx   |   mx
+     * ----------+---------+---------
+     * filter    |    xZ   |   mZ
+     */
+
+    TESTING("minimized dset object headers with filter message");
+
+    /*********
+     * SETUP *
+     *********/
+
+    if(h5_fixname(FILENAME[1], H5P_DEFAULT, filename, sizeof(filename)) == NULL)
+        TEST_ERROR
+
+    dcpl_mx_id = H5Pcreate(H5P_DATASET_CREATE);
+    if(dcpl_mx_id < 0) TEST_ERROR
+    ret = H5Pset_dset_no_attrs_hint(dcpl_mx_id, TRUE);
+    if(ret < 0) TEST_ERROR
+
+    dcpl_xZ_id = H5Pcreate(H5P_DATASET_CREATE);
+    if(dcpl_xZ_id < 0) TEST_ERROR
+    ret = H5Pset_chunk(dcpl_xZ_id, ndims, chunk_dim);
+    if(ret < 0) TEST_ERROR
+    ret = H5Pset_filter(dcpl_xZ_id, H5Z_FILTER_DEFLATE, H5Z_FLAG_OPTIONAL, 0, filter_values);
+    if(ret < 0) TEST_ERROR
+    dcpl_mZ_id = H5Pcreate(H5P_DATASET_CREATE);
+    if(dcpl_mZ_id < 0) TEST_ERROR
+    ret = H5Pset_dset_no_attrs_hint(dcpl_mZ_id, TRUE);
+    if(ret < 0) TEST_ERROR
+    ret = H5Pset_chunk(dcpl_mZ_id, ndims, chunk_dim);
+    if(ret < 0) TEST_ERROR
+    ret = H5Pset_filter( dcpl_mZ_id, H5Z_FILTER_DEFLATE, H5Z_FLAG_OPTIONAL, 0, filter_values);
+    if(ret < 0) TEST_ERROR
+
+    dspace_id = H5Screate_simple(1, extents, extents);
+    if(dspace_id < 0) TEST_ERROR
+
+    dtype_id = H5Tcopy(H5T_NATIVE_INT);
+    if(dtype_id < 0) TEST_ERROR
+
+    file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
+    if(file_id < 0) TEST_ERROR
+
+    dset_xx_id = H5Dcreate2(file_id, "xx", dtype_id, dspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    if(dset_xx_id < 0) TEST_ERROR
+
+    dset_mx_id = H5Dcreate2(file_id, "Mx", dtype_id, dspace_id, H5P_DEFAULT, dcpl_mx_id, H5P_DEFAULT);
+    if(dset_mx_id < 0) TEST_ERROR
+
+    dset_xZ_id = H5Dcreate2(file_id, "xZ", dtype_id, dspace_id, H5P_DEFAULT, dcpl_xZ_id, H5P_DEFAULT);
+    if(dset_xZ_id < 0) TEST_ERROR
+
+    dset_mZ_id = H5Dcreate2(file_id, "MZ", dtype_id, dspace_id, H5P_DEFAULT, dcpl_mZ_id, H5P_DEFAULT);
+    if(dset_mZ_id < 0) TEST_ERROR
+
+    /*********
+     * TESTS *
+     *********/
+
+    if(oh_compare(dset_mx_id, dset_xx_id) != LT) TEST_ERROR
+    if(oh_compare(dset_mx_id, dset_xZ_id) != LT) TEST_ERROR
+    if(oh_compare(dset_mZ_id, dset_mx_id) != GT) TEST_ERROR
+    if(oh_compare(dset_mZ_id, dset_xZ_id) != LT) TEST_ERROR
+
+    /************
+     * TEARDOWN *
+     ************/
+
+    if(H5Sclose(dspace_id) < 0) TEST_ERROR
+    if(H5Tclose(dtype_id) < 0) TEST_ERROR
+    if(H5Pclose(dcpl_xZ_id) < 0) TEST_ERROR
+    if(H5Pclose(dcpl_mx_id) < 0) TEST_ERROR
+    if(H5Pclose(dcpl_mZ_id) < 0) TEST_ERROR
+    if(H5Dclose(dset_xx_id) < 0) TEST_ERROR
+    if(H5Dclose(dset_xZ_id) < 0) TEST_ERROR
+    if(H5Dclose(dset_mx_id) < 0) TEST_ERROR
+    if(H5Dclose(dset_mZ_id) < 0) TEST_ERROR
+    if(H5Fclose(file_id) < 0) TEST_ERROR
+
+    PASSED()
+    return SUCCEED;
+
+error:
+    H5E_BEGIN_TRY {
+        (void)H5Sclose(dspace_id);
+        (void)H5Tclose(dtype_id);
+        (void)H5Pclose(dcpl_xZ_id);
+        (void)H5Pclose(dcpl_mx_id);
+        (void)H5Pclose(dcpl_mZ_id);
+        (void)H5Dclose(dset_xx_id);
+        (void)H5Dclose(dset_xZ_id);
+        (void)H5Dclose(dset_mx_id);
+        (void)H5Dclose(dset_mZ_id);
+        (void)H5Fclose(file_id);
+    } H5E_END_TRY;
+    return FAIL;
+} /* test_minimized_dset_ohdr_with_filter */
+
+/*
+ * Test minimized dataset object header and recording modification times.
+ */
+static herr_t
+test_minimized_dset_ohdr_modification_times(hid_t _fapl_id)
+{
+    /* test-local structure for parameterized testing
+     */
+    struct testcase {
+        unsigned oh_version;
+    };
+
+    char          filename[512] = "";
+    const hsize_t extents[1]    = {128}; /* extents of dataspace */
+    hid_t         dspace_id     = -1;
+    hid_t         dtype_id      = -1;
+    hid_t         dcpl_xT_id    = -1; /* Track modtime */
+    hid_t         dcpl_mx_id    = -1; /* minimized */
+    hid_t         dcpl_mT_id    = -1; /* minimized, Track */
+    hid_t         dcpl_mN_id    = -1; /* minimized, do Not track */
+    hid_t         dset_xx_id    = -1;
+    hid_t         dset_xT_id    = -1;
+    hid_t         dset_mx_id    = -1;
+    hid_t         dset_mT_id    = -1;
+    hid_t         dset_mN_id    = -1;
+    hid_t         file_id       = -1;
+    hid_t         fapl_id       = -1;
+    herr_t        ret;
+
+    unsigned i       = 0; /* for testcase loop */
+    unsigned n_cases = 2; /* must match `cases` array size below */
+    struct testcase cases[2] = {
+        { 1, }, /* version 1 object header */
+        { 2, }, /* version 2 object header */
+    };
+
+    /* dcpl suffixes:
+     *             | default | minimize
+     * ------------+---------+---------
+     * default     |    xx   |   mx
+     * ------------+---------+---------
+     * don't track |    xN   |   mN
+     * ------------+---------+---------
+     * track       |    xT   |   mT
+     */
+
+    TESTING("minimized dset object headers with modification times");
+
+    /*********
+     * SETUP *
+     *********/
+
+    if(h5_fixname(FILENAME[1], H5P_DEFAULT, filename, sizeof(filename)) == NULL)
+        TEST_ERROR
+
+    dcpl_mx_id = H5Pcreate(H5P_DATASET_CREATE);
+    if(dcpl_mx_id < 0) TEST_ERROR
+    ret = H5Pset_dset_no_attrs_hint(dcpl_mx_id, TRUE);
+    if(ret < 0) TEST_ERROR
+
+    dcpl_xT_id = H5Pcreate(H5P_DATASET_CREATE);
+    if(dcpl_xT_id < 0) TEST_ERROR
+    ret = H5Pset_obj_track_times(dcpl_xT_id, TRUE);
+    if(ret < 0) TEST_ERROR
+
+    dcpl_mT_id = H5Pcreate(H5P_DATASET_CREATE);
+    if(dcpl_mT_id < 0) TEST_ERROR
+    ret = H5Pset_dset_no_attrs_hint(dcpl_mT_id, TRUE);
+    if(ret < 0) TEST_ERROR
+    ret = H5Pset_obj_track_times(dcpl_mT_id, TRUE);
+    if(ret < 0) TEST_ERROR
+
+    dcpl_mN_id = H5Pcreate(H5P_DATASET_CREATE);
+    if(dcpl_mN_id < 0) TEST_ERROR
+    ret = H5Pset_dset_no_attrs_hint(dcpl_mN_id, TRUE);
+    if(ret < 0) TEST_ERROR
+    ret = H5Pset_obj_track_times(dcpl_mN_id, FALSE);
+    if(ret < 0) TEST_ERROR
+
+    dspace_id = H5Screate_simple(1, extents, extents);
+    if(dspace_id < 0) TEST_ERROR
+
+    dtype_id = H5Tcopy(H5T_NATIVE_INT);
+    if(dtype_id < 0) TEST_ERROR
+
+    for (i = 0; i < n_cases; i++) {
+
+        /* -------------- *
+         * per-case setup *
+         * -------------- */
+
+        fapl_id = H5Pcopy(_fapl_id);
+        if(fapl_id < 0) TEST_ERROR
+
+        if(cases[i].oh_version > 1) {
+            fapl_id = H5Pcreate(H5P_FILE_ACCESS);
+            if(fapl_id < 0) TEST_ERROR
+            ret = H5Pset_libver_bounds(fapl_id, H5F_LIBVER_V18, H5F_LIBVER_V110);
+            if(ret < 0) TEST_ERROR
+        }
+
+        file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
+        if(file_id < 0) TEST_ERROR
+
+        dset_xx_id = H5Dcreate2( file_id, "xx", dtype_id, dspace_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+        if(dset_xx_id < 0) TEST_ERROR
+
+        dset_mx_id = H5Dcreate2(file_id, "mx", dtype_id, dspace_id, H5P_DEFAULT, dcpl_mx_id, H5P_DEFAULT);
+        if(dset_mx_id < 0) TEST_ERROR
+
+        dset_xT_id = H5Dcreate2(file_id, "xT", dtype_id, dspace_id, H5P_DEFAULT, dcpl_xT_id, H5P_DEFAULT);
+        if(dset_xT_id < 0) TEST_ERROR
+        dset_mT_id = H5Dcreate2(file_id, "mT", dtype_id, dspace_id, H5P_DEFAULT, dcpl_mT_id, H5P_DEFAULT);
+        if(dset_mT_id < 0) TEST_ERROR
+
+        dset_mN_id = H5Dcreate2(file_id, "mN", dtype_id, dspace_id, H5P_DEFAULT, dcpl_mN_id, H5P_DEFAULT);
+        if(dset_mN_id < 0) TEST_ERROR
+
+        /* ----- *
+         * TESTS *
+         * ----- */
+
+        /* sanity check */
+        if(oh_compare(dset_mx_id, dset_xx_id) != LT) TEST_ERROR
+        if(oh_compare(dset_mx_id, dset_xT_id) != LT) TEST_ERROR
+
+        if(oh_compare(dset_xx_id, dset_xT_id) != EQ) TEST_ERROR
+        if(oh_compare(dset_mx_id, dset_mT_id) != EQ) TEST_ERROR
+        if(oh_compare(dset_mN_id, dset_mT_id) != LT) TEST_ERROR
+
+        if(oh_compare(dset_mT_id, dset_xT_id) != LT) TEST_ERROR
+
+        /* ----------------- *
+         * per-case teardown *
+         * ----------------- */
+
+        if(H5Dclose(dset_xx_id) < 0) TEST_ERROR
+        if(H5Dclose(dset_xT_id) < 0) TEST_ERROR
+        if(H5Dclose(dset_mx_id) < 0) TEST_ERROR
+        if(H5Dclose(dset_mT_id) < 0) TEST_ERROR
+        if(H5Dclose(dset_mN_id) < 0) TEST_ERROR
+        if(H5Fclose(file_id) < 0) TEST_ERROR
+        if(H5Pclose(fapl_id) < 0) TEST_ERROR
+
+    } /* for each version tested */
+
+    /************
+     * TEARDOWN *
+     ************/
+
+    if(H5Sclose(dspace_id) < 0) TEST_ERROR
+    if(H5Tclose(dtype_id) < 0) TEST_ERROR
+    if(H5Pclose(dcpl_xT_id) < 0) TEST_ERROR
+    if(H5Pclose(dcpl_mx_id) < 0) TEST_ERROR
+    if(H5Pclose(dcpl_mT_id) < 0) TEST_ERROR
+    if(H5Pclose(dcpl_mN_id) < 0) TEST_ERROR
+
+    PASSED()
+    return SUCCEED;
+
+error:
+    H5E_BEGIN_TRY {
+        (void)H5Sclose(dspace_id);
+        (void)H5Tclose(dtype_id);
+        (void)H5Pclose(dcpl_xT_id);
+        (void)H5Pclose(dcpl_mx_id);
+        (void)H5Pclose(dcpl_mT_id);
+        (void)H5Pclose(dcpl_mN_id);
+        (void)H5Dclose(dset_xx_id);
+        (void)H5Dclose(dset_xT_id);
+        (void)H5Dclose(dset_mx_id);
+        (void)H5Dclose(dset_mT_id);
+        (void)H5Dclose(dset_mN_id);
+        (void)H5Fclose(file_id);
+        (void)H5Pclose(fapl_id);
+    } H5E_END_TRY;
+    return FAIL;
+} /* test_minimized_dset_ohdr_modification_times */
+
+/*
+ * Test minimized dataset object header with a fill value set.
+ */
+static herr_t
+test_minimized_dset_ohdr_fillvalue_backwards_compatability(hid_t _fapl_id)
+{
+    char          filename[512] = "";
+    const hsize_t extents[1]    = {64}; /* extents of dataspace */
+    const int     fill[1]       = {343}; /* fill value of dataset */
+    hid_t         file_id       = -1;
+    hid_t         dtype_id      = -1;
+    hid_t         dspace_id     = -1;
+    hid_t         dcpl_id       = -1;
+    hid_t         fapl_id       = -1;
+    hid_t         dset_0_id     = -1;
+    hid_t         dset_1_id     = -1;
+    herr_t        ret;
+
+    /*********
+     * SETUP *
+     *********/
+
+    TESTING("minimized dset object headers with fill values and different libver support");
+
+    if(h5_fixname(FILENAME[1], H5P_DEFAULT, filename, sizeof(filename)) == NULL)
+        TEST_ERROR
+
+    dspace_id = H5Screate_simple(1, extents, extents);
+    if(dspace_id < 0) TEST_ERROR
+
+    dtype_id = H5Tcopy(H5T_NATIVE_INT);
+    if(dtype_id < 0) TEST_ERROR
+
+    dcpl_id = H5Pcreate(H5P_DATASET_CREATE);
+    if(dcpl_id < 0) TEST_ERROR
+
+    ret = H5Pset_dset_no_attrs_hint(dcpl_id, TRUE);
+    if(ret == FAIL) TEST_ERROR;
+
+    ret = H5Pset_fill_value(dcpl_id, dtype_id, fill);
+    if(ret == FAIL) TEST_ERROR;
+
+    fapl_id = H5Pcopy(_fapl_id);
+    if(fapl_id < 0) TEST_ERROR
+
+    ret = H5Pset_libver_bounds(fapl_id, H5F_LIBVER_EARLIEST, H5F_LIBVER_LATEST);
+    if(ret == FAIL) TEST_ERROR;
+
+    file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id);
+    if(file_id < 0) TEST_ERROR
+
+    dset_0_id = H5Dcreate2(file_id, "fullrange", dtype_id, dspace_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT);
+    if(dset_0_id < 0) TEST_ERROR
+
+    /* Close file and re-open with different libver bounds.
+     * Dataset "fullrange" must also be closed for expected reopen behavior.
+     */
+    if(H5Fclose(file_id) < 0) TEST_ERROR;
+    if(H5Dclose(dset_0_id) < 0) TEST_ERROR
+
+    ret = H5Pset_libver_bounds(fapl_id, H5F_LIBVER_V18, H5F_LIBVER_LATEST);
+    if(ret == FAIL) TEST_ERROR;
+
+    file_id = H5Fopen(filename, H5F_ACC_RDWR, fapl_id);
+    if(file_id < 0) TEST_ERROR
+
+    dset_1_id = H5Dcreate2(file_id, "upperrange", dtype_id, dspace_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT);
+    if(dset_1_id < 0) TEST_ERROR
+
+    /* re-open "fullrange" dataset
+     */
+     dset_0_id = H5Dopen2(file_id, "fullrange", H5P_DEFAULT);
+     if(dset_0_id < 0) TEST_ERROR
+
+    /*********
+     * TESTS *
+     *********/
+
+    /* dset not supporting pre-1.08 should be smaller? */
+    if(oh_compare(dset_1_id, dset_0_id) != LT) TEST_ERROR
+
+    /************
+     * TEARDOWN *
+     ************/
+
+    if(H5Sclose(dspace_id) < 0) TEST_ERROR
+    if(H5Tclose(dtype_id) < 0) TEST_ERROR
+    if(H5Pclose(dcpl_id) < 0) TEST_ERROR
+    if(H5Pclose(fapl_id) < 0) TEST_ERROR
+    if(H5Dclose(dset_0_id) < 0) TEST_ERROR
+    if(H5Dclose(dset_1_id) < 0) TEST_ERROR
+    if(H5Fclose(file_id) < 0) TEST_ERROR;
+
+    PASSED()
+    return SUCCEED;
+
+error:
+    H5E_BEGIN_TRY {
+        (void)H5Sclose(dspace_id);
+        (void)H5Tclose(dtype_id);
+        (void)H5Pclose(dcpl_id);
+        (void)H5Pclose(fapl_id);
+        (void)H5Dclose(dset_0_id);
+        (void)H5Dclose(dset_1_id);
+        (void)H5Fclose(file_id);
+    } H5E_END_TRY;
+    return FAIL;
+} /* test_minimized_dset_ohdr_fillvalue_backwards_compatability */
+
+/*
  *  Verify that messages are moved forward into a "continuation message":
  *    Create an object header with several continuation chunks
  *    Remove a message in the last chunk
@@ -1033,6 +1919,21 @@ main(void)
         if(test_ohdr_cache(filename, fapl) < 0)
             TEST_ERROR
 
+        if(test_minimized_dset_ohdr_attribute_addition(fapl) < 0)
+            TEST_ERROR
+
+        if(test_minimized_dset_ohdr_size_comparisons(fapl) < 0)
+            TEST_ERROR
+
+        if(test_minimized_dset_ohdr_with_filter(fapl) < 0)
+            TEST_ERROR
+
+        if(test_minimized_dset_ohdr_modification_times(fapl) < 0)
+            TEST_ERROR
+
+        if(test_minimized_dset_ohdr_fillvalue_backwards_compatability(fapl) < 0)
+            TEST_ERROR
+
       } /* high */
     } /* low */
 
diff --git a/test/tattr.c b/test/tattr.c
index 4358d4c..9b6ae90 100644
--- a/test/tattr.c
+++ b/test/tattr.c
@@ -157,6 +157,12 @@ typedef struct {
 static herr_t attr_op1(hid_t loc_id, const char *name, const H5A_info_t *ainfo,
     void *op_data);
 
+/* Global dcpl ID, can be re-set as a generated dcpl for various operations
+ * across multiple tests.
+ * e.g., minimized dataset object headers
+ */
+static hid_t dcpl_g = H5P_DEFAULT;
+
 
 
 /****************************************************************
@@ -196,7 +202,7 @@ test_attr_basic_write(hid_t fapl)
     CHECK(sid1, FAIL, "H5Screate_simple");
 
     /* Create a dataset */
-    dataset = H5Dcreate2(fid1, DSET1_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    dataset = H5Dcreate2(fid1, DSET1_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, dcpl_g, H5P_DEFAULT);
     CHECK(dataset, FAIL, "H5Dcreate2");
 
     /* Create dataspace for attribute */
@@ -516,7 +522,7 @@ test_attr_flush(hid_t fapl)
     spc = H5Screate(H5S_SCALAR);
     CHECK(spc, FAIL, "H5Screate");
 
-    set = H5Dcreate2(fil, DSET1_NAME, H5T_NATIVE_DOUBLE, spc, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    set = H5Dcreate2(fil, DSET1_NAME, H5T_NATIVE_DOUBLE, spc, H5P_DEFAULT, dcpl_g, H5P_DEFAULT);
     CHECK(set, FAIL, "H5Dcreate2");
 
     att = H5Acreate2(set, ATTR1_NAME, H5T_NATIVE_DOUBLE, spc, H5P_DEFAULT, H5P_DEFAULT);
@@ -587,7 +593,7 @@ test_attr_plist(hid_t fapl)
     CHECK(sid1, FAIL, "H5Screate_simple");
 
     /* Create a dataset */
-    dataset = H5Dcreate2(fid1, DSET1_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    dataset = H5Dcreate2(fid1, DSET1_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, dcpl_g, H5P_DEFAULT);
     CHECK(dataset, FAIL, "H5Dcreate2");
 
     /* Create dataspace for attribute */
@@ -701,7 +707,7 @@ test_attr_compound_write(hid_t fapl)
     CHECK(sid1, FAIL, "H5Screate_simple");
 
     /* Create a dataset */
-    dataset = H5Dcreate2(fid1, DSET1_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    dataset = H5Dcreate2(fid1, DSET1_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, dcpl_g, H5P_DEFAULT);
     CHECK(dataset, FAIL, "H5Dcreate2");
 
     /* Close dataset's dataspace */
@@ -937,7 +943,7 @@ test_attr_scalar_write(hid_t fapl)
     CHECK(sid1, FAIL, "H5Screate_simple");
 
     /* Create a dataset */
-    dataset = H5Dcreate2(fid1, DSET1_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    dataset = H5Dcreate2(fid1, DSET1_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, dcpl_g, H5P_DEFAULT);
     CHECK(dataset, FAIL, "H5Dcreate2");
 
     /* Create dataspace for attribute */
@@ -1078,7 +1084,7 @@ test_attr_mult_write(hid_t fapl)
     CHECK(sid1, FAIL, "H5Screate_simple");
 
     /* Create a dataset */
-    dataset = H5Dcreate2(fid1, DSET1_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    dataset = H5Dcreate2(fid1, DSET1_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT, dcpl_g, H5P_DEFAULT);
     CHECK(dataset, FAIL, "H5Dcreate2");
 
     /* Close dataset's dataspace */
@@ -1456,7 +1462,7 @@ test_attr_iterate(hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Create a new dataset */
-    dataset = H5Dcreate2(file, DSET2_NAME, H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    dataset = H5Dcreate2(file, DSET2_NAME, H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl_g, H5P_DEFAULT);
     CHECK(dataset, FAIL, "H5Dcreate2");
 
     /* Close dataspace */
@@ -1681,7 +1687,7 @@ test_attr_dtype_shared(hid_t fapl)
     CHECK(space_id, FAIL, "H5Screate");
 
     /* Create dataset */
-    dset_id = H5Dcreate2(file_id, DSET1_NAME, type_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    dset_id = H5Dcreate2(file_id, DSET1_NAME, type_id, space_id, H5P_DEFAULT, dcpl_g, H5P_DEFAULT);
     CHECK(dset_id, FAIL, "H5Dcreate2");
 
     /* Check reference count on named datatype */
@@ -1835,7 +1841,7 @@ test_attr_duplicate_ids(hid_t fapl)
 
     /* Create a dataset */
     dataset = H5Dcreate2(fid1, DSET1_NAME, H5T_NATIVE_UCHAR, sid1, H5P_DEFAULT,
-            H5P_DEFAULT, H5P_DEFAULT);
+            dcpl_g, H5P_DEFAULT);
     CHECK(dataset, FAIL, "H5Dcreate2");
 
     /* Create dataspace for attribute */
@@ -2161,7 +2167,7 @@ test_attr_dense_create(hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Query the group creation properties */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Create a dataset */
@@ -2292,7 +2298,7 @@ test_attr_dense_open(hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Query the group creation properties */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Enable creation order tracking on attributes, so creation order tests work */
@@ -2405,14 +2411,27 @@ test_attr_dense_delete(hid_t fcpl, hid_t fapl)
     h5_stat_size_t empty_filesize;       /* Size of empty file */
     h5_stat_size_t filesize;             /* Size of file after modifications */
     H5O_info_t  oinfo;          /* Object info                  */
+    int         use_min_dset_oh = (dcpl_g != H5P_DEFAULT);
     herr_t      ret;            /* Generic return value        */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Deleting Attributes in Dense Storage\n"));
 
     /* Create file */
+    if (use_min_dset_oh) { /* using minimized dataset headers */
+        /* modify fcpl...
+         * sidestep "bug" where file space is lost with minimized dset ohdrs
+         */
+        fcpl = H5Pcopy(fcpl);
+        CHECK(fcpl, FAIL, "H5Pcopy");
+        ret = H5Pset_file_space_strategy(fcpl, H5F_FSPACE_STRATEGY_FSM_AGGR, TRUE, 1);
+        CHECK(ret, FAIL, "H5Pset_file_space_strategy");
+    }
     fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl, fapl);
     CHECK(fid, FAIL, "H5Fcreate");
+    if (use_min_dset_oh)
+        CHECK(H5Pclose(fcpl), FAIL, "H5Pclose");
+
 
     /* Close file */
     ret = H5Fclose(fid);
@@ -2432,7 +2451,7 @@ test_attr_dense_delete(hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Query the group creation properties */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (use_min_dset_oh) ? H5Pcopy(dcpl_g) : H5Pcreate(H5P_DATASET_CREATE);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Enable creation order tracking on attributes, so creation order tests work */
@@ -2584,14 +2603,26 @@ test_attr_dense_rename(hid_t fcpl, hid_t fapl)
     h5_stat_size_t filesize;             /* Size of file after modifications */
     H5O_info_t  oinfo;          /* Object info */
     unsigned    u;              /* Local index variable */
+    int         use_min_dset_oh = (dcpl_g != H5P_DEFAULT);
     herr_t      ret;            /* Generic return value        */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Renaming Attributes in Dense Storage\n"));
 
     /* Create file */
+    if (use_min_dset_oh) { /* using minimized dataset headers */
+        /* modify fcpl...
+         * sidestep "bug" where file space is lost with minimized dset ohdrs
+         */
+        fcpl = H5Pcopy(fcpl);
+        CHECK(fcpl, FAIL, "H5Pcopy");
+        ret = H5Pset_file_space_strategy(fcpl, H5F_FSPACE_STRATEGY_FSM_AGGR, TRUE, 1);
+        CHECK(ret, FAIL, "H5Pset_file_space_strategy");
+    }
     fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl, fapl);
     CHECK(fid, FAIL, "H5Fcreate");
+    if (use_min_dset_oh)
+        CHECK(H5Pclose(fcpl), FAIL, "H5Pclose");
 
     /* Close file */
     ret = H5Fclose(fid);
@@ -2611,7 +2642,7 @@ test_attr_dense_rename(hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Query the group creation properties */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (use_min_dset_oh) ? H5Pcopy(dcpl_g) : H5Pcreate(H5P_DATASET_CREATE);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Create a dataset */
@@ -2743,14 +2774,26 @@ test_attr_dense_unlink(hid_t fcpl, hid_t fapl)
     h5_stat_size_t filesize;             /* Size of file after modifications */
     H5O_info_t  oinfo;          /* Object info */
     unsigned    u;              /* Local index variable */
+    int         use_min_dset_oh = (dcpl_g != H5P_DEFAULT);
     herr_t      ret;            /* Generic return value        */
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Unlinking Object with Attributes in Dense Storage\n"));
 
     /* Create file */
-    fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl, fapl);
-    CHECK(fid, FAIL, "H5Fcreate");
+    if (use_min_dset_oh) { /* using minimized dataset headers */
+        /* modify fcpl...
+         * sidestep "bug" where file space is lost with minimized dset ohdrs
+         */
+        fcpl = H5Pcopy(fcpl);
+        CHECK(fcpl, FAIL, "H5Pcopy");
+        ret = H5Pset_file_space_strategy(fcpl, H5F_FSPACE_STRATEGY_FSM_AGGR, TRUE, 1);
+        CHECK(ret, FAIL, "H5Pset_file_space_strategy");
+    }
+     fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl, fapl);
+     CHECK(fid, FAIL, "H5Fcreate");
+    if (use_min_dset_oh)
+        CHECK(H5Pclose(fcpl), FAIL, "H5Pclose");
 
     /* Close file */
     ret = H5Fclose(fid);
@@ -2770,7 +2813,7 @@ test_attr_dense_unlink(hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Query the group creation properties */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (use_min_dset_oh) ? H5Pcopy(dcpl_g) : H5Pcreate(H5P_DATASET_CREATE);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Create a dataset */
@@ -2898,7 +2941,7 @@ test_attr_dense_limits(hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Query the group creation properties */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Change limits on compact/dense attribute storage */
@@ -3065,7 +3108,7 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Query the group creation properties */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Create a dataset */
@@ -3595,7 +3638,7 @@ test_attr_big(hid_t fcpl, hid_t fapl)
     CHECK(big_sid, FAIL, "H5Screate_simple");
 
     /* Query the group creation properties */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Retrieve limits for compact/dense attribute storage */
@@ -3861,7 +3904,7 @@ test_attr_null_space(hid_t fcpl, hid_t fapl)
     CHECK(null_sid, FAIL, "H5Screate");
 
     /* Create a dataset */
-    dataset = H5Dcreate2(fid, DSET1_NAME, H5T_NATIVE_UCHAR, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    dataset = H5Dcreate2(fid, DSET1_NAME, H5T_NATIVE_UCHAR, sid, H5P_DEFAULT, dcpl_g, H5P_DEFAULT);
     CHECK(dataset, FAIL, "H5Dcreate2");
 
 
@@ -4054,7 +4097,7 @@ test_attr_deprec(hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Create a dataset */
-    dataset = H5Dcreate2(fid, DSET1_NAME, H5T_NATIVE_UCHAR, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    dataset = H5Dcreate2(fid, DSET1_NAME, H5T_NATIVE_UCHAR, sid, H5P_DEFAULT, dcpl_g, H5P_DEFAULT);
     CHECK(dataset, FAIL, "H5Dcreate2");
 
 
@@ -4290,7 +4333,7 @@ test_attr_corder_create_basic(hid_t fcpl, hid_t fapl)
     CHECK(fid, FAIL, "H5Fcreate");
 
     /* Create dataset creation property list */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Get creation order indexing on object */
@@ -4413,7 +4456,7 @@ test_attr_corder_create_compact(hid_t fcpl, hid_t fapl)
     CHECK(fid, FAIL, "H5Fcreate");
 
     /* Create dataset creation property list */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Set attribute creation order tracking & indexing for object */
@@ -4613,7 +4656,7 @@ test_attr_corder_create_dense(hid_t fcpl, hid_t fapl)
     CHECK(fid, FAIL, "H5Fcreate");
 
     /* Create dataset creation property list */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Set attribute creation order tracking & indexing for object */
@@ -4948,7 +4991,7 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl)
     CHECK(fid, FAIL, "H5Fcreate");
 
     /* Create dataset creation property list */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Set attribute creation order tracking & indexing for object */
@@ -5359,7 +5402,7 @@ test_attr_corder_delete(hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Create dataset creation property list */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Set attribute creation order tracking & indexing for object */
@@ -5702,7 +5745,7 @@ test_attr_info_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Create dataset creation property list */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Query the attribute creation properties */
@@ -5914,7 +5957,7 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Create dataset creation property list */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Query the attribute creation properties */
@@ -6857,7 +6900,7 @@ test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Create dataset creation property list */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Query the attribute creation properties */
@@ -7218,7 +7261,7 @@ test_attr_open_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Create dataset creation property list */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Query the attribute creation properties */
@@ -7565,7 +7608,7 @@ test_attr_open_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Create dataset creation property list */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Query the attribute creation properties */
@@ -7819,7 +7862,7 @@ test_attr_create_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl)
     CHECK(sid, FAIL, "H5Screate");
 
     /* Create dataset creation property list */
-    dcpl = H5Pcreate(H5P_DATASET_CREATE);
+    dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
     CHECK(dcpl, FAIL, "H5Pcreate");
 
     /* Query the attribute creation properties */
@@ -8120,7 +8163,7 @@ test_attr_shared_write(hid_t fcpl, hid_t fapl)
         } /* end if */
 
         /* Set up to query the object creation properties */
-        dcpl = H5Pcreate(H5P_DATASET_CREATE);
+        dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
         CHECK(dcpl, FAIL, "H5Pcreate");
 
         /* Create datasets */
@@ -8451,7 +8494,7 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl)
         } /* end if */
 
         /* Set up to query the object creation properties */
-        dcpl = H5Pcreate(H5P_DATASET_CREATE);
+        dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
         CHECK(dcpl, FAIL, "H5Pcreate");
 
         /* Create datasets */
@@ -8897,7 +8940,7 @@ test_attr_shared_delete(hid_t fcpl, hid_t fapl)
         } /* end if */
 
         /* Set up to query the object creation properties */
-        dcpl = H5Pcreate(H5P_DATASET_CREATE);
+        dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
         CHECK(dcpl, FAIL, "H5Pcreate");
 
         /* Create datasets */
@@ -9266,7 +9309,7 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl)
         } /* end if */
 
         /* Set up to query the object creation properties */
-        dcpl = H5Pcreate(H5P_DATASET_CREATE);
+        dcpl = (dcpl_g == H5P_DEFAULT) ? H5Pcreate(H5P_DATASET_CREATE) : H5Pcopy(dcpl_g);
         CHECK(dcpl, FAIL, "H5Pcreate");
 
         /* Create datasets */
@@ -9858,7 +9901,7 @@ test_attr_bug3(hid_t fcpl, hid_t fapl)
     CHECK(ret, FAIL, "H5Tcommit2");
 
     /* Create dataset */
-    did = H5Dcreate2(fid, "dset", tid2, sid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    did = H5Dcreate2(fid, "dset", tid2, sid2, H5P_DEFAULT, dcpl_g, H5P_DEFAULT);
     CHECK(did, FAIL, "H5Dcreate2");
 
     /* Create attribute on datatype, using that datatype as its datatype */
@@ -9993,7 +10036,7 @@ test_attr_bug4(hid_t fcpl, hid_t fapl)
     CHECK(ret, FAIL, "H5Tcommit2");
 
     /* Create dataset */
-    did = H5Dcreate2(fid, "dset", tid, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    did = H5Dcreate2(fid, "dset", tid, sid, H5P_DEFAULT, dcpl_g, H5P_DEFAULT);
     CHECK(did, FAIL, "H5Dcreate2");
 
     /* Create attributes on group and dataset */
@@ -10075,7 +10118,7 @@ test_attr_bug5(hid_t fcpl, hid_t fapl)
     CHECK(ret, FAIL, "H5Tcommit2");
 
     /* Create dataset */
-    did1 = H5Dcreate2(fid1, BUG3_DSET_NAME, tid1, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    did1 = H5Dcreate2(fid1, BUG3_DSET_NAME, tid1, sid, H5P_DEFAULT, dcpl_g, H5P_DEFAULT);
     CHECK(did1, FAIL, "H5Dcreate2");
 
     /* Create attribute on root group */
@@ -10773,119 +10816,106 @@ test_attr(void)
 {
     hid_t    fapl = (-1), fapl2 = (-1);    /* File access property lists */
     hid_t    fcpl = (-1), fcpl2 = (-1);    /* File creation property lists */
+    hid_t    dcpl = -1;         /* Dataset creation property list */
     unsigned new_format;        /* Whether to use the new format or not */
     unsigned use_shared;        /* Whether to use shared attributes or not */
+    unsigned minimize_dset_oh;  /* Whether to use minimized dataset object headers */
     herr_t ret;                 /* Generic return value */
 
-    /* Output message about test being performed */
     MESSAGE(5, ("Testing Attributes\n"));
 
-    /* Create a default file access property list */
     fapl = H5Pcreate(H5P_FILE_ACCESS);
     CHECK(fapl, FAIL, "H5Pcreate");
 
-    /* Copy the file access property list */
+    /* fapl2 uses "latest version of the format" for creating objects in the file */
     fapl2 = H5Pcopy(fapl);
     CHECK(fapl2, FAIL, "H5Pcopy");
-
-    /* Set the "use the latest version of the format" bounds for creating objects in the file */
     ret = H5Pset_libver_bounds(fapl2, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST);
     CHECK(ret, FAIL, "H5Pset_libver_bounds");
 
-    /* Create a default file creation property list */
     fcpl = H5Pcreate(H5P_FILE_CREATE);
     CHECK(fcpl, FAIL, "H5Pcreate");
 
-    /* Copy the file creation property list */
+    /* files with fcpl make all attributes (> 1 byte) shared
+     * i.e., all of them :-)
+     */
     fcpl2 = H5Pcopy(fcpl);
     CHECK(fcpl2, FAIL, "H5Pcopy");
-
-    /* Make attributes > 1 byte shared (i.e. all of them :-) */
     ret = H5Pset_shared_mesg_nindexes(fcpl2, (unsigned)1);
     CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
     ret = H5Pset_shared_mesg_index(fcpl2, (unsigned)0, H5O_SHMESG_ATTR_FLAG, (unsigned)1);
     CHECK_I(ret, "H5Pset_shared_mesg_index");
 
-    /* Loop over using new group format */
-    for(new_format = FALSE; new_format <= TRUE; new_format++) {
-        hid_t my_fapl;
-
-        /* Set the FAPL for the type of format */
-        if(new_format) {
-            MESSAGE(7, ("testing with new file format\n"));
-            my_fapl = fapl2;
-        } /* end if */
-        else {
-            MESSAGE(7, ("testing with old file format\n"));
-            my_fapl = fapl;
-        } /* end else */
+    for(minimize_dset_oh = 0; minimize_dset_oh <= 1; minimize_dset_oh++) {
+        if(minimize_dset_oh == 0) {
+            MESSAGE(7, ("testing with default dataset object headers\n"));
+            dcpl_g = H5P_DEFAULT;
+        } else {
+            MESSAGE(7, ("testing with minimzied dataset object headers\n"));
+            dcpl = H5Pcreate(H5P_DATASET_CREATE);
+            CHECK(dcpl, FAIL, "H5Pcreate");
+            ret = H5Pset_dset_no_attrs_hint(dcpl, TRUE);
+            CHECK_I(ret, "H5Pset_dset_no_attrs_hint");
+            dcpl_g = dcpl;
+        }
+
+        for(new_format = FALSE; new_format <= TRUE; new_format++) {
+            hid_t my_fapl;
+
+            /* Set the FAPL for the type of format */
+            if(new_format) {
+                MESSAGE(7, ("testing with new file format\n"));
+                my_fapl = fapl2;
+            } /* end if */
+            else {
+                MESSAGE(7, ("testing with old file format\n"));
+                my_fapl = fapl;
+            } /* end else */
 
-        /* These next two tests use the same file information */
-        test_attr_basic_write(my_fapl);    /* Test basic H5A writing code */
-        test_attr_basic_read(my_fapl);     /* Test basic H5A reading code */
+            /* These next two tests use the same file information */
+            test_attr_basic_write(my_fapl);    /* Test basic H5A writing code */
+            test_attr_basic_read(my_fapl);     /* Test basic H5A reading code */
 
-        /* These next two tests use their own file information */
-        test_attr_flush(my_fapl);          /* Test H5A I/O in the presence of H5Fflush calls */
-        test_attr_plist(my_fapl);          /* Test attribute property lists */
+            /* These next two tests use their own file information */
+            test_attr_flush(my_fapl);          /* Test H5A I/O in the presence of H5Fflush calls */
+            test_attr_plist(my_fapl);          /* Test attribute property lists */
 
-        /* These next two tests use the same file information */
-        test_attr_compound_write(my_fapl);  /* Test complex datatype H5A writing code */
-        test_attr_compound_read(my_fapl);   /* Test complex datatype H5A reading code */
+            /* These next two tests use the same file information */
+            test_attr_compound_write(my_fapl);  /* Test complex datatype H5A writing code */
+            test_attr_compound_read(my_fapl);   /* Test complex datatype H5A reading code */
 
-        /* These next two tests use the same file information */
-        test_attr_scalar_write(my_fapl);  /* Test scalar dataspace H5A writing code */
-        test_attr_scalar_read(my_fapl);   /* Test scalar dataspace H5A reading code */
+            /* These next two tests use the same file information */
+            test_attr_scalar_write(my_fapl);  /* Test scalar dataspace H5A writing code */
+            test_attr_scalar_read(my_fapl);   /* Test scalar dataspace H5A reading code */
 
-        /* These next four tests use the same file information */
-        test_attr_mult_write(my_fapl);     /* Test H5A writing code for multiple attributes */
-        test_attr_mult_read(my_fapl);      /* Test H5A reading code for multiple attributes */
-        test_attr_iterate(my_fapl);        /* Test H5A iterator code */
-        test_attr_delete(my_fapl);         /* Test H5A code for deleting attributes */
+            /* These next four tests use the same file information */
+            test_attr_mult_write(my_fapl);     /* Test H5A writing code for multiple attributes */
+            test_attr_mult_read(my_fapl);      /* Test H5A reading code for multiple attributes */
+            test_attr_iterate(my_fapl);        /* Test H5A iterator code */
+            test_attr_delete(my_fapl);         /* Test H5A code for deleting attributes */
 
-        /* This next test uses its own file information */
-        test_attr_dtype_shared(my_fapl);   /* Test using shared dataypes in attributes */
+            /* This next test uses its own file information */
+            test_attr_dtype_shared(my_fapl);   /* Test using shared dataypes in attributes */
 
-        /* This next test uses its own file information */
-        test_attr_duplicate_ids(my_fapl);
+            /* This next test uses its own file information */
+            test_attr_duplicate_ids(my_fapl);
 
-        /* Tests on "new format" attribute storage */
-        if(new_format == TRUE) {
-            /* Loop over using shared attributes */
             for(use_shared = FALSE; use_shared <= TRUE; use_shared++) {
                 hid_t my_fcpl;
 
-                /* Set the FCPL for shared or not */
-                if(use_shared) {
+                if(new_format == TRUE && use_shared) {
                     MESSAGE(7, ("testing with shared attributes\n"));
                     my_fcpl = fcpl2;
-                } /* end if */
-                else {
+                } else {
                     MESSAGE(7, ("testing without shared attributes\n"));
                     my_fcpl = fcpl;
-                } /* end else */
-
-                /* General attribute tests */
-                test_attr_dense_create(my_fcpl, my_fapl);       /* Test dense attribute storage creation */
-                test_attr_dense_open(my_fcpl, my_fapl);         /* Test opening attributes in dense storage */
-                test_attr_dense_delete(my_fcpl, my_fapl);       /* Test deleting attributes in dense storage */
-                test_attr_dense_rename(my_fcpl, my_fapl);       /* Test renaming attributes in dense storage */
-                test_attr_dense_unlink(my_fcpl, my_fapl);       /* Test unlinking object with attributes in dense storage */
-                test_attr_dense_limits(my_fcpl, my_fapl);       /* Test dense attribute storage limits */
-                test_attr_dense_dup_ids(my_fcpl, my_fapl);      /* Test duplicated IDs for dense attribute storage */
+                }
 
                 test_attr_big(my_fcpl, my_fapl);                /* Test storing big attribute */
                 test_attr_null_space(my_fcpl, my_fapl);         /* Test storing attribute with NULL dataspace */
                 test_attr_deprec(fcpl, my_fapl);                /* Test deprecated API routines */
                 test_attr_many(new_format, my_fcpl, my_fapl);               /* Test storing lots of attributes */
 
-                /* Attribute creation order tests */
-                test_attr_corder_create_basic(my_fcpl, my_fapl);/* Test creating an object w/attribute creation order info */
-                test_attr_corder_create_compact(my_fcpl, my_fapl);  /* Test compact attribute storage on an object w/attribute creation order info */
-                test_attr_corder_create_dense(my_fcpl, my_fapl);/* Test dense attribute storage on an object w/attribute creation order info */
-                test_attr_corder_create_reopen(my_fcpl, my_fapl);/* Test creating attributes w/reopening file from using new format to using old format */
-                test_attr_corder_transition(my_fcpl, my_fapl);  /* Test attribute storage transitions on an object w/attribute creation order info */
-                test_attr_corder_delete(my_fcpl, my_fapl);      /* Test deleting object using dense storage w/attribute creation order info */
-
                 /* New attribute API routine tests */
                 test_attr_info_by_idx(new_format, my_fcpl, my_fapl);    /* Test querying attribute info by index */
                 test_attr_delete_by_idx(new_format, my_fcpl, my_fapl);  /* Test deleting attribute by index */
@@ -10894,14 +10924,6 @@ test_attr(void)
                 test_attr_open_by_name(new_format, my_fcpl, my_fapl);   /* Test opening attributes by name */
                 test_attr_create_by_name(new_format, my_fcpl, my_fapl); /* Test creating attributes by name */
 
-                /* More complex tests with both "new format" and "shared" attributes */
-                if(use_shared == TRUE) {
-                    test_attr_shared_write(my_fcpl, my_fapl);   /* Test writing to shared attributes in compact & dense storage */
-                    test_attr_shared_rename(my_fcpl, my_fapl);  /* Test renaming shared attributes in compact & dense storage */
-                    test_attr_shared_delete(my_fcpl, my_fapl);  /* Test deleting shared attributes in compact & dense storage */
-                    test_attr_shared_unlink(my_fcpl, my_fapl);  /* Test unlinking object with shared attributes in compact & dense storage */
-                } /* end if */
-
                 /* Tests that address specific bugs */
                 test_attr_bug1(my_fcpl, my_fapl);               /* Test odd allocation operations */
                 test_attr_bug2(my_fcpl, my_fapl);               /* Test many deleted attributes */
@@ -10909,41 +10931,57 @@ test_attr(void)
                 test_attr_bug4(my_fcpl, my_fapl);               /* Test attributes on named datatypes */
                 test_attr_bug5(my_fcpl, my_fapl);               /* Test opening/closing attributes through different file handles */
                 test_attr_bug6(my_fcpl, my_fapl);               /* Test reading empty attribute */
-                test_attr_bug7(my_fcpl, my_fapl);               /* Test creating and deleting large attributes in ohdr chunk 0 */
+                /* test_attr_bug7 is specific to the "new" object header format,
+                 * and in fact fails if used with the old format due to the
+                 * attributes being larger than 64K */
                 test_attr_bug8(my_fcpl, my_fapl);               /* Test attribute expanding object header with undecoded messages */
                 test_attr_bug9(my_fcpl, my_fapl);               /* Test large attributes converting to dense storage */
-                test_attr_delete_last_dense(my_fcpl, my_fapl);  /* Test */
-            } /* end for */
-        } /* end if */
-        else {
-            /* General attribute tests */
-            test_attr_big(fcpl, my_fapl);                       /* Test storing big attribute */
-            test_attr_null_space(fcpl, my_fapl);                /* Test storing attribute with NULL dataspace */
-            test_attr_deprec(fcpl, my_fapl);                    /* Test deprecated API routines */
-            test_attr_many(new_format, fcpl, my_fapl);               /* Test storing lots of attributes */
-
-            /* New attribute API routine tests, on old-format storage */
-            test_attr_info_by_idx(new_format, fcpl, my_fapl);   /* Test querying attribute info by index */
-            test_attr_delete_by_idx(new_format, fcpl, my_fapl); /* Test deleting attribute by index */
-            test_attr_iterate2(new_format, fcpl, my_fapl);      /* Test iterating over attributes by index */
-            test_attr_open_by_idx(new_format, fcpl, my_fapl);   /* Test opening attributes by index */
-            test_attr_open_by_name(new_format, fcpl, my_fapl);  /* Test opening attributes by name */
-            test_attr_create_by_name(new_format, fcpl, my_fapl); /* Test creating attributes by name */
-
-            /* Tests that address specific bugs */
-            test_attr_bug1(fcpl, my_fapl);                      /* Test odd allocation operations */
-            test_attr_bug2(fcpl, my_fapl);                      /* Test many deleted attributes */
-            test_attr_bug3(fcpl, my_fapl);                      /* Test "self referential" attributes */
-            test_attr_bug4(fcpl, my_fapl);                      /* Test attributes on named datatypes */
-            test_attr_bug5(fcpl, my_fapl);                      /* Test opening/closing attributes through different file handles */
-            test_attr_bug6(fcpl, my_fapl);                      /* Test reading empty attribute */
-            /* Skip test_attr_bug7 because it is specific to the new object
-             * header format and in fact fails if used with the old format, due
-             * to the attributes being larger than 64K */
-            test_attr_bug8(fcpl, my_fapl);                      /* Test attribute expanding object header with undecoded messages */
-            test_attr_bug9(fcpl, my_fapl);                      /* Test large attributes converting to dense storage */
-        } /* end else */
-    } /* end for */
+
+                /* tests specific to the "new format" */
+                if (new_format == TRUE) {
+                    /* General attribute tests */
+                    test_attr_dense_create(my_fcpl, my_fapl);       /* Test dense attribute storage creation */
+                    test_attr_dense_open(my_fcpl, my_fapl);         /* Test opening attributes in dense storage */
+                    test_attr_dense_delete(my_fcpl, my_fapl);       /* Test deleting attributes in dense storage */
+                    test_attr_dense_rename(my_fcpl, my_fapl);       /* Test renaming attributes in dense storage */
+                    test_attr_dense_unlink(my_fcpl, my_fapl);       /* Test unlinking object with attributes in dense storage */
+                    test_attr_dense_limits(my_fcpl, my_fapl);       /* Test dense attribute storage limits */
+                    test_attr_dense_dup_ids(my_fcpl, my_fapl);      /* Test duplicated IDs for dense attribute storage */
+
+                    /* Attribute creation order tests */
+                    test_attr_corder_create_basic(my_fcpl, my_fapl);/* Test creating an object w/attribute creation order info */
+                    test_attr_corder_create_compact(my_fcpl, my_fapl);  /* Test compact attribute storage on an object w/attribute creation order info */
+                    test_attr_corder_create_dense(my_fcpl, my_fapl);/* Test dense attribute storage on an object w/attribute creation order info */
+                    test_attr_corder_create_reopen(my_fcpl, my_fapl);/* Test creating attributes w/reopening file from using new format to using old format */
+                    test_attr_corder_transition(my_fcpl, my_fapl);  /* Test attribute storage transitions on an object w/attribute creation order info */
+                    test_attr_corder_delete(my_fcpl, my_fapl);      /* Test deleting object using dense storage w/attribute creation order info */
+
+                    /* More complex tests with exclusively both "new format" and "shared" attributes */
+                    if(use_shared == TRUE) {
+                        test_attr_shared_write(my_fcpl, my_fapl);   /* Test writing to shared attributes in compact & dense storage */
+                        test_attr_shared_rename(my_fcpl, my_fapl);  /* Test renaming shared attributes in compact & dense storage */
+                        test_attr_shared_delete(my_fcpl, my_fapl);  /* Test deleting shared attributes in compact & dense storage */
+                        test_attr_shared_unlink(my_fcpl, my_fapl);  /* Test unlinking object with shared attributes in compact & dense storage */
+                    } /* if using shared attributes */
+
+                    test_attr_delete_last_dense(my_fcpl, my_fapl);
+
+                    /* test_attr_bug7 is specific to the "new" object header format,
+                     * and in fact fails if used with the old format due to the
+                     * attributes being larger than 64K */
+                    test_attr_bug7(my_fcpl, my_fapl);               /* Test creating and deleting large attributes in ohdr chunk 0 */
+
+                } /* if using "new format" */
+            } /* for unshared/shared attributes */
+        } /* for old/new format */
+
+        if (minimize_dset_oh != 0) {
+            ret = H5Pclose(dcpl);
+            CHECK(ret, FAIL, "H5Pclose");
+            dcpl_g = H5P_DEFAULT;
+        }
+
+    } /* for default/minimized dataset object headers */
 
     /* Close  FCPLs */
     ret = H5Pclose(fcpl);
diff --git a/test/tfile.c b/test/tfile.c
index ad7f87f..2784204 100644
--- a/test/tfile.c
+++ b/test/tfile.c
@@ -4967,7 +4967,7 @@ test_libver_bounds_real(H5F_libver_t libver_create, unsigned oh_vers_create,
 #define VERBFNAME        "tverbounds_dspace.h5"
 #define VERBDSNAME       "dataset 1"
 #define SPACE1_DIM1     3
-static int
+static void
 test_libver_bounds_open(void)
 {
     hid_t file = -1;    /* File ID */
@@ -7051,6 +7051,132 @@ test_incr_filesize(void)
 
 /****************************************************************
 **
+**  test_min_dset_ohdr():
+**    Test API calls to toggle dataset object header minimization.
+**
+**  TODO (as separate function?):
+**    + setting persists between close and (re)open?
+**    + dataset header sizes created while changing value of toggle
+**
+****************************************************************/
+static void
+test_min_dset_ohdr(void)
+{
+    const char basename[]       = "min_dset_ohdr_testfile";
+    char filename[FILENAME_LEN] = "";
+    hid_t      file_id          = -1;
+    hid_t      file2_id         = -1;
+    hbool_t    minimize;
+    herr_t     ret;
+
+    MESSAGE(5, ("Testing dataset object header minimization\n"));
+
+    /*********/
+    /* SETUP */
+    /*********/
+
+    h5_fixname(basename, H5P_DEFAULT, filename, sizeof(filename));
+
+    file_id = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    CHECK_I(file_id, "H5Fcreate");
+
+    /*********/
+    /* TESTS */
+    /*********/
+
+    /*----------------------------------------
+     * TEST default value
+     */
+    ret = H5Fget_dset_no_attrs_hint(file_id, &minimize);
+    CHECK(ret, FAIL, "H5Fget_dset_no_attrs_hint");
+    VERIFY(minimize, FALSE, "minimize flag");
+
+    /*----------------------------------------
+     * TEST set to TRUE
+     */
+    ret = H5Fset_dset_no_attrs_hint(file_id, TRUE);
+    CHECK(ret, FAIL, "H5Fset_dset_no_attrs_hint");
+
+    ret = H5Fget_dset_no_attrs_hint(file_id, &minimize);
+    CHECK(ret, FAIL, "H5Fget_dset_no_attrs_hint");
+    VERIFY(minimize, TRUE, "minimize flag");
+
+    /*----------------------------------------
+     * TEST second file open on same filename
+     */
+    file2_id = H5Fopen(filename, H5F_ACC_RDWR, H5P_DEFAULT);
+    CHECK_I(file2_id, "H5Fopen");
+
+    /* verify TRUE setting on second open
+     */
+    ret = H5Fget_dset_no_attrs_hint(file_id, &minimize);
+    CHECK(ret, FAIL, "H5Fget_dset_no_attrs_hint");
+    VERIFY(minimize, TRUE, "minimize flag");
+
+    /* re-set to FALSE on first open
+     */
+    ret = H5Fset_dset_no_attrs_hint(file_id, FALSE);
+    CHECK(ret, FAIL, "H5Fset_dset_no_attrs_hint");
+
+    /* verify FALSE set on both opens
+     */
+    ret = H5Fget_dset_no_attrs_hint(file_id, &minimize);
+    CHECK(ret, FAIL, "H5Fget_dset_no_attrs_hint");
+    VERIFY(minimize, FALSE, "minimize flag");
+
+    ret = H5Fget_dset_no_attrs_hint(file2_id, &minimize);
+    CHECK(ret, FAIL, "H5Fget_dset_no_attrs_hint");
+    VERIFY(minimize, FALSE, "minimize flag");
+
+    /* re-set to TRUE on second open
+     */
+    ret = H5Fset_dset_no_attrs_hint(file2_id, TRUE);
+    CHECK(ret, FAIL, "H5Fset_dset_no_attrs_hint");
+
+    /* verify TRUE set on both opens
+     */
+    ret = H5Fget_dset_no_attrs_hint(file_id, &minimize);
+    CHECK(ret, FAIL, "H5Fget_dset_no_attrs_hint");
+    VERIFY(minimize, TRUE, "minimize flag");
+
+    ret = H5Fget_dset_no_attrs_hint(file2_id, &minimize);
+    CHECK(ret, FAIL, "H5Fget_dset_no_attrs_hint");
+    VERIFY(minimize, TRUE, "minimize flag");
+
+    /*----------------------------------------
+     * TEST error cases
+     */
+
+    /* trying to set with invalid file ID */
+    H5E_BEGIN_TRY {
+        ret = H5Fset_dset_no_attrs_hint(-1, TRUE);
+    } H5E_END_TRY;
+    VERIFY(ret, FAIL, "H5Fset_dset_no_attrs_hint");
+
+    /* trying to get with invalid file ID */
+    H5E_BEGIN_TRY {
+        ret = H5Fget_dset_no_attrs_hint(-1, &minimize);
+    } H5E_END_TRY;
+    VERIFY(ret, FAIL, "H5Fget_dset_no_attrs_hint");
+
+    /* trying to get with invalid pointer */
+    H5E_BEGIN_TRY {
+        ret = H5Fget_dset_no_attrs_hint(file_id, NULL);
+    } H5E_END_TRY;
+    VERIFY(ret, FAIL, "H5Fget_dset_no_attrs_hint");
+
+    /************/
+    /* TEARDOWN */
+    /************/
+
+    ret = H5Fclose(file_id);
+    CHECK(ret, FAIL, "H5Fclose");
+    ret = H5Fclose(file2_id);
+    CHECK(ret, FAIL, "H5Fclose");
+} /* end test_min_dset_ohdr() */
+
+/****************************************************************
+**
 **  test_deprec():
 **    Test deprecated functionality.
 **
@@ -7336,6 +7462,7 @@ test_file(void)
     test_libver_macros();                       /* Test the macros for library version comparison */
     test_libver_macros2();                      /* Test the macros for library version comparison */
     test_incr_filesize();                       /* Test H5Fincrement_filesize() and H5Fget_eoa() */
+    test_min_dset_ohdr();                       /* Test datset object header minimization */
 #ifndef H5_NO_DEPRECATED_SYMBOLS
     test_deprec();                              /* Test deprecated routines */
 #endif /* H5_NO_DEPRECATED_SYMBOLS */
diff --git a/test/tsohm.c b/test/tsohm.c
index d00a03a..93ba14f 100644
--- a/test/tsohm.c
+++ b/test/tsohm.c
@@ -178,40 +178,41 @@ static void test_sohm_extlink(void);
 
 /****************************************************************
 **
-**  check_fcpl_values(): Helper function for test_sohm_fcpl.
+**  verify_fcpl_values(): Helper function for test_sohm_fcpl.
 **         Verifies that the *_in and *_out parameters are equal.
 **
 ****************************************************************/
-static void check_fcpl_values(hid_t fcpl_id, const unsigned nindexes_in,
-                const unsigned *flags_in, const unsigned *minsizes_in,
+static void
+verify_fcpl_values(hid_t fcpl_id, const unsigned nindexes_expected,
+                const unsigned *flags_expected, const unsigned *minsizes_expected,
                 unsigned l2b, unsigned b2l)
 {
-    unsigned    num_indexes;
-    unsigned    index_flags, min_mesg_size;
-    unsigned    list_size, btree_size;
-    unsigned     x;
-    herr_t      ret;
-
-    /* Verify number of indexes is set to default */
-    ret = H5Pget_shared_mesg_nindexes(fcpl_id, &num_indexes);
+    unsigned  nindexes_actual;
+    unsigned  list_size;
+    unsigned  btree_size;
+    unsigned  x;
+    herr_t    ret;
+
+    /* Number of indexes */
+    ret = H5Pget_shared_mesg_nindexes(fcpl_id, &nindexes_actual);
     CHECK_I(ret, "H5Pget_shared_mesg_nindexes");
-    VERIFY(num_indexes, nindexes_in, "H5Pget_shared_mesg_nindexes");
-
-    /* Verify index flags and minsizes are set */
-    for(x=0; x<num_indexes; ++x)
-    {
-        ret = H5Pget_shared_mesg_index(fcpl_id, x, &index_flags, &min_mesg_size);
+    VERIFY(nindexes_actual, nindexes_expected, "H5Pget_shared_mesg_nindexes");
+    /* Index flags and minsizes */
+    for(x=0; x<nindexes_actual; ++x) {
+        unsigned flags_i;
+        unsigned min_mesg_size;
+        ret = H5Pget_shared_mesg_index(fcpl_id, x, &flags_i, &min_mesg_size);
         CHECK_I(ret, "H5Pget_shared_mesg_index");
-        VERIFY(index_flags, flags_in[x], "H5Pget_shared_mesg_index");
-        VERIFY(min_mesg_size, minsizes_in[x], "H5Pget_shared_mesg_index");
+        VERIFY(flags_i, flags_expected[x], "H5Pget_shared_mesg_index");
+        VERIFY(min_mesg_size, minsizes_expected[x], "H5Pget_shared_mesg_index");
     }
 
-    /* Check list-to-btree and btree-to-list values */
+    /* List-to-btree and btree-to-list values */
     ret = H5Pget_shared_mesg_phase_change(fcpl_id, &list_size, &btree_size);
     CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
     VERIFY(list_size, l2b, "H5Pset_shared_mesg_phase_change");
     VERIFY(btree_size, b2l, "H5Pset_shared_mesg_phase_change");
-}
+} /* verify_fcpl_values */
 
 
 /****************************************************************
@@ -219,7 +220,8 @@ static void check_fcpl_values(hid_t fcpl_id, const unsigned nindexes_in,
 **  test_sohm_fcpl(): Test File Creation Property Lists.
 **
 ****************************************************************/
-static void test_sohm_fcpl(void)
+static void
+test_sohm_fcpl(void)
 {
     hid_t       fid = -1;
     hid_t       fcpl_id = -1;
@@ -227,14 +229,12 @@ static void test_sohm_fcpl(void)
     unsigned    x;
     herr_t	ret;		/* Generic return value	*/
 
-    /* Output message about test being performed */
     MESSAGE(5, ("Testing File Creation Properties for Shared Messages\n"));
 
     fcpl_id = H5Pcreate(H5P_FILE_CREATE);
     CHECK_I(fcpl_id, "H5Pcreate");
 
-    /* Verify fcpl values */
-    check_fcpl_values(fcpl_id, DEF_NUM_INDEXES, def_type_flags, def_minsizes, DEF_L2B, DEF_B2L);
+    verify_fcpl_values(fcpl_id, DEF_NUM_INDEXES, def_type_flags, def_minsizes, DEF_L2B, DEF_B2L);
 
     /* Create a file with this fcpl and make sure that all the values can be
      * retrieved.
@@ -245,8 +245,7 @@ static void test_sohm_fcpl(void)
     fcpl2_id = H5Fget_create_plist(fid);
     CHECK_I(fcpl2_id, "H5Fcreate");
 
-    /* Verify fcpl values */
-    check_fcpl_values(fcpl2_id, DEF_NUM_INDEXES, def_type_flags, def_minsizes, DEF_L2B, DEF_B2L);
+    verify_fcpl_values(fcpl2_id, DEF_NUM_INDEXES, def_type_flags, def_minsizes, DEF_L2B, DEF_B2L);
 
     ret = H5Pclose(fcpl2_id);
     CHECK_I(ret, "H5Pclose");
@@ -262,8 +261,7 @@ static void test_sohm_fcpl(void)
     fcpl2_id = H5Fget_create_plist(fid);
     CHECK_I(ret, "H5Fcreate");
 
-    /* Verify fcpl values */
-    check_fcpl_values(fcpl2_id, DEF_NUM_INDEXES, def_type_flags, def_minsizes, DEF_L2B, DEF_B2L);
+    verify_fcpl_values(fcpl2_id, DEF_NUM_INDEXES, def_type_flags, def_minsizes, DEF_L2B, DEF_B2L);
 
     /* Clean up */
     ret = H5Pclose(fcpl2_id);
@@ -289,7 +287,7 @@ static void test_sohm_fcpl(void)
     ret = H5Pset_shared_mesg_phase_change(fcpl_id, TEST_L2B, TEST_B2L);
     CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
 
-    check_fcpl_values(fcpl_id, TEST_NUM_INDEXES, test_type_flags, test_minsizes, TEST_L2B, TEST_B2L);
+    verify_fcpl_values(fcpl_id, TEST_NUM_INDEXES, test_type_flags, test_minsizes, TEST_L2B, TEST_B2L);
 
     /* Use the fcpl to create a file and get it back again */
     fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, H5P_DEFAULT);
@@ -297,8 +295,7 @@ static void test_sohm_fcpl(void)
     fcpl2_id = H5Fget_create_plist(fid);
     CHECK_I(fcpl2_id, "H5Fcreate");
 
-    /* Verify fcpl values */
-    check_fcpl_values(fcpl2_id, TEST_NUM_INDEXES, test_type_flags, test_minsizes, TEST_L2B, TEST_B2L);
+    verify_fcpl_values(fcpl2_id, TEST_NUM_INDEXES, test_type_flags, test_minsizes, TEST_L2B, TEST_B2L);
 
     ret = H5Pclose(fcpl2_id);
     CHECK_I(ret, "H5Pclose");
@@ -314,8 +311,7 @@ static void test_sohm_fcpl(void)
     fcpl2_id = H5Fget_create_plist(fid);
     CHECK_I(ret, "H5Fcreate");
 
-    /* Verify fcpl values */
-    check_fcpl_values(fcpl2_id, TEST_NUM_INDEXES, test_type_flags, test_minsizes, TEST_L2B, TEST_B2L);
+    verify_fcpl_values(fcpl2_id, TEST_NUM_INDEXES, test_type_flags, test_minsizes, TEST_L2B, TEST_B2L);
 
     /* Clean up */
     ret = H5Pclose(fcpl2_id);
@@ -323,6 +319,72 @@ static void test_sohm_fcpl(void)
     ret = H5Fclose(fid);
     CHECK_I(ret, "H5Fclose");
 
+    /* Actually, the list max can be exactly 1 greater than the
+     * btree min, but no more.  Also, the errors above shouldn't
+     * have corrupted the fcpl, although we do need to reset the
+     * second index that we changed above.
+     */
+    ret = H5Pset_shared_mesg_index(fcpl_id, 1, test_type_flags[1], 15);
+    CHECK_I(ret, "H5Pset_shared_mesg_index");
+    ret = H5Pset_shared_mesg_phase_change(fcpl_id, 10, 11);
+    CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
+    fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, H5P_DEFAULT);
+    CHECK_I(fid, "H5Fcreate");
+    ret = H5Fclose(fid);
+    CHECK_I(ret, "H5Fclose");
+
+    /* Test edge cases; H5O_SHMESG_MAX_NINDEXES and H5O_SHMESG_MAX_LIST_SIZE should be
+     * valid values.  Also, creating a file with uninitialized indexes
+     * (indexes 3-5) should work.
+     */
+    ret = H5Pset_shared_mesg_nindexes(fcpl_id, H5O_SHMESG_MAX_NINDEXES);
+    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+    ret = H5Pset_shared_mesg_phase_change(fcpl_id, H5O_SHMESG_MAX_LIST_SIZE, H5O_SHMESG_MAX_LIST_SIZE);
+    CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
+    fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, H5P_DEFAULT);
+    CHECK_I(fid, "H5Fcreate");
+
+
+    /* Clean up */
+    ret = H5Pclose(fcpl_id);
+    CHECK_I(ret, "H5Pclose");
+    ret = H5Fclose(fid);
+    CHECK_I(ret, "H5Fclose");
+} /* test_sohm_fcpl */
+
+
+
+/****************************************************************
+**
+**  test_sohm_fcpl_errors(): Test bogus FCPL settings for SOHMs
+**
+****************************************************************/
+static void
+test_sohm_fcpl_errors(void)
+{
+    hid_t    fcpl_id = -1;
+    hid_t    fid     = -1;
+    unsigned x;
+    herr_t   ret;
+
+    MESSAGE(5, ("Testing bogus file creation properties for shared messages\n"));
+
+    fcpl_id = H5Pcreate(H5P_FILE_CREATE);
+    CHECK_I(fcpl_id, "H5Pcreate");
+
+    /* Set up index values */
+    ret = H5Pset_shared_mesg_nindexes(fcpl_id, TEST_NUM_INDEXES);
+    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+    for(x = 0; x < TEST_NUM_INDEXES; ++x) {
+        ret = H5Pset_shared_mesg_index(fcpl_id, x, test_type_flags[x], test_minsizes[x]);
+        CHECK_I(ret, "H5Pset_shared_mesg_index");
+    }
+
+    ret = H5Pset_shared_mesg_phase_change(fcpl_id, TEST_L2B, TEST_B2L);
+    CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
+
+    verify_fcpl_values(fcpl_id, TEST_NUM_INDEXES, test_type_flags, test_minsizes, TEST_L2B, TEST_B2L);
+
     /* Test giving bogus values to H5P* functions */
     H5E_BEGIN_TRY {
         /* Trying to create too many indexes should fail */
@@ -370,40 +432,7 @@ static void test_sohm_fcpl(void)
         ret = H5Pset_shared_mesg_phase_change(fcpl_id, H5O_SHMESG_MAX_LIST_SIZE, H5O_SHMESG_MAX_LIST_SIZE+1);
         VERIFY(ret, -1, "H5Pset_shared_mesg_phase_change");
     } H5E_END_TRY
-
-
-    /* Actually, the list max can be exactly 1 greater than the
-     * btree min, but no more.  Also, the errors above shouldn't
-     * have corrupted the fcpl, although we do need to reset the
-     * second index that we changed above.
-     */
-    ret = H5Pset_shared_mesg_index(fcpl_id, 1, test_type_flags[1], 15);
-    CHECK_I(ret, "H5Pset_shared_mesg_index");
-    ret = H5Pset_shared_mesg_phase_change(fcpl_id, 10, 11);
-    CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
-    fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, H5P_DEFAULT);
-    CHECK_I(fid, "H5Fcreate");
-    ret = H5Fclose(fid);
-    CHECK_I(ret, "H5Fclose");
-
-    /* Test edge cases; H5O_SHMESG_MAX_NINDEXES and H5O_SHMESG_MAX_LIST_SIZE should be
-     * valid values.  Also, creating a file with uninitialized indexes
-     * (indexes 3-5) should work.
-     */
-    ret = H5Pset_shared_mesg_nindexes(fcpl_id, H5O_SHMESG_MAX_NINDEXES);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-    ret = H5Pset_shared_mesg_phase_change(fcpl_id, H5O_SHMESG_MAX_LIST_SIZE, H5O_SHMESG_MAX_LIST_SIZE);
-    CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
-    fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, H5P_DEFAULT);
-    CHECK_I(fid, "H5Fcreate");
-
-
-    /* Clean up */
-    ret = H5Pclose(fcpl_id);
-    CHECK_I(ret, "H5Pclose");
-    ret = H5Fclose(fid);
-    CHECK_I(ret, "H5Fclose");
-}
+} /* test_sohm_fcpl_errors */
 
 
 /*-------------------------------------------------------------------------
@@ -455,7 +484,8 @@ error:
       H5Tclose(dtype1_id);
     } H5E_END_TRY
     return -1;
-}
+} /* make_dtype_1 */
+
 
 /*-------------------------------------------------------------------------
  * Function:    make_dtype_2
@@ -518,9 +548,9 @@ error:
       H5Tclose(int_id);
     } H5E_END_TRY
     return -1;
-}
-
+} /* make_dtype2 */
 
+
 /*-------------------------------------------------------------------------
  * Function:    close_reopen_file
  *
@@ -540,16 +570,16 @@ error:
 static hid_t
 close_reopen_file(hid_t file, const char* filename, hid_t fapl_id)
 {
-    hid_t fid;
-
-    if(H5Fclose(file) < 0) FAIL_STACK_ERROR
-    if((fid = H5Fopen(filename, H5F_ACC_RDWR, fapl_id)) < 0) FAIL_STACK_ERROR
-
-    return(fid);
+    if (H5Fclose(file) < 0)
+        FAIL_STACK_ERROR
+    file = H5Fopen(filename, H5F_ACC_RDWR, fapl_id);
+    if (file < 0)
+        FAIL_STACK_ERROR
+    return(file);
 
 error:
     return -1;
-}
+} /* close_reopen_file */
 
 
 /*-------------------------------------------------------------------------
@@ -557,7 +587,6 @@ error:
  *
  * Purpose:     Creates object headers that use a large datatype message.
  *
- *              Used in test_sohm_basic.  Should close the file ID passed in.
  *              Set test_file_closing to 1 to add file closing and reopening
  *              whenever possible (to test that SOHMs are written correctly
  *              on disk and not just in memory).
@@ -571,7 +600,7 @@ error:
  *-------------------------------------------------------------------------
  */
 static hid_t
-size1_helper(hid_t file, const char* filename, hid_t fapl_id, int test_file_closing)
+size1_helper(hid_t file, const char *filename, hid_t fapl_id, int test_file_closing)
 {
     dtype1_struct wdata;
     dtype1_struct rdata;
@@ -581,6 +610,32 @@ size1_helper(hid_t file, const char* filename, hid_t fapl_id, int test_file_clos
     hsize_t     dim1[1];
     int         x;
 
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * Macro:      TSOHM_S1H_VERIFY_DATA
+ *
+ * Purpose:    Encapsulate a common pattern:
+ *             Reads the dataset and verifies that [a subset of] the data
+ *             are as expected.
+ *
+ * Programmer: Jacob Smith
+ *             2018 November 1
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ */
+#define TSOHM_S1H_VERIFY_DATA(dset_id, dtype_id) \
+{                                                \
+    HDmemset(&rdata, 0, sizeof(rdata));          \
+    if (0 > H5Dread((dset_id), (dtype_id), H5S_ALL, H5S_ALL, H5P_DEFAULT, &rdata)) { \
+        H5_FAILED(); AT();                       \
+        printf("Can't read data\n");             \
+        goto error;                              \
+    }                                            \
+    if ((rdata.i1 != wdata.i1) || (rdata.i2 != wdata.i2) || HDstrcmp(rdata.str, wdata.str)) { \
+        H5_FAILED(); AT();                       \
+        printf("incorrect read data\n");         \
+        goto error;                              \
+    }                                            \
+} /* TSOHM_S1H_VERIFY_DATA() definition */
+
     /* Closing and re-opening the file takes a long time on systems without
      * local disks.  Don't close and reopen if express testing is enabled.
      */
@@ -614,96 +669,55 @@ size1_helper(hid_t file, const char* filename, hid_t fapl_id, int test_file_clos
     /* Test writing and reading */
     if(H5Dwrite(dset_id, dtype1_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, &wdata) < 0) FAIL_STACK_ERROR
 
-    if(H5Dread(dset_id, dtype1_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, &rdata) < 0) FAIL_STACK_ERROR
-
-    if(rdata.i1 != wdata.i1 || rdata.i2 != wdata.i2 || HDstrcmp(rdata.str, wdata.str)) {
-        H5_FAILED(); AT();
-        printf("incorrect read data\n");
-        goto error;
-    } /* end if */
+    TSOHM_S1H_VERIFY_DATA(dset_id, dtype1_id)
     if(H5Dclose(dset_id) < 0) FAIL_STACK_ERROR
 
-    /* Close and re-open the file if requested*/
     if(test_file_closing)
         if((file = close_reopen_file(file, filename, fapl_id)) < 0) TEST_ERROR
 
-    /* Create more datasets with the same datatype */
-    if((dset_id = H5Dcreate2(file, DSETNAME[1], dtype1_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) FAIL_STACK_ERROR
-    if(H5Dclose(dset_id) < 0) FAIL_STACK_ERROR
+    /* Create 3 more datasets with the same datatype/dataspace */
+    for (x = 1; x < 4; x++) {
+        dset_id = H5Dcreate2(file, DSETNAME[x], dtype1_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+        if (0 > dset_id) FAIL_STACK_ERROR
+        if (x == 3)
+            if(H5Dwrite(dset_id, dtype1_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, &wdata) < 0) TEST_ERROR
+        if (H5Dclose(dset_id) < 0) FAIL_STACK_ERROR
 
-    /* Close and re-open the file if requested*/
-    if(test_file_closing)
-        if((file = close_reopen_file(file, filename, fapl_id)) < 0) TEST_ERROR
-
-    if((dset_id = H5Dcreate2(file, DSETNAME[2], dtype1_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
-    if(H5Dclose(dset_id) < 0) TEST_ERROR
-
-    /* Close and re-open the file if requested*/
-    if(test_file_closing)
-        if((file = close_reopen_file(file, filename, fapl_id)) < 0) TEST_ERROR
-
-    if((dset_id = H5Dcreate2(file,DSETNAME[3],dtype1_id,space_id,H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
-
-    /* Write data to dataset 3 for later */
-    if(H5Dwrite(dset_id, dtype1_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, &wdata) < 0) TEST_ERROR
+        if (test_file_closing)
+            if((file = close_reopen_file(file, filename, fapl_id)) < 0) TEST_ERROR
+    }
 
-    if(H5Dclose(dset_id) < 0) TEST_ERROR
     if(H5Tclose(dtype1_id) < 0) TEST_ERROR
 
-    /* Close and re-open the file if requested*/
-    if(test_file_closing)
-        if((file = close_reopen_file(file, filename, fapl_id)) < 0) TEST_ERROR
-
     /* Make sure the data has been written successfully */
-    if((dset_id = H5Dopen2(file, DSETNAME[0], H5P_DEFAULT)) < 0) TEST_ERROR
-    if((dtype1_id = H5Dget_type(dset_id)) < 0) TEST_ERROR
-
-    /* Read data back again */
-    HDmemset(&rdata, 0, sizeof(rdata));
-    if(H5Dread(dset_id, dtype1_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, &rdata) < 0) {
-        H5_FAILED(); AT();
-        printf("Can't read data\n");
-        goto error;
-    } /* end if */
-
-    if(rdata.i1 != wdata.i1 || rdata.i2 != wdata.i2 || HDstrcmp(rdata.str, wdata.str)) {
-        H5_FAILED(); AT();
-        printf("incorrect read data\n");
-        goto error;
-    } /* end if */
+    dset_id = H5Dopen2(file, DSETNAME[0], H5P_DEFAULT);
+    if(dset_id < 0) TEST_ERROR
+    dtype1_id = H5Dget_type(dset_id);
+    if(dtype1_id < 0) TEST_ERROR
+    TSOHM_S1H_VERIFY_DATA(dset_id, dtype1_id)
 
     if(H5Dclose(dset_id) < 0) TEST_ERROR
 
-    /* Create several copies of the dataset (this increases the amount of space saved by sharing the datatype message) */
+    /* Create several copies of the dataset
+     * this increases the amount of space saved by sharing the datatype message
+     */
     for(x = 0; x < SOHM_HELPER_NUM_EX_DSETS; x++) {
         if((dset_id = H5Dcreate2(file, EXTRA_DSETNAME[x], dtype1_id, space_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
         if(H5Dclose(dset_id) < 0) TEST_ERROR
 
-        /* Close and re-open the file if requested*/
         if(test_file_closing)
             if((file = close_reopen_file(file, filename, fapl_id)) < 0) TEST_ERROR
-    } /* end for */
+    }
 
     if(H5Tclose(dtype1_id) < 0) TEST_ERROR
     if(H5Sclose(space_id) < 0) TEST_ERROR
 
     /* Ensure that we can still read data back from dataset 3 */
-    if((dset_id = H5Dopen2(file, DSETNAME[3], H5P_DEFAULT)) < 0) TEST_ERROR
-    if((dtype1_id = H5Dget_type(dset_id)) < 0) TEST_ERROR
-
-    /* Read data back again */
-    HDmemset(&rdata, 0, sizeof(rdata));
-    if(H5Dread(dset_id, dtype1_id, H5S_ALL, H5S_ALL, H5P_DEFAULT, &rdata) < 0) {
-        H5_FAILED(); AT();
-        printf("Can't read data\n");
-        goto error;
-    } /* end if */
-
-    if(rdata.i1 != wdata.i1 || rdata.i2 != wdata.i2 || HDstrcmp(rdata.str, wdata.str)) {
-        H5_FAILED(); AT();
-        printf("incorrect read data\n");
-        goto error;
-    } /* end if */
+    dset_id = H5Dopen2(file, DSETNAME[3], H5P_DEFAULT);
+    if(dset_id < 0) TEST_ERROR
+    dtype1_id = H5Dget_type(dset_id);
+    if(dtype1_id < 0) TEST_ERROR
+    TSOHM_S1H_VERIFY_DATA(dset_id, dtype1_id)
 
     if(H5Dclose(dset_id) < 0) TEST_ERROR
     if(H5Tclose(dtype1_id) < 0) TEST_ERROR
@@ -717,7 +731,42 @@ size1_helper(hid_t file, const char* filename, hid_t fapl_id, int test_file_clos
         H5Fclose(file);
     } H5E_END_TRY
     return -1;
-}
+#undef TSOHM_S1H_VERIFY_DATA /* macro is exclusive to this function */
+} /* size1_helper */
+
+
+/*----------------------------------------------------------------------------
+ * Function: getsize_testsize1
+ *
+ * Purpose: Creates a test file, populates it, and returns its file size.
+ *          Oject header information from the "first" dataset in the file
+ *          is stored in pointer `oinfo`.
+ *
+ * Programmer: Jacob Smith
+ *             2018 November 1
+ *----------------------------------------------------------------------------
+ */
+static h5_stat_size_t
+getsize_testsize1(const char *filename, hid_t fcpl_id, hid_t fapl_id, unsigned open_close, H5O_info_t *oinfo)
+{
+    hid_t file = -1;
+    herr_t ret;
+
+    file = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, fapl_id);
+    CHECK_I(file, "H5Fcreate");
+
+    file = size1_helper(file, FILENAME, fapl_id, open_close);
+    CHECK_I(file, "size1_helper");
+
+    ret = H5Oget_info_by_name2(file, DSETNAME[0], oinfo, H5O_INFO_HDR, H5P_DEFAULT);
+    CHECK_I(ret, "H5Oget_info_by_name");
+
+    ret = H5Fclose(file);
+    CHECK_I(ret, "H5Fclose");
+
+    return h5_get_file_size(FILENAME, fapl_id);
+} /* getsize_testsize1 */
+
 
 /*-------------------------------------------------------------------------
  * Function:    test_sohm_size1
@@ -727,17 +776,26 @@ size1_helper(hid_t file, const char* filename, hid_t fapl_id, int test_file_clos
  * Programmer:  James Laird
  *              Monday, April 10, 2006
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
-static void test_sohm_size1(void)
+static void
+test_sohm_size1(void)
 {
     hid_t       file = -1;
     hid_t       fcpl_id = -1;
     hid_t       fapl_id = -1;
-    hsize_t     sohm_oh_size;
-    hsize_t     sohm_btree_oh_size;
+
+    unsigned       use_shared = 0;
+    unsigned       use_btree = 0;
+    unsigned       open_close = 0;
+    h5_stat_size_t file_sizes[9];
+    unsigned       size_index = 0;
+    hsize_t        oh_sizes[3];
+    unsigned       oh_size_index = 0;
+
+    hsize_t        norm_oh_size;
+    hsize_t        sohm_oh_size;
+    hsize_t        sohm_btree_oh_size;
     h5_stat_size_t norm_empty_filesize;
     h5_stat_size_t sohm_empty_filesize;
     h5_stat_size_t sohm_btree_empty_filesize;
@@ -747,6 +805,7 @@ static void test_sohm_size1(void)
     h5_stat_size_t norm_final_filesize2;
     h5_stat_size_t sohm_final_filesize2;
     h5_stat_size_t sohm_btree_final_filesize2;
+
     H5O_info_t  oinfo;
     unsigned    num_indexes = 1;
     unsigned    index_flags = H5O_SHMESG_DTYPE_FLAG;
@@ -757,7 +816,6 @@ static void test_sohm_size1(void)
 
     MESSAGE(5, ("Testing that shared datatypes save space\n"));
 
-
     /* Create a FAPL with "semi" close degree, to detect dangling IDs */
     fapl_id = H5Pcreate(H5P_FILE_ACCESS);
     CHECK_I(fapl_id, "H5Pcreate");
@@ -765,169 +823,97 @@ static void test_sohm_size1(void)
     ret = H5Pset_fclose_degree(fapl_id, H5F_CLOSE_SEMI);
     CHECK_I(ret, "H5Pset_fclose_degree");
 
-    /* Create a file with SOHMs disabled and get its size */
-    fcpl_id = H5Pcreate(H5P_FILE_CREATE);
-    CHECK_I(fcpl_id, "H5Pcreate");
-
-    ret = H5Pset_shared_mesg_nindexes(fcpl_id, 0);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-
-    file = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, fapl_id);
-    CHECK_I(file, "H5Fcreate");
-
-    ret = H5Fclose(file);
-    CHECK_I(ret, "H5Fclose");
-
-    /* Get the file size */
-    norm_empty_filesize = h5_get_file_size(FILENAME, fapl_id);
-
-    /* Add a bunch of large datatypes to the file */
-    file = H5Fopen(FILENAME, H5F_ACC_RDWR, fapl_id);
-    CHECK_I(file, "H5Fopen");
-    file = size1_helper(file, FILENAME, fapl_id, 0);
-    CHECK_I(file, "size1_helper");
-    ret = H5Fclose(file);
-    CHECK_I(ret, "H5Fclose");
-
-    /* Get the new file size */
-    norm_final_filesize = h5_get_file_size(FILENAME, fapl_id);
-
-    /* Use the same property list to create a new file. */
-    file = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, fapl_id);
-    CHECK_I(file, "H5Fcreate");
-
-    ret = H5Pclose(fcpl_id);
-    CHECK_I(ret, "H5Pclose");
-
-    /* Add the same large datatypes, but keep closing and re-opening the file */
-    file = size1_helper(file, FILENAME, fapl_id, 1);
-    CHECK_I(file, "size1_helper");
-    ret = H5Fclose(file);
-    CHECK_I(ret, "H5Fclose");
-
-    /* Get the file size */
-    norm_final_filesize2 = h5_get_file_size(FILENAME, fapl_id);
-
-
-
-    /* Now do the same thing for a file with SOHMs enabled */
-    /* Create FCPL with SOHMs enabled */
-    fcpl_id = H5Pcreate(H5P_FILE_CREATE);
-    CHECK_I(fcpl_id, "H5Pcreate");
-
-    /* Tests one index holding only datatype messages */
-    ret = H5Pset_shared_mesg_nindexes(fcpl_id, num_indexes);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-    ret = H5Pset_shared_mesg_index(fcpl_id, 0, index_flags, min_mesg_size);
-    CHECK_I(ret, "H5Pset_shared_mesg_index");
-    ret = H5Pset_shared_mesg_phase_change(fcpl_id, list_max, btree_min);
-    CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
-
-    /* Create a file */
-    file = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, fapl_id);
-    CHECK_I(file, "H5Fcreate");
-
-    ret = H5Fclose(file);
-    CHECK_I(ret, "H5Fclose");
-
-    sohm_empty_filesize = h5_get_file_size(FILENAME, fapl_id);
-
-    /* Add a bunch of datatypes to this file */
-    file = H5Fopen(FILENAME, H5F_ACC_RDWR, fapl_id);
-    CHECK_I(file, "H5Fopen");
-    file = size1_helper(file, FILENAME, fapl_id, 0);
-    CHECK_I(file, "size1_helper");
+    /* ----------------------------------------
+     * Run operations, accumulating file sizes to compare later.
+     */
+
+    for (use_shared = 0; use_shared < 2; use_shared++) {
+        for (use_btree = 0; use_btree < 2; use_btree++) {
+
+            /* cannot use btree indexing without shared messages; skip case */
+            if (use_btree && !use_shared)
+                continue;
+
+            fcpl_id = H5Pcreate(H5P_FILE_CREATE);
+            CHECK_I(fcpl_id, "H5Pcreate");
+
+            if (use_shared) {
+                /* Tests one index holding only datatype messages */
+                ret = H5Pset_shared_mesg_nindexes(fcpl_id, num_indexes);
+                CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+                ret = H5Pset_shared_mesg_index(fcpl_id, 0, index_flags, min_mesg_size);
+                CHECK_I(ret, "H5Pset_shared_mesg_index");
+
+                if (use_btree) {
+                    ret = H5Pset_shared_mesg_phase_change(fcpl_id, 0, 0);
+                } else {
+                    ret = H5Pset_shared_mesg_phase_change(fcpl_id, list_max, btree_min);
+                }
+                CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
+            } else {
+                ret = H5Pset_shared_mesg_nindexes(fcpl_id, 0);
+                CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+            }
+
+            file = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, fapl_id);
+            CHECK_I(file, "H5Fcreate");
+            ret = H5Fclose(file);
+            CHECK_I(ret, "H5Fclose");
 
-    /* Get the size of a dataset object header */
-    ret = H5Oget_info_by_name2(file, DSETNAME[0], &oinfo, H5O_INFO_HDR, H5P_DEFAULT);
-    CHECK_I(ret, "H5Oget_info_by_name");
-    ret = H5Fclose(file);
-    CHECK_I(ret, "H5Fclose");
-    sohm_oh_size = oinfo.hdr.space.total;
+            /* size of empty file */
+            file_sizes[size_index++] = h5_get_file_size(FILENAME, fapl_id);
 
-    /* Get the new file size */
-    sohm_final_filesize = h5_get_file_size(FILENAME, fapl_id);
+            /* size of populated file, with different populating behaviors */
+            for (open_close = 0; open_close < 2; open_close++)
+                file_sizes[size_index++] = getsize_testsize1(FILENAME, fcpl_id, fapl_id, open_close, &oinfo);
+            oh_sizes[oh_size_index++] = oinfo.hdr.space.total;
 
-    /* Use the same property list to create a new file. */
-    file = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, fapl_id);
-    CHECK_I(file, "H5Fcreate");
+            ret = H5Pclose(fcpl_id);
+            CHECK_I(ret, "H5Pclose");
+        } /* for btree/listed messages */
+    } /* for normal/shared messages */
 
-    ret = H5Pclose(fcpl_id);
+    ret = H5Pclose(fapl_id);
     CHECK_I(ret, "H5Pclose");
 
-    /* Add the same large datatypes, but keep closing and re-opening the file */
-    file = size1_helper(file, FILENAME, fapl_id, 1);
-    CHECK_I(file, "size1_helper");
-    ret = H5Fclose(file);
-    CHECK_I(ret, "H5Fclose");
-
-    /* Get the file size */
-    sohm_final_filesize2 = h5_get_file_size(FILENAME, fapl_id);
-
-
-
-    /* Create FCPL with SOHMs enabled that uses a B-tree index */
-    fcpl_id = H5Pcreate(H5P_FILE_CREATE);
-    CHECK_I(fcpl_id, "H5Pcreate");
-
-    /* Tests one index holding only datatype messages */
-    ret = H5Pset_shared_mesg_nindexes(fcpl_id, num_indexes);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-    ret = H5Pset_shared_mesg_index(fcpl_id, 0, index_flags, min_mesg_size);
-    CHECK_I(ret, "H5Pset_shared_mesg_index");
-    ret = H5Pset_shared_mesg_phase_change(fcpl_id, 0, 0);
-    CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
-
-    /* Create a file */
-    file = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, fapl_id);
-    CHECK_I(file, "H5Fcreate");
-
-    ret = H5Fclose(file);
-    CHECK_I(ret, "H5Fclose");
-
-    sohm_btree_empty_filesize = h5_get_file_size(FILENAME, fapl_id);
-
-    /* Add a bunch of datatypes to this file */
-    file = H5Fopen(FILENAME, H5F_ACC_RDWR, fapl_id);
-    CHECK_I(file, "H5Fopen");
-    file = size1_helper(file, FILENAME, fapl_id, 0);
-    CHECK_I(file, "size1_helper");
-
-    /* Get the size of a dataset object header */
-    ret = H5Oget_info_by_name2(file, DSETNAME[0], &oinfo, H5O_INFO_HDR, H5P_DEFAULT);
-    CHECK_I(ret, "H5Oget_info_by_name");
-    ret = H5Fclose(file);
-    CHECK_I(ret, "H5Fclose");
-    sohm_btree_oh_size = oinfo.hdr.space.total;
-
-    /* Get the new file size */
-    sohm_btree_final_filesize = h5_get_file_size(FILENAME, fapl_id);
-
-    /* Use the same property list to create a new file. */
-    file = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, fapl_id);
-    CHECK_I(file, "H5Fcreate");
+    /* sanity-check state of arrays */
+    VERIFY(9, size_index, "size_index");
+    VERIFY(3, oh_size_index, "oh_size_index");
 
-    ret = H5Pclose(fcpl_id);
-    CHECK_I(ret, "H5Pclose");
+    /* ----------------------------------------
+     * Check that all sizes make sense.
+     */
 
-    /* Add the same large datatypes, but keep closing and re-opening the file */
-    file = size1_helper(file, FILENAME, fapl_id, 1);
-    CHECK_I(file, "size1_helper");
-    ret = H5Fclose(file);
-    CHECK_I(ret, "H5Fclose");
+    /* Put result sizes into human-readable symbolic names.
+     * Order dependent on loop execution above.
+     */
+    norm_empty_filesize = file_sizes[0];
+    norm_final_filesize = file_sizes[1];
+    norm_final_filesize2 = file_sizes[2];
+    norm_oh_size = oh_sizes[0];
 
-    /* Get the file size */
-    sohm_btree_final_filesize2 = h5_get_file_size(FILENAME, fapl_id);
+    sohm_empty_filesize = file_sizes[3];
+    sohm_final_filesize = file_sizes[4];
+    sohm_final_filesize2 = file_sizes[5];
+    sohm_oh_size = oh_sizes[1];
 
+    sohm_btree_empty_filesize = file_sizes[6];
+    sohm_btree_final_filesize = file_sizes[7];
+    sohm_btree_final_filesize2 = file_sizes[8];
+    sohm_btree_oh_size = oh_sizes[2];
 
+    /* How the SOHM messages are stored shouldn't affect the
+     * size of the object header.
+     */
+    VERIFY(sohm_btree_oh_size, sohm_oh_size, "H5Oget_info_by_name");
 
-    /* Check that all sizes make sense */
+#if 0 /* TBD: lying comment or bug. See Jira HDFFV-10646 */
     /* Object headers in SOHM files should be smaller than normal object
-     * headers.  How the SOHM messages are stored shouldn't affect the
-     * size of the object header.
+     * headers.
      */
-    if(sohm_oh_size != sohm_btree_oh_size)
-        VERIFY(sohm_btree_oh_size, 1, "H5Oget_info_by_name");
+    if (sohm_oh_size >= norm_oh_size)
+        VERIFY(norm_oh_size, 1, "H5Oget_info_by_name");
+#endif /* Jira HDFFV-10646 */
 
     /* Both sohm files should be bigger than a normal file when empty.
      * It's hard to say whether a B-tree with no nodes allocated should be
@@ -950,15 +936,118 @@ static void test_sohm_size1(void)
     if(sohm_final_filesize > sohm_btree_final_filesize)
         VERIFY(sohm_final_filesize, 1, "h5_get_file_size");
 
-    /* This shouldn't change even if we open and close the file */
+    /* Comparative sizes shouldn't change even if we open and close the file */
+
     if(sohm_btree_final_filesize2 >= norm_final_filesize2)
         VERIFY(sohm_btree_final_filesize2, 1, "h5_get_file_size");
     if(sohm_final_filesize2 > sohm_btree_final_filesize2)
         VERIFY(sohm_final_filesize2, 1, "h5_get_file_size");
 
+} /* test_sohm_size1 */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    test_sohm_size_consistency_open_create
+ *
+ * Purpose:     Tests that header size is different depending on file open
+ *              procedure?
+ *              Uses "size1_helper" for file setup directed to a specific
+ *              file handle.
+ *
+ * Programmer:  Jacob Smith
+ *              2018 November 1
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+test_sohm_size_consistency_open_create(void)
+{
+    hid_t       file = -1;
+    hid_t       fcpl_id = -1;
+    hid_t       fapl_id = -1;
+    unsigned    use_btree;
+    hsize_t     oh_size_open;
+    hsize_t     oh_size_create;
+    H5O_info_t  oinfo;
+    unsigned    num_indexes = 1;
+    unsigned    index_flags = H5O_SHMESG_DTYPE_FLAG;
+    unsigned    min_mesg_size = 50;
+    unsigned    list_max = 11;
+    unsigned    btree_min = 10;
+    herr_t      ret;
+
+    MESSAGE(5, ("Testing that header size is consistent between H5Fopen and H5Fcreate\n"));
+
+    /* Create a FAPL with "semi" close degree, to detect dangling IDs */
+    fapl_id = H5Pcreate(H5P_FILE_ACCESS);
+    CHECK_I(fapl_id, "H5Pcreate");
+    ret = H5Pset_fclose_degree(fapl_id, H5F_CLOSE_SEMI);
+    CHECK_I(ret, "H5Pset_fclose_degree");
+
+    for (use_btree = 0; use_btree < 2; use_btree++) {
+        /* Create FCPL with SOHMs enabled
+         */
+        fcpl_id = H5Pcreate(H5P_FILE_CREATE);
+        CHECK_I(fcpl_id, "H5Pcreate");
+        ret = H5Pset_shared_mesg_nindexes(fcpl_id, num_indexes);
+        CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+        ret = H5Pset_shared_mesg_index(fcpl_id, 0, index_flags, min_mesg_size);
+        CHECK_I(ret, "H5Pset_shared_mesg_index");
+        if (use_btree) {
+            MESSAGE(5, ("----testing with btree index----\n"));
+            ret = H5Pset_shared_mesg_phase_change(fcpl_id, 0, 0);
+            CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
+        } else {
+            MESSAGE(5, ("----testing with normal index----\n"));
+            ret = H5Pset_shared_mesg_phase_change(fcpl_id, list_max, btree_min);
+            CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
+        }
+
+        /* Create empty file */
+        file = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, fapl_id);
+        CHECK_I(file, "H5Fcreate");
+        ret = H5Fclose(file);
+        CHECK_I(ret, "H5Fclose");
+
+        /* Test Open/Write
+         * Add messages to previously-created file */
+        file = H5Fopen(FILENAME, H5F_ACC_RDWR, fapl_id);
+        CHECK_I(file, "H5Fopen");
+        file = size1_helper(file, FILENAME, fapl_id, 0);
+        CHECK_I(file, "size1_helper");
+
+        /* Get the size of a dataset object header */
+	ret = H5Oget_info_by_name2(file, DSETNAME[0], &oinfo, H5O_INFO_HDR, H5P_DEFAULT);
+        CHECK_I(ret, "H5Oget_info_by_name");
+        oh_size_open = oinfo.hdr.space.total;
+
+        ret = H5Fclose(file);
+        CHECK_I(ret, "H5Fclose");
+
+        /* Test Create/Write
+         * Add messages to a newly-created file */
+        file = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, fapl_id);
+        CHECK_I(file, "H5Fcreate");
+        file = size1_helper(file, FILENAME, fapl_id, 0);
+        CHECK_I(file, "size1_helper");
+
+        /* Get the size of a dataset object header */
+        ret = H5Oget_info_by_name2(file, DSETNAME[0], &oinfo, H5O_INFO_HDR, H5P_DEFAULT);
+        CHECK_I(ret, "H5Oget_info_by_name");
+        oh_size_create = oinfo.hdr.space.total;
+
+        ret = H5Fclose(file);
+        CHECK_I(ret, "H5Fclose");
+
+        VERIFY(oh_size_create, oh_size_open, "H5Oget_info_by_name2");
+
+        ret = H5Pclose(fcpl_id);
+        CHECK_I(ret, "H5Pclose");
+    } /* for normal/btree indexing */
+
     ret = H5Pclose(fapl_id);
     CHECK_I(ret, "H5Pclose");
-}
+} /* test_sohm_size_consistency_open_create */
 
 
 /*-------------------------------------------------------------------------
@@ -966,149 +1055,110 @@ static void test_sohm_size1(void)
  *
  * Purpose:     Given an fcpl, tests creating attributes with and without
  *              committed datatypes.
+ *              Verify that an attribute can be written and read back.
+ *              Tests attribute on a Group.
+ *              Tests committed and non-committed datatypes.
+ *              Tests attribute access through `H5Aopen()`.
  *
  * Programmer:  James Laird
  *              Thursday, November 30, 2006
  *
  *-------------------------------------------------------------------------
  */
-static void sohm_attr_helper(hid_t fcpl_id)
+static void
+sohm_attr_helper(hid_t fcpl_id)
 {
     hid_t file_id;
-    hid_t type_id;
     hid_t space_id;
-    hid_t group_id;
-    hid_t attr_id, attr_id2;
     hsize_t dims = 2;
     int wdata[2] = {7, 42};
     int rdata[2];
     herr_t ret;
     size_t x;
+    unsigned op_index=0;
+#define TSOHM_SAH_OP_COUNT 3
+    const char *groupnames[TSOHM_SAH_OP_COUNT] = {
+        "group_for_nothing_special",
+        "group_for_commited_dtype",
+        "group_for_commited_dtype_and_other_ID_access",
+    };
 
-    /*----------------------------------------------------------------------------
-     *    Test attribute with transient datatype
-     */
-    /* Create a file using the fcpl */
     file_id = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, H5P_DEFAULT);
     CHECK_I(file_id, "H5Fcreate");
 
-    /* Create a normal datatype and dataset */
-    type_id = H5Tcopy(H5T_NATIVE_INT);
-    CHECK_I(type_id, "H5Tcopy");
     space_id = H5Screate_simple(1, &dims, &dims);
     CHECK_I(space_id, "H5Screate_simple");
 
-    /* Create and verify an attribute on a group */
-    group_id = H5Gcreate2(file_id, "group", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    CHECK_I(group_id, "H5Gcreate2");
-    attr_id = H5Acreate2(group_id, "attribute", type_id, space_id, H5P_DEFAULT, H5P_DEFAULT);
-    CHECK_I(attr_id, "H5Acreate2");
-    ret = H5Awrite(attr_id, H5T_NATIVE_INT, wdata);
-    CHECK_I(ret, "H5Awrite");
-
-    /* Close the datatype and group */
-    ret = H5Tclose(type_id);
-    CHECK_I(ret, "H5Tclose");
-    ret = H5Gclose(group_id);
-    CHECK_I(ret, "H5Gclose");
-
-    /* Flush the file to force data to be written */
-    ret = H5Fflush(file_id, H5F_SCOPE_GLOBAL);
-    CHECK_I(ret, "H5Fflush");
-
-    /* Verify */
-    HDmemset(rdata, 0, sizeof(rdata));
-    ret = H5Aread(attr_id, H5T_NATIVE_INT, rdata);
-    CHECK_I(ret, "H5Aread");
-    for(x = 0; x < (size_t)dims; ++x)
-        VERIFY(rdata[x], wdata[x], "H5Aread");
-
-    /* Cleanup */
-    ret = H5Aclose(attr_id);
-    CHECK_I(ret, "H5Aclose");
-
-    /*----------------------------------------------------------------------------
-     *    Test attribute with committed datatype
+    /* loop:
+     * 0 - nothing special
+     * 1 - committed datatype
+     * 2 - committed datatype, read through second ID
      */
-    /* Repeat with a committed datatype */
-    type_id = H5Tcopy(H5T_NATIVE_INT);
-    CHECK_I(type_id, "H5Tcopy");
-    ret = H5Tcommit2(file_id, "datatype", type_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    CHECK_I(ret, "H5Tcommit2");
-
-    /* Create and verify an attribute */
-    group_id = H5Gcreate2(file_id, "another_group", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    CHECK_I(group_id, "H5Gcreate2");
-    attr_id = H5Acreate2(group_id, "attribute", type_id, space_id, H5P_DEFAULT, H5P_DEFAULT);
-    CHECK_I(attr_id, "H5Acreate2");
-    ret = H5Awrite(attr_id, H5T_NATIVE_INT, wdata);
-    CHECK_I(ret, "H5Awrite");
-
-    /* Close the datatype and group */
-    ret = H5Tclose(type_id);
-    CHECK_I(ret, "H5Tclose");
-    ret = H5Gclose(group_id);
-    CHECK_I(ret, "H5Gclose");
-
-    /* Flush the file to force data to be written */
-    ret = H5Fflush(file_id, H5F_SCOPE_GLOBAL);
-    CHECK_I(ret, "H5Fflush");
+    for (op_index = 0; op_index < TSOHM_SAH_OP_COUNT; op_index++) {
+        hid_t type_id  = -1;
+        hid_t group_id = -1;
+        hid_t attr_id  = -1;
+        hid_t attr_id2 = -1;
+        hid_t attr_read_id;
 
-    /* Verify */
-    HDmemset(rdata, 0, sizeof(rdata));
-    ret = H5Aread(attr_id, H5T_NATIVE_INT, rdata);
-    CHECK_I(ret, "H5Aread");
-    for(x = 0; x < (size_t)dims; ++x)
-        VERIFY(rdata[x], wdata[x], "H5Aread");
+        /* create group in file with name unique to op_index */
+        group_id = H5Gcreate2(file_id, groupnames[op_index], H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+        CHECK_I(group_id, "H5Gcreate2");
 
-    /* Cleanup */
-    ret = H5Aclose(attr_id);
-    CHECK_I(ret, "H5Aclose");
+        type_id = H5Tcopy(H5T_NATIVE_INT);
+        CHECK_I(type_id, "H5Tcopy");
 
-    /*----------------------------------------------------------------------------
-     *    Test attribute operation with two ID handles
-     */
-    /* Create and verify an attribute */
-    group_id = H5Gcreate2(file_id, "yet_another_group", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
-    CHECK_I(group_id, "H5Gcreate2");
-
-    attr_id = H5Acreate2(group_id, "attribute", H5T_NATIVE_INT, space_id, H5P_DEFAULT, H5P_DEFAULT);
-    CHECK_I(attr_id, "H5Acreate2");
+        /* Commit the datatype for the latter iterations.
+         * Only do this ONCE.
+         */
+        if (op_index == 1) {
+            ret = H5Tcommit2(file_id, "datatype", type_id, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+            CHECK_I(ret, "H5Tcommit2");
+        }
 
-    /* Open the attribute to get another handle */
-    attr_id2 = H5Aopen(group_id, "attribute", H5P_DEFAULT);
-    CHECK_I(attr_id2, "H5Aopen");
+        attr_id = H5Acreate2(group_id, "attribute", type_id, space_id, H5P_DEFAULT, H5P_DEFAULT);
+        CHECK_I(attr_id, "H5Acreate2");
 
-    ret = H5Awrite(attr_id, H5T_NATIVE_INT, wdata);
-    CHECK_I(ret, "H5Awrite");
+        if (op_index == 2) {
+            /* Open the attribute to get another handle */
+            attr_id2 = H5Aopen(group_id, "attribute", H5P_DEFAULT);
+            CHECK_I(attr_id2, "H5Aopen");
+        }
 
-    /* Close the group */
-    ret = H5Gclose(group_id);
-    CHECK_I(ret, "H5Gclose");
+        ret = H5Awrite(attr_id, H5T_NATIVE_INT, wdata);
+        CHECK_I(ret, "H5Awrite");
 
-    /* Flush the file to force data to be written */
-    ret = H5Fflush(file_id, H5F_SCOPE_GLOBAL);
-    CHECK_I(ret, "H5Fflush");
+        ret = H5Gclose(group_id);
+        CHECK_I(ret, "H5Gclose");
+        ret = H5Tclose(type_id);
+        CHECK_I(ret, "H5Tclose")
 
-    /* Verify the data with another ID handle */
-    HDmemset(rdata, 0, sizeof(rdata));
-    ret = H5Aread(attr_id2, H5T_NATIVE_INT, rdata);
-    CHECK_I(ret, "H5Aread");
+        /* Flush the file to force data to be written */
+        ret = H5Fflush(file_id, H5F_SCOPE_GLOBAL);
+        CHECK_I(ret, "H5Fflush");
 
-    for(x = 0; x < (size_t)dims; ++x)
-        VERIFY(rdata[x], wdata[x], "H5Aread");
+        /* Verify */
+        attr_read_id = (op_index == 2) ? attr_id2 : attr_id;
+        HDmemset(rdata, 0, sizeof(rdata));
+        ret = H5Aread(attr_read_id, H5T_NATIVE_INT, rdata);
+        CHECK_I(ret, "H5Aread");
+        for(x = 0; x < (size_t)dims; ++x)
+            VERIFY(rdata[x], wdata[x], "H5Aread");
 
-    /* Cleanup */
-    ret = H5Aclose(attr_id);
-    CHECK_I(ret, "H5Aclose");
-    ret = H5Aclose(attr_id2);
-    CHECK_I(ret, "H5Aclose");
+        ret = H5Aclose(attr_id);
+        CHECK_I(ret, "H5Aclose");
+        if (attr_id2 > -1 ) {
+            ret = H5Aclose(attr_id2);
+            CHECK_I(ret, "H5Aclose");
+        }
+    } /* for each attribute operation */
 
     ret = H5Sclose(space_id);
     CHECK_I(ret, "H5Sclose");
     ret = H5Fclose(file_id);
     CHECK_I(ret, "H5Fclose");
-}
+#undef TSOHM_SAH_OP_COUNT
+} /* sohm_attr_helper */
 
 
 /*-------------------------------------------------------------------------
@@ -1125,101 +1175,160 @@ static void sohm_attr_helper(hid_t fcpl_id)
  *
  *-------------------------------------------------------------------------
  */
-static void test_sohm_attrs(void)
+static void
+test_sohm_attrs(void)
 {
     hid_t fcpl_id;
+    unsigned i = 0;
+#define TSOHM_TSA_NFLAGS_1 7
+    unsigned flags1[TSOHM_TSA_NFLAGS_1] = {
+        H5O_SHMESG_ATTR_FLAG,
+        H5O_SHMESG_SDSPACE_FLAG,
+        H5O_SHMESG_DTYPE_FLAG,
+        H5O_SHMESG_ATTR_FLAG | H5O_SHMESG_SDSPACE_FLAG,
+        H5O_SHMESG_SDSPACE_FLAG | H5O_SHMESG_DTYPE_FLAG,
+        H5O_SHMESG_ATTR_FLAG | H5O_SHMESG_DTYPE_FLAG,
+        H5O_SHMESG_ATTR_FLAG | H5O_SHMESG_SDSPACE_FLAG | H5O_SHMESG_DTYPE_FLAG,
+    };
+#define TSOHM_TSA_NFLAGS_2 6
+    unsigned flags2[TSOHM_TSA_NFLAGS_2][2] = {
+        {   H5O_SHMESG_ATTR_FLAG,
+            H5O_SHMESG_SDSPACE_FLAG | H5O_SHMESG_DTYPE_FLAG,
+        },
+        {   H5O_SHMESG_SDSPACE_FLAG,
+            H5O_SHMESG_ATTR_FLAG | H5O_SHMESG_DTYPE_FLAG,
+        },
+        {   H5O_SHMESG_DTYPE_FLAG,
+            H5O_SHMESG_ATTR_FLAG | H5O_SHMESG_SDSPACE_FLAG,
+        },
+        {   H5O_SHMESG_SDSPACE_FLAG | H5O_SHMESG_DTYPE_FLAG,
+            H5O_SHMESG_ATTR_FLAG,
+        },
+        {   H5O_SHMESG_ATTR_FLAG | H5O_SHMESG_DTYPE_FLAG,
+            H5O_SHMESG_SDSPACE_FLAG,
+        },
+        {   H5O_SHMESG_ATTR_FLAG | H5O_SHMESG_SDSPACE_FLAG,
+            H5O_SHMESG_DTYPE_FLAG,
+        },
+    };
+#define TSOHM_TSA_NFLAGS_3 5
+    unsigned flags3[TSOHM_TSA_NFLAGS_3][3] = {
+        {   H5O_SHMESG_ATTR_FLAG,
+            H5O_SHMESG_SDSPACE_FLAG,
+            H5O_SHMESG_DTYPE_FLAG,
+        },
+        {   H5O_SHMESG_DTYPE_FLAG,
+            H5O_SHMESG_ATTR_FLAG,
+            H5O_SHMESG_SDSPACE_FLAG,
+        },
+        {   H5O_SHMESG_SDSPACE_FLAG,
+            H5O_SHMESG_DTYPE_FLAG,
+            H5O_SHMESG_ATTR_FLAG,
+        },
+        {   0, /* first index does not hold a shared message type? */
+            H5O_SHMESG_SDSPACE_FLAG | H5O_SHMESG_DTYPE_FLAG,
+            H5O_SHMESG_ATTR_FLAG,
+        },
+        {   0, /* missing SDSPACE flag */
+            H5O_SHMESG_DTYPE_FLAG,
+            H5O_SHMESG_ATTR_FLAG,
+        },
+    };
     herr_t ret;
 
     MESSAGE(5, ("Testing that shared messages work with attributes\n"));
 
-    /* Create an fcpl with no shared messages */
+    /* No shared messages */
     fcpl_id = H5Pcreate(H5P_FILE_CREATE);
     CHECK_I(fcpl_id, "H5Pcreate");
     ret = H5Pset_shared_mesg_nindexes(fcpl_id, 0);
     CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
 
-    /* Make sure attributes can be read with these settings (they'd better!) */
-    sohm_attr_helper(fcpl_id);
-
-
-    /* Run tests with only one kind of message to be shared */
-    ret = H5Pset_shared_mesg_nindexes(fcpl_id, 1);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-    ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_ATTR_FLAG, 2);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-
-    /* Verify */
-    sohm_attr_helper(fcpl_id);
-
-    ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_SDSPACE_FLAG, 2);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-
-    sohm_attr_helper(fcpl_id);
-
-    ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_DTYPE_FLAG, 2);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-
-    sohm_attr_helper(fcpl_id);
-
-
-    /* Run with any two types shared */
-    ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_SDSPACE_FLAG | H5O_SHMESG_DTYPE_FLAG, 2);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-
-    sohm_attr_helper(fcpl_id);
-
-    ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_ATTR_FLAG | H5O_SHMESG_DTYPE_FLAG, 2);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-
-    sohm_attr_helper(fcpl_id);
-
-    ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_SDSPACE_FLAG | H5O_SHMESG_ATTR_FLAG, 2);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-
     sohm_attr_helper(fcpl_id);
 
+    ret = H5Pclose(fcpl_id);
+    CHECK_I(ret, "H5Pclose");
 
-    /* Run test with all three kinds of message shared */
-    ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_SDSPACE_FLAG | H5O_SHMESG_DTYPE_FLAG | H5O_SHMESG_ATTR_FLAG, 2);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+    /* One shared message index
+     */
+    for (i=0; i < TSOHM_TSA_NFLAGS_1; i++) {
+        fcpl_id = H5Pcreate(H5P_FILE_CREATE);
+        CHECK_I(fcpl_id, "H5Pcreate");
+        ret = H5Pset_shared_mesg_nindexes(fcpl_id, 1);
+        CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+        ret = H5Pset_shared_mesg_index(fcpl_id, 0, flags1[i], 2);
+        CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
 
-    sohm_attr_helper(fcpl_id);
+        sohm_attr_helper(fcpl_id);
 
+        ret = H5Pclose(fcpl_id);
+        CHECK_I(ret, "H5Pclose");
+    }
 
-    /* Try using two indexes */
-    ret = H5Pset_shared_mesg_nindexes(fcpl_id, 2);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-    ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_ATTR_FLAG | H5O_SHMESG_DTYPE_FLAG, 2);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-    ret = H5Pset_shared_mesg_index(fcpl_id, 1, H5O_SHMESG_SDSPACE_FLAG, 2);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+    /* two shared message indices
+     */
+    for (i=0; i < TSOHM_TSA_NFLAGS_2; i++) {
+        fcpl_id = H5Pcreate(H5P_FILE_CREATE);
+        CHECK_I(fcpl_id, "H5Pcreate");
+        ret = H5Pset_shared_mesg_nindexes(fcpl_id, 2);
+        CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+        ret = H5Pset_shared_mesg_index(fcpl_id, 0, flags2[i][0], 2);
+        CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+        ret = H5Pset_shared_mesg_index(fcpl_id, 1, flags2[i][1], 2);
+        CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
 
-    sohm_attr_helper(fcpl_id);
+        sohm_attr_helper(fcpl_id);
 
-    ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_DTYPE_FLAG, 2);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+        ret = H5Pclose(fcpl_id);
+        CHECK_I(ret, "H5Pclose");
+    }
 
-    sohm_attr_helper(fcpl_id);
+    /* duplicate flags in separate indices causes problems
+     */
+    H5E_BEGIN_TRY {
+        fcpl_id = H5Pcreate(H5P_FILE_CREATE);
+        CHECK_I(fcpl_id, "H5Pcreate");
+        ret = H5Pset_shared_mesg_nindexes(fcpl_id, 2);
+        CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+        ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_ATTR_FLAG, 2);
+        CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+        ret = H5Pset_shared_mesg_index(fcpl_id, 1, H5O_SHMESG_ATTR_FLAG, 2);
+        CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+
+        ret = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, H5P_DEFAULT);
+        VERIFY(ret, -1, "H5Fcreate");
+
+        ret = H5Pclose(fcpl_id);
+        CHECK_I(ret, "H5Pclose");
+    } H5E_END_TRY;
 
-    ret = H5Pset_shared_mesg_index(fcpl_id, 1, H5O_SHMESG_ATTR_FLAG, 2);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+    /* three shared message indices
+     */
+    for (i=0; i < TSOHM_TSA_NFLAGS_3; i++) {
+        fcpl_id = H5Pcreate(H5P_FILE_CREATE);
+        CHECK_I(fcpl_id, "H5Pcreate");
+        ret = H5Pset_shared_mesg_nindexes(fcpl_id, 3);
+        CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+        ret = H5Pset_shared_mesg_index(fcpl_id, 0, flags3[i][0], 2);
+        CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+        ret = H5Pset_shared_mesg_index(fcpl_id, 1, flags3[i][1], 2);
+        CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+        ret = H5Pset_shared_mesg_index(fcpl_id, 2, flags3[i][2], 2);
+        CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
 
-    sohm_attr_helper(fcpl_id);
+        sohm_attr_helper(fcpl_id);
 
+        ret = H5Pclose(fcpl_id);
+        CHECK_I(ret, "H5Pclose");
+    }
 
-    /* One index for each kind of message */
-    ret = H5Pset_shared_mesg_nindexes(fcpl_id, 3);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-    ret = H5Pset_shared_mesg_index(fcpl_id, 2, H5O_SHMESG_SDSPACE_FLAG, 2);
-    CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
+#undef TSOHM_TSA_NFLAGS_1
+#undef TSOHM_TSA_NFLAGS_2
+#undef TSOHM_TSA_NFLAGS_3
 
-    sohm_attr_helper(fcpl_id);
+} /* test_sohm_attrs */
 
 
-    /* Close the FCPL */
-    ret = H5Pclose(fcpl_id);
-    CHECK_I(ret, "H5Pclose");
-}
 
 /*-------------------------------------------------------------------------
  * Function:    size2_verify_plist1
@@ -1233,7 +1342,8 @@ static void test_sohm_attrs(void)
  *
  *-------------------------------------------------------------------------
  */
-static void size2_verify_plist1(hid_t plist)
+static void
+size2_verify_plist1(hid_t plist)
 {
     size_t cd_nelmts;
     unsigned int cd_value;
@@ -1281,7 +1391,8 @@ static void size2_verify_plist1(hid_t plist)
 
     ret = H5Tclose(dtype1_id);
     CHECK_I(ret, "H5Tclose");
-}
+} /* size2_verify_plist1 */
+
 
 /*-------------------------------------------------------------------------
  * Function:    size2_verify_plist2
@@ -1295,7 +1406,8 @@ static void size2_verify_plist1(hid_t plist)
  *
  *-------------------------------------------------------------------------
  */
-static void size2_verify_plist2(hid_t plist)
+static void
+size2_verify_plist2(hid_t plist)
 {
     size_t cd_nelmts;
     unsigned int cd_value;
@@ -1352,7 +1464,7 @@ static void size2_verify_plist2(hid_t plist)
 
     ret = H5Tclose(dtype2_id);
     CHECK_I(ret, "H5Tclose");
-}
+} /* size2_verify_plist2 */
 
 #ifdef NOT_NOW
 
@@ -1382,7 +1494,7 @@ size2_dump_struct(const char *name, size2_helper_struct *sizes)
   printf("   interleaved: %llu \tdelta: %llu\n", (unsigned long long)sizes->interleaved, (unsigned long long)(sizes->interleaved - sizes->dsets2));
   printf("    attributes: %llu \tdelta: %llu\n", (unsigned long long)sizes->attrs1, (unsigned long long)(sizes->attrs1 - sizes->interleaved));
   printf("  attributes 2: %llu \tdelta: %llu\n", (unsigned long long)sizes->attrs2, (unsigned long long)(sizes->attrs2 - sizes->attrs1));
-}
+} /* size2_dump_struct */
 #endif /* NOT_NOW */
 
 
@@ -1573,15 +1685,14 @@ size2_helper(hid_t fcpl_id, int test_file_closing, size2_helper_struct *ret_size
     ret_sizes->dsets1 = h5_get_file_size(FILENAME, H5P_DEFAULT);
 
 
-    /* Now create a new group filled with datasets that use all different messages */
+    /* Create new group filled with datasets that use all different messages */
     file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
     CHECK_I(file_id, "H5Fopen");
     group_id = H5Gcreate2(file_id, "group", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
     CHECK_I(group_id, "H5Gcreate2");
 
     /* Create NUM_DATASETS datasets in the new group */
-    for(x=0; x<NUM_DATASETS; ++x)
-    {
+    for(x=0; x<NUM_DATASETS; ++x) {
         dset_id = H5Dcreate2(group_id, DSETNAME[x], dtype2_id, dspace2_id, H5P_DEFAULT, dcpl2_id, H5P_DEFAULT);
         CHECK_I(dset_id, "H5Dcreate2");
 
@@ -1604,7 +1715,7 @@ size2_helper(hid_t fcpl_id, int test_file_closing, size2_helper_struct *ret_size
             group_id = H5Gopen2(file_id, "group", H5P_DEFAULT);
             CHECK_I(group_id, "H5Gopen2");
         }
-    }
+    } /* for each dataset */
 
     /* Close file and get its size now */
     ret = H5Gclose(group_id);
@@ -1621,8 +1732,7 @@ size2_helper(hid_t fcpl_id, int test_file_closing, size2_helper_struct *ret_size
     CHECK_I(group_id, "H5Gcreate2");
 
     /* Create NUM_DATASETS datasets in the new group */
-    for(x=0; x<NUM_DATASETS; x+=2)
-    {
+    for(x=0; x<NUM_DATASETS; x+=2) {
         dset_id = H5Dcreate2(group_id, DSETNAME[x], dtype1_id, dspace1_id, H5P_DEFAULT, dcpl1_id, H5P_DEFAULT);
         CHECK_I(dset_id, "H5Dcreate2");
 
@@ -1658,7 +1768,7 @@ size2_helper(hid_t fcpl_id, int test_file_closing, size2_helper_struct *ret_size
             group_id = H5Gopen2(file_id, "interleaved group", H5P_DEFAULT);
             CHECK_I(group_id, "H5Gopen2");
         }
-    }
+    } /* for each even dataset */
 
     /* Close file and get its size now */
     ret = H5Gclose(group_id);
@@ -1700,7 +1810,7 @@ size2_helper(hid_t fcpl_id, int test_file_closing, size2_helper_struct *ret_size
             group_id = H5Gopen2(file_id, "group", H5P_DEFAULT);
             CHECK_I(group_id, "H5Gopen2");
         }
-    }
+    } /* for each attribute */
 
     /* Close file and get its size now */
     ret = H5Gclose(group_id);
@@ -1716,8 +1826,7 @@ size2_helper(hid_t fcpl_id, int test_file_closing, size2_helper_struct *ret_size
     group_id = H5Gopen2(file_id, "interleaved group", H5P_DEFAULT);
     CHECK_I(group_id, "H5Gopen2");
 
-    for(x=0; x<NUM_ATTRIBUTES; ++x)
-    {
+    for(x=0; x<NUM_ATTRIBUTES; ++x) {
         /* Create the same name and value for each attribute as before */
         attr_string1[0] = attr_name[0] = (char)((x / 10) + '0');
         attr_string1[1] = attr_name[1] = (char)((x % 10) + '0');
@@ -1740,7 +1849,8 @@ size2_helper(hid_t fcpl_id, int test_file_closing, size2_helper_struct *ret_size
             group_id = H5Gopen2(file_id, "interleaved group", H5P_DEFAULT);
             CHECK_I(group_id, "H5Gopen2");
         }
-    }
+    } /* for each attribute */
+
     /* Close file and get its size now */
     ret = H5Gclose(group_id);
     CHECK_I(ret, "H5Gclose");
@@ -1768,7 +1878,7 @@ size2_helper(hid_t fcpl_id, int test_file_closing, size2_helper_struct *ret_size
     CHECK_I(ret, "H5Pclose");
 
     return 0;
-}
+} /* size2_helper */
 
 
 /*-------------------------------------------------------------------------
@@ -1785,7 +1895,8 @@ size2_helper(hid_t fcpl_id, int test_file_closing, size2_helper_struct *ret_size
  *
  *-------------------------------------------------------------------------
  */
-static void size2_verify(void)
+static void
+size2_verify(void)
 {
     hid_t file_id = -1;
     hid_t dset_id=-1;
@@ -1957,7 +2068,7 @@ static void size2_verify(void)
         CHECK_I(attr1_id, "H5Aclose");
         ret = H5Aclose(attr2_id);
         CHECK_I(attr2_id, "H5Aclose");
-    }
+    } /* for each attribute */
 
     /* Close everything */
     ret = H5Tclose(attr_type_id);
@@ -1968,7 +2079,7 @@ static void size2_verify(void)
     CHECK_I(ret, "H5Gclose");
     ret = H5Fclose(file_id);
     CHECK_I(ret, "H5Fclose");
-}
+} /* size2_verify */
 
 
 /*-------------------------------------------------------------------------
@@ -1993,7 +2104,8 @@ static void size2_verify(void)
  *
  *-------------------------------------------------------------------------
  */
-static void test_sohm_size2(int close_reopen)
+static void
+test_sohm_size2(int close_reopen)
 {
     hid_t       fcpl_id = -1;
     /* Sizes for file with no shared messages at all */
@@ -2585,7 +2697,7 @@ static void test_sohm_size2(int close_reopen)
         VERIFY(0, 1, "h5_get_file_size");
     if((h5_stat_size_t)((float)share_tiny_index.attrs2 * OVERHEAD_ALLOWED) < type_space_index.attrs2)
         VERIFY(0, 1, "h5_get_file_size");
-} /* end test_sohm_size2() */
+} /* end test_sohm_size2() */ 
 
 
 /*-------------------------------------------------------------------------
@@ -2601,27 +2713,24 @@ static void test_sohm_size2(int close_reopen)
  *
  *-------------------------------------------------------------------------
  */
-static void delete_helper_write(hid_t file_id, hid_t *dspace_id, hid_t *dcpl_id, int x)
+static void
+delete_helper_write(hid_t file_id, hid_t *dspace_id, hid_t *dcpl_id, int x)
 {
     hid_t dset_id = -1;
     hid_t attr_id = -1;
     char wdata;
     herr_t ret;
 
-    /* Create dataset */
     dset_id = H5Dcreate2(file_id, DSETNAME[x], H5T_NATIVE_CHAR, dspace_id[x], H5P_DEFAULT, dcpl_id[x], H5P_DEFAULT);
     CHECK_I(dset_id, "H5Dcreate2");
 
-    /* Write data to dataset */
     wdata = (char)(x + 'a');
     ret = H5Dwrite(dset_id, H5T_NATIVE_CHAR, dspace_id[x], dspace_id[x], H5P_DEFAULT, &wdata);
     CHECK_I(ret, "H5Dwrite");
 
-    /* Create an attribute on the dataset. */
     attr_id = H5Acreate2(dset_id, "attr_name", H5T_NATIVE_CHAR, dspace_id[x], H5P_DEFAULT, H5P_DEFAULT);
     CHECK_I(attr_id, "H5Acreate2");
 
-    /* Write to attribute */
     ret = H5Awrite(attr_id, H5T_NATIVE_CHAR, &wdata);
     CHECK_I(ret, "H5Awrite");
 
@@ -2629,7 +2738,7 @@ static void delete_helper_write(hid_t file_id, hid_t *dspace_id, hid_t *dcpl_id,
     CHECK_I(ret, "H5Aclose");
     ret = H5Dclose(dset_id);
     CHECK_I(ret, "H5Dclose");
-}
+} /* delete_helper_write */
 
 
 /*-------------------------------------------------------------------------
@@ -2645,28 +2754,25 @@ static void delete_helper_write(hid_t file_id, hid_t *dspace_id, hid_t *dcpl_id,
  *
  *-------------------------------------------------------------------------
  */
-static void delete_helper_read(hid_t file_id, hid_t *dspace_id, int x)
+static void
+delete_helper_read(hid_t file_id, hid_t *dspace_id, int x)
 {
     hid_t dset_id = -1;
     hid_t attr_id = -1;
     char rdata;
     herr_t ret;
 
-    /* Open dataset */
     dset_id = H5Dopen2(file_id, DSETNAME[x], H5P_DEFAULT);
     CHECK_I(dset_id, "H5Dopen2");
 
-    /* Read */
     rdata = '\0';
     ret = H5Dread(dset_id, H5T_NATIVE_CHAR, dspace_id[x], dspace_id[x], H5P_DEFAULT, &rdata);
     CHECK_I(ret, "H5Dread");
     VERIFY(rdata, (x + 'a'), "H5Dread");
 
-    /* Open attribute */
     attr_id = H5Aopen(dset_id, "attr_name", H5P_DEFAULT);
     CHECK_I(attr_id, "H5Aopen");
 
-    /* Read */
     rdata = '\0';
     ret = H5Aread(attr_id, H5T_NATIVE_CHAR, &rdata);
     CHECK_I(ret, "H5Dread");
@@ -2677,7 +2783,7 @@ static void delete_helper_read(hid_t file_id, hid_t *dspace_id, int x)
     CHECK_I(ret, "H5Aclose");
     ret = H5Dclose(dset_id);
     CHECK_I(ret, "H5Dclose");
-}
+} /* delete_helper_read */
 
 
 /*-------------------------------------------------------------------------
@@ -2701,7 +2807,8 @@ static void delete_helper_read(hid_t file_id, hid_t *dspace_id, int x)
  *
  *-------------------------------------------------------------------------
  */
-static void delete_helper(hid_t fcpl_id, hid_t *dspace_id, hid_t *dcpl_id)
+static void
+delete_helper(hid_t fcpl_id, hid_t *dspace_id, hid_t *dcpl_id)
 {
     hid_t file_id=-1;
     int x;
@@ -2765,7 +2872,7 @@ static void delete_helper(hid_t fcpl_id, hid_t *dspace_id, hid_t *dcpl_id)
         VERIFY(norm_filesize, deleted_filesize, "h5_get_file_size");
     if(deleted_filesize > (h5_stat_size_t)((float)norm_filesize * OVERHEAD_ALLOWED))
         VERIFY(deleted_filesize, norm_filesize, "h5_get_file_size");
-}
+} /* delete_helper */
 
 
 /*-------------------------------------------------------------------------
@@ -2799,6 +2906,8 @@ test_sohm_delete(void)
     hsize_t dims[] = DELETE_DIMS;
     herr_t ret;
 
+    MESSAGE(5, ("Testing deletion of SOHMs\n"));
+
     /* Create a number of different dataspaces.
      * For simplicity, each dataspace has only one element.
      */
@@ -2914,13 +3023,14 @@ test_sohm_delete(void)
 
 
 /*-------------------------------------------------------------------------
- * Function:    test_sohm_delete_revert_helper
+ * Function:    verify_dset_create_and_delete_does_not_grow_file
  *
  * Purpose:     Tests that shared object header message deletion returns
  *              the file to its previous state using the supplied FCPL.
  *
- *              Creates shared messages and then deletes them.  Ensures
- *              that the file has not grown in size.
+ *              Creates a file according to the supplied FCPL,
+ *              then creates datasets and deletes them.
+ *              Done in two passes: once with one dataset, once with two.
  *
  * Programmer:  James Laird
  *              Wednesday, January 3, 2007
@@ -2930,7 +3040,7 @@ test_sohm_delete(void)
  *-------------------------------------------------------------------------
  */
 static int
-test_sohm_delete_revert_helper(hid_t fcpl_id)
+verify_dset_create_and_delete_does_not_grow_file(hid_t fcpl_id)
 {
     hid_t file_id;
     hid_t dspace_id;
@@ -3017,13 +3127,14 @@ test_sohm_delete_revert_helper(hid_t fcpl_id)
         return(0);
     else
         return(-1);
-} /* test_sohm_delete_revert_helper() */
+} /* verify_dset_create_and_delete_does_not_grow_file */
 
 
 /*-------------------------------------------------------------------------
  * Function:    test_sohm_delete_revert
  *
- * Purpose:     Calls test_sohm_delete_revert_helper with different FCPLs.
+ * Purpose:     Verifies that creation and deletion of datasets with shared
+ *              message headers will not increase file size.
  *
  * Programmer:  James Laird
  *              Wednesday, January 3, 2007
@@ -3038,6 +3149,8 @@ test_sohm_delete_revert(void)
     hid_t fcpl_id;
     herr_t ret;
 
+    MESSAGE(5, ("Testing that file reverts to original size on SOHM deletion\n"));
+
     /* Create an fcpl with messages in two indexes */
     fcpl_id = H5Pcreate(H5P_FILE_CREATE);
     CHECK_I(fcpl_id, "H5Pcreate");
@@ -3049,14 +3162,14 @@ test_sohm_delete_revert(void)
     CHECK_I(ret, "H5Pset_shared_mesg_index");
 
     /* Call the helper function to test this FCPL. */
-    ret = test_sohm_delete_revert_helper(fcpl_id);
-    CHECK_I(ret, "test_sohm_delete_revert_helper");
+    ret = verify_dset_create_and_delete_does_not_grow_file(fcpl_id);
+    CHECK_I(ret, "verify_dset_create_and_delete_does_not_grow_file");
 
     /* Try using B-trees */
     ret = H5Pset_shared_mesg_phase_change(fcpl_id, 0, 0);
     CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
-    ret = test_sohm_delete_revert_helper(fcpl_id);
-    CHECK_I(ret, "test_sohm_delete_revert_helper");
+    ret = verify_dset_create_and_delete_does_not_grow_file(fcpl_id);
+    CHECK_I(ret, "verify_dset_create_and_delete_does_not_grow_file");
 
 
     /* Try sharing all messages */
@@ -3067,14 +3180,14 @@ test_sohm_delete_revert(void)
     ret = H5Pset_shared_mesg_phase_change(fcpl_id, 10, 5);
     CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
 
-    ret = test_sohm_delete_revert_helper(fcpl_id);
-    CHECK_I(ret, "test_sohm_delete_revert_helper");
+    ret = verify_dset_create_and_delete_does_not_grow_file(fcpl_id);
+    CHECK_I(ret, "verify_dset_create_and_delete_does_not_grow_file");
 
     /* Try using B-trees */
     ret = H5Pset_shared_mesg_phase_change(fcpl_id, 0, 0);
     CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
-    ret = test_sohm_delete_revert_helper(fcpl_id);
-    CHECK_I(ret, "test_sohm_delete_revert_helper");
+    ret = verify_dset_create_and_delete_does_not_grow_file(fcpl_id);
+    CHECK_I(ret, "verify_dset_create_and_delete_does_not_grow_file");
 
     /* There should be at least two messages in the test (datatype and
      * dataspace).  Use an index that will transition from a list to
@@ -3082,8 +3195,8 @@ test_sohm_delete_revert(void)
      */
     ret = H5Pset_shared_mesg_phase_change(fcpl_id, 1, 2);
     CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
-    ret = test_sohm_delete_revert_helper(fcpl_id);
-    CHECK_I(ret, "test_sohm_delete_revert_helper");
+    ret = verify_dset_create_and_delete_does_not_grow_file(fcpl_id);
+    CHECK_I(ret, "verify_dset_create_and_delete_does_not_grow_file");
 
 
     /* Try with shared messages enabled, but when messages are too big
@@ -3091,16 +3204,16 @@ test_sohm_delete_revert(void)
      */
     ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_ALL_FLAG, 35);
     CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
-    ret = test_sohm_delete_revert_helper(fcpl_id);
-    CHECK_I(ret, "test_sohm_delete_revert_helper");
+    ret = verify_dset_create_and_delete_does_not_grow_file(fcpl_id);
+    CHECK_I(ret, "verify_dset_create_and_delete_does_not_grow_file");
 
     ret = H5Pclose(fcpl_id);
     CHECK_I(ret, "H5Pclose");
-}
+} /* test_sohm_delete_revert */
 
 
 /*-------------------------------------------------------------------------
- * Function:    test_sohm_extlink_helper
+ * Function:    verify_dset_create_and_open_through_extlink_with_sohm
  *
  * Purpose:     Tests that a dataset created through an external link can
  *              be opened (that shared messages were created or not and
@@ -3113,7 +3226,8 @@ test_sohm_delete_revert(void)
  *
  *-------------------------------------------------------------------------
  */
-static void test_sohm_extlink_helper(hid_t src_fcpl_id, hid_t dst_fcpl_id)
+static void
+verify_dset_create_and_open_through_extlink_with_sohm(hid_t src_fcpl_id, hid_t dst_fcpl_id)
 {
     hid_t src_file_id = -1;
     hid_t dst_file_id = -1;
@@ -3164,7 +3278,7 @@ static void test_sohm_extlink_helper(hid_t src_fcpl_id, hid_t dst_fcpl_id)
     CHECK_I(ret, "H5Dclose");
     ret = H5Fclose(dst_file_id);
     CHECK_I(ret, "H5Fclose");
-}
+} /* verify_dset_create_and_open_through_extlink_with_sohm */
 
 
 /*-------------------------------------------------------------------------
@@ -3186,7 +3300,8 @@ test_sohm_extlink(void)
     hid_t fcpl_id = -1;
     herr_t ret;
 
-    /* Create fcpl */
+    MESSAGE(5, ("Testing SOHM creation through external links\n"));
+
     fcpl_id = H5Pcreate(H5P_FILE_CREATE);
     CHECK_I(fcpl_id, "H5Pcreate");
     ret = H5Pset_shared_mesg_nindexes(fcpl_id, 1);
@@ -3194,20 +3309,17 @@ test_sohm_extlink(void)
     ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_ALL_FLAG, 16);
     CHECK_I(ret, "H5Pset_shared_mesg_index");
 
-    /* Test using external links when the source or destination file uses
-     * shared messages
-     */
-    test_sohm_extlink_helper(fcpl_id, H5P_DEFAULT);
-    test_sohm_extlink_helper(H5P_DEFAULT, fcpl_id);
-    test_sohm_extlink_helper(fcpl_id, fcpl_id);
+    verify_dset_create_and_open_through_extlink_with_sohm(fcpl_id, H5P_DEFAULT);
+    verify_dset_create_and_open_through_extlink_with_sohm(H5P_DEFAULT, fcpl_id);
+    verify_dset_create_and_open_through_extlink_with_sohm(fcpl_id, fcpl_id);
 
     ret = H5Pclose(fcpl_id);
     CHECK_I(ret, "H5Pclose");
-}
+} /* test_sohm_extlink */
 
 
 /*-------------------------------------------------------------------------
- * Function:    test_sohm_extend_dset_helper
+ * Function:    verify_dataset_extension
  *
  * Purpose:     Tests extending a dataset's dataspace when sharing is
  *              enabled.
@@ -3223,7 +3335,7 @@ test_sohm_extlink(void)
  *-------------------------------------------------------------------------
  */
 static int
-test_sohm_extend_dset_helper(hid_t fcpl_id, hbool_t close_reopen)
+verify_dataset_extension(hid_t fcpl_id, hbool_t close_reopen)
 {
     hid_t file_id = -1;
     hid_t orig_space_id = -1;
@@ -3239,10 +3351,95 @@ test_sohm_extend_dset_helper(hid_t fcpl_id, hbool_t close_reopen)
     int old_nerrs;              /* Number of errors when entering this routine */
     herr_t ret;
 
-    /* Retrieve the current # of reported errors */
+    hsize_t *space_dims[3];
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * Macro:      TSOHM_VDE_VERIFY_SPACES
+ *
+ * Purpose:    Encapsulate a common pattern
+ *             Open, read-verify, and close the dataspaces for datasets 1-3
+ *
+ * Programmer: Jacob Smith
+ *             2018 November 5
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ */
+#define TSOHM_VDE_VERIFY_SPACES(dims)                                     \
+{                                                                         \
+    /* Open dataspaces                                                    \
+     */                                                                   \
+    space1_id = H5Dget_space(dset1_id);                                   \
+    CHECK_I(space1_id, "H5Dget_space");                                   \
+    space2_id = H5Dget_space(dset2_id);                                   \
+    CHECK_I(space2_id, "H5Dget_space");                                   \
+    space3_id = H5Dget_space(dset3_id);                                   \
+    CHECK_I(space3_id, "H5Dget_space");                                   \
+    /* Verify dataspaces                                                  \
+     */                                                                   \
+    ret = H5Sget_simple_extent_dims(space1_id, out_dims, out_maxdims);    \
+    CHECK_I(ret, "H5Sget_simple_extent_dims");                            \
+    for(x=0; x<EXTEND_NDIMS; ++x) {                                       \
+        VERIFY(out_dims[x], (dims)[0][x], "H5Sget_simple_extent_dims");   \
+        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims"); \
+    }                                                                     \
+    ret = H5Sget_simple_extent_dims(space2_id, out_dims, out_maxdims);    \
+    CHECK_I(ret, "H5Sget_simple_extent_dims");                            \
+    for(x=0; x<EXTEND_NDIMS; ++x) {                                       \
+        VERIFY(out_dims[x], (dims)[1][x], "H5Sget_simple_extent_dims");   \
+        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims"); \
+    }                                                                     \
+    ret = H5Sget_simple_extent_dims(space3_id, out_dims, out_maxdims);    \
+    CHECK_I(ret, "H5Sget_simple_extent_dims");                            \
+    for(x=0; x<EXTEND_NDIMS; ++x) {                                       \
+        VERIFY(out_dims[x], (dims)[2][x], "H5Sget_simple_extent_dims");   \
+        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims"); \
+    }                                                                     \
+    /* Close dataspaces                                                   \
+     */                                                                   \
+    CHECK_I(H5Sclose(space1_id), "H5Sclose");                             \
+    CHECK_I(H5Sclose(space2_id), "H5Sclose");                             \
+    CHECK_I(H5Sclose(space3_id), "H5Sclose");                             \
+} /* define TSOHM_VDE_VERIFY_SPACES */
+
+/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ * Macro:      TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS()
+ *
+ * Purpose:    Encapsulate a common pattern
+ *             Wrapper to close and reopen file and datasets:
+ *                + "dataset" (dset_id)
+ *                + if n > 1 then include "dataset2" (dset_id2)
+ *                + if n > 2 then include "dataset3" (dset_id3)
+ *                + file (file_id)
+ *
+ * Programmer: Jacob Smith
+ *             2018 November 5
+ * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ */
+#define TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS(n)               \
+{                                                              \
+    CHECK_I(H5Dclose(dset1_id), "H5Dclose");                   \
+    if ((n) > 1)                                               \
+        CHECK_I(H5Dclose(dset2_id), "H5Dclose");               \
+    if ((n) > 2)                                               \
+        CHECK_I(H5Dclose(dset3_id), "H5Dclose");               \
+    CHECK_I(H5Fclose(file_id), "H5Fclose");                    \
+                                                               \
+    file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);    \
+    CHECK_I(file_id, "H5Fopen");                               \
+    dset1_id = H5Dopen2(file_id, "dataset", H5P_DEFAULT);      \
+    CHECK_I(dset1_id, "H5Dopen2");                             \
+    if ((n) > 1) {                                             \
+        dset2_id = H5Dopen2(file_id, "dataset2", H5P_DEFAULT); \
+        CHECK_I(dset2_id, "H5Dopen2");                         \
+    }                                                          \
+    if ((n) > 2) {                                             \
+        dset3_id = H5Dopen2(file_id, "dataset3", H5P_DEFAULT); \
+        CHECK_I(dset3_id, "H5Dopen2");                         \
+    }                                                          \
+} /* define TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS */
+
+    /* Remember the current # of reported errors */
     old_nerrs = GetTestNumErrs();
 
-    /* Create file */
     file_id = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl_id, H5P_DEFAULT);
     CHECK_I(file_id, "H5Fcreate");
 
@@ -3258,250 +3455,52 @@ test_sohm_extend_dset_helper(hid_t fcpl_id, hbool_t close_reopen)
     dset1_id = H5Dcreate2(file_id, "dataset", H5T_NATIVE_LONG, orig_space_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT);
     CHECK_I(dset1_id, "H5Dcreate2");
 
-    if(close_reopen) {
-        /* If requested, close all open IDs and reopen them */
-        ret = H5Dclose(dset1_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Fclose(file_id);
-        CHECK_I(ret, "H5Fclose");
-
-        file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
-        CHECK_I(file_id, "H5Fopen");
-        dset1_id = H5Dopen2(file_id, "dataset", H5P_DEFAULT);
-        CHECK_I(dset1_id, "H5Dopen2");
-    }
+    if(close_reopen)
+        TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS(1);
 
     /* Create another dataset starting with the same dataspace */
     dset2_id = H5Dcreate2(file_id, "dataset2", H5T_NATIVE_LONG, orig_space_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT);
     CHECK_I(dset2_id, "H5Dcreate2");
 
-    if(close_reopen) {
-        /* If requested, close all open IDs and reopen them */
-        ret = H5Dclose(dset1_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset2_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Fclose(file_id);
-        CHECK_I(ret, "H5Fclose");
-
-        file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
-        CHECK_I(file_id, "H5Fopen");
-        dset1_id = H5Dopen2(file_id, "dataset", H5P_DEFAULT);
-        CHECK_I(dset1_id, "H5Dopen2");
-        dset2_id = H5Dopen2(file_id, "dataset2", H5P_DEFAULT);
-        CHECK_I(dset2_id, "H5Dopen2");
-    }
+    if(close_reopen)
+        TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS(2);
 
     /* Create a third dataset with the same dataspace */
     dset3_id = H5Dcreate2(file_id, "dataset3", H5T_NATIVE_LONG, orig_space_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT);
     CHECK_I(dset3_id, "H5Dcreate2");
 
-    if(close_reopen) {
-        /* If requested, close all open IDs and reopen them */
-        ret = H5Dclose(dset1_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset2_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset3_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Fclose(file_id);
-        CHECK_I(ret, "H5Fclose");
-
-        file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
-        CHECK_I(file_id, "H5Fopen");
-        dset1_id = H5Dopen2(file_id, "dataset", H5P_DEFAULT);
-        CHECK_I(dset1_id, "H5Dopen2");
-        dset2_id = H5Dopen2(file_id, "dataset2", H5P_DEFAULT);
-        CHECK_I(dset2_id, "H5Dopen2");
-        dset3_id = H5Dopen2(file_id, "dataset3", H5P_DEFAULT);
-        CHECK_I(dset3_id, "H5Dopen2");
-    }
+    if(close_reopen)
+        TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS(3);
 
     /* Extend the first dataset */
     ret = H5Dset_extent(dset1_id, dims2);
     CHECK_I(ret, "H5Dset_extent");
-    if(close_reopen) {
-        /* If requested, close all open IDs and reopen them */
-        ret = H5Dclose(dset1_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset2_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset3_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Fclose(file_id);
-        CHECK_I(ret, "H5Fclose");
-
-        file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
-        CHECK_I(file_id, "H5Fopen");
-        dset1_id = H5Dopen2(file_id, "dataset", H5P_DEFAULT);
-        CHECK_I(dset1_id, "H5Dopen2");
-        dset2_id = H5Dopen2(file_id, "dataset2", H5P_DEFAULT);
-        CHECK_I(dset2_id, "H5Dopen2");
-        dset3_id = H5Dopen2(file_id, "dataset3", H5P_DEFAULT);
-        CHECK_I(dset3_id, "H5Dopen2");
-    }
-
-    /* Get the dataspaces from the datasets */
-    space1_id = H5Dget_space(dset1_id);
-    CHECK_I(space1_id, "H5Dget_space");
-    space2_id = H5Dget_space(dset2_id);
-    CHECK_I(space2_id, "H5Dget_space");
-    space3_id = H5Dget_space(dset3_id);
-    CHECK_I(space3_id, "H5Dget_space");
-
-    /* Verify the dataspaces */
-    ret = H5Sget_simple_extent_dims(space1_id, out_dims, out_maxdims);
-    CHECK_I(ret, "H5Sget_simple_extent_dims");
-    for(x=0; x<EXTEND_NDIMS; ++x) {
-        VERIFY(out_dims[x], dims2[x], "H5Sget_simple_extent_dims");
-        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims");
-    }
-
-    ret = H5Sget_simple_extent_dims(space2_id, out_dims, out_maxdims);
-    CHECK_I(ret, "H5Sget_simple_extent_dims");
-    for(x=0; x<EXTEND_NDIMS; ++x) {
-        VERIFY(out_dims[x], dims1[x], "H5Sget_simple_extent_dims");
-        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims");
-    }
-
-    ret = H5Sget_simple_extent_dims(space3_id, out_dims, out_maxdims);
-    CHECK_I(ret, "H5Sget_simple_extent_dims");
-    for(x=0; x<EXTEND_NDIMS; ++x) {
-        VERIFY(out_dims[x], dims1[x], "H5Sget_simple_extent_dims");
-        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims");
-    }
+    if(close_reopen)
+        TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS(3);
 
-    /* Close all three dataspaces */
-    ret = H5Sclose(space1_id);
-    CHECK_I(ret, "H5Sclose");
-    ret = H5Sclose(space2_id);
-    CHECK_I(ret, "H5Sclose");
-    ret = H5Sclose(space3_id);
-    CHECK_I(ret, "H5Sclose");
+    space_dims[0] = dims2;
+    space_dims[1] = dims1;
+    space_dims[2] = dims1;
+    TSOHM_VDE_VERIFY_SPACES(space_dims);
 
     /* Extend the second dataset */
     ret = H5Dset_extent(dset2_id, dims2);
     CHECK_I(ret, "H5Dset_extent");
-    if(close_reopen) {
-        /* If requested, close all open IDs and reopen them */
-        ret = H5Dclose(dset1_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset2_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset3_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Fclose(file_id);
-        CHECK_I(ret, "H5Fclose");
-
-        file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
-        CHECK_I(file_id, "H5Fopen");
-        dset1_id = H5Dopen2(file_id, "dataset", H5P_DEFAULT);
-        CHECK_I(dset1_id, "H5Dopen2");
-        dset2_id = H5Dopen2(file_id, "dataset2", H5P_DEFAULT);
-        CHECK_I(dset2_id, "H5Dopen2");
-        dset3_id = H5Dopen2(file_id, "dataset3", H5P_DEFAULT);
-        CHECK_I(dset3_id, "H5Dopen2");
-    }
+    if(close_reopen)
+        TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS(3);
 
-    /* Get the dataspaces from the datasets */
-    space1_id = H5Dget_space(dset1_id);
-    CHECK_I(space1_id, "H5Dget_space");
-    space2_id = H5Dget_space(dset2_id);
-    CHECK_I(space2_id, "H5Dget_space");
-    space3_id = H5Dget_space(dset3_id);
-    CHECK_I(space3_id, "H5Dget_space");
-
-    /* Verify the dataspaces */
-    ret = H5Sget_simple_extent_dims(space1_id, out_dims, out_maxdims);
-    CHECK_I(ret, "H5Sget_simple_extent_dims");
-    for(x=0; x<EXTEND_NDIMS; ++x) {
-        VERIFY(out_dims[x], dims2[x], "H5Sget_simple_extent_dims");
-        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims");
-    }
-
-    ret = H5Sget_simple_extent_dims(space2_id, out_dims, out_maxdims);
-    CHECK_I(ret, "H5Sget_simple_extent_dims");
-    for(x=0; x<EXTEND_NDIMS; ++x) {
-        VERIFY(out_dims[x], dims2[x], "H5Sget_simple_extent_dims");
-        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims");
-    }
-
-    ret = H5Sget_simple_extent_dims(space3_id, out_dims, out_maxdims);
-    CHECK_I(ret, "H5Sget_simple_extent_dims");
-    for(x=0; x<EXTEND_NDIMS; ++x) {
-        VERIFY(out_dims[x], dims1[x], "H5Sget_simple_extent_dims");
-        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims");
-    }
-
-    /* Close all three dataspaces */
-    ret = H5Sclose(space1_id);
-    CHECK_I(ret, "H5Sclose");
-    ret = H5Sclose(space2_id);
-    CHECK_I(ret, "H5Sclose");
-    ret = H5Sclose(space3_id);
-    CHECK_I(ret, "H5Sclose");
+    space_dims[1] = dims2;
+    TSOHM_VDE_VERIFY_SPACES(space_dims);
 
     /* Extend the third dataset */
     ret = H5Dset_extent(dset3_id, dims2);
     CHECK_I(ret, "H5Dset_extent");
-    if(close_reopen) {
-        /* If requested, close all open IDs and reopen them */
-        ret = H5Dclose(dset1_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset2_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset3_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Fclose(file_id);
-        CHECK_I(ret, "H5Fclose");
 
-        file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
-        CHECK_I(file_id, "H5Fopen");
-        dset1_id = H5Dopen2(file_id, "dataset", H5P_DEFAULT);
-        CHECK_I(dset1_id, "H5Dopen2");
-        dset2_id = H5Dopen2(file_id, "dataset2", H5P_DEFAULT);
-        CHECK_I(dset2_id, "H5Dopen2");
-        dset3_id = H5Dopen2(file_id, "dataset3", H5P_DEFAULT);
-        CHECK_I(dset3_id, "H5Dopen2");
-    }
-
-    /* Get the dataspaces from the datasets */
-    space1_id = H5Dget_space(dset1_id);
-    CHECK_I(space1_id, "H5Dget_space");
-    space2_id = H5Dget_space(dset2_id);
-    CHECK_I(space2_id, "H5Dget_space");
-    space3_id = H5Dget_space(dset3_id);
-    CHECK_I(space3_id, "H5Dget_space");
-
-    /* Verify the dataspaces */
-    ret = H5Sget_simple_extent_dims(space1_id, out_dims, out_maxdims);
-    CHECK_I(ret, "H5Sget_simple_extent_dims");
-    for(x=0; x<EXTEND_NDIMS; ++x) {
-        VERIFY(out_dims[x], dims2[x], "H5Sget_simple_extent_dims");
-        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims");
-    }
+    if(close_reopen)
+        TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS(3);
 
-    ret = H5Sget_simple_extent_dims(space2_id, out_dims, out_maxdims);
-    CHECK_I(ret, "H5Sget_simple_extent_dims");
-    for(x=0; x<EXTEND_NDIMS; ++x) {
-        VERIFY(out_dims[x], dims2[x], "H5Sget_simple_extent_dims");
-        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims");
-    }
-
-    ret = H5Sget_simple_extent_dims(space3_id, out_dims, out_maxdims);
-    CHECK_I(ret, "H5Sget_simple_extent_dims");
-    for(x=0; x<EXTEND_NDIMS; ++x) {
-        VERIFY(out_dims[x], dims2[x], "H5Sget_simple_extent_dims");
-        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims");
-    }
-
-    /* Close all three dataspaces */
-    ret = H5Sclose(space1_id);
-    CHECK_I(ret, "H5Sclose");
-    ret = H5Sclose(space2_id);
-    CHECK_I(ret, "H5Sclose");
-    ret = H5Sclose(space3_id);
-    CHECK_I(ret, "H5Sclose");
+    space_dims[2] = dims2;
+    TSOHM_VDE_VERIFY_SPACES(space_dims);
 
     /* Close the datasets and file */
     ret = H5Dclose(dset1_id);
@@ -3523,164 +3522,44 @@ test_sohm_extend_dset_helper(hid_t fcpl_id, hbool_t close_reopen)
     CHECK_I(file_id, "H5Fcreate");
     dset1_id = H5Dcreate2(file_id, "dataset", H5T_NATIVE_LONG, orig_space_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT);
     CHECK_I(dset1_id, "H5Dcreate2");
-    if(close_reopen) {
-        /* If requested, close all open IDs and reopen them */
-        ret = H5Dclose(dset1_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Fclose(file_id);
-        CHECK_I(ret, "H5Fclose");
-
-        file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
-        CHECK_I(file_id, "H5Fopen");
-        dset1_id = H5Dopen2(file_id, "dataset", H5P_DEFAULT);
-        CHECK_I(dset1_id, "H5Dopen2");
-    }
+    if (close_reopen)
+        TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS(1);
 
     /* Extend the first dataset */
     ret = H5Dset_extent(dset1_id, dims2);
     CHECK_I(ret, "H5Dset_extent");
-    if(close_reopen) {
-        /* If requested, close all open IDs and reopen them */
-        ret = H5Dclose(dset1_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Fclose(file_id);
-        CHECK_I(ret, "H5Fclose");
-
-        file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
-        CHECK_I(file_id, "H5Fopen");
-        dset1_id = H5Dopen2(file_id, "dataset", H5P_DEFAULT);
-        CHECK_I(dset1_id, "H5Dopen2");
-    }
+    if (close_reopen)
+        TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS(1);
 
     /* Create the second dataset.  Its dataspace will be unshared and then
      * become shared when extended.
      */
     dset2_id = H5Dcreate2(file_id, "dataset2", H5T_NATIVE_LONG, orig_space_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT);
     CHECK_I(dset2_id, "H5Dcreate2");
-    if(close_reopen) {
-        /* If requested, close all open IDs and reopen them */
-        ret = H5Dclose(dset1_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset2_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Fclose(file_id);
-        CHECK_I(ret, "H5Fclose");
-
-        file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
-        CHECK_I(file_id, "H5Fopen");
-        dset1_id = H5Dopen2(file_id, "dataset", H5P_DEFAULT);
-        CHECK_I(dset1_id, "H5Dopen2");
-        dset2_id = H5Dopen2(file_id, "dataset2", H5P_DEFAULT);
-        CHECK_I(dset2_id, "H5Dopen2");
-    }
+    if (close_reopen)
+        TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS(2);
 
     /* Extend the second dataset */
     ret = H5Dset_extent(dset2_id, dims2);
     CHECK_I(ret, "H5Dset_extent");
-    if(close_reopen) {
-        /* If requested, close all open IDs and reopen them */
-        ret = H5Dclose(dset1_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset2_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Fclose(file_id);
-        CHECK_I(ret, "H5Fclose");
-
-        file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
-        CHECK_I(file_id, "H5Fopen");
-        dset1_id = H5Dopen2(file_id, "dataset", H5P_DEFAULT);
-        CHECK_I(dset1_id, "H5Dopen2");
-        dset2_id = H5Dopen2(file_id, "dataset2", H5P_DEFAULT);
-        CHECK_I(dset2_id, "H5Dopen2");
-    }
+    if (close_reopen)
+        TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS(2);
 
     /* Create the third dataset.  Its dataspace will be unshared and then
      * become shared when extended.
      */
     dset3_id = H5Dcreate2(file_id, "dataset3", H5T_NATIVE_LONG, orig_space_id, H5P_DEFAULT, dcpl_id, H5P_DEFAULT);
     CHECK_I(dset3_id, "H5Dcreate2");
-    if(close_reopen) {
-        /* If requested, close all open IDs and reopen them */
-        ret = H5Dclose(dset1_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset2_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset3_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Fclose(file_id);
-        CHECK_I(ret, "H5Fclose");
-
-        file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
-        CHECK_I(file_id, "H5Fopen");
-        dset1_id = H5Dopen2(file_id, "dataset", H5P_DEFAULT);
-        CHECK_I(dset1_id, "H5Dopen2");
-        dset2_id = H5Dopen2(file_id, "dataset2", H5P_DEFAULT);
-        CHECK_I(dset2_id, "H5Dopen2");
-        dset3_id = H5Dopen2(file_id, "dataset3", H5P_DEFAULT);
-        CHECK_I(dset3_id, "H5Dopen2");
-    }
+    if (close_reopen)
+        TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS(3);
 
     /* Extend the third dataset */
     ret = H5Dset_extent(dset3_id, dims2);
     CHECK_I(ret, "H5Dset_extent");
-    if(close_reopen) {
-        /* If requested, close all open IDs and reopen them */
-        ret = H5Dclose(dset1_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset2_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Dclose(dset3_id);
-        CHECK_I(ret, "H5Dclose");
-        ret = H5Fclose(file_id);
-        CHECK_I(ret, "H5Fclose");
-
-        file_id = H5Fopen(FILENAME, H5F_ACC_RDWR, H5P_DEFAULT);
-        CHECK_I(file_id, "H5Fopen");
-        dset1_id = H5Dopen2(file_id, "dataset", H5P_DEFAULT);
-        CHECK_I(dset1_id, "H5Dopen2");
-        dset2_id = H5Dopen2(file_id, "dataset2", H5P_DEFAULT);
-        CHECK_I(dset2_id, "H5Dopen2");
-        dset3_id = H5Dopen2(file_id, "dataset3", H5P_DEFAULT);
-        CHECK_I(dset3_id, "H5Dopen2");
-    }
-
-    /* Get the dataspaces from the datasets */
-    space1_id = H5Dget_space(dset1_id);
-    CHECK_I(space1_id, "H5Dget_space");
-    space2_id = H5Dget_space(dset2_id);
-    CHECK_I(space2_id, "H5Dget_space");
-    space3_id = H5Dget_space(dset3_id);
-    CHECK_I(space3_id, "H5Dget_space");
-
-    /* Verify the dataspaces */
-    ret = H5Sget_simple_extent_dims(space1_id, out_dims, out_maxdims);
-    CHECK_I(ret, "H5Sget_simple_extent_dims");
-    for(x=0; x<EXTEND_NDIMS; ++x) {
-        VERIFY(out_dims[x], dims2[x], "H5Sget_simple_extent_dims");
-        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims");
-    }
-
-    ret = H5Sget_simple_extent_dims(space2_id, out_dims, out_maxdims);
-    CHECK_I(ret, "H5Sget_simple_extent_dims");
-    for(x=0; x<EXTEND_NDIMS; ++x) {
-        VERIFY(out_dims[x], dims2[x], "H5Sget_simple_extent_dims");
-        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims");
-    }
-
-    ret = H5Sget_simple_extent_dims(space3_id, out_dims, out_maxdims);
-    CHECK_I(ret, "H5Sget_simple_extent_dims");
-    for(x=0; x<EXTEND_NDIMS; ++x) {
-        VERIFY(out_dims[x], dims2[x], "H5Sget_simple_extent_dims");
-        VERIFY(out_maxdims[x], max_dims[x], "H5Sget_simple_extent_dims");
-    }
+    if (close_reopen)
+        TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS(3);
 
-    /* Close all three dataspaces */
-    ret = H5Sclose(space1_id);
-    CHECK_I(ret, "H5Sclose");
-    ret = H5Sclose(space2_id);
-    CHECK_I(ret, "H5Sclose");
-    ret = H5Sclose(space3_id);
-    CHECK_I(ret, "H5Sclose");
+    TSOHM_VDE_VERIFY_SPACES(space_dims);
 
     /* Close the datasets and file */
     ret = H5Dclose(dset1_id);
@@ -3698,12 +3577,15 @@ test_sohm_extend_dset_helper(hid_t fcpl_id, hbool_t close_reopen)
     ret = H5Pclose(dcpl_id);
     CHECK_I(ret, "H5Pclose");
 
-    /* Retrieve current # of errors */
+    /* Complaini if this test generated errors */
     if(old_nerrs == GetTestNumErrs())
         return(0);
     else
         return(-1);
-} /* end test_sohm_extend_dset_helper() */
+/* macros are exclusive to this function */
+#undef TSOHM_VDE_CLOSE_REOPEN_FILE_AND_DSETS
+#undef TSOHM_VDE_VERIFY_SPACES
+} /* verify_dataset_extension */
 
 
 /*-------------------------------------------------------------------------
@@ -3726,7 +3608,8 @@ test_sohm_extend_dset(void)
     hid_t fcpl_id = -1;
     herr_t ret;
 
-    /* Create fcpl */
+    MESSAGE(5, ("Testing extending shared dataspaces\n"));
+
     fcpl_id = H5Pcreate(H5P_FILE_CREATE);
     CHECK_I(fcpl_id, "H5Pcreate");
 
@@ -3735,20 +3618,20 @@ test_sohm_extend_dset(void)
     CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
 
     /* No shared messages */
-    ret = test_sohm_extend_dset_helper(fcpl_id, FALSE);
-    CHECK_I(ret, "test_sohm_extend_dset_helper");
-    ret = test_sohm_extend_dset_helper(fcpl_id, TRUE);
-    CHECK_I(ret, "test_sohm_extend_dset_helper");
+    ret = verify_dataset_extension(fcpl_id, FALSE);
+    CHECK_I(ret, "verify_dataset_extension");
+    ret = verify_dataset_extension(fcpl_id, TRUE);
+    CHECK_I(ret, "verify_dataset_extension");
 
 
     /* Only dataspaces */
     ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_SDSPACE_FLAG, 16);
     CHECK_I(ret, "H5Pset_shared_mesg_index");
 
-    ret = test_sohm_extend_dset_helper(fcpl_id, FALSE);
-    CHECK_I(ret, "test_sohm_extend_dset_helper");
-    ret = test_sohm_extend_dset_helper(fcpl_id, TRUE);
-    CHECK_I(ret, "test_sohm_extend_dset_helper");
+    ret = verify_dataset_extension(fcpl_id, FALSE);
+    CHECK_I(ret, "verify_dataset_extension");
+    ret = verify_dataset_extension(fcpl_id, TRUE);
+    CHECK_I(ret, "verify_dataset_extension");
 
     /* All messages */
     ret = H5Pset_shared_mesg_nindexes(fcpl_id, 1);
@@ -3756,44 +3639,44 @@ test_sohm_extend_dset(void)
     ret = H5Pset_shared_mesg_index(fcpl_id, 0, H5O_SHMESG_ALL_FLAG, 16);
     CHECK_I(ret, "H5Pset_shared_mesg_index");
 
-    ret = test_sohm_extend_dset_helper(fcpl_id, FALSE);
-    CHECK_I(ret, "test_sohm_extend_dset_helper");
-    ret = test_sohm_extend_dset_helper(fcpl_id, TRUE);
-    CHECK_I(ret, "test_sohm_extend_dset_helper");
+    ret = verify_dataset_extension(fcpl_id, FALSE);
+    CHECK_I(ret, "verify_dataset_extension");
+    ret = verify_dataset_extension(fcpl_id, TRUE);
+    CHECK_I(ret, "verify_dataset_extension");
 
 
     /* All messages in lists */
     ret = H5Pset_shared_mesg_phase_change(fcpl_id, 100, 50);
     CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
 
-    ret = test_sohm_extend_dset_helper(fcpl_id, FALSE);
-    CHECK_I(ret, "test_sohm_extend_dset_helper");
-    ret = test_sohm_extend_dset_helper(fcpl_id, TRUE);
-    CHECK_I(ret, "test_sohm_extend_dset_helper");
+    ret = verify_dataset_extension(fcpl_id, FALSE);
+    CHECK_I(ret, "verify_dataset_extension");
+    ret = verify_dataset_extension(fcpl_id, TRUE);
+    CHECK_I(ret, "verify_dataset_extension");
 
 
     /* All messages in lists converted to B-trees */
     ret = H5Pset_shared_mesg_phase_change(fcpl_id, 1, 0);
     CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
 
-    ret = test_sohm_extend_dset_helper(fcpl_id, FALSE);
-    CHECK_I(ret, "test_sohm_extend_dset_helper");
-    ret = test_sohm_extend_dset_helper(fcpl_id, TRUE);
-    CHECK_I(ret, "test_sohm_extend_dset_helper");
+    ret = verify_dataset_extension(fcpl_id, FALSE);
+    CHECK_I(ret, "verify_dataset_extension");
+    ret = verify_dataset_extension(fcpl_id, TRUE);
+    CHECK_I(ret, "verify_dataset_extension");
 
 
     /* All messages in B-trees */
     ret = H5Pset_shared_mesg_phase_change(fcpl_id, 0, 0);
     CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
 
-    ret = test_sohm_extend_dset_helper(fcpl_id, FALSE);
-    CHECK_I(ret, "test_sohm_extend_dset_helper");
-    ret = test_sohm_extend_dset_helper(fcpl_id, TRUE);
-    CHECK_I(ret, "test_sohm_extend_dset_helper");
+    ret = verify_dataset_extension(fcpl_id, FALSE);
+    CHECK_I(ret, "verify_dataset_extension");
+    ret = verify_dataset_extension(fcpl_id, TRUE);
+    CHECK_I(ret, "verify_dataset_extension");
 
     ret = H5Pclose(fcpl_id);
     CHECK_I(ret, "H5Pclose");
-}
+} /* test_sohm_extend_dset */
 
 
 /*-------------------------------------------------------------------------
@@ -3827,37 +3710,30 @@ test_sohm_external_dtype(void)
     unsigned x, i;
     herr_t ret;
 
+    MESSAGE(5, ("Testing shared external datatype\n"));
+
     fcpl = H5Pcreate(H5P_FILE_CREATE);
     CHECK_I(fcpl, "H5Pcreate");
-
-    /* Set up index values for sohm */
     ret = H5Pset_shared_mesg_nindexes(fcpl, TEST_NUM_INDEXES);
     CHECK_I(ret, "H5Pset_shared_mesg_nindexes");
-
-    for(x=0; x<TEST_NUM_INDEXES; ++x)
-    {
+    for(x=0; x<TEST_NUM_INDEXES; ++x) {
         ret = H5Pset_shared_mesg_index(fcpl, x, test_type_flags[x], test_minsizes[x]);
         CHECK_I(ret, "H5Pset_shared_mesg_index");
     }
-
     ret = H5Pset_shared_mesg_phase_change(fcpl, TEST_L2B, TEST_B2L);
     CHECK_I(ret, "H5Pset_shared_mesg_phase_change");
 
-    /* Create the data space */
     space = H5Screate_simple(2, dims, NULL);
     CHECK_I(space, "H5Screate_simple");
 
-    /* Create a data type for s1_t */
     s1_tid = H5Tcreate(H5T_COMPOUND, sizeof(s1_t));
     CHECK_I(s1_tid, "H5Tcreate");
-
     ret = H5Tinsert(s1_tid, "a", HOFFSET(s1_t,a), H5T_NATIVE_INT);
     CHECK_I(ret, "H5Tinsert");
-
     ret = H5Tinsert (s1_tid, "b", HOFFSET(s1_t,b), H5T_NATIVE_INT);
     CHECK_I(ret, "H5Tinsert");
 
-    /* Create the first file for this test */
+    /* Set up dataset in first file */
     file1 = H5Fcreate(FILENAME_SRC, H5F_ACC_TRUNC, fcpl, H5P_DEFAULT);
     CHECK_I(file1, "H5Fcreate");
 
@@ -3866,7 +3742,6 @@ test_sohm_external_dtype(void)
     CHECK(ret, FAIL, "H5F_get_sohm_mesg_count_test");
     VERIFY(dmsg_count, 0, "H5F_get_sohm_mesg_count_test");
 
-    /* Create data set */
     dataset1 = H5Dcreate2(file1, "dataset_1", s1_tid, space, H5P_DEFAULT, H5P_DEFAULT,
         H5P_DEFAULT);
     CHECK_I(dataset1, "H5Dcreate2");
@@ -3876,26 +3751,25 @@ test_sohm_external_dtype(void)
     CHECK(ret, FAIL, "H5F_get_sohm_mesg_count_test");
     VERIFY(dmsg_count, 1, "H5F_get_sohm_mesg_count_test");
 
-    /* Retieve the dataset's datatype */
     dset1_tid = H5Dget_type(dataset1);
     CHECK_I(dset1_tid, "H5Dget_type");
 
     /* Allocate space and initialize data */
     orig = (s1_t*)HDmalloc(NX * NY * sizeof(s1_t));
+    if (orig == NULL)
+        CHECK_I(-1, "HDmalloc");
     for(i=0; i<NX*NY; i++) {
         s_ptr = (s1_t*)orig + i;
         s_ptr->a = (int)(i * 3 + 1);
         s_ptr->b = (int)(i * 3 + 2);
     }
 
-    /* Write the data to the dataset1 */
     ret = H5Dwrite(dataset1, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, orig);
     CHECK_I(ret, "H5Dwrite");
-
     ret = H5Dclose(dataset1);
     CHECK_I(ret, "H5Dclose");
 
-    /* Create the second file for this test */
+    /* Create dataset in second file using datatype from dataset in the first file */
     file2 = H5Fcreate(FILENAME_DST, H5F_ACC_TRUNC, fcpl, H5P_DEFAULT);
     CHECK_I(file2, "H5Fcreate");
 
@@ -3904,7 +3778,6 @@ test_sohm_external_dtype(void)
     CHECK(ret, FAIL, "H5F_get_sohm_mesg_count_test");
     VERIFY(dmsg_count, 0, "H5F_get_sohm_mesg_count_test");
 
-    /* Create a data set using the datatype of the dataset in the first file. */
     dataset2 = H5Dcreate2(file2, "dataset_2", dset1_tid, space, H5P_DEFAULT, H5P_DEFAULT,
         H5P_DEFAULT);
     CHECK_I(dataset2, "H5Dcreate2");
@@ -3914,30 +3787,25 @@ test_sohm_external_dtype(void)
     CHECK(ret, FAIL, "H5F_get_sohm_mesg_count_test");
     VERIFY(dmsg_count, 1, "H5F_get_sohm_mesg_count_test");
 
-    /* Write the data to the dataset2 */
     ret = H5Dwrite(dataset2, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, orig);
     CHECK_I(ret, "H5Dwrite");
 
     ret = H5Dclose(dataset2);
     CHECK_I(ret, "H5Dclose");
 
-    /* Close file 1 and the dataset's datatype in file 1.  Verify that the datatype in
-     * file 2 is still accessible. */
     ret = H5Tclose(dset1_tid);
     CHECK_I(ret, "H5Tclose");
 
     ret = H5Fclose(file1);
     CHECK_I(ret, "H5Fclose");
 
-    /* Open the dataset in file 2 */
+    /* Verify that datatype details are still accessible by second file */
     dataset2 = H5Dopen2(file2, "dataset_2", H5P_DEFAULT);
     CHECK_I(dataset2, "H5Dopen2");
 
-    /* Retieve the dataset's datatype */
     dset2_tid = H5Dget_type(dataset2);
     CHECK_I(dset2_tid, "H5Dget_type");
 
-    /* Verify the datatype is compound */
     dtype_class = H5Tget_class(dset2_tid);
     VERIFY(dtype_class, H5T_COMPOUND, "H5Tget_class");
 
@@ -3947,21 +3815,17 @@ test_sohm_external_dtype(void)
     ret = H5Dclose(dataset2);
     CHECK_I(ret, "H5Dclose");
 
-    /* Finishing test and release resources */
+    /* Cleanup */
     ret = H5Sclose(space);
     CHECK_I(ret, "H5Sclose");
-
     ret = H5Tclose(s1_tid);
     CHECK_I(ret, "H5Tclose");
-
     ret = H5Pclose(fcpl);
     CHECK_I(ret, "H5Pclose");
-
     ret = H5Fclose(file2);
     CHECK_I(ret, "H5Fclose");
-
     HDfree(orig);
-}
+} /* test_sohm_external_dtype */
 
 
 /****************************************************************
@@ -3972,11 +3836,14 @@ test_sohm_external_dtype(void)
 void
 test_sohm(void)
 {
-    /* Output message about test being performed */
     MESSAGE(5, ("Testing Shared Object Header Messages\n"));
 
     test_sohm_fcpl();		/* Test SOHMs and file creation plists */
+    test_sohm_fcpl_errors();    /* Bogus H5P* calls for SOHMs */
     test_sohm_size1();          /* Tests the sizes of files with one SOHM */
+#if 0 /* TODO: REVEALS BUG TO BE FIXED - SEE JIRA HDFFV-10645 */
+    test_sohm_size_consistency_open_create();
+#endif /* Jira HDFFV-10645 */
     test_sohm_attrs();          /* Tests shared messages in attributes */
     test_sohm_size2(0);         /* Tests the sizes of files with multiple SOHMs */
     test_sohm_size2(1);         /* Tests the sizes of files with multiple
@@ -4012,5 +3879,5 @@ cleanup_sohm(void)
     remove(FILENAME);
     remove(FILENAME_SRC);
     remove(FILENAME_DST);
-}
+} /* cleanup_sohm */