Normalization with vol_integration (test code and H5Xtest.c)

1 files changed, 161 insertions, 167 deletions

diff --git a/test/farray.c b/test/farray.c
index 383cb32..21d3186 100644
--- a/test/farray.c
+++ b/test/farray.c
@@ -25,9 +25,9 @@
 #include "H5FApkg.h"		/* Fixed Arrays			*/
 
 /* Other private headers that this test requires */
-#include "H5CXprivate.h"        /* API Contexts                         */
-#include "H5Iprivate.h"		/* IDs			  		*/
-#include "H5VMprivate.h"	/* Vectors and arrays 			*/
+#include "H5CXprivate.h"        /* API Contexts                             */
+#include "H5Iprivate.h"         /* IDs                                      */
+#include "H5VMprivate.h"        /* Vectors and arrays                       */
 
 
 /* Local macros */
@@ -113,74 +113,71 @@ h5_stat_size_t empty_size_g;
 
 
 /*-------------------------------------------------------------------------
- * Function:	init_cparam
+ * Function:    init_cparam
  *
- * Purpose:	Initialize array creation parameter structure
+ * Purpose:     Initialize array creation parameter structure
  *
- * Return:	Success:	0
- *		Failure:	-1
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
-static int
+static herr_t
 init_cparam(H5FA_create_t *cparam, farray_test_param_t *tparam)
 {
     /* Wipe out background */
     HDmemset(cparam, 0, sizeof(*cparam));
 
-    cparam->cls = H5FA_CLS_TEST;
-    cparam->raw_elmt_size = ELMT_SIZE;
-    cparam->max_dblk_page_nelmts_bits = MAX_DBLOCK_PAGE_NELMTS_BITS;
-    cparam->nelmts = tparam->nelmts;
+    cparam->cls                         = H5FA_CLS_TEST;
+    cparam->raw_elmt_size               = ELMT_SIZE;
+    cparam->max_dblk_page_nelmts_bits   = MAX_DBLOCK_PAGE_NELMTS_BITS;
+    cparam->nelmts                      = tparam->nelmts;
 
-    return(0);
+    return SUCCEED;
 } /* init_cparam() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	create_file
+ * Function:    create_file
  *
- * Purpose:	Create file and retrieve pointer to internal file object
- *
- * Return:	Success:	0
- *		Failure:	-1
+ * Purpose:     Create file and retrieve pointer to internal file object
  *
+ * Return:      SUCCEED/FAIL
+ *   
  *-------------------------------------------------------------------------
  */
-static int
-create_file(hid_t fapl, hid_t *file, H5F_t **f)
+static herr_t
+create_file(hid_t fapl_id, hid_t *fid, H5F_t **f)
 {
     /* Create the file to work on */
-    if((*file = H5Fcreate(filename_g, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
+    if((*fid = H5Fcreate(filename_g, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id)) < 0)
         FAIL_STACK_ERROR
 
     /* Get a pointer to the internal file object */
-    if(NULL == (*f = (H5F_t *)H5I_object(*file)))
-        FAIL_STACK_ERROR
+    if(NULL == (*f = (H5F_t *)H5I_object(*fid)))
+        FAIL_STACK_ERROR;
 
     /* Ignore metadata tags in the file's cache */
     if(H5AC_ignore_tags(*f) < 0)
-        FAIL_STACK_ERROR
+        FAIL_STACK_ERROR;
 
     /* Success */
-    return(0);
+    return SUCCEED;
 
 error:
-    return(-1);
+    return FAIL;
 } /* create_file() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	check_stats
+ * Function:    check_stats
  *
- * Purpose:	Verify stats for a fixed array
+ * Purpose:     Verify stats for a fixed array
  *
- * Return:	Success:	0
- *		Failure:	-1
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
-static int
+static herr_t
 check_stats(const H5FA_t *fa, const farray_state_t *state)
 {
     H5FA_stat_t farray_stats;           /* Statistics about the array */
@@ -194,40 +191,38 @@ check_stats(const H5FA_t *fa, const farray_state_t *state)
         HDfprintf(stdout, "farray_stats.hdr_size = %Hu, state->hdr_size = %Hu\n",
 	    farray_stats.hdr_size, state->hdr_size);
         TEST_ERROR
-    } /* end if */
+    }
 
     if(farray_stats.dblk_size != state->dblk_size) {
         HDfprintf(stdout, "farray_stats.dblk_size = %Hu, state->dblk_size = %Hu\n",
 	    farray_stats.dblk_size, state->dblk_size);
         TEST_ERROR
-    } /* end if */
+    }
 
     if(farray_stats.nelmts != state->nelmts) {
         HDfprintf(stdout, "farray_stats.nelmts = %Hu, state->nelmts = %Hu\n",
 	    farray_stats.nelmts, state->nelmts);
         TEST_ERROR
-    } /* end if */
+    }
 
