[svn-r25497] Description:

    Merge changes that correspond to the 64-bit ID changes (without the actual
switch to 64-bit IDs) to the 1.8 release branch.  (Plus a few minor cleanups
and alignments with the trunk that aren't on the branch)

Tested on:
    Mac OSX/64 10.9.4 (amazon) w/C++ & FORTRAN
    (h5committested on branch already for a week)

1 files changed, 195 insertions, 195 deletions

diff --git a/testpar/testphdf5.c b/testpar/testphdf5.c
index 713d6e1..865d381 100644
--- a/testpar/testphdf5.c
+++ b/testpar/testphdf5.c
@@ -28,15 +28,15 @@ int dim0;
 int dim1;
 int chunkdim0;
 int chunkdim1;
-int nerrors = 0;      /* errors count */
-int ndatasets = 300;      /* number of datasets to create*/
+int nerrors = 0;			/* errors count */
+int ndatasets = 300;			/* number of datasets to create*/
 int ngroups = 512;                      /* number of groups to create in root
                                          * group. */
-int facc_type = FACC_MPIO;    /*Test file access type */
+int facc_type = FACC_MPIO;		/*Test file access type */
 int dxfer_coll_type = DXFER_COLLECTIVE_IO;
 
-H5E_auto2_t old_func;            /* previous error handler */
-void *old_client_data;      /* previous error handler arg.*/
+H5E_auto2_t old_func;		        /* previous error handler */
+void *old_client_data;			/* previous error handler arg.*/
 
 /* other option flags */
 
@@ -48,10 +48,10 @@ void *old_client_data;      /* previous error handler arg.*/
 #define NFILENAME 2
 #define PARATESTFILE filenames[0]
 const char *FILENAME[NFILENAME]={
-      "ParaTest",
-      NULL};
-char  filenames[NFILENAME][PATH_MAX];
-hid_t  fapl;        /* file access property list */
+	    "ParaTest",
+	    NULL};
+char	filenames[NFILENAME][PATH_MAX];
+hid_t	fapl;				/* file access property list */
 
 #ifdef USE_PAUSE
 /* pause the process for a moment to allow debugger to attach if desired. */
@@ -64,7 +64,7 @@ void pause_proc(void)
 {
 
     int pid;
-    h5_stat_t  statbuf;
+    h5_stat_t	statbuf;
     char greenlight[] = "go";
     int maxloop = 10;
     int loops = 0;
@@ -82,14 +82,14 @@ void pause_proc(void)
 
     if (MAINPROCESS)
   while ((HDstat(greenlight, &statbuf) == -1) && loops < maxloop){
-      if (!loops++){
-    printf("Proc %d (%*s, %d): to debug, attach %d\n",
-        mpi_rank, mpi_namelen, mpi_name, pid, pid);
-      }
-      printf("waiting(%ds) for file %s ...\n", time_int, greenlight);
-      fflush(stdout);
-      sleep(time_int);
-  }
+	    if (!loops++){
+		printf("Proc %d (%*s, %d): to debug, attach %d\n",
+		    mpi_rank, mpi_namelen, mpi_name, pid, pid);
+	    }
+	    printf("waiting(%ds) for file %s ...\n", time_int, greenlight);
+	    fflush(stdout);
+	    sleep(time_int);
+	}
     MPI_Barrier(MPI_COMM_WORLD);
 }
 
@@ -101,7 +101,7 @@ int MPI_Init(int *argc, char ***argv)
     pause_proc();
     return (ret_code);
 }
