Convert hbool_t --> bool in testpar (#3495)

1 files changed, 82 insertions, 83 deletions

diff --git a/testpar/API/t_shapesame.c b/testpar/API/t_shapesame.c
index 9d48827..fd6a8dd 100644
--- a/testpar/API/t_shapesame.c
+++ b/testpar/API/t_shapesame.c
@@ -130,14 +130,14 @@ struct hs_dr_pio_test_vars_t {
 static void
 hs_dr_pio_test__setup(const int test_num, const int edge_size, const int checker_edge_size,
                       const int chunk_edge_size, const int small_rank, const int large_rank,
-                      const hbool_t use_collective_io, const hid_t dset_type, const int express_test,
+                      const bool use_collective_io, const hid_t dset_type, const int express_test,
                       struct hs_dr_pio_test_vars_t *tv_ptr)
 {
 #if CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG
     const char *fcnName = "hs_dr_pio_test__setup()";
 #endif /* CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG */
     const char *filename;
-    hbool_t     mis_match = FALSE;
+    bool        mis_match = false;
     int         i;
     int         mrc;
     int         mpi_rank; /* needed by the VRFY macro */
@@ -470,7 +470,7 @@ hs_dr_pio_test__setup(const int test_num, const int edge_size, const int checker
 
     /* verify that the correct data was written to the small data set */
     expected_value = 0;
-    mis_match      = FALSE;
+    mis_match      = false;
     ptr_1          = tv_ptr->small_ds_buf_1;
 
     i = 0;
@@ -478,12 +478,12 @@ hs_dr_pio_test__setup(const int test_num, const int edge_size, const int checker
 
         if (*ptr_1 != expected_value) {
 
-            mis_match = TRUE;
+            mis_match = true;
         }
         ptr_1++;
         expected_value++;
     }
-    VRFY((mis_match == FALSE), "small ds init data good.");
+    VRFY((mis_match == false), "small ds init data good.");
 
     /* setup selections for writing initial data to the large data set */
 
@@ -541,7 +541,7 @@ hs_dr_pio_test__setup(const int test_num, const int edge_size, const int checker
 
     /* verify that the correct data was written to the large data set */
     expected_value = 0;
-    mis_match      = FALSE;
+    mis_match      = false;
     ptr_1          = tv_ptr->large_ds_buf_1;
 
     i = 0;
@@ -549,12 +549,12 @@ hs_dr_pio_test__setup(const int test_num, const int edge_size, const int checker
 
         if (*ptr_1 != expected_value) {
 
-            mis_match = TRUE;
+            mis_match = true;
         }
         ptr_1++;
         expected_value++;
     }
-    VRFY((mis_match == FALSE), "large ds init data good.");
+    VRFY((mis_match == false), "large ds init data good.");
 
     /* sync with the other processes before changing data */
     mrc = MPI_Barrier(MPI_COMM_WORLD);
@@ -702,7 +702,7 @@ contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
 #if CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG
     const char *fcnName = "contig_hs_dr_pio_test__run_test()";
 #endif /* CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
-    hbool_t   mis_match = FALSE;
+    bool      mis_match = false;
     int       i, j, k, l;
     size_t    n;
     int       mpi_rank; /* needed by the VRFY macro */
@@ -824,7 +824,7 @@ contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
                      * selections as having the same shape.
                      */
                     check = H5Sselect_shape_same(tv_ptr->small_ds_slice_sid, tv_ptr->file_large_ds_sid_0);
-                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
+                    VRFY((check == true), "H5Sselect_shape_same passed");
 
                     /* Read selection from disk */
 #if CONTIG_HS_DR_PIO_TEST__D2M_L2S__DEBUG
@@ -842,7 +842,7 @@ contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
 
                     /* verify that expected data is retrieved */
 
-                    mis_match = FALSE;
+                    mis_match = false;
                     ptr_1     = tv_ptr->small_ds_slice_buf;
                     expected_value =
                         (uint32_t)((i * tv_ptr->edge_size * tv_ptr->edge_size * tv_ptr->edge_size *
@@ -854,7 +854,7 @@ contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
 
                         if (*ptr_1 != expected_value) {
 
-                            mis_match = TRUE;
+                            mis_match = true;
                         }
 
                         *ptr_1 = 0; /* zero data for next use */
@@ -863,7 +863,7 @@ contig_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
                         expected_value++;
                     }
 
-                    VRFY((mis_match == FALSE), "small slice read from large ds data good.");
+                    VRFY((mis_match == false), "small slice read from large ds data good.");
 
                     (tv_ptr->tests_run)++;
                 }
@@ -910,7 +910,7 @@ contig_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
 #if CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG
     const char *fcnName = "contig_hs_dr_pio_test__d2m_s2l()";
 #endif /* CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
-    hbool_t   mis_match = FALSE;
+    bool      mis_match = false;
     int       i, j, k, l;
     size_t    n;
     int       mpi_rank; /* needed by the VRFY macro */
@@ -1053,7 +1053,7 @@ contig_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                      * selections as having the same shape.
                      */
                     check = H5Sselect_shape_same(tv_ptr->file_small_ds_sid_0, tv_ptr->mem_large_ds_sid);
-                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
+                    VRFY((check == true), "H5Sselect_shape_same passed");
 
                     /* Read selection from disk */
 #if CONTIG_HS_DR_PIO_TEST__D2M_S2L__DEBUG
@@ -1089,7 +1089,7 @@ contig_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
 
                             if (*ptr_1 != expected_value) {
 
-                                mis_match = TRUE;
+                                mis_match = true;
                             }
                             expected_value++;
                         }
@@ -1097,7 +1097,7 @@ contig_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
 
                             if (*ptr_1 != 0) {
 
-                                mis_match = TRUE;
+                                mis_match = true;
                             }
                         }
                         /* zero out the value for the next pass */
@@ -1106,7 +1106,7 @@ contig_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                         ptr_1++;
                     }
 
-                    VRFY((mis_match == FALSE), "small slice read from large ds data good.");
+                    VRFY((mis_match == false), "small slice read from large ds data good.");
 
                     (tv_ptr->tests_run)++;
                 }
@@ -1155,7 +1155,7 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
 #if CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG
     const char *fcnName = "contig_hs_dr_pio_test__m2d_l2s()";
 #endif /* CONTIG_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
-    hbool_t   mis_match = FALSE;
+    bool      mis_match = false;
     int       i, j, k, l;
     size_t    n;
     int       mpi_rank; /* needed by the VRFY macro */
@@ -1319,7 +1319,7 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
                      * on disk full square selections as having the same shape.
                      */
                     check = H5Sselect_shape_same(tv_ptr->file_small_ds_sid_0, tv_ptr->mem_large_ds_sid);
-                    VRFY((check == TRUE), "H5Sselect_shape_same passed.");
+                    VRFY((check == true), "H5Sselect_shape_same passed.");
 
                     /* write the slice from the in memory large data set to the
                      * slice of the on disk small dataset. */
@@ -1342,7 +1342,7 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
 
                     /* verify that expected data is retrieved */
 
-                    mis_match = FALSE;
+                    mis_match = false;
                     ptr_1     = tv_ptr->small_ds_buf_1;
 
                     expected_value =
@@ -1363,7 +1363,7 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
 
                             if (*ptr_1 != expected_value) {
 
-                                mis_match = TRUE;
+                                mis_match = true;
                             }
                             expected_value++;
                         }