-    /* All tests passed */
-    return(0);
+    /* Success */
+    return SUCCEED;
 
 error:
-    return(-1);
+    return FAIL;
 } /* check_stats() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	set_fa_state
+ * Function:    set_fa_state
  *
- * Purpose:	Set the state of the Fixed Array
+ * Purpose:     Set the state of the Fixed Array
  *
- * Return:	does not fail
- *
- * Programmer:	Vailin Choi; 5th August, 2009
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
-static int
+static herr_t
 set_fa_state(const H5FA_create_t *cparam, farray_state_t *state)
 {
     size_t dblk_page_nelmts;			/* # of elements per page */
@@ -242,57 +237,58 @@ set_fa_state(const H5FA_create_t *cparam, farray_state_t *state)
 
     dblk_page_nelmts = (size_t)1 << cparam->max_dblk_page_nelmts_bits;
     if(state->nelmts > dblk_page_nelmts) {
-	size_t npages = (size_t)(((state->nelmts + dblk_page_nelmts) - 1) / dblk_page_nelmts);
-	size_t dblk_page_init_size = (npages + 7) / 8;
-	hsize_t checksum_size = npages * 4;
+        size_t npages = (size_t)(((state->nelmts + dblk_page_nelmts) - 1) / dblk_page_nelmts);
+        size_t dblk_page_init_size = (npages + 7) / 8;
+        hsize_t checksum_size = npages * 4;
 
-	state->dblk_size = DBLOCK_PREFIX + dblk_page_init_size + checksum_size +
+        state->dblk_size = DBLOCK_PREFIX + dblk_page_init_size + checksum_size +
 			    state->nelmts * cparam->raw_elmt_size;
-    } else
-	state->dblk_size = DBLOCK_PREFIX + state->nelmts * cparam->raw_elmt_size;
+    }
+    else
+        state->dblk_size = DBLOCK_PREFIX + state->nelmts * cparam->raw_elmt_size;
 
-    return(0);
+    return SUCCEED;
 } /* end set_fa_state() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	reopen_file
+ * Function:    reopen_file
  *
- * Purpose:	Perform common "re-open" operations on file & array for testing
+ * Purpose:     Perform common "re-open" operations on file & array for testing
  *
- * Return:	Success:	0
- *		Failure:	-1
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
 static int
-reopen_file(hid_t *file, H5F_t **f, hid_t fapl, 
+reopen_file(hid_t *fid, H5F_t **f, hid_t fapl_id, 
     H5FA_t **fa, haddr_t fa_addr, const farray_test_param_t *tparam)
 {
     /* Check for closing & re-opening the array */
     /* (actually will close & re-open the file as well) */
     if(tparam->reopen_array) {
+
         /* Close array, if given */
         if(fa && *fa) {
             if(H5FA_close(*fa) < 0)
                 FAIL_STACK_ERROR
             *fa = NULL;
-        } /* end if */
+        }
 
         /* Close file */