-#endif  /* USE_PAUSE */
+#endif	/* USE_PAUSE */
 
 
 /*
@@ -111,15 +111,15 @@ static void
 usage(void)
 {
     printf("    [-r] [-w] [-m<n_datasets>] [-n<n_groups>] "
-  "[-o] [-f <prefix>] [-d <dim0> <dim1>]\n");
+	"[-o] [-f <prefix>] [-d <dim0> <dim1>]\n");
     printf("\t-m<n_datasets>"
-  "\tset number of datasets for the multiple dataset test\n");
+	"\tset number of datasets for the multiple dataset test\n");
     printf("\t-n<n_groups>"
         "\tset number of groups for the multiple group test\n");
     printf("\t-f <prefix>\tfilename prefix\n");
     printf("\t-2\t\tuse Split-file together with MPIO\n");
     printf("\t-d <factor0> <factor1>\tdataset dimensions factors. Defaults (%d,%d)\n",
-  ROW_FACTOR, COL_FACTOR);
+	ROW_FACTOR, COL_FACTOR);
     printf("\t-c <dim0> <dim1>\tdataset chunk dimensions. Defaults (dim0/10,dim1/10)\n");
     printf("\n");
 }
@@ -131,7 +131,7 @@ usage(void)
 static int
 parse_options(int argc, char **argv)
 {
-    int mpi_size, mpi_rank;        /* mpi variables */
+    int mpi_size, mpi_rank;				/* mpi variables */
 
     MPI_Comm_size(MPI_COMM_WORLD, &mpi_size);
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
@@ -142,107 +142,107 @@ parse_options(int argc, char **argv)
     chunkdim1 = (dim1+9)/10;
 
     while (--argc){
-  if (**(++argv) != '-'){
-      break;
-  }else{
-      switch(*(*argv+1)){
-    case 'm':   ndatasets = atoi((*argv+1)+1);
-          if (ndatasets < 0){
-        nerrors++;
-        return(1);
-          }
-          break;
-          case 'n':   ngroups = atoi((*argv+1)+1);
-                if (ngroups < 0){
+	if (**(++argv) != '-'){
+	    break;
+	}else{
+	    switch(*(*argv+1)){
+		case 'm':   ndatasets = atoi((*argv+1)+1);
+			    if (ndatasets < 0){
+				nerrors++;
+				return(1);
+			    }
+			    break;
+	        case 'n':   ngroups = atoi((*argv+1)+1);
+		            if (ngroups < 0){
                                 nerrors++;
                                 return(1);
-          }
+			    }
                             break;
-    case 'f':   if (--argc < 1) {
-        nerrors++;
-        return(1);
-          }
-          if (**(++argv) == '-') {
-        nerrors++;
-        return(1);
-          }
-          paraprefix = *argv;
-          break;
-    case 'i':   /* Collective MPI-IO access with independent IO  */
-          dxfer_coll_type = DXFER_INDEPENDENT_IO;
-          break;
-    case '2':   /* Use the split-file driver with MPIO access */
-          /* Can use $HDF5_METAPREFIX to define the */
-          /* meta-file-prefix. */
-          facc_type = FACC_MPIO | FACC_SPLIT;
-          break;
-    case 'd':   /* dimensizes */
-          if (--argc < 2){
-        nerrors++;
-        return(1);
-          }
-          dim0 = atoi(*(++argv))*mpi_size;
-          argc--;
-          dim1 = atoi(*(++argv))*mpi_size;
-          /* set default chunkdim sizes too */
-          chunkdim0 = (dim0+9)/10;
-          chunkdim1 = (dim1+9)/10;
-          break;
-    case 'c':   /* chunk dimensions */
-          if (--argc < 2){
-        nerrors++;
-        return(1);
-          }
-          chunkdim0 = atoi(*(++argv));
-          argc--;
-          chunkdim1 = atoi(*(++argv));
-          break;
-    case 'h':   /* print help message--return with nerrors set */
-          return(1);
-    default:    printf("Illegal option(%s)\n", *argv);
-          nerrors++;
-          return(1);
-      }
-  }
+		case 'f':   if (--argc < 1) {
+				nerrors++;
+				return(1);
+			    }
+			    if (**(++argv) == '-') {
+				nerrors++;
+				return(1);
+			    }
+			    paraprefix = *argv;
+			    break;
+		case 'i':   /* Collective MPI-IO access with independent IO  */
+			    dxfer_coll_type = DXFER_INDEPENDENT_IO;
+			    break;
+		case '2':   /* Use the split-file driver with MPIO access */
+			    /* Can use $HDF5_METAPREFIX to define the */
+			    /* meta-file-prefix. */
+			    facc_type = FACC_MPIO | FACC_SPLIT;
+			    break;
+		case 'd':   /* dimensizes */
+			    if (--argc < 2){
+				nerrors++;
+				return(1);
+			    }
+			    dim0 = atoi(*(++argv))*mpi_size;
+			    argc--;
+			    dim1 = atoi(*(++argv))*mpi_size;
+			    /* set default chunkdim sizes too */
+			    chunkdim0 = (dim0+9)/10;
+			    chunkdim1 = (dim1+9)/10;
+			    break;
+		case 'c':   /* chunk dimensions */
+			    if (--argc < 2){
+				nerrors++;
+				return(1);
+			    }
+			    chunkdim0 = atoi(*(++argv));
+			    argc--;
+			    chunkdim1 = atoi(*(++argv));
+			    break;
+		case 'h':   /* print help message--return with nerrors set */
+			    return(1);
+		default:    printf("Illegal option(%s)\n", *argv);
+			    nerrors++;
+			    return(1);
+	    }
+	}
     } /*while*/
 
     /* check validity of dimension and chunk sizes */
     if (dim0 <= 0 || dim1 <= 0){
-  printf("Illegal dim sizes (%d, %d)\n", dim0, dim1);
-  nerrors++;
-  return(1);
+	printf("Illegal dim sizes (%d, %d)\n", dim0, dim1);
+	nerrors++;
+	return(1);
     }
     if (chunkdim0 <= 0 || chunkdim1 <= 0){
-  printf("Illegal chunkdim sizes (%d, %d)\n", chunkdim0, chunkdim1);
-  nerrors++;
-  return(1);
+	printf("Illegal chunkdim sizes (%d, %d)\n", chunkdim0, chunkdim1);
+	nerrors++;
+	return(1);
     }
 
     /* Make sure datasets can be divided into equal portions by the processes */
     if ((dim0 % mpi_size) || (dim1 % mpi_size)){
-  if (MAINPROCESS)
-      printf("dim0(%d) and dim1(%d) must be multiples of processes(%d)\n",
-        dim0, dim1, mpi_size);
-  nerrors++;
-  return(1);
+	if (MAINPROCESS)
+	    printf("dim0(%d) and dim1(%d) must be multiples of processes(%d)\n",
+		    dim0, dim1, mpi_size);
+	nerrors++;
+	return(1);
     }
 
     /* compose the test filenames */
     {
-  int i, n;
-
-  n = sizeof(FILENAME)/sizeof(FILENAME[0]) - 1;  /* exclude the NULL */
-
-  for (i=0; i < n; i++)
-      if (h5_fixname(FILENAME[i],fapl,filenames[i],sizeof(filenames[i]))
-    == NULL){
-    printf("h5_fixname failed\n");
-    nerrors++;
-    return(1);
-      }
-  printf("Test filenames are:\n");
-  for (i=0; i < n; i++)
-      printf("    %s\n", filenames[i]);
+	int i, n;
+
+	n = sizeof(FILENAME)/sizeof(FILENAME[0]) - 1;	/* exclude the NULL */
+
+	for (i=0; i < n; i++)
+	    if (h5_fixname(FILENAME[i],fapl,filenames[i],sizeof(filenames[i]))
+		== NULL){
+		printf("h5_fixname failed\n");
+		nerrors++;
+		return(1);
+	    }
+	printf("Test filenames are:\n");
+	for (i=0; i < n; i++)
+	    printf("    %s\n", filenames[i]);
     }
 
     return(0);