@@ -1371,7 +1371,7 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
 
                             if (*ptr_1 != 0) {
 
-                                mis_match = TRUE;
+                                mis_match = true;
                             }
                         }
                         /* zero out the value for the next pass */
@@ -1380,7 +1380,7 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
                         ptr_1++;
                     }
 
-                    VRFY((mis_match == FALSE), "small slice write from large ds data good.");
+                    VRFY((mis_match == false), "small slice write from large ds data good.");
 
                     (tv_ptr->tests_run)++;
                 }
@@ -1431,7 +1431,7 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
 #if CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG
     const char *fcnName = "contig_hs_dr_pio_test__m2d_s2l()";
 #endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
-    hbool_t   mis_match = FALSE;
+    bool      mis_match = false;
     int       i, j, k, l;
     size_t    n;
     int       mpi_rank; /* needed by the VRFY macro */
@@ -1602,7 +1602,7 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                      * as having the same shape.
                      */
                     check = H5Sselect_shape_same(tv_ptr->mem_small_ds_sid, tv_ptr->file_large_ds_sid_0);
-                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
+                    VRFY((check == true), "H5Sselect_shape_same passed");
 
                     /* write the small data set slice from memory to the
                      * target slice of the disk data set
@@ -1650,7 +1650,7 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
 
                             if (*ptr_1 != expected_value) {
 
-                                mis_match = TRUE;
+                                mis_match = true;
                             }
 
                             expected_value++;
@@ -1659,7 +1659,7 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
 
                             if (*ptr_1 != 0) {
 
-                                mis_match = TRUE;
+                                mis_match = true;
                             }
                         }
                         /* zero out buffer for next test */
