Rename HDassert() to assert() (#3191)

* Change HDassert to assert

* Fix bin/make_err

testpar/API/t_chunk_alloc.c

@@ -275,7 +275,7 @@ parallel_access_dataset(const char *filename, int chunk_factor, access_type acti
         case open_only:
             break;
         default:
-            HDassert(0);
+            assert(0);
     }
 
     /* Close up */
@@ -401,7 +401,7 @@ verify_data(const char *filename, int chunk_factor, write_type write_pattern, in
                     value = 0;
                 break;
             default:
-                HDassert(0);
+                assert(0);
         }
 
         /* verify content of the chunk */

testpar/API/t_dset.c

@@ -3116,13 +3116,13 @@ test_actual_io_mode(int selection_mode)
 
     MPI_Barrier(MPI_COMM_WORLD);
 
-    HDassert(mpi_size >= 1);
+    assert(mpi_size >= 1);
 
     mpi_comm = MPI_COMM_WORLD;
     mpi_info = MPI_INFO_NULL;
 
     filename = (const char *)PARATESTFILE /* GetTestParameters() */;
-    HDassert(filename != NULL);
+    assert(filename != NULL);
 
     /* Setup the file access template */
     fapl = create_faccess_plist(mpi_comm, mpi_info, facc_type);
@@ -3638,7 +3638,7 @@ test_no_collective_cause_mode(int selection_mode)
 
     MPI_Barrier(MPI_COMM_WORLD);
 
-    HDassert(mpi_size >= 1);
+    assert(mpi_size >= 1);
 
     mpi_comm = MPI_COMM_WORLD;
     mpi_info = MPI_INFO_NULL;
@@ -3680,7 +3680,7 @@ test_no_collective_cause_mode(int selection_mode)
     }
 
     filename = (const char *)PARATESTFILE /* GetTestParameters() */;
-    HDassert(filename != NULL);
+    assert(filename != NULL);
 
     /* Setup the file access template */
     fapl = create_faccess_plist(mpi_comm, mpi_info, l_facc_type);
@@ -4294,7 +4294,7 @@ test_dense_attr(void)
 
     /* get filename */
     filename = (const char *)PARATESTFILE /* GetTestParameters() */;
-    HDassert(filename != NULL);
+    assert(filename != NULL);
 
     fpid = H5Pcreate(H5P_FILE_ACCESS);
     VRFY((fpid > 0), "H5Pcreate succeeded");

testpar/API/t_file.c