@@ -257,7 +257,7 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type)
 {
     hid_t ret_pl = -1;
     herr_t ret;                 /* generic return value */
-    int mpi_rank;    /* mpi variables */
+    int mpi_rank;		/* mpi variables */
 
     /* need the rank for error checking macros */
     MPI_Comm_rank(MPI_COMM_WORLD, &mpi_rank);
@@ -266,32 +266,32 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type)
     VRFY((ret_pl >= 0), "H5P_FILE_ACCESS");
 
     if (l_facc_type == FACC_DEFAULT)
-  return (ret_pl);
+	return (ret_pl);
 
     if (l_facc_type == FACC_MPIO){
-  /* set Parallel access with communicator */
-  ret = H5Pset_fapl_mpio(ret_pl, comm, info);
-  VRFY((ret >= 0), "");
-  return(ret_pl);
+	/* set Parallel access with communicator */
+	ret = H5Pset_fapl_mpio(ret_pl, comm, info);
+	VRFY((ret >= 0), "");
+	return(ret_pl);
     }
 
     if (l_facc_type == (FACC_MPIO | FACC_SPLIT)){
-  hid_t mpio_pl;
-
-  mpio_pl = H5Pcreate (H5P_FILE_ACCESS);
-  VRFY((mpio_pl >= 0), "");
-  /* set Parallel access with communicator */
-  ret = H5Pset_fapl_mpio(mpio_pl, comm, info);
-  VRFY((ret >= 0), "");
-
-  /* setup file access template */
-  ret_pl = H5Pcreate (H5P_FILE_ACCESS);
-  VRFY((ret_pl >= 0), "");
-  /* set Parallel access with communicator */
-  ret = H5Pset_fapl_split(ret_pl, ".meta", mpio_pl, ".raw", mpio_pl);
-  VRFY((ret >= 0), "H5Pset_fapl_split succeeded");
-  H5Pclose(mpio_pl);
-  return(ret_pl);
+	hid_t mpio_pl;
+
+	mpio_pl = H5Pcreate (H5P_FILE_ACCESS);
+	VRFY((mpio_pl >= 0), "");
+	/* set Parallel access with communicator */
+	ret = H5Pset_fapl_mpio(mpio_pl, comm, info);
+	VRFY((ret >= 0), "");
+
+	/* setup file access template */
+	ret_pl = H5Pcreate (H5P_FILE_ACCESS);
+	VRFY((ret_pl >= 0), "");
+	/* set Parallel access with communicator */
+	ret = H5Pset_fapl_split(ret_pl, ".meta", mpio_pl, ".raw", mpio_pl);
+	VRFY((ret >= 0), "H5Pset_fapl_split succeeded");
+	H5Pclose(mpio_pl);
+	return(ret_pl);
     }
 
     /* unknown file access types */
