[svn-r157] Reformatted code with indent...

1 files changed, 977 insertions, 1012 deletions

diff --git a/test/hyperslab.c b/test/hyperslab.c
index 64c731e..82f78c4 100644
--- a/test/hyperslab.c
+++ b/test/hyperslab.c
@@ -2,14 +2,14 @@
  * Copyright (C) 1997 NCSA
  *                    All rights reserved.
  *
- * Programmer: 	Robb Matzke <matzke@llnl.gov>
- *             	Friday, October 10, 1997
+ * Programmer:  Robb Matzke <matzke@llnl.gov>
+ *              Friday, October 10, 1997
  *
- * Purpose:	Hyperslab operations are rather complex, so this file
- *		attempts to test them extensively so we can be relatively
- *		sure they really work.  We only test 1d, 2d, and 3d cases
- *		because testing general dimensionalities would require us to
- *		rewrite much of the hyperslab stuff.
+ * Purpose:     Hyperslab operations are rather complex, so this file
+ *              attempts to test them extensively so we can be relatively
+ *              sure they really work.  We only test 1d, 2d, and 3d cases
+ *              because testing general dimensionalities would require us to
+ *              rewrite much of the hyperslab stuff.
  */
 #include <H5private.h>
 #include <H5MMprivate.h>
@@ -20,22 +20,21 @@
 #endif
 #define AT() printf ("   at %s:%d in %s()\n",__FILE__,__LINE__,__FUNCTION__);
 
-#define TEST_SMALL	0x0001
-#define TEST_MEDIUM	0x0002
-
-#define VARIABLE_SRC	0
-#define VARIABLE_DST	1
-#define VARIABLE_BOTH	2
+#define TEST_SMALL      0x0001
+#define TEST_MEDIUM     0x0002
 
+#define VARIABLE_SRC    0
+#define VARIABLE_DST    1
+#define VARIABLE_BOTH   2
 
 /*-------------------------------------------------------------------------
- * Function:	init_full
+ * Function:    init_full
  *
- * Purpose:	Initialize full array.
+ * Purpose:     Initialize full array.
  *
- * Return:	void
+ * Return:      void
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, October 10, 1997
  *
  * Modifications:
@@ -43,33 +42,31 @@
  *-------------------------------------------------------------------------
  */
 static uintn
-init_full (uint8 *array, size_t nx, size_t ny, size_t nz)
+init_full(uint8 *array, size_t nx, size_t ny, size_t nz)
 {
-   int		i,  j, k;
-   uint8	acc=128;
-   uintn	total=0;
-
-   for (i=0; i<nx; i++) {
-      for (j=0; j<ny; j++) {
-	 for (k=0; k<nz; k++) {
-	    total += acc;
-	    *array++ = acc++;
-	 }
-      }
-   }
-   return total;
+    int                     i, j, k;
+    uint8                   acc = 128;
+    uintn                   total = 0;
+
+    for (i = 0; i < nx; i++) {
+        for (j = 0; j < ny; j++) {
+            for (k = 0; k < nz; k++) {
+                total += acc;
+                *array++ = acc++;
+            }
+        }
+    }
+    return total;
 }
-
-
 
 /*-------------------------------------------------------------------------
- * Function:	print_array
+ * Function:    print_array
  *
- * Purpose:	Prints the values in an array
+ * Purpose:     Prints the values in an array
  *
- * Return:	void
+ * Return:      void
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, October 10, 1997
  *
  * Modifications:
@@ -77,40 +74,40 @@ init_full (uint8 *array, size_t nx, size_t ny, size_t nz)
  *-------------------------------------------------------------------------
  */
 static void
-print_array (uint8 *array, size_t nx, size_t ny, size_t nz)
+print_array(uint8 *array, size_t nx, size_t ny, size_t nz)
 {
-   int		i, j, k;
-
-   for (i=0; i<nx; i++) {
-      if (nz>1) {
-	 printf ("i=%d:\n", i);
-      } else {
-	 printf ("%03d:", i);
-      }
-      
-      for (j=0; j<ny; j++) {
-	 if (nz>1) printf ("%03d:", j);
-	 for (k=0; k<nz; k++) {
-	    printf (" %3d", *array++);
-	 }
-	 if (nz>1) printf ("\n");
-      }
-      printf ("\n");
-   }
+    int                     i, j, k;
+
+    for (i = 0; i < nx; i++) {
+        if (nz > 1) {
+            printf("i=%d:\n", i);
+        } else {
+            printf("%03d:", i);
+        }
+
+        for (j = 0; j < ny; j++) {
+            if (nz > 1)
+                printf("%03d:", j);
+            for (k = 0; k < nz; k++) {
+                printf(" %3d", *array++);
+            }
+            if (nz > 1)
+                printf("\n");
+        }
+        printf("\n");
+    }
 }
-
-
 
 /*-------------------------------------------------------------------------
- * Function:	print_ref
+ * Function:    print_ref
  *
- * Purpose:	Prints the reference value
+ * Purpose:     Prints the reference value
  *
- * Return:	Success:	0
+ * Return:      Success:        0
  *
- *		Failure:	
+ *              Failure:        
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, October 10, 1997
  *
  * Modifications:
@@ -118,28 +115,27 @@ print_array (uint8 *array, size_t nx, size_t ny, size_t nz)
  *-------------------------------------------------------------------------
  */
 static void
