mirror of
https://github.com/HDFGroup/hdf5.git
synced 2025-02-17 16:10:24 +08:00
1c1679b2d4
----------------------
./bin/release
./src/H5.c
./src/H5private.h
./src/H5public.h
./src/H5Fpublic.h
Changed the version number constants to names that begin with
H5_VERS_ and added macros that check that the version numbers
in the include files match the version number of the library.
./MANIFEST
./html/H5.user.html
./html/Version.html [NEW]
./html/version.obj [NEW]
./html/version.gif [NEW]
Documented version numbers and the macros, constants, and
functions associated with them.
./bin/versinc
A perl script that increments the minor version number and
sets the patch level back to zero. This is intended to be
invoked from the top of the source tree by a cvs commit
anywhere in the source tree. Quincey?
./src/H5O.c
./src/H5Oprivate.h
Added H5O_count() to count the number of object header
messages of a particular type. Quincey needs this for the
attribute package.
./test/dsets.c
Fixed warnings. Enabled the small strip-mine buffer test.
./config/linux
Added optimizations for the Pentium-Pro for production mode.
730 lines
19 KiB
C
730 lines
19 KiB
C
/*
|
||
* Copyright (C) 1997 NCSA
|
||
* All rights reserved.
|
||
*
|
||
* Programmer: Robb Matzke <matzke@llnl.gov>
|
||
* Tuesday, December 9, 1997
|
||
*
|
||
* Purpose: Tests the dataset interface (H5D)
|
||
*/
|
||
#include <assert.h>
|
||
#include <hdf5.h>
|
||
#include <math.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <unistd.h>
|
||
|
||
#include <H5config.h>
|
||
#ifndef HAVE_ATTRIBUTE
|
||
# undef __attribute__
|
||
# define __attribute__(X) /*void*/
|
||
# define __unused__ /*void*/
|
||
#else
|
||
# define __unused__ __attribute__((unused))
|
||
#endif
|
||
|
||
#ifndef HAVE_FUNCTION
|
||
# undef __FUNCTION__
|
||
# define __FUNCTION__ ""
|
||
#endif
|
||
|
||
#define AT() printf (" at %s:%d in %s()...\n", \
|
||
__FILE__, __LINE__, __FUNCTION__);
|
||
|
||
#define DSET_DEFAULT_NAME "default"
|
||
#define DSET_CHUNKED_NAME "chunked"
|
||
#define DSET_SIMPLE_IO_NAME "simple_io"
|
||
#define DSET_TCONV_NAME "tconv"
|
||
#define DSET_COMPRESS_NAME "compressed"
|
||
#define DSET_BOGUS_NAME "bogus"
|
||
|
||
#define H5Z_BOGUS 255
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: display_error_cb
|
||
*
|
||
* Purpose: Displays the error stack after printing "*FAILED*".
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Wednesday, March 4, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
display_error_cb (void __unused__ *client_data)
|
||
{
|
||
puts ("*FAILED*");
|
||
H5Eprint (stdout);
|
||
return 0;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_create
|
||
*
|
||
* Purpose: Attempts to create a dataset.
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Tuesday, December 9, 1997
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_create(hid_t file)
|
||
{
|
||
hid_t dataset, space, create_parms;
|
||
hsize_t dims[2];
|
||
herr_t status;
|
||
hsize_t csize[2];
|
||
herr_t (*func)(void*) = NULL;
|
||
void *client_data = NULL;
|
||
|
||
printf("%-70s", "Testing create/open/close");
|
||
fflush (stdout);
|
||
|
||
/* Create the data space */
|
||
dims[0] = 256;
|
||
dims[1] = 512;
|
||
space = H5Screate_simple(2, dims, NULL);
|
||
assert(space>=0);
|
||
|
||
/*
|
||
* Create a dataset using the default dataset creation properties. We're
|
||
* not sure what they are, so we won't check.
|
||
*/
|
||
dataset = H5Dcreate(file, DSET_DEFAULT_NAME, H5T_NATIVE_DOUBLE, space,
|
||
H5P_DEFAULT);
|
||
if (dataset<0) goto error;
|
||
|
||
/* Close the dataset */
|
||
if (H5Dclose(dataset) < 0) goto error;
|
||
|
||
/*
|
||
* Try creating a dataset that already exists. This should fail since a
|
||
* dataset can only be created once. Temporarily turn off error
|
||
* reporting.
|
||
*/
|
||
H5Eget_auto (&func, &client_data);
|
||
H5Eset_auto (NULL, NULL);
|
||
dataset = H5Dcreate(file, DSET_DEFAULT_NAME, H5T_NATIVE_DOUBLE, space,
|
||
H5P_DEFAULT);
|
||
H5Eset_auto (func, client_data);
|
||
if (dataset >= 0) {
|
||
puts("*FAILED*");
|
||
printf(" Library allowed overwrite of existing dataset.\n");
|
||
goto error;
|
||
}
|
||
|
||
/*
|
||
* Open the dataset we created above and then close it. This is how
|
||
* existing datasets are accessed.
|
||
*/
|
||
if ((dataset = H5Dopen(file, DSET_DEFAULT_NAME))<0) goto error;
|
||
if (H5Dclose(dataset) < 0) goto error;
|
||
|
||
/*
|
||
* Try opening a non-existent dataset. This should fail since new datasets
|
||
* cannot be created with this function. Temporarily turn off error
|
||
* reporting.
|
||
*/
|
||
H5Eget_auto (&func, &client_data);
|
||
H5Eset_auto (NULL, NULL);
|
||
dataset = H5Dopen(file, "does_not_exist");
|
||
H5Eset_auto (func, client_data);
|
||
if (dataset >= 0) {
|
||
puts("*FAILED*");
|
||
printf(" Opened a non-existent dataset.\n");
|
||
goto error;
|
||
}
|
||
|
||
/*
|
||
* Create a new dataset that uses chunked storage instead of the default
|
||
* layout.
|
||
*/
|
||
create_parms = H5Pcreate(H5P_DATASET_CREATE);
|
||
assert(create_parms >= 0);
|
||
csize[0] = 5;
|
||
csize[1] = 100;
|
||
status = H5Pset_chunk(create_parms, 2, csize);
|
||
assert(status >= 0);
|
||
|
||
dataset = H5Dcreate(file, DSET_CHUNKED_NAME, H5T_NATIVE_DOUBLE, space,
|
||
create_parms);
|
||
if (dataset < 0) goto error;
|
||
|
||
/*
|
||
* Close the chunked dataset.
|
||
*/
|
||
if (H5Dclose(dataset) < 0) goto error;
|
||
|
||
puts(" PASSED");
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_simple_io
|
||
*
|
||
* Purpose: Tests simple I/O. That is, reading and writing a complete
|
||
* multi-dimensional array without data type or data space
|
||
* conversions, without compression, and stored contiguously.
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Wednesday, December 10, 1997
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_simple_io(hid_t file)
|
||
{
|
||
hid_t dataset, space, xfer;
|
||
herr_t status;
|
||
int points[100][200], check[100][200];
|
||
int i, j, n;
|
||
hsize_t dims[2];
|
||
void *tconv_buf = NULL;
|
||
|
||
printf("%-70s", "Testing simple I/O");
|
||
fflush (stdout);
|
||
|
||
/* Initialize the dataset */
|
||
for (i = n = 0; i < 100; i++) {
|
||
for (j = 0; j < 100; j++) {
|
||
points[i][j] = n++;
|
||
}
|
||
}
|
||
|
||
/* Create the data space */
|
||
dims[0] = 100;
|
||
dims[1] = 200;
|
||
space = H5Screate_simple(2, dims, NULL);
|
||
assert(space>=0);
|
||
|
||
/* Create a small conversion buffer to test strip mining */
|
||
tconv_buf = malloc (1000);
|
||
xfer = H5Pcreate (H5P_DATASET_XFER);
|
||
assert (xfer>=0);
|
||
status = H5Pset_buffer (xfer, 1000, tconv_buf, NULL);
|
||
assert (status>=0);
|
||
|
||
/* Create the dataset */
|
||
dataset = H5Dcreate(file, DSET_SIMPLE_IO_NAME, H5T_NATIVE_INT, space,
|
||
H5P_DEFAULT);
|
||
assert(dataset >= 0);
|
||
|
||
/* Write the data to the dataset */
|
||
status = H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
|
||
xfer, points);
|
||
if (status<0) goto error;
|
||
|
||
/* Read the dataset back */
|
||
status = H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
|
||
xfer, check);
|
||
if (status<0) goto error;
|
||
|
||
/* Check that the values read are the same as the values written */
|
||
for (i = 0; i < 100; i++) {
|
||
for (j = 0; j < 200; j++) {
|
||
if (points[i][j] != check[i][j]) {
|
||
puts("*FAILED*");
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %d,%d\n", i, j);
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
|
||
H5Dclose(dataset);
|
||
|
||
puts(" PASSED");
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_tconv
|
||
*
|
||
* Purpose: Test some simple data type conversion stuff.
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Wednesday, January 14, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_tconv(hid_t file)
|
||
{
|
||
char *out=NULL, *in=NULL;
|
||
int i;
|
||
hsize_t dims[1];
|
||
hid_t space, dataset, type;
|
||
herr_t status;
|
||
|
||
out = malloc (4*1000000);
|
||
assert (out);
|
||
in = malloc (4*1000000);
|
||
assert (in);
|
||
|
||
printf("%-70s", "Testing data type conversion");
|
||
fflush (stdout);
|
||
|
||
/* Initialize the dataset */
|
||
for (i = 0; i < 1000000; i++) {
|
||
out[i*4+0] = 0x11;
|
||
out[i*4+1] = 0x22;
|
||
out[i*4+2] = 0x33;
|
||
out[i*4+3] = 0x44;
|
||
}
|
||
|
||
/* Create the data space */
|
||
dims[0] = 1000000;
|
||
space = H5Screate_simple (1, dims, NULL);
|
||
assert(space >= 0);
|
||
|
||
/* Create the data set */
|
||
dataset = H5Dcreate(file, DSET_TCONV_NAME, H5T_NATIVE_INT32, space,
|
||
H5P_DEFAULT);
|
||
assert(dataset >= 0);
|
||
|
||
/* Write the data to the dataset */
|
||
status = H5Dwrite(dataset, H5T_NATIVE_INT32, H5S_ALL, H5S_ALL,
|
||
H5P_DEFAULT, out);
|
||
assert(status >= 0);
|
||
|
||
/* Create a new type with the opposite byte order */
|
||
type = H5Tcopy(H5T_NATIVE_INT32);
|
||
switch (H5Tget_order(type)) {
|
||
case H5T_ORDER_BE:
|
||
H5Tset_order(type, H5T_ORDER_LE);
|
||
break;
|
||
case H5T_ORDER_LE:
|
||
H5Tset_order(type, H5T_ORDER_BE);
|
||
break;
|
||
default:
|
||
assert("funny byte order" && 0);
|
||
break;
|
||
}
|
||
|
||
/* Read data with byte order conversion */
|
||
status = H5Dread(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, in);
|
||
assert(status >= 0);
|
||
|
||
/* Check */
|
||
for (i = 0; i < 1000000; i++) {
|
||
assert(in[4 * i + 0] == out[4 * i + 3]);
|
||
assert(in[4 * i + 1] == out[4 * i + 2]);
|
||
assert(in[4 * i + 2] == out[4 * i + 1]);
|
||
assert(in[4 * i + 3] == out[4 * i + 0]);
|
||
}
|
||
|
||
H5Dclose(dataset);
|
||
H5Tclose(type);
|
||
|
||
puts(" PASSED");
|
||
return 0;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: bogus
|
||
*
|
||
* Purpose: A bogus compression method.
|
||
*
|
||
* Return: Success: SRC_NBYTES, see compression documentation.
|
||
*
|
||
* Failure: 0
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Tuesday, April 21, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static size_t
|
||
bogus (unsigned int __unused__ flags, size_t __unused__ cd_size,
|
||
const void __unused__ *client_data, size_t src_nbytes, const void *src,
|
||
size_t __unused__ dst_nbytes, void *dst/*out*/)
|
||
{
|
||
memcpy (dst, src, src_nbytes);
|
||
return src_nbytes;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_compression
|
||
*
|
||
* Purpose: Tests dataset compression.
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: -1
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Wednesday, April 15, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static herr_t
|
||
test_compression(hid_t file)
|
||
{
|
||
hid_t dataset, space, xfer, dc;
|
||
herr_t status;
|
||
int points[100][200], check[100][200];
|
||
const hsize_t size[2] = {100, 200};
|
||
const hsize_t chunk_size[2] = {2, 25};
|
||
const hssize_t hs_offset[2] = {7, 30};
|
||
const hsize_t hs_size[2] = {4, 50};
|
||
|
||
hsize_t i, j, n;
|
||
void *tconv_buf = NULL;
|
||
|
||
printf ("%-70s", "Testing compression (setup)");
|
||
fflush (stderr);
|
||
|
||
/* Create the data space */
|
||
space = H5Screate_simple(2, size, NULL);
|
||
assert(space>=0);
|
||
|
||
/*
|
||
* Create a small conversion buffer to test strip mining. We
|
||
* might as well test all we can!
|
||
*/
|
||
xfer = H5Pcreate (H5P_DATASET_XFER);
|
||
assert (xfer>=0);
|
||
tconv_buf = malloc (1000);
|
||
status = H5Pset_buffer (xfer, 1000, tconv_buf, NULL);
|
||
assert (status>=0);
|
||
|
||
/* Use chunked storage with compression */
|
||
dc = H5Pcreate (H5P_DATASET_CREATE);
|
||
H5Pset_chunk (dc, 2, chunk_size);
|
||
H5Pset_deflate (dc, 6);
|
||
|
||
/* Create the dataset */
|
||
dataset = H5Dcreate(file, DSET_COMPRESS_NAME, H5T_NATIVE_INT, space, dc);
|
||
assert(dataset >= 0);
|
||
puts (" PASSED");
|
||
|
||
/*----------------------------------------------------------------------
|
||
* STEP 1: Read uninitialized data. It should be zero.
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
printf ("%-70s", "Testing compression (uninitialized read)");
|
||
fflush (stdout);
|
||
|
||
status = H5Dread (dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
|
||
xfer, check);
|
||
if (status<0) goto error;
|
||
|
||
for (i=0; i<size[0]; i++) {
|
||
for (j=0; j<size[1]; j++) {
|
||
if (0!=check[i][j]) {
|
||
puts("*FAILED*");
|
||
printf(" Read a non-zero value.\n");
|
||
printf(" At index %lu,%lu\n",
|
||
(unsigned long)i, (unsigned long)j);
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
puts (" PASSED");
|
||
|
||
/*----------------------------------------------------------------------
|
||
* STEP 2: Test compression by setting up a chunked dataset and writing
|
||
* to it.
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
printf("%-70s", "Testing compression (write)");
|
||
fflush (stdout);
|
||
|
||
for (i=n=0; i<size[0]; i++) {
|
||
for (j=0; j<size[1]; j++) {
|
||
points[i][j] = n++;
|
||
}
|
||
}
|
||
|
||
status = H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
|
||
xfer, points);
|
||
if (status<0) goto error;
|
||
puts (" PASSED");
|
||
|
||
/*----------------------------------------------------------------------
|
||
* STEP 3: Try to read the data we just wrote.
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
printf ("%-70s", "Testing compression (read)");
|
||
fflush (stdout);
|
||
|
||
/* Read the dataset back */
|
||
status = H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
|
||
xfer, check);
|
||
if (status<0) goto error;
|
||
|
||
/* Check that the values read are the same as the values written */
|
||
for (i=0; i<size[0]; i++) {
|
||
for (j=0; j<size[1]; j++) {
|
||
if (points[i][j] != check[i][j]) {
|
||
puts("*FAILED*");
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %lu,%lu\n",
|
||
(unsigned long)i, (unsigned long)j);
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
puts (" PASSED");
|
||
|
||
/*----------------------------------------------------------------------
|
||
* STEP 4: Write new data over the top of the old data. The new data is
|
||
* random thus not very compressible, and will cause the chunks to move
|
||
* around as they grow. We only change values for the left half of the
|
||
* dataset although we rewrite the whole thing.
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
printf ("%-70s", "Testing compression (modify)");
|
||
fflush (stdout);
|
||
|
||
for (i=0; i<size[0]; i++) {
|
||
for (j=0; j<size[1]/2; j++) {
|
||
points[i][j] = rand ();
|
||
}
|
||
}
|
||
status = H5Dwrite (dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
|
||
xfer, points);
|
||
if (status<0) goto error;
|
||
|
||
|
||
/* Read the dataset back and check it */
|
||
status = H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
|
||
xfer, check);
|
||
if (status<0) goto error;
|
||
|
||
/* Check that the values read are the same as the values written */
|
||
for (i=0; i<size[0]; i++) {
|
||
for (j=0; j<size[1]; j++) {
|
||
if (points[i][j] != check[i][j]) {
|
||
puts("*FAILED*");
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %lu,%lu\n",
|
||
(unsigned long)i, (unsigned long)j);
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
puts (" PASSED");
|
||
|
||
/*----------------------------------------------------------------------
|
||
* STEP 5: Close the dataset and then open it and read it again. This
|
||
* insures that the compression message is picked up properly from the
|
||
* object header.
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
printf ("%-70s", "Testing compression (re-open)");
|
||
fflush (stdout);
|
||
|
||
H5Dclose (dataset);
|
||
dataset = H5Dopen (file, DSET_COMPRESS_NAME);
|
||
status = H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
|
||
xfer, check);
|
||
if (status<0) goto error;
|
||
|
||
/* Check that the values read are the same as the values written */
|
||
for (i=0; i<size[0]; i++) {
|
||
for (j=0; j<size[1]; j++) {
|
||
if (points[i][j] != check[i][j]) {
|
||
puts("*FAILED*");
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %lu,%lu\n",
|
||
(unsigned long)i, (unsigned long)j);
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
puts (" PASSED");
|
||
|
||
|
||
/*----------------------------------------------------------------------
|
||
* STEP 6: Test partial I/O by writing to and then reading from a
|
||
* hyperslab of the dataset. The hyperslab does not line up on chunk
|
||
* boundaries (we know that case already works from above tests).
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
printf ("%-70s", "Testing compression (partial I/O)");
|
||
fflush (stderr);
|
||
|
||
for (i=0; i<hs_size[0]; i++) {
|
||
for (j=0; j<hs_size[1]; j++) {
|
||
points[hs_offset[0]+i][hs_offset[1]+j] = rand ();
|
||
}
|
||
}
|
||
H5Sset_hyperslab (space, hs_offset, hs_size, NULL);
|
||
|
||
status = H5Dwrite (dataset, H5T_NATIVE_INT, space, space, xfer, points);
|
||
if (status<0) goto error;
|
||
status = H5Dread (dataset, H5T_NATIVE_INT, space, space, xfer, check);
|
||
if (status<0) goto error;
|
||
|
||
/* Check that the values read are the same as the values written */
|
||
for (i=0; i<hs_size[0]; i++) {
|
||
for (j=0; j<hs_size[1]; j++) {
|
||
if (points[hs_offset[0]+i][hs_offset[1]+j] !=
|
||
check[hs_offset[0]+i][hs_offset[1]+j]) {
|
||
puts("*FAILED*");
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %lu,%lu\n",
|
||
(unsigned long)(hs_offset[0]+i),
|
||
(unsigned long)(hs_offset[1]+j));
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
puts (" PASSED");
|
||
|
||
/*----------------------------------------------------------------------
|
||
* STEP 7: Register an application-defined compression method and use it
|
||
* to write and then read the dataset.
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
printf ("%-70s", "Testing compression (app-defined method)");
|
||
fflush (stdout);
|
||
|
||
H5Zregister (H5Z_BOGUS, "bogus", bogus, bogus);
|
||
H5Pset_compression (dc, H5Z_BOGUS, 0, 0, NULL);
|
||
H5Dclose (dataset);
|
||
H5Sclose (space);
|
||
space = H5Screate_simple (2, size, NULL);
|
||
dataset = H5Dcreate (file, DSET_BOGUS_NAME, H5T_NATIVE_INT, space, dc);
|
||
assert (dataset>=0);
|
||
|
||
status = H5Dwrite (dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
|
||
xfer, points);
|
||
if (status<0) goto error;
|
||
status = H5Dread (dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
|
||
xfer, check);
|
||
if (status<0) goto error;
|
||
|
||
for (i=0; i<size[0]; i++) {
|
||
for (j=0; j<size[1]; j++) {
|
||
if (points[i][j] != check[i][j]) {
|
||
puts("*FAILED*");
|
||
printf(" Read different values than written.\n");
|
||
printf(" At index %lu,%lu\n",
|
||
(unsigned long)i, (unsigned long)j);
|
||
goto error;
|
||
}
|
||
}
|
||
}
|
||
puts (" PASSED");
|
||
|
||
|
||
|
||
/*----------------------------------------------------------------------
|
||
* Cleanup
|
||
*----------------------------------------------------------------------
|
||
*/
|
||
H5Dclose(dataset);
|
||
return 0;
|
||
|
||
error:
|
||
return -1;
|
||
}
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: main
|
||
*
|
||
* Purpose: Tests the dataset interface (H5D)
|
||
*
|
||
* Return: Success: exit(0)
|
||
*
|
||
* Failure: exit(1)
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Tuesday, December 9, 1997
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
int
|
||
main(void)
|
||
{
|
||
hid_t file, grp;
|
||
herr_t status;
|
||
int nerrors = 0;
|
||
|
||
status = H5open ();
|
||
assert (status>=0);
|
||
|
||
/* Automatic error reporting to standard output */
|
||
H5Eset_auto (display_error_cb, NULL);
|
||
|
||
unlink("dataset.h5");
|
||
file = H5Fcreate("dataset.h5", H5F_ACC_TRUNC|H5F_ACC_DEBUG,
|
||
H5P_DEFAULT, H5P_DEFAULT);
|
||
assert(file >= 0);
|
||
|
||
/* Cause the library to emit initial messages */
|
||
grp = H5Gcreate (file, "emit diagnostics", 0);
|
||
H5Gclose (grp);
|
||
|
||
|
||
status = test_create(file);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
|
||
status = test_simple_io(file);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
|
||
status = test_tconv(file);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
|
||
status = test_compression(file);
|
||
nerrors += status < 0 ? 1 : 0;
|
||
|
||
status = H5Fclose(file);
|
||
|
||
if (nerrors) {
|
||
printf("***** %d DATASET TEST%s FAILED! *****\n",
|
||
nerrors, 1 == nerrors ? "" : "S");
|
||
exit(1);
|
||
}
|
||
printf("All dataset tests passed.\n");
|
||
|
||
status = H5close ();
|
||
assert (status>=0);
|
||
|
||
return 0;
|
||
}
|