@@ -301,7 +301,7 @@ create_faccess_plist(MPI_Comm comm, MPI_Info info, int l_facc_type)
 
 int main(int argc, char **argv)
 {
-    int mpi_size, mpi_rank;        /* mpi variables */
+    int mpi_size, mpi_rank;				/* mpi variables */
     H5Ptest_param_t ndsets_params, ngroups_params;
     H5Ptest_param_t collngroups_params;
     H5Ptest_param_t io_mode_confusion_params;
@@ -319,9 +319,9 @@ int main(int argc, char **argv)
     dim1 = COL_FACTOR*mpi_size;
 
     if (MAINPROCESS){
-  printf("===================================\n");
-  printf("PHDF5 TESTS START\n");
-  printf("===================================\n");
+	printf("===================================\n");
+	printf("PHDF5 TESTS START\n");
+	printf("===================================\n");
     }
 
     /* Attempt to turn off atexit post processing so that in case errors
@@ -340,41 +340,41 @@ int main(int argc, char **argv)
 
     /* Tests are generally arranged from least to most complexity... */
     AddTest("mpiodup", test_fapl_mpio_dup, NULL,
-      "fapl_mpio duplicate", NULL);
+	    "fapl_mpio duplicate", NULL);
 
     AddTest("split", test_split_comm_access, NULL,
-      "dataset using split communicators", PARATESTFILE);
+	    "dataset using split communicators", PARATESTFILE);
 
     AddTest("idsetw", dataset_writeInd, NULL,
-      "dataset independent write", PARATESTFILE);
+	    "dataset independent write", PARATESTFILE);
     AddTest("idsetr", dataset_readInd, NULL,
-      "dataset independent read", PARATESTFILE);
+	    "dataset independent read", PARATESTFILE);
 
     AddTest("cdsetw", dataset_writeAll, NULL,
-      "dataset collective write", PARATESTFILE);
+	    "dataset collective write", PARATESTFILE);
     AddTest("cdsetr", dataset_readAll, NULL,
-      "dataset collective read", PARATESTFILE);
+	    "dataset collective read", PARATESTFILE);
 
     AddTest("eidsetw", extend_writeInd, NULL,
-      "extendible dataset independent write", PARATESTFILE);
+	    "extendible dataset independent write", PARATESTFILE);
     AddTest("eidsetr", extend_readInd, NULL,
-      "extendible dataset independent read", PARATESTFILE);
+	    "extendible dataset independent read", PARATESTFILE);
     AddTest("ecdsetw", extend_writeAll, NULL,
-      "extendible dataset collective write", PARATESTFILE);
+	    "extendible dataset collective write", PARATESTFILE);
     AddTest("ecdsetr", extend_readAll, NULL,
-      "extendible dataset collective read", PARATESTFILE);
+	    "extendible dataset collective read", PARATESTFILE);
     AddTest("eidsetw2", extend_writeInd2, NULL,
-      "extendible dataset independent write #2", PARATESTFILE);
+	    "extendible dataset independent write #2", PARATESTFILE);
     AddTest("selnone", none_selection_chunk, NULL,
             "chunked dataset with none-selection", PARATESTFILE);
     AddTest("calloc", test_chunk_alloc, NULL,
-      "parallel extend Chunked allocation on serial file", PARATESTFILE);
+	    "parallel extend Chunked allocation on serial file", PARATESTFILE);
     AddTest("fltread", test_filter_read, NULL,
-      "parallel read of dataset written serially with filters", PARATESTFILE);
+	    "parallel read of dataset written serially with filters", PARATESTFILE);
 
 #ifdef H5_HAVE_FILTER_DEFLATE
     AddTest("cmpdsetr", compress_readAll, NULL,
-      "compressed dataset collective read", PARATESTFILE);
+	    "compressed dataset collective read", PARATESTFILE);
 #endif /* H5_HAVE_FILTER_DEFLATE */
 
     AddTest("zerodsetr", zero_dim_dset, NULL,
@@ -383,22 +383,22 @@ int main(int argc, char **argv)
     ndsets_params.name = PARATESTFILE;
     ndsets_params.count = ndatasets;
     AddTest("ndsetw", multiple_dset_write, NULL,
-      "multiple datasets write", &ndsets_params);
+	    "multiple datasets write", &ndsets_params);
 
     ngroups_params.name = PARATESTFILE;
     ngroups_params.count = ngroups;
     AddTest("ngrpw", multiple_group_write, NULL,
-      "multiple groups write", &ngroups_params);
+	    "multiple groups write", &ngroups_params);
     AddTest("ngrpr", multiple_group_read, NULL,
-      "multiple groups read", &ngroups_params);
+	    "multiple groups read", &ngroups_params);
 
     AddTest("compact", compact_dataset, NULL,
-      "compact dataset test", PARATESTFILE);
+	    "compact dataset test", PARATESTFILE);
 
     collngroups_params.name = PARATESTFILE;
     collngroups_params.count = ngroups;
     AddTest("cngrpw", collective_group_write, NULL,
-      "collective group and dataset write", &collngroups_params);
+	    "collective group and dataset write", &collngroups_params);
     AddTest("ingrpr", independent_group_read, NULL,
 	    "independent group and dataset read", &collngroups_params);
 #ifndef H5_HAVE_WIN32_API