-        if(*file) {
-            if(H5Fclose(*file) < 0)
+        if(*fid) {
+            if(H5Fclose(*fid) < 0)
                 FAIL_STACK_ERROR
-            *file = (-1);
+            *fid = H5I_INVALID_HID;
             *f = NULL;
-        } /* end if */
+        }
 
         /* Re-open the file */
-        if((*file = H5Fopen(filename_g, H5F_ACC_RDWR, fapl)) < 0)
+        if((*fid = H5Fopen(filename_g, H5F_ACC_RDWR, fapl_id)) < 0)
             FAIL_STACK_ERROR
 
         /* Get a pointer to the internal file object */
-        if(NULL == (*f = (H5F_t *)H5I_object(*file)))
+        if(NULL == (*f = (H5F_t *)H5I_object(*fid)))
             FAIL_STACK_ERROR
 
         /* Ignore metadata tags in the file's cache */
@@ -303,27 +299,26 @@ reopen_file(hid_t *file, H5F_t **f, hid_t fapl,
         if(fa)
             if(NULL == (*fa = H5FA_open(*f, fa_addr, NULL)))
                 FAIL_STACK_ERROR
-    } /* end if */
+    }
 
     /* Success */
-    return(0);
+    return SUCCEED;
 
 error:
-    return(-1);
+    return FAIL;
 } /* reopen_file() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	create_array
+ * Function:    create_array
  *
- * Purpose:	Create a fixed array and perform initial checks
+ * Purpose:     Create a fixed array and perform initial checks
  *
- * Return:	Success:	0
- *		Failure:	-1
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
-static int
+static herr_t
 create_array(H5F_t *f, const H5FA_create_t *cparam,
     H5FA_t **fa, haddr_t *fa_addr)
 {
@@ -338,65 +333,65 @@ create_array(H5F_t *f, const H5FA_create_t *cparam,
         FAIL_STACK_ERROR
     if(!H5F_addr_defined(*fa_addr))
         TEST_ERROR
+
+    /* Check array stats */
     HDmemset(&state, 0, sizeof(state));
-    state.hdr_size = FA_HDR_SIZE;
-    state.nelmts = cparam->nelmts;
+    state.hdr_size  = FA_HDR_SIZE;
+    state.nelmts    = cparam->nelmts;
     if(check_stats(*fa, &state))
         TEST_ERROR
 
     /* Success */
-    return(0);
+    return SUCCEED;
 
 error:
-    return(-1);
+    return FAIL;
 } /* create_array() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	verify_cparam
+ * Function:    verify_cparam
  *
- * Purpose:	Verify creation parameters are correct
+ * Purpose:     Verify creation parameters are correct
  *
- * Return:	Success:	0
- *		Failure:	-1
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
-static int
+static herr_t
 verify_cparam(const H5FA_t *fa, const H5FA_create_t *cparam)
 {
     H5FA_create_t test_cparam;          /* Creation parameters for array */
 
     /* Retrieve creation parameters */
     HDmemset(&test_cparam, 0, sizeof(H5FA_create_t));
-    if(H5FA_get_cparam_test(fa, &test_cparam) < 0)
+    if(H5FA__get_cparam_test(fa, &test_cparam) < 0)
         FAIL_STACK_ERROR
 
     /* Verify creation parameters */
-    if(H5FA_cmp_cparam_test(cparam, &test_cparam))
+    if(H5FA__cmp_cparam_test(cparam, &test_cparam))
         TEST_ERROR
 
     /* Success */
-    return(0);
+    return SUCCEED;
 
 error:
-    return(-1);
+    return FAIL;
 } /* verify_cparam() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	finish
+ * Function:    finish
  *
- * Purpose:	Close array, delete array, close file and verify that file
+ * Purpose:     Close array, delete array, close file and verify that file
  *              is empty size
  *
- * Return:	Success:	0
- *		Failure:	-1
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
-static int
-finish(hid_t file, hid_t fapl, H5F_t *f, H5FA_t *fa, haddr_t fa_addr)
+static herr_t
+finish(hid_t fid, hid_t fapl_id, H5F_t *f, H5FA_t *fa, haddr_t fa_addr)
 {
     h5_stat_size_t file_size;           /* File size, after deleting array */
 
@@ -409,11 +404,11 @@ finish(hid_t file, hid_t fapl, H5F_t *f, H5FA_t *fa, haddr_t fa_addr)
         FAIL_STACK_ERROR
 
     /* Close the file */
-    if(H5Fclose(file) < 0)
+    if(H5Fclose(fid) < 0)
         FAIL_STACK_ERROR
 
     /* Get the size of the file */
-    if((file_size = h5_get_file_size(filename_g, fapl)) < 0)
+    if((file_size = h5_get_file_size(filename_g, fapl_id)) < 0)
         TEST_ERROR
 
     /* Verify the file is correct size */
@@ -421,10 +416,10 @@ finish(hid_t file, hid_t fapl, H5F_t *f, H5FA_t *fa, haddr_t fa_addr)
         TEST_ERROR
 
     /* Success */
-    return(0);
+    return SUCCEED;
 
 error:
-    return(-1);
+    return FAIL;
 } /* finish() */
 
 
@@ -627,23 +622,21 @@ error:
  *-------------------------------------------------------------------------
  */
 static unsigned
-test_open_twice(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t *tparam)
+test_open_twice(hid_t fapl_id, H5FA_create_t *cparam, farray_test_param_t *tparam)
 {
-    hid_t	file = -1;              /* File ID */
-    hid_t	file2 = -1;             /* File ID */
-    H5F_t	*f = NULL;              /* Internal file object pointer */
-    H5F_t	*f2 = NULL;             /* Internal file object pointer */
-    H5FA_t      *fa = NULL;             /* Fixed array wrapper */
-    H5FA_t      *fa2 = NULL;            /* Fixed array wrapper */
-    haddr_t     fa_addr = HADDR_UNDEF;  /* Array address in file */
+    hid_t           fid     = H5I_INVALID_HID;  /* File ID                      */
+    hid_t           fid2    = H5I_INVALID_HID;  /* File ID                      */
+    H5F_t          *f       = NULL;             /* Internal file object pointer */
+    H5F_t          *f2      = NULL;             /* Internal file object pointer */
+    H5FA_t         *fa      = NULL;             /* Fixed array wrapper          */
+    H5FA_t         *fa2     = NULL;             /* Fixed array wrapper          */
+    haddr_t         fa_addr = HADDR_UNDEF;      /* Array address in file        */
 
     /* Create file & retrieve pointer to internal file object */
-    if(create_file(fapl, &file, &f) < 0)
+    if(create_file(fapl_id, &fid, &f) < 0)
         TEST_ERROR
 
-    /*
-     * Display testing message
-     */
+    /* Display testing message */
     TESTING("open fixed array twice");
 
     /* Create array */
@@ -666,15 +659,15 @@ test_open_twice(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t *tparam)
     fa2 = NULL;
 
     /* Check for closing & re-opening the file */
-    if(reopen_file(&file, &f, fapl, &fa, fa_addr, tparam) < 0)
+    if(reopen_file(&fid, &f, fapl_id, &fa, fa_addr, tparam) < 0)
         TEST_ERROR
 
     /* Re-open the file */
-    if((file2 = H5Freopen(file)) < 0)
+    if((fid2 = H5Freopen(fid)) < 0)
         FAIL_STACK_ERROR
 
     /* Get a pointer to the internal file object */
-    if(NULL == (f2 = (H5F_t *)H5I_object(file2)))
+    if(NULL == (f2 = (H5F_t *)H5I_object(fid2)))
         FAIL_STACK_ERROR
 
     /* Open the fixed array through the second file handle */
@@ -694,11 +687,11 @@ test_open_twice(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t *tparam)
     /* (close before second file, to detect error on internal array header's
      *  shared file information)
      */
-    if(H5Fclose(file) < 0)
+    if(H5Fclose(fid) < 0)
         FAIL_STACK_ERROR
 
     /* Close array, delete array, close file & verify file is empty */
-    if(finish(file2, fapl, f2, fa2, fa_addr) < 0)
+    if(finish(fid2, fapl_id, f2, fa2, fa_addr) < 0)
         TEST_ERROR
 
     /* All tests passed */
@@ -712,8 +705,8 @@ error:
             H5FA_close(fa);
         if(fa2)
             H5FA_close(fa2);
-	H5Fclose(file);
-	H5Fclose(file2);
+        H5Fclose(fid);
+        H5Fclose(fid2);
     } H5E_END_TRY;
 
     return 1;
