[svn-r27626] Various minor warning fixes before major SWMR and VDS merges.

gcc 4.9.2 was used to create the warning list

- implicit casts
- shadowed variables
- various enum issues
- other minor fixes (comments, unused macros, etc.)

Tested on: h5committest

13 files changed, 177 insertions, 161 deletions

diff --git a/test/dsets.c b/test/dsets.c
index e6b2ee4..136fec2 100644
--- a/test/dsets.c
+++ b/test/dsets.c
@@ -7567,7 +7567,7 @@ test_chunk_expand(hid_t fapl)
         if(TRUE != H5Zfilter_avail(H5Z_FILTER_EXPAND)) FAIL_STACK_ERROR
 
         /* Loop over storage allocation time */
-        for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; alloc_time++) {
+        for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; H5_INC_ENUM(H5D_alloc_time_t, alloc_time)) {
             /* Create file */
             if((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) FAIL_STACK_ERROR
 
diff --git a/test/earray.c b/test/earray.c
index feaa15e..b510992 100644
--- a/test/earray.c
+++ b/test/earray.c
@@ -2894,7 +2894,7 @@ main(void)
     init_cparam(&cparam);
 
     /* Iterate over the testing parameters */
-    for(curr_test = EARRAY_TEST_NORMAL; curr_test < EARRAY_TEST_NTESTS; curr_test++) {
+    for(curr_test = EARRAY_TEST_NORMAL; curr_test < EARRAY_TEST_NTESTS; H5_INC_ENUM(earray_test_type_t, curr_test)) {
 
         /* Initialize the testing parameters */
         init_tparam(&tparam, &cparam);
@@ -2926,7 +2926,7 @@ main(void)
         nerrors += test_flush_depend(fapl, &cparam, &tparam);
 
         /* Iterate over the type of capacity tests */
-        for(curr_iter = EARRAY_ITER_FW; curr_iter < EARRAY_ITER_NITERS; curr_iter++) {
+        for(curr_iter = EARRAY_ITER_FW; curr_iter < EARRAY_ITER_NITERS; H5_INC_ENUM(earray_iter_type_t, curr_iter)) {
             hsize_t sblk;               /* Super block index */
             hsize_t dblk;               /* Data block index */
             hsize_t nelmts;             /* # of elements to test */
diff --git a/test/farray.c b/test/farray.c
index 4c18916..43b63c6 100644
--- a/test/farray.c
+++ b/test/farray.c
@@ -1554,11 +1554,11 @@ main(void)
     }
 
     /* Iterate over the testing parameters */
-    for(curr_test = FARRAY_TEST_NORMAL; curr_test < FARRAY_TEST_NTESTS; curr_test++) {
+    for(curr_test = FARRAY_TEST_NORMAL; curr_test < FARRAY_TEST_NTESTS; H5_INC_ENUM(farray_test_type_t, curr_test)) {
 
         /* Initialize the testing parameters */
-	HDmemset(&tparam, 0, sizeof(tparam));
-	tparam.nelmts = TEST_NELMTS;
+        HDmemset(&tparam, 0, sizeof(tparam));
+        tparam.nelmts = TEST_NELMTS;
 
         /* Set appropriate testing parameters for each test */
         switch(curr_test) {
@@ -1589,7 +1589,7 @@ main(void)
         nerrors += test_delete_open(fapl, &cparam, &tparam);
 
 	/* Iterate over the type of capacity tests */
-	for(curr_iter = FARRAY_ITER_FW; curr_iter < FARRAY_ITER_NITERS; curr_iter++) {
+	for(curr_iter = FARRAY_ITER_FW; curr_iter < FARRAY_ITER_NITERS; H5_INC_ENUM(farray_iter_type_t, curr_iter)) {
 
             /* Set appropriate parameters for each type of iteration */
             switch(curr_iter) {
diff --git a/test/fheap.c b/test/fheap.c
index c300028..bb30e05 100644
--- a/test/fheap.c
+++ b/test/fheap.c
@@ -16380,7 +16380,7 @@ main(void)
 
     /* Iterate over the testing parameters */
 #ifndef QAK
-    for(curr_test = FHEAP_TEST_NORMAL; curr_test < FHEAP_TEST_NTESTS; curr_test++) {
+    for(curr_test = FHEAP_TEST_NORMAL; curr_test < FHEAP_TEST_NTESTS; H5_INC_ENUM(fheap_test_type_t, curr_test)) {
 #else /* QAK */
 HDfprintf(stderr, "Uncomment test loop!\n");
 curr_test = FHEAP_TEST_NORMAL;
@@ -16430,7 +16430,7 @@ HDfprintf(stderr, "Uncomment tests!\n");
 
 #ifndef QAK2
         /* Filling with different sized objects */
-        for(fill = FHEAP_TEST_FILL_LARGE; fill < FHEAP_TEST_FILL_N; fill++) {
+        for(fill = FHEAP_TEST_FILL_LARGE; fill < FHEAP_TEST_FILL_N; H5_INC_ENUM(fheap_test_fill_t, fill)) {
 #else /* QAK2 */
 HDfprintf(stderr, "Uncomment test loop!\n");
 fill = FHEAP_TEST_FILL_LARGE;
@@ -16542,9 +16542,9 @@ HDfprintf(stderr, "Uncomment tests!\n");
             fheap_test_del_drain_t drain_half;   /* Deletion draining */
 
             /* More complex removal patterns */
-            for(del_dir = FHEAP_DEL_FORWARD; del_dir < FHEAP_DEL_NDIRS; del_dir++) {
+            for(del_dir = FHEAP_DEL_FORWARD; del_dir < FHEAP_DEL_NDIRS; H5_INC_ENUM(fheap_test_del_dir_t, del_dir)) {
                 tparam.del_dir = del_dir;
-                for(drain_half = FHEAP_DEL_DRAIN_ALL; drain_half < FHEAP_DEL_DRAIN_N; drain_half++) {
+                for(drain_half = FHEAP_DEL_DRAIN_ALL; drain_half < FHEAP_DEL_DRAIN_N; H5_INC_ENUM(fheap_test_del_drain_t, drain_half)) {
                     tparam.drain_half = drain_half;
 #else /* QAK2 */
 HDfprintf(stderr, "Uncomment test loops!\n");
@@ -16683,7 +16683,7 @@ HDfprintf(stderr, "Uncomment tests!\n");
             } /* end switch */
 
             /* Try several different methods of deleting objects */
-            for(del_dir = FHEAP_DEL_FORWARD; del_dir < FHEAP_DEL_NDIRS; del_dir++) {
+            for(del_dir = FHEAP_DEL_FORWARD; del_dir < FHEAP_DEL_NDIRS; H5_INC_ENUM(fheap_test_del_dir_t, del_dir)) {
                 tparam.del_dir = del_dir;
 
                 /* Test 'huge' object insert & delete */
@@ -16726,7 +16726,7 @@ HDfprintf(stderr, "Uncomment tests!\n");
         {
         fheap_test_del_dir_t del_dir;   /* Deletion direction */
 
-        for(del_dir = FHEAP_DEL_FORWARD; del_dir < FHEAP_DEL_NDIRS; del_dir++) {
+        for(del_dir = FHEAP_DEL_FORWARD; del_dir < FHEAP_DEL_NDIRS; H5_INC_ENUM(fheap_test_del_dir_t, del_dir)) {
             tparam.del_dir = del_dir;
 
             /* Controlled tests */
diff --git a/test/fillval.c b/test/fillval.c
index c791504..b7b2ff5 100644
--- a/test/fillval.c
+++ b/test/fillval.c
@@ -845,7 +845,7 @@ test_rdwr_cases(hid_t file, hid_t dcpl, const char *dname, void *_fillval,
     if(datatype==H5T_INTEGER) {
         /*check for overflow*/
         HDassert((nelmts * sizeof(int)) == (hsize_t)((size_t)(nelmts * sizeof(int))));
-        buf = HDmalloc((size_t)(nelmts * sizeof(int)));
+        buf = (int *)HDmalloc((size_t)(nelmts * sizeof(int)));
 
         if(H5Dread(dset1, H5T_NATIVE_INT, mspace, fspace, H5P_DEFAULT, buf) < 0)
             goto error;
diff --git a/test/gen_udlinks.c b/test/gen_udlinks.c
index a1312d2..fc044da 100644
--- a/test/gen_udlinks.c
+++ b/test/gen_udlinks.c
@@ -57,6 +57,10 @@ main (void)
       strcpy(filename1, NAME_BE_1);
       strcpy(filename2, NAME_BE_2);
       break;
+    case H5T_ORDER_ERROR:
+    case H5T_ORDER_VAX:
+    case H5T_ORDER_MIXED:
+    case H5T_ORDER_NONE:
     default:
       goto error;
   }
diff --git a/test/tattr.c b/test/tattr.c
index 137c7c9..6642cf1 100644
--- a/test/tattr.c
+++ b/test/tattr.c
@@ -5919,9 +5919,9 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl)
     CHECK(ret, FAIL, "H5Pget_attr_phase_change");
 
     /* Loop over operating on different indices on link fields */
-    for(idx_type = H5_INDEX_NAME; idx_type <=H5_INDEX_CRT_ORDER; idx_type++) {
+    for(idx_type = H5_INDEX_NAME; idx_type <= H5_INDEX_CRT_ORDER; H5_INC_ENUM(H5_index_t, idx_type)) {
         /* Loop over operating in different orders */
-        for(order = H5_ITER_INC; order <=H5_ITER_DEC; order++) {
+        for(order = H5_ITER_INC; order <= H5_ITER_DEC; H5_INC_ENUM(H5_iter_order_t, order)) {
             /* Loop over using index for creation order value */
             for(use_index = FALSE; use_index <= TRUE; use_index++) {
                 /* Print appropriate test message */
@@ -6868,9 +6868,9 @@ test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl)
     iter_info.visited = visited;
 
     /* Loop over operating on different indices on link fields */
-    for(idx_type = H5_INDEX_NAME; idx_type <=H5_INDEX_CRT_ORDER; idx_type++) {
+    for(idx_type = H5_INDEX_NAME; idx_type <= H5_INDEX_CRT_ORDER; H5_INC_ENUM(H5_index_t, idx_type)) {
         /* Loop over operating in different orders */
-        for(order = H5_ITER_INC; order <=H5_ITER_DEC; order++) {
+        for(order = H5_ITER_INC; order <= H5_ITER_DEC; H5_INC_ENUM(H5_iter_order_t, order)) {
             /* Loop over using index for creation order value */
             for(use_index = FALSE; use_index <= TRUE; use_index++) {
                 /* Print appropriate test message */
@@ -7223,9 +7223,9 @@ test_attr_open_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl)
     CHECK(ret, FAIL, "H5Pget_attr_phase_change");
 
     /* Loop over operating on different indices on link fields */
-    for(idx_type = H5_INDEX_NAME; idx_type <=H5_INDEX_CRT_ORDER; idx_type++) {
+    for(idx_type = H5_INDEX_NAME; idx_type <= H5_INDEX_CRT_ORDER; H5_INC_ENUM(H5_index_t, idx_type)) {
         /* Loop over operating in different orders */
-        for(order = H5_ITER_INC; order <=H5_ITER_DEC; order++) {
+        for(order = H5_ITER_INC; order <= H5_ITER_DEC; H5_INC_ENUM(H5_iter_order_t, order)) {
             /* Loop over using index for creation order value */
             for(use_index = FALSE; use_index <= TRUE; use_index++) {
                 /* Print appropriate test message */
diff --git a/test/tfile.c b/test/tfile.c
index 4913a15..33c947f 100644
--- a/test/tfile.c
+++ b/test/tfile.c
@@ -827,7 +827,9 @@ test_file_close(void)
             ret = H5Gclose(group_id3);
             CHECK(ret, FAIL, "H5Gclose");
 	    break;
-        default:
+
+    case H5F_CLOSE_DEFAULT:
+    default:
             CHECK(fc_degree, H5F_CLOSE_DEFAULT, "H5Pget_fclose_degree");
             break;
     }
@@ -1314,6 +1316,19 @@ test_obj_count_and_id(hid_t fid1, hid_t fid2, hid_t did, hid_t gid1,
                         VERIFY(oid_list[i], did, "H5Fget_obj_ids");
                         break;
 
+                    case H5I_UNINIT:
+                    case H5I_BADID:
+                    case H5I_DATATYPE:
+                    case H5I_DATASPACE:
+                    case H5I_ATTR:
+                    case H5I_REFERENCE:
+                    case H5I_VFL:
+                    case H5I_GENPROP_CLS:
+                    case H5I_GENPROP_LST:
+                    case H5I_ERROR_CLASS:
+                    case H5I_ERROR_MSG:
+                    case H5I_ERROR_STACK:
+                    case H5I_NTYPES:
                     default:
                         ERROR("H5Fget_obj_ids");
                 } /* end switch */
@@ -3079,67 +3094,68 @@ test_filespace_info(void)
             my_fapl = fapl;
         } /* end else */
 
-	/* Test with different sized free space section threshold */
-	for(fs_size = 0; fs_size <= TEST_THRESHOLD10; fs_size++) {
+        /* Test with different sized free space section threshold */
+        for(fs_size = 0; fs_size <= TEST_THRESHOLD10; fs_size++) {
 
-	    /* Test with different file space handling strategies */
-	    for(fs_type = 0; fs_type < H5F_FILE_SPACE_NTYPES; H5_INC_ENUM(H5F_file_space_type_t, fs_type)) {
+            /* Test with different file space handling strategies */
+            for(fs_type = H5F_FILE_SPACE_DEFAULT; fs_type < H5F_FILE_SPACE_NTYPES; H5_INC_ENUM(H5F_file_space_type_t, fs_type)) {
 
-		/* Get a copy of the default file creation property */
-		fcpl1 = H5Pcopy(fcpl);
-		CHECK(fcpl1, FAIL, "H5Pcopy");
+                /* Get a copy of the default file creation property */
+                fcpl1 = H5Pcopy(fcpl);
+                CHECK(fcpl1, FAIL, "H5Pcopy");
 
-		/* Set file space strategy and free space section threshold */
-		ret = H5Pset_file_space(fcpl1, fs_type, fs_size);
-		CHECK(ret, FAIL, "H5Pget_file_space");
+                /* Set file space strategy and free space section threshold */
+                ret = H5Pset_file_space(fcpl1, fs_type, fs_size);
+                CHECK(ret, FAIL, "H5Pget_file_space");
 
-		/* Get the file space info from the creation property */
-		ret = H5Pget_file_space(fcpl1, &strategy, &threshold);
-		CHECK(ret, FAIL, "H5Pget_file_space");
+                /* Get the file space info from the creation property */
+                ret = H5Pget_file_space(fcpl1, &strategy, &threshold);
+                CHECK(ret, FAIL, "H5Pget_file_space");
 
-		/* A 0 value for strategy retains existing strategy in use */
-		VERIFY(strategy, (H5F_file_space_type_t)(fs_type ? fs_type : def_type), "H5Pget_file_space");
-		/* A 0 value for threshold retains existing threshold in use */
-		VERIFY(threshold, (hsize_t)(fs_size ? fs_size : def_size), "H5Pget_file_space");
+                /* A 0 value for strategy retains existing strategy in use */
+                VERIFY(strategy, (H5F_file_space_type_t)(fs_type ? fs_type : def_type), "H5Pget_file_space");
+                /* A 0 value for threshold retains existing threshold in use */
+                VERIFY(threshold, (hsize_t)(fs_size ? fs_size : def_size), "H5Pget_file_space");
 
-		/* Create the file with the specified file space info */
-		fid1 = H5Fcreate(filename, H5F_ACC_TRUNC, fcpl1, my_fapl);
-		CHECK(ret, FAIL, "H5Fcreate");
+                /* Create the file with the specified file space info */
+                fid1 = H5Fcreate(filename, H5F_ACC_TRUNC, fcpl1, my_fapl);
+                CHECK(ret, FAIL, "H5Fcreate");
 
-		/* Close the file */
-		ret = H5Fclose(fid1);
-		CHECK(ret, FAIL, "H5Fclose");
+                /* Close the file */
+                ret = H5Fclose(fid1);
+                CHECK(ret, FAIL, "H5Fclose");
 
-		/* Re-open the file */
-		fid2 = H5Fopen(filename, H5F_ACC_RDWR, my_fapl);
-		CHECK(ret, FAIL, "H5Fopen");
+                /* Re-open the file */
+                fid2 = H5Fopen(filename, H5F_ACC_RDWR, my_fapl);
+                CHECK(ret, FAIL, "H5Fopen");
 
-		/* Get the file's creation property */
-		fcpl2 = H5Fget_create_plist(fid2);
-		CHECK(fcpl2, FAIL, "H5Fget_create_plist");
+                /* Get the file's creation property */
+                fcpl2 = H5Fget_create_plist(fid2);
+                CHECK(fcpl2, FAIL, "H5Fget_create_plist");
 
-		strategy = threshold = 0;
+                strategy = H5F_FILE_SPACE_DEFAULT;
+                threshold = 0;
 
-		/* Get the file space info from the creation property list */
-		ret = H5Pget_file_space(fcpl2, &strategy, &threshold);
-		CHECK(ret, FAIL, "H5Pget_file_space");
+                /* Get the file space info from the creation property list */
+                ret = H5Pget_file_space(fcpl2, &strategy, &threshold);
+                CHECK(ret, FAIL, "H5Pget_file_space");
 
-		VERIFY(strategy, (H5F_file_space_type_t)(fs_type ? fs_type : def_type), "H5Pget_file_space");
-		VERIFY(threshold, (hsize_t)(fs_size ? fs_size : def_size), "H5Pget_file_space");
+                VERIFY(strategy, (H5F_file_space_type_t)(fs_type ? fs_type : def_type), "H5Pget_file_space");
+                VERIFY(threshold, (hsize_t)(fs_size ? fs_size : def_size), "H5Pget_file_space");
 
-		/* Close the file */
-		ret = H5Fclose(fid2);
-		CHECK(ret, FAIL, "H5Fclose");
+                /* Close the file */
+                ret = H5Fclose(fid2);
+                CHECK(ret, FAIL, "H5Fclose");
 
-		/* Release file-creation template */
-		ret = H5Pclose(fcpl1);
-		CHECK(ret, FAIL, "H5Pclose");
-		ret = H5Pclose(fcpl2);
-		CHECK(ret, FAIL, "H5Pclose");
-	    } /* end for file space strategy type */
-	} /* end for free space threshold */
+                /* Release file-creation template */
+                ret = H5Pclose(fcpl1);
+                CHECK(ret, FAIL, "H5Pclose");
+                ret = H5Pclose(fcpl2);
+                CHECK(ret, FAIL, "H5Pclose");
+            } /* end for file space strategy type */
+        } /* end for free space threshold */
 
-	h5_cleanup(FILESPACE_NAME, my_fapl);
+        h5_cleanup(FILESPACE_NAME, my_fapl);
 
     } /* end for new/old format */
 
diff --git a/test/tgenprop.c b/test/tgenprop.c
index 10cae6d..fda4161 100644
--- a/test/tgenprop.c
+++ b/test/tgenprop.c
@@ -61,6 +61,18 @@ double          prop4_def=1.41F;   /* Property 4 default value */
 #define PROP4_SIZE      sizeof(prop4_def)
 #define PROP4_DEF_VALUE (&prop4_def)
 
+/* Structs used during iteration */
+typedef struct iter_data_t {
+    int     iter_count;
+    char    **names;
+} iter_data_t;
+
+typedef struct count_data_t {
+    int     count;
+    hid_t   id;
+} count_data_t;
+
+
 /****************************************************************
 **
 **  test_genprop_basic_class(): Test basic generic property list code.
@@ -284,17 +296,12 @@ test_genprop_basic_class_prop(void)
 **
 ****************************************************************/
 static int
-test_genprop_iter1(hid_t id, const char *name, void *iter_data)
+test_genprop_iter1(hid_t H5_ATTR_UNUSED id, const char *name,
+    void *iter_data)
 {
-    struct {                /* Struct for iterations */
-        int iter_count;
-        const char **names;
-    } *iter_struct = iter_data;
-
-    /* Shut compiler up */
-    id = id;
+    iter_data_t *idata = (iter_data_t *)iter_data;
 
-    return(HDstrcmp(name,iter_struct->names[iter_struct->iter_count++]));
+    return HDstrcmp(name,idata->names[idata->iter_count++]);
 }
 
 /****************************************************************
@@ -373,43 +380,34 @@ test_genprop_class_iter(void)
 static herr_t
 test_genprop_cls_crt_cb1(hid_t list_id, void *create_data)
 {
-    struct {                /* Struct for iterations */
-        int count;
-        hid_t id;
-    } *count_struct=create_data;
+    count_data_t *cdata = (count_data_t *)create_data;
 
-    count_struct->count++;
-    count_struct->id=list_id;
+    cdata->count++;
+    cdata->id = list_id;
 
-    return(SUCCEED);
+    return SUCCEED;
 }
 
 static herr_t
 test_genprop_cls_cpy_cb1(hid_t new_list_id, hid_t H5_ATTR_UNUSED old_list_id, void *copy_data)
 {
-    struct {                /* Struct for iterations */
-        int count;
-        hid_t id;
-    } *count_struct=copy_data;
+    count_data_t *cdata = (count_data_t *)copy_data;
 
-    count_struct->count++;
-    count_struct->id=new_list_id;
+    cdata->count++;
+    cdata->id = new_list_id;
 
-    return(SUCCEED);
+    return SUCCEED;
 }
 
 static herr_t
 test_genprop_cls_cls_cb1(hid_t list_id, void *create_data)
 {
-    struct {                /* Struct for iterations */
-        int count;
-        hid_t id;
-    } *count_struct=create_data;
+    count_data_t *cdata = (count_data_t *)create_data;
 
-    count_struct->count++;
-    count_struct->id=list_id;
+    cdata->count++;
+    cdata->id = list_id;
 
-    return(SUCCEED);
+    return SUCCEED;
 }
 
 /****************************************************************
@@ -843,17 +841,12 @@ test_genprop_basic_list_prop(void)
 **
 ****************************************************************/
 static int
-test_genprop_iter2(hid_t id, const char *name, void *iter_data)
+test_genprop_iter2(hid_t H5_ATTR_UNUSED id, const char *name,
+    void *iter_data)
 {
-    struct {                /* Struct for iterations */
-        int iter_count;
-        const char **names;
-    } *iter_struct=iter_data;
-
-    /* Shut compiler up */
-    id=id;
+    iter_data_t *idata = (iter_data_t *)iter_data;
 
-    return(HDstrcmp(name,iter_struct->names[iter_struct->iter_count++]));
+    return HDstrcmp(name,idata->names[idata->iter_count++]);
 }
 
 /****************************************************************
@@ -995,15 +988,12 @@ prop_cb_info prop3_cb_info;     /* Callback statistics for property #3 */
 static herr_t
 test_genprop_cls_cpy_cb2(hid_t new_list_id, hid_t H5_ATTR_UNUSED old_list_id, void *create_data)
 {
-    struct {                /* Struct for iterations */
-        int count;
-        hid_t id;
-    } *count_struct=create_data;
+    count_data_t *cdata = (count_data_t *)create_data;
 
-    count_struct->count++;
-    count_struct->id=new_list_id;
+    cdata->count++;
+    cdata->id = new_list_id;
 
-    return(SUCCEED);
+    return SUCCEED;
 }
 
 /****************************************************************
diff --git a/test/th5s.c b/test/th5s.c
index 9d08abe..a478803 100644
--- a/test/th5s.c
+++ b/test/th5s.c
@@ -565,7 +565,7 @@ test_h5s_zero_dim(void)
                 wdata_real[i][j][k] = i + j + k;
 
     /* Test with different space allocation times */
-    for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; alloc_time++) {
+    for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; H5_INC_ENUM(H5D_alloc_time_t, alloc_time)) {
 
         /* Make sure we can create the space with the dimension size 0 (starting from v1.8.7).
          * The dimension doesn't need to be unlimited. */
diff --git a/test/tmisc.c b/test/tmisc.c
index 11c6de7..6a68857 100644
--- a/test/tmisc.c
+++ b/test/tmisc.c
@@ -713,7 +713,7 @@ create_struct3(void)
     misc5_struct3_hndl *str3hndl;       /* New 'struct3' created */
     herr_t ret;                         /* For error checking */
 
-    str3hndl = HDmalloc(sizeof(misc5_struct3_hndl));
+    str3hndl = (misc5_struct3_hndl *)HDmalloc(sizeof(misc5_struct3_hndl));
     CHECK(str3hndl,NULL,"malloc");
 
     str3hndl->st3h_base = H5Tcreate(H5T_COMPOUND, sizeof(misc5_struct3));
@@ -722,10 +722,10 @@ create_struct3(void)
     ret = H5Tinsert(str3hndl->st3h_base, "st3_el1", HOFFSET( misc5_struct3, st3_el1), H5T_NATIVE_INT);
     CHECK(ret,FAIL,"H5Tinsert");
 
-    str3hndl->st3h_id=H5Tvlen_create(str3hndl->st3h_base);
+    str3hndl->st3h_id = H5Tvlen_create(str3hndl->st3h_base);
     CHECK(str3hndl->st3h_id,FAIL,"H5Tvlen_create");
 
-    return(str3hndl);
+    return str3hndl;
 }
 
 static void
@@ -733,10 +733,10 @@ delete_struct3(misc5_struct3_hndl *str3hndl)
 {
     herr_t ret;                         /* For error checking */
 
-    ret=H5Tclose(str3hndl->st3h_id);
+    ret = H5Tclose(str3hndl->st3h_id);
     CHECK(ret,FAIL,"H5Tclose");
 
-    ret=H5Tclose(str3hndl->st3h_base);
+    ret = H5Tclose(str3hndl->st3h_base);
     CHECK(ret,FAIL,"H5Tclose");
 
     HDfree(str3hndl);
@@ -756,7 +756,7 @@ create_struct2(void)
     misc5_struct2_hndl *str2hndl;       /* New 'struct2' created */
     herr_t ret;                         /* For error checking */
 
-    str2hndl = HDmalloc(sizeof(misc5_struct2_hndl));
+    str2hndl = (misc5_struct2_hndl *)HDmalloc(sizeof(misc5_struct2_hndl));
     CHECK(str2hndl, NULL, "malloc");
 
     str2hndl->st2h_base = H5Tcreate(H5T_COMPOUND, sizeof(misc5_struct2));
@@ -765,16 +765,16 @@ create_struct2(void)
     ret = H5Tinsert(str2hndl->st2h_base, "st2_el1", HOFFSET(misc5_struct2, st2_el1), H5T_NATIVE_INT);
     CHECK(ret, FAIL, "H5Tinsert");
 
-    str2hndl->st2h_st3hndl=create_struct3();
+    str2hndl->st2h_st3hndl = create_struct3();
     CHECK(str2hndl->st2h_st3hndl,NULL,"create_struct3");
 
-    ret=H5Tinsert(str2hndl->st2h_base, "st2_el2", HOFFSET(misc5_struct2, st2_el2), str2hndl->st2h_st3hndl->st3h_id);
+    ret = H5Tinsert(str2hndl->st2h_base, "st2_el2", HOFFSET(misc5_struct2, st2_el2), str2hndl->st2h_st3hndl->st3h_id);
     CHECK(ret,FAIL,"H5Tinsert");
 
-    str2hndl->st2h_id= H5Tvlen_create(str2hndl->st2h_base);
+    str2hndl->st2h_id = H5Tvlen_create(str2hndl->st2h_base);
     CHECK(str2hndl->st2h_id,FAIL,"H5Tvlen_create");
 
-    return(str2hndl);
+    return str2hndl;
 }
 
 static void
@@ -798,10 +798,10 @@ set_struct2(misc5_struct2 *buf)
 {
     unsigned i;         /* Local index variable */
 
-    buf->st2_el1=MISC5_DBGELVAL2;
-    buf->st2_el2.len=MISC5_DBGNELM3;
+    buf->st2_el1 = MISC5_DBGELVAL2;
+    buf->st2_el2.len = MISC5_DBGNELM3;
 
-    buf->st2_el2.p=HDmalloc((buf->st2_el2.len)*sizeof(misc5_struct3));
+    buf->st2_el2.p = HDmalloc((buf->st2_el2.len)*sizeof(misc5_struct3));
     CHECK(buf->st2_el2.p,NULL,"malloc");
 
     for(i=0; i<(buf->st2_el2.len); i++)
@@ -822,7 +822,7 @@ create_struct1(void)
     misc5_struct1_hndl *str1hndl;       /* New 'struct1' created */
     herr_t ret;                         /* For error checking */
 
-    str1hndl = HDmalloc(sizeof(misc5_struct1_hndl));
+    str1hndl = (misc5_struct1_hndl *)HDmalloc(sizeof(misc5_struct1_hndl));
     CHECK(str1hndl, NULL, "malloc");
 
     str1hndl->st1h_base = H5Tcreate(H5T_COMPOUND, sizeof(misc5_struct1));
@@ -834,13 +834,13 @@ create_struct1(void)
     str1hndl->st1h_st2hndl=create_struct2();
     CHECK(str1hndl->st1h_st2hndl,NULL,"create_struct2");
 
-    ret=H5Tinsert(str1hndl->st1h_base, "st1_el2", HOFFSET(misc5_struct1, st1_el2), str1hndl->st1h_st2hndl->st2h_id);
+    ret = H5Tinsert(str1hndl->st1h_base, "st1_el2", HOFFSET(misc5_struct1, st1_el2), str1hndl->st1h_st2hndl->st2h_id);
     CHECK(ret,FAIL,"H5Tinsert");
 
-    str1hndl->st1h_id=H5Tvlen_create(str1hndl->st1h_base);
+    str1hndl->st1h_id = H5Tvlen_create(str1hndl->st1h_base);
     CHECK(str1hndl->st1h_id,FAIL,"H5Tvlen_create");
 
-    return(str1hndl);
+    return str1hndl;
 }
 
 static void
@@ -848,12 +848,12 @@ delete_struct1(misc5_struct1_hndl *str1hndl)
 {
     herr_t ret;                         /* For error checking */
 
-    ret=H5Tclose(str1hndl->st1h_id);
+    ret = H5Tclose(str1hndl->st1h_id);
     CHECK(ret,FAIL,"H5Tclose");
 
     delete_struct2(str1hndl->st1h_st2hndl);
 
-    ret=H5Tclose(str1hndl->st1h_base);
+    ret = H5Tclose(str1hndl->st1h_base);
     CHECK(ret,FAIL,"H5Tclose");
 
     HDfree(str1hndl);
@@ -1243,10 +1243,10 @@ test_misc8(void)
     MESSAGE(5, ("Testing dataset storage sizes\n"));
 
     /* Allocate space for the data to write & read */
-    wdata=HDmalloc(sizeof(int)*MISC8_DIM0*MISC8_DIM1);
+    wdata = (int *)HDmalloc(sizeof(int) * MISC8_DIM0 * MISC8_DIM1);
     CHECK(wdata,NULL,"malloc");
 #ifdef VERIFY_DATA
-    rdata=HDmalloc(sizeof(int)*MISC8_DIM0*MISC8_DIM1);
+    rdata = (int *)HDmalloc(sizeof(int) * MISC8_DIM0 * MISC8_DIM1);
     CHECK(rdata,NULL,"malloc");
 #endif /* VERIFY_DATA */
 
diff --git a/test/ttst.c b/test/ttst.c
index 4ffe4cd..b869b63 100644
--- a/test/ttst.c
+++ b/test/ttst.c
@@ -95,13 +95,13 @@ test_tst_init(void)
     } /* end for */
 
     /* Allocate space for the array of unique words */
-    uniq_words=HDmalloc(sizeof(char *)*num_uniq_words);
+    uniq_words = (char **)HDmalloc(sizeof(char *)*num_uniq_words);
 
     /* Allocate space for the array of randomized order unique words also */
-    rand_uniq_words=HDmalloc(sizeof(char *)*num_uniq_words);
+    rand_uniq_words = (char **)HDmalloc(sizeof(char *)*num_uniq_words);
 
     /* Allocate space for the array of sorted order unique words also */
-    sort_uniq_words=HDmalloc(sizeof(char *)*num_uniq_words);
+    sort_uniq_words = (char **)HDmalloc(sizeof(char *)*num_uniq_words);
 
     /* Insert unique words from test set into unique word set */
     w=0;
diff --git a/test/tvltypes.c b/test/tvltypes.c
index d1a4235..b7bbaee 100644
--- a/test/tvltypes.c
+++ b/test/tvltypes.c
@@ -1021,7 +1021,7 @@ test_vltypes_compound_vlen_vlen(void)
         wdata[i].f=(float)((i*20)/3.0F);
         wdata[i].v.p=HDmalloc((i+L1_INCM)*sizeof(hvl_t));
         wdata[i].v.len=i+L1_INCM;
-        for(t1=(wdata[i].v).p,j=0; j<(i+L1_INCM); j++, t1++) {
+        for(t1=(hvl_t *)((wdata[i].v).p),j=0; j<(i+L1_INCM); j++, t1++) {
             t1->p=HDmalloc((j+L2_INCM)*sizeof(unsigned int));
             t1->len=j+L2_INCM;
             for(k=0; k<j+L2_INCM; k++)
@@ -1102,7 +1102,7 @@ test_vltypes_compound_vlen_vlen(void)
             continue;
         } /* end if */
 
-        for(t1=wdata[i].v.p, t2=rdata[i].v.p, j=0; j<rdata[i].v.len; j++, t1++, t2++) {
+        for(t1=(hvl_t *)(wdata[i].v.p), t2=(hvl_t *)(rdata[i].v.p), j=0; j<rdata[i].v.len; j++, t1++, t2++) {
             if(t1->len != t2->len) {
                 TestErrPrintf("%d: VL data length don't match!, i=%d, j=%d, t1->len=%d, t2->len=%d\n",__LINE__,(int)i,(int)j,(int)t1->len,(int)t2->len);
                 continue;
@@ -1161,13 +1161,13 @@ static void
 test_vltypes_compound_vlstr(void)
 {
     typedef enum {
-	red,
-	blue,
-	green
+        red,
+        blue,
+        green
     } e1;
     typedef struct {
         char *string;
-	e1   color;
+        e1   color;
     } s2;
     typedef struct {                    /* Struct that the compound type are composed of */
         hvl_t v;
@@ -1199,12 +1199,12 @@ test_vltypes_compound_vlstr(void)
     for(i=0; i<SPACE1_DIM1; i++) {
         wdata[i].v.p=(s2*)HDmalloc((i+L3_INCM)*sizeof(s2));
         wdata[i].v.len=i+L3_INCM;
-        for(t1=(wdata[i].v).p, j=0; j<(i+L3_INCM); j++, t1++) {
-	    strcat(str, "m");
-	    t1->string = (char*)HDmalloc(strlen(str)*sizeof(char)+1);
+        for(t1=(s2 *)((wdata[i].v).p), j=0; j<(i+L3_INCM); j++, t1++) {
+            strcat(str, "m");
+            t1->string = (char*)HDmalloc(strlen(str)*sizeof(char)+1);
             strcpy(t1->string, str);
-	    /*t1->color = red;*/
-	    t1->color = blue;
+            /*t1->color = red;*/
+            t1->color = blue;
         }
     } /* end for */
 
@@ -1342,7 +1342,7 @@ test_vltypes_compound_vlstr(void)
             continue;
         } /* end if */
 
-        for(t1=wdata[i].v.p, t2=rdata[i].v.p, j=0; j<rdata[i].v.len; j++, t1++, t2++) {
+        for(t1=(s2 *)(wdata[i].v.p), t2=(s2 *)(rdata[i].v.p), j=0; j<rdata[i].v.len; j++, t1++, t2++) {
                 if( strcmp(t1->string, t2->string) ) {
                     TestErrPrintf("VL data values don't match!, t1->string=%s, t2->string=%s\n",t1->string, t2->string);
                     continue;
@@ -1400,7 +1400,7 @@ test_vltypes_compound_vlstr(void)
             continue;
         } /* end if */
 
-        for(t1=wdata2[i].v.p, t2=rdata2[i].v.p, j=0; j<rdata2[i].v.len; j++, t1++, t2++) {
+        for(t1=(s2 *)(wdata2[i].v.p), t2=(s2 *)(rdata2[i].v.p), j=0; j<rdata2[i].v.len; j++, t1++, t2++) {
                 if( strcmp(t1->string, t2->string) ) {
                     TestErrPrintf("VL data values don't match!, t1->string=%s, t2->string=%s\n",t1->string, t2->string);
                     continue;
@@ -1871,7 +1871,7 @@ test_vltypes_vlen_vlen_atomic(void)
             return;
         } /* end if */
         wdata[i].len=i+1;
-        for(t1=wdata[i].p,j=0; j<(i+1); j++, t1++) {
+        for(t1=(hvl_t *)(wdata[i].p),j=0; j<(i+1); j++, t1++) {
             t1->p=HDmalloc((j+1)*sizeof(unsigned int));
             if(t1->p==NULL) {
                 TestErrPrintf("Cannot allocate memory for VL data! i=%u, j=%u\n",i,j);
@@ -1977,7 +1977,7 @@ test_vltypes_vlen_vlen_atomic(void)
             TestErrPrintf("%d: VL data length don't match!, wdata[%d].len=%d, rdata[%d].len=%d\n",__LINE__,(int)i,(int)wdata[i].len,(int)i,(int)rdata[i].len);
             continue;
         } /* end if */
-        for(t1=wdata[i].p, t2=rdata[i].p, j=0; j<rdata[i].len; j++, t1++, t2++) {
+        for(t1=(hvl_t *)wdata[i].p, t2=(hvl_t *)(rdata[i].p), j=0; j<rdata[i].len; j++, t1++, t2++) {
             if(t1->len!=t2->len) {
                 TestErrPrintf("%d: VL data length don't match!, i=%d, j=%d, t1->len=%d, t2->len=%d\n",__LINE__,(int)i,(int)j,(int)t1->len,(int)t2->len);
                 continue;
@@ -2062,7 +2062,7 @@ rewrite_longer_vltypes_vlen_vlen_atomic(void)
             return;
         } /* end if */
         wdata[i].len = i + increment;
-        for(t1 = wdata[i].p, j = 0; j < (i + increment); j++, t1++) {
+        for(t1 = (hvl_t *)(wdata[i].p), j = 0; j < (i + increment); j++, t1++) {
             t1->p = HDmalloc((j + 1) * sizeof(unsigned int));
             if(t1->p == NULL) {
                 TestErrPrintf("Cannot allocate memory for VL data! i=%u, j=%u\n", i, j);
@@ -2157,7 +2157,7 @@ rewrite_longer_vltypes_vlen_vlen_atomic(void)
             TestErrPrintf("%d: VL data length don't match!, wdata[%d].len=%d, rdata[%d].len=%d\n",__LINE__,(int)i,(int)wdata[i].len,(int)i,(int)rdata[i].len);
             continue;
         } /* end if */
-        for(t1=wdata[i].p, t2=rdata[i].p, j=0; j<rdata[i].len; j++, t1++, t2++) {
+        for(t1=(hvl_t *)(wdata[i].p), t2=(hvl_t *)(rdata[i].p), j=0; j<rdata[i].len; j++, t1++, t2++) {
             if(t1->len!=t2->len) {
                 TestErrPrintf("%d: VL data length don't match!, i=%d, j=%d, t1->len=%d, t2->len=%d\n",__LINE__,(int)i,(int)j,(int)t1->len,(int)t2->len);
                 continue;
@@ -2238,7 +2238,7 @@ rewrite_shorter_vltypes_vlen_vlen_atomic(void)
             return;
         } /* end if */
         wdata[i].len=i+increment;
-        for(t1=wdata[i].p,j=0; j<(i+increment); j++, t1++) {
+        for(t1=(hvl_t *)(wdata[i].p),j=0; j<(i+increment); j++, t1++) {
             t1->p=HDmalloc((j+1)*sizeof(unsigned int));
             if(t1->p==NULL) {
                 TestErrPrintf("Cannot allocate memory for VL data! i=%u, j=%u\n",i,j);
@@ -2333,7 +2333,7 @@ rewrite_shorter_vltypes_vlen_vlen_atomic(void)
             TestErrPrintf("%d: VL data length don't match!, wdata[%d].len=%d, rdata[%d].len=%d\n",__LINE__,(int)i,(int)wdata[i].len,(int)i,(int)rdata[i].len);
             continue;
         } /* end if */
-        for(t1=wdata[i].p, t2=rdata[i].p, j=0; j<rdata[i].len; j++, t1++, t2++) {
+        for(t1=(hvl_t *)(wdata[i].p), t2=(hvl_t *)(rdata[i].p), j=0; j<rdata[i].len; j++, t1++, t2++) {
             if(t1->len!=t2->len) {
                 TestErrPrintf("%d: VL data length don't match!, i=%d, j=%d, t1->len=%d, t2->len=%d\n",__LINE__,(int)i,(int)j,(int)t1->len,(int)t2->len);
                 continue;
@@ -2496,7 +2496,7 @@ test_vltypes_fill_value(void)
 
 
     /* Allocate space for the buffer to read data */
-    rbuf = HDmalloc(SPACE4_DIM_LARGE * sizeof(dtype1_struct));
+    rbuf = (dtype1_struct *)HDmalloc(SPACE4_DIM_LARGE * sizeof(dtype1_struct));
     CHECK(rbuf, NULL, "HDmalloc");
 
 
@@ -2538,7 +2538,7 @@ test_vltypes_fill_value(void)
     CHECK(file_id, FAIL, "H5Fcreate");
 
     /* Create datasets with different storage layouts */
-    for(layout = H5D_COMPACT; layout <= H5D_CHUNKED; layout++) {
+    for(layout = H5D_COMPACT; layout <= H5D_CHUNKED; H5_INC_ENUM(H5D_layout_t, layout)) {
         unsigned compress_loop;         /* # of times to run loop, for testing compressed chunked dataset */
         unsigned test_loop;             /* Loop over datasets */
 
@@ -2597,6 +2597,8 @@ test_vltypes_fill_value(void)
                     }
                     break;
 
+                case H5D_LAYOUT_ERROR:
+                case H5D_NLAYOUTS:
                 default:
                     assert(0 && "Unknown layout type!");
                     break;
@@ -2648,7 +2650,7 @@ test_vltypes_fill_value(void)
     CHECK(file_id, FAIL, "H5Fopen");
 
     /* Read empty datasets with different storage layouts */
-    for(layout = H5D_COMPACT; layout <= H5D_CHUNKED; layout++) {
+    for(layout = H5D_COMPACT; layout <= H5D_CHUNKED; H5_INC_ENUM(H5D_layout_t, layout)) {
         unsigned compress_loop;         /* # of times to run loop, for testing compressed chunked dataset */
         unsigned test_loop;             /* Loop over datasets */
 
@@ -2698,6 +2700,8 @@ test_vltypes_fill_value(void)
                     dset_elmts = SPACE4_DIM_LARGE;
                     break;
 
+                case H5D_LAYOUT_ERROR:
+                case H5D_NLAYOUTS:
                 default:
                     assert(0 && "Unknown layout type!");
                     break;
@@ -2843,7 +2847,7 @@ test_vltypes_fill_value(void)
     CHECK(file_id, FAIL, "H5Fopen");
 
     /* Write one element & fill values to  datasets with different storage layouts */
-    for(layout = H5D_COMPACT; layout <= H5D_CHUNKED; layout++) {
+    for(layout = H5D_COMPACT; layout <= H5D_CHUNKED; H5_INC_ENUM(H5D_layout_t, layout)) {
         unsigned compress_loop;         /* # of times to run loop, for testing compressed chunked dataset */
         unsigned test_loop;             /* Loop over datasets */
 
@@ -2893,6 +2897,8 @@ test_vltypes_fill_value(void)
                     dset_elmts = SPACE4_DIM_LARGE;
                     break;
 
+                case H5D_LAYOUT_ERROR:
+                case H5D_NLAYOUTS:
                 default:
                     assert(0 && "Unknown layout type!");
                     break;