[svn-r131] Tests hyperslabs.

1 files changed, 1192 insertions, 0 deletions

diff --git a/test/hyperslab.c b/test/hyperslab.c
new file mode 100644
index 0000000..b07a8fa
--- /dev/null
+++ b/test/hyperslab.c
@@ -0,0 +1,1192 @@
+/*
+ * Copyright (C) 1997 NCSA
+ *                    All rights reserved.
+ *
+ * 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.
+ */
+#include <H5private.h>
+#include <H5MMprivate.h>
+#include <H5Vprivate.h>
+
+#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
+
+
+/*-------------------------------------------------------------------------
+ * Function:	init_full
+ *
+ * Purpose:	Initialize full array.
+ *
+ * Return:	void
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, October 10, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static uintn
+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;
+}
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:	print_array
+ *
+ * Purpose:	Prints the values in an array
+ *
+ * Return:	void
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, October 10, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+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");
+   }
+}
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:	print_ref
+ *
+ * Purpose:	Prints the reference value
+ *
+ * Return:	Success:	0
+ *
+ *		Failure:	
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, October 10, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static void
+print_ref (size_t nx, size_t ny, size_t nz)
+{
+   uint8	*array;
+
+   array = H5MM_xcalloc (nx*ny*nz, sizeof(uint8));
+
+   printf ("Reference array:\n");
+   init_full (array, nx, ny, nz);
+   print_array (array, nx, ny, nz);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	test_fill
+ *
+ * Purpose:	Tests the H5V_hyper_fill() function.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Saturday, October 11, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+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)
+{
+   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, "%d", nx);
+      } else {
+	 ndims = 2;
+	 nz = 1;
+	 sprintf (dim, "%dx%d", nx, ny);
+      }
+   } else {
+      ndims = 3;
+      sprintf (dim, "%dx%dx%d", nx, ny, 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
+ *
+ * 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.
+ *
+ *		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.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, October 10, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+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)
+{
+   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, "%d", nx);
+      } else {
+	 ndims = 2;
+	 nz = 1;
+	 sprintf (dim, "%dx%d", nx, ny);
+      }
+   } else {
+      ndims = 3;
+      sprintf (dim, "%dx%dx%d", nx, ny, 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
+ *
+ * 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
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Saturday, October 11, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+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;
+}
+
+
+/*-------------------------------------------------------------------------
+ * 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.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Saturday, October 11, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+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;
+}
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:	test_transpose
+ *
+ * Purpose:	Copy a 2d array from here to there and transpose the elements
+ *		as it's copied.
+ *
+ * Return:	Success:	SUCCEED
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Saturday, October 11, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+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 %4dx%-4d", nx, 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
+ *
+ * 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
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Monday, October 13, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+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 %4dx%-4d to %4dx%-4d ",
+	    2*nx, 2*ny, nx, 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 %4dx%-4d to %4dx%-4d ",
+	    nx, ny, 2*nx, 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
+ *
+ * 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)
+ *
+ *		Failure:	exit(non-zero)
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, October 10, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+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;
+   }
+   
+   
+   /*------------------------------
+    * 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;
+   }
+   
+
+   /*---------------------
+    * 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;
+   }
+   
+   
+   /*---------------------------
+    * 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;
+   }
+   
+
+   /*-------------------------
+    * 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);
+}