1997-12-11 06:41:56 +08:00
|
|
|
|
/*
|
|
|
|
|
* Copyright (C) 1997 NCSA
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* All rights reserved.
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Programmer: Robb Matzke <matzke@llnl.gov>
|
|
|
|
|
* Tuesday, December 9, 1997
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Purpose: Tests the dataset interface (H5D)
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*/
|
|
|
|
|
#include <assert.h>
|
|
|
|
|
#include <hdf5.h>
|
|
|
|
|
#include <math.h>
|
|
|
|
|
#include <stdio.h>
|
1998-03-01 02:19:05 +08:00
|
|
|
|
#include <stdlib.h>
|
1998-04-28 21:59:08 +08:00
|
|
|
|
#include <string.h>
|
1997-12-11 06:41:56 +08:00
|
|
|
|
#include <unistd.h>
|
|
|
|
|
|
1998-04-07 23:34:16 +08:00
|
|
|
|
#include <H5config.h>
|
|
|
|
|
#ifndef HAVE_ATTRIBUTE
|
|
|
|
|
# undef __attribute__
|
|
|
|
|
# define __attribute__(X) /*void*/
|
1998-04-09 05:43:02 +08:00
|
|
|
|
# define __unused__ /*void*/
|
|
|
|
|
#else
|
|
|
|
|
# define __unused__ __attribute__((unused))
|
1998-04-07 23:34:16 +08:00
|
|
|
|
#endif
|
|
|
|
|
|
1997-12-17 05:08:59 +08:00
|
|
|
|
#ifndef HAVE_FUNCTION
|
1998-04-07 23:34:16 +08:00
|
|
|
|
# undef __FUNCTION__
|
|
|
|
|
# define __FUNCTION__ ""
|
1997-12-17 05:08:59 +08:00
|
|
|
|
#endif
|
1998-04-07 23:34:16 +08:00
|
|
|
|
|
1998-03-06 05:27:38 +08:00
|
|
|
|
#define AT() printf (" at %s:%d in %s()...\n", \
|
|
|
|
|
__FILE__, __LINE__, __FUNCTION__);
|
|
|
|
|
|
1998-05-29 07:02:29 +08:00
|
|
|
|
#define TEST_FILE_NAME "dataset.h5"
|
1998-03-06 05:27:38 +08:00
|
|
|
|
#define DSET_DEFAULT_NAME "default"
|
|
|
|
|
#define DSET_CHUNKED_NAME "chunked"
|
|
|
|
|
#define DSET_SIMPLE_IO_NAME "simple_io"
|
|
|
|
|
#define DSET_TCONV_NAME "tconv"
|
1998-04-18 05:29:43 +08:00
|
|
|
|
#define DSET_COMPRESS_NAME "compressed"
|
1998-04-22 04:32:07 +08:00
|
|
|
|
#define DSET_BOGUS_NAME "bogus"
|
|
|
|
|
|
|
|
|
|
#define H5Z_BOGUS 255
|
1998-03-06 05:27:38 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* 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
|
1998-04-09 05:43:02 +08:00
|
|
|
|
display_error_cb (void __unused__ *client_data)
|
1998-03-06 05:27:38 +08:00
|
|
|
|
{
|
|
|
|
|
puts ("*FAILED*");
|
|
|
|
|
H5Eprint (stdout);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
1997-12-11 06:41:56 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Function: test_create
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Purpose: Attempts to create a dataset.
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Return: Success: 0
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Failure: -1
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Tuesday, December 9, 1997
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static herr_t
|
1998-01-17 06:23:43 +08:00
|
|
|
|
test_create(hid_t file)
|
1997-12-11 06:41:56 +08:00
|
|
|
|
{
|
1998-03-06 05:27:38 +08:00
|
|
|
|
hid_t dataset, space, create_parms;
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hsize_t dims[2];
|
1998-03-06 05:27:38 +08:00
|
|
|
|
herr_t status;
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hsize_t csize[2];
|
1998-03-06 05:27:38 +08:00
|
|
|
|
herr_t (*func)(void*) = NULL;
|
|
|
|
|
void *client_data = NULL;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
printf("%-70s", "Testing create/open/close");
|
1998-04-18 05:29:43 +08:00
|
|
|
|
fflush (stdout);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Create the data space */
|
|
|
|
|
dims[0] = 256;
|
|
|
|
|
dims[1] = 512;
|
1998-02-26 02:48:33 +08:00
|
|
|
|
space = H5Screate_simple(2, dims, NULL);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
assert(space>=0);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Create a dataset using the default dataset creation properties. We're
|
1998-01-17 06:23:43 +08:00
|
|
|
|
* not sure what they are, so we won't check.
|
|
|
|
|
*/
|
|
|
|
|
dataset = H5Dcreate(file, DSET_DEFAULT_NAME, H5T_NATIVE_DOUBLE, space,
|
1998-03-06 05:27:38 +08:00
|
|
|
|
H5P_DEFAULT);
|
|
|
|
|
if (dataset<0) goto error;
|
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/* Close the dataset */
|
1998-03-06 05:27:38 +08:00
|
|
|
|
if (H5Dclose(dataset) < 0) goto error;
|
1998-03-01 02:19:05 +08:00
|
|
|
|
|
1998-07-21 05:01:32 +08:00
|
|
|
|
/* Add a comment to the dataset */
|
|
|
|
|
status = H5Gset_comment(file, DSET_DEFAULT_NAME, "This is a dataset");
|
|
|
|
|
if (status<0) goto error;
|
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/*
|
|
|
|
|
* Try creating a dataset that already exists. This should fail since a
|
1998-03-01 02:19:05 +08:00
|
|
|
|
* dataset can only be created once. Temporarily turn off error
|
|
|
|
|
* reporting.
|
1998-01-17 06:23:43 +08:00
|
|
|
|
*/
|
1998-03-06 05:27:38 +08:00
|
|
|
|
H5Eget_auto (&func, &client_data);
|
1998-03-01 02:19:05 +08:00
|
|
|
|
H5Eset_auto (NULL, NULL);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
dataset = H5Dcreate(file, DSET_DEFAULT_NAME, H5T_NATIVE_DOUBLE, space,
|
1998-03-06 05:27:38 +08:00
|
|
|
|
H5P_DEFAULT);
|
|
|
|
|
H5Eset_auto (func, client_data);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
if (dataset >= 0) {
|
1998-03-06 05:27:38 +08:00
|
|
|
|
puts("*FAILED*");
|
|
|
|
|
printf(" Library allowed overwrite of existing dataset.\n");
|
|
|
|
|
goto error;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
1998-03-01 02:19:05 +08:00
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/*
|
|
|
|
|
* Open the dataset we created above and then close it. This is how
|
|
|
|
|
* existing datasets are accessed.
|
|
|
|
|
*/
|
1998-03-06 05:27:38 +08:00
|
|
|
|
if ((dataset = H5Dopen(file, DSET_DEFAULT_NAME))<0) goto error;
|
|
|
|
|
if (H5Dclose(dataset) < 0) goto error;
|
1998-03-01 02:19:05 +08:00
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/*
|
|
|
|
|
* Try opening a non-existent dataset. This should fail since new datasets
|
1998-03-01 02:19:05 +08:00
|
|
|
|
* cannot be created with this function. Temporarily turn off error
|
|
|
|
|
* reporting.
|
1998-01-17 06:23:43 +08:00
|
|
|
|
*/
|
1998-03-06 05:27:38 +08:00
|
|
|
|
H5Eget_auto (&func, &client_data);
|
1998-03-01 02:19:05 +08:00
|
|
|
|
H5Eset_auto (NULL, NULL);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
dataset = H5Dopen(file, "does_not_exist");
|
1998-03-06 05:27:38 +08:00
|
|
|
|
H5Eset_auto (func, client_data);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
if (dataset >= 0) {
|
1998-03-06 05:27:38 +08:00
|
|
|
|
puts("*FAILED*");
|
|
|
|
|
printf(" Opened a non-existent dataset.\n");
|
|
|
|
|
goto error;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
1998-03-06 05:27:38 +08:00
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/*
|
|
|
|
|
* Create a new dataset that uses chunked storage instead of the default
|
|
|
|
|
* layout.
|
|
|
|
|
*/
|
1998-02-26 03:13:49 +08:00
|
|
|
|
create_parms = H5Pcreate(H5P_DATASET_CREATE);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
assert(create_parms >= 0);
|
|
|
|
|
csize[0] = 5;
|
|
|
|
|
csize[1] = 100;
|
1998-02-26 03:13:49 +08:00
|
|
|
|
status = H5Pset_chunk(create_parms, 2, csize);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
assert(status >= 0);
|
|
|
|
|
|
|
|
|
|
dataset = H5Dcreate(file, DSET_CHUNKED_NAME, H5T_NATIVE_DOUBLE, space,
|
1998-03-06 05:27:38 +08:00
|
|
|
|
create_parms);
|
|
|
|
|
if (dataset < 0) goto error;
|
1998-05-01 13:16:50 +08:00
|
|
|
|
H5Pclose (create_parms);
|
1998-03-06 05:27:38 +08:00
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/*
|
|
|
|
|
* Close the chunked dataset.
|
|
|
|
|
*/
|
1998-03-06 05:27:38 +08:00
|
|
|
|
if (H5Dclose(dataset) < 0) goto error;
|
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
puts(" PASSED");
|
1998-03-05 00:20:23 +08:00
|
|
|
|
return 0;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
1998-03-06 05:27:38 +08:00
|
|
|
|
error:
|
1998-03-05 00:20:23 +08:00
|
|
|
|
return -1;
|
1997-12-11 06:41:56 +08:00
|
|
|
|
}
|
1998-03-06 05:27:38 +08:00
|
|
|
|
|
1997-12-11 06:41:56 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Function: test_simple_io
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* 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.
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Return: Success: 0
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Failure: -1
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Wednesday, December 10, 1997
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static herr_t
|
1998-01-17 06:23:43 +08:00
|
|
|
|
test_simple_io(hid_t file)
|
1997-12-11 06:41:56 +08:00
|
|
|
|
{
|
1998-03-17 09:29:54 +08:00
|
|
|
|
hid_t dataset, space, xfer;
|
|
|
|
|
herr_t status;
|
|
|
|
|
int points[100][200], check[100][200];
|
|
|
|
|
int i, j, n;
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hsize_t dims[2];
|
1998-03-17 09:29:54 +08:00
|
|
|
|
void *tconv_buf = NULL;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
printf("%-70s", "Testing simple I/O");
|
1998-04-18 05:29:43 +08:00
|
|
|
|
fflush (stdout);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Initialize the dataset */
|
|
|
|
|
for (i = n = 0; i < 100; i++) {
|
1998-03-06 05:27:38 +08:00
|
|
|
|
for (j = 0; j < 100; j++) {
|
|
|
|
|
points[i][j] = n++;
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Create the data space */
|
|
|
|
|
dims[0] = 100;
|
|
|
|
|
dims[1] = 200;
|
1998-02-26 02:48:33 +08:00
|
|
|
|
space = H5Screate_simple(2, dims, NULL);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
assert(space>=0);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
1998-03-17 09:29:54 +08:00
|
|
|
|
/* 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);
|
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/* Create the dataset */
|
|
|
|
|
dataset = H5Dcreate(file, DSET_SIMPLE_IO_NAME, H5T_NATIVE_INT, space,
|
1998-03-06 05:27:38 +08:00
|
|
|
|
H5P_DEFAULT);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
assert(dataset >= 0);
|
|
|
|
|
|
|
|
|
|
/* Write the data to the dataset */
|
1998-02-26 02:48:33 +08:00
|
|
|
|
status = H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
|
1998-03-17 09:29:54 +08:00
|
|
|
|
xfer, points);
|
1998-03-06 05:27:38 +08:00
|
|
|
|
if (status<0) goto error;
|
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/* Read the dataset back */
|
1998-02-26 02:48:33 +08:00
|
|
|
|
status = H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
|
1998-03-17 09:29:54 +08:00
|
|
|
|
xfer, check);
|
1998-03-06 05:27:38 +08:00
|
|
|
|
if (status<0) goto error;
|
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/* Check that the values read are the same as the values written */
|
|
|
|
|
for (i = 0; i < 100; i++) {
|
1998-03-06 05:27:38 +08:00
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
|
1998-05-01 13:16:50 +08:00
|
|
|
|
H5Pclose (xfer);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
H5Dclose(dataset);
|
1998-05-01 13:16:50 +08:00
|
|
|
|
free (tconv_buf);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
puts(" PASSED");
|
1998-03-05 00:20:23 +08:00
|
|
|
|
return 0;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
error:
|
1998-03-05 00:20:23 +08:00
|
|
|
|
return -1;
|
1997-12-11 06:41:56 +08:00
|
|
|
|
}
|
1998-01-15 03:42:59 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Function: test_tconv
|
1998-01-15 03:42:59 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Purpose: Test some simple data type conversion stuff.
|
1998-01-15 03:42:59 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Return: Success: 0
|
1998-01-15 03:42:59 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Failure: -1
|
1998-01-15 03:42:59 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Wednesday, January 14, 1998
|
1998-01-15 03:42:59 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static herr_t
|
1998-01-17 06:23:43 +08:00
|
|
|
|
test_tconv(hid_t file)
|
1998-01-15 03:42:59 +08:00
|
|
|
|
{
|
1998-03-05 00:20:23 +08:00
|
|
|
|
char *out=NULL, *in=NULL;
|
|
|
|
|
int i;
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hsize_t dims[1];
|
1998-06-19 05:03:30 +08:00
|
|
|
|
hid_t space, dataset;
|
1998-02-13 00:39:09 +08:00
|
|
|
|
herr_t status;
|
|
|
|
|
|
|
|
|
|
out = malloc (4*1000000);
|
|
|
|
|
assert (out);
|
|
|
|
|
in = malloc (4*1000000);
|
|
|
|
|
assert (in);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
printf("%-70s", "Testing data type conversion");
|
1998-04-18 05:29:43 +08:00
|
|
|
|
fflush (stdout);
|
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
/* Initialize the dataset */
|
1998-03-05 00:20:23 +08:00
|
|
|
|
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;
|
|
|
|
|
}
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Create the data space */
|
|
|
|
|
dims[0] = 1000000;
|
1998-02-26 02:48:33 +08:00
|
|
|
|
space = H5Screate_simple (1, dims, NULL);
|
1998-03-05 00:20:23 +08:00
|
|
|
|
assert(space >= 0);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
/* Create the data set */
|
1998-06-19 05:03:30 +08:00
|
|
|
|
dataset = H5Dcreate(file, DSET_TCONV_NAME, H5T_STD_I32LE, space,
|
1998-03-06 05:27:38 +08:00
|
|
|
|
H5P_DEFAULT);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
assert(dataset >= 0);
|
|
|
|
|
|
|
|
|
|
/* Write the data to the dataset */
|
1998-06-19 05:03:30 +08:00
|
|
|
|
status = H5Dwrite(dataset, H5T_STD_I32LE, H5S_ALL, H5S_ALL,
|
1998-03-06 05:27:38 +08:00
|
|
|
|
H5P_DEFAULT, out);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
assert(status >= 0);
|
|
|
|
|
|
|
|
|
|
/* Read data with byte order conversion */
|
1998-06-19 05:03:30 +08:00
|
|
|
|
status = H5Dread(dataset, H5T_STD_I32BE, H5S_ALL, H5S_ALL,
|
|
|
|
|
H5P_DEFAULT, in);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
assert(status >= 0);
|
|
|
|
|
|
|
|
|
|
/* Check */
|
|
|
|
|
for (i = 0; i < 1000000; i++) {
|
1998-03-06 05:27:38 +08:00
|
|
|
|
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]);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
H5Dclose(dataset);
|
1998-05-01 13:16:50 +08:00
|
|
|
|
free (out);
|
|
|
|
|
free (in);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
|
|
|
|
puts(" PASSED");
|
1998-03-05 00:20:23 +08:00
|
|
|
|
return 0;
|
1998-01-15 03:42:59 +08:00
|
|
|
|
}
|
1998-04-18 05:29:43 +08:00
|
|
|
|
|
1998-04-22 04:32:07 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* 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
|
1998-04-23 01:26:01 +08:00
|
|
|
|
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*/)
|
1998-04-22 04:32:07 +08:00
|
|
|
|
{
|
|
|
|
|
memcpy (dst, src, src_nbytes);
|
|
|
|
|
return src_nbytes;
|
|
|
|
|
}
|
|
|
|
|
|
1998-04-18 05:29:43 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* 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];
|
1998-04-22 04:32:07 +08:00
|
|
|
|
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;
|
1998-04-18 05:29:43 +08:00
|
|
|
|
void *tconv_buf = NULL;
|
|
|
|
|
|
1998-04-22 04:32:07 +08:00
|
|
|
|
printf ("%-70s", "Testing compression (setup)");
|
|
|
|
|
fflush (stderr);
|
1998-04-18 05:29:43 +08:00
|
|
|
|
|
|
|
|
|
/* Create the data space */
|
1998-04-22 04:32:07 +08:00
|
|
|
|
space = H5Screate_simple(2, size, NULL);
|
1998-04-18 05:29:43 +08:00
|
|
|
|
assert(space>=0);
|
|
|
|
|
|
1998-04-23 01:26:01 +08:00
|
|
|
|
/*
|
|
|
|
|
* Create a small conversion buffer to test strip mining. We
|
|
|
|
|
* might as well test all we can!
|
|
|
|
|
*/
|
1998-04-18 05:29:43 +08:00
|
|
|
|
xfer = H5Pcreate (H5P_DATASET_XFER);
|
|
|
|
|
assert (xfer>=0);
|
1998-04-22 04:32:07 +08:00
|
|
|
|
tconv_buf = malloc (1000);
|
1998-04-18 05:29:43 +08:00
|
|
|
|
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);
|
1998-04-22 04:32:07 +08:00
|
|
|
|
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++;
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-04-18 05:29:43 +08:00
|
|
|
|
|
|
|
|
|
status = H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL,
|
|
|
|
|
xfer, points);
|
|
|
|
|
if (status<0) goto error;
|
1998-04-22 04:32:07 +08:00
|
|
|
|
puts (" PASSED");
|
|
|
|
|
|
|
|
|
|
/*----------------------------------------------------------------------
|
|
|
|
|
* STEP 3: Try to read the data we just wrote.
|
|
|
|
|
*----------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
printf ("%-70s", "Testing compression (read)");
|
|
|
|
|
fflush (stdout);
|
1998-04-18 05:29:43 +08:00
|
|
|
|
|
|
|
|
|
/* 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 */
|
1998-04-22 04:32:07 +08:00
|
|
|
|
for (i=0; i<size[0]; i++) {
|
|
|
|
|
for (j=0; j<size[1]; j++) {
|
1998-04-18 05:29:43 +08:00
|
|
|
|
if (points[i][j] != check[i][j]) {
|
|
|
|
|
puts("*FAILED*");
|
|
|
|
|
printf(" Read different values than written.\n");
|
1998-04-22 04:32:07 +08:00
|
|
|
|
printf(" At index %lu,%lu\n",
|
|
|
|
|
(unsigned long)i, (unsigned long)j);
|
1998-04-18 05:29:43 +08:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-04-22 04:32:07 +08:00
|
|
|
|
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.
|
|
|
|
|
*----------------------------------------------------------------------
|
1998-04-18 05:29:43 +08:00
|
|
|
|
*/
|
1998-04-22 04:32:07 +08:00
|
|
|
|
printf ("%-70s", "Testing compression (modify)");
|
|
|
|
|
fflush (stdout);
|
|
|
|
|
|
|
|
|
|
for (i=0; i<size[0]; i++) {
|
|
|
|
|
for (j=0; j<size[1]/2; j++) {
|
1998-04-18 05:29:43 +08:00
|
|
|
|
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 */
|
1998-04-22 04:32:07 +08:00
|
|
|
|
for (i=0; i<size[0]; i++) {
|
|
|
|
|
for (j=0; j<size[1]; j++) {
|
1998-04-18 05:29:43 +08:00
|
|
|
|
if (points[i][j] != check[i][j]) {
|
|
|
|
|
puts("*FAILED*");
|
|
|
|
|
printf(" Read different values than written.\n");
|
1998-04-22 04:32:07 +08:00
|
|
|
|
printf(" At index %lu,%lu\n",
|
|
|
|
|
(unsigned long)i, (unsigned long)j);
|
1998-04-18 05:29:43 +08:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-04-22 04:32:07 +08:00
|
|
|
|
puts (" PASSED");
|
1998-04-18 05:29:43 +08:00
|
|
|
|
|
1998-04-22 04:32:07 +08:00
|
|
|
|
/*----------------------------------------------------------------------
|
|
|
|
|
* 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);
|
1998-04-18 05:29:43 +08:00
|
|
|
|
|
1998-04-22 04:32:07 +08:00
|
|
|
|
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 ();
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-07-07 05:01:59 +08:00
|
|
|
|
H5Sselect_hyperslab (space, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL);
|
1998-04-22 04:32:07 +08:00
|
|
|
|
|
|
|
|
|
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;
|
1998-04-18 05:29:43 +08:00
|
|
|
|
|
1998-04-22 04:32:07 +08:00
|
|
|
|
/* 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));
|
1998-07-07 05:01:59 +08:00
|
|
|
|
printf(" At original: %d\n", (int)points[hs_offset[0]+i][hs_offset[1]+j]);
|
|
|
|
|
printf(" At returned: %d\n", (int)check[hs_offset[0]+i][hs_offset[1]+j]);
|
1998-04-22 04:32:07 +08:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
puts (" PASSED");
|
1998-04-18 05:29:43 +08:00
|
|
|
|
|
1998-04-22 04:32:07 +08:00
|
|
|
|
/*----------------------------------------------------------------------
|
|
|
|
|
* 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);
|
1998-04-18 05:29:43 +08:00
|
|
|
|
|
1998-04-22 04:32:07 +08:00
|
|
|
|
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
|
|
|
|
|
*----------------------------------------------------------------------
|
|
|
|
|
*/
|
1998-05-01 13:16:50 +08:00
|
|
|
|
H5Pclose (xfer);
|
|
|
|
|
H5Pclose (dc);
|
1998-04-22 04:32:07 +08:00
|
|
|
|
H5Dclose(dataset);
|
1998-05-01 13:16:50 +08:00
|
|
|
|
free (tconv_buf);
|
1998-04-18 05:29:43 +08:00
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
1998-06-10 22:43:15 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: test_multiopen
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Tests that a bug no longer exists. If a dataset is opened
|
|
|
|
|
* twice and one of the handles is used to extend the dataset,
|
|
|
|
|
* then the other handle should return the new size when
|
|
|
|
|
* queried.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: 0
|
|
|
|
|
*
|
|
|
|
|
* Failure: -1
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Tuesday, June 9, 1998
|
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static herr_t
|
|
|
|
|
test_multiopen (hid_t file)
|
|
|
|
|
{
|
[svn-r429] Changes since 19980616
----------------------
./html/tracing.html NEW
This entire update is to make it possible for the library to
print the name, arguments, and return value of every API call
without requiring any extra work from developers or app
programmers. This file describes how this all works.
./configure.in
Added the `--enable-tracing' switch. If you use it then the
library will include code to print API function names,
argument names and values, and function return values.
However, you must then turn on the tracing by setting the
HDF5_TRACE environment variable to a file descriptor number.
The default is `--disable-tracing' since enabling it causes a
slight increase in library size and a slowdown resulting from
an extra function call for each API function call (I couldn't
even measure the slowdown :-)
./bin/trace NEW
A perl script that synchronizes the H5TRACE() macro calls in
the *.c files with the function return type and formal
argument names and types. If you use GNU make and gcc then
this will be done automatically, otherwise just invoke this
script with the names of one or more .c files. You could do
it by hand to, but encoding argument types is a little tricky
at first.
./config/commence.in
Added the $(TRACE) macro, which defaults to the no-op.
Added -D_POSIX_SOURCE to the compiler command line.
./src/Makefile.in
Override the default for $(TRACE).
./config/depend.in
Automatically calls $(TRACE) to synchronize the H5TRACE()
macros in any source file that changed. As with makefile
dependencies, one way to force synchronization of all files is
to remove the `.depend' file.
./MANIFEST
Added new files.
./src/H5Eprivate.h
Modified HRETURN_ERROR() and HRETURN() for tracing.
./src/H5.c
./src/H5private.h
This is where the real tracing work really happens, in
H5_trace().
./src/H5A.c
./src/H5D.c
./src/H5G.c
./src/H5P.c
./src/H5S.c
./src/H5Z.c
Added H5TRACE() calls to all API functions. You don't really
need these changes if you don't want to merge your stuff
because they can be generated automatically by going to the
hdf5/src directory and saying ../bin/trace *.c
./src/H5T.c
Added H5TRACE() calls. Other stuff below.
./src/H5E.c
./src/H5Epublic.h
Added H5TRACE() calls. Created a type H5E_auto_t for the
`func' argument of H5Eset_auto() and H5Eget_auto() to make
those arguments easier to parse for tracing. It should also
make it clearer for users that don't know how to read
complicated ANSI data types.
./src/H5F.c
Added H5TRACE() calls. Changed a couple `uintn' argument
types in API functions to `unsigned int' since `uintn' part of
the API. Changed a few "can't" and "cant" error messages to
"unable to".
./src/H5Ipublic.h
Removed H5_DIRECTORY from the H5I_group_t enum. It wasn't
used anywhere.
./src/H5Tconv.c
Removed an unused label.
./src/H5Fistore.c
./src/H5Oattr.c
./src/H5Odtype.c
./src/H5T.c
./test/dsets.c
./test/dtypes.c
Fixed a warning about a variable possibly used before it's
initialized. Added __unused__ to turn off some unused
argument warnings that pop up when debugging is turned off and
optimizations are turned on.
1998-06-18 04:46:29 +08:00
|
|
|
|
hid_t dcpl=-1, space=-1, dset1=-1, dset2=-1;
|
1998-06-10 22:43:15 +08:00
|
|
|
|
hsize_t cur_size[1] = {10};
|
|
|
|
|
static hsize_t max_size[1] = {H5S_UNLIMITED};
|
|
|
|
|
hsize_t tmp_size[1];
|
|
|
|
|
|
|
|
|
|
printf ("%-70s", "Testing multi-open with extending");
|
|
|
|
|
|
|
|
|
|
/* Create the dataset and open it twice */
|
|
|
|
|
if ((dcpl=H5Pcreate (H5P_DATASET_CREATE))<0) goto error;
|
|
|
|
|
if (H5Pset_chunk (dcpl, 1, cur_size)<0) goto error;
|
|
|
|
|
if ((space=H5Screate_simple (1, cur_size, max_size))<0) goto error;
|
|
|
|
|
if ((dset1=H5Dcreate (file, "multiopen", H5T_NATIVE_INT, space,
|
|
|
|
|
dcpl))<0) goto error;
|
|
|
|
|
if ((dset2=H5Dopen (file, "multiopen"))<0) goto error;
|
|
|
|
|
if (H5Sclose (space)<0) goto error;
|
|
|
|
|
|
|
|
|
|
/* Extend with the first handle */
|
|
|
|
|
cur_size[0] = 20;
|
|
|
|
|
if (H5Dextend (dset1, cur_size)<0) goto error;
|
|
|
|
|
|
|
|
|
|
/* Get the size from the second handle */
|
|
|
|
|
if ((space = H5Dget_space (dset2))<0) goto error;
|
1998-07-15 05:14:12 +08:00
|
|
|
|
if (H5Sextent_dims (space, tmp_size, NULL)<0) goto error;
|
1998-06-10 22:43:15 +08:00
|
|
|
|
if (cur_size[0]!=tmp_size[0]) {
|
|
|
|
|
puts ("*FAILED*");
|
|
|
|
|
printf (" Got %d instead of %d!\n",
|
|
|
|
|
(int)tmp_size[0], (int)cur_size[0]);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (H5Dclose (dset1)<0) goto error;
|
|
|
|
|
if (H5Dclose (dset2)<0) goto error;
|
|
|
|
|
if (H5Sclose (space)<0) goto error;
|
|
|
|
|
if (H5Pclose (dcpl)<0) goto error;
|
|
|
|
|
puts (" PASSED");
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
H5Dclose (dset1);
|
|
|
|
|
H5Dclose (dset2);
|
|
|
|
|
H5Sclose (space);
|
|
|
|
|
H5Pclose (dcpl);
|
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
1997-12-11 06:41:56 +08:00
|
|
|
|
|
1998-05-29 07:02:29 +08:00
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: cleanup
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Cleanup temporary test files
|
|
|
|
|
*
|
|
|
|
|
* Return: none
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Albert Cheng
|
|
|
|
|
* May 28, 1998
|
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static void
|
|
|
|
|
cleanup(void)
|
|
|
|
|
{
|
1998-06-06 05:03:49 +08:00
|
|
|
|
if (!getenv ("HDF5_NOCLEANUP")) {
|
|
|
|
|
remove(TEST_FILE_NAME);
|
|
|
|
|
}
|
1998-05-29 07:02:29 +08:00
|
|
|
|
}
|
1998-06-06 05:03:49 +08:00
|
|
|
|
|
1998-05-29 07:02:29 +08:00
|
|
|
|
|
1997-12-11 06:41:56 +08:00
|
|
|
|
/*-------------------------------------------------------------------------
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Function: main
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Purpose: Tests the dataset interface (H5D)
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Return: Success: exit(0)
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Failure: exit(1)
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
1998-03-06 05:27:38 +08:00
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Tuesday, December 9, 1997
|
1997-12-11 06:41:56 +08:00
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
int
|
1998-01-17 06:23:43 +08:00
|
|
|
|
main(void)
|
1997-12-11 06:41:56 +08:00
|
|
|
|
{
|
1998-04-18 05:29:43 +08:00
|
|
|
|
hid_t file, grp;
|
1998-03-06 05:27:38 +08:00
|
|
|
|
herr_t status;
|
|
|
|
|
int nerrors = 0;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
1998-01-31 03:25:44 +08:00
|
|
|
|
status = H5open ();
|
|
|
|
|
assert (status>=0);
|
|
|
|
|
|
1998-03-01 02:19:05 +08:00
|
|
|
|
/* Automatic error reporting to standard output */
|
1998-03-06 05:27:38 +08:00
|
|
|
|
H5Eset_auto (display_error_cb, NULL);
|
1998-03-01 02:19:05 +08:00
|
|
|
|
|
1998-05-29 07:02:29 +08:00
|
|
|
|
file = H5Fcreate(TEST_FILE_NAME, H5F_ACC_TRUNC|H5F_ACC_DEBUG,
|
1998-04-18 05:29:43 +08:00
|
|
|
|
H5P_DEFAULT, H5P_DEFAULT);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
assert(file >= 0);
|
|
|
|
|
|
1998-04-18 05:29:43 +08:00
|
|
|
|
/* Cause the library to emit initial messages */
|
|
|
|
|
grp = H5Gcreate (file, "emit diagnostics", 0);
|
1998-07-21 05:01:32 +08:00
|
|
|
|
H5Gset_comment(grp, ".", "Causes diagnostic messages to be emitted");
|
1998-04-18 05:29:43 +08:00
|
|
|
|
H5Gclose (grp);
|
1998-07-21 05:01:32 +08:00
|
|
|
|
|
1998-04-18 05:29:43 +08:00
|
|
|
|
|
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
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;
|
1998-04-18 05:29:43 +08:00
|
|
|
|
|
|
|
|
|
status = test_compression(file);
|
|
|
|
|
nerrors += status < 0 ? 1 : 0;
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
1998-06-10 22:43:15 +08:00
|
|
|
|
status = test_multiopen (file);
|
|
|
|
|
nerrors += status < 0 ? 1 : 0;
|
|
|
|
|
|
1998-01-17 06:23:43 +08:00
|
|
|
|
status = H5Fclose(file);
|
|
|
|
|
|
|
|
|
|
if (nerrors) {
|
1998-03-06 05:27:38 +08:00
|
|
|
|
printf("***** %d DATASET TEST%s FAILED! *****\n",
|
|
|
|
|
nerrors, 1 == nerrors ? "" : "S");
|
|
|
|
|
exit(1);
|
1998-01-17 06:23:43 +08:00
|
|
|
|
}
|
|
|
|
|
printf("All dataset tests passed.\n");
|
1998-01-31 03:25:44 +08:00
|
|
|
|
|
|
|
|
|
status = H5close ();
|
|
|
|
|
assert (status>=0);
|
|
|
|
|
|
1998-05-29 07:02:29 +08:00
|
|
|
|
cleanup();
|
1998-02-10 03:37:40 +08:00
|
|
|
|
return 0;
|
1997-12-11 06:41:56 +08:00
|
|
|
|
}
|