-print_ref (size_t nx, size_t ny, size_t nz)
+print_ref(size_t nx, size_t ny, size_t nz)
 {
-   uint8	*array;
+    uint8                  *array;
 
-   array = H5MM_xcalloc (nx*ny*nz, sizeof(uint8));
+    array = H5MM_xcalloc(nx * ny * nz, sizeof(uint8));
 
-   printf ("Reference array:\n");
-   init_full (array, nx, ny, nz);
-   print_array (array, nx, ny, nz);
+    printf("Reference array:\n");
+    init_full(array, nx, ny, nz);
+    print_array(array, nx, ny, nz);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	test_fill
+ * Function:    test_fill
  *
- * Purpose:	Tests the H5V_hyper_fill() function.
+ * Purpose:     Tests the H5V_hyper_fill() function.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Saturday, October 11, 1997
  *
  * Modifications:
@@ -147,156 +143,153 @@ print_ref (size_t nx, size_t ny, size_t nz)
  *-------------------------------------------------------------------------
  */
 static herr_t
-test_fill (size_t nx,  size_t ny,  size_t nz,
-	   size_t di,  size_t dj,  size_t dk,
-	   size_t ddx, size_t ddy, size_t ddz)
+test_fill(size_t nx, size_t ny, size_t nz,
+          size_t di, size_t dj, size_t dk,
+          size_t ddx, size_t ddy, size_t ddz)
 {
-   uint8	*dst=NULL;		/*destination array		*/
-   size_t	hs_size[3];		/*hyperslab size		*/
-   size_t	dst_size[3];		/*destination total size	*/
-   size_t	dst_offset[3];		/*offset of hyperslab in dest	*/
-   uintn	ref_value;		/*reference value		*/
-   uintn	acc;			/*accumulator			*/
-   int		i, j, k, dx, dy, dz, u, v, w;	/*counters		*/
-   int		ndims;			/*hyperslab dimensionality	*/
-   char		dim[64],s[256];		/*temp string			*/
-   uintn	fill_value;		/*fill value			*/
-
-   /*
-    * Dimensionality.
-    */
-   if (0==nz) {
-      if (0==ny) {
-	 ndims = 1;
-	 ny = nz = 1;
-	 sprintf (dim, "%lu", (unsigned long)nx);
-      } else {
-	 ndims = 2;
-	 nz = 1;
-	 sprintf (dim, "%lux%lu", (unsigned long)nx, (unsigned long)ny);
-      }
-   } else {
-      ndims = 3;
-      sprintf (dim, "%lux%lux%lu",
-	       (unsigned long)nx, (unsigned long)ny, (unsigned long)nz);
-   }
-   sprintf (s, "Testing hyperslab fill %-11s variable hyperslab  ", dim);
-   printf ("%-70s", s);
-   fflush (stdout);
-
-   /* Allocate array */
-   dst = H5MM_xcalloc (nx*ny*nz, 1);
-   init_full (dst, nx, ny, nz);
-
-   
-   for (i=0; i<nx; i+=di) {
-      for (j=0; j<ny; j+=dj) {
-	 for (k=0; k<nz; k+=dk) {
-	    for (dx=1; dx<=nx-i; dx+=ddx) {
-	       for (dy=1; dy<=ny-j; dy+=ddy) {
-		  for (dz=1; dz<=nz-k; dz+=ddz) {
-
-		     /* Describe the hyperslab */
-		     dst_size[0] = nx;
-		     dst_size[1] = ny;
-		     dst_size[2] = nz;
-		     dst_offset[0] = i;
-		     dst_offset[1] = j;
-		     dst_offset[2] = k;
-		     hs_size[0] = dx;
-		     hs_size[1] = dy;
-		     hs_size[2] = dz;
-
-		     for (fill_value=0; fill_value<256; fill_value+=64) {
-			/*
-			 * Initialize the full array, then subtract the
-			 * original * fill values and add the new ones.
-			 */
-			ref_value = init_full (dst, nx, ny, nz);
-			for (u=dst_offset[0]; u<dst_offset[0]+dx; u++) {
-			   for (v=dst_offset[1]; v<dst_offset[1]+dy; v++) {
-			      for (w=dst_offset[2]; w<dst_offset[2]+dz; w++) {
-				 ref_value -= dst[u*ny*nz + v*nz + w];
-			      }
-			   }
-			}
-			ref_value += fill_value * dx * dy * dz;
-
-			/* Fill the hyperslab with some value */
-			H5V_hyper_fill (ndims, hs_size, dst_size, dst_offset,
-					dst, fill_value);
-
-			/*
-			 * Sum the array and compare it to the reference
-			 * value.
-			 */
-			acc = 0;
-			for (u=0; u<nx; u++) {
-			   for (v=0; v<ny; v++) {
-			      for (w=0; w<nz; w++) {
-				 acc += dst[u*ny*nz + v*nz + w];
-			      }
-			   }
-			}
-
-			if (acc != ref_value) {
-			   puts ("*FAILED*");
-			   if (!isatty (1)) {
-			      /*
-			       * Print debugging info unless output is going
-			       * directly to a terminal.
-			       */
-			      AT ();
-			      printf ("   acc != ref_value\n");
-			      printf ("   i=%d, j=%d, k=%d, "
-				      "dx=%d, dy=%d, dz=%d, fill=%d\n",
-				      i, j, k, dx, dy, dz, fill_value);
-			      print_ref (nx, ny, nz);
-			      printf ("\n   Result is:\n");
-			      print_array (dst, nx, ny, nz);
-			   }
-			   goto error;
-			}
-		     }
-		  }
-	       }
-	    }
-	 }
-      }
-   }
-   puts (" PASSED");
-   H5MM_xfree (dst);
-   return SUCCEED;
-
- error:
-   H5MM_xfree (dst);
-   return FAIL;
+    uint8                  *dst = NULL;         /*destination array             */
+    size_t                  hs_size[3];         /*hyperslab size                */
+    size_t                  dst_size[3];        /*destination total size        */
+    size_t                  dst_offset[3];      /*offset of hyperslab in dest   */
+    uintn                   ref_value;  /*reference value               */
+    uintn                   acc;        /*accumulator                   */
+    int                     i, j, k, dx, dy, dz, u, v, w;       /*counters              */
+    int                     ndims;      /*hyperslab dimensionality      */
+    char                    dim[64], s[256];    /*temp string                   */
+    uintn                   fill_value;         /*fill value                    */
+
+    /*
+     * Dimensionality.
+     */
+    if (0 == nz) {
+        if (0 == ny) {
+            ndims = 1;
+            ny = nz = 1;
+            sprintf(dim, "%lu", (unsigned long) nx);
+        } else {
+            ndims = 2;
+            nz = 1;
+            sprintf(dim, "%lux%lu", (unsigned long) nx, (unsigned long) ny);
+        }
+    } else {
+        ndims = 3;
+        sprintf(dim, "%lux%lux%lu",
+                (unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
+    }
+    sprintf(s, "Testing hyperslab fill %-11s variable hyperslab  ", dim);
+    printf("%-70s", s);
+    fflush(stdout);
+
+    /* Allocate array */
+    dst = H5MM_xcalloc(nx * ny * nz, 1);
+    init_full(dst, nx, ny, nz);
+
+    for (i = 0; i < nx; i += di) {
+        for (j = 0; j < ny; j += dj) {
+            for (k = 0; k < nz; k += dk) {
+                for (dx = 1; dx <= nx - i; dx += ddx) {
+                    for (dy = 1; dy <= ny - j; dy += ddy) {
+                        for (dz = 1; dz <= nz - k; dz += ddz) {
+
+                            /* Describe the hyperslab */
+                            dst_size[0] = nx;
+                            dst_size[1] = ny;
+                            dst_size[2] = nz;
+                            dst_offset[0] = i;
+                            dst_offset[1] = j;
+                            dst_offset[2] = k;
+                            hs_size[0] = dx;
+                            hs_size[1] = dy;
+                            hs_size[2] = dz;
+
+                            for (fill_value = 0; fill_value < 256; fill_value += 64) {
+                                /*
+                                 * Initialize the full array, then subtract the
+                                 * original * fill values and add the new ones.
+                                 */
+                                ref_value = init_full(dst, nx, ny, nz);
+                                for (u = dst_offset[0]; u < dst_offset[0] + dx; u++) {
+                                    for (v = dst_offset[1]; v < dst_offset[1] + dy; v++) {
+                                        for (w = dst_offset[2]; w < dst_offset[2] + dz; w++) {
+                                            ref_value -= dst[u * ny * nz + v * nz + w];
+                                        }
+                                    }
+                                }
+                                ref_value += fill_value * dx * dy * dz;
+
+                                /* Fill the hyperslab with some value */
+                                H5V_hyper_fill(ndims, hs_size, dst_size, dst_offset,
+                                               dst, fill_value);
+
+                                /*
+                                 * Sum the array and compare it to the reference
+                                 * value.
+                                 */
+                                acc = 0;
+                                for (u = 0; u < nx; u++) {
+                                    for (v = 0; v < ny; v++) {
+                                        for (w = 0; w < nz; w++) {
+                                            acc += dst[u * ny * nz + v * nz + w];
+                                        }
+                                    }
+                                }
+
+                                if (acc != ref_value) {
+                                    puts("*FAILED*");
+                                    if (!isatty(1)) {
+                                        /*
+                                         * Print debugging info unless output is going
+                                         * directly to a terminal.
+                                         */
+                                        AT();
+                                        printf("   acc != ref_value\n");
+                                        printf("   i=%d, j=%d, k=%d, "
+                                           "dx=%d, dy=%d, dz=%d, fill=%d\n",
+                                           i, j, k, dx, dy, dz, fill_value);
+                                        print_ref(nx, ny, nz);
+                                        printf("\n   Result is:\n");
+                                        print_array(dst, nx, ny, nz);
+                                    }
+                                    goto error;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    puts(" PASSED");
+    H5MM_xfree(dst);
+    return SUCCEED;
+
+  error:
+    H5MM_xfree(dst);
+    return FAIL;
 }
-
-
 
 /*-------------------------------------------------------------------------
- * Function:	test_copy
+ * Function:    test_copy
  *
- * Purpose:	Tests H5V_hyper_copy().
+ * Purpose:     Tests H5V_hyper_copy().
  *
- * 		The NX, NY, and NZ arguments are the size for the source and
- *		destination arrays.  You map pass zero for NZ or for NY and
- *		NZ to test the 2-d and 1-d cases respectively.
+ *              The NX, NY, and NZ arguments are the size for the source and
+ *              destination arrays.  You map pass zero for NZ or for NY and
+ *              NZ to test the 2-d and 1-d cases respectively.
  *
- *		A hyperslab is copied from/to (depending on MODE) various
- *		places in SRC and DST beginning at 0,0,0 and increasing
- *		location by DI,DJ,DK in the x, y, and z directions.
+ *              A hyperslab is copied from/to (depending on MODE) various
+ *              places in SRC and DST beginning at 0,0,0 and increasing
+ *              location by DI,DJ,DK in the x, y, and z directions.
  *
- *		For each hyperslab location, various sizes of hyperslabs are
- *		tried beginning with 1x1x1 and increasing the size in each
- *		dimension by DDX,DDY,DDZ.
+ *              For each hyperslab location, various sizes of hyperslabs are
+ *              tried beginning with 1x1x1 and increasing the size in each
+ *              dimension by DDX,DDY,DDZ.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, October 10, 1997
  *
  * Modifications:
@@ -304,257 +297,254 @@ test_fill (size_t nx,  size_t ny,  size_t nz,
  *-------------------------------------------------------------------------
  */
 static herr_t
-test_copy (int mode,
-	   size_t nx,  size_t ny,  size_t nz,
-	   size_t di,  size_t dj,  size_t dk,
-	   size_t ddx, size_t ddy, size_t ddz)
+test_copy(int mode,
+          size_t nx, size_t ny, size_t nz,
+          size_t di, size_t dj, size_t dk,
+          size_t ddx, size_t ddy, size_t ddz)
 {
-   uint8	*src=NULL;		/*source array			*/
-   uint8	*dst=NULL;		/*destination array		*/
-   size_t	hs_size[3];		/*hyperslab size		*/
-   size_t	dst_size[3];		/*destination total size	*/
-   size_t	src_size[3];		/*source total size		*/
-   size_t	dst_offset[3];		/*offset of hyperslab in dest	*/
-   size_t	src_offset[3];		/*offset of hyperslab in source	*/
-   uintn	ref_value;		/*reference value		*/
-   uintn	acc;			/*accumulator			*/
-   int		i, j, k, dx, dy, dz, u, v, w;	/*counters		*/
-   int		ndims;			/*hyperslab dimensionality	*/
-   char		dim[64], s[256];	/*temp string			*/
-   const char	*sub;
-
-   /*
-    * Dimensionality.
-    */
-   if (0==nz) {
-      if (0==ny) {
-	 ndims = 1;
-	 ny = nz = 1;
-	 sprintf (dim, "%lu", (unsigned long)nx);
-      } else {
-	 ndims = 2;
-	 nz = 1;
-	 sprintf (dim, "%lux%lu", (unsigned long)nx, (unsigned long)ny);
-      }
-   } else {
-      ndims = 3;
-      sprintf (dim, "%lux%lux%lu",
-	       (unsigned long)nx, (unsigned long)ny, (unsigned long)nz);
-   }
-   
-   switch (mode) {
-   case VARIABLE_SRC:
-      /*
-       * The hyperslab "travels" through the source array but the
-       * destination hyperslab is always at the origin of the destination
-       * array.
-       */
-      sub = "variable source";
-      break;
-   case VARIABLE_DST:
-      /*
-       * We always read a hyperslab from the origin of the source and copy it
-       * to a hyperslab at various locations in the destination.
-       */
-      sub = "variable destination";
-      break;
-   case VARIABLE_BOTH:
-      /*
-       * We read the hyperslab from various locations in the source and copy
-       * it to the same location in the destination.
-       */
-      sub = "sync source & dest  ";
-      break;
-   default:
-      abort ();
-   }
-   
-   sprintf (s, "Testing hyperslab copy %-11s %s", dim, sub);
-   printf ("%-70s", s);
-   fflush (stdout);
-
-   /*
-    * Allocate arrays
-    */
-   src = H5MM_xcalloc (nx*ny*nz, 1);
-   dst = H5MM_xcalloc (nx*ny*nz, 1);
-   init_full (src, nx, ny, nz);
-
-   for (i=0; i<nx; i+=di) {
-      for (j=0; j<ny; j+=dj) {
-	 for (k=0; k<nz; k+=dk) {
-	    for (dx=1; dx<=nx-i; dx+=ddx) {
-	       for (dy=1; dy<=ny-j; dy+=ddy) {
-		  for (dz=1; dz<=nz-k; dz+=ddz) {
-
-		     /*
-		      * Describe the source and destination hyperslabs and the
-		      * arrays to which they belong.
-		      */
-		     hs_size[0] = dx;
-		     hs_size[1] = dy;
-		     hs_size[2] = dz;
-		     dst_size[0] = src_size[0] = nx;
-		     dst_size[1] = src_size[1] = ny;
-		     dst_size[2] = src_size[2] = nz;
-		     switch (mode) {
-		     case VARIABLE_SRC:
-			dst_offset[0] = 0;
-			dst_offset[1] = 0;
-			dst_offset[2] = 0;
-			src_offset[0] = i;
-			src_offset[1] = j;
-			src_offset[2] = k;
-			break;
-		     case VARIABLE_DST:
-			dst_offset[0] = i;
-			dst_offset[1] = j;
-			dst_offset[2] = k;
-			src_offset[0] = 0;
-			src_offset[1] = 0;
-			src_offset[2] = 0;
-			break;
-		     case VARIABLE_BOTH:
-			dst_offset[0] = i;
-			dst_offset[1] = j;
-			dst_offset[2] = k;
-			src_offset[0] = i;
-			src_offset[1] = j;
-			src_offset[2] = k;
-			break;
-		     default:
-			abort ();
-		     }
-
-		     /*
-		      * Sum the main array directly to get a reference value
-		      * to compare against later.
-		      */
-		     ref_value = 0;
-		     for (u=src_offset[0]; u<src_offset[0]+dx; u++) {
-			for (v=src_offset[1]; v<src_offset[1]+dy; v++) {
-			   for (w=src_offset[2]; w<src_offset[2]+dz; w++) {
-			      ref_value += src[u*ny*nz + v*nz + w];
-			   }
-			}
-		     }
-
-		     /*
-		      * Set all loc values to 1 so we can detect writing
-		      * outside the hyperslab.
-		      */
-		     for (u=0; u<nx; u++) {
-			for (v=0; v<ny; v++) {
-			   for (w=0; w<nz; w++) {
-			      dst[u*ny*nz + v*nz + w] = 1;
-			   }
-			}
-		     }
-
-		     /*
-		      * Copy a hyperslab from the global array to the local
-		      * array.
-		      */
-		     H5V_hyper_copy (ndims, hs_size,
-				     dst_size, dst_offset, dst,
-				     src_size, src_offset, src);
-
-		     /*
-		      * Sum the destination hyperslab.  It should be the same
-		      * as the reference value.
-		      */
-		     acc = 0;
-		     for (u=dst_offset[0]; u<dst_offset[0]+dx; u++) {
-			for (v=dst_offset[1]; v<dst_offset[1]+dy; v++) {
-			   for (w=dst_offset[2]; w<dst_offset[2]+dz; w++) {
-			      acc += dst[u*ny*nz + v*nz + w];
-			   }
-			}
-		     }
-		     if (acc != ref_value) {
-			puts ("*FAILED*");
-			if (!isatty (1)) {
-			   /*
-			    * Print debugging info unless output is going
-			    * directly to a terminal.
-			    */
-			   AT ();
-			   printf ("   acc != ref_value\n");
-			   printf ("   i=%d, j=%d, k=%d, "
-				   "dx=%d, dy=%d, dz=%d\n",
-				   i, j, k, dx, dy, dz);
-			   print_ref (nx, ny, nz);
-			   printf ("\n   Destination array is:\n");
-			   print_array (dst, nx, ny, nz);
-			}
-			goto error;
-		     }
-
-		     /*
-		      * Sum the entire array. It should be a fixed amount
-		      * larger than the reference value since we added the
-		      * border of 1's to the hyperslab.
-		      */
-		     acc = 0;
-		     for (u=0; u<nx; u++) {
-			for (v=0; v<ny; v++) {
-			   for (w=0; w<nz; w++) {
-			      acc += dst[u*ny*nz + v*nz + w];
-			   }
-			}
-		     }
-		     if (acc != ref_value + nx*ny*nz - dx*dy*dz) {
-			puts ("*FAILED*");
-			if (!isatty (1)) {
-			   /*
-			    * Print debugging info unless output is going
-			    * directly to a terminal.
-			    */
-			   AT ();
-			   printf ("   acc != ref_value + nx*ny*nz - "
-				   "dx*dy*dz\n");
-			   printf ("   i=%d, j=%d, k=%d, "
-				   "dx=%d, dy=%d, dz=%d\n",
-				   i, j, k, dx, dy, dz);
-			   print_ref (nx, ny, nz);
-			   printf ("\n   Destination array is:\n");
-			   print_array (dst, nx, ny, nz);
-			}
-			goto error;
-		     }
-		  }
-	       }
-	    }
-	 }
-      }
-   }
-   puts (" PASSED");
-   H5MM_xfree (src);
-   H5MM_xfree (dst);
-   return SUCCEED;
-
- error:
-   H5MM_xfree (src);
-   H5MM_xfree (dst);
-   return FAIL;
+    uint8                  *src = NULL;         /*source array                  */
+    uint8                  *dst = NULL;         /*destination array             */
+    size_t                  hs_size[3];         /*hyperslab size                */
+    size_t                  dst_size[3];        /*destination total size        */
+    size_t                  src_size[3];        /*source total size             */
+    size_t                  dst_offset[3];      /*offset of hyperslab in dest   */
+    size_t                  src_offset[3];      /*offset of hyperslab in source */
+    uintn                   ref_value;  /*reference value               */
+    uintn                   acc;        /*accumulator                   */
+    int                     i, j, k, dx, dy, dz, u, v, w;       /*counters              */
+    int                     ndims;      /*hyperslab dimensionality      */
+    char                    dim[64], s[256];    /*temp string                   */
+    const char             *sub;
+
+    /*
+     * Dimensionality.
+     */
+    if (0 == nz) {
+        if (0 == ny) {
+            ndims = 1;
+            ny = nz = 1;
+            sprintf(dim, "%lu", (unsigned long) nx);
+        } else {
+            ndims = 2;
+            nz = 1;
+            sprintf(dim, "%lux%lu", (unsigned long) nx, (unsigned long) ny);
+        }
+    } else {
+        ndims = 3;
+        sprintf(dim, "%lux%lux%lu",
+                (unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
+    }
+
+    switch (mode) {
+    case VARIABLE_SRC:
+        /*
+         * The hyperslab "travels" through the source array but the
+         * destination hyperslab is always at the origin of the destination
+         * array.
+         */
+        sub = "variable source";
+        break;
+    case VARIABLE_DST:
+        /*
+         * We always read a hyperslab from the origin of the source and copy it
+         * to a hyperslab at various locations in the destination.
+         */
+        sub = "variable destination";
+        break;
+    case VARIABLE_BOTH:
+        /*
+         * We read the hyperslab from various locations in the source and copy
+         * it to the same location in the destination.
+         */
+        sub = "sync source & dest  ";
+        break;
+    default:
+        abort();
+    }
+
+    sprintf(s, "Testing hyperslab copy %-11s %s", dim, sub);
+    printf("%-70s", s);
+    fflush(stdout);
+
+    /*
+     * Allocate arrays
+     */
+    src = H5MM_xcalloc(nx * ny * nz, 1);
+    dst = H5MM_xcalloc(nx * ny * nz, 1);
+    init_full(src, nx, ny, nz);
+
+    for (i = 0; i < nx; i += di) {
+        for (j = 0; j < ny; j += dj) {
+            for (k = 0; k < nz; k += dk) {
+                for (dx = 1; dx <= nx - i; dx += ddx) {
+                    for (dy = 1; dy <= ny - j; dy += ddy) {
+                        for (dz = 1; dz <= nz - k; dz += ddz) {
+
+                            /*
+                             * Describe the source and destination hyperslabs and the
+                             * arrays to which they belong.
+                             */
+                            hs_size[0] = dx;
+                            hs_size[1] = dy;
+                            hs_size[2] = dz;
+                            dst_size[0] = src_size[0] = nx;
+                            dst_size[1] = src_size[1] = ny;
+                            dst_size[2] = src_size[2] = nz;
+                            switch (mode) {
+                            case VARIABLE_SRC:
+                                dst_offset[0] = 0;
+                                dst_offset[1] = 0;
+                                dst_offset[2] = 0;
+                                src_offset[0] = i;
+                                src_offset[1] = j;
+                                src_offset[2] = k;
+                                break;
+                            case VARIABLE_DST:
+                                dst_offset[0] = i;
+                                dst_offset[1] = j;
+                                dst_offset[2] = k;
+                                src_offset[0] = 0;
+                                src_offset[1] = 0;
+                                src_offset[2] = 0;
+                                break;
+                            case VARIABLE_BOTH:
+                                dst_offset[0] = i;
+                                dst_offset[1] = j;
+                                dst_offset[2] = k;
+                                src_offset[0] = i;
+                                src_offset[1] = j;
+                                src_offset[2] = k;
+                                break;
+                            default:
+                                abort();
+                            }
+
+                            /*
+                             * Sum the main array directly to get a reference value
+                             * to compare against later.
+                             */
+                            ref_value = 0;
+                            for (u = src_offset[0]; u < src_offset[0] + dx; u++) {
+                                for (v = src_offset[1]; v < src_offset[1] + dy; v++) {
+                                    for (w = src_offset[2]; w < src_offset[2] + dz; w++) {
+                                        ref_value += src[u * ny * nz + v * nz + w];
+                                    }
+                                }
+                            }
+
+                            /*
+                             * Set all loc values to 1 so we can detect writing
+                             * outside the hyperslab.
+                             */
+                            for (u = 0; u < nx; u++) {
+                                for (v = 0; v < ny; v++) {
+                                    for (w = 0; w < nz; w++) {
+                                        dst[u * ny * nz + v * nz + w] = 1;
+                                    }
+                                }
+                            }
+
+                            /*
+                             * Copy a hyperslab from the global array to the local
+                             * array.
+                             */
+                            H5V_hyper_copy(ndims, hs_size,
+                                           dst_size, dst_offset, dst,
+                                           src_size, src_offset, src);
+
+                            /*
+                             * Sum the destination hyperslab.  It should be the same
+                             * as the reference value.
+                             */
+                            acc = 0;
+                            for (u = dst_offset[0]; u < dst_offset[0] + dx; u++) {
+                                for (v = dst_offset[1]; v < dst_offset[1] + dy; v++) {
+                                    for (w = dst_offset[2]; w < dst_offset[2] + dz; w++) {
+                                        acc += dst[u * ny * nz + v * nz + w];
+                                    }
+                                }
+                            }
+                            if (acc != ref_value) {
+                                puts("*FAILED*");
+                                if (!isatty(1)) {
+                                    /*
+                                     * Print debugging info unless output is going
+                                     * directly to a terminal.
+                                     */
+                                    AT();
+                                    printf("   acc != ref_value\n");
+                                    printf("   i=%d, j=%d, k=%d, "
+                                           "dx=%d, dy=%d, dz=%d\n",
+                                           i, j, k, dx, dy, dz);
+                                    print_ref(nx, ny, nz);
+                                    printf("\n   Destination array is:\n");
+                                    print_array(dst, nx, ny, nz);
+                                }
+                                goto error;
+                            }
+                            /*
+                             * Sum the entire array. It should be a fixed amount
+                             * larger than the reference value since we added the
+                             * border of 1's to the hyperslab.
+                             */
+                            acc = 0;
+                            for (u = 0; u < nx; u++) {
+                                for (v = 0; v < ny; v++) {
+                                    for (w = 0; w < nz; w++) {
+                                        acc += dst[u * ny * nz + v * nz + w];
+                                    }
+                                }
+                            }
+                            if (acc != ref_value + nx * ny * nz - dx * dy * dz) {
+                                puts("*FAILED*");
+                                if (!isatty(1)) {
+                                    /*
+                                     * Print debugging info unless output is going
+                                     * directly to a terminal.
+                                     */
+                                    AT();
+                                    printf("   acc != ref_value + nx*ny*nz - "
+                                           "dx*dy*dz\n");
+                                    printf("   i=%d, j=%d, k=%d, "
+                                           "dx=%d, dy=%d, dz=%d\n",
+                                           i, j, k, dx, dy, dz);
+                                    print_ref(nx, ny, nz);
+                                    printf("\n   Destination array is:\n");
+                                    print_array(dst, nx, ny, nz);
+                                }
+                                goto error;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    puts(" PASSED");
+    H5MM_xfree(src);
+    H5MM_xfree(dst);
+    return SUCCEED;
+
+  error:
+    H5MM_xfree(src);
+    H5MM_xfree(dst);
+    return FAIL;
 }
-
-
 
 /*-------------------------------------------------------------------------
- * Function:	test_multifill
+ * Function:    test_multifill
  *
- * Purpose:	Tests the H5V_stride_copy() function by using it to fill a
- *		hyperslab by replicating a multi-byte sequence.  This might
- *		be useful to initialize an array of structs with a default
- *		struct value, or to initialize an array of floating-point
- *		values with a default bit-pattern.
+ * Purpose:     Tests the H5V_stride_copy() function by using it to fill a
+ *              hyperslab by replicating a multi-byte sequence.  This might
+ *              be useful to initialize an array of structs with a default
+ *              struct value, or to initialize an array of floating-point
+ *              values with a default bit-pattern.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Saturday, October 11, 1997
  *
  * Modifications:
@@ -562,112 +552,111 @@ test_copy (int mode,
  *-------------------------------------------------------------------------
  */
 static herr_t
-test_multifill (int nx)
+test_multifill(int nx)
 {
-   int		i, j;
-   size_t	size;
-   intn		src_stride;
-   intn		dst_stride;
-   char		s[64];
-
-   struct a_struct {
-      int left;
-      double mid;
-      int right;
-   } fill, *src=NULL, *dst=NULL;
-   
-   printf ("%-70s", "Testing multi-byte fill value");
-   fflush (stdout);
-   
-   /* Initialize the source and destination */
-   src = H5MM_xmalloc (nx * sizeof(*src));
-   dst = H5MM_xmalloc (nx * sizeof(*dst));
-   for (i=0; i<nx; i++) {
-      src[i].left = 1111111;
-      src[i].mid = 12345.6789;
-      src[i].right = 2222222;
-      dst[i].left = 3333333;
-      dst[i].mid = 98765.4321;
-      dst[i].right = 4444444;
-   }
-   
-   /*
-    * Describe the fill value.  The zero stride says to read the same thing
-    * over and over again.
-    */
-   fill.left = 55555555;
-   fill.mid = 3.1415927;
-   fill.right = 66666666;
-   src_stride = 0;
-
-   /*
-    * The destination stride says to fill in one value per array element
-    */
-   dst_stride = sizeof(fill);
-
-   /*
-    * Copy the fill value into each element
-    */
-   size = nx;
-   H5V_stride_copy (1, sizeof(double), &size,
-		    &dst_stride, &(dst[0].mid), &src_stride, &(fill.mid));
-   
-   /*
-    * Check
-    */
-   s[0] = '\0';
-   for (i=0; i<nx; i++) {
-      if (dst[i].left != 3333333) {
-	 sprintf (s, "bad dst[%d].left", i);
-      } else if (dst[i].mid != fill.mid) {
-	 sprintf (s, "bad dst[%d].mid", i);
-      } else if (dst[i].right != 4444444) {
-	 sprintf (s, "bad dst[%d].right", i);
-      }
-      if (s[0]) {
-	 puts ("*FAILED*");
-	 if (!isatty (1)) {
-	    AT ();
-	    printf ("   fill={%d,%g,%d}\n   ",
-		    fill.left, fill.mid, fill.right);
-	    for (j=0; j<sizeof(fill); j++) {
-	       printf (" %02x", ((uint8*)&fill)[j]);
-	    }
-	    printf ("\n   dst[%d]={%d,%g,%d}\n   ",
-		    i, dst[i].left, dst[i].mid, dst[i].right);
-	    for (j=0; j<sizeof(dst[i]); j++) {
-	       printf (" %02x", ((uint8*)(dst+i))[j]);
-	    }
-	    printf ("\n");
-	 }
-	 goto error;
-      }
-   }
-
-   puts (" PASSED");
-   H5MM_xfree (src);
-   H5MM_xfree (dst);
-   return SUCCEED;
-
- error:
-   H5MM_xfree (src);
-   H5MM_xfree (dst);
-   return FAIL;
+    int                     i, j;
+    size_t                  size;
+    intn                    src_stride;
+    intn                    dst_stride;
+    char                    s[64];
+
+    struct a_struct {
+        int                     left;
+        double                  mid;
+        int                     right;
+    } fill                 , *src = NULL, *dst = NULL;
+
+    printf("%-70s", "Testing multi-byte fill value");
+    fflush(stdout);
+
+    /* Initialize the source and destination */
+    src = H5MM_xmalloc(nx * sizeof(*src));
+    dst = H5MM_xmalloc(nx * sizeof(*dst));
+    for (i = 0; i < nx; i++) {
+        src[i].left = 1111111;
+        src[i].mid = 12345.6789;
+        src[i].right = 2222222;
+        dst[i].left = 3333333;
+        dst[i].mid = 98765.4321;
+        dst[i].right = 4444444;
+    }
+
+    /*
+     * Describe the fill value.  The zero stride says to read the same thing
+     * over and over again.
+     */
+    fill.left = 55555555;
+    fill.mid = 3.1415927;
+    fill.right = 66666666;
+    src_stride = 0;
+
+    /*
+     * The destination stride says to fill in one value per array element
+     */
+    dst_stride = sizeof(fill);
+
+    /*
+     * Copy the fill value into each element
+     */
+    size = nx;
+    H5V_stride_copy(1, sizeof(double), &size,
+            &dst_stride, &          (dst[0].mid), &src_stride, &(fill.mid));
+
+    /*
+     * Check
+     */
+    s[0] = '\0';
+    for (i = 0; i < nx; i++) {
+        if (dst[i].left != 3333333) {
+            sprintf(s, "bad dst[%d].left", i);
+        } else if (dst[i].mid != fill.mid) {
+            sprintf(s, "bad dst[%d].mid", i);
+        } else if (dst[i].right != 4444444) {
+            sprintf(s, "bad dst[%d].right", i);
+        }
+        if (s[0]) {
+            puts("*FAILED*");
+            if (!isatty(1)) {
+                AT();
+                printf("   fill={%d,%g,%d}\n   ",
+                       fill.left, fill.mid, fill.right);
+                for (j = 0; j < sizeof(fill); j++) {
+                    printf(" %02x", ((uint8 *) &fill)[j]);
+                }
+                printf("\n   dst[%d]={%d,%g,%d}\n   ",
+                       i, dst[i].left, dst[i].mid, dst[i].right);
+                for (j = 0; j < sizeof(dst[i]); j++) {
+                    printf(" %02x", ((uint8 *) (dst + i))[j]);
+                }
+                printf("\n");
+            }
+            goto error;
+        }
+    }
+
+    puts(" PASSED");
+    H5MM_xfree(src);
+    H5MM_xfree(dst);
+    return SUCCEED;
+
+  error:
+    H5MM_xfree(src);
+    H5MM_xfree(dst);
+    return FAIL;
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	test_endian
+ * Function:    test_endian
  *
- * Purpose:	Tests the H5V_stride_copy() function by using it to copy an
- *		array of integers and swap the byte ordering from little
- *		endian to big endian or vice versa depending on the hardware.
+ * Purpose:     Tests the H5V_stride_copy() function by using it to copy an
+ *              array of integers and swap the byte ordering from little
+ *              endian to big endian or vice versa depending on the hardware.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Saturday, October 11, 1997
  *
  * Modifications:
@@ -675,80 +664,78 @@ test_multifill (int nx)
  *-------------------------------------------------------------------------
  */
 static herr_t
-test_endian (size_t nx)
+test_endian(size_t nx)
 {
-   uint8	*src=NULL;		/*source array			*/
-   uint8	*dst=NULL;		/*destination array		*/
-   intn		src_stride[2];		/*source strides		*/
-   intn		dst_stride[2];		/*destination strides		*/
-   size_t	size[2];		/*size vector			*/
-   int		i, j;
-
-   printf ("%-70s", "Testing endian conversion by stride");
-   fflush (stdout);
-
-   /* Initialize arrays */
-   src = H5MM_xmalloc (nx*4);
-   init_full (src, nx, 4, 1);
-   dst = H5MM_xcalloc (nx, 4);
-
-   /* Initialize strides */
-   src_stride[0] = 0;
-   src_stride[1] = 1;
-   dst_stride[0] = 8;
-   dst_stride[1] = -1;
-   size[0] = nx;
-   size[1] = 4;
-
-   /* Copy the array */
-   H5V_stride_copy (2, 1, size, dst_stride, dst+3, src_stride, src);
-
-   /* Compare */
-   for (i=0; i<nx; i++) {
-      for (j=0; j<4; j++) {
-	 if (src[i*4+j] != dst[i*4+3-j]) {
-	    puts ("*FAILED*");
-	    if (!isatty (1)) {
-	       /*
-	        * Print debugging info unless output is going directly to a
-	        * terminal.
-	        */
-	       AT ();
-	       printf ("   i=%d, j=%d\n", i, j);
-	       printf ("   Source array is:\n");
-	       print_array (src, nx, 4, 1);
-	       printf ("\n   Result is:\n");
-	       print_array (dst, nx, 4, 1);
-	    }
-	    goto error;
-	 }
-      }
-   }
-
-   puts (" PASSED");
-   H5MM_xfree (src);
-   H5MM_xfree (dst);
-   return SUCCEED;
-
- error:
-   H5MM_xfree (src);
-   H5MM_xfree (dst);
-   return FAIL;
+    uint8                  *src = NULL;         /*source array                  */
+    uint8                  *dst = NULL;         /*destination array             */
+    intn                    src_stride[2];      /*source strides                */
+    intn                    dst_stride[2];      /*destination strides           */
+    size_t                  size[2];    /*size vector                   */
+    int                     i, j;
+
+    printf("%-70s", "Testing endian conversion by stride");
+    fflush(stdout);
+
+    /* Initialize arrays */
+    src = H5MM_xmalloc(nx * 4);
+    init_full(src, nx, 4, 1);
+    dst = H5MM_xcalloc(nx, 4);
+
+    /* Initialize strides */
+    src_stride[0] = 0;
+    src_stride[1] = 1;
+    dst_stride[0] = 8;
+    dst_stride[1] = -1;
+    size[0] = nx;
+    size[1] = 4;
+
+    /* Copy the array */
+    H5V_stride_copy(2, 1, size, dst_stride, dst + 3, src_stride, src);
+
+    /* Compare */
+    for (i = 0; i < nx; i++) {
+        for (j = 0; j < 4; j++) {
+            if (src[i * 4 + j] != dst[i * 4 + 3 - j]) {
+                puts("*FAILED*");
+                if (!isatty(1)) {
+                    /*
+                     * Print debugging info unless output is going directly to a
+                     * terminal.
+                     */
+                    AT();
+                    printf("   i=%d, j=%d\n", i, j);
+                    printf("   Source array is:\n");
+                    print_array(src, nx, 4, 1);
+                    printf("\n   Result is:\n");
+                    print_array(dst, nx, 4, 1);
+                }
+                goto error;
+            }
+        }
+    }
+
+    puts(" PASSED");
+    H5MM_xfree(src);
+    H5MM_xfree(dst);
+    return SUCCEED;
+
+  error:
+    H5MM_xfree(src);
+    H5MM_xfree(dst);
+    return FAIL;
 }
-
-
 
 /*-------------------------------------------------------------------------
- * Function:	test_transpose
+ * Function:    test_transpose
  *
- * Purpose:	Copy a 2d array from here to there and transpose the elements
- *		as it's copied.
+ * Purpose:     Copy a 2d array from here to there and transpose the elements
+ *              as it's copied.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Saturday, October 11, 1997
  *
  * Modifications:
@@ -756,105 +743,102 @@ test_endian (size_t nx)
  *-------------------------------------------------------------------------
  */
 static herr_t
-test_transpose (size_t nx, size_t ny)
+test_transpose(size_t nx, size_t ny)
 {
-   intn		*src = NULL;
-   intn		*dst = NULL;
-   int		i, j;
-   intn		src_stride[2], dst_stride[2];
-   size_t	size[2];
-   char		s[256];
-
-   sprintf (s, "Testing 2d transpose by stride %4lux%-lud",
-	    (unsigned long)nx, (unsigned long)ny);
-   printf ("%-70s", s);
-   fflush (stdout);
-
-   /* Initialize */
-   src = H5MM_xmalloc (nx*ny * sizeof(*src));
-   for (i=0; i<nx; i++) {
-      for (j=0; j<ny; j++) {
-	 src[i*ny + j] = i*ny + j;
-      }
-   }
-   dst = H5MM_xcalloc (nx*ny, sizeof(*dst));
-
-   /* Build stride info */
-   size[0] = nx;
-   size[1] = ny;
-   src_stride[0] = 0;
-   src_stride[1] = sizeof(*src);
-   dst_stride[0] = (1 - nx*ny) * sizeof(*src);
-   dst_stride[1] = nx * sizeof(*src);
-
-   /* Copy and transpose */
-   if (nx==ny) {
-      H5V_stride_copy (2, sizeof(*src), size,
-		       dst_stride, dst,
-		       src_stride, src);
-   } else {
-      H5V_stride_copy (2, sizeof(*src), size,
-		       dst_stride, dst,
-		       src_stride, src);
-   }
-   
-
-   /* Check */
-   for (i=0; i<nx; i++) {
-      for (j=0; j<ny; j++) {
-	 if (src[i*ny + j] != dst[j*nx + i]) {
-	    puts ("*FAILED*");
-	    if (!isatty (1)) {
-	       AT ();
-	       printf ("   diff at i=%d, j=%d\n", i, j);
-	       printf ("   Source is:\n");
-	       for (i=0; i<nx; i++) {
-		  printf ("%3d:", i);
-		  for (j=0; j<ny; j++) {
-		     printf (" %6d", src[i*ny+j]);
-		  }
-		  printf ("\n");
-	       }
-	       printf ("\n   Destination is:\n");
-	       for (i=0; i<ny; i++) {
-		  printf ("%3d:", i);
-		  for (j=0; j<nx; j++) {
-		     printf (" %6d", dst[i*nx+j]);
-		  }
-		  printf ("\n");
-	       }
-	    }
-	    goto error;
-	 }
-      }
-   }
-
-   puts (" PASSED");
-   H5MM_xfree (src);
-   H5MM_xfree (dst);
-   return SUCCEED;
-
- error:
-   H5MM_xfree (src);
-   H5MM_xfree (dst);
-   return FAIL;
+    intn                   *src = NULL;
+    intn                   *dst = NULL;
+    int                     i, j;
+    intn                    src_stride[2], dst_stride[2];
+    size_t                  size[2];
+    char                    s[256];
+
+    sprintf(s, "Testing 2d transpose by stride %4lux%-lud",
+            (unsigned long) nx, (unsigned long) ny);
+    printf("%-70s", s);
+    fflush(stdout);
+
+    /* Initialize */
+    src = H5MM_xmalloc(nx * ny * sizeof(*src));
+    for (i = 0; i < nx; i++) {
+        for (j = 0; j < ny; j++) {
+            src[i * ny + j] = i * ny + j;
+        }
+    }
+    dst = H5MM_xcalloc(nx * ny, sizeof(*dst));
+
+    /* Build stride info */
+    size[0] = nx;
+    size[1] = ny;
+    src_stride[0] = 0;
+    src_stride[1] = sizeof(*src);
+    dst_stride[0] = (1 - nx * ny) * sizeof(*src);
+    dst_stride[1] = nx * sizeof(*src);
+
+    /* Copy and transpose */
+    if (nx == ny) {
+        H5V_stride_copy(2, sizeof(*src), size,
+                        dst_stride, dst,
+                        src_stride, src);
+    } else {
+        H5V_stride_copy(2, sizeof(*src), size,
+                        dst_stride, dst,
+                        src_stride, src);
+    }
+
+    /* Check */
+    for (i = 0; i < nx; i++) {
+        for (j = 0; j < ny; j++) {
+            if (src[i * ny + j] != dst[j * nx + i]) {
+                puts("*FAILED*");
+                if (!isatty(1)) {
+                    AT();
+                    printf("   diff at i=%d, j=%d\n", i, j);
+                    printf("   Source is:\n");
+                    for (i = 0; i < nx; i++) {
+                        printf("%3d:", i);
+                        for (j = 0; j < ny; j++) {
+                            printf(" %6d", src[i * ny + j]);
+                        }
+                        printf("\n");
+                    }
+                    printf("\n   Destination is:\n");
+                    for (i = 0; i < ny; i++) {
+                        printf("%3d:", i);
+                        for (j = 0; j < nx; j++) {
+                            printf(" %6d", dst[i * nx + j]);
+                        }
+                        printf("\n");
+                    }
+                }
+                goto error;
+            }
+        }
+    }
+
+    puts(" PASSED");
+    H5MM_xfree(src);
+    H5MM_xfree(dst);
+    return SUCCEED;
+
+  error:
+    H5MM_xfree(src);
+    H5MM_xfree(dst);
+    return FAIL;
 }
-
-
 
 /*-------------------------------------------------------------------------
- * Function:	test_sub_super
+ * Function:    test_sub_super
  *
- * Purpose:	Tests H5V_stride_copy() to reduce the resolution of an image
- *		by copying half the pixels in the X and Y directions.  Then
- *		we use the small image and duplicate every pixel to result in
- *		a 2x2 square.
+ * Purpose:     Tests H5V_stride_copy() to reduce the resolution of an image
+ *              by copying half the pixels in the X and Y directions.  Then
+ *              we use the small image and duplicate every pixel to result in
+ *              a 2x2 square.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, October 13, 1997
  *
  * Modifications:
@@ -862,143 +846,140 @@ test_transpose (size_t nx, size_t ny)
  *-------------------------------------------------------------------------
  */
 static herr_t
-test_sub_super (size_t nx, size_t ny)
+test_sub_super(size_t nx, size_t ny)
 {
-   uint8	*full = NULL;		/*original image		*/
-   uint8	*half = NULL;		/*image at 1/2 resolution	*/
-   uint8	*twice = NULL;		/*2x2 pixels			*/
-   intn		src_stride[4];		/*source stride info		*/
-   intn		dst_stride[4];		/*destination stride info	*/
-   size_t	size[4];		/*number of sample points	*/
-   int		i, j;
-   char		s[256];
-
-   sprintf (s, "Testing image sampling %4lux%-4lu to %4lux%-4lu ",
-	    (unsigned long)(2*nx), (unsigned long)(2*ny),
-	    (unsigned long)nx, (unsigned long)ny);
-   printf ("%-70s", s);
-   fflush (stdout);
-
-   /* Initialize */
-   full = H5MM_xmalloc (4*nx*ny);
-   init_full (full, 2*nx, 2*ny, 1);
-   half = H5MM_xcalloc (nx*ny, 1);
-   twice = H5MM_xcalloc (4*nx*ny, 1);
-
-   /* Setup */
-   size[0] = nx;
-   size[1] = ny;
-   src_stride[0] = 2*ny;
-   src_stride[1] = 2;
-   dst_stride[0] = 0;
-   dst_stride[1] = 1;
-
-   /* Copy */
-   H5V_stride_copy (2, sizeof(uint8), size,
-		    dst_stride, half, src_stride, full);
-
-   /* Check */
-   for (i=0; i<nx; i++) {
-      for (j=0; j<ny; j++) {
-	 if (full[4*i*ny + 2*j] != half[i*ny+j]) {
-	    puts ("*FAILED*");
-	    if (!isatty (1)) {
-	       AT ();
-	       printf ("   full[%d][%d] != half[%d][%d]\n", i*2, j*2, i, j);
-	       printf ("   full is:\n");
-	       print_array (full, 2*nx, 2*ny, 1);
-	       printf ("\n   half is:\n");
-	       print_array (half, nx, ny, 1);
-	    }
-	    goto error;
-	 }
-      }
-   }
-   puts (" PASSED");
-
-
-   /*
-    * Test replicating pixels to produce an image twice as large in each
-    * dimension.
-    */
-   sprintf (s, "Testing image sampling %4lux%-4lu to %4lux%-4lu ",
-	    (unsigned long)nx, (unsigned long)ny,
-	    (unsigned long)(2*nx), (unsigned long)(2*ny));
-   printf ("%-70s", s);
-   fflush (stdout);
-
-   /* Setup stride */
-   size[0] = nx;
-   size[1] = ny;
-   size[2] = 2;
-   size[3] = 2;
-   src_stride[0] = 0;
-   src_stride[1] = 1;
-   src_stride[2] = 0;
-   src_stride[3] = 0;
-   dst_stride[0] = 2*ny;
-   dst_stride[1] = 2*sizeof(uint8) - 4*ny;
-   dst_stride[2] = 2*ny - 2*sizeof(uint8);
-   dst_stride[3] = sizeof(uint8);
-
-   /* Copy */
-   H5V_stride_copy (4, sizeof(uint8), size,
-		    dst_stride, twice, src_stride, half);
-   
-   /* Check */
-   s[0] = '\0';
-   for (i=0; i<nx; i++) {
-      for (j=0; j<ny; j++) {
-	 if (half[i*ny+j] != twice[4*i*ny + 2*j]) {
-	    sprintf (s, "half[%d][%d] != twice[%d][%d]", i, j, 2*i, 2*j);
-	 } else if (half[i*ny+j] != twice[4*i*ny + 2*j + 1]) {
-	    sprintf (s, "half[%d][%d] != twice[%d][%d]", i, j, 2*i, 2*j+1);
-	 } else if (half[i*ny+j] != twice[(2*i+1)*2*ny + 2*j]) {
-	    sprintf (s, "half[%d][%d] != twice[%d][%d]", i, j, 2*i+1, 2*j);
-	 } else if (half[i*ny+j] != twice[(2*i+1)*2*ny + 2*j + 1]) {
-	    sprintf (s, "half[%d][%d] != twice[%d][%d]", i, j, 2*i+1, 2*j+1);
-	 }
-	 if (s[0]) {
-	    puts ("*FAILED*");
-	    if (!isatty (1)) {
-	       AT ();
-	       printf ("   %s\n   Half is:\n", s);
-	       print_array (half, nx, ny, 1);
-	       printf ("\n   Twice is:\n");
-	       print_array (twice, 2*nx, 2*ny, 1);
-	    }
-	    goto error;
-	 }
-      }
-   }
-   puts (" PASSED");
-
-
-   H5MM_xfree (full);
-   H5MM_xfree (half);
-   H5MM_xfree (twice);
-   return SUCCEED;
-
- error:
-   H5MM_xfree (full);
-   H5MM_xfree (half);
-   H5MM_xfree (twice);
-   return FAIL;
+    uint8                  *full = NULL;        /*original image                */
+    uint8                  *half = NULL;        /*image at 1/2 resolution       */
+    uint8                  *twice = NULL;       /*2x2 pixels                    */
+    intn                    src_stride[4];      /*source stride info            */
+    intn                    dst_stride[4];      /*destination stride info       */
+    size_t                  size[4];    /*number of sample points       */
+    int                     i, j;
+    char                    s[256];
+
+    sprintf(s, "Testing image sampling %4lux%-4lu to %4lux%-4lu ",
+            (unsigned long) (2 * nx), (unsigned long) (2 * ny),
+            (unsigned long) nx, (unsigned long) ny);
+    printf("%-70s", s);
+    fflush(stdout);
+
+    /* Initialize */
+    full = H5MM_xmalloc(4 * nx * ny);
+    init_full(full, 2 * nx, 2 * ny, 1);
+    half = H5MM_xcalloc(nx * ny, 1);
+    twice = H5MM_xcalloc(4 * nx * ny, 1);
+
+    /* Setup */
+    size[0] = nx;
+    size[1] = ny;
+    src_stride[0] = 2 * ny;
+    src_stride[1] = 2;
+    dst_stride[0] = 0;
+    dst_stride[1] = 1;
+
+    /* Copy */
+    H5V_stride_copy(2, sizeof(uint8), size,
+                    dst_stride, half, src_stride, full);
+
+    /* Check */
+    for (i = 0; i < nx; i++) {
+        for (j = 0; j < ny; j++) {
+            if (full[4 * i * ny + 2 * j] != half[i * ny + j]) {
+                puts("*FAILED*");
+                if (!isatty(1)) {
+                    AT();
+                    printf("   full[%d][%d] != half[%d][%d]\n", i * 2, j * 2, i, j);
+                    printf("   full is:\n");
+                    print_array(full, 2 * nx, 2 * ny, 1);
+                    printf("\n   half is:\n");
+                    print_array(half, nx, ny, 1);
+                }
+                goto error;
+            }
+        }
+    }
+    puts(" PASSED");
+
+    /*
+     * Test replicating pixels to produce an image twice as large in each
+     * dimension.
+     */
+    sprintf(s, "Testing image sampling %4lux%-4lu to %4lux%-4lu ",
+            (unsigned long) nx, (unsigned long) ny,
+            (unsigned long) (2 * nx), (unsigned long) (2 * ny));
+    printf("%-70s", s);
+    fflush(stdout);
+
+    /* Setup stride */
+    size[0] = nx;
+    size[1] = ny;
+    size[2] = 2;
+    size[3] = 2;
+    src_stride[0] = 0;
+    src_stride[1] = 1;
+    src_stride[2] = 0;
+    src_stride[3] = 0;
+    dst_stride[0] = 2 * ny;
+    dst_stride[1] = 2 * sizeof(uint8) - 4 * ny;
+    dst_stride[2] = 2 * ny - 2 * sizeof(uint8);
+    dst_stride[3] = sizeof(uint8);
+
+    /* Copy */
+    H5V_stride_copy(4, sizeof(uint8), size,
+                    dst_stride, twice, src_stride, half);
+
+    /* Check */
+    s[0] = '\0';
+    for (i = 0; i < nx; i++) {
+        for (j = 0; j < ny; j++) {
+            if (half[i * ny + j] != twice[4 * i * ny + 2 * j]) {
+                sprintf(s, "half[%d][%d] != twice[%d][%d]", i, j, 2 * i, 2 * j);
+            } else if (half[i * ny + j] != twice[4 * i * ny + 2 * j + 1]) {
+                sprintf(s, "half[%d][%d] != twice[%d][%d]", i, j, 2 * i, 2 * j + 1);
+            } else if (half[i * ny + j] != twice[(2 * i + 1) * 2 * ny + 2 * j]) {
+                sprintf(s, "half[%d][%d] != twice[%d][%d]", i, j, 2 * i + 1, 2 * j);
+            } else if (half[i * ny + j] != twice[(2 * i + 1) * 2 * ny + 2 * j + 1]) {
+                sprintf(s, "half[%d][%d] != twice[%d][%d]", i, j, 2 * i + 1, 2 * j + 1);
+            }
+            if (s[0]) {
+                puts("*FAILED*");
+                if (!isatty(1)) {
+                    AT();
+                    printf("   %s\n   Half is:\n", s);
+                    print_array(half, nx, ny, 1);
+                    printf("\n   Twice is:\n");
+                    print_array(twice, 2 * nx, 2 * ny, 1);
+                }
+                goto error;
+            }
+        }
+    }
+    puts(" PASSED");
+
+    H5MM_xfree(full);
+    H5MM_xfree(half);
+    H5MM_xfree(twice);
+    return SUCCEED;
+
+  error:
+    H5MM_xfree(full);
+    H5MM_xfree(half);
+    H5MM_xfree(twice);
+    return FAIL;
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	main
+ * Function:    main
  *
- * Purpose:	Test various hyperslab operations.  Give the words
- *		`small' and/or `medium' on the command line or only `small'
- * 		is assumed.
+ * Purpose:     Test various hyperslab operations.  Give the words
+ *              `small' and/or `medium' on the command line or only `small'
+ *              is assumed.
  *
- * Return:	Success:	exit(0)
+ * Return:      Success:        exit(0)
  *
- *		Failure:	exit(non-zero)
+ *              Failure:        exit(non-zero)
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, October 10, 1997
  *
  * Modifications:
@@ -1006,195 +987,179 @@ test_sub_super (size_t nx, size_t ny)
  *-------------------------------------------------------------------------
  */
 int
-main (int argc, char *argv[])
+main(int argc, char *argv[])
 {
-   herr_t	status;
-   int		nerrors=0;
-   uintn	size_of_test;
-
-   /* Parse arguments or assume `small' */
-   if (1==argc) {
-      size_of_test = TEST_SMALL;
-   } else {
-      intn i;
-      for (i=1,size_of_test=0; i<argc; i++) {
-	 if (!strcmp (argv[i], "small")) {
-	    size_of_test |= TEST_SMALL;
-	 } else if (!strcmp (argv[i], "medium")) {
-	    size_of_test |= TEST_MEDIUM;
-	 } else {
-	    printf ("unrecognized argument: %s\n", argv[i]);
-	    exit (1);
-	 }
-      }
-   }
-   printf ("Test sizes: ");
-   if (size_of_test & TEST_SMALL) printf (" SMALL");
-   if (size_of_test & TEST_MEDIUM) printf (" MEDIUM");
-   printf ("\n");
-      
-
-
-   /*
-    *------------------------------ 
-    * TEST HYPERSLAB FILL OPERATION
-    *------------------------------ 
-    */
-   if (size_of_test & TEST_SMALL) {
-      status = test_fill (11, 0, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_fill (11, 10, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_fill (3, 5, 5, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-   }
-   if (size_of_test & TEST_MEDIUM) {
-      status = test_fill (113, 0, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_fill (15, 11, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_fill (5, 7, 7, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-   }
-   
-   
+    herr_t                  status;
+    int                     nerrors = 0;
+    uintn                   size_of_test;
+
+    /* Parse arguments or assume `small' */
+    if (1 == argc) {
+        size_of_test = TEST_SMALL;
+    } else {
+        intn                    i;
+        for (i = 1, size_of_test = 0; i < argc; i++) {
+            if (!strcmp(argv[i], "small")) {
+                size_of_test |= TEST_SMALL;
+            } else if (!strcmp(argv[i], "medium")) {
+                size_of_test |= TEST_MEDIUM;
+            } else {
+                printf("unrecognized argument: %s\n", argv[i]);
+                exit(1);
+            }
+        }
+    }
+    printf("Test sizes: ");
+    if (size_of_test & TEST_SMALL)
+        printf(" SMALL");
+    if (size_of_test & TEST_MEDIUM)
+        printf(" MEDIUM");
+    printf("\n");
+
+    /*
+     *------------------------------ 
+     * TEST HYPERSLAB FILL OPERATION
+     *------------------------------ 
+     */
+    if (size_of_test & TEST_SMALL) {
+        status = test_fill(11, 0, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_fill(11, 10, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_fill(3, 5, 5, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+    }
+    if (size_of_test & TEST_MEDIUM) {
+        status = test_fill(113, 0, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_fill(15, 11, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_fill(5, 7, 7, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+    }
    /*------------------------------
     * TEST HYPERSLAB COPY OPERATION
     *------------------------------ 
     */
 
-   /* exhaustive, one-dimensional test */
-   if (size_of_test & TEST_SMALL) {
-      status = test_copy (VARIABLE_SRC,  11, 0, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_DST,  11, 0, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_BOTH, 11, 0, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-   }
-   if (size_of_test & TEST_MEDIUM) {
-      status = test_copy (VARIABLE_SRC,  179, 0, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_DST,  179, 0, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_BOTH, 179, 0, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-   }
-
-   /* exhaustive, two-dimensional test */
-   if (size_of_test & TEST_SMALL) {
-      status = test_copy (VARIABLE_SRC,  11, 10, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_DST,  11, 10, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_BOTH, 11, 10, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-   }
-   if (size_of_test & TEST_MEDIUM) {
-      status = test_copy (VARIABLE_SRC,  13, 19, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_DST,  13, 19, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_BOTH, 13, 19, 0, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-   }
-
-   /* sparse, two-dimensional test */
-   if (size_of_test & TEST_MEDIUM) {
-      status = test_copy (VARIABLE_SRC,  73, 67, 0, 7, 11, 1, 13, 11, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_DST,  73, 67, 0, 7, 11, 1, 13, 11, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_BOTH, 73, 67, 0, 7, 11, 1, 13, 11, 1);
-      nerrors += status<0 ? 1 : 0;
-   }
-   
-
-   /* exhaustive, three-dimensional test */
-   if (size_of_test & TEST_SMALL) {
-      status = test_copy (VARIABLE_SRC,  3, 5, 5, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_DST,  3, 5, 5, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_BOTH, 3, 5, 5, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-   }
-   if (size_of_test & TEST_MEDIUM) {
-      status = test_copy (VARIABLE_SRC,  7, 9, 5, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_DST,  7, 9, 5, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-      status = test_copy (VARIABLE_BOTH, 7, 9, 5, 1, 1, 1, 1, 1, 1);
-      nerrors += status<0 ? 1 : 0;
-   }
-   
-
+    /* exhaustive, one-dimensional test */
+    if (size_of_test & TEST_SMALL) {
+        status = test_copy(VARIABLE_SRC, 11, 0, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_DST, 11, 0, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_BOTH, 11, 0, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+    }
+    if (size_of_test & TEST_MEDIUM) {
+        status = test_copy(VARIABLE_SRC, 179, 0, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_DST, 179, 0, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_BOTH, 179, 0, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+    }
+    /* exhaustive, two-dimensional test */
+    if (size_of_test & TEST_SMALL) {
+        status = test_copy(VARIABLE_SRC, 11, 10, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_DST, 11, 10, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_BOTH, 11, 10, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+    }
+    if (size_of_test & TEST_MEDIUM) {
+        status = test_copy(VARIABLE_SRC, 13, 19, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_DST, 13, 19, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_BOTH, 13, 19, 0, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+    }
+    /* sparse, two-dimensional test */
+    if (size_of_test & TEST_MEDIUM) {
+        status = test_copy(VARIABLE_SRC, 73, 67, 0, 7, 11, 1, 13, 11, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_DST, 73, 67, 0, 7, 11, 1, 13, 11, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_BOTH, 73, 67, 0, 7, 11, 1, 13, 11, 1);
+        nerrors += status < 0 ? 1 : 0;
+    }
+    /* exhaustive, three-dimensional test */
+    if (size_of_test & TEST_SMALL) {
+        status = test_copy(VARIABLE_SRC, 3, 5, 5, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_DST, 3, 5, 5, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_BOTH, 3, 5, 5, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+    }
+    if (size_of_test & TEST_MEDIUM) {
+        status = test_copy(VARIABLE_SRC, 7, 9, 5, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_DST, 7, 9, 5, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_copy(VARIABLE_BOTH, 7, 9, 5, 1, 1, 1, 1, 1, 1);
+        nerrors += status < 0 ? 1 : 0;
+    }
    /*---------------------
     * TEST MULTI-BYTE FILL
     *--------------------- 
     */
 
-   if (size_of_test & TEST_SMALL) {
-      status = test_multifill (10);
-      nerrors += status<0 ? 1 : 0;
-   }
-   if (size_of_test & TEST_MEDIUM) {
-      status = test_multifill (500000);
-      nerrors += status<0 ? 1 : 0;
-   }
-   
-   
+    if (size_of_test & TEST_SMALL) {
+        status = test_multifill(10);
+        nerrors += status < 0 ? 1 : 0;
+    }
+    if (size_of_test & TEST_MEDIUM) {
+        status = test_multifill(500000);
+        nerrors += status < 0 ? 1 : 0;
+    }
    /*---------------------------
     * TEST TRANSLATION OPERATORS
     *---------------------------
     */
 
-   if (size_of_test & TEST_SMALL) {
-      status = test_endian (10);
-      nerrors += status<0 ? 1 : 0;
-      status = test_transpose (9, 9);
-      nerrors += status<0 ? 1 : 0;
-      status = test_transpose (3, 11);
-      nerrors += status<0 ? 1 : 0;
-   }
-   if (size_of_test & TEST_MEDIUM) {
-      status = test_endian (800000);
-      nerrors += status<0 ? 1 : 0;
-      status = test_transpose (1200, 1200);
-      nerrors += status<0 ? 1 : 0;
-      status = test_transpose (800, 1800);
-      nerrors += status<0 ? 1 : 0;
-   }
-   
-
+    if (size_of_test & TEST_SMALL) {
+        status = test_endian(10);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_transpose(9, 9);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_transpose(3, 11);
+        nerrors += status < 0 ? 1 : 0;
+    }
+    if (size_of_test & TEST_MEDIUM) {
+        status = test_endian(800000);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_transpose(1200, 1200);
+        nerrors += status < 0 ? 1 : 0;
+        status = test_transpose(800, 1800);
+        nerrors += status < 0 ? 1 : 0;
+    }
    /*-------------------------
     * TEST SAMPLING OPERATIONS
     *------------------------- 
     */
-   
-   if (size_of_test & TEST_SMALL) {
-      status = test_sub_super (5, 10);
-      nerrors += status<0 ? 1 : 0;
-   }
-   if (size_of_test & TEST_MEDIUM) {
-      status = test_sub_super (480, 640);
-      nerrors += status<0 ? 1 : 0;
-   }
-   
-   
-
-   /*--- END OF TESTS ---*/
-
-   if (nerrors) {
-      printf ("***** %d HYPERSLAB TEST%s FAILED! *****\n",
-	      nerrors, 1==nerrors?"":"S");
-      if (isatty (1)) {
-	 printf ("(Redirect output to a pager or a file to see "
-		 "debug output)\n");
-      }
-      exit (1);
-   }
-
-   printf ("All hyperslab tests passed.\n");
-   exit (0);
+
+    if (size_of_test & TEST_SMALL) {
+        status = test_sub_super(5, 10);
+        nerrors += status < 0 ? 1 : 0;
+    }
+    if (size_of_test & TEST_MEDIUM) {
+        status = test_sub_super(480, 640);
+        nerrors += status < 0 ? 1 : 0;
+    }
+/*--- END OF TESTS ---*/
+
+    if (nerrors) {
+        printf("***** %d HYPERSLAB TEST%s FAILED! *****\n",
+               nerrors, 1 == nerrors ? "" : "S");
+        if (isatty(1)) {
+            printf("(Redirect output to a pager or a file to see "
+                   "debug output)\n");
+        }
+        exit(1);
+    }
+    printf("All hyperslab tests passed.\n");
+    exit(0);
 }