mirror of
https://github.com/HDFGroup/hdf5.git
synced 2025-01-18 15:15:56 +08:00
1c0597aa74
Changes since 19990614 ---------------------- ./src/H5D.c Changed the way the plist_id argument of H5Dvlen_reclaim() is checked so that it's more specific and works when debugging is turned off. ./src/H5TB.c Removed an unused local variable. ./test/fillval.c ./test/h5test.c ./test/h5test.h Changed `basename' variables to `base_name' to prevent a warning about a global with the same name. ./tools/h5ls.c Changed `indent' variables to `ind' to prevent a warning about a global with the same name. ./tools/h5toh4.c Commented out declarations for things that normally appear in system header files since our definitions might be incompatible with the system and prevent h5toh4 from compiling. If all looks good on other systems then we can permanently remove these declarations...
746 lines
21 KiB
C
746 lines
21 KiB
C
/*
|
||
* Copyright (C) 1998 NCSA
|
||
* All rights reserved.
|
||
*
|
||
* Programmer: Robb Matzke <robb@arborea.spizella.com>
|
||
* Thursday, October 1, 1998
|
||
*
|
||
* Purpose: Tests dataset fill values.
|
||
*/
|
||
#include <h5test.h>
|
||
|
||
/*
|
||
* Define NO_FILLING if you want to compare how this test works when there is
|
||
* no fill value (that is, when the fill value is zero).
|
||
*/
|
||
/* #define NO_FILLING */
|
||
|
||
const char *FILENAME[] = {
|
||
"fillval_1",
|
||
"fillval_2",
|
||
"fillval_3",
|
||
"fillval_4",
|
||
"fillval_5",
|
||
"fillval_6",
|
||
NULL
|
||
};
|
||
|
||
#define FILE_NAME_RAW "fillval.raw"
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_getset
|
||
*
|
||
* Purpose: Tests the H5Pget_fill_value() and H5Pset_fill_value()
|
||
* functions.
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: number of errors
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Thursday, October 1, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static int
|
||
test_getset(void)
|
||
{
|
||
herr_t status;
|
||
hid_t dcpl=-1;
|
||
int fill_i;
|
||
hid_t type_ss=-1, type_si=-1;
|
||
struct fill_si {
|
||
int v1, v2;
|
||
} fill_si;
|
||
struct fill_ss {
|
||
short v1, v2;
|
||
} fill_ss, fill_ss_rd;
|
||
|
||
TESTING("property lists");
|
||
|
||
/*
|
||
* Create the dataset creation property list and the data types that will
|
||
* be used during this test.
|
||
*/
|
||
if ((dcpl=H5Pcreate(H5P_DATASET_CREATE))<0) goto error;
|
||
if ((type_ss=H5Tcreate(H5T_COMPOUND, sizeof fill_ss))<0 ||
|
||
H5Tinsert(type_ss, "v1", HOFFSET(struct fill_ss, v1),
|
||
H5T_NATIVE_SHORT)<0 ||
|
||
H5Tinsert(type_ss, "v2", HOFFSET(struct fill_ss, v2),
|
||
H5T_NATIVE_SHORT)<0) {
|
||
goto error;
|
||
}
|
||
if ((type_si=H5Tcreate(H5T_COMPOUND, sizeof fill_si))<0 ||
|
||
H5Tinsert(type_si, "v1", HOFFSET(struct fill_si, v1),
|
||
H5T_NATIVE_INT)<0 ||
|
||
H5Tinsert(type_si, "v2", HOFFSET(struct fill_si, v2),
|
||
H5T_NATIVE_INT)<0) {
|
||
goto error;
|
||
}
|
||
|
||
/*
|
||
* Reading the fill value from a dataset creation property list that has
|
||
* no fill value should result in a failure.
|
||
*/
|
||
H5E_BEGIN_TRY {
|
||
status = H5Pget_fill_value(dcpl, H5T_NATIVE_INT, &fill_i);
|
||
} H5E_END_TRY;
|
||
if (status>=0) {
|
||
FAILED();
|
||
puts(" H5Pget_fill_value() should have been negative");
|
||
goto error;
|
||
}
|
||
|
||
/*
|
||
* Set the fill value using a struct as the data type.
|
||
*/
|
||
fill_ss.v1 = 1111;
|
||
fill_ss.v2 = 2222;
|
||
if (H5Pset_fill_value(dcpl, type_ss, &fill_ss)<0) goto error;
|
||
|
||
/*
|
||
* Get the fill value using the same data type that was used to set it.
|
||
*/
|
||
if (H5Pget_fill_value(dcpl, type_ss, &fill_ss_rd)<0) goto error;
|
||
if (fill_ss.v1!=fill_ss_rd.v1 || fill_ss.v2!=fill_ss_rd.v2) {
|
||
FAILED();
|
||
puts(" Failed to get fill value using same data type that was ");
|
||
puts(" used to set the fill value.");
|
||
goto error;
|
||
}
|
||
|
||
/*
|
||
* Get the fill value using some other data type.
|
||
*/
|
||
if (H5Pget_fill_value(dcpl, type_si, &fill_si)<0) goto error;
|
||
if (fill_ss.v1!=fill_si.v1 || fill_ss.v2!=fill_si.v2) {
|
||
FAILED();
|
||
puts(" Failed to get fill value using a data type other than what");
|
||
puts(" was used to set the fill value.");
|
||
goto error;
|
||
}
|
||
|
||
/*
|
||
* Reset the fill value
|
||
*/
|
||
if (H5Pset_fill_value(dcpl, type_si, &fill_si)<0) goto error;
|
||
if (H5Pget_fill_value(dcpl, type_ss, &fill_ss)<0) goto error;
|
||
if (fill_si.v1!=fill_ss.v1 || fill_si.v2!=fill_ss.v2) {
|
||
FAILED();
|
||
puts(" Resetting the fill value was unsuccessful.");
|
||
goto error;
|
||
}
|
||
|
||
/* Success */
|
||
if (H5Pclose(dcpl)<0) goto error;
|
||
if (H5Tclose(type_si)<0) goto error;
|
||
if (H5Tclose(type_ss)<0) goto error;
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
H5E_BEGIN_TRY {
|
||
H5Pclose(dcpl);
|
||
H5Tclose(type_si);
|
||
H5Tclose(type_ss);
|
||
} H5E_END_TRY;
|
||
return 1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_create
|
||
*
|
||
* Purpose: Tests creating datasets that have fill values.
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: number of errors
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Thursday, October 1, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static int
|
||
test_create(hid_t fapl, const char *base_name, H5D_layout_t layout)
|
||
{
|
||
hid_t file=-1, space=-1, dcpl=-1, dset1=-1, dset2=-1, dset3=-1;
|
||
hsize_t cur_size[5] = {32, 16, 8, 4, 2};
|
||
hsize_t ch_size[5] = {1, 1, 1, 4, 2};
|
||
short rd_s, fill_s = 0x1234;
|
||
long rd_l, fill_l = 0x4321;
|
||
char filename[1024];
|
||
|
||
if (H5D_CHUNKED==layout) {
|
||
TESTING("chunked dataset creation");
|
||
} else {
|
||
TESTING("contiguous dataset creation");
|
||
}
|
||
|
||
/*
|
||
* Create a file and three datasets. The three datasets test three fill
|
||
* conversion paths: small to large, large to small, and no conversion.
|
||
* They depend on `short' being smaller than `long'.
|
||
*/
|
||
h5_fixname(base_name, fapl, filename, sizeof filename);
|
||
if ((file=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl))<0)
|
||
goto error;
|
||
if ((space=H5Screate_simple(5, cur_size, cur_size))<0) goto error;
|
||
if ((dcpl=H5Pcreate(H5P_DATASET_CREATE))<0) goto error;
|
||
if (H5D_CHUNKED==layout) {
|
||
if (H5Pset_chunk(dcpl, 5, ch_size)<0) goto error;
|
||
}
|
||
|
||
/* Small to large fill conversion */
|
||
#ifndef NO_FILLING
|
||
if (H5Pset_fill_value(dcpl, H5T_NATIVE_SHORT, &fill_s)<0) goto error;
|
||
#endif
|
||
if ((dset1=H5Dcreate(file, "dset1", H5T_NATIVE_LONG, space, dcpl))<0)
|
||
goto error;
|
||
|
||
/* Large to small fill conversion */
|
||
#ifndef NO_FILLING
|
||
if (H5Pset_fill_value(dcpl, H5T_NATIVE_LONG, &fill_l)<0) goto error;
|
||
#endif
|
||
if ((dset2=H5Dcreate(file, "dset2", H5T_NATIVE_SHORT, space, dcpl))<0)
|
||
goto error;
|
||
|
||
/* No conversion */
|
||
#ifndef NO_FILLING
|
||
if (H5Pset_fill_value(dcpl, H5T_NATIVE_LONG, &fill_l)<0) goto error;
|
||
#endif
|
||
if ((dset3=H5Dcreate(file, "dset3", H5T_NATIVE_LONG, space, dcpl))<0)
|
||
goto error;
|
||
|
||
/* Close everything */
|
||
if (H5Dclose(dset1)<0) goto error;
|
||
if (H5Dclose(dset2)<0) goto error;
|
||
if (H5Dclose(dset3)<0) goto error;
|
||
if (H5Sclose(space)<0) goto error;
|
||
if (H5Pclose(dcpl)<0) goto error;
|
||
if (H5Fclose(file)<0) goto error;
|
||
|
||
/* Open the file and get the dataset fill value from each dataset */
|
||
if ((file=H5Fopen(filename, H5F_ACC_RDONLY, fapl))<0)
|
||
goto error;
|
||
|
||
/* Large to small conversion */
|
||
if ((dset1=H5Dopen(file, "dset1"))<0) goto error;
|
||
if ((dcpl=H5Dget_create_plist(dset1))<0) goto error;
|
||
if (H5Dclose(dset1)<0) goto error;
|
||
#ifndef NO_FILLING
|
||
if (H5Pget_fill_value(dcpl, H5T_NATIVE_SHORT, &rd_s)<0) goto error;
|
||
if (rd_s!=fill_s) {
|
||
FAILED();
|
||
puts(" Got a different fill value than what was set.");
|
||
printf(" Got %d, set %d\n", rd_s, fill_s);
|
||
goto error;
|
||
}
|
||
#endif
|
||
if (H5Pclose(dcpl)<0) goto error;
|
||
|
||
/* Small to large conversion */
|
||
if ((dset2=H5Dopen(file, "dset2"))<0) goto error;
|
||
if ((dcpl=H5Dget_create_plist(dset2))<0) goto error;
|
||
if (H5Dclose(dset2)<0) goto error;
|
||
#ifndef NO_FILLING
|
||
if (H5Pget_fill_value(dcpl, H5T_NATIVE_LONG, &rd_l)<0) goto error;
|
||
if (rd_l!=fill_l) {
|
||
FAILED();
|
||
puts(" Got a different fill value than what was set.");
|
||
printf(" Got %ld, set %ld\n", rd_l, fill_l);
|
||
goto error;
|
||
}
|
||
#endif
|
||
if (H5Pclose(dcpl)<0) goto error;
|
||
|
||
/* No conversion */
|
||
if ((dset3=H5Dopen(file, "dset3"))<0) goto error;
|
||
if ((dcpl=H5Dget_create_plist(dset3))<0) goto error;
|
||
if (H5Dclose(dset3)<0) goto error;
|
||
#ifndef NO_FILLING
|
||
if (H5Pget_fill_value(dcpl, H5T_NATIVE_LONG, &rd_l)<0) goto error;
|
||
if (rd_l!=fill_l) {
|
||
FAILED();
|
||
puts(" Got a different fill value than what was set.");
|
||
printf(" Got %ld, set %ld\n", rd_l, fill_l);
|
||
goto error;
|
||
}
|
||
#endif
|
||
if (H5Pclose(dcpl)<0) goto error;
|
||
|
||
|
||
|
||
if (H5Fclose(file)<0) goto error;
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
H5E_BEGIN_TRY {
|
||
H5Pclose(dcpl);
|
||
H5Sclose(space);
|
||
H5Dclose(dset1);
|
||
H5Dclose(dset2);
|
||
H5Dclose(dset3);
|
||
H5Fclose(file);
|
||
} H5E_END_TRY;
|
||
return 1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_rdwr
|
||
*
|
||
* Purpose: Tests fill values for chunked datasets.
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: number of errors
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Thursday, October 1, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static int
|
||
test_rdwr(hid_t fapl, const char *base_name, H5D_layout_t layout)
|
||
{
|
||
hid_t file=-1, fspace=-1, mspace=-1, dcpl=-1, dset=-1;
|
||
hsize_t cur_size[5] = {32, 16, 8, 4, 2};
|
||
hsize_t ch_size[5] = {1, 16, 8, 4, 2};
|
||
hsize_t one[5] = {1, 1, 1, 1, 1};
|
||
hsize_t hs_size[5], hs_stride[5];
|
||
hssize_t hs_offset[5], nelmts;
|
||
#ifdef NO_FILLING
|
||
int fillval = 0;
|
||
#else
|
||
int fillval = 0x4c70f1cd;
|
||
#endif
|
||
int val_rd, should_be;
|
||
int i, j, *buf=NULL, odd;
|
||
char filename[1024];
|
||
|
||
if (H5D_CHUNKED==layout) {
|
||
TESTING("chunked dataset I/O");
|
||
} else {
|
||
TESTING("contiguous dataset I/O");
|
||
}
|
||
|
||
/* Create a file and dataset */
|
||
h5_fixname(base_name, fapl, filename, sizeof filename);
|
||
if ((file=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl))<0)
|
||
goto error;
|
||
if ((fspace=H5Screate_simple(5, cur_size, cur_size))<0) goto error;
|
||
if ((dcpl=H5Pcreate(H5P_DATASET_CREATE))<0) goto error;
|
||
if (H5D_CHUNKED==layout) {
|
||
if (H5Pset_chunk(dcpl, 5, ch_size)<0) goto error;
|
||
}
|
||
#ifndef NO_FILLING
|
||
if (H5Pset_fill_value(dcpl, H5T_NATIVE_INT, &fillval)<0) goto error;
|
||
#endif
|
||
if ((dset=H5Dcreate(file, "dset", H5T_NATIVE_INT, fspace, dcpl))<0)
|
||
goto error;
|
||
|
||
/* Read some data and make sure it's the fill value */
|
||
if ((mspace=H5Screate_simple(5, one, NULL))<0) goto error;
|
||
for (i=0; i<1000; i++) {
|
||
for (j=0; j<5; j++) {
|
||
hs_offset[j] = rand() % cur_size[j];
|
||
}
|
||
if (H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_offset, NULL,
|
||
one, NULL)<0) goto error;
|
||
if (H5Dread(dset, H5T_NATIVE_INT, mspace, fspace, H5P_DEFAULT,
|
||
&val_rd)<0) goto error;
|
||
if (val_rd!=fillval) {
|
||
FAILED();
|
||
puts(" Value read was not a fill value.");
|
||
printf(" Elmt={%ld,%ld,%ld,%ld,%ld}, read: %u, "
|
||
"Fill value: %u\n",
|
||
(long)hs_offset[0], (long)hs_offset[1],
|
||
(long)hs_offset[2], (long)hs_offset[3],
|
||
(long)hs_offset[4], val_rd, fillval);
|
||
goto error;
|
||
}
|
||
}
|
||
if (H5Sclose(mspace)<0) goto error;
|
||
|
||
/* Write to all odd data locations */
|
||
for (i=0, nelmts=1; i<5; i++) {
|
||
hs_size[i] = cur_size[i]/2;
|
||
hs_offset[i] = 0;
|
||
hs_stride[i] = 2;
|
||
nelmts *= hs_size[i];
|
||
}
|
||
if ((mspace=H5Screate_simple(5, hs_size, hs_size))<0) goto error;
|
||
buf = malloc(nelmts*sizeof(int));
|
||
for (i=0; i<nelmts; i++) buf[i] = 9999;
|
||
if (H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_offset, hs_stride,
|
||
hs_size, NULL)<0) goto error;
|
||
if (H5Dwrite(dset, H5T_NATIVE_INT, mspace, fspace, H5P_DEFAULT,
|
||
buf)<0) goto error;
|
||
free(buf);
|
||
buf = NULL;
|
||
H5Sclose(mspace);
|
||
|
||
/* Read some data and make sure it's the right value */
|
||
if ((mspace=H5Screate_simple(5, one, NULL))<0) goto error;
|
||
for (i=0; i<1000; i++) {
|
||
for (j=0, odd=0; j<5; j++) {
|
||
hs_offset[j] = rand() % cur_size[j];
|
||
odd += hs_offset[j]%2;
|
||
}
|
||
should_be = odd ? fillval : 9999;
|
||
if (H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_offset, NULL,
|
||
one, NULL)<0) goto error;
|
||
if (H5Dread(dset, H5T_NATIVE_INT, mspace, fspace, H5P_DEFAULT,
|
||
&val_rd)<0) goto error;
|
||
|
||
if (val_rd!=should_be) {
|
||
FAILED();
|
||
puts(" Value read was not correct.");
|
||
printf(" Elmt={%ld,%ld,%ld,%ld,%ld}, read: %u, "
|
||
"should be: %u\n",
|
||
(long)hs_offset[0], (long)hs_offset[1],
|
||
(long)hs_offset[2], (long)hs_offset[3],
|
||
(long)hs_offset[4], val_rd, should_be);
|
||
goto error;
|
||
}
|
||
}
|
||
if (H5Sclose(mspace)<0) goto error;
|
||
|
||
|
||
|
||
if (H5Dclose(dset)<0) goto error;
|
||
if (H5Sclose(fspace)<0) goto error;
|
||
if (H5Pclose(dcpl)<0) goto error;
|
||
if (H5Fclose(file)<0) goto error;
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
H5E_BEGIN_TRY {
|
||
H5Dclose(dset);
|
||
H5Sclose(fspace);
|
||
H5Sclose(mspace);
|
||
H5Pclose(dcpl);
|
||
H5Fclose(file);
|
||
} H5E_END_TRY;
|
||
return 1;
|
||
}
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: test_extend
|
||
*
|
||
* Purpose: Test that filling works okay when a dataset is extended.
|
||
*
|
||
* Return: Success: 0
|
||
*
|
||
* Failure: number of errors
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Monday, October 5, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
static int
|
||
test_extend(hid_t fapl, const char *base_name, H5D_layout_t layout)
|
||
{
|
||
hid_t file=-1, fspace=-1, mspace=-1, dcpl=-1, dset=-1;
|
||
hsize_t cur_size[5] = {32, 16, 8, 4, 2};
|
||
hsize_t max_size[5] = {128, 64, 32, 16, 8};
|
||
hsize_t ch_size[5] = {1, 16, 8, 4, 2};
|
||
hsize_t one[5] = {1, 1, 1, 1, 1};
|
||
hsize_t hs_size[5], hs_stride[5];
|
||
hssize_t hs_offset[5], nelmts;
|
||
#ifdef NO_FILLING
|
||
int fillval = 0;
|
||
#else
|
||
int fillval = 0x4c70f1cd;
|
||
#endif
|
||
int val_rd, should_be;
|
||
int i, j, *buf=NULL, odd, fd;
|
||
char filename[1024];
|
||
|
||
if (H5D_CHUNKED==layout) {
|
||
TESTING("chunked dataset extend");
|
||
} else {
|
||
TESTING("contiguous dataset extend");
|
||
}
|
||
|
||
if ((dcpl=H5Pcreate(H5P_DATASET_CREATE))<0) goto error;
|
||
if (H5D_CHUNKED==layout) {
|
||
if (H5Pset_chunk(dcpl, 5, ch_size)<0) goto error;
|
||
}
|
||
#ifndef NO_FILLING
|
||
if (H5Pset_fill_value(dcpl, H5T_NATIVE_INT, &fillval)<0) goto error;
|
||
#endif
|
||
|
||
#if 1
|
||
/*
|
||
* Remove this once contiguous datasets can support extensions in other
|
||
* than the slowest varying dimension. The purpose of this block is to
|
||
* make only the slowest varying dimension extendible and yet have the
|
||
* same total number of elements as originally.
|
||
*
|
||
* If this is removed prematurely then you will get an error `only the
|
||
* first dimension can be extendible' as long as the test isn't skipped
|
||
* below.
|
||
*/
|
||
if (H5D_CONTIGUOUS==layout) {
|
||
max_size[0] = (max_size[0]*max_size[1]*max_size[2]*
|
||
max_size[3]*max_size[4]) /
|
||
(cur_size[1]*cur_size[2]*cur_size[3]*cur_size[4]);
|
||
max_size[1] = cur_size[1];
|
||
max_size[2] = cur_size[2];
|
||
max_size[3] = cur_size[3];
|
||
max_size[4] = cur_size[4];
|
||
}
|
||
#endif
|
||
|
||
#if 1
|
||
/*
|
||
* Remove this once internal contiguous datasets can support
|
||
* extending. If it's removed prematurely you will get an error
|
||
* `extendible contiguous non-external dataset' as long as the test isn't
|
||
* skipped below.
|
||
*/
|
||
if (H5D_CONTIGUOUS==layout) {
|
||
nelmts = max_size[0]*max_size[1]*max_size[2]*max_size[3]*max_size[4];
|
||
if ((fd=open(FILE_NAME_RAW, O_RDWR|O_CREAT|O_TRUNC, 0666))<0 ||
|
||
close(fd)<0) goto error;
|
||
if (H5Pset_external(dcpl, FILE_NAME_RAW, 0, nelmts*sizeof(int))<0)
|
||
goto error;
|
||
}
|
||
#endif
|
||
|
||
#if 1
|
||
/*
|
||
* Remove this when contiguous datasets can be exended to some
|
||
* predetermined fininte size, even if it's just in the slowest varying
|
||
* dimension. If it's removed prematurely then you'll get one of the
|
||
* errors described above or `unable to select fill value region'.
|
||
*/
|
||
if (H5D_CONTIGUOUS==layout) {
|
||
SKIPPED();
|
||
puts(" Not implemented yet -- needs H5S_SELECT_DIFF operator");
|
||
goto skip;
|
||
}
|
||
#endif
|
||
|
||
/* Create a file and dataset */
|
||
h5_fixname(base_name, fapl, filename, sizeof filename);
|
||
if ((file=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl))<0)
|
||
goto error;
|
||
if ((fspace=H5Screate_simple(5, cur_size, max_size))<0) goto error;
|
||
if ((dset=H5Dcreate(file, "dset", H5T_NATIVE_INT, fspace, dcpl))<0)
|
||
goto error;
|
||
|
||
/* Read some data and make sure it's the fill value */
|
||
if ((mspace=H5Screate_simple(5, one, NULL))<0) goto error;
|
||
for (i=0; i<1000; i++) {
|
||
for (j=0; j<5; j++) {
|
||
hs_offset[j] = rand() % cur_size[j];
|
||
}
|
||
if (H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_offset, NULL,
|
||
one, NULL)<0) goto error;
|
||
if (H5Dread(dset, H5T_NATIVE_INT, mspace, fspace, H5P_DEFAULT,
|
||
&val_rd)<0) goto error;
|
||
if (val_rd!=fillval) {
|
||
FAILED();
|
||
puts(" Value read was not a fill value.");
|
||
printf(" Elmt={%ld,%ld,%ld,%ld,%ld}, read: %u, "
|
||
"Fill value: %u\n",
|
||
(long)hs_offset[0], (long)hs_offset[1],
|
||
(long)hs_offset[2], (long)hs_offset[3],
|
||
(long)hs_offset[4], val_rd, fillval);
|
||
goto error;
|
||
}
|
||
}
|
||
if (H5Sclose(mspace)<0) goto error;
|
||
|
||
/* Write to all odd data locations */
|
||
for (i=0, nelmts=1; i<5; i++) {
|
||
hs_size[i] = cur_size[i]/2;
|
||
hs_offset[i] = 0;
|
||
hs_stride[i] = 2;
|
||
nelmts *= hs_size[i];
|
||
}
|
||
if ((mspace=H5Screate_simple(5, hs_size, hs_size))<0) goto error;
|
||
buf = malloc(nelmts*sizeof(int));
|
||
for (i=0; i<nelmts; i++) buf[i] = 9999;
|
||
if (H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_offset, hs_stride,
|
||
hs_size, NULL)<0) goto error;
|
||
if (H5Dwrite(dset, H5T_NATIVE_INT, mspace, fspace, H5P_DEFAULT,
|
||
buf)<0) goto error;
|
||
free(buf);
|
||
buf = NULL;
|
||
H5Sclose(mspace);
|
||
|
||
/* Read some data and make sure it's the right value */
|
||
if ((mspace=H5Screate_simple(5, one, NULL))<0) goto error;
|
||
for (i=0; i<1000; i++) {
|
||
for (j=0, odd=0; j<5; j++) {
|
||
hs_offset[j] = rand() % cur_size[j];
|
||
odd += hs_offset[j]%2;
|
||
}
|
||
should_be = odd ? fillval : 9999;
|
||
if (H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_offset, NULL,
|
||
one, NULL)<0) goto error;
|
||
if (H5Dread(dset, H5T_NATIVE_INT, mspace, fspace, H5P_DEFAULT,
|
||
&val_rd)<0) goto error;
|
||
|
||
if (val_rd!=should_be) {
|
||
FAILED();
|
||
puts(" Value read was not correct.");
|
||
printf(" Elmt={%ld,%ld,%ld,%ld,%ld}, read: %u, "
|
||
"should be: %u\n",
|
||
(long)hs_offset[0], (long)hs_offset[1],
|
||
(long)hs_offset[2], (long)hs_offset[3],
|
||
(long)hs_offset[4], val_rd, should_be);
|
||
goto error;
|
||
}
|
||
}
|
||
if (H5Sclose(mspace)<0) goto error;
|
||
|
||
/* Extend the dataset */
|
||
if (H5Dextend(dset, max_size)<0) goto error;
|
||
if (H5Sclose(fspace)<0) goto error;
|
||
if ((fspace=H5Dget_space(dset))<0) goto error;
|
||
|
||
/* Read some data and make sure it's the right value */
|
||
if ((mspace=H5Screate_simple(5, one, NULL))<0) goto error;
|
||
for (i=0; i<1000; i++) {
|
||
for (j=0, odd=0; j<5; j++) {
|
||
hs_offset[j] = rand() % max_size[j];
|
||
if ((hsize_t)hs_offset[j]>=cur_size[j]) {
|
||
odd = 1;
|
||
} else {
|
||
odd += hs_offset[j]%2;
|
||
}
|
||
}
|
||
|
||
should_be = odd ? fillval : 9999;
|
||
if (H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_offset, NULL,
|
||
one, NULL)<0) goto error;
|
||
if (H5Dread(dset, H5T_NATIVE_INT, mspace, fspace, H5P_DEFAULT,
|
||
&val_rd)<0) goto error;
|
||
|
||
if (val_rd!=should_be) {
|
||
FAILED();
|
||
puts(" Value read was not correct.");
|
||
printf(" Elmt={%ld,%ld,%ld,%ld,%ld}, read: %u, "
|
||
"should be: %u\n",
|
||
(long)hs_offset[0], (long)hs_offset[1],
|
||
(long)hs_offset[2], (long)hs_offset[3],
|
||
(long)hs_offset[4], val_rd, should_be);
|
||
goto error;
|
||
}
|
||
}
|
||
if (H5Sclose(mspace)<0) goto error;
|
||
|
||
if (H5Dclose(dset)<0) goto error;
|
||
if (H5Sclose(fspace)<0) goto error;
|
||
if (H5Pclose(dcpl)<0) goto error;
|
||
if (H5Fclose(file)<0) goto error;
|
||
PASSED();
|
||
return 0;
|
||
|
||
error:
|
||
H5E_BEGIN_TRY {
|
||
H5Dclose(dset);
|
||
H5Sclose(fspace);
|
||
H5Sclose(mspace);
|
||
H5Pclose(dcpl);
|
||
H5Fclose(file);
|
||
} H5E_END_TRY;
|
||
return 1;
|
||
|
||
skip:
|
||
H5E_BEGIN_TRY {
|
||
H5Dclose(dset);
|
||
H5Sclose(fspace);
|
||
H5Sclose(mspace);
|
||
H5Pclose(dcpl);
|
||
H5Fclose(file);
|
||
} H5E_END_TRY;
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
/*-------------------------------------------------------------------------
|
||
* Function: main
|
||
*
|
||
* Purpose: Tests fill values
|
||
*
|
||
* Return: Success:
|
||
*
|
||
* Failure:
|
||
*
|
||
* Programmer: Robb Matzke
|
||
* Thursday, October 1, 1998
|
||
*
|
||
* Modifications:
|
||
*
|
||
*-------------------------------------------------------------------------
|
||
*/
|
||
int
|
||
main(int argc, char *argv[])
|
||
{
|
||
int nerrors=0, argno, test_contig=1, test_chunk=1;
|
||
hid_t fapl=-1;
|
||
|
||
if (argc>=2) {
|
||
test_contig = test_chunk = 0;
|
||
for (argno=1; argno<argc; argno++) {
|
||
if (!strcmp(argv[argno], "contiguous")) {
|
||
test_contig = 1;
|
||
} else if (!strcmp(argv[argno], "chunked")) {
|
||
test_chunk = 1;
|
||
} else {
|
||
fprintf(stderr, "usage: %s [contiguous] [chunked]\n", argv[0]);
|
||
exit(1);
|
||
}
|
||
}
|
||
}
|
||
|
||
h5_reset();
|
||
fapl = h5_fileaccess();
|
||
|
||
nerrors += test_getset();
|
||
|
||
/* Chunked storage layout tests */
|
||
if (test_chunk) {
|
||
nerrors += test_create(fapl, FILENAME[0], H5D_CHUNKED);
|
||
nerrors += test_rdwr (fapl, FILENAME[2], H5D_CHUNKED);
|
||
nerrors += test_extend(fapl, FILENAME[4], H5D_CHUNKED);
|
||
}
|
||
|
||
/* Contiguous storage layout tests */
|
||
if (test_contig) {
|
||
nerrors += test_create(fapl, FILENAME[1], H5D_CONTIGUOUS);
|
||
nerrors += test_rdwr (fapl, FILENAME[3], H5D_CONTIGUOUS);
|
||
nerrors += test_extend(fapl, FILENAME[5], H5D_CONTIGUOUS);
|
||
}
|
||
|
||
if (nerrors) goto error;
|
||
puts("All fill value tests passed.");
|
||
if (h5_cleanup(fapl)) remove(FILE_NAME_RAW);
|
||
return 0;
|
||
|
||
error:
|
||
puts("***** FILL VALUE TESTS FAILED *****");
|
||
return 1;
|
||
}
|