1998-10-06 05:01:10 +08:00
|
|
|
|
/*
|
|
|
|
|
* Copyright (C) 1998 NCSA
|
|
|
|
|
* All rights reserved.
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Robb Matzke <robb@arborea.spizella.com>
|
|
|
|
|
* Thursday, October 1, 1998
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Tests dataset fill values.
|
|
|
|
|
*/
|
2001-04-04 02:09:16 +08:00
|
|
|
|
#include "h5test.h"
|
1998-11-03 01:58:28 +08:00
|
|
|
|
|
1998-10-06 05:01:10 +08:00
|
|
|
|
/*
|
|
|
|
|
* 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 */
|
|
|
|
|
|
1998-11-24 04:40:35 +08:00
|
|
|
|
const char *FILENAME[] = {
|
|
|
|
|
"fillval_1",
|
|
|
|
|
"fillval_2",
|
|
|
|
|
"fillval_3",
|
|
|
|
|
"fillval_4",
|
|
|
|
|
"fillval_5",
|
|
|
|
|
"fillval_6",
|
2002-08-21 00:18:02 +08:00
|
|
|
|
"fillval_7",
|
|
|
|
|
"fillval_8",
|
1998-11-24 04:40:35 +08:00
|
|
|
|
NULL
|
|
|
|
|
};
|
1998-10-06 05:01:10 +08:00
|
|
|
|
|
2002-04-12 06:53:26 +08:00
|
|
|
|
typedef struct {
|
|
|
|
|
float a;
|
|
|
|
|
int x;
|
|
|
|
|
double y;
|
|
|
|
|
char z;
|
|
|
|
|
} comp_datatype;
|
|
|
|
|
|
|
|
|
|
/* The fill_old.h5 is generated from gen_old_fill.c in HDF5 'test' directory
|
|
|
|
|
* for version 1.4(after 1.4.3). To get this data file, simply compile
|
|
|
|
|
* gen_old_fill.c with HDF5 library (before v1.5) and run it. */
|
|
|
|
|
#define FILE_COMPATIBLE "fill_old.h5"
|
1998-10-06 05:01:10 +08:00
|
|
|
|
#define FILE_NAME_RAW "fillval.raw"
|
|
|
|
|
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: create_compound_type
|
|
|
|
|
*
|
|
|
|
|
* Purpose: create a compound datatype
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: datatype ID
|
|
|
|
|
*
|
|
|
|
|
* Failure: -1
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Raymond Lu
|
|
|
|
|
* Monday, Jan 26, 2001
|
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static hid_t create_compound_type(void)
|
|
|
|
|
{
|
|
|
|
|
hid_t ret_value=-1;
|
|
|
|
|
|
|
|
|
|
if((ret_value = H5Tcreate(H5T_COMPOUND, sizeof(comp_datatype)))<0)
|
|
|
|
|
goto error;
|
|
|
|
|
if(H5Tinsert(ret_value, "a", HOFFSET(comp_datatype,a), H5T_NATIVE_FLOAT)<0)
|
|
|
|
|
goto error;
|
|
|
|
|
if(H5Tinsert(ret_value, "x", HOFFSET(comp_datatype,x), H5T_NATIVE_INT)<0)
|
|
|
|
|
goto error;
|
|
|
|
|
if(H5Tinsert(ret_value, "y", HOFFSET(comp_datatype,y),
|
|
|
|
|
H5T_NATIVE_DOUBLE)<0) goto error;
|
|
|
|
|
if(H5Tinsert(ret_value, "z", HOFFSET(comp_datatype,z), H5T_NATIVE_CHAR)<0)
|
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
|
|
return ret_value;
|
|
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
H5Tclose(ret_value);
|
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
1998-10-06 05:01:10 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* 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)
|
|
|
|
|
{
|
1998-11-24 04:40:35 +08:00
|
|
|
|
hid_t dcpl=-1;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
int fill_i;
|
1998-11-24 04:40:35 +08:00
|
|
|
|
hid_t type_ss=-1, type_si=-1;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
struct fill_si {
|
|
|
|
|
int v1, v2;
|
|
|
|
|
} fill_si;
|
|
|
|
|
struct fill_ss {
|
|
|
|
|
short v1, v2;
|
|
|
|
|
} fill_ss, fill_ss_rd;
|
|
|
|
|
|
1998-11-24 04:40:35 +08:00
|
|
|
|
TESTING("property lists");
|
1998-10-06 05:01:10 +08:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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 {
|
2002-05-21 02:43:31 +08:00
|
|
|
|
H5Pget_fill_value(dcpl, H5T_NATIVE_INT, &fill_i);
|
1998-10-06 05:01:10 +08:00
|
|
|
|
} H5E_END_TRY;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
if (fill_i != 0) {
|
2001-01-26 01:03:29 +08:00
|
|
|
|
H5_FAILED();
|
2002-04-12 06:53:26 +08:00
|
|
|
|
puts(" H5Pget_fill_value() should return default 0");
|
1998-10-06 05:01:10 +08:00
|
|
|
|
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) {
|
2001-01-26 01:03:29 +08:00
|
|
|
|
H5_FAILED();
|
1998-11-24 04:40:35 +08:00
|
|
|
|
puts(" Failed to get fill value using same data type that was ");
|
|
|
|
|
puts(" used to set the fill value.");
|
1998-10-06 05:01:10 +08:00
|
|
|
|
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) {
|
2001-01-26 01:03:29 +08:00
|
|
|
|
H5_FAILED();
|
1998-11-24 04:40:35 +08:00
|
|
|
|
puts(" Failed to get fill value using a data type other than what");
|
|
|
|
|
puts(" was used to set the fill value.");
|
1998-10-06 05:01:10 +08:00
|
|
|
|
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) {
|
2001-01-26 01:03:29 +08:00
|
|
|
|
H5_FAILED();
|
1998-11-24 04:40:35 +08:00
|
|
|
|
puts(" Resetting the fill value was unsuccessful.");
|
1998-10-06 05:01:10 +08:00
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Success */
|
|
|
|
|
if (H5Pclose(dcpl)<0) goto error;
|
1998-11-24 04:40:35 +08:00
|
|
|
|
if (H5Tclose(type_si)<0) goto error;
|
|
|
|
|
if (H5Tclose(type_ss)<0) goto error;
|
|
|
|
|
PASSED();
|
1998-10-06 05:01:10 +08:00
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
error:
|
1998-11-24 04:40:35 +08:00
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
H5Pclose(dcpl);
|
|
|
|
|
H5Tclose(type_si);
|
|
|
|
|
H5Tclose(type_ss);
|
|
|
|
|
} H5E_END_TRY;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
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:
|
2002-04-12 06:53:26 +08:00
|
|
|
|
* Many new cases have been added to this test since
|
|
|
|
|
* the fill value design has been modified.
|
|
|
|
|
*
|
1998-10-06 05:01:10 +08:00
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static int
|
1999-06-15 22:58:25 +08:00
|
|
|
|
test_create(hid_t fapl, const char *base_name, H5D_layout_t layout)
|
1998-10-06 05:01:10 +08:00
|
|
|
|
{
|
2002-04-12 06:53:26 +08:00
|
|
|
|
hid_t file=-1, space=-1, dcpl=-1, comp_type_id=-1;
|
|
|
|
|
hid_t dset1=-1, dset2=-1, dset3=-1, dset4=-1, dset5=-1,
|
2002-05-21 02:43:31 +08:00
|
|
|
|
dset6=-1, /* dset7=-1, */ dset8=-1, dset9=-1;
|
2002-08-21 00:18:02 +08:00
|
|
|
|
hsize_t cur_size[5] = {2, 16, 8, 4, 2};
|
1998-10-06 05:01:10 +08:00
|
|
|
|
hsize_t ch_size[5] = {1, 1, 1, 4, 2};
|
1998-10-09 01:13:14 +08:00
|
|
|
|
short rd_s, fill_s = 0x1234;
|
|
|
|
|
long rd_l, fill_l = 0x4321;
|
1998-11-24 04:40:35 +08:00
|
|
|
|
char filename[1024];
|
2002-04-12 06:53:26 +08:00
|
|
|
|
H5D_space_status_t allocation;
|
2002-09-14 00:57:46 +08:00
|
|
|
|
H5D_alloc_time_t alloc_time;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
H5D_fill_time_t fill_time;
|
|
|
|
|
comp_datatype rd_c, fill_ctype;
|
|
|
|
|
|
1998-10-06 05:01:10 +08:00
|
|
|
|
if (H5D_CHUNKED==layout) {
|
1998-11-24 04:40:35 +08:00
|
|
|
|
TESTING("chunked dataset creation");
|
2002-08-21 00:18:02 +08:00
|
|
|
|
} else if (H5D_COMPACT==layout) {
|
|
|
|
|
TESTING("compact dataset creation");
|
1998-10-06 05:01:10 +08:00
|
|
|
|
} else {
|
1998-11-24 04:40:35 +08:00
|
|
|
|
TESTING("contiguous dataset creation");
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
|
|
|
|
|
1998-10-09 01:13:14 +08:00
|
|
|
|
/*
|
2002-04-12 06:53:26 +08:00
|
|
|
|
* Create a file.
|
1998-10-09 01:13:14 +08:00
|
|
|
|
*/
|
1999-06-15 22:58:25 +08:00
|
|
|
|
h5_fixname(base_name, fapl, filename, sizeof filename);
|
1998-11-24 04:40:35 +08:00
|
|
|
|
if ((file=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl))<0)
|
|
|
|
|
goto error;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
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;
|
2002-08-21 00:18:02 +08:00
|
|
|
|
} else if (H5D_COMPACT==layout) {
|
|
|
|
|
if (H5Pset_layout(dcpl, H5D_COMPACT)<0) goto error;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
2002-08-21 00:18:02 +08:00
|
|
|
|
|
2002-04-12 06:53:26 +08:00
|
|
|
|
/* Create a compound datatype */
|
|
|
|
|
if((comp_type_id = create_compound_type())<0) goto error;
|
1998-10-09 01:13:14 +08:00
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* I. Test cases for late space allocation except compact dataset */
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if(H5D_COMPACT!=layout) {
|
2002-09-14 00:57:46 +08:00
|
|
|
|
if(H5Pset_alloc_time(dcpl, H5D_ALLOC_TIME_LATE) < 0) goto error;
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) goto error;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* 1. Compound datatype test */
|
|
|
|
|
if(H5Pget_fill_value(dcpl, comp_type_id, &fill_ctype)<0) goto error;
|
|
|
|
|
fill_ctype.y = 4444;
|
|
|
|
|
if(H5Pset_fill_value(dcpl, comp_type_id, &fill_ctype)<0) goto error;
|
|
|
|
|
if((dset9 = H5Dcreate(file, "dset9", comp_type_id, space, dcpl))<0)
|
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
|
|
/* 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'.
|
|
|
|
|
*/
|
|
|
|
|
/* 2. Small to large fill conversion */
|
1998-10-06 05:01:10 +08:00
|
|
|
|
#ifndef NO_FILLING
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if (H5Pset_fill_value(dcpl, H5T_NATIVE_SHORT, &fill_s)<0) goto error;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
#endif
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if ((dset1=H5Dcreate(file, "dset1", H5T_NATIVE_LONG, space, dcpl))<0)
|
|
|
|
|
goto error;
|
1998-10-09 01:13:14 +08:00
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* 3. Large to small fill conversion */
|
1998-10-09 01:13:14 +08:00
|
|
|
|
#ifndef NO_FILLING
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if (H5Pset_fill_value(dcpl, H5T_NATIVE_LONG, &fill_l)<0) goto error;
|
1998-10-09 01:13:14 +08:00
|
|
|
|
#endif
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if ((dset2=H5Dcreate(file, "dset2", H5T_NATIVE_SHORT, space, dcpl))<0)
|
|
|
|
|
goto error;
|
1998-10-09 01:13:14 +08:00
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* 4. No conversion */
|
1998-10-09 01:13:14 +08:00
|
|
|
|
#ifndef NO_FILLING
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if (H5Pset_fill_value(dcpl, H5T_NATIVE_LONG, &fill_l)<0) goto error;
|
1998-10-09 01:13:14 +08:00
|
|
|
|
#endif
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if ((dset3=H5Dcreate(file, "dset3", H5T_NATIVE_LONG, space, dcpl))<0)
|
|
|
|
|
goto error;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* 5. late space allocation and never write fill value */
|
|
|
|
|
if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_NEVER) < 0) goto error;
|
|
|
|
|
if ((dset4=H5Dcreate(file, "dset4", H5T_NATIVE_LONG, space, dcpl))<0)
|
2002-04-12 06:53:26 +08:00
|
|
|
|
goto error;
|
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* 6. fill value is undefined while fill write time is H5D_FILL_TIME_ALLOC.
|
|
|
|
|
* Supposed to fail. */
|
|
|
|
|
if(H5Pset_fill_value(dcpl, -1, NULL)<0) goto error;
|
|
|
|
|
if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) goto error;
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
if(H5Dcreate(file, "dset7", H5T_NATIVE_LONG, space, dcpl)!=FAIL)
|
|
|
|
|
goto error;
|
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
}
|
|
|
|
|
|
2002-04-12 06:53:26 +08:00
|
|
|
|
/* II. Test early space allocation cases */
|
2002-08-21 00:18:02 +08:00
|
|
|
|
|
2002-04-12 06:53:26 +08:00
|
|
|
|
if (H5Pclose(dcpl)<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;
|
2002-08-21 00:18:02 +08:00
|
|
|
|
} else if (H5D_COMPACT==layout) {
|
|
|
|
|
if (H5Pset_layout(dcpl, H5D_COMPACT)<0) goto error;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
}
|
2002-09-14 00:57:46 +08:00
|
|
|
|
if(H5Pset_alloc_time(dcpl, H5D_ALLOC_TIME_EARLY) < 0) goto error;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
|
|
|
|
/* 1. Compound datatype test */
|
|
|
|
|
if(H5Pget_fill_value(dcpl, comp_type_id, &fill_ctype)<0) goto error;
|
|
|
|
|
fill_ctype.y = 4444;
|
|
|
|
|
if(H5Pset_fill_value(dcpl, comp_type_id, &fill_ctype)<0) goto error;
|
|
|
|
|
if((dset8 = H5Dcreate(file, "dset8", comp_type_id, space, dcpl))<0)
|
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if(H5Pset_fill_value(dcpl, H5T_NATIVE_LONG, &fill_l)<0) goto error;
|
|
|
|
|
|
|
|
|
|
/* 2. Never write fill value */
|
|
|
|
|
if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_NEVER) < 0) goto error;
|
|
|
|
|
if((dset5 = H5Dcreate(file, "dset5", H5T_NATIVE_INT, space, dcpl))<0)
|
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
|
|
/* 3. Write fill value at space allocation time */
|
|
|
|
|
if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) goto error;
|
|
|
|
|
if((dset6 = H5Dcreate(file, "dset6", H5T_NATIVE_LONG, space, dcpl))<0)
|
|
|
|
|
goto error;
|
|
|
|
|
|
|
|
|
|
/* 4. fill value is undefined while fill write time is H5D_FILL_TIME_ALLOC.
|
|
|
|
|
* Supposed to fail. */
|
|
|
|
|
if(H5Pset_fill_value(dcpl, -1, NULL)<0) goto error;
|
|
|
|
|
H5E_BEGIN_TRY {
|
2002-05-21 02:43:31 +08:00
|
|
|
|
if(H5Dcreate(file, "dset7", H5T_NATIVE_LONG, space, dcpl)!=FAIL)
|
2002-04-12 06:53:26 +08:00
|
|
|
|
goto error;
|
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
|
1998-10-09 01:13:14 +08:00
|
|
|
|
/* Close everything */
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if(H5D_COMPACT != layout) {
|
|
|
|
|
if (H5Dclose(dset1)<0) goto error;
|
|
|
|
|
if (H5Dclose(dset2)<0) goto error;
|
|
|
|
|
if (H5Dclose(dset3)<0) goto error;
|
|
|
|
|
if (H5Dclose(dset4)<0) goto error;
|
|
|
|
|
if (H5Dclose(dset9)<0) goto error;
|
|
|
|
|
}
|
2002-04-12 06:53:26 +08:00
|
|
|
|
if (H5Dclose(dset5)<0) goto error;
|
|
|
|
|
if (H5Dclose(dset6)<0) goto error;
|
|
|
|
|
if (H5Dclose(dset8)<0) goto error;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
if (H5Sclose(space)<0) goto error;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
if (H5Pclose(dcpl)<0) goto error;
|
|
|
|
|
if (H5Fclose(file)<0) goto error;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
|
1998-10-09 01:13:14 +08:00
|
|
|
|
/* Open the file and get the dataset fill value from each dataset */
|
1998-11-24 04:40:35 +08:00
|
|
|
|
if ((file=H5Fopen(filename, H5F_ACC_RDONLY, fapl))<0)
|
1998-10-06 05:01:10 +08:00
|
|
|
|
goto error;
|
1998-10-09 01:13:14 +08:00
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* I. Check cases for late space allocation except compact dataset */
|
|
|
|
|
if(H5D_COMPACT != layout) {
|
|
|
|
|
/* 1. Large to small conversion */
|
|
|
|
|
if ((dset1=H5Dopen(file, "dset1"))<0) goto error;
|
|
|
|
|
if ((dcpl=H5Dget_create_plist(dset1))<0) goto error;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
#ifndef NO_FILLING
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if (H5Pget_fill_value(dcpl, H5T_NATIVE_SHORT, &rd_s)<0) goto error;
|
|
|
|
|
if (rd_s!=fill_s) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf(" %d: Got a different fill value than what was set.",__LINE__);
|
|
|
|
|
printf(" Got %d, set %d\n", rd_s, fill_s);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
1998-10-06 05:01:10 +08:00
|
|
|
|
#endif
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if (H5Dclose(dset1)<0) goto error;
|
|
|
|
|
if (H5Pclose(dcpl)<0) goto error;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* 2. Small to large conversion */
|
|
|
|
|
if ((dset2=H5Dopen(file, "dset2"))<0) goto error;
|
|
|
|
|
if ((dcpl=H5Dget_create_plist(dset2))<0) goto error;
|
1998-10-09 01:13:14 +08:00
|
|
|
|
#ifndef NO_FILLING
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if (H5Pget_fill_value(dcpl, H5T_NATIVE_LONG, &rd_l)<0) goto error;
|
|
|
|
|
if (rd_l!=fill_l) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf(" %d: Got a different fill value than what was set.",__LINE__);
|
|
|
|
|
printf(" Got %ld, set %ld\n", rd_l, fill_l);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
1998-10-09 01:13:14 +08:00
|
|
|
|
#endif
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if (H5Dclose(dset2)<0) goto error;
|
|
|
|
|
if (H5Pclose(dcpl)<0) goto error;
|
1998-10-09 01:13:14 +08:00
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* 3. No conversion */
|
|
|
|
|
if ((dset3=H5Dopen(file, "dset3"))<0) goto error;
|
|
|
|
|
if ((dcpl=H5Dget_create_plist(dset3))<0) goto error;
|
1998-10-09 01:13:14 +08:00
|
|
|
|
#ifndef NO_FILLING
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if (H5Pget_fill_value(dcpl, H5T_NATIVE_LONG, &rd_l)<0) goto error;
|
|
|
|
|
if (rd_l!=fill_l) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf(" %d: Got a different fill value than what was set.",__LINE__);
|
|
|
|
|
printf(" Got %ld, set %ld\n", rd_l, fill_l);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
1998-10-09 01:13:14 +08:00
|
|
|
|
#endif
|
2002-09-14 00:57:46 +08:00
|
|
|
|
if(H5Pget_alloc_time(dcpl, &alloc_time)<0) goto error;
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if(H5Pget_fill_time(dcpl, &fill_time)<0) goto error;
|
2002-09-14 00:57:46 +08:00
|
|
|
|
if(alloc_time != H5D_ALLOC_TIME_LATE) {
|
2002-08-21 00:18:02 +08:00
|
|
|
|
H5_FAILED();
|
2002-09-14 00:57:46 +08:00
|
|
|
|
puts(" Got non-H5D_ALLOC_TIME_LATE space allocation time.");
|
2002-08-21 00:18:02 +08:00
|
|
|
|
printf(" Got %d\n", alloc_time);
|
|
|
|
|
}
|
|
|
|
|
if(fill_time != H5D_FILL_TIME_ALLOC) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Got non-H5D_FILL_TIME_ALLOC fill value write time.");
|
|
|
|
|
printf(" Got %d\n", fill_time);
|
|
|
|
|
}
|
|
|
|
|
if (H5Dclose(dset3)<0) goto error;
|
|
|
|
|
if (H5Pclose(dcpl)<0) goto error;
|
1998-10-09 01:13:14 +08:00
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* 4. late space allocation and never write fill value */
|
|
|
|
|
if ((dset4=H5Dopen(file, "dset4"))<0) goto error;
|
|
|
|
|
if (H5Dget_space_status(dset4, &allocation)<0) goto error;
|
|
|
|
|
if (layout == H5D_CONTIGUOUS && allocation != H5D_SPACE_STATUS_NOT_ALLOCATED) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Got allocated space instead of unallocated.");
|
|
|
|
|
printf(" Got %d\n", allocation);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
if ((dcpl=H5Dget_create_plist(dset4))<0) goto error;
|
2002-09-14 00:57:46 +08:00
|
|
|
|
if(H5Pget_alloc_time(dcpl, &alloc_time)<0) goto error;
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if(H5Pget_fill_time(dcpl, &fill_time)<0) goto error;
|
2002-09-14 00:57:46 +08:00
|
|
|
|
if(alloc_time != H5D_ALLOC_TIME_LATE) {
|
2002-08-21 00:18:02 +08:00
|
|
|
|
H5_FAILED();
|
2002-09-14 00:57:46 +08:00
|
|
|
|
puts(" Got non-H5D_ALLOC_TIME_LATE space allocation time.");
|
2002-08-21 00:18:02 +08:00
|
|
|
|
printf(" Got %d\n", alloc_time);
|
|
|
|
|
}
|
|
|
|
|
if(fill_time != H5D_FILL_TIME_NEVER) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Got non-H5D_FILL_TIME_NEVER fill value write time.");
|
|
|
|
|
printf(" Got %d\n", fill_time);
|
|
|
|
|
}
|
|
|
|
|
if (H5Dclose(dset4)<0) goto error;
|
|
|
|
|
if (H5Pclose(dcpl)<0) goto error;
|
|
|
|
|
|
|
|
|
|
/* 5. Compound datatype test */
|
|
|
|
|
if ((dset9=H5Dopen(file, "dset9"))<0) goto error;
|
|
|
|
|
if ((dcpl=H5Dget_create_plist(dset9))<0) goto error;
|
|
|
|
|
if (H5Pget_fill_value(dcpl, comp_type_id, &rd_c)<0) goto error;
|
|
|
|
|
if( rd_c.a!=0 || rd_c.y != fill_ctype.y || rd_c.x != 0 || rd_c.z != '\0') {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Got wrong fill value");
|
|
|
|
|
printf(" Got rd_c.a=%f, rd_c.y=%f and rd_c.x=%d, rd_c.z=%c\n",
|
|
|
|
|
rd_c.a, rd_c.y, rd_c.x, rd_c.z);
|
|
|
|
|
}
|
|
|
|
|
if (H5Dclose(dset9)<0) goto error;
|
|
|
|
|
if (H5Pclose(dcpl)<0) goto error;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
}
|
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* II. Check early space allocation cases */
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
|
|
|
|
/* 1. Never write fill value */
|
|
|
|
|
if ((dset5=H5Dopen(file, "dset5"))<0) goto error;
|
|
|
|
|
if ((dcpl=H5Dget_create_plist(dset5))<0) goto error;
|
|
|
|
|
if (H5Dget_space_status(dset5, &allocation)<0) goto error;
|
|
|
|
|
if (layout == H5D_CONTIGUOUS && allocation != H5D_SPACE_STATUS_ALLOCATED) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf(" %d: Got unallocated space instead of allocated.\n",__LINE__);
|
|
|
|
|
printf(" Got %d\n", allocation);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
2002-09-14 00:57:46 +08:00
|
|
|
|
if(H5Pget_alloc_time(dcpl, &alloc_time)<0) goto error;
|
|
|
|
|
if(alloc_time != H5D_ALLOC_TIME_EARLY) {
|
2002-04-12 06:53:26 +08:00
|
|
|
|
H5_FAILED();
|
2002-09-14 00:57:46 +08:00
|
|
|
|
puts(" Got non-H5D_ALLOC_TIME_EARLY space allocation time.");
|
2002-04-12 06:53:26 +08:00
|
|
|
|
printf(" Got %d\n", alloc_time);
|
|
|
|
|
}
|
|
|
|
|
if(H5Pget_fill_time(dcpl, &fill_time)<0) goto error;
|
|
|
|
|
if(fill_time != H5D_FILL_TIME_NEVER) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Got non-H5D_FILL_TIME_NEVER fill value write time.");
|
|
|
|
|
printf(" Got %d\n", fill_time);
|
|
|
|
|
}
|
|
|
|
|
if (H5Dclose(dset5)<0) goto error;
|
|
|
|
|
if (H5Pclose(dcpl)<0) goto error;
|
|
|
|
|
|
|
|
|
|
/* 2. test writing fill value at space allocation time */
|
|
|
|
|
if ((dset6=H5Dopen(file, "dset6"))<0) goto error;
|
|
|
|
|
if ((dcpl=H5Dget_create_plist(dset6))<0) goto error;
|
|
|
|
|
if (H5Dget_space_status(dset6, &allocation)<0) goto error;
|
|
|
|
|
if (layout == H5D_CONTIGUOUS && allocation != H5D_SPACE_STATUS_ALLOCATED) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf(" %d: Got unallocated space instead of allocated.\n",__LINE__);
|
|
|
|
|
printf(" Got %d\n", allocation);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
if (H5Pget_fill_value(dcpl, H5T_NATIVE_LONG, &rd_l)<0) goto error;
|
|
|
|
|
if (rd_l!=fill_l) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf(" %d: Got a different fill value than what was set.",__LINE__);
|
|
|
|
|
printf(" Got %ld, set %ld\n", rd_l, fill_l);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
2002-09-14 00:57:46 +08:00
|
|
|
|
if(H5Pget_alloc_time(dcpl, &alloc_time)<0) goto error;
|
|
|
|
|
if(alloc_time != H5D_ALLOC_TIME_EARLY) {
|
2002-04-12 06:53:26 +08:00
|
|
|
|
H5_FAILED();
|
2002-09-14 00:57:46 +08:00
|
|
|
|
puts(" Got non-H5D_ALLOC_TIME_EARLY space allocation time.");
|
2002-04-12 06:53:26 +08:00
|
|
|
|
printf(" Got %d\n", alloc_time);
|
|
|
|
|
}
|
|
|
|
|
if(H5Pget_fill_time(dcpl, &fill_time)<0) goto error;
|
|
|
|
|
if(fill_time != H5D_FILL_TIME_ALLOC) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Got non-H5D_FILL_TIME_ALLOC fill value write time.");
|
|
|
|
|
printf(" Got %d\n", fill_time);
|
|
|
|
|
}
|
|
|
|
|
if (H5Dclose(dset6)<0) goto error;
|
|
|
|
|
if (H5Pclose(dcpl)<0) goto error;
|
|
|
|
|
|
|
|
|
|
/* 3. Compound datatype test */
|
|
|
|
|
if ((dset8=H5Dopen(file, "dset8"))<0) goto error;
|
|
|
|
|
if ((dcpl=H5Dget_create_plist(dset8))<0) goto error;
|
|
|
|
|
if (H5Pget_fill_value(dcpl, comp_type_id, &rd_c)<0) goto error;
|
|
|
|
|
if( rd_c.a != 0 || rd_c.y != fill_ctype.y || rd_c.x != 0 || rd_c.z!='\0') {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Got wrong fill value");
|
|
|
|
|
printf(" Got rd_c.a=%f, rd_c.y=%f and rd_c.x=%d, rd_c.z=%c\n",
|
|
|
|
|
rd_c.a, rd_c.y, rd_c.x, rd_c.z);
|
|
|
|
|
}
|
|
|
|
|
if (H5Dclose(dset8)<0) goto error;
|
|
|
|
|
if (H5Pclose(dcpl)<0) goto error;
|
|
|
|
|
|
1998-10-09 01:13:14 +08:00
|
|
|
|
if (H5Fclose(file)<0) goto error;
|
1998-11-24 04:40:35 +08:00
|
|
|
|
PASSED();
|
1998-10-06 05:01:10 +08:00
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
H5Pclose(dcpl);
|
|
|
|
|
H5Sclose(space);
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if(H5D_COMPACT != layout) {
|
|
|
|
|
H5Dclose(dset1);
|
|
|
|
|
H5Dclose(dset2);
|
|
|
|
|
H5Dclose(dset3);
|
|
|
|
|
H5Dclose(dset4);
|
|
|
|
|
H5Dclose(dset9);
|
|
|
|
|
}
|
2002-04-12 06:53:26 +08:00
|
|
|
|
H5Dclose(dset5);
|
|
|
|
|
H5Dclose(dset6);
|
|
|
|
|
H5Dclose(dset8);
|
1998-10-06 05:01:10 +08:00
|
|
|
|
H5Fclose(file);
|
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
2002-04-12 06:53:26 +08:00
|
|
|
|
* Function: test_rdwr_cases
|
1998-10-06 05:01:10 +08:00
|
|
|
|
*
|
2002-04-12 06:53:26 +08:00
|
|
|
|
* Purpose: Tests fill values read and write for datasets.
|
1998-10-06 05:01:10 +08:00
|
|
|
|
*
|
|
|
|
|
* Return: Success: 0
|
|
|
|
|
*
|
2002-04-12 06:53:26 +08:00
|
|
|
|
* Failure: 1
|
1998-10-06 05:01:10 +08:00
|
|
|
|
*
|
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Thursday, October 1, 1998
|
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
2002-04-12 06:53:26 +08:00
|
|
|
|
* This function is called by test_rdwr to write and read
|
|
|
|
|
* dataset for different cases.
|
1998-10-06 05:01:10 +08:00
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static int
|
2002-04-12 06:53:26 +08:00
|
|
|
|
test_rdwr_cases(hid_t file, hid_t dcpl, const char *dname, void *_fillval,
|
|
|
|
|
H5D_fill_time_t fill_time, H5D_layout_t layout,
|
|
|
|
|
H5T_class_t datatype, hid_t ctype_id)
|
1998-10-06 05:01:10 +08:00
|
|
|
|
{
|
2002-04-12 06:53:26 +08:00
|
|
|
|
hid_t fspace=-1, mspace=-1, dset1=-1, dset2=-1;
|
2002-08-21 00:18:02 +08:00
|
|
|
|
hsize_t cur_size[5] = {2, 16, 8, 4, 2};
|
1998-10-06 05:01:10 +08:00
|
|
|
|
hsize_t one[5] = {1, 1, 1, 1, 1};
|
1998-10-21 10:37:37 +08:00
|
|
|
|
hsize_t hs_size[5], hs_stride[5];
|
|
|
|
|
hssize_t hs_offset[5], nelmts;
|
2002-08-27 21:42:22 +08:00
|
|
|
|
int fillval=(-1), val_rd, should_be;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
int i, j, *buf=NULL, odd;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
comp_datatype rd_c, fill_c, should_be_c;
|
|
|
|
|
comp_datatype *buf_c=NULL;
|
|
|
|
|
H5D_space_status_t allocation;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
|
2002-04-12 06:53:26 +08:00
|
|
|
|
if (datatype==H5T_INTEGER)
|
|
|
|
|
fillval = *(int*)_fillval;
|
|
|
|
|
else if(datatype==H5T_COMPOUND) {
|
|
|
|
|
fill_c.a=((comp_datatype*)_fillval)->a;
|
|
|
|
|
fill_c.x=((comp_datatype*)_fillval)->x;
|
|
|
|
|
fill_c.y=((comp_datatype*)_fillval)->y;
|
|
|
|
|
fill_c.z=((comp_datatype*)_fillval)->z;
|
2002-08-27 21:42:22 +08:00
|
|
|
|
} else {
|
|
|
|
|
puts("Invalid type for test");
|
|
|
|
|
goto error;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
|
|
|
|
/* Create dataset */
|
1998-10-06 05:01:10 +08:00
|
|
|
|
if ((fspace=H5Screate_simple(5, cur_size, cur_size))<0) goto error;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
if (datatype==H5T_INTEGER && (dset1=H5Dcreate(file, dname, H5T_NATIVE_INT,
|
|
|
|
|
fspace, dcpl))<0) goto error;
|
|
|
|
|
if (datatype==H5T_COMPOUND && (dset2=H5Dcreate(file, dname, ctype_id,
|
|
|
|
|
fspace, dcpl))<0) goto error;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
|
|
|
|
|
/* 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;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
/* case for atomic datatype */
|
|
|
|
|
if (datatype==H5T_INTEGER) {
|
|
|
|
|
if(H5Dread(dset1, H5T_NATIVE_INT, mspace, fspace, H5P_DEFAULT,
|
|
|
|
|
&val_rd)<0) goto error;
|
|
|
|
|
if (fill_time!=H5D_FILL_TIME_NEVER && val_rd!=fillval) {
|
|
|
|
|
H5_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;
|
|
|
|
|
}
|
|
|
|
|
/* case for compound datatype */
|
|
|
|
|
} else if(datatype==H5T_COMPOUND) {
|
|
|
|
|
if(H5Dread(dset2, ctype_id, mspace, fspace, H5P_DEFAULT,
|
|
|
|
|
&rd_c)<0) goto error;
|
|
|
|
|
if (fill_time!=H5D_FILL_TIME_NEVER && (rd_c.a!=fill_c.a ||
|
|
|
|
|
rd_c.x!=fill_c.x || rd_c.y!=fill_c.y ||
|
|
|
|
|
rd_c.z!=fill_c.z)) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Value read was not a fill value.");
|
|
|
|
|
printf(" Elmt={%ld,%ld,%ld,%ld,%ld}, read: %f, %d, %f, %c"
|
|
|
|
|
"Fill value: %f, %d, %f, %c\n",
|
|
|
|
|
(long)hs_offset[0], (long)hs_offset[1],
|
|
|
|
|
(long)hs_offset[2], (long)hs_offset[3],
|
|
|
|
|
(long)hs_offset[4], rd_c.a, rd_c.x, rd_c.y, rd_c.z,
|
|
|
|
|
fill_c.a, fill_c.x, fill_c.y, fill_c.z);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
}
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
if (H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_offset, hs_stride,
|
2002-04-12 06:53:26 +08:00
|
|
|
|
hs_size, NULL)<0) goto error;
|
|
|
|
|
|
|
|
|
|
/* case for atomic datatype */
|
|
|
|
|
if(datatype==H5T_INTEGER) {
|
|
|
|
|
/*check for overflow*/
|
|
|
|
|
assert((nelmts*sizeof(int))==(hssize_t)((size_t)(nelmts*sizeof(int))));
|
|
|
|
|
buf = malloc((size_t)(nelmts*sizeof(int)));
|
|
|
|
|
for (i=0; i<nelmts; i++) buf[i] = 9999;
|
|
|
|
|
if (H5Dwrite(dset1, H5T_NATIVE_INT, mspace, fspace, H5P_DEFAULT,
|
|
|
|
|
buf)<0) goto error;
|
|
|
|
|
}
|
|
|
|
|
/* case for compound datatype */
|
|
|
|
|
else if(datatype==H5T_COMPOUND) {
|
|
|
|
|
assert((nelmts*sizeof(comp_datatype))==
|
|
|
|
|
(hssize_t)((size_t)(nelmts*sizeof(comp_datatype))));
|
|
|
|
|
buf_c = (comp_datatype*)calloc((size_t)nelmts,sizeof(comp_datatype));
|
|
|
|
|
for (i=0; i<nelmts; i++) {
|
|
|
|
|
buf_c[i].a = 1111.11;
|
|
|
|
|
buf_c[i].x = 2222;
|
|
|
|
|
buf_c[i].y = 3333.3333;
|
|
|
|
|
buf_c[i].z = 'd';
|
|
|
|
|
}
|
|
|
|
|
if (H5Dwrite(dset2, ctype_id, mspace, fspace, H5P_DEFAULT,
|
|
|
|
|
buf_c)<0) goto error;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Check if space is allocated */
|
|
|
|
|
if (datatype==H5T_INTEGER && H5Dget_space_status(dset1, &allocation)<0)
|
|
|
|
|
goto error;
|
|
|
|
|
if (datatype==H5T_COMPOUND && H5Dget_space_status(dset2, &allocation)<0)
|
|
|
|
|
goto error;
|
|
|
|
|
if (layout == H5D_CONTIGUOUS && allocation != H5D_SPACE_STATUS_ALLOCATED) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf(" %d: Got unallocated space instead of allocated.\n",__LINE__);
|
|
|
|
|
printf(" Got %d\n", allocation);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
1998-10-06 05:01:10 +08:00
|
|
|
|
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];
|
2001-11-28 00:29:13 +08:00
|
|
|
|
odd += (int)(hs_offset[j]%2);
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
|
|
|
|
if (H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_offset, NULL,
|
|
|
|
|
one, NULL)<0) goto error;
|
|
|
|
|
|
2002-04-12 06:53:26 +08:00
|
|
|
|
/* case for atomic datatype */
|
|
|
|
|
if (datatype==H5T_INTEGER) {
|
|
|
|
|
if (H5Dread(dset1, H5T_NATIVE_INT, mspace, fspace, H5P_DEFAULT,
|
|
|
|
|
&val_rd)<0) goto error;
|
|
|
|
|
if(fill_time == H5D_FILL_TIME_ALLOC) {
|
|
|
|
|
should_be = odd ? fillval : 9999;
|
|
|
|
|
if (val_rd!=should_be) {
|
|
|
|
|
H5_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;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if(fill_time == H5D_FILL_TIME_NEVER && !odd) {
|
|
|
|
|
should_be = 9999;
|
|
|
|
|
if (val_rd!=should_be) {
|
|
|
|
|
H5_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;
|
|
|
|
|
}
|
|
|
|
|
} else if(fill_time == H5D_FILL_TIME_NEVER && odd) {
|
|
|
|
|
/*Trash data. Don't compare*/
|
|
|
|
|
}
|
|
|
|
|
} /* end for datatype==H5T_INTEGER */
|
|
|
|
|
/* case for compound datatype */
|
|
|
|
|
else if (datatype==H5T_COMPOUND) {
|
|
|
|
|
if (H5Dread(dset2, ctype_id, mspace, fspace, H5P_DEFAULT,
|
|
|
|
|
&rd_c)<0) goto error;
|
|
|
|
|
if(fill_time == H5D_FILL_TIME_ALLOC) {
|
|
|
|
|
if(odd) {
|
|
|
|
|
should_be_c.a=fill_c.a;
|
|
|
|
|
should_be_c.x=fill_c.x;
|
|
|
|
|
should_be_c.y=fill_c.y;
|
|
|
|
|
should_be_c.z=fill_c.z;
|
|
|
|
|
} else {
|
|
|
|
|
should_be_c.a=buf_c[0].a;
|
|
|
|
|
should_be_c.x=buf_c[0].x;
|
|
|
|
|
should_be_c.y=buf_c[0].y;
|
|
|
|
|
should_be_c.z=buf_c[0].z;
|
|
|
|
|
}
|
|
|
|
|
if( rd_c.a!=should_be_c.a || rd_c.x!=should_be_c.x ||
|
|
|
|
|
rd_c.y!=should_be_c.y || rd_c.z!=should_be_c.z) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Value read was not correct.");
|
|
|
|
|
printf(" Elmt={%ld,%ld,%ld,%ld,%ld}, read: %f,%d,%f,%c "
|
|
|
|
|
"should be: %f,%d,%f,%c\n",
|
|
|
|
|
(long)hs_offset[0], (long)hs_offset[1],
|
|
|
|
|
(long)hs_offset[2], (long)hs_offset[3],
|
|
|
|
|
(long)hs_offset[4],
|
|
|
|
|
rd_c.a, rd_c.x, rd_c.y, rd_c.z, should_be_c.a,
|
|
|
|
|
should_be_c.x,should_be_c.y,should_be_c.z);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
} /* end for fill_time == H5D_FILL_TIME_ALLOC */
|
|
|
|
|
else if(fill_time == H5D_FILL_TIME_NEVER && !odd) {
|
|
|
|
|
should_be_c.a=buf_c[0].a;
|
|
|
|
|
should_be_c.x=buf_c[0].x;
|
|
|
|
|
should_be_c.y=buf_c[0].y;
|
|
|
|
|
should_be_c.z=buf_c[0].z;
|
|
|
|
|
if( rd_c.a!=should_be_c.a || rd_c.x!=should_be_c.x ||
|
|
|
|
|
rd_c.y!=should_be_c.y || rd_c.z!=should_be_c.z) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Value read was not correct.");
|
|
|
|
|
printf(" Elmt={%ld,%ld,%ld,%ld,%ld}, read: %f,%d,%f,%c "
|
|
|
|
|
"should be: %f,%d,%f,%c\n",
|
|
|
|
|
(long)hs_offset[0], (long)hs_offset[1],
|
|
|
|
|
(long)hs_offset[2], (long)hs_offset[3],
|
|
|
|
|
(long)hs_offset[4],
|
|
|
|
|
rd_c.a, rd_c.x, rd_c.y, rd_c.z, should_be_c.a,
|
|
|
|
|
should_be_c.x,should_be_c.y,should_be_c.z);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
} /* end for fill_time == H5D_FILL_TIME_NEVER */
|
|
|
|
|
else if(fill_time == H5D_FILL_TIME_NEVER && odd) {
|
|
|
|
|
/*Trash data. Don't compare*/
|
|
|
|
|
}
|
|
|
|
|
} /* end for datatype==H5T_COMPOUND */
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
1998-10-06 05:01:10 +08:00
|
|
|
|
if (H5Sclose(mspace)<0) goto error;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
if (datatype==H5T_INTEGER && H5Dclose(dset1)<0) goto error;
|
|
|
|
|
if (datatype==H5T_COMPOUND && H5Dclose(dset2)<0) goto error;
|
|
|
|
|
if (H5Sclose(fspace)<0) goto error;
|
|
|
|
|
return 0;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
|
2002-04-12 06:53:26 +08:00
|
|
|
|
error:
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
if(datatype==H5T_INTEGER) H5Dclose(dset1);
|
|
|
|
|
if(datatype==H5T_COMPOUND) H5Dclose(dset2);
|
|
|
|
|
H5Sclose(fspace);
|
|
|
|
|
H5Sclose(mspace);
|
|
|
|
|
} H5E_END_TRY;
|
2002-08-21 00:18:02 +08:00
|
|
|
|
|
2002-04-12 06:53:26 +08:00
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: test_rdwr
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Tests fill values for datasets.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: 0
|
|
|
|
|
*
|
|
|
|
|
* Failure: number of errors
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Thursday, October 1, 1998
|
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
* Many new cases have been added to this test since the
|
|
|
|
|
* fill value design is modified.
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
test_rdwr(hid_t fapl, const char *base_name, H5D_layout_t layout)
|
|
|
|
|
{
|
|
|
|
|
char filename[1024];
|
|
|
|
|
hid_t file=-1, dcpl=-1, ctype_id=-1;
|
2002-08-21 00:18:02 +08:00
|
|
|
|
hsize_t ch_size[5] = {2, 16, 8, 4, 2};
|
2002-04-12 06:53:26 +08:00
|
|
|
|
int nerrors=0;
|
|
|
|
|
int fillval = 0x4c70f1cd;
|
2002-07-02 03:16:43 +08:00
|
|
|
|
comp_datatype fill_ctype={0,0,0,0};
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
|
|
|
|
if (H5D_CHUNKED==layout) {
|
|
|
|
|
TESTING("chunked dataset I/O");
|
2002-08-21 00:18:02 +08:00
|
|
|
|
} else if (H5D_COMPACT==layout) {
|
|
|
|
|
TESTING("compact dataset I/O");
|
2002-04-12 06:53:26 +08:00
|
|
|
|
} else {
|
|
|
|
|
TESTING("contiguous dataset I/O");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
h5_fixname(base_name, fapl, filename, sizeof filename);
|
|
|
|
|
if ((file=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl))<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;
|
2002-08-21 00:18:02 +08:00
|
|
|
|
} else if (H5D_COMPACT==layout) {
|
|
|
|
|
if (H5Pset_layout(dcpl, H5D_COMPACT)<0) goto error;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
}
|
|
|
|
|
if ((ctype_id=create_compound_type())<0) goto error;
|
|
|
|
|
|
|
|
|
|
|
2002-09-14 00:57:46 +08:00
|
|
|
|
/* I. Test H5D_ALLOC_TIME_LATE space allocation cases */
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if(H5D_COMPACT != layout) {
|
2002-09-14 00:57:46 +08:00
|
|
|
|
if(H5Pset_alloc_time(dcpl, H5D_ALLOC_TIME_LATE) < 0) goto error;
|
2002-08-21 00:18:02 +08:00
|
|
|
|
|
|
|
|
|
/* case for H5D_FILL_TIME_ALLOC as fill write time and fill value to be default */
|
|
|
|
|
if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) goto error;
|
|
|
|
|
fillval = 0;
|
|
|
|
|
nerrors += test_rdwr_cases(file, dcpl, "dset1", &fillval, H5D_FILL_TIME_ALLOC,
|
|
|
|
|
layout, H5T_INTEGER, -1);
|
|
|
|
|
|
|
|
|
|
/* case for H5D_FILL_TIME_NEVER as fill write time and fill value to be default */
|
|
|
|
|
if (H5Pset_fill_time(dcpl, H5D_FILL_TIME_NEVER) < 0) goto error;
|
|
|
|
|
nerrors += test_rdwr_cases(file, dcpl, "dset2", &fillval, H5D_FILL_TIME_NEVER,
|
2002-04-12 06:53:26 +08:00
|
|
|
|
layout, H5T_INTEGER, -1);
|
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* case for H5D_FILL_TIME_ALLOC as fill write time and fill value is user-defined */
|
|
|
|
|
if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) goto error;
|
|
|
|
|
fillval = 0x4c70f1cd;
|
|
|
|
|
if (H5Pset_fill_value(dcpl, H5T_NATIVE_INT, &fillval)<0) goto error;
|
|
|
|
|
nerrors += test_rdwr_cases(file, dcpl, "dset3", &fillval, H5D_FILL_TIME_ALLOC,
|
2002-04-12 06:53:26 +08:00
|
|
|
|
layout, H5T_INTEGER, -1);
|
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* case for H5D_FILL_TIME_NEVER as fill write time and fill value is user-defined */
|
|
|
|
|
if (H5Pset_fill_time(dcpl, H5D_FILL_TIME_NEVER) < 0) goto error;
|
|
|
|
|
if (H5Pset_fill_value(dcpl, H5T_NATIVE_INT, &fillval)<0) goto error;
|
|
|
|
|
nerrors += test_rdwr_cases(file, dcpl, "dset4", &fillval, H5D_FILL_TIME_NEVER,
|
2002-04-12 06:53:26 +08:00
|
|
|
|
layout, H5T_INTEGER, -1);
|
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* case for H5D_FILL_TIME_ALLOC as fill write time and fill value is undefined */
|
|
|
|
|
/* This case has been tested in test_create() function */
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* case for H5D_FILL_TIME_NEVER as fill write time and fill value is undefined */
|
|
|
|
|
if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_NEVER) < 0) goto error;
|
|
|
|
|
if (H5Pset_fill_value(dcpl, -1, NULL)<0) goto error;
|
|
|
|
|
nerrors += test_rdwr_cases(file, dcpl, "dset5", &fillval, H5D_FILL_TIME_NEVER,
|
2002-04-12 06:53:26 +08:00
|
|
|
|
layout, H5T_INTEGER, -1);
|
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
/* case for H5D_FILL_TIME_ALLOC as fill write time and fill value is user-defined
|
|
|
|
|
* as compound type */
|
|
|
|
|
if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) goto error;
|
|
|
|
|
fill_ctype.y = 4444.4444;
|
|
|
|
|
if(H5Pset_fill_value(dcpl, ctype_id, &fill_ctype)<0) goto error;
|
|
|
|
|
nerrors += test_rdwr_cases(file, dcpl, "dset11", &fill_ctype, H5D_FILL_TIME_ALLOC,
|
2002-04-12 06:53:26 +08:00
|
|
|
|
layout, H5T_COMPOUND, ctype_id);
|
1998-10-06 05:01:10 +08:00
|
|
|
|
|
2002-08-21 00:18:02 +08:00
|
|
|
|
if (H5Pclose(dcpl)<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;
|
|
|
|
|
}
|
2002-04-12 06:53:26 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2002-09-14 00:57:46 +08:00
|
|
|
|
/* II. Test H5D_ALLOC_TIME_EARLY space allocation cases */
|
|
|
|
|
if(H5Pset_alloc_time(dcpl, H5D_ALLOC_TIME_EARLY) < 0) goto error;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
|
|
|
|
/* case for H5D_FILL_TIME_ALLOC as fill write time and fill value to be default */
|
|
|
|
|
if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) goto error;
|
|
|
|
|
fillval = 0;
|
|
|
|
|
nerrors += test_rdwr_cases(file, dcpl, "dset6", &fillval, H5D_FILL_TIME_ALLOC,
|
|
|
|
|
layout, H5T_INTEGER, -1);
|
|
|
|
|
|
|
|
|
|
/* case for H5D_FILL_TIME_NEVER as fill write time and fill value to be default */
|
|
|
|
|
if (H5Pset_fill_time(dcpl, H5D_FILL_TIME_NEVER) < 0) goto error;
|
|
|
|
|
nerrors += test_rdwr_cases(file, dcpl, "dset7", &fillval, H5D_FILL_TIME_NEVER, layout,
|
2002-08-21 00:18:02 +08:00
|
|
|
|
H5T_INTEGER, -1);
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
|
|
|
|
/* case for H5D_FILL_TIME_ALLOC as fill write time and fill value is user-defined */
|
|
|
|
|
if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) goto error;
|
|
|
|
|
fillval = 0x4c70f1cd;
|
|
|
|
|
if (H5Pset_fill_value(dcpl, H5T_NATIVE_INT, &fillval)<0) goto error;
|
|
|
|
|
nerrors += test_rdwr_cases(file, dcpl, "dset8", &fillval, H5D_FILL_TIME_ALLOC,
|
|
|
|
|
layout, H5T_INTEGER, -1);
|
|
|
|
|
|
|
|
|
|
/* case for H5D_FILL_TIME_NEVER as fill write time and fill value is user-defined */
|
|
|
|
|
if (H5Pset_fill_time(dcpl, H5D_FILL_TIME_NEVER) < 0) goto error;
|
|
|
|
|
if (H5Pset_fill_value(dcpl, H5T_NATIVE_INT, &fillval)<0) goto error;
|
|
|
|
|
nerrors += test_rdwr_cases(file, dcpl, "dset9", &fillval, H5D_FILL_TIME_NEVER,
|
|
|
|
|
layout, H5T_INTEGER, -1);
|
|
|
|
|
|
|
|
|
|
/* case for H5D_FILL_TIME_ALLOC as fill write time and fill value is undefined */
|
|
|
|
|
/* This case has been tested in test_create() function */
|
|
|
|
|
|
|
|
|
|
/* case for H5D_FILL_TIME_NEVER as fill write time and fill value is undefined */
|
|
|
|
|
if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_NEVER) < 0) goto error;
|
|
|
|
|
if (H5Pset_fill_value(dcpl, -1, NULL)<0) goto error;
|
|
|
|
|
nerrors += test_rdwr_cases(file, dcpl, "dset10", &fillval, H5D_FILL_TIME_NEVER,
|
|
|
|
|
layout, H5T_INTEGER, -1);
|
|
|
|
|
|
|
|
|
|
/* case for H5D_FILL_TIME_ALLOC as fill write time and fill value is user-defined
|
|
|
|
|
* as compound type */
|
|
|
|
|
if(H5Pset_fill_time(dcpl, H5D_FILL_TIME_ALLOC) < 0) goto error;
|
|
|
|
|
fill_ctype.y = 4444.4444;
|
|
|
|
|
if(H5Pset_fill_value(dcpl, ctype_id, &fill_ctype)<0) goto error;
|
|
|
|
|
nerrors += test_rdwr_cases(file, dcpl, "dset12", &fill_ctype, H5D_FILL_TIME_ALLOC,
|
|
|
|
|
layout, H5T_COMPOUND, ctype_id);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if(nerrors)
|
|
|
|
|
goto error;
|
|
|
|
|
if (H5Pclose(dcpl)<0) goto error;
|
|
|
|
|
if (H5Tclose(ctype_id)<0) goto error;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
if (H5Fclose(file)<0) goto error;
|
1998-11-24 04:40:35 +08:00
|
|
|
|
PASSED();
|
1998-10-06 05:01:10 +08:00
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
H5E_BEGIN_TRY {
|
2002-04-12 06:53:26 +08:00
|
|
|
|
H5Pclose(dcpl);
|
|
|
|
|
H5Tclose(ctype_id);
|
|
|
|
|
H5Fclose(file);
|
1998-10-06 05:01:10 +08:00
|
|
|
|
} H5E_END_TRY;
|
2002-04-12 06:53:26 +08:00
|
|
|
|
return nerrors;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* 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
|
1999-06-15 22:58:25 +08:00
|
|
|
|
test_extend(hid_t fapl, const char *base_name, H5D_layout_t layout)
|
1998-10-06 05:01:10 +08:00
|
|
|
|
{
|
1998-11-03 01:58:28 +08:00
|
|
|
|
hid_t file=-1, fspace=-1, mspace=-1, dcpl=-1, dset=-1;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
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};
|
1998-10-21 10:37:37 +08:00
|
|
|
|
hsize_t hs_size[5], hs_stride[5];
|
|
|
|
|
hssize_t hs_offset[5], nelmts;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
#ifdef NO_FILLING
|
|
|
|
|
int fillval = 0;
|
|
|
|
|
#else
|
|
|
|
|
int fillval = 0x4c70f1cd;
|
|
|
|
|
#endif
|
|
|
|
|
int val_rd, should_be;
|
|
|
|
|
int i, j, *buf=NULL, odd, fd;
|
1998-11-24 04:40:35 +08:00
|
|
|
|
char filename[1024];
|
1998-10-06 05:01:10 +08:00
|
|
|
|
|
|
|
|
|
if (H5D_CHUNKED==layout) {
|
1998-11-24 04:40:35 +08:00
|
|
|
|
TESTING("chunked dataset extend");
|
1998-10-06 05:01:10 +08:00
|
|
|
|
} else {
|
1998-11-24 04:40:35 +08:00
|
|
|
|
TESTING("contiguous dataset extend");
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
2001-01-10 05:22:30 +08:00
|
|
|
|
if (H5Pset_external(dcpl, FILE_NAME_RAW, (off_t)0, (hsize_t)nelmts*sizeof(int))<0)
|
1998-10-06 05:01:10 +08:00
|
|
|
|
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) {
|
1998-11-24 04:40:35 +08:00
|
|
|
|
SKIPPED();
|
|
|
|
|
puts(" Not implemented yet -- needs H5S_SELECT_DIFF operator");
|
1999-01-07 19:42:04 +08:00
|
|
|
|
goto skip;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Create a file and dataset */
|
1999-06-15 22:58:25 +08:00
|
|
|
|
h5_fixname(base_name, fapl, filename, sizeof filename);
|
1998-11-24 04:40:35 +08:00
|
|
|
|
if ((file=H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl))<0)
|
|
|
|
|
goto error;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
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) {
|
2001-01-26 01:03:29 +08:00
|
|
|
|
H5_FAILED();
|
1998-11-24 04:40:35 +08:00
|
|
|
|
puts(" Value read was not a fill value.");
|
|
|
|
|
printf(" Elmt={%ld,%ld,%ld,%ld,%ld}, read: %u, "
|
1998-10-06 05:01:10 +08:00
|
|
|
|
"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;
|
2001-01-10 05:22:30 +08:00
|
|
|
|
assert((nelmts*sizeof(int))==(hssize_t)((size_t)(nelmts*sizeof(int)))); /*check for overflow*/
|
|
|
|
|
buf = malloc((size_t)(nelmts*sizeof(int)));
|
1998-10-06 05:01:10 +08:00
|
|
|
|
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];
|
2001-11-28 00:29:13 +08:00
|
|
|
|
odd += (int)(hs_offset[j]%2);
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
|
|
|
|
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) {
|
2001-01-26 01:03:29 +08:00
|
|
|
|
H5_FAILED();
|
1998-11-24 04:40:35 +08:00
|
|
|
|
puts(" Value read was not correct.");
|
|
|
|
|
printf(" Elmt={%ld,%ld,%ld,%ld,%ld}, read: %u, "
|
1998-10-06 05:01:10 +08:00
|
|
|
|
"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 {
|
2001-11-28 00:29:13 +08:00
|
|
|
|
odd += (int)(hs_offset[j]%2);
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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) {
|
2001-01-26 01:03:29 +08:00
|
|
|
|
H5_FAILED();
|
1998-11-24 04:40:35 +08:00
|
|
|
|
puts(" Value read was not correct.");
|
|
|
|
|
printf(" Elmt={%ld,%ld,%ld,%ld,%ld}, read: %u, "
|
1998-10-06 05:01:10 +08:00
|
|
|
|
"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;
|
1998-11-24 04:40:35 +08:00
|
|
|
|
PASSED();
|
1998-10-06 05:01:10 +08:00
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
H5Dclose(dset);
|
|
|
|
|
H5Sclose(fspace);
|
|
|
|
|
H5Sclose(mspace);
|
|
|
|
|
H5Pclose(dcpl);
|
|
|
|
|
H5Fclose(file);
|
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
return 1;
|
1999-01-07 19:42:04 +08:00
|
|
|
|
|
|
|
|
|
skip:
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
H5Dclose(dset);
|
|
|
|
|
H5Sclose(fspace);
|
|
|
|
|
H5Sclose(mspace);
|
|
|
|
|
H5Pclose(dcpl);
|
|
|
|
|
H5Fclose(file);
|
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
return 0;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: test_compatible
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Tests fill value and dataspace for datasets created by v1.4
|
|
|
|
|
* library.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: 0
|
|
|
|
|
*
|
|
|
|
|
* Failure: number of errors
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Raymond Lu
|
|
|
|
|
* Feb 27, 2002
|
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
static int
|
|
|
|
|
test_compatible(void)
|
|
|
|
|
{
|
|
|
|
|
hid_t file=-1, dset1=-1, dset2=-1;
|
|
|
|
|
hid_t dcpl1=-1, dcpl2=-1, fspace=-1, mspace=-1;
|
|
|
|
|
int rd_fill=0, fill_val=4444, val_rd=0;
|
|
|
|
|
hsize_t dims[2], one[2]={1,1};
|
|
|
|
|
hssize_t hs_offset[2]={3,4};
|
|
|
|
|
H5D_fill_value_t status;
|
2002-04-13 05:08:48 +08:00
|
|
|
|
char *srcdir = getenv("srcdir"); /*where the src code is located*/
|
|
|
|
|
char testfile[512]=""; /* test file name */
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
[svn-r6252] Purpose:
Lots of performance improvements & a couple new internal API interfaces.
Description:
Performance Improvements:
- Cached file offset & length sizes in shared file struct, to avoid
constantly looking them up in the FCPL.
- Generic property improvements:
- Added "revision" number to generic property classes to speed
up comparisons.
- Changed method of storing properties from using a hash-table
to the TBBT routines in the library.
- Share the propery names between classes and the lists derived
from them.
- Removed redundant 'def_value' buffer from each property.
- Switching code to use a "copy on write" strategy for
properties in each list, where the properties in each list
are shared with the properties in the class, until a
property's value is changed in a list.
- Fixed error in layout code which was allocating too many buffers.
- Redefined public macros of the form (H5open()/H5check, <variable>)
internally to only be (<variable>), avoiding innumerable useless
calls to H5open() and H5check_version().
- Reuse already zeroed buffers in H5F_contig_fill instead of
constantly re-zeroing them.
- Don't write fill values if writing entire dataset.
- Use gettimeofday() system call instead of time() system when
checking the modification time of a dataset.
- Added reference counted string API and use it for tracking the
names of objects opening in a file (for the ID->name code).
- Removed redundant H5P_get() calls in B-tree routines.
- Redefine H5T datatype macros internally to the library, to avoid
calling H5check redundantly.
- Keep dataspace information for dataset locally instead of reading
from disk each time. Added new module to track open objects
in a file, to allow this (which will be useful eventually for
some FPH5 metadata caching issues).
- Remove H5AC_find macro which was inlining metadata cache lookups,
and call function instead.
- Remove redundant memset() calls from H5G_namei() routine.
- Remove redundant checking of object type when locating objects
in metadata cache and rely on the address only.
- Create default dataset object to use when default dataset creation
property list is used to create datasets, bypassing querying
for all the property list values.
- Use default I/O vector size when performing raw data with the
default dataset transfer property list, instead of querying for
I/O vector size.
- Remove H5P_DEFAULT internally to the library, replacing it with
more specific default property list based on the type of
property list needed.
- Remove redundant memset() calls in object header message (H5O*)
routines.
- Remove redunant memset() calls in data I/O routines.
- Split free-list allocation routines into malloc() and calloc()-
like routines, instead of one combined routine.
- Remove lots of indirection in H5O*() routines.
- Simplify metadata cache entry comparison routine (used when
flushing entire cache out).
- Only enable metadata cache statistics when H5AC_DEBUG is turned
on, instead of always tracking them.
- Simplify address comparison macro (H5F_addr_eq).
- Remove redundant metadata cache entry protections during dataset
creation by protecting the object header once and making all
the modifications necessary for the dataset creation before
unprotecting it.
- Reduce # of "number of element in extent" computations performed
by computing and storing the value during dataspace creation.
- Simplify checking for group location's file information, when file
has not been involving in file-mounting operations.
- Use binary encoding for modification time, instead of ASCII.
- Hoist H5HL_peek calls (to get information in a local heap)
out of loops in many group routine.
- Use static variable for iterators of selections, instead of
dynamically allocation them each time.
- Lookup & insert new entries in one step, avoiding traversing
group's B-tree twice.
- Fixed memory leak in H5Gget_objname_idx() routine (tangential to
performance improvements, but fixed along the way).
- Use free-list for reference counted strings.
- Don't bother copying object names into cached group entries,
since they are re-created when an object is opened.
The benchmark I used to measure these results created several thousand
small (2K) datasets in a file and wrote out the data for them. This is
Elena's "regular.c" benchmark.
These changes resulted in approximately ~4.3x speedup of the
development branch when compared to the previous code in the
development branch and ~1.4x speedup compared to the release
branch.
Additionally, these changes reduce the total memory used (code and
data) by the development branch by ~800KB, bringing the development
branch back into the same ballpark as the release branch.
I'll send out a more detailed description of the benchmark results
as a followup note.
New internal API routines:
Added "reference counted strings" API for tracking strings that get
used by multiple owners without duplicating the strings.
Added "ternary search tree" API for text->object mappings.
Platforms tested:
Tested h5committest {arabica (fortran), eirene (fortran, C++)
modi4 (parallel, fortran)}
Other platforms/configurations tested?
FreeBSD 4.7 (sleipnir) serial & parallel
Solaris 2.6 (baldric) serial
2003-01-10 01:20:03 +08:00
|
|
|
|
TESTING("contiguous dataset compatibility with v. 1.4");
|
2002-04-13 05:08:48 +08:00
|
|
|
|
|
|
|
|
|
/* Generate correct name for test file by prepending the source path */
|
|
|
|
|
if(srcdir && ((strlen(srcdir) + strlen(FILE_COMPATIBLE) + 1) <
|
|
|
|
|
sizeof(testfile))) {
|
|
|
|
|
strcpy(testfile, srcdir);
|
|
|
|
|
strcat(testfile, "/");
|
|
|
|
|
}
|
|
|
|
|
strcat(testfile, FILE_COMPATIBLE);
|
|
|
|
|
|
2002-10-31 21:40:24 +08:00
|
|
|
|
if ((file=H5Fopen(testfile, H5F_ACC_RDONLY, H5P_DEFAULT))<0) {
|
|
|
|
|
printf(" Could not open file %s. Try set $srcdir to point at the "
|
|
|
|
|
"source directory of test\n", testfile);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
2002-04-12 06:53:26 +08:00
|
|
|
|
|
|
|
|
|
if((dset1=H5Dopen(file, "dset1"))<0) goto error;
|
|
|
|
|
if ((dcpl1=H5Dget_create_plist(dset1))<0) goto error;
|
|
|
|
|
if (H5Pfill_value_defined(dcpl1, &status)<0) goto error;
|
|
|
|
|
if(status != H5D_FILL_VALUE_UNDEFINED) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf(" %d: Got a different fill value than what was set.",__LINE__);
|
|
|
|
|
printf(" Got status=%ld, suppose to be H5D_FILL_VALUE_UNDEFINED\n",
|
|
|
|
|
(long)status);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
if((fspace = H5Dget_space(dset1))<0) goto error;
|
|
|
|
|
if(H5Sget_simple_extent_dims(fspace, dims, NULL)<0) goto error;
|
|
|
|
|
if(dims[0] != 8 || dims[1] != 8) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Got a different dimension size than what was set.");
|
|
|
|
|
printf(" Got dims[0]=%ld, dims[1]=%ld, set 8x8\n", (long)dims[0], (long)dims[1]);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
if((mspace=H5Screate_simple(2, one, NULL))<0) goto error;
|
|
|
|
|
if(H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_offset, NULL, one, NULL)<0)
|
|
|
|
|
goto error;
|
|
|
|
|
if(H5Dread(dset1, H5T_NATIVE_INT, mspace, fspace, H5P_DEFAULT, &val_rd)<0)
|
|
|
|
|
goto error;
|
|
|
|
|
if (val_rd != 0) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Got a different value than what was set.");
|
|
|
|
|
printf(" Got %ld, set 0\n", (long)val_rd);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
if(H5Pclose(dcpl1)<0) goto error;
|
|
|
|
|
if(H5Sclose(fspace)<0) goto error;
|
|
|
|
|
if(H5Sclose(mspace)<0) goto error;
|
|
|
|
|
if(H5Dclose(dset1)<0) goto error;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
if((dset2=H5Dopen(file, "dset2"))<0) goto error;
|
|
|
|
|
if ((dcpl2=H5Dget_create_plist(dset2))<0) goto error;
|
|
|
|
|
if (H5Pfill_value_defined(dcpl2, &status)<0) goto error;
|
|
|
|
|
if(status != H5D_FILL_VALUE_USER_DEFINED) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf(" %d: Got a different fill value than what was set.",__LINE__);
|
|
|
|
|
printf(" Got status=%ld, suppose to be H5D_FILL_VALUE_USER_DEFINED\n",
|
|
|
|
|
(long)status);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
if (H5Pget_fill_value(dcpl2, H5T_NATIVE_INT, &rd_fill)<0) goto error;
|
|
|
|
|
if (rd_fill != fill_val) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf(" %d: Got a different fill value than what was set.",__LINE__);
|
|
|
|
|
printf(" Got %ld, set %ld\n", (long)rd_fill, (long)fill_val);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
fspace = -1;
|
|
|
|
|
if((fspace = H5Dget_space(dset2))<0) goto error;
|
|
|
|
|
dims[0] = dims[1] = (hsize_t)-1;
|
|
|
|
|
if(H5Sget_simple_extent_dims(fspace, dims, NULL)<0) goto error;
|
|
|
|
|
if(dims[0] != 8 || dims[1] != 8) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Got a different dimension size than what was set.");
|
|
|
|
|
printf(" Got dims[0]=%ld, dims[1]=%ld, set 8x8\n", (long)dims[0], (long)dims[1]);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
if((mspace=H5Screate_simple(2, one, NULL))<0) goto error;
|
|
|
|
|
if(H5Sselect_hyperslab(fspace, H5S_SELECT_SET, hs_offset, NULL, one, NULL)<0)
|
|
|
|
|
goto error;
|
|
|
|
|
if(H5Dread(dset2, H5T_NATIVE_INT, mspace, fspace, H5P_DEFAULT, &val_rd)<0)
|
|
|
|
|
goto error;
|
|
|
|
|
if (val_rd != fill_val) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
puts(" Got a different value than what was set.");
|
|
|
|
|
printf(" Got %ld, set %ld\n", (long)val_rd, (long)fill_val);
|
|
|
|
|
goto error;
|
|
|
|
|
}
|
|
|
|
|
if(H5Pclose(dcpl2)<0) goto error;
|
|
|
|
|
if(H5Sclose(fspace)<0) goto error;
|
|
|
|
|
if(H5Sclose(mspace)<0) goto error;
|
|
|
|
|
if(H5Dclose(dset2)<0) goto error;
|
|
|
|
|
|
|
|
|
|
if(H5Fclose(file)<0) goto error;
|
|
|
|
|
PASSED();
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
H5Pclose(dcpl1);
|
|
|
|
|
H5Sclose(fspace);
|
|
|
|
|
H5Sclose(mspace);
|
|
|
|
|
H5Dclose(dset1);
|
|
|
|
|
H5Pclose(dcpl2);
|
|
|
|
|
H5Sclose(fspace);
|
|
|
|
|
H5Dclose(dset2);
|
|
|
|
|
H5Fclose(file);
|
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
1998-10-06 05:01:10 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: main
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Tests fill values
|
|
|
|
|
*
|
|
|
|
|
* Return: Success:
|
|
|
|
|
*
|
|
|
|
|
* Failure:
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Robb Matzke
|
|
|
|
|
* Thursday, October 1, 1998
|
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
int
|
|
|
|
|
main(int argc, char *argv[])
|
|
|
|
|
{
|
2002-08-21 00:18:02 +08:00
|
|
|
|
int nerrors=0, argno, test_contig=1, test_chunk=1, test_compact=1;
|
1998-11-24 04:40:35 +08:00
|
|
|
|
hid_t fapl=-1;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
|
|
|
|
|
if (argc>=2) {
|
2002-08-21 00:18:02 +08:00
|
|
|
|
test_contig = test_chunk = test_compact = 0;
|
1998-10-06 05:01:10 +08:00
|
|
|
|
for (argno=1; argno<argc; argno++) {
|
|
|
|
|
if (!strcmp(argv[argno], "contiguous")) {
|
|
|
|
|
test_contig = 1;
|
|
|
|
|
} else if (!strcmp(argv[argno], "chunked")) {
|
|
|
|
|
test_chunk = 1;
|
2002-08-21 00:18:02 +08:00
|
|
|
|
} else if (!strcmp(argv[argno], "compact")) {
|
|
|
|
|
test_compact =1;
|
|
|
|
|
} else {
|
|
|
|
|
fprintf(stderr, "usage: %s [contiguous] [chunked] [compact]\n", argv[0]);
|
1998-10-06 05:01:10 +08:00
|
|
|
|
exit(1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1998-11-24 04:40:35 +08:00
|
|
|
|
h5_reset();
|
|
|
|
|
fapl = h5_fileaccess();
|
1998-10-06 05:01:10 +08:00
|
|
|
|
|
|
|
|
|
nerrors += test_getset();
|
|
|
|
|
|
|
|
|
|
/* Chunked storage layout tests */
|
|
|
|
|
if (test_chunk) {
|
1998-11-24 04:40:35 +08:00
|
|
|
|
nerrors += test_create(fapl, FILENAME[0], H5D_CHUNKED);
|
|
|
|
|
nerrors += test_rdwr (fapl, FILENAME[2], H5D_CHUNKED);
|
|
|
|
|
nerrors += test_extend(fapl, FILENAME[4], H5D_CHUNKED);
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Contiguous storage layout tests */
|
|
|
|
|
if (test_contig) {
|
1998-11-24 04:40:35 +08:00
|
|
|
|
nerrors += test_create(fapl, FILENAME[1], H5D_CONTIGUOUS);
|
|
|
|
|
nerrors += test_rdwr (fapl, FILENAME[3], H5D_CONTIGUOUS);
|
|
|
|
|
nerrors += test_extend(fapl, FILENAME[5], H5D_CONTIGUOUS);
|
2002-04-12 06:53:26 +08:00
|
|
|
|
nerrors += test_compatible();
|
1998-10-06 05:01:10 +08:00
|
|
|
|
}
|
2002-08-21 00:18:02 +08:00
|
|
|
|
|
|
|
|
|
/* Compact dataset storage tests */
|
|
|
|
|
if (test_compact) {
|
|
|
|
|
nerrors += test_create(fapl, FILENAME[6], H5D_COMPACT);
|
|
|
|
|
nerrors += test_rdwr (fapl, FILENAME[7], H5D_COMPACT);
|
|
|
|
|
}
|
|
|
|
|
|
1998-10-06 05:01:10 +08:00
|
|
|
|
if (nerrors) goto error;
|
|
|
|
|
puts("All fill value tests passed.");
|
2000-09-10 08:08:27 +08:00
|
|
|
|
if (h5_cleanup(FILENAME, fapl)) remove(FILE_NAME_RAW);
|
1998-10-06 05:01:10 +08:00
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
error:
|
|
|
|
|
puts("***** FILL VALUE TESTS FAILED *****");
|
|
|
|
|
return 1;
|
|
|
|
|
}
|