1997-10-21 07:22:19 +08:00
|
|
|
|
/*
|
|
|
|
|
* Copyright (C) 1997 NCSA
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* All rights reserved.
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Programmer: Robb Matzke <matzke@llnl.gov>
|
|
|
|
|
* Friday, October 10, 1997
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* 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.
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*/
|
|
|
|
|
#include <H5private.h>
|
|
|
|
|
#include <H5MMprivate.h>
|
|
|
|
|
#include <H5Vprivate.h>
|
|
|
|
|
|
1997-12-17 05:08:59 +08:00
|
|
|
|
#ifndef HAVE_FUNCTION
|
1998-02-10 03:37:40 +08:00
|
|
|
|
#undef __FUNCTION__
|
1997-12-17 05:08:59 +08:00
|
|
|
|
#define __FUNCTION__ ""
|
|
|
|
|
#endif
|
1998-03-05 00:20:23 +08:00
|
|
|
|
#define AT() printf (" at %s:%d in %s()\n",__FILE__,__LINE__,__FUNCTION__);
|
1997-10-21 07:22:19 +08:00
|
|
|
|
|
1998-03-05 00:20:23 +08:00
|
|
|
|
#define TEST_SMALL 0x0001
|
|
|
|
|
#define TEST_MEDIUM 0x0002
|
1997-10-21 07:22:19 +08:00
|
|
|
|
|
1998-03-05 00:20:23 +08:00
|
|
|
|
#define VARIABLE_SRC 0
|
|
|
|
|
#define VARIABLE_DST 1
|
|
|
|
|
#define VARIABLE_BOTH 2
|
1997-10-21 07:22:19 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Function: init_full
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Purpose: Initialize full array.
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Return: void
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Friday, October 10, 1997
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static uintn
|
1998-01-17 06:23:43 +08:00
|
|
|
|
init_full(uint8 *array, size_t nx, size_t ny, size_t nz)
|
1997-10-21 07:22:19 +08:00
|
|
|
|
{
|
1998-04-07 23:34:16 +08:00
|
|
|
|
size_t i, j, k;
|
1998-03-05 00:20:23 +08:00
|
|
|
|
uint8 acc = 128;
|
|
|
|
|
uintn total = 0;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
1998-04-07 23:34:16 +08:00
|
|
|
|
for (i=0; i<nx; i++) {
|
|
|
|
|
for (j=0; j<ny; j++) {
|
|
|
|
|
for (k=0; k<nz; k++) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
total += acc;
|
|
|
|
|
*array++ = acc++;
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
return total;
|
1997-10-21 07:22:19 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Function: print_array
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Purpose: Prints the values in an array
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Return: void
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Friday, October 10, 1997
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static void
|
1998-01-17 06:23:43 +08:00
|
|
|
|
print_array(uint8 *array, size_t nx, size_t ny, size_t nz)
|
1997-10-21 07:22:19 +08:00
|
|
|
|
{
|
1998-04-07 23:34:16 +08:00
|
|
|
|
size_t i, j, k;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
1998-04-07 23:34:16 +08:00
|
|
|
|
for (i=0; i<nx; i++) {
|
|
|
|
|
if (nz>1) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
printf("i=%d:\n", i);
|
|
|
|
|
} else {
|
|
|
|
|
printf("%03d:", i);
|
|
|
|
|
}
|
|
|
|
|
|
1998-04-07 23:34:16 +08:00
|
|
|
|
for (j=0; j<ny; j++) {
|
|
|
|
|
if (nz>1)
|
1998-03-05 00:20:23 +08:00
|
|
|
|
printf("%03d:", j);
|
1998-04-07 23:34:16 +08:00
|
|
|
|
for (k=0; k<nz; k++) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
printf(" %3d", *array++);
|
|
|
|
|
}
|
1998-04-07 23:34:16 +08:00
|
|
|
|
if (nz>1)
|
1998-03-05 00:20:23 +08:00
|
|
|
|
printf("\n");
|
|
|
|
|
}
|
|
|
|
|
printf("\n");
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
1997-10-21 07:22:19 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Function: print_ref
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Purpose: Prints the reference value
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Return: Success: 0
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Failure:
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Friday, October 10, 1997
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static void
|
1998-01-17 06:23:43 +08:00
|
|
|
|
print_ref(size_t nx, size_t ny, size_t nz)
|
1997-10-21 07:22:19 +08:00
|
|
|
|
{
|
1998-03-05 00:20:23 +08:00
|
|
|
|
uint8 *array;
|
1997-10-21 07:22:19 +08:00
|
|
|
|
|
1998-06-23 11:41:22 +08:00
|
|
|
|
array = H5MM_calloc(nx*ny*nz*sizeof(uint8));
|
1997-10-21 07:22:19 +08:00
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
printf("Reference array:\n");
|
|
|
|
|
init_full(array, nx, ny, nz);
|
|
|
|
|
print_array(array, nx, ny, nz);
|
1997-10-21 07:22:19 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Function: test_fill
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Purpose: Tests the H5V_hyper_fill() function.
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Return: Success: SUCCEED
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Failure: FAIL
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Saturday, October 11, 1997
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static herr_t
|
1998-01-17 06:23:43 +08:00
|
|
|
|
test_fill(size_t nx, size_t ny, size_t nz,
|
1998-03-05 00:20:23 +08:00
|
|
|
|
size_t di, size_t dj, size_t dk,
|
|
|
|
|
size_t ddx, size_t ddy, size_t ddz)
|
1997-10-21 07:22:19 +08:00
|
|
|
|
{
|
1998-03-05 00:20:23 +08:00
|
|
|
|
uint8 *dst = NULL; /*destination array */
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hsize_t hs_size[3]; /*hyperslab size */
|
|
|
|
|
hsize_t dst_size[3]; /*destination total size */
|
|
|
|
|
hssize_t dst_offset[3]; /*offset of hyperslab in dest */
|
1998-03-05 00:20:23 +08:00
|
|
|
|
uintn ref_value; /*reference value */
|
|
|
|
|
uintn acc; /*accumulator */
|
1998-04-07 23:34:16 +08:00
|
|
|
|
size_t i, j, k, dx, dy, dz; /*counters */
|
1998-03-05 00:20:23 +08:00
|
|
|
|
size_t u, v, w;
|
|
|
|
|
int ndims; /*hyperslab dimensionality */
|
|
|
|
|
char dim[64], s[256]; /*temp string */
|
|
|
|
|
uintn fill_value; /*fill value */
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Dimensionality.
|
|
|
|
|
*/
|
|
|
|
|
if (0 == nz) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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);
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
} else {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
ndims = 3;
|
|
|
|
|
sprintf(dim, "%lux%lux%lu",
|
|
|
|
|
(unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
1998-03-05 00:20:23 +08:00
|
|
|
|
sprintf(s, "Testing hyperslab fill %-11s variable hyperslab", dim);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
printf("%-70s", s);
|
|
|
|
|
fflush(stdout);
|
|
|
|
|
|
|
|
|
|
/* Allocate array */
|
1998-06-23 11:41:22 +08:00
|
|
|
|
dst = H5MM_calloc(nx*ny*nz);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
init_full(dst, nx, ny, nz);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nx; i += di) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-04-09 05:43:02 +08:00
|
|
|
|
dst_offset[0] = (hssize_t)i;
|
|
|
|
|
dst_offset[1] = (hssize_t)j;
|
|
|
|
|
dst_offset[2] = (hssize_t)k;
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
puts(" PASSED");
|
|
|
|
|
H5MM_xfree(dst);
|
|
|
|
|
return SUCCEED;
|
|
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
H5MM_xfree(dst);
|
|
|
|
|
return FAIL;
|
1997-10-21 07:22:19 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Function: test_copy
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Purpose: Tests H5V_hyper_copy().
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* 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.
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* 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.
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* For each hyperslab location, various sizes of hyperslabs are
|
|
|
|
|
* tried beginning with 1x1x1 and increasing the size in each
|
|
|
|
|
* dimension by DDX,DDY,DDZ.
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Return: Success: SUCCEED
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Failure: FAIL
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Friday, October 10, 1997
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static herr_t
|
1998-01-17 06:23:43 +08:00
|
|
|
|
test_copy(int mode,
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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)
|
1997-10-21 07:22:19 +08:00
|
|
|
|
{
|
1998-03-05 00:20:23 +08:00
|
|
|
|
uint8 *src = NULL; /*source array */
|
|
|
|
|
uint8 *dst = NULL; /*destination array */
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hsize_t hs_size[3]; /*hyperslab size */
|
|
|
|
|
hsize_t dst_size[3]; /*destination total size */
|
|
|
|
|
hsize_t src_size[3]; /*source total size */
|
|
|
|
|
hssize_t dst_offset[3]; /*offset of hyperslab in dest */
|
|
|
|
|
hssize_t src_offset[3]; /*offset of hyperslab in source */
|
1998-03-05 00:20:23 +08:00
|
|
|
|
uintn ref_value; /*reference value */
|
|
|
|
|
uintn acc; /*accumulator */
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hsize_t i, j, k, dx, dy, dz; /*counters */
|
|
|
|
|
hsize_t u, v, w;
|
1998-03-05 00:20:23 +08:00
|
|
|
|
int ndims; /*hyperslab dimensionality */
|
|
|
|
|
char dim[64], s[256]; /*temp string */
|
|
|
|
|
const char *sub;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Dimensionality.
|
|
|
|
|
*/
|
|
|
|
|
if (0 == nz) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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);
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
} else {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
ndims = 3;
|
|
|
|
|
sprintf(dim, "%lux%lux%lu",
|
|
|
|
|
(unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
switch (mode) {
|
|
|
|
|
case VARIABLE_SRC:
|
1998-03-05 00:20:23 +08:00
|
|
|
|
/*
|
|
|
|
|
* The hyperslab "travels" through the source array but the
|
|
|
|
|
* destination hyperslab is always at the origin of the destination
|
|
|
|
|
* array.
|
|
|
|
|
*/
|
|
|
|
|
sub = "variable source";
|
|
|
|
|
break;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
case VARIABLE_DST:
|
1998-03-05 00:20:23 +08:00
|
|
|
|
/*
|
|
|
|
|
* 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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
case VARIABLE_BOTH:
|
1998-03-05 00:20:23 +08:00
|
|
|
|
/*
|
|
|
|
|
* 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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
default:
|
1998-03-05 00:20:23 +08:00
|
|
|
|
abort();
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
sprintf(s, "Testing hyperslab copy %-11s %s", dim, sub);
|
|
|
|
|
printf("%-70s", s);
|
|
|
|
|
fflush(stdout);
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Allocate arrays
|
|
|
|
|
*/
|
1998-06-23 11:41:22 +08:00
|
|
|
|
src = H5MM_calloc(nx*ny*nz);
|
|
|
|
|
dst = H5MM_calloc(nx*ny*nz);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
init_full(src, nx, ny, nz);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < nx; i += di) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-04-09 05:43:02 +08:00
|
|
|
|
src_offset[0] = (hssize_t)i;
|
|
|
|
|
src_offset[1] = (hssize_t)j;
|
|
|
|
|
src_offset[2] = (hssize_t)k;
|
1998-03-05 00:20:23 +08:00
|
|
|
|
break;
|
|
|
|
|
case VARIABLE_DST:
|
1998-04-09 05:43:02 +08:00
|
|
|
|
dst_offset[0] = (hssize_t)i;
|
|
|
|
|
dst_offset[1] = (hssize_t)j;
|
|
|
|
|
dst_offset[2] = (hssize_t)k;
|
1998-03-05 00:20:23 +08:00
|
|
|
|
src_offset[0] = 0;
|
|
|
|
|
src_offset[1] = 0;
|
|
|
|
|
src_offset[2] = 0;
|
|
|
|
|
break;
|
|
|
|
|
case VARIABLE_BOTH:
|
1998-04-09 05:43:02 +08:00
|
|
|
|
dst_offset[0] = (hssize_t)i;
|
|
|
|
|
dst_offset[1] = (hssize_t)j;
|
|
|
|
|
dst_offset[2] = (hssize_t)k;
|
|
|
|
|
src_offset[0] = (hssize_t)i;
|
|
|
|
|
src_offset[1] = (hssize_t)j;
|
|
|
|
|
src_offset[2] = (hssize_t)k;
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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");
|
1998-04-09 05:43:02 +08:00
|
|
|
|
printf(" i=%lu, j=%lu, k=%lu, "
|
|
|
|
|
"dx=%lu, dy=%lu, dz=%lu\n",
|
|
|
|
|
(unsigned long)i,
|
|
|
|
|
(unsigned long)j,
|
|
|
|
|
(unsigned long)k,
|
|
|
|
|
(unsigned long)dx,
|
|
|
|
|
(unsigned long)dy,
|
|
|
|
|
(unsigned long)dz);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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");
|
1998-04-09 05:43:02 +08:00
|
|
|
|
printf(" i=%lu, j=%lu, k=%lu, "
|
|
|
|
|
"dx=%lu, dy=%lu, dz=%lu\n",
|
|
|
|
|
(unsigned long)i,
|
|
|
|
|
(unsigned long)j,
|
|
|
|
|
(unsigned long)k,
|
|
|
|
|
(unsigned long)dx,
|
|
|
|
|
(unsigned long)dy,
|
|
|
|
|
(unsigned long)dz);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
print_ref(nx, ny, nz);
|
|
|
|
|
printf("\n Destination array is:\n");
|
|
|
|
|
print_array(dst, nx, ny, nz);
|
|
|
|
|
}
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
puts(" PASSED");
|
|
|
|
|
H5MM_xfree(src);
|
|
|
|
|
H5MM_xfree(dst);
|
|
|
|
|
return SUCCEED;
|
|
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
H5MM_xfree(src);
|
|
|
|
|
H5MM_xfree(dst);
|
|
|
|
|
return FAIL;
|
1997-10-21 07:22:19 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Function: test_multifill
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* 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.
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Return: Success: SUCCEED
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Failure: FAIL
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Saturday, October 11, 1997
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static herr_t
|
1998-04-07 23:34:16 +08:00
|
|
|
|
test_multifill(size_t nx)
|
1997-10-21 07:22:19 +08:00
|
|
|
|
{
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hsize_t i, j;
|
|
|
|
|
hsize_t size;
|
|
|
|
|
hssize_t src_stride;
|
|
|
|
|
hssize_t dst_stride;
|
1998-03-05 00:20:23 +08:00
|
|
|
|
char s[64];
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
struct a_struct {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
int left;
|
|
|
|
|
double mid;
|
|
|
|
|
int right;
|
|
|
|
|
} fill , *src = NULL, *dst = NULL;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
printf("%-70s", "Testing multi-byte fill value");
|
|
|
|
|
fflush(stdout);
|
|
|
|
|
|
|
|
|
|
/* Initialize the source and destination */
|
1998-06-23 11:41:22 +08:00
|
|
|
|
src = H5MM_malloc(nx * sizeof(*src));
|
|
|
|
|
dst = H5MM_malloc(nx * sizeof(*dst));
|
1998-01-17 06:23:43 +08:00
|
|
|
|
for (i = 0; i < nx; i++) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Describe the fill value. The zero stride says to read the same thing
|
1998-01-17 06:23:43 +08:00
|
|
|
|
* 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;
|
1998-04-09 05:43:02 +08:00
|
|
|
|
H5V_stride_copy(1, (hsize_t)sizeof(double), &size,
|
1998-03-05 00:20:23 +08:00
|
|
|
|
&dst_stride, &(dst[0].mid), &src_stride, &(fill.mid));
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Check
|
|
|
|
|
*/
|
|
|
|
|
s[0] = '\0';
|
|
|
|
|
for (i = 0; i < nx; i++) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
if (dst[i].left != 3333333) {
|
1998-04-09 05:43:02 +08:00
|
|
|
|
sprintf(s, "bad dst[%lu].left", (unsigned long)i);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
} else if (dst[i].mid != fill.mid) {
|
1998-04-09 05:43:02 +08:00
|
|
|
|
sprintf(s, "bad dst[%lu].mid", (unsigned long)i);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
} else if (dst[i].right != 4444444) {
|
1998-04-09 05:43:02 +08:00
|
|
|
|
sprintf(s, "bad dst[%lu].right", (unsigned long)i);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
}
|
|
|
|
|
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]);
|
|
|
|
|
}
|
1998-04-09 05:43:02 +08:00
|
|
|
|
printf("\n dst[%lu]={%d,%g,%d}\n ",
|
|
|
|
|
(unsigned long)i,
|
|
|
|
|
dst[i].left, dst[i].mid, dst[i].right);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
for (j = 0; j < sizeof(dst[i]); j++) {
|
|
|
|
|
printf(" %02x", ((uint8 *) (dst + i))[j]);
|
|
|
|
|
}
|
|
|
|
|
printf("\n");
|
|
|
|
|
}
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
puts(" PASSED");
|
|
|
|
|
H5MM_xfree(src);
|
|
|
|
|
H5MM_xfree(dst);
|
|
|
|
|
return SUCCEED;
|
|
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
H5MM_xfree(src);
|
|
|
|
|
H5MM_xfree(dst);
|
|
|
|
|
return FAIL;
|
1997-10-21 07:22:19 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Function: test_endian
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* 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.
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Return: Success: SUCCEED
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Failure: FAIL
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Saturday, October 11, 1997
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static herr_t
|
1998-01-17 06:23:43 +08:00
|
|
|
|
test_endian(size_t nx)
|
1997-10-21 07:22:19 +08:00
|
|
|
|
{
|
1998-03-05 00:20:23 +08:00
|
|
|
|
uint8 *src = NULL; /*source array */
|
|
|
|
|
uint8 *dst = NULL; /*destination array */
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hssize_t src_stride[2]; /*source strides */
|
|
|
|
|
hssize_t dst_stride[2]; /*destination strides */
|
|
|
|
|
hsize_t size[2]; /*size vector */
|
|
|
|
|
hsize_t i, j;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
printf("%-70s", "Testing endian conversion by stride");
|
|
|
|
|
fflush(stdout);
|
|
|
|
|
|
|
|
|
|
/* Initialize arrays */
|
1998-06-23 11:41:22 +08:00
|
|
|
|
src = H5MM_malloc(nx * 4);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
init_full(src, nx, 4, 1);
|
1998-06-23 11:41:22 +08:00
|
|
|
|
dst = H5MM_calloc(nx * 4);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* 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 */
|
1998-04-09 05:43:02 +08:00
|
|
|
|
H5V_stride_copy(2, (hsize_t)1, size, dst_stride, dst + 3, src_stride, src);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Compare */
|
|
|
|
|
for (i = 0; i < nx; i++) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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();
|
1998-04-09 05:43:02 +08:00
|
|
|
|
printf(" i=%lu, j=%lu\n",
|
|
|
|
|
(unsigned long)i, (unsigned long)j);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
printf(" Source array is:\n");
|
|
|
|
|
print_array(src, nx, 4, 1);
|
|
|
|
|
printf("\n Result is:\n");
|
|
|
|
|
print_array(dst, nx, 4, 1);
|
|
|
|
|
}
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
puts(" PASSED");
|
|
|
|
|
H5MM_xfree(src);
|
|
|
|
|
H5MM_xfree(dst);
|
|
|
|
|
return SUCCEED;
|
|
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
H5MM_xfree(src);
|
|
|
|
|
H5MM_xfree(dst);
|
|
|
|
|
return FAIL;
|
1997-10-21 07:22:19 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Function: test_transpose
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Purpose: Copy a 2d array from here to there and transpose the elements
|
|
|
|
|
* as it's copied.
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Return: Success: SUCCEED
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Failure: FAIL
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Saturday, October 11, 1997
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static herr_t
|
1998-01-17 06:23:43 +08:00
|
|
|
|
test_transpose(size_t nx, size_t ny)
|
1997-10-21 07:22:19 +08:00
|
|
|
|
{
|
1998-03-05 00:20:23 +08:00
|
|
|
|
intn *src = NULL;
|
|
|
|
|
intn *dst = NULL;
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hsize_t i, j;
|
|
|
|
|
hssize_t src_stride[2], dst_stride[2];
|
|
|
|
|
hsize_t size[2];
|
1998-03-05 00:20:23 +08:00
|
|
|
|
char s[256];
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
sprintf(s, "Testing 2d transpose by stride %4lux%-lud",
|
1998-03-05 00:20:23 +08:00
|
|
|
|
(unsigned long) nx, (unsigned long) ny);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
printf("%-70s", s);
|
|
|
|
|
fflush(stdout);
|
|
|
|
|
|
|
|
|
|
/* Initialize */
|
1998-06-23 11:41:22 +08:00
|
|
|
|
src = H5MM_malloc(nx * ny * sizeof(*src));
|
1998-01-17 06:23:43 +08:00
|
|
|
|
for (i = 0; i < nx; i++) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
for (j = 0; j < ny; j++) {
|
|
|
|
|
src[i * ny + j] = (intn)(i * ny + j);
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
1998-06-23 11:41:22 +08:00
|
|
|
|
dst = H5MM_calloc(nx*ny*sizeof(*dst));
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Build stride info */
|
|
|
|
|
size[0] = nx;
|
|
|
|
|
size[1] = ny;
|
|
|
|
|
src_stride[0] = 0;
|
|
|
|
|
src_stride[1] = sizeof(*src);
|
1998-03-05 00:30:56 +08:00
|
|
|
|
dst_stride[0] = (ssize_t)((1 - nx * ny) * sizeof(*src));
|
|
|
|
|
dst_stride[1] = (ssize_t)(nx * sizeof(*src));
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Copy and transpose */
|
|
|
|
|
if (nx == ny) {
|
1998-04-09 05:43:02 +08:00
|
|
|
|
H5V_stride_copy(2, (hsize_t)sizeof(*src), size,
|
1998-03-05 00:20:23 +08:00
|
|
|
|
dst_stride, dst,
|
|
|
|
|
src_stride, src);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
} else {
|
1998-04-09 05:43:02 +08:00
|
|
|
|
H5V_stride_copy(2, (hsize_t)sizeof(*src), size,
|
1998-03-05 00:20:23 +08:00
|
|
|
|
dst_stride, dst,
|
|
|
|
|
src_stride, src);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Check */
|
|
|
|
|
for (i = 0; i < nx; i++) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
for (j = 0; j < ny; j++) {
|
|
|
|
|
if (src[i * ny + j] != dst[j * nx + i]) {
|
|
|
|
|
puts("*FAILED*");
|
|
|
|
|
if (!isatty(1)) {
|
|
|
|
|
AT();
|
1998-04-09 05:43:02 +08:00
|
|
|
|
printf(" diff at i=%lu, j=%lu\n",
|
|
|
|
|
(unsigned long)i, (unsigned long)j);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
printf(" Source is:\n");
|
|
|
|
|
for (i = 0; i < nx; i++) {
|
1998-04-09 05:43:02 +08:00
|
|
|
|
printf("%3lu:", (unsigned long)i);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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++) {
|
1998-04-09 05:43:02 +08:00
|
|
|
|
printf("%3lu:", (unsigned long)i);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
for (j = 0; j < nx; j++) {
|
|
|
|
|
printf(" %6d", dst[i * nx + j]);
|
|
|
|
|
}
|
|
|
|
|
printf("\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
puts(" PASSED");
|
|
|
|
|
H5MM_xfree(src);
|
|
|
|
|
H5MM_xfree(dst);
|
|
|
|
|
return SUCCEED;
|
|
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
H5MM_xfree(src);
|
|
|
|
|
H5MM_xfree(dst);
|
|
|
|
|
return FAIL;
|
1997-10-21 07:22:19 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Function: test_sub_super
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* 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.
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Return: Success: SUCCEED
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Failure: FAIL
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Monday, October 13, 1997
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static herr_t
|
1998-01-17 06:23:43 +08:00
|
|
|
|
test_sub_super(size_t nx, size_t ny)
|
1997-10-21 07:22:19 +08:00
|
|
|
|
{
|
1998-03-05 00:20:23 +08:00
|
|
|
|
uint8 *full = NULL; /*original image */
|
|
|
|
|
uint8 *half = NULL; /*image at 1/2 resolution */
|
|
|
|
|
uint8 *twice = NULL; /*2x2 pixels */
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hssize_t src_stride[4]; /*source stride info */
|
|
|
|
|
hssize_t dst_stride[4]; /*destination stride info */
|
|
|
|
|
hsize_t size[4]; /*number of sample points */
|
|
|
|
|
hsize_t i, j;
|
1998-03-05 00:20:23 +08:00
|
|
|
|
char s[256];
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
sprintf(s, "Testing image sampling %4lux%-4lu to %4lux%-4lu ",
|
1998-03-05 00:20:23 +08:00
|
|
|
|
(unsigned long) (2 * nx), (unsigned long) (2 * ny),
|
|
|
|
|
(unsigned long) nx, (unsigned long) ny);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
printf("%-70s", s);
|
|
|
|
|
fflush(stdout);
|
|
|
|
|
|
|
|
|
|
/* Initialize */
|
1998-06-23 11:41:22 +08:00
|
|
|
|
full = H5MM_malloc(4 * nx * ny);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
init_full(full, 2 * nx, 2 * ny, 1);
|
1998-06-23 11:41:22 +08:00
|
|
|
|
half = H5MM_calloc(nx*ny);
|
|
|
|
|
twice = H5MM_calloc(4*nx*ny);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Setup */
|
|
|
|
|
size[0] = nx;
|
|
|
|
|
size[1] = ny;
|
1998-03-05 00:30:56 +08:00
|
|
|
|
src_stride[0] = (ssize_t)(2 * ny);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
src_stride[1] = 2;
|
|
|
|
|
dst_stride[0] = 0;
|
|
|
|
|
dst_stride[1] = 1;
|
|
|
|
|
|
|
|
|
|
/* Copy */
|
1998-04-09 05:43:02 +08:00
|
|
|
|
H5V_stride_copy(2, (hsize_t)sizeof(uint8), size,
|
1998-03-05 00:20:23 +08:00
|
|
|
|
dst_stride, half, src_stride, full);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Check */
|
|
|
|
|
for (i = 0; i < nx; i++) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
for (j = 0; j < ny; j++) {
|
|
|
|
|
if (full[4 * i * ny + 2 * j] != half[i * ny + j]) {
|
|
|
|
|
puts("*FAILED*");
|
|
|
|
|
if (!isatty(1)) {
|
|
|
|
|
AT();
|
1998-04-09 05:43:02 +08:00
|
|
|
|
printf(" full[%lu][%lu] != half[%lu][%lu]\n",
|
|
|
|
|
(unsigned long)i*2,
|
|
|
|
|
(unsigned long)j*2,
|
|
|
|
|
(unsigned long)i,
|
|
|
|
|
(unsigned long)j);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
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 ",
|
1998-03-05 00:20:23 +08:00
|
|
|
|
(unsigned long) nx, (unsigned long) ny,
|
|
|
|
|
(unsigned long) (2 * nx), (unsigned long) (2 * ny));
|
1998-01-17 06:23:43 +08:00
|
|
|
|
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;
|
1998-03-05 00:30:56 +08:00
|
|
|
|
dst_stride[0] = (ssize_t)(2 * ny);
|
|
|
|
|
dst_stride[1] = (ssize_t)(2 * sizeof(uint8) - 4 * ny);
|
|
|
|
|
dst_stride[2] = (ssize_t)(2 * ny - 2 * sizeof(uint8));
|
1998-01-17 06:23:43 +08:00
|
|
|
|
dst_stride[3] = sizeof(uint8);
|
|
|
|
|
|
|
|
|
|
/* Copy */
|
1998-04-09 05:43:02 +08:00
|
|
|
|
H5V_stride_copy(4, (hsize_t)sizeof(uint8), size,
|
1998-03-05 00:20:23 +08:00
|
|
|
|
dst_stride, twice, src_stride, half);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Check */
|
|
|
|
|
s[0] = '\0';
|
|
|
|
|
for (i = 0; i < nx; i++) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
for (j = 0; j < ny; j++) {
|
|
|
|
|
if (half[i*ny+j] != twice[4*i*ny + 2*j]) {
|
1998-04-09 05:43:02 +08:00
|
|
|
|
sprintf(s, "half[%lu][%lu] != twice[%lu][%lu]",
|
|
|
|
|
(unsigned long)i,
|
|
|
|
|
(unsigned long)j,
|
|
|
|
|
(unsigned long)i*2,
|
|
|
|
|
(unsigned long)j*2);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
} else if (half[i*ny + j] != twice[4*i*ny + 2*j + 1]) {
|
1998-04-09 05:43:02 +08:00
|
|
|
|
sprintf(s, "half[%lu][%lu] != twice[%lu][%lu]",
|
|
|
|
|
(unsigned long)i,
|
|
|
|
|
(unsigned long)j,
|
|
|
|
|
(unsigned long)i*2,
|
|
|
|
|
(unsigned long)j*2+1);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
} else if (half[i*ny + j] != twice[(2*i +1)*2*ny + 2*j]) {
|
1998-04-09 05:43:02 +08:00
|
|
|
|
sprintf(s, "half[%lu][%lu] != twice[%lu][%lu]",
|
|
|
|
|
(unsigned long)i,
|
|
|
|
|
(unsigned long)j,
|
|
|
|
|
(unsigned long)i*2+1,
|
|
|
|
|
(unsigned long)j*2);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
} else if (half[i*ny + j] != twice[(2*i+1)*2*ny + 2*j+1]) {
|
1998-04-09 05:43:02 +08:00
|
|
|
|
sprintf(s, "half[%lu][%lu] != twice[%lu][%lu]",
|
|
|
|
|
(unsigned long)i,
|
|
|
|
|
(unsigned long)j,
|
|
|
|
|
(unsigned long)i*2+1,
|
|
|
|
|
(unsigned long)j*2+1);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
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;
|
1997-10-21 07:22:19 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Function: main
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Purpose: Test various hyperslab operations. Give the words
|
|
|
|
|
* `small' and/or `medium' on the command line or only `small'
|
|
|
|
|
* is assumed.
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Return: Success: exit(0)
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Failure: exit(non-zero)
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
1998-03-05 00:20:23 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Friday, October 10, 1997
|
1997-10-21 07:22:19 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
int
|
1998-01-17 06:23:43 +08:00
|
|
|
|
main(int argc, char *argv[])
|
1997-10-21 07:22:19 +08:00
|
|
|
|
{
|
1998-03-05 00:20:23 +08:00
|
|
|
|
herr_t status;
|
|
|
|
|
int nerrors = 0;
|
|
|
|
|
uintn size_of_test;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Parse arguments or assume `small' */
|
|
|
|
|
if (1 == argc) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
size_of_test = TEST_SMALL;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
} else {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
printf("Test sizes: ");
|
|
|
|
|
if (size_of_test & TEST_SMALL)
|
1998-03-05 00:20:23 +08:00
|
|
|
|
printf(" SMALL");
|
1998-01-17 06:23:43 +08:00
|
|
|
|
if (size_of_test & TEST_MEDIUM)
|
1998-03-05 00:20:23 +08:00
|
|
|
|
printf(" MEDIUM");
|
1998-01-17 06:23:43 +08:00
|
|
|
|
printf("\n");
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
*------------------------------
|
|
|
|
|
* TEST HYPERSLAB FILL OPERATION
|
|
|
|
|
*------------------------------
|
|
|
|
|
*/
|
|
|
|
|
if (size_of_test & TEST_SMALL) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
if (size_of_test & TEST_MEDIUM) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
1997-10-21 07:22:19 +08:00
|
|
|
|
/*------------------------------
|
|
|
|
|
* TEST HYPERSLAB COPY OPERATION
|
|
|
|
|
*------------------------------
|
|
|
|
|
*/
|
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/* exhaustive, one-dimensional test */
|
|
|
|
|
if (size_of_test & TEST_SMALL) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
if (size_of_test & TEST_MEDIUM) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
/* exhaustive, two-dimensional test */
|
|
|
|
|
if (size_of_test & TEST_SMALL) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
if (size_of_test & TEST_MEDIUM) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
/* sparse, two-dimensional test */
|
|
|
|
|
if (size_of_test & TEST_MEDIUM) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
/* exhaustive, three-dimensional test */
|
|
|
|
|
if (size_of_test & TEST_SMALL) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
if (size_of_test & TEST_MEDIUM) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
1997-10-21 07:22:19 +08:00
|
|
|
|
/*---------------------
|
|
|
|
|
* TEST MULTI-BYTE FILL
|
|
|
|
|
*---------------------
|
|
|
|
|
*/
|
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
if (size_of_test & TEST_SMALL) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
status = test_multifill(10);
|
|
|
|
|
nerrors += status < 0 ? 1 : 0;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
if (size_of_test & TEST_MEDIUM) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
status = test_multifill(500000);
|
|
|
|
|
nerrors += status < 0 ? 1 : 0;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
1997-10-21 07:22:19 +08:00
|
|
|
|
/*---------------------------
|
|
|
|
|
* TEST TRANSLATION OPERATORS
|
|
|
|
|
*---------------------------
|
|
|
|
|
*/
|
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
if (size_of_test & TEST_SMALL) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
if (size_of_test & TEST_MEDIUM) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
1997-10-21 07:22:19 +08:00
|
|
|
|
/*-------------------------
|
|
|
|
|
* TEST SAMPLING OPERATIONS
|
|
|
|
|
*-------------------------
|
|
|
|
|
*/
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
if (size_of_test & TEST_SMALL) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
status = test_sub_super(5, 10);
|
|
|
|
|
nerrors += status < 0 ? 1 : 0;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
if (size_of_test & TEST_MEDIUM) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
status = test_sub_super(480, 640);
|
|
|
|
|
nerrors += status < 0 ? 1 : 0;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
/*--- END OF TESTS ---*/
|
|
|
|
|
|
|
|
|
|
if (nerrors) {
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
printf("All hyperslab tests passed.\n");
|
1998-02-10 03:37:40 +08:00
|
|
|
|
return 0;
|
1997-10-21 07:22:19 +08:00
|
|
|
|
}
|