@@ -1667,7 +1667,7 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                         ptr_1++;
                     }
 
-                    VRFY((mis_match == FALSE), "small ds slice write to large ds slice data good.");
+                    VRFY((mis_match == false), "small ds slice write to large ds slice data good.");
 
                     (tv_ptr->tests_run)++;
                 }
@@ -1701,7 +1701,7 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
 
 static void
 contig_hs_dr_pio_test__run_test(const int test_num, const int edge_size, const int chunk_edge_size,
-                                const int small_rank, const int large_rank, const hbool_t use_collective_io,
+                                const int small_rank, const int large_rank, const bool use_collective_io,
                                 const hid_t dset_type, int express_test, int *skips_ptr, int max_skips,
                                 int64_t *total_tests_ptr, int64_t *tests_run_ptr, int64_t *tests_skipped_ptr,
                                 int mpi_rank)
@@ -1947,7 +1947,7 @@ contig_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
                     chunk_edge_size = 0;
 
                     contig_hs_dr_pio_test__run_test(
-                        test_num, edge_size, chunk_edge_size, small_rank, large_rank, FALSE, dset_type,
+                        test_num, edge_size, chunk_edge_size, small_rank, large_rank, false, dset_type,
                         express_test, &skips, max_skips, &total_tests, &tests_run, &tests_skipped, mpi_rank);
                     test_num++;
                     break;
@@ -1958,7 +1958,7 @@ contig_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
                     chunk_edge_size = 0;
 
                     contig_hs_dr_pio_test__run_test(
-                        test_num, edge_size, chunk_edge_size, small_rank, large_rank, TRUE, dset_type,
+                        test_num, edge_size, chunk_edge_size, small_rank, large_rank, true, dset_type,
                         express_test, &skips, max_skips, &total_tests, &tests_run, &tests_skipped, mpi_rank);
                     test_num++;
                     break;
@@ -1969,7 +1969,7 @@ contig_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
                     chunk_edge_size = 5;
 
                     contig_hs_dr_pio_test__run_test(
-                        test_num, edge_size, chunk_edge_size, small_rank, large_rank, FALSE, dset_type,
+                        test_num, edge_size, chunk_edge_size, small_rank, large_rank, false, dset_type,
                         express_test, &skips, max_skips, &total_tests, &tests_run, &tests_skipped, mpi_rank);
                     test_num++;
                     break;
@@ -1980,14 +1980,14 @@ contig_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
                     chunk_edge_size = 5;
 
                     contig_hs_dr_pio_test__run_test(
-                        test_num, edge_size, chunk_edge_size, small_rank, large_rank, TRUE, dset_type,
+                        test_num, edge_size, chunk_edge_size, small_rank, large_rank, true, dset_type,
                         express_test, &skips, max_skips, &total_tests, &tests_run, &tests_skipped, mpi_rank);
                     test_num++;
                     break;
                     /* end of case COL_CHUNKED */
 
                 default:
-                    VRFY((FALSE), "unknown test type");
+                    VRFY((false), "unknown test type");
                     break;
 
             } /* end of switch(sstest_type) */
@@ -2046,7 +2046,7 @@ ckrbrd_hs_dr_pio_test__slct_ckrbrd(const int mpi_rank, const hid_t tgt_sid, cons
 #if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG
     const char *fcnName = "ckrbrd_hs_dr_pio_test__slct_ckrbrd():";
 #endif
-    hbool_t   first_selection = TRUE;
+    bool      first_selection = true;
     int       i, j, k, l, m;
     int       n_cube_offset;
     int       sel_offset;
@@ -2249,7 +2249,7 @@ ckrbrd_hs_dr_pio_test__slct_ckrbrd(const int mpi_rank, const hid_t tgt_sid, cons
 
                             if (first_selection) {
 
-                                first_selection = FALSE;
+                                first_selection = false;
 
                                 ret = H5Sselect_hyperslab(tgt_sid, H5S_SELECT_SET, &(start[n_cube_offset]),
                                                           &(stride[n_cube_offset]), &(count[n_cube_offset]),
@@ -2321,7 +2321,7 @@ ckrbrd_hs_dr_pio_test__slct_ckrbrd(const int mpi_rank, const hid_t tgt_sid, cons
 **  ckrbrd_hs_dr_pio_test__verify_data():
 **
 **    Examine the supplied buffer to see if it contains the
-**    expected data.  Return TRUE if it does, and FALSE
+**    expected data.  Return true if it does, and false
 **      otherwise.
 **
 **    The supplied buffer is presumed to this process's slice
@@ -2374,17 +2374,17 @@ ckrbrd_hs_dr_pio_test__slct_ckrbrd(const int mpi_rank, const hid_t tgt_sid, cons
 
 #define CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG 0
 
-static hbool_t
+static bool
 ckrbrd_hs_dr_pio_test__verify_data(uint32_t *buf_ptr, const int rank, const int edge_size,
                                    const int checker_edge_size, uint32_t first_expected_val,
-                                   hbool_t buf_starts_in_checker)
+                                   bool buf_starts_in_checker)
 {
 #if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG
     const char *fcnName = "ckrbrd_hs_dr_pio_test__verify_data():";
 #endif
-    hbool_t   good_data = TRUE;
-    hbool_t   in_checker;
-    hbool_t   start_in_checker[5];
+    bool      good_data = true;
+    bool      in_checker;
+    bool      start_in_checker[5];
     uint32_t  expected_value;
     uint32_t *val_ptr;
     int       i, j, k, l, m;     /* to track position in n-cube */
@@ -2476,7 +2476,7 @@ do {
 
                         if (*val_ptr != expected_value) {
 
-                            good_data = FALSE;
+                            good_data = false;
                         }
 
                         /* zero out buffer for re-use */
@@ -2484,7 +2484,7 @@ do {
                     }
                     else if (*val_ptr != 0) {
 
-                        good_data = FALSE;
+                        good_data = false;
 
                         /* zero out buffer for re-use */
                         *val_ptr = 0;
@@ -2546,7 +2546,7 @@ ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
     const char *fcnName = "ckrbrd_hs_dr_pio_test__d2m_l2s()";
     uint32_t   *ptr_0;
 #endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG */
-    hbool_t  data_ok = FALSE;
+    bool     data_ok = false;
     int      i, j, k, l;
     uint32_t expected_value;
     int      mpi_rank; /* needed by VRFY */
@@ -2698,7 +2698,7 @@ ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
                      * selections as having the same shape.
                      */
                     check = H5Sselect_shape_same(tv_ptr->small_ds_slice_sid, tv_ptr->file_large_ds_sid_0);
-                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
+                    VRFY((check == true), "H5Sselect_shape_same passed");
 
                     /* Read selection from disk */
 #if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_L2S__DEBUG
@@ -2729,9 +2729,9 @@ ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
 
                     data_ok = ckrbrd_hs_dr_pio_test__verify_data(
                         tv_ptr->small_ds_slice_buf, tv_ptr->small_rank - 1, tv_ptr->edge_size,
-                        tv_ptr->checker_edge_size, expected_value, (hbool_t)TRUE);
+                        tv_ptr->checker_edge_size, expected_value, (bool)true);
 
-                    VRFY((data_ok == TRUE), "small slice read from large ds data good.");
+                    VRFY((data_ok == true), "small slice read from large ds data good.");
 
                     (tv_ptr->tests_run)++;
                 }
@@ -2778,7 +2778,7 @@ ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
 #if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG
     const char *fcnName = "ckrbrd_hs_dr_pio_test__d2m_s2l()";
 #endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
-    hbool_t   data_ok = FALSE;
+    bool      data_ok = false;
     int       i, j, k, l;
     size_t    u;
     size_t    start_index;
@@ -2920,7 +2920,7 @@ ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                      * selections as having the same shape.
                      */
                     check = H5Sselect_shape_same(tv_ptr->file_small_ds_sid_0, tv_ptr->mem_large_ds_sid);
-                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
+                    VRFY((check == true), "H5Sselect_shape_same passed");
 
                     /* Read selection from disk */
 #if CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG
@@ -2938,7 +2938,7 @@ ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                     /* verify that the expected data and only the
                      * expected data was read.
                      */
-                    data_ok        = TRUE;
+                    data_ok        = true;
                     ptr_1          = tv_ptr->large_ds_buf_1;
                     expected_value = (uint32_t)((size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size);
                     start_index =
@@ -2978,7 +2978,7 @@ ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
 
                         if (*ptr_1 != 0) {
 
-                            data_ok = FALSE;
+                            data_ok = false;
                         }
 
                         /* zero out the value for the next pass */
@@ -2987,13 +2987,13 @@ ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                         ptr_1++;
                     }
 
-                    VRFY((data_ok == TRUE), "slice read from small to large ds data good(1).");
+                    VRFY((data_ok == true), "slice read from small to large ds data good(1).");
 
                     data_ok = ckrbrd_hs_dr_pio_test__verify_data(ptr_1, tv_ptr->small_rank - 1,
                                                                  tv_ptr->edge_size, tv_ptr->checker_edge_size,
-                                                                 expected_value, (hbool_t)TRUE);
+                                                                 expected_value, (bool)true);
 
-                    VRFY((data_ok == TRUE), "slice read from small to large ds data good(2).");
+                    VRFY((data_ok == true), "slice read from small to large ds data good(2).");
 
                     ptr_1 = tv_ptr->large_ds_buf_1 + stop_index + 1;
 
@@ -3001,7 +3001,7 @@ ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
 
                         if (*ptr_1 != 0) {
 
-                            data_ok = FALSE;
+                            data_ok = false;
                         }
 
                         /* zero out the value for the next pass */
@@ -3010,7 +3010,7 @@ ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                         ptr_1++;
                     }
 
-                    VRFY((data_ok == TRUE), "slice read from small to large ds data good(3).");
+                    VRFY((data_ok == true), "slice read from small to large ds data good(3).");
 
                     (tv_ptr->tests_run)++;
                 }
@@ -3061,7 +3061,7 @@ ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
 #if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG
     const char *fcnName = "ckrbrd_hs_dr_pio_test__m2d_l2s()";
 #endif /* CHECKER_BOARD_HS_DR_PIO_TEST__M2D_L2S__DEBUG */
-    hbool_t   data_ok = FALSE;
+    bool      data_ok = false;
     int       i, j, k, l;
     size_t    u;
     size_t    start_index;
@@ -3242,7 +3242,7 @@ ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
                      * slice of the small data set as having the same shape.
                      */
                     check = H5Sselect_shape_same(tv_ptr->file_small_ds_sid_1, tv_ptr->mem_large_ds_sid);
-                    VRFY((check == TRUE), "H5Sselect_shape_same passed.");
+                    VRFY((check == true), "H5Sselect_shape_same passed.");
 
                     /* write the checker board selection of the slice from the in
                      * memory large data set to the slice of the on disk small
@@ -3279,33 +3279,33 @@ ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
                     assert(start_index < stop_index);
                     assert(stop_index <= tv_ptr->small_ds_size);
 
-                    data_ok = TRUE;
+                    data_ok = true;
 
                     ptr_1 = tv_ptr->small_ds_buf_1;
                     for (u = 0; u < start_index; u++, ptr_1++) {
 
                         if (*ptr_1 != 0) {
 
-                            data_ok = FALSE;
+                            data_ok = false;
                             *ptr_1  = 0;
                         }
                     }
 
                     data_ok &= ckrbrd_hs_dr_pio_test__verify_data(
                         tv_ptr->small_ds_buf_1 + start_index, tv_ptr->small_rank - 1, tv_ptr->edge_size,
-                        tv_ptr->checker_edge_size, expected_value, (hbool_t)TRUE);
+                        tv_ptr->checker_edge_size, expected_value, (bool)true);
 
                     ptr_1 = tv_ptr->small_ds_buf_1;
                     for (u = stop_index; u < tv_ptr->small_ds_size; u++, ptr_1++) {
 
                         if (*ptr_1 != 0) {
 
-                            data_ok = FALSE;
+                            data_ok = false;
                             *ptr_1  = 0;
                         }
                     }
 
-                    VRFY((data_ok == TRUE), "large slice write slice to small slice data good.");
+                    VRFY((data_ok == true), "large slice write slice to small slice data good.");
 
                     (tv_ptr->tests_run)++;
                 }
@@ -3356,7 +3356,7 @@ ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
 #if CHECKER_BOARD_HS_DR_PIO_TEST__M2D_S2L__DEBUG
     const char *fcnName = "ckrbrd_hs_dr_pio_test__m2d_s2l()";
 #endif /* CONTIG_HS_DR_PIO_TEST__M2D_S2L__DEBUG */
-    hbool_t   data_ok = FALSE;
+    bool      data_ok = false;
     int       i, j, k, l;
     size_t    u;
     size_t    start_index;
@@ -3533,7 +3533,7 @@ ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                      * as having the same shape.
                      */
                     check = H5Sselect_shape_same(tv_ptr->mem_small_ds_sid, tv_ptr->file_large_ds_sid_1);
-                    VRFY((check == TRUE), "H5Sselect_shape_same passed");
+                    VRFY((check == true), "H5Sselect_shape_same passed");
 
                     /* write the small data set slice from memory to the
                      * target slice of the disk data set
@@ -3573,33 +3573,33 @@ ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                     assert(start_index < stop_index);
                     assert(stop_index < tv_ptr->large_ds_size);
 
-                    data_ok = TRUE;
+                    data_ok = true;
 
                     ptr_1 = tv_ptr->large_ds_buf_1;
                     for (u = 0; u < start_index; u++, ptr_1++) {
 
                         if (*ptr_1 != 0) {
 
-                            data_ok = FALSE;
+                            data_ok = false;
                             *ptr_1  = 0;
                         }
                     }
 
                     data_ok &= ckrbrd_hs_dr_pio_test__verify_data(
                         tv_ptr->large_ds_buf_1 + start_index, tv_ptr->small_rank - 1, tv_ptr->edge_size,
-                        tv_ptr->checker_edge_size, expected_value, (hbool_t)TRUE);
+                        tv_ptr->checker_edge_size, expected_value, (bool)true);
 
                     ptr_1 = tv_ptr->large_ds_buf_1;
                     for (u = stop_index; u < tv_ptr->small_ds_size; u++, ptr_1++) {
 
                         if (*ptr_1 != 0) {
 
-                            data_ok = FALSE;
+                            data_ok = false;
                             *ptr_1  = 0;
                         }
                     }
 
-                    VRFY((data_ok == TRUE), "small ds cb slice write to large ds slice data good.");
+                    VRFY((data_ok == true), "small ds cb slice write to large ds slice data good.");
 
                     (tv_ptr->tests_run)++;
                 }
@@ -3634,10 +3634,9 @@ ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
 static void
 ckrbrd_hs_dr_pio_test__run_test(const int test_num, const int edge_size, const int checker_edge_size,
                                 const int chunk_edge_size, const int small_rank, const int large_rank,
-                                const hbool_t use_collective_io, const hid_t dset_type,
-                                const int express_test, int *skips_ptr, int max_skips,
-                                int64_t *total_tests_ptr, int64_t *tests_run_ptr, int64_t *tests_skipped_ptr,
-                                int mpi_rank)
+                                const bool use_collective_io, const hid_t dset_type, const int express_test,
+                                int *skips_ptr, int max_skips, int64_t *total_tests_ptr,
+                                int64_t *tests_run_ptr, int64_t *tests_skipped_ptr, int mpi_rank)
 
 {
 #if CKRBRD_HS_DR_PIO_TEST__RUN_TEST__DEBUG
@@ -3870,7 +3869,7 @@ ckrbrd_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
                     /* contiguous data set, independent I/O */
                     chunk_edge_size = 0;
                     ckrbrd_hs_dr_pio_test__run_test(test_num, edge_size, checker_edge_size, chunk_edge_size,
-                                                    small_rank, large_rank, FALSE, dset_type, express_test,
+                                                    small_rank, large_rank, false, dset_type, express_test,
                                                     &skips, max_skips, &total_tests, &tests_run,
                                                     &tests_skipped, mpi_rank);
                     test_num++;
@@ -3881,7 +3880,7 @@ ckrbrd_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
                     /* contiguous data set, collective I/O */
                     chunk_edge_size = 0;
                     ckrbrd_hs_dr_pio_test__run_test(test_num, edge_size, checker_edge_size, chunk_edge_size,
-                                                    small_rank, large_rank, TRUE, dset_type, express_test,
+                                                    small_rank, large_rank, true, dset_type, express_test,
                                                     &skips, max_skips, &total_tests, &tests_run,
                                                     &tests_skipped, mpi_rank);
                     test_num++;
@@ -3892,7 +3891,7 @@ ckrbrd_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
                     /* chunked data set, independent I/O */
                     chunk_edge_size = 5;
                     ckrbrd_hs_dr_pio_test__run_test(test_num, edge_size, checker_edge_size, chunk_edge_size,
-                                                    small_rank, large_rank, FALSE, dset_type, express_test,
+                                                    small_rank, large_rank, false, dset_type, express_test,
                                                     &skips, max_skips, &total_tests, &tests_run,
                                                     &tests_skipped, mpi_rank);
                     test_num++;
@@ -3903,7 +3902,7 @@ ckrbrd_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
                     /* chunked data set, collective I/O */
                     chunk_edge_size = 5;
                     ckrbrd_hs_dr_pio_test__run_test(test_num, edge_size, checker_edge_size, chunk_edge_size,
-                                                    small_rank, large_rank, TRUE, dset_type, express_test,
+                                                    small_rank, large_rank, true, dset_type, express_test,
                                                     &skips, max_skips, &total_tests, &tests_run,
                                                     &tests_skipped, mpi_rank);
                     test_num++;
@@ -3911,7 +3910,7 @@ ckrbrd_hs_dr_pio_test(ShapeSameTestMethods sstest_type)
                     /* end of case COL_CHUNKED */
 
                 default:
-                    VRFY((FALSE), "unknown test type");
+                    VRFY((false), "unknown test type");
                     break;
 
             } /* end of switch(sstest_type) */
@@ -4188,9 +4187,9 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type)
         /* set Parallel access with communicator */
         ret = H5Pset_fapl_mpio(ret_pl, comm, info);
         VRFY((ret >= 0), "");
-        ret = H5Pset_all_coll_metadata_ops(ret_pl, TRUE);
+        ret = H5Pset_all_coll_metadata_ops(ret_pl, true);
         VRFY((ret >= 0), "");
-        ret = H5Pset_coll_metadata_write(ret_pl, TRUE);
+        ret = H5Pset_coll_metadata_write(ret_pl, true);
         VRFY((ret >= 0), "");
         return (ret_pl);
     }