@@ -727,8 +727,8 @@ open_file(const char *filename, hid_t fapl, int metadata_write_strategy, hsize_t
         entry_ptr = cache_ptr->index[i];
 
         while (entry_ptr != NULL) {
-            HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
-            HDassert(entry_ptr->is_dirty == FALSE);
+            assert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+            assert(entry_ptr->is_dirty == FALSE);
 
             if (!entry_ptr->is_pinned && !entry_ptr->is_protected) {
                 ret = H5AC_expunge_entry(f, entry_ptr->type, entry_ptr->addr, 0);

testpar/API/t_mdset.c

@@ -1955,7 +1955,7 @@ rr_obj_hdr_flush_confusion(void)
         return;
     }
 
-    HDassert(mpi_size > 2);
+    assert(mpi_size > 2);
 
     is_reader = mpi_rank % 2;
     mrc       = MPI_Comm_split(MPI_COMM_WORLD, is_reader, mpi_rank, &comm);
@@ -2781,7 +2781,7 @@ chunk_align_bug_1(void)
 #endif
 
     /* Set aggregator size and alignment, disable metadata aggregator */
-    HDassert(AGGR_SIZE > CHUNK_SIZE);
+    assert(AGGR_SIZE > CHUNK_SIZE);
     ret = H5Pset_small_data_block_size(fapl_id, AGGR_SIZE);
     VRFY((ret >= 0), "H5Pset_small_data_block_size succeeded");
     ret = H5Pset_meta_block_size(fapl_id, 0);

testpar/API/t_shapesame.c

@@ -151,12 +151,12 @@ hs_dr_pio_test__setup(const int test_num, const int edge_size, const int checker
     hid_t       large_ds_dcpl_id = H5P_DEFAULT;
     herr_t      ret; /* Generic return value */
 
-    HDassert(edge_size >= 6);
-    HDassert(edge_size >= chunk_edge_size);
-    HDassert((chunk_edge_size == 0) || (chunk_edge_size >= 3));
-    HDassert(1 < small_rank);
-    HDassert(small_rank < large_rank);
-    HDassert(large_rank <= PAR_SS_DR_MAX_RANK);
+    assert(edge_size >= 6);
+    assert(edge_size >= chunk_edge_size);
+    assert((chunk_edge_size == 0) || (chunk_edge_size >= 3));
+    assert(1 < small_rank);
+    assert(small_rank < large_rank);
+    assert(large_rank <= PAR_SS_DR_MAX_RANK);
 
     tv_ptr->test_num          = test_num;
     tv_ptr->edge_size         = edge_size;
@@ -171,7 +171,7 @@ hs_dr_pio_test__setup(const int test_num, const int edge_size, const int checker
     /* the VRFY() macro needs the local variable mpi_rank -- set it up now */
     mpi_rank = tv_ptr->mpi_rank;
 
-    HDassert(tv_ptr->mpi_size >= 1);
+    assert(tv_ptr->mpi_size >= 1);
 
     tv_ptr->mpi_comm = MPI_COMM_WORLD;
     tv_ptr->mpi_info = MPI_INFO_NULL;
@@ -185,8 +185,8 @@ hs_dr_pio_test__setup(const int test_num, const int edge_size, const int checker
     /* used by checker board tests only */
     tv_ptr->small_ds_offset = PAR_SS_DR_MAX_RANK - tv_ptr->small_rank;
 
-    HDassert(0 < tv_ptr->small_ds_offset);
-    HDassert(tv_ptr->small_ds_offset < PAR_SS_DR_MAX_RANK);
+    assert(0 < tv_ptr->small_ds_offset);
+    assert(tv_ptr->small_ds_offset < PAR_SS_DR_MAX_RANK);
 
     for (i = 0; i < tv_ptr->large_rank - 1; i++) {
 
@@ -198,8 +198,8 @@ hs_dr_pio_test__setup(const int test_num, const int edge_size, const int checker
     /* used by checker board tests only */
     tv_ptr->large_ds_offset = PAR_SS_DR_MAX_RANK - tv_ptr->large_rank;
 
-    HDassert(0 <= tv_ptr->large_ds_offset);
-    HDassert(tv_ptr->large_ds_offset < PAR_SS_DR_MAX_RANK);
+    assert(0 <= tv_ptr->large_ds_offset);
+    assert(tv_ptr->large_ds_offset < PAR_SS_DR_MAX_RANK);
 
     /* set up the start, stride, count, and block pointers */
     /* used by contiguous tests only */
@@ -252,7 +252,7 @@ hs_dr_pio_test__setup(const int test_num, const int edge_size, const int checker
     HDmemset(tv_ptr->large_ds_slice_buf, 0, sizeof(uint32_t) * tv_ptr->large_ds_slice_size);
 
     filename = filenames[0]; /* (const char *)GetTestParameters(); */
-    HDassert(filename != NULL);
+    assert(filename != NULL);
 #if CONTIG_HS_DR_PIO_TEST__SETUP__DEBUG
     if (MAINPROCESS) {
 
@@ -1088,8 +1088,8 @@ contig_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                                  (k * tv_ptr->edge_size * tv_ptr->edge_size) + (l * tv_ptr->edge_size));
                     stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
 
-                    HDassert(start_index < stop_index);
-                    HDassert(stop_index <= tv_ptr->large_ds_size);
+                    assert(start_index < stop_index);
+                    assert(stop_index <= tv_ptr->large_ds_size);
 
                     for (n = 0; n < tv_ptr->large_ds_size; n++) {
 
@@ -1364,8 +1364,8 @@ contig_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
                     start_index = (size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size;
                     stop_index  = start_index + tv_ptr->small_ds_slice_size - 1;
 
-                    HDassert(start_index < stop_index);
-                    HDassert(stop_index <= tv_ptr->small_ds_size);
+                    assert(start_index < stop_index);
+                    assert(stop_index <= tv_ptr->small_ds_size);
 
                     for (n = 0; n < tv_ptr->small_ds_size; n++) {
 
@@ -1653,8 +1653,8 @@ contig_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                                  (k * tv_ptr->edge_size * tv_ptr->edge_size) + (l * tv_ptr->edge_size));
                     stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
 
-                    HDassert(start_index < stop_index);
-                    HDassert(stop_index < tv_ptr->large_ds_size);
+                    assert(start_index < stop_index);
+                    assert(stop_index < tv_ptr->large_ds_size);
 
                     for (n = 0; n < tv_ptr->large_ds_size; n++) {
 
@@ -2076,20 +2076,20 @@ ckrbrd_hs_dr_pio_test__slct_ckrbrd(const int mpi_rank, const hid_t tgt_sid, cons
     hsize_t block[PAR_SS_DR_MAX_RANK];
     herr_t  ret; /* Generic return value */
 
-    HDassert(edge_size >= 6);
-    HDassert(0 < checker_edge_size);
-    HDassert(checker_edge_size <= edge_size);
-    HDassert(0 < sel_rank);
-    HDassert(sel_rank <= tgt_rank);
-    HDassert(tgt_rank <= test_max_rank);
-    HDassert(test_max_rank <= PAR_SS_DR_MAX_RANK);
+    assert(edge_size >= 6);
+    assert(0 < checker_edge_size);
+    assert(checker_edge_size <= edge_size);
+    assert(0 < sel_rank);
+    assert(sel_rank <= tgt_rank);
+    assert(tgt_rank <= test_max_rank);
+    assert(test_max_rank <= PAR_SS_DR_MAX_RANK);
 
     sel_offset = test_max_rank - sel_rank;
-    HDassert(sel_offset >= 0);
+    assert(sel_offset >= 0);
 
     n_cube_offset = test_max_rank - tgt_rank;
-    HDassert(n_cube_offset >= 0);
-    HDassert(n_cube_offset <= sel_offset);
+    assert(n_cube_offset >= 0);
+    assert(n_cube_offset <= sel_offset);
 
 #if CKRBRD_HS_DR_PIO_TEST__SELECT_CHECKER_BOARD__DEBUG
     HDfprintf(stdout, "%s:%d: edge_size/checker_edge_size = %d/%d\n", fcnName, mpi_rank, edge_size,
@@ -2407,13 +2407,13 @@ ckrbrd_hs_dr_pio_test__verify_data(uint32_t *buf_ptr, const int rank, const int
     int       v, w, x, y, z;     /* to track position in checker */
     const int test_max_rank = 5; /* code changes needed if this is increased */
 
-    HDassert(buf_ptr != NULL);
-    HDassert(0 < rank);
-    HDassert(rank <= test_max_rank);
-    HDassert(edge_size >= 6);
-    HDassert(0 < checker_edge_size);
-    HDassert(checker_edge_size <= edge_size);
-    HDassert(test_max_rank <= PAR_SS_DR_MAX_RANK);
+    assert(buf_ptr != NULL);
+    assert(0 < rank);
+    assert(rank <= test_max_rank);
+    assert(edge_size >= 6);
+    assert(0 < checker_edge_size);
+    assert(checker_edge_size <= edge_size);
+    assert(test_max_rank <= PAR_SS_DR_MAX_RANK);
 
 #if CKRBRD_HS_DR_PIO_TEST__VERIFY_DATA__DEBUG
 
@@ -2702,11 +2702,11 @@ ckrbrd_hs_dr_pio_test__d2m_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
                     tv_ptr->start[3] = (hsize_t)l;
                     tv_ptr->start[4] = 0;
 
-                    HDassert((tv_ptr->start[0] == 0) || (0 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[1] == 0) || (1 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[2] == 0) || (2 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[3] == 0) || (3 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[4] == 0) || (4 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[0] == 0) || (0 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[1] == 0) || (1 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[2] == 0) || (2 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[3] == 0) || (3 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[4] == 0) || (4 < tv_ptr->small_ds_offset + 1));
 
                     ckrbrd_hs_dr_pio_test__slct_ckrbrd(
                         tv_ptr->mpi_rank, tv_ptr->file_large_ds_sid_0, tv_ptr->large_rank, tv_ptr->edge_size,
@@ -2926,11 +2926,11 @@ ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                     tv_ptr->start[3] = (hsize_t)l;
                     tv_ptr->start[4] = 0;
 
-                    HDassert((tv_ptr->start[0] == 0) || (0 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[1] == 0) || (1 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[2] == 0) || (2 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[3] == 0) || (3 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[4] == 0) || (4 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[0] == 0) || (0 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[1] == 0) || (1 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[2] == 0) || (2 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[3] == 0) || (3 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[4] == 0) || (4 < tv_ptr->small_ds_offset + 1));
 
                     ckrbrd_hs_dr_pio_test__slct_ckrbrd(
                         tv_ptr->mpi_rank, tv_ptr->mem_large_ds_sid, tv_ptr->large_rank, tv_ptr->edge_size,
@@ -2991,8 +2991,8 @@ ckrbrd_hs_dr_pio_test__d2m_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                     }
 #endif /* CHECKER_BOARD_HS_DR_PIO_TEST__D2M_S2L__DEBUG */
 
-                    HDassert(start_index < stop_index);
-                    HDassert(stop_index <= tv_ptr->large_ds_size);
+                    assert(start_index < stop_index);
+                    assert(stop_index <= tv_ptr->large_ds_size);
 
                     for (u = 0; u < start_index; u++) {
 
@@ -3248,11 +3248,11 @@ ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
                     tv_ptr->start[3] = (hsize_t)l;
                     tv_ptr->start[4] = 0;
 
-                    HDassert((tv_ptr->start[0] == 0) || (0 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[1] == 0) || (1 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[2] == 0) || (2 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[3] == 0) || (3 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[4] == 0) || (4 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[0] == 0) || (0 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[1] == 0) || (1 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[2] == 0) || (2 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[3] == 0) || (3 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[4] == 0) || (4 < tv_ptr->small_ds_offset + 1));
 
                     ckrbrd_hs_dr_pio_test__slct_ckrbrd(
                         tv_ptr->mpi_rank, tv_ptr->mem_large_ds_sid, tv_ptr->large_rank, tv_ptr->edge_size,
@@ -3298,8 +3298,8 @@ ckrbrd_hs_dr_pio_test__m2d_l2s(struct hs_dr_pio_test_vars_t *tv_ptr)
                     start_index = (size_t)(tv_ptr->mpi_rank) * tv_ptr->small_ds_slice_size;
                     stop_index  = start_index + tv_ptr->small_ds_slice_size - 1;
 
-                    HDassert(start_index < stop_index);
-                    HDassert(stop_index <= tv_ptr->small_ds_size);
+                    assert(start_index < stop_index);
+                    assert(stop_index <= tv_ptr->small_ds_size);
 
                     data_ok = TRUE;
 
@@ -3541,11 +3541,11 @@ ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                     tv_ptr->start[3] = (hsize_t)l;
                     tv_ptr->start[4] = 0;
 
-                    HDassert((tv_ptr->start[0] == 0) || (0 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[1] == 0) || (1 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[2] == 0) || (2 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[3] == 0) || (3 < tv_ptr->small_ds_offset + 1));
-                    HDassert((tv_ptr->start[4] == 0) || (4 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[0] == 0) || (0 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[1] == 0) || (1 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[2] == 0) || (2 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[3] == 0) || (3 < tv_ptr->small_ds_offset + 1));
+                    assert((tv_ptr->start[4] == 0) || (4 < tv_ptr->small_ds_offset + 1));
 
                     ckrbrd_hs_dr_pio_test__slct_ckrbrd(
                         tv_ptr->mpi_rank, tv_ptr->file_large_ds_sid_1, tv_ptr->large_rank, tv_ptr->edge_size,
@@ -3594,8 +3594,8 @@ ckrbrd_hs_dr_pio_test__m2d_s2l(struct hs_dr_pio_test_vars_t *tv_ptr)
                                  (k * tv_ptr->edge_size * tv_ptr->edge_size) + (l * tv_ptr->edge_size));
                     stop_index = start_index + tv_ptr->small_ds_slice_size - 1;
 
-                    HDassert(start_index < stop_index);
-                    HDassert(stop_index < tv_ptr->large_ds_size);
+                    assert(start_index < stop_index);
+                    assert(stop_index < tv_ptr->large_ds_size);
 
                     data_ok = TRUE;
 

testpar/API/t_span_tree.c

@@ -1038,21 +1038,21 @@ lower_dim_size_comp_test__select_checker_board(const int mpi_rank, const hid_t t
     }
 #endif /* LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG */
 
-    HDassert(0 < checker_edge_size);
-    HDassert(0 < sel_rank);
-    HDassert(sel_rank <= tgt_rank);
-    HDassert(tgt_rank <= test_max_rank);
-    HDassert(test_max_rank <= LDSCT_DS_RANK);
+    assert(0 < checker_edge_size);
+    assert(0 < sel_rank);
+    assert(sel_rank <= tgt_rank);
+    assert(tgt_rank <= test_max_rank);
+    assert(test_max_rank <= LDSCT_DS_RANK);
 
     sel_offset = test_max_rank - sel_rank;
-    HDassert(sel_offset >= 0);
+    assert(sel_offset >= 0);
 
     ds_offset = test_max_rank - tgt_rank;
-    HDassert(ds_offset >= 0);
-    HDassert(ds_offset <= sel_offset);
+    assert(ds_offset >= 0);
+    assert(ds_offset <= sel_offset);
 
-    HDassert((hsize_t)checker_edge_size <= dims[sel_offset]);
-    HDassert(dims[sel_offset] == 10);
+    assert((hsize_t)checker_edge_size <= dims[sel_offset]);
+    assert(dims[sel_offset] == 10);
 
 #if LOWER_DIM_SIZE_COMP_TEST__SELECT_CHECKER_BOARD__DEBUG
     if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
@@ -1389,13 +1389,13 @@ lower_dim_size_comp_test__verify_data(uint32_t *buf_ptr,
     int       v, w, x, y, z;     /* to track position in checker */
     const int test_max_rank = 5; /* code changes needed if this is increased */
 
-    HDassert(buf_ptr != NULL);
-    HDassert(0 < rank);
-    HDassert(rank <= test_max_rank);
-    HDassert(edge_size >= 6);
-    HDassert(0 < checker_edge_size);
-    HDassert(checker_edge_size <= edge_size);
-    HDassert(test_max_rank <= LDSCT_DS_RANK);
+    assert(buf_ptr != NULL);
+    assert(0 < rank);
+    assert(rank <= test_max_rank);
+    assert(edge_size >= 6);
+    assert(0 < checker_edge_size);
+    assert(checker_edge_size <= edge_size);
+    assert(test_max_rank <= LDSCT_DS_RANK);
 
 #if LOWER_DIM_SIZE_COMP_TEST__VERIFY_DATA__DEBUG
     if (mpi_rank == LOWER_DIM_SIZE_COMP_TEST_DEBUG_TARGET_RANK) {
@@ -1598,7 +1598,7 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size, const hbool_t use_
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
 
-    HDassert(mpi_size >= 1);
+    assert(mpi_size >= 1);
 
     mpi_comm = MPI_COMM_WORLD;
     mpi_info = MPI_INFO_NULL;
@@ -1667,7 +1667,7 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size, const hbool_t use_
     /* get the file name */
 
     filename = (const char *)PARATESTFILE /* GetTestParameters() */;
-    HDassert(filename != NULL);
+    assert(filename != NULL);
 
     /* ----------------------------------------
      * CREATE AN HDF5 FILE WITH PARALLEL ACCESS
@@ -2160,9 +2160,9 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size, const hbool_t use_
 
     stop_index = start_index + (int)small_ds_slice_size;
 
-    HDassert(0 <= start_index);
-    HDassert(start_index < stop_index);
-    HDassert(stop_index <= (int)large_ds_size);
+    assert(0 <= start_index);
+    assert(start_index < stop_index);
+    assert(stop_index <= (int)large_ds_size);
 
     ptr_1 = large_ds_buf_1;
 
@@ -2260,9 +2260,9 @@ lower_dim_size_comp_test__run_test(const int chunk_edge_size, const hbool_t use_
 
     stop_index = start_index + (int)small_ds_slice_size;
 
-    HDassert(0 <= start_index);
-    HDassert(start_index < stop_index);
-    HDassert(stop_index <= (int)small_ds_size);
+    assert(0 <= start_index);
+    assert(start_index < stop_index);
+    assert(stop_index <= (int)small_ds_size);
 
     ptr_1 = small_ds_buf_1;
 
@@ -2490,11 +2490,11 @@ link_chunk_collective_io_test(void)
         return;
     }
 
-    HDassert(mpi_size > 0);
+    assert(mpi_size > 0);
 
     /* get the file name */
     filename = (const char *)PARATESTFILE /* GetTestParameters() */;
-    HDassert(filename != NULL);
+    assert(filename != NULL);
 
     /* setup file access template */
     acc_tpl = create_faccess_plist(mpi_comm, mpi_info, facc_type);