@@ -408,71 +408,71 @@ int main(int argc, char **argv)
     printf("big dataset test will be skipped on Windows (JIRA HDDFV-8064)\n");
 #endif
     AddTest("fill", dataset_fillvalue, NULL,
-      "dataset fill value", PARATESTFILE);
+	    "dataset fill value", PARATESTFILE);
 
     AddTest("cchunk1",
-  coll_chunk1,NULL, "simple collective chunk io",PARATESTFILE);
+	coll_chunk1,NULL, "simple collective chunk io",PARATESTFILE);
     AddTest("cchunk2",
-  coll_chunk2,NULL, "noncontiguous collective chunk io",PARATESTFILE);
+	coll_chunk2,NULL, "noncontiguous collective chunk io",PARATESTFILE);
     AddTest("cchunk3",
-  coll_chunk3,NULL, "multi-chunk collective chunk io",PARATESTFILE);
+	coll_chunk3,NULL, "multi-chunk collective chunk io",PARATESTFILE);
     AddTest("cchunk4",
         coll_chunk4,NULL, "collective chunk io with partial non-selection ",PARATESTFILE);
 
     if((mpi_size < 3)&& MAINPROCESS ) {
-  printf("Collective chunk IO optimization APIs ");
-  printf("needs at least 3 processes to participate\n");
-  printf("Collective chunk IO API tests will be skipped \n");
+	printf("Collective chunk IO optimization APIs ");
+	printf("needs at least 3 processes to participate\n");
+	printf("Collective chunk IO API tests will be skipped \n");
     }
     AddTest((mpi_size <3)? "-cchunk5":"cchunk5" ,
         coll_chunk5,NULL,
-  "linked chunk collective IO without optimization",PARATESTFILE);
+	"linked chunk collective IO without optimization",PARATESTFILE);
     AddTest((mpi_size < 3)? "-cchunk6" : "cchunk6",
-  coll_chunk6,NULL,
-  "multi-chunk collective IO with direct request",PARATESTFILE);
+	coll_chunk6,NULL,
+	"multi-chunk collective IO with direct request",PARATESTFILE);
     AddTest((mpi_size < 3)? "-cchunk7" : "cchunk7",
-  coll_chunk7,NULL,
-  "linked chunk collective IO with optimization",PARATESTFILE);
+	coll_chunk7,NULL,
+	"linked chunk collective IO with optimization",PARATESTFILE);
     AddTest((mpi_size < 3)? "-cchunk8" : "cchunk8",
-  coll_chunk8,NULL,
-  "linked chunk collective IO transferring to multi-chunk",PARATESTFILE);
+	coll_chunk8,NULL,
+	"linked chunk collective IO transferring to multi-chunk",PARATESTFILE);
     AddTest((mpi_size < 3)? "-cchunk9" : "cchunk9",
-  coll_chunk9,NULL,
-  "multiple chunk collective IO with optimization",PARATESTFILE);
+	coll_chunk9,NULL,
+	"multiple chunk collective IO with optimization",PARATESTFILE);
     AddTest((mpi_size < 3)? "-cchunk10" : "cchunk10",
-  coll_chunk10,NULL,
-  "multiple chunk collective IO transferring to independent IO",PARATESTFILE);
+	coll_chunk10,NULL,
+	"multiple chunk collective IO transferring to independent IO",PARATESTFILE);
 
 
 
 /* irregular collective IO tests*/
     AddTest("ccontw",
-  coll_irregular_cont_write,NULL,
-  "collective irregular contiguous write",PARATESTFILE);
+	coll_irregular_cont_write,NULL,
+	"collective irregular contiguous write",PARATESTFILE);
     AddTest("ccontr",
-  coll_irregular_cont_read,NULL,
-  "collective irregular contiguous read",PARATESTFILE);
+	coll_irregular_cont_read,NULL,
+	"collective irregular contiguous read",PARATESTFILE);
     AddTest("cschunkw",
-  coll_irregular_simple_chunk_write,NULL,
-  "collective irregular simple chunk write",PARATESTFILE);
+	coll_irregular_simple_chunk_write,NULL,
+	"collective irregular simple chunk write",PARATESTFILE);
     AddTest("cschunkr",
-  coll_irregular_simple_chunk_read,NULL,
-  "collective irregular simple chunk read",PARATESTFILE);
+	coll_irregular_simple_chunk_read,NULL,
+	"collective irregular simple chunk read",PARATESTFILE);
     AddTest("ccchunkw",
-  coll_irregular_complex_chunk_write,NULL,
-  "collective irregular complex chunk write",PARATESTFILE);
+	coll_irregular_complex_chunk_write,NULL,
+	"collective irregular complex chunk write",PARATESTFILE);
     AddTest("ccchunkr",
-  coll_irregular_complex_chunk_read,NULL,
-  "collective irregular complex chunk read",PARATESTFILE);
+	coll_irregular_complex_chunk_read,NULL,
+	"collective irregular complex chunk read",PARATESTFILE);
 
     AddTest("null", null_dataset, NULL,
-      "null dataset test", PARATESTFILE);
+	    "null dataset test", PARATESTFILE);
 
     io_mode_confusion_params.name  = PARATESTFILE;
     io_mode_confusion_params.count = 0; /* value not used */
 
     AddTest("I/Omodeconf", io_mode_confusion, NULL,
-      "I/O mode confusion test -- hangs quickly on failure",
+	    "I/O mode confusion test -- hangs quickly on failure",
             &io_mode_confusion_params);
 
     if((mpi_size < 3) && MAINPROCESS) {
@@ -539,9 +539,9 @@ int main(int argc, char **argv)
     TestParseCmdLine(argc, argv);
 
     if (dxfer_coll_type == DXFER_INDEPENDENT_IO && MAINPROCESS){
-  printf("===================================\n"
-         "   Using Independent I/O with file set view to replace collective I/O \n"
-         "===================================\n");
+	printf("===================================\n"
+	       "   Using Independent I/O with file set view to replace collective I/O \n"
+	       "===================================\n");
     }
 
 
@@ -566,16 +566,16 @@ int main(int argc, char **argv)
     {
         int temp;
         MPI_Allreduce(&nerrors, &temp, 1, MPI_INT, MPI_MAX, MPI_COMM_WORLD);
-  nerrors=temp;
+	nerrors=temp;
     }
 
-    if (MAINPROCESS){    /* only process 0 reports */
-  printf("===================================\n");
-  if (nerrors)
-      printf("***PHDF5 tests detected %d errors***\n", nerrors);
-  else
-      printf("PHDF5 tests finished with no errors\n");
-  printf("===================================\n");
+    if (MAINPROCESS){		/* only process 0 reports */
+	printf("===================================\n");
+	if (nerrors)
+	    printf("***PHDF5 tests detected %d errors***\n", nerrors);
+	else
+	    printf("PHDF5 tests finished with no errors\n");
+	printf("===================================\n");
     }
     /* close HDF5 library */
     H5close();