@@ -736,26 +729,24 @@ error:
  *-------------------------------------------------------------------------
  */
 static unsigned
-test_open_twice_diff(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t *tparam)
+test_open_twice_diff(hid_t fapl_id, H5FA_create_t *cparam, farray_test_param_t *tparam)
 {
-    char        filename_tmp[FARRAY_FILENAME_LEN];      /* Temporary file name */
-    hid_t	file = -1;              /* File ID */
-    hid_t	file2 = -1;             /* File ID */
-    hid_t	file0 = -1;             /* File ID */
-    hid_t	file00 = -1;            /* File ID */
-    H5F_t	*f = NULL;              /* Internal file object pointer */
-    H5F_t	*f2 = NULL;             /* Internal file object pointer */
-    H5FA_t      *fa = NULL;             /* Fixed array wrapper */
-    H5FA_t      *fa2 = NULL;            /* Fixed array wrapper */
-    haddr_t     fa_addr = HADDR_UNDEF;  /* Array address in file */
-
-    /*
-     * Display testing message
-     */
+    char filename_tmp[FARRAY_FILENAME_LEN];     /* Temporary file name          */
+    hid_t           fid     = H5I_INVALID_HID;  /* File ID                      */
+    hid_t           fid2    = H5I_INVALID_HID;  /* File ID                      */
+    hid_t           fid0    = H5I_INVALID_HID;  /* File ID                      */
+    hid_t           fid00   = H5I_INVALID_HID;  /* File ID                      */
+    H5F_t          *f       = NULL;             /* Internal file object pointer */
+    H5F_t          *f2      = NULL;             /* Internal file object pointer */
+    H5FA_t         *fa      = NULL;             /* Fixed array wrapper          */
+    H5FA_t         *fa2     = NULL;             /* Fixed array wrapper          */
+    haddr_t         fa_addr = HADDR_UNDEF;      /* Array address in file        */
+
+    /* Display testing message */
     TESTING("open fixed array twice, through different file handles");
 
     /* Create file & retrieve pointer to internal file object */
-    if(create_file(fapl, &file, &f) < 0)
+    if(create_file(fapl_id, &fid, &f) < 0)
         TEST_ERROR
 
     /* Create array */
@@ -781,11 +772,11 @@ test_open_twice_diff(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t *tpa
     /* (So that there is something holding the file open when the extensible
      *  array is closed)
      */
-    if((file0 = H5Fopen(filename_g, H5F_ACC_RDWR, fapl)) < 0)
+    if((fid0 = H5Fopen(filename_g, H5F_ACC_RDWR, fapl_id)) < 0)
         FAIL_STACK_ERROR
 
     /* Check for closing & re-opening the file */
-    if(reopen_file(&file, &f, fapl, &fa, fa_addr, tparam) < 0)
+    if(reopen_file(&fid, &f, fapl_id, &fa, fa_addr, tparam) < 0)
         TEST_ERROR
 
     /* Close the first fixed array wrapper */
@@ -797,26 +788,25 @@ test_open_twice_diff(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t *tpa
     /* (close before second file, to detect error on internal array header's
      *  shared file information)
      */
-    if(H5Fclose(file) < 0)
+    if(H5Fclose(fid) < 0)
         FAIL_STACK_ERROR
-    file = -1;
+    fid = H5I_INVALID_HID;
 
     /* Open a different file */
     /* (This re-allocates the 'top' file pointer and assigns it a different
      *  'shared' file pointer, making the file pointer in the fixed array's
      *  header stale)
      */
-    h5_fixname(FILENAME[1], fapl, filename_tmp, sizeof(filename_tmp));
-    if((file00 = H5Fcreate(filename_tmp, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
+    h5_fixname(FILENAME[1], fapl_id, filename_tmp, sizeof(filename_tmp));
+    if((fid00 = H5Fcreate(filename_tmp, H5F_ACC_TRUNC, H5P_DEFAULT, fapl_id)) < 0)
         FAIL_STACK_ERROR
 
-
     /* Re-open the file with the fixed array */
-    if((file2 = H5Fopen(filename_g, H5F_ACC_RDWR, fapl)) < 0)
+    if((fid2 = H5Fopen(filename_g, H5F_ACC_RDWR, fapl_id)) < 0)
         FAIL_STACK_ERROR
 
     /* Get a pointer to the internal file object */
-    if(NULL == (f2 = (H5F_t *)H5I_object(file2)))
+    if(NULL == (f2 = (H5F_t *)H5I_object(fid2)))
         FAIL_STACK_ERROR
 
     /* Open the fixed array through the second file handle */
@@ -828,13 +818,13 @@ test_open_twice_diff(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t *tpa
         TEST_ERROR
 
     /* Close the extra file handles */
-    if(H5Fclose(file0) < 0)
+    if(H5Fclose(fid0) < 0)
         FAIL_STACK_ERROR
-    if(H5Fclose(file00) < 0)
+    if(H5Fclose(fid00) < 0)
         FAIL_STACK_ERROR
 
     /* Close array, delete array, close file & verify file is empty */
-    if(finish(file2, fapl, f2, fa2, fa_addr) < 0)
+    if(finish(fid2, fapl_id, f2, fa2, fa_addr) < 0)
         TEST_ERROR
 
     /* All tests passed */
@@ -848,10 +838,10 @@ error:
             H5FA_close(fa);
         if(fa2)
             H5FA_close(fa2);
-	H5Fclose(file);
-	H5Fclose(file2);
-	H5Fclose(file0);
-	H5Fclose(file00);
+        H5Fclose(fid);
+        H5Fclose(fid2);
+        H5Fclose(fid0);
+        H5Fclose(fid00);
     } H5E_END_TRY;
 
     return 1;
@@ -966,7 +956,7 @@ error:
             H5FA_close(fa);
         if(fa2)
             H5FA_close(fa2);
-	H5Fclose(file);
+        H5Fclose(file);
     } H5E_END_TRY;
 
     return 1;
@@ -1666,7 +1656,7 @@ main(void)
     fapl = h5_fileaccess();
     ExpressMode = GetTestExpress();
     if(ExpressMode > 1)
-	printf("***Express test mode on.  Some tests may be skipped\n");
+        HDprintf("***Express test mode on.  Some tests may be skipped\n");
 
     /* Set the filename to use for this test (dependent on fapl) */
     h5_fixname(FILENAME[0], fapl, filename_g, sizeof(filename_g));
@@ -1706,12 +1696,12 @@ main(void)
         switch(curr_test) {
             /* "Normal" testing parameters */
             case FARRAY_TEST_NORMAL:
-                puts("Testing with NORMAL PARAMETERS");
+                HDputs("Testing with NORMAL PARAMETERS");
                 break;
 
             /* "Re-open array" testing parameters */
             case FARRAY_TEST_REOPEN:
-                puts("Testing with reopen array flag set");
+                HDputs("Testing with reopen array flag set");
                 tparam.reopen_array = FARRAY_TEST_REOPEN;
                 break;
 
@@ -1738,25 +1728,25 @@ main(void)
             switch(curr_iter) {
                 /* "Forward" testing parameters */
                 case FARRAY_ITER_FW:
-                    puts("Testing with forward iteration");
+                    HDputs("Testing with forward iteration");
                     tparam.fiter = &fa_iter_fw;
                     break;
 
                 /* "Reverse" testing parameters */
                 case FARRAY_ITER_RV:
-                    puts("Testing with reverse iteration");
+                    HDputs("Testing with reverse iteration");
                     tparam.fiter = &fa_iter_rv;
                     break;
 
                 /* "Random" testing parameters */
                 case FARRAY_ITER_RND:
-                    puts("Testing with random iteration");
+                    HDputs("Testing with random iteration");
                     tparam.fiter = &fa_iter_rnd;
                     break;
 
                 /* "Cyclic" testing parameters */
                 case FARRAY_ITER_CYC:
-                    puts("Testing with cyclic iteration");
+                    HDputs("Testing with cyclic iteration");
                     tparam.fiter = &fa_iter_cyc;
                     break;
 
@@ -1772,22 +1762,26 @@ main(void)
             nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)tparam.nelmts, "setting all the array elements");
         } /* end for */
 
-	/* Check skipping elements */
+        /* Check skipping elements */
         nerrors += test_skip_elmts(fapl, &cparam, &tparam, (hsize_t)1, TRUE, "skipping to first element");
         nerrors += test_skip_elmts(fapl, &cparam, &tparam, ((hsize_t)1 << cparam.max_dblk_page_nelmts_bits), TRUE, "skipping to first element in data block page");
         nerrors += test_skip_elmts(fapl, &cparam, &tparam, (hsize_t)(tparam.nelmts - 1), TRUE, "skipping to last element");
 
-	/* Create Fixed Array of MAX_NELMTS elements */
-	/*
-	 * MAX_NELMTS succeeds on jam and smirom.
-	 * The value was adjusted for linew due to the following:
-	    Linew failed with "H5FD_sec2_truncate(): unable to extend file properly"
-	    Linew failed with "H5FD_sec2_truncate(): File too large"
-	 */
+	    /* Create Fixed Array */
+        /* MAX_NELMTS succeeds on some platforms buy may fail on others:
+         *
+         *      "H5FD_sec2_truncate(): unable to extend file properly"
+         *
+         * and
+         *
+         *      "H5FD_sec2_truncate(): File too large"
+         *
+         * have both been seen.
+         */
         tparam.nelmts = MAX_NELMTS/17;
-	init_cparam(&cparam, &tparam);
+        init_cparam(&cparam, &tparam);
 
-	/* Set the last element in the Fixed Array */
+        /* Set the last element in the Fixed Array */
         nerrors += test_skip_elmts(fapl, &cparam, &tparam, (hsize_t)(tparam.nelmts - 1), FALSE, "skipping to last element");
     } /* end for */
 
@@ -1800,22 +1794,22 @@ main(void)
 
     if(nerrors)
         goto error;
-    puts("All fixed array tests passed.");
+    HDputs("All fixed array tests passed.");
 
     /* Clean up file used */
     h5_cleanup(FILENAME, fapl);
 
-    return 0;
+    HDexit(EXIT_SUCCESS);
 
 error:
-    puts("*** TESTS FAILED ***");
+    HDputs("*** TESTS FAILED ***");
 
     H5E_BEGIN_TRY {
-	H5Pclose(fapl);
+        H5Pclose(fapl);
     } H5E_END_TRY;
 
     if(api_ctx_pushed) H5CX_pop();
 
-    return 1;
+    HDexit(EXIT_FAILURE);
 } /* end main() */