2003-04-01 01:59:04 +08:00
|
|
|
|
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
|
2007-02-07 22:56:24 +08:00
|
|
|
|
* Copyright by The HDF Group. *
|
2003-04-01 01:59:04 +08:00
|
|
|
|
* Copyright by the Board of Trustees of the University of Illinois. *
|
|
|
|
|
* All rights reserved. *
|
|
|
|
|
* *
|
|
|
|
|
* This file is part of HDF5. The full HDF5 copyright notice, including *
|
|
|
|
|
* terms governing use, modification, and redistribution, is contained in *
|
2017-04-15 00:54:16 +08:00
|
|
|
|
* the COPYING file, which can be found at the root of the source code *
|
|
|
|
|
* distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases. *
|
|
|
|
|
* If you do not have access to either file, you may request a copy from *
|
|
|
|
|
* help@hdfgroup.org. *
|
2003-04-01 01:59:04 +08:00
|
|
|
|
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
1997-09-04 21:03:31 +08:00
|
|
|
|
|
|
|
|
|
/***********************************************************
|
|
|
|
|
*
|
2003-04-09 03:53:01 +08:00
|
|
|
|
* Test program: th5s
|
1997-09-04 21:03:31 +08:00
|
|
|
|
*
|
|
|
|
|
* Test the dataspace functionality
|
|
|
|
|
*
|
|
|
|
|
*************************************************************/
|
|
|
|
|
|
2001-04-04 02:09:16 +08:00
|
|
|
|
#include "testhdf5.h"
|
2010-03-18 20:23:04 +08:00
|
|
|
|
#include "H5srcdir.h"
|
1997-09-04 21:03:31 +08:00
|
|
|
|
|
2001-04-04 02:09:16 +08:00
|
|
|
|
#include "H5private.h"
|
|
|
|
|
#include "H5Bprivate.h"
|
|
|
|
|
#include "H5Sprivate.h"
|
|
|
|
|
#include "H5Pprivate.h"
|
1997-09-04 21:03:31 +08:00
|
|
|
|
|
2000-10-21 04:57:56 +08:00
|
|
|
|
#define TESTFILE "th5s.h5"
|
2001-04-01 11:25:53 +08:00
|
|
|
|
#define DATAFILE "th5s1.h5"
|
2004-04-09 05:23:19 +08:00
|
|
|
|
#define NULLFILE "th5s2.h5"
|
2004-07-28 00:55:19 +08:00
|
|
|
|
#define BASICFILE "th5s3.h5"
|
2011-04-08 05:56:38 +08:00
|
|
|
|
#define ZEROFILE "th5s4.h5"
|
|
|
|
|
#define BASICDATASET "basic_dataset"
|
|
|
|
|
#define BASICDATASET1 "basic_dataset1"
|
2004-07-28 00:55:19 +08:00
|
|
|
|
#define BASICDATASET2 "basic_dataset2"
|
2011-04-08 05:56:38 +08:00
|
|
|
|
#define BASICDATASET3 "basic_dataset3"
|
|
|
|
|
#define BASICDATASET4 "basic_dataset4"
|
2004-07-28 00:55:19 +08:00
|
|
|
|
#define BASICATTR "basic_attribute"
|
2004-04-09 05:23:19 +08:00
|
|
|
|
#define NULLDATASET "null_dataset"
|
|
|
|
|
#define NULLATTR "null_attribute"
|
2011-04-08 05:56:38 +08:00
|
|
|
|
#define EXTFILE_NAME "ext_file"
|
1997-09-04 21:03:31 +08:00
|
|
|
|
|
|
|
|
|
/* 3-D dataset with fixed dimensions */
|
1998-04-09 05:43:02 +08:00
|
|
|
|
#define SPACE1_RANK 3
|
|
|
|
|
#define SPACE1_DIM1 3
|
|
|
|
|
#define SPACE1_DIM2 15
|
|
|
|
|
#define SPACE1_DIM3 13
|
1997-09-04 21:03:31 +08:00
|
|
|
|
|
|
|
|
|
/* 4-D dataset with one unlimited dimension */
|
1998-04-09 05:43:02 +08:00
|
|
|
|
#define SPACE2_RANK 4
|
|
|
|
|
#define SPACE2_DIM1 0
|
|
|
|
|
#define SPACE2_DIM2 15
|
|
|
|
|
#define SPACE2_DIM3 13
|
|
|
|
|
#define SPACE2_DIM4 23
|
1998-07-07 05:01:59 +08:00
|
|
|
|
#define SPACE2_MAX1 H5S_UNLIMITED
|
|
|
|
|
#define SPACE2_MAX2 15
|
|
|
|
|
#define SPACE2_MAX3 13
|
|
|
|
|
#define SPACE2_MAX4 23
|
1997-09-04 21:03:31 +08:00
|
|
|
|
|
1998-04-29 06:33:07 +08:00
|
|
|
|
/* Scalar dataset with simple datatype */
|
|
|
|
|
#define SPACE3_RANK 0
|
1998-06-19 05:03:30 +08:00
|
|
|
|
unsigned space3_data=65;
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
|
|
|
|
/* Scalar dataset with compound datatype */
|
|
|
|
|
#define SPACE4_FIELDNAME1 "c1"
|
|
|
|
|
#define SPACE4_FIELDNAME2 "u"
|
|
|
|
|
#define SPACE4_FIELDNAME3 "f"
|
|
|
|
|
#define SPACE4_FIELDNAME4 "c2"
|
|
|
|
|
size_t space4_field1_off=0;
|
|
|
|
|
size_t space4_field2_off=0;
|
|
|
|
|
size_t space4_field3_off=0;
|
|
|
|
|
size_t space4_field4_off=0;
|
|
|
|
|
struct space4_struct {
|
|
|
|
|
char c1;
|
1998-06-19 05:03:30 +08:00
|
|
|
|
unsigned u;
|
1998-04-29 06:33:07 +08:00
|
|
|
|
float f;
|
|
|
|
|
char c2;
|
2015-03-02 02:48:54 +08:00
|
|
|
|
} space4_data={'v',987123,-3.14F,'g'}; /* Test data for 4th dataspace */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
1997-09-04 21:03:31 +08:00
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
1998-04-29 06:33:07 +08:00
|
|
|
|
** test_h5s_basic(): Test basic H5S (dataspace) code.
|
2005-08-14 04:53:35 +08:00
|
|
|
|
**
|
1997-09-04 21:03:31 +08:00
|
|
|
|
****************************************************************/
|
2005-08-14 04:53:35 +08:00
|
|
|
|
static void
|
1998-04-29 06:33:07 +08:00
|
|
|
|
test_h5s_basic(void)
|
1997-09-04 21:03:31 +08:00
|
|
|
|
{
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hid_t fid1; /* HDF5 File IDs */
|
|
|
|
|
hid_t sid1, sid2; /* Dataspace ID */
|
1998-10-27 03:55:54 +08:00
|
|
|
|
hid_t dset1; /* Dataset ID */
|
2011-04-08 05:56:38 +08:00
|
|
|
|
hid_t aid1; /* Attribute ID */
|
2001-03-17 02:17:25 +08:00
|
|
|
|
int rank; /* Logical rank of dataspace */
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hsize_t dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
|
1998-10-27 03:55:54 +08:00
|
|
|
|
hsize_t dims2[] = {SPACE2_DIM1, SPACE2_DIM2, SPACE2_DIM3,
|
|
|
|
|
SPACE2_DIM4};
|
|
|
|
|
hsize_t dims3[H5S_MAX_RANK+1];
|
|
|
|
|
hsize_t max2[] = {SPACE2_MAX1, SPACE2_MAX2, SPACE2_MAX3,
|
|
|
|
|
SPACE2_MAX4};
|
1998-04-09 05:43:02 +08:00
|
|
|
|
hsize_t tdims[4]; /* Dimension array to test with */
|
1998-07-07 05:01:59 +08:00
|
|
|
|
hsize_t tmax[4];
|
2001-03-17 02:17:25 +08:00
|
|
|
|
hssize_t n; /* Number of dataspace elements */
|
1998-04-09 05:43:02 +08:00
|
|
|
|
herr_t ret; /* Generic return value */
|
1997-09-04 21:03:31 +08:00
|
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
MESSAGE(5, ("Testing Dataspace Manipulation\n"));
|
1997-09-04 21:03:31 +08:00
|
|
|
|
|
2011-04-13 04:25:27 +08:00
|
|
|
|
sid1 = H5Screate_simple(SPACE1_RANK, dims1, max2);
|
1998-02-26 02:48:33 +08:00
|
|
|
|
CHECK(sid1, FAIL, "H5Screate_simple");
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
1998-09-01 11:35:23 +08:00
|
|
|
|
n = H5Sget_simple_extent_npoints(sid1);
|
2001-03-17 02:17:25 +08:00
|
|
|
|
CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
|
1998-10-27 03:55:54 +08:00
|
|
|
|
VERIFY(n, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3,
|
|
|
|
|
"H5Sget_simple_extent_npoints");
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
1998-09-01 11:35:23 +08:00
|
|
|
|
rank = H5Sget_simple_extent_ndims(sid1);
|
2001-03-17 02:17:25 +08:00
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
|
1998-09-01 11:35:23 +08:00
|
|
|
|
VERIFY(rank, SPACE1_RANK, "H5Sget_simple_extent_ndims");
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
2001-03-17 02:17:25 +08:00
|
|
|
|
rank = H5Sget_simple_extent_dims(sid1, tdims, NULL);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
|
2004-03-09 04:09:52 +08:00
|
|
|
|
VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
|
1998-09-01 11:35:23 +08:00
|
|
|
|
"H5Sget_simple_extent_dims");
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
1998-07-07 05:01:59 +08:00
|
|
|
|
sid2 = H5Screate_simple(SPACE2_RANK, dims2, max2);
|
1998-02-26 02:48:33 +08:00
|
|
|
|
CHECK(sid2, FAIL, "H5Screate_simple");
|
1997-09-04 21:03:31 +08:00
|
|
|
|
|
1998-09-01 11:35:23 +08:00
|
|
|
|
n = H5Sget_simple_extent_npoints(sid2);
|
2001-03-17 02:17:25 +08:00
|
|
|
|
CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
|
1998-06-19 05:03:30 +08:00
|
|
|
|
VERIFY(n, SPACE2_DIM1 * SPACE2_DIM2 * SPACE2_DIM3 * SPACE2_DIM4,
|
1998-09-01 11:35:23 +08:00
|
|
|
|
"H5Sget_simple_extent_npoints");
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
1998-09-01 11:35:23 +08:00
|
|
|
|
rank = H5Sget_simple_extent_ndims(sid2);
|
2001-03-17 02:17:25 +08:00
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
|
1998-09-01 11:35:23 +08:00
|
|
|
|
VERIFY(rank, SPACE2_RANK, "H5Sget_simple_extent_ndims");
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
2001-03-17 02:17:25 +08:00
|
|
|
|
rank = H5Sget_simple_extent_dims(sid2, tdims, tmax);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
|
2004-03-09 04:09:52 +08:00
|
|
|
|
VERIFY(HDmemcmp(tdims, dims2, SPACE2_RANK * sizeof(hsize_t)), 0,
|
1998-09-01 11:35:23 +08:00
|
|
|
|
"H5Sget_simple_extent_dims");
|
2004-03-09 04:09:52 +08:00
|
|
|
|
VERIFY(HDmemcmp(tmax, max2, SPACE2_RANK * sizeof(hsize_t)), 0,
|
1998-09-01 11:35:23 +08:00
|
|
|
|
"H5Sget_simple_extent_dims");
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
2011-04-13 04:25:27 +08:00
|
|
|
|
/* Change max dims to be equal to the dimensions */
|
2004-07-21 00:26:40 +08:00
|
|
|
|
ret = H5Sset_extent_simple(sid1, SPACE1_RANK, dims1, NULL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sset_extent_simple");
|
|
|
|
|
rank = H5Sget_simple_extent_dims(sid1, tdims, tmax);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
|
|
|
|
|
VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
|
|
|
|
|
"H5Sget_simple_extent_dims");
|
|
|
|
|
VERIFY(HDmemcmp(tmax, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
|
|
|
|
|
"H5Sget_simple_extent_dims");
|
|
|
|
|
|
1998-03-13 05:04:53 +08:00
|
|
|
|
ret = H5Sclose(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
1998-03-13 05:04:53 +08:00
|
|
|
|
ret = H5Sclose(sid2);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
1998-01-17 06:23:43 +08:00
|
|
|
|
|
1998-10-27 03:55:54 +08:00
|
|
|
|
/*
|
|
|
|
|
* Check to be sure we can't create a simple data space that has too many
|
|
|
|
|
* dimensions.
|
|
|
|
|
*/
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
sid1 = H5Screate_simple(H5S_MAX_RANK+1, dims3, NULL);
|
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
VERIFY(sid1, FAIL, "H5Screate_simple");
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Try reading a file that has been prepared that has a dataset with a
|
|
|
|
|
* higher dimensionality than what the library can handle.
|
2000-10-21 04:57:56 +08:00
|
|
|
|
*
|
|
|
|
|
* If this test fails and the H5S_MAX_RANK variable has changed, follow
|
2003-04-14 19:18:55 +08:00
|
|
|
|
* the instructions in space_overflow.c for regenerating the th5s.h5 file.
|
1998-10-27 03:55:54 +08:00
|
|
|
|
*/
|
2000-10-25 02:58:31 +08:00
|
|
|
|
{
|
2010-03-18 05:38:20 +08:00
|
|
|
|
const char *testfile = H5_get_srcdir_filename(TESTFILE); /* Corrected test file name */
|
|
|
|
|
|
2000-10-25 02:58:31 +08:00
|
|
|
|
fid1 = H5Fopen(testfile, H5F_ACC_RDONLY, H5P_DEFAULT);
|
1999-03-10 07:13:22 +08:00
|
|
|
|
CHECK_I(fid1, "H5Fopen");
|
2000-10-25 02:58:31 +08:00
|
|
|
|
if (fid1 >= 0){
|
2013-03-02 04:09:40 +08:00
|
|
|
|
dset1 = H5Dopen2(fid1, "dset", H5P_DEFAULT);
|
|
|
|
|
VERIFY(dset1, FAIL, "H5Dopen2");
|
|
|
|
|
ret = H5Fclose(fid1);
|
|
|
|
|
CHECK_I(ret, "H5Fclose");
|
2000-10-25 02:58:31 +08:00
|
|
|
|
}
|
|
|
|
|
else
|
2013-03-02 04:09:40 +08:00
|
|
|
|
printf("***cannot open the pre-created H5S_MAX_RANK test file (%s)\n", testfile);
|
2000-10-25 02:58:31 +08:00
|
|
|
|
}
|
2000-04-13 06:02:26 +08:00
|
|
|
|
|
|
|
|
|
/* Verify that incorrect dimensions don't work */
|
2007-01-18 04:48:58 +08:00
|
|
|
|
dims1[0] = H5S_UNLIMITED;
|
|
|
|
|
sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
|
|
|
|
|
VERIFY(sid1, FAIL, "H5Screate_simple");
|
|
|
|
|
|
|
|
|
|
dims1[0] = H5S_UNLIMITED;
|
2000-04-13 06:02:26 +08:00
|
|
|
|
sid1 = H5Screate(H5S_SIMPLE);
|
|
|
|
|
CHECK(sid1, FAIL, "H5Screate");
|
|
|
|
|
|
|
|
|
|
ret = H5Sset_extent_simple(sid1,SPACE1_RANK,dims1,NULL);
|
|
|
|
|
VERIFY(ret, FAIL, "H5Sset_extent_simple");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(sid1);
|
|
|
|
|
CHECK_I(ret, "H5Sclose");
|
2004-07-28 00:55:19 +08:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Try writing simple dataspaces without setting their extents
|
|
|
|
|
*/
|
|
|
|
|
/* Create the file */
|
|
|
|
|
fid1 = H5Fcreate(BASICFILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
|
|
|
|
|
CHECK(fid1, FAIL, "H5Fcreate");
|
|
|
|
|
|
|
|
|
|
dims1[0]=SPACE1_DIM1;
|
|
|
|
|
|
|
|
|
|
sid1 = H5Screate(H5S_SIMPLE);
|
|
|
|
|
CHECK(sid1, FAIL, "H5Screate");
|
|
|
|
|
sid2 = H5Screate_simple(1, dims1, dims1);
|
|
|
|
|
CHECK(sid2, FAIL, "H5Screate");
|
|
|
|
|
|
|
|
|
|
/* This dataset's space has no extent; it should not be created */
|
|
|
|
|
H5E_BEGIN_TRY {
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
dset1 = H5Dcreate2(fid1, BASICDATASET, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
2004-07-28 00:55:19 +08:00
|
|
|
|
} H5E_END_TRY
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
VERIFY(dset1, FAIL, "H5Dcreate2");
|
2004-07-28 00:55:19 +08:00
|
|
|
|
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
dset1 = H5Dcreate2(fid1, BASICDATASET2, H5T_NATIVE_INT, sid2, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
|
|
|
|
CHECK(dset1, FAIL, "H5Dcreate2");
|
2004-07-28 00:55:19 +08:00
|
|
|
|
|
|
|
|
|
/* Try some writes with the bad dataspace (sid1) */
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, sid1, H5S_ALL, H5P_DEFAULT, &n);
|
|
|
|
|
} H5E_END_TRY
|
|
|
|
|
VERIFY(ret, FAIL, "H5Dwrite");
|
|
|
|
|
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, &n);
|
|
|
|
|
} H5E_END_TRY
|
|
|
|
|
VERIFY(ret, FAIL, "H5Dwrite");
|
|
|
|
|
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, sid1, sid1, H5P_DEFAULT, &n);
|
|
|
|
|
} H5E_END_TRY
|
|
|
|
|
VERIFY(ret, FAIL, "H5Dwrite");
|
|
|
|
|
|
|
|
|
|
/* Try to iterate using the bad dataspace */
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
ret = H5Diterate(&n, H5T_NATIVE_INT, sid1, NULL, NULL);
|
|
|
|
|
} H5E_END_TRY
|
|
|
|
|
VERIFY(ret, FAIL, "H5Diterate");
|
|
|
|
|
|
|
|
|
|
/* Try to fill using the bad dataspace */
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
ret = H5Dfill(NULL, H5T_NATIVE_INT, &n, H5T_NATIVE_INT, sid1);
|
|
|
|
|
} H5E_END_TRY
|
2004-12-29 22:26:20 +08:00
|
|
|
|
VERIFY(ret, FAIL, "H5Dfill");
|
2004-07-28 00:55:19 +08:00
|
|
|
|
|
|
|
|
|
/* Now use the bad dataspace as the space for an attribute */
|
|
|
|
|
H5E_BEGIN_TRY {
|
[svn-r14218] Description:
Changed H5Acreate2 -> H5Acreate_by_name, to be more consistent with
other new API routines.
Re-added simpler form of H5Acreate2, which creates attributes directly
on an object.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-31 02:13:48 +08:00
|
|
|
|
aid1 = H5Acreate2(dset1, BASICATTR, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT);
|
2004-07-28 00:55:19 +08:00
|
|
|
|
} H5E_END_TRY
|
[svn-r14187] Description:
Put H5Acreate() under API versioning, with all internal usage shifted
to H5Acreate2().
Add regression tests for H5Acreate1().
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-05 06:19:07 +08:00
|
|
|
|
VERIFY(aid1, FAIL, "H5Acreate2");
|
2004-07-28 00:55:19 +08:00
|
|
|
|
|
|
|
|
|
/* Make sure that dataspace reads using the bad dataspace fail */
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, sid1, H5S_ALL, H5P_DEFAULT, &n);
|
|
|
|
|
} H5E_END_TRY
|
|
|
|
|
VERIFY(ret, FAIL, "H5Dread");
|
|
|
|
|
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, &n);
|
|
|
|
|
} H5E_END_TRY
|
|
|
|
|
VERIFY(ret, FAIL, "H5Dread");
|
|
|
|
|
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, sid1, sid1, H5P_DEFAULT, &n);
|
|
|
|
|
} H5E_END_TRY
|
|
|
|
|
VERIFY(ret, FAIL, "H5Dread");
|
|
|
|
|
|
|
|
|
|
/* Clean up */
|
|
|
|
|
ret = H5Dclose(dset1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
|
|
|
ret = H5Sclose(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Sclose(sid2);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Fclose(fid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fclose");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
} /* test_h5s_basic() */
|
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_null(): Test NULL data space
|
|
|
|
|
**
|
|
|
|
|
****************************************************************/
|
|
|
|
|
static void
|
|
|
|
|
test_h5s_null(void)
|
|
|
|
|
{
|
|
|
|
|
hid_t fid; /* File ID */
|
2004-04-18 04:32:01 +08:00
|
|
|
|
hid_t sid; /* Dataspace IDs */
|
2004-04-09 05:23:19 +08:00
|
|
|
|
hid_t dset_sid, dset_sid2; /* Dataspace IDs */
|
2004-04-18 04:32:01 +08:00
|
|
|
|
hid_t attr_sid; /* Dataspace IDs */
|
2004-04-09 05:23:19 +08:00
|
|
|
|
hid_t did; /* Dataset ID */
|
2004-04-18 04:32:01 +08:00
|
|
|
|
hid_t attr; /*Attribute ID */
|
2004-04-10 03:42:05 +08:00
|
|
|
|
H5S_class_t stype; /* dataspace type */
|
2004-04-18 04:32:01 +08:00
|
|
|
|
hssize_t nelem; /* Number of elements */
|
|
|
|
|
unsigned uval=2; /* Buffer for writing to dataset */
|
|
|
|
|
int val=1; /* Buffer for writing to attribute */
|
|
|
|
|
H5S_sel_type sel_type; /* Type of selection currently */
|
|
|
|
|
hsize_t dims[1]={10}; /* Dimensions for converting null dataspace to simple */
|
|
|
|
|
H5S_class_t space_type; /* Type of dataspace */
|
2004-04-09 05:23:19 +08:00
|
|
|
|
herr_t ret; /* Generic return value */
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Output message about test being performed */
|
|
|
|
|
MESSAGE(5, ("Testing Null Dataspace\n"));
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Create the file */
|
|
|
|
|
fid = H5Fcreate(NULLFILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
|
|
|
|
|
CHECK(fid, FAIL, "H5Fcreate");
|
|
|
|
|
|
|
|
|
|
sid = H5Screate(H5S_NULL);
|
|
|
|
|
CHECK(sid, FAIL, "H5Screate");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-04-18 04:32:01 +08:00
|
|
|
|
/* Check that the null dataspace actually has 0 elements */
|
|
|
|
|
nelem = H5Sget_simple_extent_npoints(sid);
|
|
|
|
|
VERIFY(nelem, 0, "H5Sget_simple_extent_npoints");
|
|
|
|
|
|
|
|
|
|
/* Check that the dataspace was created with an "all" selection */
|
|
|
|
|
sel_type = H5Sget_select_type(sid);
|
|
|
|
|
VERIFY(sel_type, H5S_SEL_ALL, "H5Sget_select_type");
|
|
|
|
|
|
|
|
|
|
/* Check that the null dataspace has 0 elements selected */
|
|
|
|
|
nelem = H5Sget_select_npoints(sid);
|
|
|
|
|
VERIFY(nelem, 0, "H5Sget_select_npoints");
|
|
|
|
|
|
|
|
|
|
/* Change to "none" selection */
|
|
|
|
|
ret = H5Sselect_none(sid);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_none");
|
|
|
|
|
|
|
|
|
|
/* Check that the null dataspace has 0 elements selected */
|
|
|
|
|
nelem = H5Sget_select_npoints(sid);
|
|
|
|
|
VERIFY(nelem, 0, "H5Sget_select_npoints");
|
|
|
|
|
|
|
|
|
|
/* Check to be sure we can't set a hyperslab selection on a null dataspace */
|
|
|
|
|
H5E_BEGIN_TRY {
|
2004-12-29 22:26:20 +08:00
|
|
|
|
hsize_t start[1]={0};
|
2004-04-18 04:32:01 +08:00
|
|
|
|
hsize_t count[1]={0};
|
|
|
|
|
|
|
|
|
|
ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL, count, NULL);
|
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
VERIFY(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Check to be sure we can't set a point selection on a null dataspace */
|
|
|
|
|
H5E_BEGIN_TRY {
|
2004-12-29 22:26:20 +08:00
|
|
|
|
hsize_t coord[1][1]; /* Coordinates for point selection */
|
2004-04-18 04:32:01 +08:00
|
|
|
|
|
|
|
|
|
coord[0][0]=0;
|
2008-05-01 03:51:13 +08:00
|
|
|
|
ret = H5Sselect_elements(sid, H5S_SELECT_SET, (size_t)1, (const hsize_t *)coord);
|
2004-04-18 04:32:01 +08:00
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
VERIFY(ret, FAIL, "H5Sselect_elements");
|
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Create first dataset */
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
did = H5Dcreate2(fid, NULLDATASET, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
|
|
|
|
CHECK(did, FAIL, "H5Dcreate2");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-04-18 04:32:01 +08:00
|
|
|
|
/* Write "nothing" to the dataset */
|
|
|
|
|
ret = H5Dwrite(did, H5T_NATIVE_UINT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &uval);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
|
|
|
|
|
|
|
|
|
/* Write "nothing" to the dataset (with type conversion :-) */
|
|
|
|
|
ret = H5Dwrite(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &val);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
|
|
|
|
|
|
|
|
|
/* Try reading from the dataset (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Dread(did, H5T_NATIVE_UINT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &uval);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
|
|
|
|
VERIFY(uval, 2, "H5Dread");
|
|
|
|
|
|
|
|
|
|
/* Try reading from the dataset (with type conversion :-) (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &val);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
|
|
|
|
VERIFY(val, 1, "H5Dread");
|
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Create an attribute for the group */
|
[svn-r14218] Description:
Changed H5Acreate2 -> H5Acreate_by_name, to be more consistent with
other new API routines.
Re-added simpler form of H5Acreate2, which creates attributes directly
on an object.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-31 02:13:48 +08:00
|
|
|
|
attr = H5Acreate2(did, NULLATTR, H5T_NATIVE_INT, sid, H5P_DEFAULT, H5P_DEFAULT);
|
[svn-r14187] Description:
Put H5Acreate() under API versioning, with all internal usage shifted
to H5Acreate2().
Add regression tests for H5Acreate1().
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-05 06:19:07 +08:00
|
|
|
|
CHECK(attr, FAIL, "H5Acreate2");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-04-18 04:32:01 +08:00
|
|
|
|
/* Write "nothing" to the attribute */
|
|
|
|
|
ret = H5Awrite(attr, H5T_NATIVE_INT, &val);
|
|
|
|
|
CHECK(ret, FAIL, "H5Awrite");
|
|
|
|
|
|
|
|
|
|
/* Write "nothing" to the attribute (with type conversion :-) */
|
|
|
|
|
ret = H5Awrite(attr, H5T_NATIVE_UINT, &uval);
|
|
|
|
|
CHECK(ret, FAIL, "H5Awrite");
|
|
|
|
|
|
|
|
|
|
/* Try reading from the attribute (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Aread(attr, H5T_NATIVE_INT, &val);
|
|
|
|
|
CHECK(ret, FAIL, "H5Aread");
|
|
|
|
|
VERIFY(val, 1, "H5Aread");
|
|
|
|
|
|
|
|
|
|
/* Try reading from the attribute (with type conversion :-) (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Aread(attr, H5T_NATIVE_UINT, &uval);
|
|
|
|
|
CHECK(ret, FAIL, "H5Aread");
|
|
|
|
|
VERIFY(uval, 2, "H5Aread");
|
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Close attribute */
|
|
|
|
|
ret=H5Aclose(attr);
|
|
|
|
|
CHECK(ret, FAIL, "H5Aclose");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Close the dataset */
|
|
|
|
|
ret = H5Dclose(did);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
|
|
|
|
2004-04-18 04:32:01 +08:00
|
|
|
|
/* Verify that we've got the right kind of dataspace */
|
|
|
|
|
space_type = H5Sget_simple_extent_type(sid);
|
|
|
|
|
VERIFY(space_type, H5S_NULL, "H5Sget_simple_extent_type");
|
|
|
|
|
|
|
|
|
|
/* Convert the null dataspace to a simple dataspace */
|
|
|
|
|
ret = H5Sset_extent_simple(sid, 1, dims, NULL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sset_extent_simple");
|
|
|
|
|
|
|
|
|
|
/* Verify that we've got the right kind of dataspace now */
|
|
|
|
|
space_type = H5Sget_simple_extent_type(sid);
|
|
|
|
|
VERIFY(space_type, H5S_SIMPLE, "H5Sget_simple_extent_type");
|
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Close the dataspace */
|
|
|
|
|
ret = H5Sclose(sid);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
2004-07-28 00:55:19 +08:00
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Close the file */
|
|
|
|
|
ret = H5Fclose(fid);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fclose");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/*============================================
|
2005-08-14 04:53:35 +08:00
|
|
|
|
* Reopen the file to check the data space
|
2004-04-09 05:23:19 +08:00
|
|
|
|
*============================================
|
2005-08-14 04:53:35 +08:00
|
|
|
|
*/
|
2004-04-09 05:23:19 +08:00
|
|
|
|
fid = H5Fopen(NULLFILE, H5F_ACC_RDONLY, H5P_DEFAULT);
|
|
|
|
|
CHECK(fid, FAIL, "H5Fopen");
|
|
|
|
|
|
|
|
|
|
/* Reopen the dataset */
|
[svn-r14193] Description:
Make H5Dopen versioned and change all internal usage to use H5Dopen2
Add simple regression test for H5Dopen1
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-09 03:59:36 +08:00
|
|
|
|
did = H5Dopen2(fid, NULLDATASET, H5P_DEFAULT);
|
|
|
|
|
CHECK(did, FAIL, "H5Dopen2");
|
2004-04-09 05:23:19 +08:00
|
|
|
|
|
|
|
|
|
/* Get the space of the dataset */
|
|
|
|
|
dset_sid = H5Dget_space(did);
|
|
|
|
|
CHECK(dset_sid, FAIL, "H5Dget_space");
|
|
|
|
|
|
|
|
|
|
/* Query the NULL dataspace */
|
|
|
|
|
dset_sid2 = H5Scopy(dset_sid);
|
|
|
|
|
CHECK(dset_sid2, FAIL, "H5Scopy");
|
|
|
|
|
|
|
|
|
|
/* Verify the class type of dataspace */
|
2004-04-10 03:42:05 +08:00
|
|
|
|
stype = H5Sget_simple_extent_type(dset_sid2);
|
|
|
|
|
VERIFY(stype, H5S_NULL, "H5Sget_simple_extent_type");
|
2004-04-09 05:23:19 +08:00
|
|
|
|
|
|
|
|
|
/* Verify there is zero element in the dataspace */
|
2004-07-02 04:02:47 +08:00
|
|
|
|
ret = (herr_t)H5Sget_simple_extent_npoints(dset_sid2);
|
2004-04-09 05:23:19 +08:00
|
|
|
|
VERIFY(ret, 0, "H5Sget_simple_extent_npoints");
|
|
|
|
|
|
2004-04-18 04:32:01 +08:00
|
|
|
|
/* Try reading from the dataset (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Dread(did, H5T_NATIVE_UINT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &uval);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
|
|
|
|
VERIFY(uval, 2, "H5Dread");
|
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Close the dataspace */
|
|
|
|
|
ret = H5Sclose(dset_sid);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
ret = H5Sclose(dset_sid2);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
/* Open the attribute for the dataset */
|
[svn-r14217] Description:
Change H5Aopen -> H5Aopen_by_name, in order to be more consistent with
other new API routines.
Re-add H5Aopen as a simpler routine, to open attributes on a particular
object. (Much like the old H5Aopen_name routine).
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-31 00:07:20 +08:00
|
|
|
|
attr = H5Aopen(did, NULLATTR, H5P_DEFAULT);
|
[svn-r14185] Description:
Move H5Aopen_name() routine to deprecated symbol section and replace
internal usage with H5Aopen().
Add simple regression test for H5Aopen_name() to deprecated routine
test.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-05 03:29:58 +08:00
|
|
|
|
CHECK(attr, FAIL, "H5Aopen");
|
2004-04-09 05:23:19 +08:00
|
|
|
|
|
|
|
|
|
/* Get the space of the dataset */
|
|
|
|
|
attr_sid = H5Aget_space(attr);
|
|
|
|
|
CHECK(attr_sid, FAIL, "H5Aget_space");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Verify the class type of dataspace */
|
2004-04-10 03:42:05 +08:00
|
|
|
|
stype = H5Sget_simple_extent_type(attr_sid);
|
|
|
|
|
VERIFY(stype, H5S_NULL, "H5Sget_simple_extent_type");
|
2004-04-09 05:23:19 +08:00
|
|
|
|
|
|
|
|
|
/* Verify there is zero element in the dataspace */
|
2004-07-02 04:02:47 +08:00
|
|
|
|
ret = (herr_t)H5Sget_simple_extent_npoints(attr_sid);
|
2004-04-09 05:23:19 +08:00
|
|
|
|
VERIFY(ret, 0, "H5Sget_simple_extent_npoints");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Close the dataspace */
|
|
|
|
|
ret = H5Sclose(attr_sid);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-04-18 04:32:01 +08:00
|
|
|
|
/* Try reading from the attribute (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Aread(attr, H5T_NATIVE_INT, &val);
|
|
|
|
|
CHECK(ret, FAIL, "H5Aread");
|
|
|
|
|
VERIFY(val, 1, "H5Aread");
|
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Close attribute */
|
|
|
|
|
ret=H5Aclose(attr);
|
|
|
|
|
CHECK(ret, FAIL, "H5Aclose");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Close the dataset */
|
|
|
|
|
ret = H5Dclose(did);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
|
/* Close the file */
|
|
|
|
|
ret = H5Fclose(fid);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fclose");
|
2004-07-22 05:30:26 +08:00
|
|
|
|
} /* end test_h5s_null() */
|
|
|
|
|
|
2011-04-08 05:56:38 +08:00
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_zero_dim(): Test the code for dataspace with zero dimension size
|
|
|
|
|
**
|
|
|
|
|
****************************************************************/
|
|
|
|
|
static void
|
|
|
|
|
test_h5s_zero_dim(void)
|
|
|
|
|
{
|
|
|
|
|
hid_t fid1; /* HDF5 File IDs */
|
|
|
|
|
hid_t sid1, attr_sid; /* Dataspace ID */
|
2011-04-13 04:25:27 +08:00
|
|
|
|
hid_t sid_chunk; /* Dataspace ID for chunked dataset */
|
2011-04-08 05:56:38 +08:00
|
|
|
|
hid_t dset1; /* Dataset ID */
|
|
|
|
|
hid_t plist_id; /* Dataset creation property list */
|
|
|
|
|
hid_t attr; /* Attribute ID */
|
|
|
|
|
int rank; /* Logical rank of dataspace */
|
2011-04-13 04:25:27 +08:00
|
|
|
|
hsize_t dims1[] = {0, SPACE1_DIM2, SPACE1_DIM3};
|
|
|
|
|
hsize_t max_dims[] = {SPACE1_DIM1+1, SPACE1_DIM2, SPACE1_DIM3};
|
2011-04-11 23:59:41 +08:00
|
|
|
|
hsize_t extend_dims[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
|
2011-04-08 05:56:38 +08:00
|
|
|
|
hsize_t chunk_dims[] = {SPACE1_DIM1, SPACE1_DIM2/3, SPACE1_DIM3};
|
|
|
|
|
hsize_t tdims[SPACE1_RANK]; /* Dimension array to test with */
|
|
|
|
|
int wdata[SPACE1_DIM2][SPACE1_DIM3];
|
|
|
|
|
int rdata[SPACE1_DIM2][SPACE1_DIM3];
|
|
|
|
|
short wdata_short[SPACE1_DIM2][SPACE1_DIM3];
|
|
|
|
|
short rdata_short[SPACE1_DIM2][SPACE1_DIM3];
|
|
|
|
|
int wdata_real[SPACE1_DIM1][SPACE1_DIM2][SPACE1_DIM3];
|
|
|
|
|
int rdata_real[SPACE1_DIM1][SPACE1_DIM2][SPACE1_DIM3];
|
|
|
|
|
int val = 3;
|
|
|
|
|
hsize_t start[] = {0, 0, 0};
|
|
|
|
|
hsize_t count[] = {3, 15, 13};
|
|
|
|
|
hsize_t coord[1][3]; /* Coordinates for point selection */
|
|
|
|
|
hssize_t nelem; /* Number of elements */
|
|
|
|
|
H5S_sel_type sel_type; /* Type of selection currently */
|
|
|
|
|
H5S_class_t stype; /* dataspace type */
|
2012-03-13 05:45:38 +08:00
|
|
|
|
H5D_alloc_time_t alloc_time; /* Space allocation time */
|
2011-04-08 05:56:38 +08:00
|
|
|
|
herr_t ret; /* Generic return value */
|
|
|
|
|
unsigned int i, j, k;
|
|
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
|
|
|
|
MESSAGE(5, ("Testing Dataspace with zero dimension size\n"));
|
|
|
|
|
|
|
|
|
|
/* Initialize the data */
|
2016-07-23 06:43:18 +08:00
|
|
|
|
for(i = 0; i < SPACE1_DIM2; i++)
|
|
|
|
|
for(j = 0; j < SPACE1_DIM3; j++) {
|
|
|
|
|
wdata[i][j] = (int)(i + j);
|
2011-04-08 05:56:38 +08:00
|
|
|
|
rdata[i][j] = 7;
|
2016-07-23 06:43:18 +08:00
|
|
|
|
wdata_short[i][j] = (short)(i + j);
|
2011-04-08 05:56:38 +08:00
|
|
|
|
rdata_short[i][j] = 7;
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-23 06:43:18 +08:00
|
|
|
|
for(i = 0; i < SPACE1_DIM1; i++)
|
|
|
|
|
for(j = 0; j < SPACE1_DIM2; j++)
|
|
|
|
|
for(k = 0; k < SPACE1_DIM3; k++)
|
|
|
|
|
wdata_real[i][j][k] = (int)(i + j + k);
|
2011-04-11 23:59:41 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Test with different space allocation times */
|
2015-09-01 03:04:23 +08:00
|
|
|
|
for(alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; H5_INC_ENUM(H5D_alloc_time_t, alloc_time)) {
|
2012-03-13 05:45:38 +08:00
|
|
|
|
|
|
|
|
|
/* Make sure we can create the space with the dimension size 0 (starting from v1.8.7).
|
|
|
|
|
* The dimension doesn't need to be unlimited. */
|
|
|
|
|
dims1[0] = 0;
|
|
|
|
|
dims1[1] = SPACE1_DIM2;
|
|
|
|
|
dims1[2] = SPACE1_DIM3;
|
|
|
|
|
sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
|
|
|
|
|
CHECK(sid1, FAIL, "H5Screate_simple");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
sid1 = H5Screate(H5S_SIMPLE);
|
|
|
|
|
CHECK(sid1, FAIL, "H5Screate");
|
|
|
|
|
|
|
|
|
|
/* SID1 has the 1st dimension size as zero. The maximal dimension will be
|
|
|
|
|
* the same as the dimension because of the NULL passed in. */
|
|
|
|
|
ret = H5Sset_extent_simple(sid1,SPACE1_RANK,dims1,NULL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sset_extent_simple");
|
|
|
|
|
|
|
|
|
|
/* Check that the dataspace actually has 0 elements */
|
|
|
|
|
nelem = H5Sget_simple_extent_npoints(sid1);
|
|
|
|
|
VERIFY(nelem, 0, "H5Sget_simple_extent_npoints");
|
|
|
|
|
|
|
|
|
|
/* Check that the dataspace was created with an "all" selection */
|
|
|
|
|
sel_type = H5Sget_select_type(sid1);
|
|
|
|
|
VERIFY(sel_type, H5S_SEL_ALL, "H5Sget_select_type");
|
|
|
|
|
|
|
|
|
|
/* Check that the dataspace has 0 elements selected */
|
|
|
|
|
nelem = H5Sget_select_npoints(sid1);
|
|
|
|
|
VERIFY(nelem, 0, "H5Sget_select_npoints");
|
|
|
|
|
|
|
|
|
|
/* Change to "none" selection */
|
|
|
|
|
ret = H5Sselect_none(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_none");
|
|
|
|
|
|
|
|
|
|
/* Check that the dataspace has 0 elements selected */
|
|
|
|
|
nelem = H5Sget_select_npoints(sid1);
|
|
|
|
|
VERIFY(nelem, 0, "H5Sget_select_npoints");
|
|
|
|
|
|
|
|
|
|
/* Try to select all dataspace */
|
|
|
|
|
ret = H5Sselect_all(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_all");
|
|
|
|
|
|
|
|
|
|
/* Check that the dataspace has 0 elements selected */
|
|
|
|
|
nelem = H5Sget_select_npoints(sid1);
|
|
|
|
|
VERIFY(nelem, 0, "H5Sget_select_npoints");
|
|
|
|
|
|
|
|
|
|
/* Create the dataspace for chunked dataset with the first dimension size as zero.
|
|
|
|
|
* The maximal dimensions are bigger than the dimensions for later expansion. */
|
|
|
|
|
sid_chunk = H5Screate_simple(SPACE1_RANK, dims1, max_dims);
|
|
|
|
|
CHECK(sid_chunk, FAIL, "H5Screate_simple");
|
|
|
|
|
|
|
|
|
|
/*============================================
|
|
|
|
|
* Make sure we can use 0-dimension to create
|
|
|
|
|
* contiguous, chunked, compact, and external
|
|
|
|
|
* datasets, and also attribute.
|
|
|
|
|
*============================================
|
|
|
|
|
*/
|
|
|
|
|
fid1 = H5Fcreate(ZEROFILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
|
|
|
|
|
CHECK(fid1, FAIL, "H5Fcreate");
|
|
|
|
|
|
|
|
|
|
/*===================== Contiguous dataset =======================*/
|
|
|
|
|
plist_id = H5Pcreate(H5P_DATASET_CREATE);
|
|
|
|
|
CHECK(plist_id, FAIL, "H5Pcreate");
|
|
|
|
|
|
|
|
|
|
ret = H5Pset_alloc_time(plist_id, alloc_time);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pset_alloc_time");
|
|
|
|
|
|
|
|
|
|
dset1 = H5Dcreate2(fid1, BASICDATASET, H5T_NATIVE_INT, sid1, H5P_DEFAULT, plist_id, H5P_DEFAULT);
|
|
|
|
|
CHECK(dset1, FAIL, "H5Dcreate2");
|
|
|
|
|
|
|
|
|
|
ret = H5Pclose(plist_id);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pclose");
|
|
|
|
|
|
|
|
|
|
/* Write "nothing" to the dataset */
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, sid1, H5S_ALL, H5P_DEFAULT, wdata);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
|
|
|
|
|
|
|
|
|
ret = H5Fflush(fid1, H5F_SCOPE_GLOBAL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fflush");
|
|
|
|
|
|
|
|
|
|
/* Try reading from the dataset (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, sid1, H5S_ALL, H5P_DEFAULT, rdata);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
|
|
|
|
|
|
|
|
|
/* Check results */
|
|
|
|
|
for(i=0; i<SPACE1_DIM2; i++) {
|
|
|
|
|
for(j=0; j<SPACE1_DIM3; j++) {
|
|
|
|
|
if(rdata[i][j] != 7) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf("element [%d][%d] is %d but should have been 7\n",
|
|
|
|
|
i, j, rdata[i][j]);
|
|
|
|
|
}
|
2011-04-08 05:56:38 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Write "nothing" to the dataset (with type conversion :-) */
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_SHORT, H5S_ALL, H5S_ALL, H5P_DEFAULT, wdata_short);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Fflush(fid1, H5F_SCOPE_GLOBAL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fflush");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Try reading from the dataset (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, sid1, H5S_ALL, H5P_DEFAULT, rdata_short);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Check results */
|
|
|
|
|
for(i=0; i<SPACE1_DIM2; i++) {
|
|
|
|
|
for(j=0; j<SPACE1_DIM3; j++) {
|
|
|
|
|
if(rdata_short[i][j] != 7) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf("element [%d][%d] is %d but should have been 7\n",
|
|
|
|
|
i, j, rdata_short[i][j]);
|
|
|
|
|
}
|
2011-04-08 05:56:38 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Select a hyperslab beyond its current dimension sizes, then try to write
|
|
|
|
|
* the data. It should fail. */
|
|
|
|
|
ret = H5Sselect_hyperslab(sid1, H5S_SELECT_SET, start, NULL, count, NULL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, wdata);
|
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
VERIFY(ret, FAIL, "H5Dwrite");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Change to "none" selection */
|
|
|
|
|
ret = H5Sselect_none(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_none");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Select a point beyond the dimension size, then try to write the data.
|
|
|
|
|
* It should fail. */
|
|
|
|
|
coord[0][0]=2; coord[0][1]=5; coord[0][2]=3;
|
|
|
|
|
ret = H5Sselect_elements(sid1, H5S_SELECT_SET, (size_t)1, (const hsize_t *)coord);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_elements");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, &val);
|
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
VERIFY(ret, FAIL, "H5Dwrite");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Restore the selection to all */
|
|
|
|
|
ret = H5Sselect_all(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_all");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Dclose(dset1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/*=================== Chunked dataset ====================*/
|
|
|
|
|
plist_id = H5Pcreate(H5P_DATASET_CREATE);
|
|
|
|
|
CHECK(plist_id, FAIL, "H5Pcreate");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Pset_chunk(plist_id, SPACE1_RANK, chunk_dims);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pset_chunk");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2013-01-14 23:42:17 +08:00
|
|
|
|
/* ret = H5Pset_alloc_time(plist_id, alloc_time); */
|
|
|
|
|
/* CHECK(ret, FAIL, "H5Pset_alloc_time"); */
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
dset1 = H5Dcreate2(fid1, BASICDATASET1, H5T_NATIVE_INT, sid_chunk, H5P_DEFAULT, plist_id, H5P_DEFAULT);
|
|
|
|
|
CHECK(dset1, FAIL, "H5Dcreate2");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Write "nothing" to the dataset */
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, wdata);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Fflush(fid1, H5F_SCOPE_GLOBAL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fflush");
|
2011-04-11 23:59:41 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Try reading from the dataset (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
2011-04-11 23:59:41 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Check results */
|
|
|
|
|
for(i=0; i<SPACE1_DIM2; i++)
|
|
|
|
|
for(j=0; j<SPACE1_DIM3; j++) {
|
|
|
|
|
if(rdata[i][j] != 7) {
|
2011-04-11 23:59:41 +08:00
|
|
|
|
H5_FAILED();
|
2012-03-13 05:45:38 +08:00
|
|
|
|
printf("element [%d][%d] is %d but should have been 7\n",
|
|
|
|
|
i, j, rdata[i][j]);
|
2011-04-11 23:59:41 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Now extend the dataset to SPACE1_DIM1*SPACE1_DIM2*SPACE1_DIM3 and make sure
|
|
|
|
|
* we can write data to it */
|
|
|
|
|
extend_dims[0] = SPACE1_DIM1;
|
|
|
|
|
ret = H5Dset_extent(dset1, extend_dims);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dset_extent");
|
|
|
|
|
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, wdata_real);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
|
|
|
|
|
|
|
|
|
ret = H5Fflush(fid1, H5F_SCOPE_GLOBAL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fflush");
|
|
|
|
|
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata_real);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
|
|
|
|
|
|
|
|
|
/* Check results */
|
|
|
|
|
for(i=0; i<SPACE1_DIM1; i++) {
|
|
|
|
|
for(j=0; j<SPACE1_DIM2; j++) {
|
|
|
|
|
for(k=0; k<SPACE1_DIM3; k++) {
|
|
|
|
|
if(rdata_real[i][j][k] != wdata_real[i][j][k]) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf("element [%d][%d][%d] is %d but should have been %d\n",
|
|
|
|
|
i, j, k, rdata_real[i][j][k], wdata_real[i][j][k]);
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-04-11 23:59:41 +08:00
|
|
|
|
}
|
2012-03-13 05:45:38 +08:00
|
|
|
|
}
|
2011-04-11 23:59:41 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Now shrink the first dimension size of the dataset to 0 and make sure no data is in it */
|
|
|
|
|
extend_dims[0] = 0;
|
2011-04-15 01:24:03 +08:00
|
|
|
|
ret = H5Dset_extent(dset1, extend_dims);
|
2012-03-13 05:45:38 +08:00
|
|
|
|
CHECK(ret, FAIL, "H5Dset_extent");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Fflush(fid1, H5F_SCOPE_GLOBAL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fflush");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Try reading from the dataset (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Check results */
|
|
|
|
|
for(i=0; i<SPACE1_DIM2; i++)
|
|
|
|
|
for(j=0; j<SPACE1_DIM3; j++) {
|
|
|
|
|
if(rdata[i][j] != 7) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf("element [%d][%d] is %d but should have been 7\n",
|
|
|
|
|
i, j, rdata[i][j]);
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Now extend the first dimension size of the dataset to SPACE1_DIM1*3 past the maximal size.
|
|
|
|
|
* It is supposed to fail. */
|
|
|
|
|
extend_dims[0] = SPACE1_DIM1*3;
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
ret = H5Dset_extent(dset1, extend_dims);
|
|
|
|
|
} H5E_END_TRY;
|
|
|
|
|
VERIFY(ret, FAIL, "H5Dset_extent");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Pclose(plist_id);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pclose");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Dclose(dset1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/*=================== Compact dataset =====================*/
|
|
|
|
|
plist_id = H5Pcreate(H5P_DATASET_CREATE);
|
|
|
|
|
CHECK(plist_id, FAIL, "H5Pcreate");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Pset_layout(plist_id, H5D_COMPACT);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pset_layout");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Don't set the allocation time for compact storage datasets (must be early) */
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
dset1 = H5Dcreate2(fid1, BASICDATASET2, H5T_NATIVE_INT, sid1, H5P_DEFAULT, plist_id, H5P_DEFAULT);
|
|
|
|
|
CHECK(dset1, FAIL, "H5Dcreate2");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Write "nothing" to the dataset */
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, wdata);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Fflush(fid1, H5F_SCOPE_GLOBAL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fflush");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Try reading from the dataset (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Check results */
|
|
|
|
|
for(i=0; i<SPACE1_DIM2; i++)
|
|
|
|
|
for(j=0; j<SPACE1_DIM3; j++) {
|
|
|
|
|
if(rdata[i][j] != 7) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf("element [%d][%d] is %d but should have been 7\n",
|
|
|
|
|
i, j, rdata[i][j]);
|
|
|
|
|
}
|
2011-04-08 05:56:38 +08:00
|
|
|
|
}
|
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Pclose(plist_id);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pclose");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Dclose(dset1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/*=========== Contiguous dataset with external storage ============*/
|
|
|
|
|
plist_id = H5Pcreate(H5P_DATASET_CREATE);
|
|
|
|
|
CHECK(plist_id, FAIL, "H5Pcreate");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Change the DCPL for contiguous layout with external storage. The size of the reserved
|
|
|
|
|
* space in the external file is the size of the dataset (zero because one dimension size is zero).
|
|
|
|
|
* There's no need to clean up the external file since the library doesn't create it
|
|
|
|
|
* until the data is written to it. */
|
|
|
|
|
ret = H5Pset_external(plist_id, EXTFILE_NAME, (off_t)0, (hsize_t)0);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pset_external");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Pset_alloc_time(plist_id, alloc_time);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pset_alloc_time");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
dset1 = H5Dcreate2(fid1, BASICDATASET3, H5T_NATIVE_INT, sid1, H5P_DEFAULT, plist_id, H5P_DEFAULT);
|
|
|
|
|
CHECK(dset1, FAIL, "H5Dcreate2");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Write "nothing" to the dataset */
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, sid1, H5S_ALL, H5P_DEFAULT, wdata);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Fflush(fid1, H5F_SCOPE_GLOBAL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fflush");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Try reading from the dataset (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, sid1, H5S_ALL, H5P_DEFAULT, rdata);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Check results */
|
|
|
|
|
for(i=0; i<SPACE1_DIM2; i++) {
|
|
|
|
|
for(j=0; j<SPACE1_DIM3; j++) {
|
|
|
|
|
if(rdata[i][j] != 7) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf("element [%d][%d] is %d but should have been 7\n",
|
|
|
|
|
i, j, rdata[i][j]);
|
|
|
|
|
}
|
2011-04-08 05:56:38 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Pclose(plist_id);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pclose");
|
2011-04-23 04:28:43 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Dclose(dset1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/*=============== Create an attribute for the file ================*/
|
|
|
|
|
attr = H5Acreate2(fid1, NULLATTR, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT);
|
|
|
|
|
CHECK(attr, FAIL, "H5Acreate2");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Write "nothing" to the attribute */
|
|
|
|
|
ret = H5Awrite(attr, H5T_NATIVE_INT, wdata);
|
|
|
|
|
CHECK(ret, FAIL, "H5Awrite");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Fflush(fid1, H5F_SCOPE_GLOBAL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fflush");
|
2011-04-13 04:25:27 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Try reading from the attribute (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Aread(attr, H5T_NATIVE_INT, rdata);
|
|
|
|
|
CHECK(ret, FAIL, "H5Aread");
|
2011-04-13 04:25:27 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Check results */
|
|
|
|
|
for(i=0; i<SPACE1_DIM2; i++) {
|
|
|
|
|
for(j=0; j<SPACE1_DIM3; j++) {
|
|
|
|
|
if(rdata[i][j] != 7) {
|
2011-04-08 05:56:38 +08:00
|
|
|
|
H5_FAILED();
|
2012-03-13 05:45:38 +08:00
|
|
|
|
printf("element [%d][%d] is %d but should have been 7\n",
|
|
|
|
|
i, j, rdata[i][j]);
|
2011-04-08 05:56:38 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Write "nothing" to the attribute (with type conversion :-) */
|
|
|
|
|
ret = H5Awrite(attr, H5T_NATIVE_SHORT, wdata_short);
|
|
|
|
|
CHECK(ret, FAIL, "H5Awrite");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Fflush(fid1, H5F_SCOPE_GLOBAL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fflush");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Try reading from the attribute (with type conversion :-) (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Aread(attr, H5T_NATIVE_SHORT, rdata_short);
|
|
|
|
|
CHECK(ret, FAIL, "H5Aread");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Check results */
|
|
|
|
|
for(i=0; i<SPACE1_DIM2; i++) {
|
|
|
|
|
for(j=0; j<SPACE1_DIM3; j++) {
|
|
|
|
|
if(rdata_short[i][j] != 7) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf("element [%d][%d] is %d but should have been 7\n",
|
|
|
|
|
i, j, rdata_short[i][j]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-04-11 23:59:41 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Close attribute */
|
|
|
|
|
ret = H5Aclose(attr);
|
|
|
|
|
CHECK(ret, FAIL, "H5Aclose");
|
|
|
|
|
|
|
|
|
|
/*===============================================================
|
|
|
|
|
* Extend the dimension to make it a normal dataspace (3x15x13).
|
|
|
|
|
* Verify that data can be written to and read from the chunked
|
|
|
|
|
* dataset now.
|
|
|
|
|
*===============================================================
|
|
|
|
|
*/
|
|
|
|
|
dims1[0]=SPACE1_DIM1;
|
|
|
|
|
ret = H5Sset_extent_simple(sid_chunk,SPACE1_RANK,dims1,max_dims);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sset_extent_simple");
|
|
|
|
|
|
|
|
|
|
nelem = H5Sget_simple_extent_npoints(sid_chunk);
|
|
|
|
|
CHECK(nelem, FAIL, "H5Sget_simple_extent_npoints");
|
|
|
|
|
VERIFY(nelem, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3,
|
|
|
|
|
"H5Sget_simple_extent_npoints");
|
|
|
|
|
|
|
|
|
|
rank = H5Sget_simple_extent_ndims(sid_chunk);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
|
|
|
|
|
VERIFY(rank, SPACE1_RANK, "H5Sget_simple_extent_ndims");
|
|
|
|
|
|
|
|
|
|
rank = H5Sget_simple_extent_dims(sid_chunk, tdims, NULL);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
|
|
|
|
|
VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
|
|
|
|
|
"H5Sget_simple_extent_dims");
|
|
|
|
|
|
|
|
|
|
/* Set it to chunked dataset */
|
|
|
|
|
plist_id = H5Pcreate(H5P_DATASET_CREATE);
|
|
|
|
|
CHECK(plist_id, FAIL, "H5Pcreate");
|
|
|
|
|
|
|
|
|
|
ret = H5Pset_chunk(plist_id, SPACE1_RANK, chunk_dims);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pset_chunk");
|
|
|
|
|
|
|
|
|
|
ret = H5Pset_alloc_time(plist_id, alloc_time);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pset_alloc_time");
|
|
|
|
|
|
|
|
|
|
dset1 = H5Dcreate2(fid1, BASICDATASET4, H5T_NATIVE_INT, sid_chunk, H5P_DEFAULT, plist_id, H5P_DEFAULT);
|
|
|
|
|
CHECK(dset1, FAIL, "H5Dcreate2");
|
|
|
|
|
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, wdata_real);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
|
|
|
|
|
|
|
|
|
ret = H5Fflush(fid1, H5F_SCOPE_GLOBAL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fflush");
|
|
|
|
|
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata_real);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
|
|
|
|
|
|
|
|
|
/* Check results */
|
|
|
|
|
for(i=0; i<SPACE1_DIM1; i++) {
|
|
|
|
|
for(j=0; j<SPACE1_DIM2; j++) {
|
|
|
|
|
for(k=0; k<SPACE1_DIM3; k++) {
|
|
|
|
|
if(rdata_real[i][j][k] != wdata_real[i][j][k]) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf("element [%d][%d][%d] is %d but should have been %d\n",
|
|
|
|
|
i, j, k, rdata_real[i][j][k], wdata_real[i][j][k]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Pclose(plist_id);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pclose");
|
|
|
|
|
|
|
|
|
|
ret = H5Dclose(dset1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
|
|
|
|
|
|
|
|
/* Change the dimensions to make them zero size again (0x0x0). Verify that
|
|
|
|
|
* no element is in the dataspace. */
|
|
|
|
|
dims1[0]=dims1[1]=dims1[2]=0;
|
|
|
|
|
ret = H5Sset_extent_simple(sid_chunk,SPACE1_RANK,dims1,NULL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sset_extent_simple");
|
|
|
|
|
|
|
|
|
|
/* Check that the dataspace actually has 0 elements */
|
|
|
|
|
nelem = H5Sget_simple_extent_npoints(sid_chunk);
|
|
|
|
|
VERIFY(nelem, 0, "H5Sget_simple_extent_npoints");
|
|
|
|
|
|
|
|
|
|
/* Check that the dataspace was created with an "all" selection */
|
|
|
|
|
sel_type = H5Sget_select_type(sid_chunk);
|
|
|
|
|
VERIFY(sel_type, H5S_SEL_ALL, "H5Sget_select_type");
|
|
|
|
|
|
|
|
|
|
/* Check that the dataspace has 0 elements selected */
|
|
|
|
|
nelem = H5Sget_select_npoints(sid_chunk);
|
|
|
|
|
VERIFY(nelem, 0, "H5Sget_select_npoints");
|
|
|
|
|
|
|
|
|
|
/* Change to "none" selection */
|
|
|
|
|
ret = H5Sselect_none(sid_chunk);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_none");
|
|
|
|
|
|
|
|
|
|
/* Check that the dataspace has 0 elements selected */
|
|
|
|
|
nelem = H5Sget_select_npoints(sid_chunk);
|
|
|
|
|
VERIFY(nelem, 0, "H5Sget_select_npoints");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(sid_chunk);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
ret = H5Fclose(fid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fclose");
|
|
|
|
|
|
|
|
|
|
/*============================================
|
|
|
|
|
* Reopen the file to check the data space
|
|
|
|
|
*============================================
|
|
|
|
|
*/
|
|
|
|
|
fid1 = H5Fopen(ZEROFILE, H5F_ACC_RDONLY, H5P_DEFAULT);
|
|
|
|
|
CHECK(fid1, FAIL, "H5Fopen");
|
|
|
|
|
|
|
|
|
|
/* Reopen the chunked dataset */
|
|
|
|
|
dset1 = H5Dopen2(fid1, BASICDATASET1, H5P_DEFAULT);
|
|
|
|
|
CHECK(dset1, FAIL, "H5Dopen2");
|
|
|
|
|
|
|
|
|
|
/* Get the space of the dataset and querry it */
|
|
|
|
|
sid1 = H5Dget_space(dset1);
|
|
|
|
|
CHECK(sid1, FAIL, "H5Dget_space");
|
|
|
|
|
|
|
|
|
|
/* Verify the class type of dataspace */
|
|
|
|
|
stype = H5Sget_simple_extent_type(sid1);
|
|
|
|
|
VERIFY(stype, H5S_SIMPLE, "H5Sget_simple_extent_type");
|
|
|
|
|
|
|
|
|
|
/* Verify there is zero element in the dataspace */
|
|
|
|
|
nelem = H5Sget_simple_extent_npoints(sid1);
|
|
|
|
|
VERIFY(nelem, 0, "H5Sget_simple_extent_npoints");
|
|
|
|
|
|
|
|
|
|
/* Verify the dimension sizes are correct */
|
|
|
|
|
rank = H5Sget_simple_extent_dims(sid1, tdims, NULL);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
|
|
|
|
|
VERIFY(tdims[0], 0, "H5Sget_simple_extent_dims");
|
|
|
|
|
VERIFY(tdims[1], SPACE1_DIM2, "H5Sget_simple_extent_dims");
|
|
|
|
|
VERIFY(tdims[2], SPACE1_DIM3, "H5Sget_simple_extent_dims");
|
|
|
|
|
|
|
|
|
|
/* Try reading from the dataset (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
|
|
|
|
|
|
|
|
|
/* Check results */
|
|
|
|
|
for(i=0; i<SPACE1_DIM2; i++) {
|
|
|
|
|
for(j=0; j<SPACE1_DIM3; j++) {
|
|
|
|
|
if(rdata[i][j] != 7) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf("element [%d][%d] is %d but should have been 7\n",
|
|
|
|
|
i, j, rdata[i][j]);
|
|
|
|
|
}
|
2011-04-08 05:56:38 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Close the dataset and its dataspace */
|
|
|
|
|
ret = H5Dclose(dset1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Sclose(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Open the attribute for the file */
|
|
|
|
|
attr = H5Aopen(fid1, NULLATTR, H5P_DEFAULT);
|
|
|
|
|
CHECK(attr, FAIL, "H5Aopen");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Get the space of the dataset */
|
|
|
|
|
attr_sid = H5Aget_space(attr);
|
|
|
|
|
CHECK(attr_sid, FAIL, "H5Aget_space");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Verify the class type of dataspace */
|
|
|
|
|
stype = H5Sget_simple_extent_type(attr_sid);
|
|
|
|
|
VERIFY(stype, H5S_SIMPLE, "H5Sget_simple_extent_type");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Verify there is zero element in the dataspace */
|
|
|
|
|
nelem = H5Sget_simple_extent_npoints(attr_sid);
|
|
|
|
|
VERIFY(nelem, 0, "H5Sget_simple_extent_npoints");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Try reading from the attribute (make certain our buffer is unmodified) */
|
|
|
|
|
ret = H5Aread(attr, H5T_NATIVE_SHORT, rdata_short);
|
|
|
|
|
CHECK(ret, FAIL, "H5Aread");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Check results */
|
|
|
|
|
for(i=0; i<SPACE1_DIM2; i++) {
|
|
|
|
|
for(j=0; j<SPACE1_DIM3; j++) {
|
|
|
|
|
if(rdata_short[i][j] != 7) {
|
|
|
|
|
H5_FAILED();
|
|
|
|
|
printf("element [%d][%d] is %d but should have been 7\n",
|
|
|
|
|
i, j, rdata_short[i][j]);
|
|
|
|
|
}
|
2011-04-08 05:56:38 +08:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Close attribute */
|
|
|
|
|
ret=H5Aclose(attr);
|
|
|
|
|
CHECK(ret, FAIL, "H5Aclose");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
/* Close the dataspace */
|
|
|
|
|
ret = H5Sclose(attr_sid);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
|
ret = H5Fclose(fid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fclose");
|
|
|
|
|
} /* end for */
|
|
|
|
|
} /* test_h5s_zero_dim() */
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
|
|
|
|
|
2004-07-22 05:30:26 +08:00
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_encode(): Test H5S (dataspace) encoding and decoding.
|
2005-08-14 04:53:35 +08:00
|
|
|
|
**
|
2004-07-22 05:30:26 +08:00
|
|
|
|
****************************************************************/
|
2005-08-14 04:53:35 +08:00
|
|
|
|
static void
|
2004-07-22 05:30:26 +08:00
|
|
|
|
test_h5s_encode(void)
|
|
|
|
|
{
|
|
|
|
|
hid_t sid1, sid2, sid3; /* Dataspace ID */
|
|
|
|
|
hid_t decoded_sid1, decoded_sid2, decoded_sid3;
|
|
|
|
|
int rank; /* Logical rank of dataspace */
|
|
|
|
|
hsize_t dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
|
|
|
|
|
size_t sbuf_size=0, null_size=0, scalar_size=0;
|
|
|
|
|
unsigned char *sbuf=NULL, *null_sbuf=NULL, *scalar_buf=NULL;
|
|
|
|
|
hsize_t tdims[4]; /* Dimension array to test with */
|
|
|
|
|
hssize_t n; /* Number of dataspace elements */
|
2004-12-29 22:26:20 +08:00
|
|
|
|
hsize_t start[] = {0, 0, 0};
|
2004-07-22 05:30:26 +08:00
|
|
|
|
hsize_t stride[] = {2, 5, 3};
|
|
|
|
|
hsize_t count[] = {2, 2, 2};
|
|
|
|
|
hsize_t block[] = {1, 3, 1};
|
|
|
|
|
H5S_sel_type sel_type;
|
|
|
|
|
H5S_class_t space_type;
|
|
|
|
|
hssize_t nblocks;
|
2014-08-12 03:13:45 +08:00
|
|
|
|
hid_t ret_id; /* Generic hid_t return value */
|
2004-07-22 05:30:26 +08:00
|
|
|
|
herr_t ret; /* Generic return value */
|
|
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
|
|
|
|
MESSAGE(5, ("Testing Dataspace Encoding and Decoding\n"));
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Test encoding and decoding of simple dataspace and hyperslab selection.
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
|
|
|
|
|
CHECK(sid1, FAIL, "H5Screate_simple");
|
|
|
|
|
|
|
|
|
|
ret = H5Sselect_hyperslab(sid1, H5S_SELECT_SET, start, stride, count, block);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Encode simple data space in a buffer */
|
|
|
|
|
ret = H5Sencode(sid1, NULL, &sbuf_size);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
|
|
|
|
if(sbuf_size>0)
|
2006-10-24 04:40:14 +08:00
|
|
|
|
sbuf = (unsigned char*)HDcalloc((size_t)1, sbuf_size);
|
2004-07-22 05:30:26 +08:00
|
|
|
|
|
2004-07-28 11:51:43 +08:00
|
|
|
|
/* Try decoding bogus buffer */
|
|
|
|
|
H5E_BEGIN_TRY {
|
2014-08-12 03:13:45 +08:00
|
|
|
|
ret_id = H5Sdecode(sbuf);
|
2004-07-28 11:51:43 +08:00
|
|
|
|
} H5E_END_TRY;
|
2014-08-12 03:13:45 +08:00
|
|
|
|
VERIFY(ret_id, FAIL, "H5Sdecode");
|
2004-07-28 11:51:43 +08:00
|
|
|
|
|
2004-07-22 05:30:26 +08:00
|
|
|
|
ret = H5Sencode(sid1, sbuf, &sbuf_size);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
|
|
|
|
/* Decode from the dataspace buffer and return an object handle */
|
|
|
|
|
decoded_sid1=H5Sdecode(sbuf);
|
|
|
|
|
CHECK(decoded_sid1, FAIL, "H5Sdecode");
|
|
|
|
|
|
|
|
|
|
/* Verify the decoded dataspace */
|
|
|
|
|
n = H5Sget_simple_extent_npoints(decoded_sid1);
|
|
|
|
|
CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
|
|
|
|
|
VERIFY(n, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3,
|
|
|
|
|
"H5Sget_simple_extent_npoints");
|
|
|
|
|
|
|
|
|
|
rank = H5Sget_simple_extent_ndims(decoded_sid1);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
|
|
|
|
|
VERIFY(rank, SPACE1_RANK, "H5Sget_simple_extent_ndims");
|
|
|
|
|
|
|
|
|
|
rank = H5Sget_simple_extent_dims(decoded_sid1, tdims, NULL);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
|
|
|
|
|
VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
|
|
|
|
|
"H5Sget_simple_extent_dims");
|
|
|
|
|
|
|
|
|
|
/* Verify hyperslabe selection */
|
|
|
|
|
sel_type = H5Sget_select_type(decoded_sid1);
|
|
|
|
|
VERIFY(sel_type, H5S_SEL_HYPERSLABS, "H5Sget_select_type");
|
|
|
|
|
|
|
|
|
|
nblocks = H5Sget_select_hyper_nblocks(decoded_sid1);
|
|
|
|
|
VERIFY(nblocks, 2*2*2, "H5Sget_select_hyper_nblocks");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-07-22 05:30:26 +08:00
|
|
|
|
ret = H5Sclose(decoded_sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-07-22 05:30:26 +08:00
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Test encoding and decoding of null dataspace.
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
sid2 = H5Screate(H5S_NULL);
|
|
|
|
|
CHECK(sid2, FAIL, "H5Screate");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-07-22 05:30:26 +08:00
|
|
|
|
/* Encode null data space in a buffer */
|
|
|
|
|
ret = H5Sencode(sid2, NULL, &null_size);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
|
|
|
|
if(null_size>0)
|
2006-10-24 04:40:14 +08:00
|
|
|
|
null_sbuf = (unsigned char*)HDcalloc((size_t)1, null_size);
|
2004-07-22 05:30:26 +08:00
|
|
|
|
|
|
|
|
|
ret = H5Sencode(sid2, null_sbuf, &null_size);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
|
|
|
|
/* Decode from the dataspace buffer and return an object handle */
|
|
|
|
|
decoded_sid2=H5Sdecode(null_sbuf);
|
|
|
|
|
CHECK(decoded_sid2, FAIL, "H5Sdecode");
|
|
|
|
|
|
|
|
|
|
/* Verify decoded dataspace */
|
|
|
|
|
space_type = H5Sget_simple_extent_type(decoded_sid2);
|
|
|
|
|
VERIFY(space_type, H5S_NULL, "H5Sget_simple_extent_type");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-07-22 05:30:26 +08:00
|
|
|
|
ret = H5Sclose(sid2);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-07-22 05:30:26 +08:00
|
|
|
|
ret = H5Sclose(decoded_sid2);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Test encoding and decoding of scalar dataspace.
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
/* Create scalar dataspace */
|
|
|
|
|
sid3 = H5Screate(H5S_SCALAR);
|
|
|
|
|
CHECK(sid3, FAIL, "H5Screate_simple");
|
|
|
|
|
|
|
|
|
|
/* Encode scalar data space in a buffer */
|
|
|
|
|
ret = H5Sencode(sid3, NULL, &scalar_size);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
|
|
|
|
if(scalar_size>0)
|
2006-10-24 04:40:14 +08:00
|
|
|
|
scalar_buf = (unsigned char*)HDcalloc((size_t)1, scalar_size);
|
2004-07-22 05:30:26 +08:00
|
|
|
|
|
|
|
|
|
ret = H5Sencode(sid3, scalar_buf, &scalar_size);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
|
|
|
|
/* Decode from the dataspace buffer and return an object handle */
|
|
|
|
|
decoded_sid3=H5Sdecode(scalar_buf);
|
|
|
|
|
CHECK(decoded_sid3, FAIL, "H5Sdecode");
|
|
|
|
|
|
|
|
|
|
/* Verify extent type */
|
|
|
|
|
space_type = H5Sget_simple_extent_type(decoded_sid3);
|
|
|
|
|
VERIFY(space_type, H5S_SCALAR, "H5Sget_simple_extent_type");
|
|
|
|
|
|
|
|
|
|
/* Verify decoded dataspace */
|
|
|
|
|
n = H5Sget_simple_extent_npoints(decoded_sid3);
|
|
|
|
|
CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
|
|
|
|
|
VERIFY(n, 1, "H5Sget_simple_extent_npoints");
|
|
|
|
|
|
|
|
|
|
rank = H5Sget_simple_extent_ndims(decoded_sid3);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
|
|
|
|
|
VERIFY(rank, 0, "H5Sget_simple_extent_ndims");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(sid3);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2004-07-22 05:30:26 +08:00
|
|
|
|
ret = H5Sclose(decoded_sid3);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
2006-10-24 04:40:14 +08:00
|
|
|
|
HDfree(sbuf);
|
|
|
|
|
HDfree(null_sbuf);
|
|
|
|
|
HDfree(scalar_buf);
|
2004-07-22 05:30:26 +08:00
|
|
|
|
} /* test_h5s_encode() */
|
2004-04-09 05:23:19 +08:00
|
|
|
|
|
1998-04-29 06:33:07 +08:00
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_scalar_write(): Test scalar H5S (dataspace) writing code.
|
2005-08-14 04:53:35 +08:00
|
|
|
|
**
|
1998-04-29 06:33:07 +08:00
|
|
|
|
****************************************************************/
|
2005-08-14 04:53:35 +08:00
|
|
|
|
static void
|
1998-04-29 06:33:07 +08:00
|
|
|
|
test_h5s_scalar_write(void)
|
|
|
|
|
{
|
|
|
|
|
hid_t fid1; /* HDF5 File IDs */
|
|
|
|
|
hid_t dataset; /* Dataset ID */
|
[svn-r18157] Description:
Bring back changes from Coverity session on 1/15/10:
r18111:
Fix Coverity issue #130: make certain that the cache gets freed on error.
r18112:
Fix Coverity issue #43 by making cache testing calls protected by 'pass'
variable.
r18113:
Fix Coverity issue #129 by releasing the cache on error.
r18115:
Coverity #45 fix: patched an error check in H5Screate_simple to prevent future dereferencing of a NULL point.
Added a verification in test/th5s.c.
r18116:
Fix Coverity issue #43 by releasing cache on error.
r18117:
Coverity #362,363 by adding HGOTO_DONE, freeing allocations and associated changes. REsolving coverity results #364-368, 369, 370-372, 377, 379, and 380.
r18118:
Fix Coverity issue #42: assert that cache & test specification pointer are
valid.
r18122:
Coverity #362,363 by adding HGOTO_DONE and freeing allocations. This also takes care of #357,358.
r18123:
Coverity #359-361, 373-376: Added HGOTO_DONE(FAIL) statement after checking allocation for NULL. Verified allocation is freed in done block.
r18128:
Fixed coverity issue #10 -- removed dead code.
Tested on:
Mac OS X/32 10.6.2 (amazon)
2010-01-23 12:39:40 +08:00
|
|
|
|
hid_t sid1; /* Dataspace ID */
|
2001-03-17 02:17:25 +08:00
|
|
|
|
int rank; /* Logical rank of dataspace */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
hsize_t tdims[4]; /* Dimension array to test with */
|
2001-03-17 02:17:25 +08:00
|
|
|
|
hssize_t n; /* Number of dataspace elements */
|
[svn-r18157] Description:
Bring back changes from Coverity session on 1/15/10:
r18111:
Fix Coverity issue #130: make certain that the cache gets freed on error.
r18112:
Fix Coverity issue #43 by making cache testing calls protected by 'pass'
variable.
r18113:
Fix Coverity issue #129 by releasing the cache on error.
r18115:
Coverity #45 fix: patched an error check in H5Screate_simple to prevent future dereferencing of a NULL point.
Added a verification in test/th5s.c.
r18116:
Fix Coverity issue #43 by releasing cache on error.
r18117:
Coverity #362,363 by adding HGOTO_DONE, freeing allocations and associated changes. REsolving coverity results #364-368, 369, 370-372, 377, 379, and 380.
r18118:
Fix Coverity issue #42: assert that cache & test specification pointer are
valid.
r18122:
Coverity #362,363 by adding HGOTO_DONE and freeing allocations. This also takes care of #357,358.
r18123:
Coverity #359-361, 373-376: Added HGOTO_DONE(FAIL) statement after checking allocation for NULL. Verified allocation is freed in done block.
r18128:
Fixed coverity issue #10 -- removed dead code.
Tested on:
Mac OS X/32 10.6.2 (amazon)
2010-01-23 12:39:40 +08:00
|
|
|
|
H5S_class_t ext_type; /* Extent type */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
herr_t ret; /* Generic return value */
|
|
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
2001-03-17 02:17:25 +08:00
|
|
|
|
MESSAGE(5, ("Testing Scalar Dataspace Manipulation during Writing\n"));
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
|
|
|
|
/* Create file */
|
2001-04-01 11:25:53 +08:00
|
|
|
|
fid1 = H5Fcreate(DATAFILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
|
1998-04-29 06:33:07 +08:00
|
|
|
|
CHECK(fid1, FAIL, "H5Fcreate");
|
|
|
|
|
|
[svn-r18157] Description:
Bring back changes from Coverity session on 1/15/10:
r18111:
Fix Coverity issue #130: make certain that the cache gets freed on error.
r18112:
Fix Coverity issue #43 by making cache testing calls protected by 'pass'
variable.
r18113:
Fix Coverity issue #129 by releasing the cache on error.
r18115:
Coverity #45 fix: patched an error check in H5Screate_simple to prevent future dereferencing of a NULL point.
Added a verification in test/th5s.c.
r18116:
Fix Coverity issue #43 by releasing cache on error.
r18117:
Coverity #362,363 by adding HGOTO_DONE, freeing allocations and associated changes. REsolving coverity results #364-368, 369, 370-372, 377, 379, and 380.
r18118:
Fix Coverity issue #42: assert that cache & test specification pointer are
valid.
r18122:
Coverity #362,363 by adding HGOTO_DONE and freeing allocations. This also takes care of #357,358.
r18123:
Coverity #359-361, 373-376: Added HGOTO_DONE(FAIL) statement after checking allocation for NULL. Verified allocation is freed in done block.
r18128:
Fixed coverity issue #10 -- removed dead code.
Tested on:
Mac OS X/32 10.6.2 (amazon)
2010-01-23 12:39:40 +08:00
|
|
|
|
/* Verify a non-zero rank fails with a NULL dimension. */
|
|
|
|
|
H5E_BEGIN_TRY {
|
|
|
|
|
sid1 = H5Screate_simple(SPACE1_RANK, NULL, NULL);
|
|
|
|
|
} H5E_END_TRY
|
|
|
|
|
VERIFY(sid1, FAIL, "H5Screate_simple");
|
|
|
|
|
|
1998-04-29 06:33:07 +08:00
|
|
|
|
/* Create scalar dataspace */
|
|
|
|
|
sid1 = H5Screate_simple(SPACE3_RANK, NULL, NULL);
|
|
|
|
|
CHECK(sid1, FAIL, "H5Screate_simple");
|
|
|
|
|
|
1998-09-01 11:35:23 +08:00
|
|
|
|
n = H5Sget_simple_extent_npoints(sid1);
|
2001-03-17 02:17:25 +08:00
|
|
|
|
CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
|
1998-09-01 11:35:23 +08:00
|
|
|
|
VERIFY(n, 1, "H5Sget_simple_extent_npoints");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
1998-09-01 11:35:23 +08:00
|
|
|
|
rank = H5Sget_simple_extent_ndims(sid1);
|
2001-03-17 02:17:25 +08:00
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
|
1998-09-01 11:35:23 +08:00
|
|
|
|
VERIFY(rank, SPACE3_RANK, "H5Sget_simple_extent_ndims");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
2001-03-17 02:17:25 +08:00
|
|
|
|
rank = H5Sget_simple_extent_dims(sid1, tdims, NULL);
|
|
|
|
|
VERIFY(rank, 0, "H5Sget_simple_extent_dims");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
1998-07-24 03:03:01 +08:00
|
|
|
|
/* Verify extent type */
|
1998-09-01 11:35:23 +08:00
|
|
|
|
ext_type = H5Sget_simple_extent_type(sid1);
|
|
|
|
|
VERIFY(ext_type, H5S_SCALAR, "H5Sget_simple_extent_type");
|
1998-07-24 03:03:01 +08:00
|
|
|
|
|
1998-04-29 06:33:07 +08:00
|
|
|
|
/* Create a dataset */
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
dataset = H5Dcreate2(fid1, "Dataset1", H5T_NATIVE_UINT, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
|
|
|
|
CHECK(dataset, FAIL, "H5Dcreate2");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
1998-06-19 05:03:30 +08:00
|
|
|
|
ret = H5Dwrite(dataset, H5T_NATIVE_UINT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &space3_data);
|
1998-04-29 06:33:07 +08:00
|
|
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
|
|
|
|
|
|
|
|
|
/* Close Dataset */
|
|
|
|
|
ret = H5Dclose(dataset);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
|
|
|
|
|
|
|
|
/* Close scalar dataspace */
|
|
|
|
|
ret = H5Sclose(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
/* Close file */
|
|
|
|
|
ret = H5Fclose(fid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fclose");
|
|
|
|
|
} /* test_h5s_scalar_write() */
|
|
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_scalar_read(): Test scalar H5S (dataspace) reading code.
|
2005-08-14 04:53:35 +08:00
|
|
|
|
**
|
1998-04-29 06:33:07 +08:00
|
|
|
|
****************************************************************/
|
2005-08-14 04:53:35 +08:00
|
|
|
|
static void
|
1998-04-29 06:33:07 +08:00
|
|
|
|
test_h5s_scalar_read(void)
|
|
|
|
|
{
|
|
|
|
|
hid_t fid1; /* HDF5 File IDs */
|
|
|
|
|
hid_t dataset; /* Dataset ID */
|
1998-06-19 05:03:30 +08:00
|
|
|
|
hid_t sid1; /* Dataspace ID */
|
2001-03-17 02:17:25 +08:00
|
|
|
|
int rank; /* Logical rank of dataspace */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
hsize_t tdims[4]; /* Dimension array to test with */
|
2001-03-17 02:17:25 +08:00
|
|
|
|
hssize_t n; /* Number of dataspace elements */
|
1998-06-19 05:03:30 +08:00
|
|
|
|
unsigned rdata; /* Scalar data read in */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
herr_t ret; /* Generic return value */
|
2002-06-05 00:23:22 +08:00
|
|
|
|
H5S_class_t ext_type; /* Extent type */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
2001-03-17 02:17:25 +08:00
|
|
|
|
MESSAGE(5, ("Testing Scalar Dataspace Manipulation during Reading\n"));
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
|
|
|
|
/* Create file */
|
2001-04-01 11:25:53 +08:00
|
|
|
|
fid1 = H5Fopen(DATAFILE, H5F_ACC_RDWR, H5P_DEFAULT);
|
1998-04-29 06:33:07 +08:00
|
|
|
|
CHECK(fid1, FAIL, "H5Fopen");
|
|
|
|
|
|
|
|
|
|
/* Create a dataset */
|
[svn-r14193] Description:
Make H5Dopen versioned and change all internal usage to use H5Dopen2
Add simple regression test for H5Dopen1
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-09 03:59:36 +08:00
|
|
|
|
dataset = H5Dopen2(fid1, "Dataset1", H5P_DEFAULT);
|
|
|
|
|
CHECK(dataset, FAIL, "H5Dopen2");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
[svn-r14193] Description:
Make H5Dopen versioned and change all internal usage to use H5Dopen2
Add simple regression test for H5Dopen1
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-09 03:59:36 +08:00
|
|
|
|
sid1 = H5Dget_space(dataset);
|
1998-04-29 06:33:07 +08:00
|
|
|
|
CHECK(sid1, FAIL, "H5Dget_space");
|
|
|
|
|
|
1998-09-01 11:35:23 +08:00
|
|
|
|
n = H5Sget_simple_extent_npoints(sid1);
|
2001-03-17 02:17:25 +08:00
|
|
|
|
CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
|
1998-09-01 11:35:23 +08:00
|
|
|
|
VERIFY(n, 1, "H5Sget_simple_extent_npoints");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
1998-09-01 11:35:23 +08:00
|
|
|
|
rank = H5Sget_simple_extent_ndims(sid1);
|
2001-03-17 02:17:25 +08:00
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
|
1998-09-01 11:35:23 +08:00
|
|
|
|
VERIFY(rank, SPACE3_RANK, "H5Sget_simple_extent_ndims");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
2001-03-17 02:17:25 +08:00
|
|
|
|
rank = H5Sget_simple_extent_dims(sid1, tdims, NULL);
|
|
|
|
|
VERIFY(rank, 0, "H5Sget_simple_extent_dims");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
2002-06-05 00:23:22 +08:00
|
|
|
|
/* Verify extent type */
|
|
|
|
|
ext_type = H5Sget_simple_extent_type(sid1);
|
|
|
|
|
VERIFY(ext_type, H5S_SCALAR, "H5Sget_simple_extent_type");
|
|
|
|
|
|
1998-06-19 05:03:30 +08:00
|
|
|
|
ret = H5Dread(dataset, H5T_NATIVE_UINT, H5S_ALL, H5S_ALL, H5P_DEFAULT, &rdata);
|
1998-04-29 06:33:07 +08:00
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
|
|
|
|
VERIFY(rdata, space3_data, "H5Dread");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
1998-04-29 06:33:07 +08:00
|
|
|
|
/* Close Dataset */
|
|
|
|
|
ret = H5Dclose(dataset);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
|
|
|
|
|
|
|
|
/* Close scalar dataspace */
|
|
|
|
|
ret = H5Sclose(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
/* Close file */
|
|
|
|
|
ret = H5Fclose(fid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fclose");
|
|
|
|
|
} /* test_h5s_scalar_read() */
|
|
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_compound_scalar_write(): Test scalar H5S (dataspace) writing for
|
|
|
|
|
** compound datatypes.
|
2005-08-14 04:53:35 +08:00
|
|
|
|
**
|
1998-04-29 06:33:07 +08:00
|
|
|
|
****************************************************************/
|
2005-08-14 04:53:35 +08:00
|
|
|
|
static void
|
1998-04-29 06:33:07 +08:00
|
|
|
|
test_h5s_compound_scalar_write(void)
|
|
|
|
|
{
|
|
|
|
|
hid_t fid1; /* HDF5 File IDs */
|
|
|
|
|
hid_t dataset; /* Dataset ID */
|
1998-06-19 05:03:30 +08:00
|
|
|
|
hid_t tid1; /* Attribute datatype ID */
|
|
|
|
|
hid_t sid1; /* Dataspace ID */
|
2001-03-17 02:17:25 +08:00
|
|
|
|
int rank; /* Logical rank of dataspace */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
hsize_t tdims[4]; /* Dimension array to test with */
|
2001-03-17 02:17:25 +08:00
|
|
|
|
hssize_t n; /* Number of dataspace elements */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
herr_t ret; /* Generic return value */
|
|
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
2001-03-17 02:17:25 +08:00
|
|
|
|
MESSAGE(5, ("Testing Scalar Dataspace Manipulation for Writing Compound Datatypes\n"));
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
|
|
|
|
/* Create file */
|
2001-04-01 11:25:53 +08:00
|
|
|
|
fid1 = H5Fcreate(DATAFILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
|
1998-04-29 06:33:07 +08:00
|
|
|
|
CHECK(fid1, FAIL, "H5Fcreate");
|
|
|
|
|
|
|
|
|
|
/* Create the compound datatype. */
|
|
|
|
|
tid1 = H5Tcreate (H5T_COMPOUND, sizeof(struct space4_struct));
|
|
|
|
|
CHECK(tid1, FAIL, "H5Tcreate");
|
|
|
|
|
space4_field1_off=HOFFSET(struct space4_struct, c1);
|
1998-06-19 05:03:30 +08:00
|
|
|
|
ret = H5Tinsert(tid1, SPACE4_FIELDNAME1, space4_field1_off,
|
1998-11-26 01:21:21 +08:00
|
|
|
|
H5T_NATIVE_SCHAR);
|
1998-04-29 06:33:07 +08:00
|
|
|
|
CHECK(ret, FAIL, "H5Tinsert");
|
|
|
|
|
space4_field2_off=HOFFSET(struct space4_struct, u);
|
1998-06-19 05:03:30 +08:00
|
|
|
|
ret = H5Tinsert(tid1, SPACE4_FIELDNAME2, space4_field2_off,
|
|
|
|
|
H5T_NATIVE_UINT);
|
1998-04-29 06:33:07 +08:00
|
|
|
|
CHECK(ret, FAIL, "H5Tinsert");
|
|
|
|
|
space4_field3_off=HOFFSET(struct space4_struct, f);
|
1998-06-19 05:03:30 +08:00
|
|
|
|
ret = H5Tinsert(tid1, SPACE4_FIELDNAME3, space4_field3_off,
|
|
|
|
|
H5T_NATIVE_FLOAT);
|
1998-04-29 06:33:07 +08:00
|
|
|
|
CHECK(ret, FAIL, "H5Tinsert");
|
|
|
|
|
space4_field4_off=HOFFSET(struct space4_struct, c2);
|
1998-06-19 05:03:30 +08:00
|
|
|
|
ret = H5Tinsert(tid1, SPACE4_FIELDNAME4, space4_field4_off,
|
1998-11-26 01:21:21 +08:00
|
|
|
|
H5T_NATIVE_SCHAR);
|
1998-04-29 06:33:07 +08:00
|
|
|
|
CHECK(ret, FAIL, "H5Tinsert");
|
|
|
|
|
|
|
|
|
|
/* Create scalar dataspace */
|
|
|
|
|
sid1 = H5Screate_simple(SPACE3_RANK, NULL, NULL);
|
|
|
|
|
CHECK(sid1, FAIL, "H5Screate_simple");
|
|
|
|
|
|
1998-09-01 11:35:23 +08:00
|
|
|
|
n = H5Sget_simple_extent_npoints(sid1);
|
2001-03-17 02:17:25 +08:00
|
|
|
|
CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
|
1998-09-01 11:35:23 +08:00
|
|
|
|
VERIFY(n, 1, "H5Sget_simple_extent_npoints");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
1998-09-01 11:35:23 +08:00
|
|
|
|
rank = H5Sget_simple_extent_ndims(sid1);
|
2001-03-17 02:17:25 +08:00
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
|
1998-09-01 11:35:23 +08:00
|
|
|
|
VERIFY(rank, SPACE3_RANK, "H5Sget_simple_extent_ndims");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
2001-03-17 02:17:25 +08:00
|
|
|
|
rank = H5Sget_simple_extent_dims(sid1, tdims, NULL);
|
|
|
|
|
VERIFY(rank, 0, "H5Sget_simple_extent_dims");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
|
|
|
|
/* Create a dataset */
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
dataset = H5Dcreate2(fid1, "Dataset1", tid1, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
|
|
|
|
CHECK(dataset, FAIL, "H5Dcreate2");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
|
|
|
|
ret = H5Dwrite(dataset, tid1, H5S_ALL, H5S_ALL, H5P_DEFAULT, &space4_data);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dwrite");
|
|
|
|
|
|
|
|
|
|
/* Close Dataset */
|
|
|
|
|
ret = H5Dclose(dataset);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
|
|
|
|
2010-08-21 05:37:12 +08:00
|
|
|
|
/* Close compound datatype */
|
|
|
|
|
ret = H5Tclose(tid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
|
|
|
|
1998-04-29 06:33:07 +08:00
|
|
|
|
/* Close scalar dataspace */
|
|
|
|
|
ret = H5Sclose(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
/* Close file */
|
|
|
|
|
ret = H5Fclose(fid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fclose");
|
|
|
|
|
} /* test_h5s_compound_scalar_write() */
|
|
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_compound_scalar_read(): Test scalar H5S (dataspace) reading for
|
|
|
|
|
** compound datatypes.
|
2005-08-14 04:53:35 +08:00
|
|
|
|
**
|
1998-04-29 06:33:07 +08:00
|
|
|
|
****************************************************************/
|
2005-08-14 04:53:35 +08:00
|
|
|
|
static void
|
1998-04-29 06:33:07 +08:00
|
|
|
|
test_h5s_compound_scalar_read(void)
|
|
|
|
|
{
|
|
|
|
|
hid_t fid1; /* HDF5 File IDs */
|
|
|
|
|
hid_t dataset; /* Dataset ID */
|
1998-06-19 05:03:30 +08:00
|
|
|
|
hid_t sid1; /* Dataspace ID */
|
|
|
|
|
hid_t type; /* Datatype */
|
2001-03-17 02:17:25 +08:00
|
|
|
|
int rank; /* Logical rank of dataspace */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
hsize_t tdims[4]; /* Dimension array to test with */
|
2001-03-17 02:17:25 +08:00
|
|
|
|
hssize_t n; /* Number of dataspace elements */
|
1998-06-19 05:03:30 +08:00
|
|
|
|
struct space4_struct rdata; /* Scalar data read in */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
herr_t ret; /* Generic return value */
|
|
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
2001-03-17 02:17:25 +08:00
|
|
|
|
MESSAGE(5, ("Testing Scalar Dataspace Manipulation for Reading Compound Datatypes\n"));
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
|
|
|
|
/* Create file */
|
2001-04-01 11:25:53 +08:00
|
|
|
|
fid1 = H5Fopen(DATAFILE, H5F_ACC_RDWR, H5P_DEFAULT);
|
1998-04-29 06:33:07 +08:00
|
|
|
|
CHECK(fid1, FAIL, "H5Fopen");
|
|
|
|
|
|
|
|
|
|
/* Create a dataset */
|
[svn-r14193] Description:
Make H5Dopen versioned and change all internal usage to use H5Dopen2
Add simple regression test for H5Dopen1
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-09 03:59:36 +08:00
|
|
|
|
dataset = H5Dopen2(fid1, "Dataset1", H5P_DEFAULT);
|
|
|
|
|
CHECK(dataset, FAIL, "H5Dopen2");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
[svn-r14193] Description:
Make H5Dopen versioned and change all internal usage to use H5Dopen2
Add simple regression test for H5Dopen1
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-09 03:59:36 +08:00
|
|
|
|
sid1 = H5Dget_space(dataset);
|
1998-04-29 06:33:07 +08:00
|
|
|
|
CHECK(sid1, FAIL, "H5Dget_space");
|
|
|
|
|
|
1998-09-01 11:35:23 +08:00
|
|
|
|
n = H5Sget_simple_extent_npoints(sid1);
|
2001-03-17 02:17:25 +08:00
|
|
|
|
CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
|
1998-09-01 11:35:23 +08:00
|
|
|
|
VERIFY(n, 1, "H5Sget_simple_extent_npoints");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
1998-09-01 11:35:23 +08:00
|
|
|
|
rank = H5Sget_simple_extent_ndims(sid1);
|
2001-03-17 02:17:25 +08:00
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
|
1998-09-01 11:35:23 +08:00
|
|
|
|
VERIFY(rank, SPACE3_RANK, "H5Sget_simple_extent_ndims");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
2001-03-17 02:17:25 +08:00
|
|
|
|
rank = H5Sget_simple_extent_dims(sid1, tdims, NULL);
|
|
|
|
|
VERIFY(rank, 0, "H5Sget_simple_extent_dims");
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
|
|
|
|
type=H5Dget_type(dataset);
|
|
|
|
|
CHECK(type, FAIL, "H5Dget_type");
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
1998-04-29 06:33:07 +08:00
|
|
|
|
ret = H5Dread(dataset, type, H5S_ALL, H5S_ALL, H5P_DEFAULT, &rdata);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dread");
|
|
|
|
|
if(HDmemcmp(&space4_data,&rdata,sizeof(struct space4_struct))) {
|
|
|
|
|
printf("scalar data different: space4_data.c1=%c, read_data4.c1=%c\n",space4_data.c1,rdata.c1);
|
|
|
|
|
printf("scalar data different: space4_data.u=%u, read_data4.u=%u\n",space4_data.u,rdata.u);
|
2015-03-12 06:51:14 +08:00
|
|
|
|
printf("scalar data different: space4_data.f=%f, read_data4.f=%f\n",(double)space4_data.f,(double)rdata.f);
|
2004-01-10 09:41:13 +08:00
|
|
|
|
TestErrPrintf("scalar data different: space4_data.c1=%c, read_data4.c1=%c\n",space4_data.c1,rdata.c2);
|
1998-04-29 06:33:07 +08:00
|
|
|
|
} /* end if */
|
2005-08-14 04:53:35 +08:00
|
|
|
|
|
2006-05-04 06:04:30 +08:00
|
|
|
|
/* Close datatype */
|
|
|
|
|
ret = H5Tclose(type);
|
|
|
|
|
CHECK(ret, FAIL, "H5Tclose");
|
|
|
|
|
|
1998-04-29 06:33:07 +08:00
|
|
|
|
/* Close Dataset */
|
|
|
|
|
ret = H5Dclose(dataset);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
|
|
|
|
|
|
|
|
/* Close scalar dataspace */
|
|
|
|
|
ret = H5Sclose(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
/* Close file */
|
|
|
|
|
ret = H5Fclose(fid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fclose");
|
|
|
|
|
} /* test_h5s_compound_scalar_read() */
|
1997-09-04 21:03:31 +08:00
|
|
|
|
|
2001-10-03 00:58:16 +08:00
|
|
|
|
/* Data arrays for chunk test */
|
|
|
|
|
double chunk_data_dbl[50000][3];
|
|
|
|
|
float chunk_data_flt[50000][3];
|
|
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_chunk(): Exercise chunked I/O, testing when data conversion
|
|
|
|
|
** is necessary and the entire chunk read in doesn't fit into the
|
|
|
|
|
** conversion buffer
|
2005-08-14 04:53:35 +08:00
|
|
|
|
**
|
2001-10-03 00:58:16 +08:00
|
|
|
|
****************************************************************/
|
2005-08-14 04:53:35 +08:00
|
|
|
|
static void
|
2001-10-03 00:58:16 +08:00
|
|
|
|
test_h5s_chunk(void)
|
|
|
|
|
{
|
|
|
|
|
herr_t status;
|
|
|
|
|
hid_t fileID, dsetID;
|
|
|
|
|
hid_t plist_id;
|
|
|
|
|
hid_t space_id;
|
|
|
|
|
hsize_t dims[2];
|
|
|
|
|
hsize_t csize[2];
|
|
|
|
|
int i,j;
|
|
|
|
|
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
fileID = H5Fcreate(DATAFILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
|
2001-10-03 00:58:16 +08:00
|
|
|
|
CHECK(fileID, FAIL, "H5Fcreate");
|
|
|
|
|
|
|
|
|
|
plist_id = H5Pcreate(H5P_DATASET_CREATE);
|
|
|
|
|
CHECK(plist_id, FAIL, "H5Pcreate");
|
|
|
|
|
|
|
|
|
|
csize[0] = 50000;
|
|
|
|
|
csize[1] = 3;
|
|
|
|
|
status = H5Pset_chunk(plist_id, 2, csize);
|
|
|
|
|
CHECK(status, FAIL, "H5Pset_chunk");
|
|
|
|
|
|
|
|
|
|
/* Create the data space */
|
|
|
|
|
dims[0] = 50000;
|
|
|
|
|
dims[1] = 3;
|
|
|
|
|
space_id = H5Screate_simple(2, dims, NULL);
|
|
|
|
|
CHECK(space_id, FAIL, "H5Screate_simple");
|
|
|
|
|
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
dsetID = H5Dcreate2(fileID, "coords", H5T_NATIVE_FLOAT, space_id, H5P_DEFAULT, plist_id, H5P_DEFAULT);
|
|
|
|
|
CHECK(dsetID, FAIL, "H5Dcreate2");
|
2001-10-03 00:58:16 +08:00
|
|
|
|
|
|
|
|
|
/* Initialize float array */
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
for(i = 0; i < 50000; i++)
|
|
|
|
|
for(j = 0; j < 3; j++)
|
2016-07-23 06:43:18 +08:00
|
|
|
|
chunk_data_flt[i][j] = (float)(i + 1) * 2.5F - (float)j * 100.3F;
|
2001-10-03 00:58:16 +08:00
|
|
|
|
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
status = H5Dwrite(dsetID, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, chunk_data_flt);
|
2001-10-03 00:58:16 +08:00
|
|
|
|
CHECK(status, FAIL, "H5Dwrite");
|
|
|
|
|
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
status = H5Pclose(plist_id);
|
2001-10-03 00:58:16 +08:00
|
|
|
|
CHECK(status, FAIL, "H5Pclose");
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
status = H5Sclose(space_id);
|
2001-10-03 00:58:16 +08:00
|
|
|
|
CHECK(status, FAIL, "H5Sclose");
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
status = H5Dclose(dsetID);
|
2001-10-03 00:58:16 +08:00
|
|
|
|
CHECK(status, FAIL, "H5Dclose");
|
[svn-r14199] Description:
Add H5Dcreate to API versioned routines, replacing internal usage with
H5Dcreate2
Fix thread-safe error stack initialization for API versioned error
stack printing routines.
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-12 00:24:11 +08:00
|
|
|
|
status = H5Fclose(fileID);
|
2001-10-03 00:58:16 +08:00
|
|
|
|
CHECK(status, FAIL, "H5Fclose");
|
|
|
|
|
|
|
|
|
|
/* Reset/initialize the data arrays to read in */
|
[svn-r14193] Description:
Make H5Dopen versioned and change all internal usage to use H5Dopen2
Add simple regression test for H5Dopen1
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-09 03:59:36 +08:00
|
|
|
|
HDmemset(chunk_data_dbl, 0, sizeof(double) * 50000 * 3);
|
|
|
|
|
HDmemset(chunk_data_flt, 0, sizeof(float) * 50000 * 3);
|
2001-10-03 00:58:16 +08:00
|
|
|
|
|
[svn-r14193] Description:
Make H5Dopen versioned and change all internal usage to use H5Dopen2
Add simple regression test for H5Dopen1
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-09 03:59:36 +08:00
|
|
|
|
fileID = H5Fopen(DATAFILE, H5F_ACC_RDONLY, H5P_DEFAULT);
|
2001-10-03 00:58:16 +08:00
|
|
|
|
CHECK(fileID, FAIL, "H5Fopen");
|
[svn-r14193] Description:
Make H5Dopen versioned and change all internal usage to use H5Dopen2
Add simple regression test for H5Dopen1
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-09 03:59:36 +08:00
|
|
|
|
dsetID = H5Dopen2(fileID, "coords", H5P_DEFAULT);
|
|
|
|
|
CHECK(dsetID, FAIL, "H5Dopen2");
|
2001-10-03 00:58:16 +08:00
|
|
|
|
|
[svn-r19472] Description:
Create a new, more streamlined method of generating I/O sequences when
there is only a single block defined by a hyperslab. This improves the
performance of Ger Van Diepen's (LOFAR team) benchmark by about 20%.
Tested on:
FreeBSD/32 6.3 (duty) in debug mode
FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (jam) w/PGI compilers, w/default API=1.8.x,
w/C++ & FORTRAN, w/threadsafe, in debug mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, w/threadsafe, in production mode
Linux/PPC 2.6 (heiwa) w/C++ & FORTRAN, w/threadsafe, in debug mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in debug mode
Mac OS X/32 10.6.4 (amazon) in debug mode
Mac OS X/32 10.6.4 (amazon) w/C++ & FORTRAN, w/threadsafe,
in production mode
Mac OS X/32 10.6.4 (amazon) w/parallel, in debug mode
2010-09-23 23:03:42 +08:00
|
|
|
|
status= H5Dread(dsetID, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, chunk_data_dbl);
|
2001-10-03 00:58:16 +08:00
|
|
|
|
CHECK(status, FAIL, "H5Dread");
|
[svn-r19472] Description:
Create a new, more streamlined method of generating I/O sequences when
there is only a single block defined by a hyperslab. This improves the
performance of Ger Van Diepen's (LOFAR team) benchmark by about 20%.
Tested on:
FreeBSD/32 6.3 (duty) in debug mode
FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (jam) w/PGI compilers, w/default API=1.8.x,
w/C++ & FORTRAN, w/threadsafe, in debug mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, w/threadsafe, in production mode
Linux/PPC 2.6 (heiwa) w/C++ & FORTRAN, w/threadsafe, in debug mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in debug mode
Mac OS X/32 10.6.4 (amazon) in debug mode
Mac OS X/32 10.6.4 (amazon) w/C++ & FORTRAN, w/threadsafe,
in production mode
Mac OS X/32 10.6.4 (amazon) w/parallel, in debug mode
2010-09-23 23:03:42 +08:00
|
|
|
|
status= H5Dread(dsetID, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, chunk_data_flt);
|
2001-10-03 00:58:16 +08:00
|
|
|
|
CHECK(status, FAIL, "H5Dread");
|
|
|
|
|
|
[svn-r14193] Description:
Make H5Dopen versioned and change all internal usage to use H5Dopen2
Add simple regression test for H5Dopen1
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-09 03:59:36 +08:00
|
|
|
|
status = H5Dclose(dsetID);
|
2001-10-03 00:58:16 +08:00
|
|
|
|
CHECK(status, FAIL, "H5Dclose");
|
[svn-r14193] Description:
Make H5Dopen versioned and change all internal usage to use H5Dopen2
Add simple regression test for H5Dopen1
Tested on:
FreeBSD/32 6.2 (duty) in debug mode
FreeBSD/64 6.2 (liberty) w/C++ & FORTRAN, in debug mode
Linux/32 2.6 (kagiso) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
in debug mode
Linux/64-amd64 2.6 (smirom) w/default API=1.6.x, w/C++ & FORTRAN,
in production mode
Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
in production mode
Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
w/szip filter, in production mode
Mac OS X/32 10.4.10 (amazon) in debug mode
2007-10-09 03:59:36 +08:00
|
|
|
|
status = H5Fclose(fileID);
|
2001-10-03 00:58:16 +08:00
|
|
|
|
CHECK(status, FAIL, "H5Fclose");
|
|
|
|
|
|
|
|
|
|
for(i=0; i<50000; i++) {
|
|
|
|
|
for(j=0; j<3; j++) {
|
2007-03-12 23:52:52 +08:00
|
|
|
|
/* Check if the two values are within 0.001% range. */
|
2016-07-23 06:43:18 +08:00
|
|
|
|
if(!H5_DBL_REL_EQUAL(chunk_data_dbl[i][j], (double)chunk_data_flt[i][j], (double)0.00001F))
|
2015-03-12 06:51:14 +08:00
|
|
|
|
TestErrPrintf("%u: chunk_data_dbl[%d][%d]=%e, chunk_data_flt[%d][%d]=%e\n", (unsigned)__LINE__, i, j, chunk_data_dbl[i][j], i, j, (double)chunk_data_flt[i][j]);
|
2001-10-03 00:58:16 +08:00
|
|
|
|
} /* end for */
|
|
|
|
|
} /* end for */
|
|
|
|
|
} /* test_h5s_chunk() */
|
|
|
|
|
|
2005-11-07 11:13:53 +08:00
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_extent_equal(): Exercise extent comparison code
|
|
|
|
|
**
|
|
|
|
|
****************************************************************/
|
|
|
|
|
static void
|
|
|
|
|
test_h5s_extent_equal(void)
|
|
|
|
|
{
|
|
|
|
|
hid_t null_space; /* Null dataspace */
|
|
|
|
|
hid_t scalar_space; /* Scalar dataspace */
|
|
|
|
|
hid_t d1_space1, d1_space2, d1_space3, d1_space4; /* 1-D dataspaces */
|
|
|
|
|
hid_t d2_space1, d2_space2, d2_space3, d2_space4; /* 2-D dataspaces */
|
|
|
|
|
hid_t d3_space1, d3_space2, d3_space3, d3_space4; /* 3-D dataspaces */
|
|
|
|
|
hsize_t d1_dims1[1] = {10}, /* 1-D dimensions */
|
|
|
|
|
d1_dims2[1] = {20},
|
|
|
|
|
d1_dims3[1] = {H5S_UNLIMITED};
|
|
|
|
|
hsize_t d2_dims1[2] = {10, 10}, /* 2-D dimensions */
|
|
|
|
|
d2_dims2[2] = {20, 20},
|
|
|
|
|
d2_dims3[2] = {H5S_UNLIMITED, H5S_UNLIMITED};
|
|
|
|
|
hsize_t d3_dims1[3] = {10, 10, 10}, /* 3-D dimensions */
|
|
|
|
|
d3_dims2[3] = {20, 20, 20},
|
|
|
|
|
d3_dims3[3] = {H5S_UNLIMITED, H5S_UNLIMITED, H5S_UNLIMITED};
|
|
|
|
|
htri_t ext_equal; /* Whether two dataspace extents are equal */
|
|
|
|
|
herr_t ret; /* Generic error return */
|
|
|
|
|
|
|
|
|
|
/* Create dataspaces */
|
|
|
|
|
null_space = H5Screate(H5S_NULL);
|
|
|
|
|
CHECK(null_space, FAIL, "H5Screate");
|
|
|
|
|
|
|
|
|
|
scalar_space = H5Screate(H5S_SCALAR);
|
|
|
|
|
CHECK(scalar_space, FAIL, "H5Screate");
|
|
|
|
|
|
|
|
|
|
d1_space1 = H5Screate_simple(1, d1_dims1, NULL);
|
|
|
|
|
CHECK(d1_space1, FAIL, "H5Screate");
|
|
|
|
|
d1_space2 = H5Screate_simple(1, d1_dims2, NULL);
|
|
|
|
|
CHECK(d1_space2, FAIL, "H5Screate");
|
|
|
|
|
d1_space3 = H5Screate_simple(1, d1_dims1, d1_dims2);
|
|
|
|
|
CHECK(d1_space3, FAIL, "H5Screate");
|
|
|
|
|
d1_space4 = H5Screate_simple(1, d1_dims1, d1_dims3);
|
|
|
|
|
CHECK(d1_space4, FAIL, "H5Screate");
|
|
|
|
|
|
|
|
|
|
d2_space1 = H5Screate_simple(2, d2_dims1, NULL);
|
|
|
|
|
CHECK(d2_space1, FAIL, "H5Screate");
|
|
|
|
|
d2_space2 = H5Screate_simple(2, d2_dims2, NULL);
|
|
|
|
|
CHECK(d2_space2, FAIL, "H5Screate");
|
|
|
|
|
d2_space3 = H5Screate_simple(2, d2_dims1, d2_dims2);
|
|
|
|
|
CHECK(d2_space3, FAIL, "H5Screate");
|
|
|
|
|
d2_space4 = H5Screate_simple(2, d2_dims1, d2_dims3);
|
|
|
|
|
CHECK(d2_space4, FAIL, "H5Screate");
|
|
|
|
|
|
|
|
|
|
d3_space1 = H5Screate_simple(3, d3_dims1, NULL);
|
|
|
|
|
CHECK(d3_space1, FAIL, "H5Screate");
|
|
|
|
|
d3_space2 = H5Screate_simple(3, d3_dims2, NULL);
|
|
|
|
|
CHECK(d3_space2, FAIL, "H5Screate");
|
|
|
|
|
d3_space3 = H5Screate_simple(3, d3_dims1, d3_dims2);
|
|
|
|
|
CHECK(d3_space3, FAIL, "H5Screate");
|
|
|
|
|
d3_space4 = H5Screate_simple(3, d3_dims1, d3_dims3);
|
|
|
|
|
CHECK(d3_space4, FAIL, "H5Screate");
|
|
|
|
|
|
|
|
|
|
/* Compare all dataspace combinations */
|
|
|
|
|
|
|
|
|
|
/* Compare null dataspace against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, null_space);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(null_space, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Compare scalar dataspace against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, null_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(scalar_space, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Compare small 1-D dataspace w/no max. dims against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, null_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space1, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Compare larger 1-D dataspace w/no max. dims against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, null_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space2, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Compare small 1-D dataspace w/fixed max. dims against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, null_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space3, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Compare small 1-D dataspace w/unlimited max. dims against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, null_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d1_space4, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Compare small 2-D dataspace w/no max. dims against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, null_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space1, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Compare larger 2-D dataspace w/no max. dims against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, null_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space2, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Compare small 2-D dataspace w/fixed max. dims against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, null_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space3, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Compare small 2-D dataspace w/unlimited max. dims against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, null_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d2_space4, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Compare small 3-D dataspace w/no max. dims against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, null_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space1, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Compare larger 2-D dataspace w/no max. dims against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, null_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space2, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Compare small 2-D dataspace w/fixed max. dims against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, null_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space3, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Compare small 2-D dataspace w/unlimited max. dims against all others, including itself */
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, null_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, scalar_space);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, d1_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, d1_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, d1_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, d1_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, d2_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, d2_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, d2_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, d2_space4);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, d3_space1);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, d3_space2);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, d3_space3);
|
|
|
|
|
VERIFY(ext_equal, FALSE, "H5Sextent_equal");
|
|
|
|
|
ext_equal = H5Sextent_equal(d3_space4, d3_space4);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
|
|
|
|
|
/* Close dataspaces */
|
|
|
|
|
ret = H5Sclose(null_space);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(scalar_space);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(d1_space1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Sclose(d1_space2);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Sclose(d1_space3);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Sclose(d1_space4);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(d2_space1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Sclose(d2_space2);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Sclose(d2_space3);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Sclose(d2_space4);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(d3_space1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Sclose(d3_space2);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Sclose(d3_space3);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Sclose(d3_space4);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
} /* test_h5s_extent_equal() */
|
|
|
|
|
|
2015-02-26 01:29:30 +08:00
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_extent_copy(): Exercise extent copy code
|
|
|
|
|
**
|
|
|
|
|
****************************************************************/
|
|
|
|
|
static void
|
|
|
|
|
test_h5s_extent_copy(void)
|
|
|
|
|
{
|
|
|
|
|
hid_t spaces[14] = {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}; /* Array of all dataspaces */
|
|
|
|
|
hid_t tmp_space = -1;
|
|
|
|
|
hsize_t d1_dims1[1] = {10}, /* 1-D dimensions */
|
|
|
|
|
d1_dims2[1] = {20},
|
|
|
|
|
d1_dims3[1] = {H5S_UNLIMITED};
|
|
|
|
|
hsize_t d2_dims1[2] = {10, 10}, /* 2-D dimensions */
|
|
|
|
|
d2_dims2[2] = {20, 20},
|
|
|
|
|
d2_dims3[2] = {H5S_UNLIMITED, H5S_UNLIMITED};
|
|
|
|
|
hsize_t d3_dims1[3] = {10, 10, 10}, /* 3-D dimensions */
|
|
|
|
|
d3_dims2[3] = {20, 20, 20},
|
|
|
|
|
d3_dims3[3] = {H5S_UNLIMITED, H5S_UNLIMITED, H5S_UNLIMITED};
|
2015-04-01 22:22:16 +08:00
|
|
|
|
hsize_t npoints[14]; /* Expected number of points in selection for each element in spaces */
|
|
|
|
|
hssize_t npoints_ret; /* Number of points returned by H5Sget_select_npoints() */
|
2015-02-26 01:29:30 +08:00
|
|
|
|
htri_t ext_equal; /* Whether two dataspace extents are equal */
|
|
|
|
|
const unsigned num_spaces = sizeof(spaces) / sizeof(spaces[0]);
|
|
|
|
|
unsigned i, j;
|
|
|
|
|
herr_t ret; /* Generic error return */
|
|
|
|
|
|
|
|
|
|
/* Create dataspaces */
|
|
|
|
|
spaces[0] = H5Screate(H5S_NULL);
|
|
|
|
|
CHECK(spaces[0], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[0] = (hsize_t)0;
|
2015-02-26 01:29:30 +08:00
|
|
|
|
|
|
|
|
|
spaces[1] = H5Screate(H5S_SCALAR);
|
|
|
|
|
CHECK(spaces[1], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[1] = (hsize_t)1;
|
2015-02-26 01:29:30 +08:00
|
|
|
|
|
|
|
|
|
spaces[2] = H5Screate_simple(1, d1_dims1, NULL);
|
|
|
|
|
CHECK(spaces[2], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[2] = d1_dims1[0];
|
2015-02-26 01:29:30 +08:00
|
|
|
|
spaces[3] = H5Screate_simple(1, d1_dims2, NULL);
|
|
|
|
|
CHECK(spaces[3], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[3] = d1_dims2[0];
|
2015-02-26 01:29:30 +08:00
|
|
|
|
spaces[4] = H5Screate_simple(1, d1_dims1, d1_dims2);
|
|
|
|
|
CHECK(spaces[4], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[4] = d1_dims1[0];
|
2015-02-26 01:29:30 +08:00
|
|
|
|
spaces[5] = H5Screate_simple(1, d1_dims1, d1_dims3);
|
|
|
|
|
CHECK(spaces[5], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[5] = d1_dims1[0];
|
2015-02-26 01:29:30 +08:00
|
|
|
|
|
|
|
|
|
spaces[6] = H5Screate_simple(2, d2_dims1, NULL);
|
|
|
|
|
CHECK(spaces[6], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[6] = d2_dims1[0] * d2_dims1[1];
|
2015-02-26 01:29:30 +08:00
|
|
|
|
spaces[7] = H5Screate_simple(2, d2_dims2, NULL);
|
|
|
|
|
CHECK(spaces[7], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[7] = d2_dims2[0] * d2_dims2[1];
|
2015-02-26 01:29:30 +08:00
|
|
|
|
spaces[8] = H5Screate_simple(2, d2_dims1, d2_dims2);
|
|
|
|
|
CHECK(spaces[8], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[8] = d2_dims1[0] * d2_dims1[1];
|
2015-02-26 01:29:30 +08:00
|
|
|
|
spaces[9] = H5Screate_simple(2, d2_dims1, d2_dims3);
|
|
|
|
|
CHECK(spaces[9], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[9] = d2_dims1[0] * d2_dims1[1];
|
2015-02-26 01:29:30 +08:00
|
|
|
|
|
|
|
|
|
spaces[10] = H5Screate_simple(3, d3_dims1, NULL);
|
|
|
|
|
CHECK(spaces[10], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[10] = d3_dims1[0] * d3_dims1[1] * d3_dims1[2];
|
2015-02-26 01:29:30 +08:00
|
|
|
|
spaces[11] = H5Screate_simple(3, d3_dims2, NULL);
|
|
|
|
|
CHECK(spaces[11], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[11] = d3_dims2[0] * d3_dims2[1] * d3_dims2[2];
|
2015-02-26 01:29:30 +08:00
|
|
|
|
spaces[12] = H5Screate_simple(3, d3_dims1, d3_dims2);
|
|
|
|
|
CHECK(spaces[12], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[12] = d3_dims1[0] * d3_dims1[1] * d3_dims1[2];
|
2015-02-26 01:29:30 +08:00
|
|
|
|
spaces[13] = H5Screate_simple(3, d3_dims1, d3_dims3);
|
|
|
|
|
CHECK(spaces[13], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
npoints[13] = d3_dims1[0] * d3_dims1[1] * d3_dims1[2];
|
2015-02-26 01:29:30 +08:00
|
|
|
|
|
|
|
|
|
tmp_space = H5Screate(H5S_NULL);
|
|
|
|
|
CHECK(tmp_space, FAIL, "H5Screate");
|
|
|
|
|
|
|
|
|
|
/* Copy between all dataspace combinations. Note there are a few
|
|
|
|
|
* duplicates. */
|
|
|
|
|
for(i = 0; i < num_spaces; i++)
|
|
|
|
|
for(j = i; j < num_spaces; j++) {
|
|
|
|
|
/* Copy from i to j, unless the inner loop just restarted, in which
|
|
|
|
|
* case i and j are the same, so the second call to H5Sextent_copy()
|
|
|
|
|
* will test copying from i/j to i/j */
|
|
|
|
|
ret = H5Sextent_copy(tmp_space, spaces[j]);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sextent_copy");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
|
|
|
|
|
/* Verify that the extents are equal */
|
2015-02-26 01:29:30 +08:00
|
|
|
|
ext_equal = H5Sextent_equal(tmp_space, spaces[j]);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
|
|
|
|
|
2015-04-01 22:22:16 +08:00
|
|
|
|
/* Verify that the correct number of elements is selected */
|
|
|
|
|
npoints_ret = H5Sget_select_npoints(tmp_space);
|
|
|
|
|
VERIFY((hsize_t)npoints_ret, npoints[j], "H5Sget_select_npoints");
|
|
|
|
|
|
2015-02-26 01:29:30 +08:00
|
|
|
|
/* Copy from j to i */
|
|
|
|
|
ret = H5Sextent_copy(tmp_space, spaces[i]);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sextent_copy");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
|
|
|
|
|
/* Verify that the extents are equal */
|
2015-02-26 01:29:30 +08:00
|
|
|
|
ext_equal = H5Sextent_equal(tmp_space, spaces[i]);
|
|
|
|
|
VERIFY(ext_equal, TRUE, "H5Sextent_equal");
|
2015-04-01 22:22:16 +08:00
|
|
|
|
|
|
|
|
|
/* Verify that the correct number of elements is selected */
|
|
|
|
|
npoints_ret = H5Sget_select_npoints(tmp_space);
|
|
|
|
|
VERIFY((hsize_t)npoints_ret, npoints[i], "H5Sget_select_npoints");
|
2015-02-26 01:29:30 +08:00
|
|
|
|
} /* end for */
|
|
|
|
|
|
|
|
|
|
/* Close dataspaces */
|
|
|
|
|
for(i = 0; i < num_spaces; i++) {
|
|
|
|
|
ret = H5Sclose(spaces[i]);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
spaces[i] = -1;
|
|
|
|
|
} /* end for */
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(tmp_space);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
} /* test_h5s_extent_copy() */
|
|
|
|
|
|
2015-08-29 03:43:03 +08:00
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_bug1(): Test Creating dataspace with H5Screate then
|
|
|
|
|
* setting extent with H5Sextent_copy.
|
|
|
|
|
**
|
|
|
|
|
****************************************************************/
|
|
|
|
|
static void
|
|
|
|
|
test_h5s_bug1(void)
|
|
|
|
|
{
|
|
|
|
|
hid_t space1; /* Dataspace to copy extent to */
|
|
|
|
|
hid_t space2; /* Scalar dataspace */
|
|
|
|
|
hsize_t dims[2] = {10, 10}; /* Dimensions */
|
|
|
|
|
hsize_t start[2] = {0, 0}; /* Hyperslab start */
|
|
|
|
|
htri_t select_valid; /* Whether the dataspace selection is valid */
|
|
|
|
|
herr_t ret; /* Generic error return */
|
|
|
|
|
|
|
|
|
|
/* Create dataspaces */
|
|
|
|
|
space1 = H5Screate(H5S_SIMPLE);
|
|
|
|
|
CHECK(space1, FAIL, "H5Screate");
|
|
|
|
|
space2 = H5Screate_simple(2, dims, NULL);
|
|
|
|
|
CHECK(space2, FAIL, "H5Screate");
|
|
|
|
|
|
|
|
|
|
/* Copy extent to space1 */
|
|
|
|
|
ret = H5Sextent_copy(space1, space2);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sextent_copy");
|
|
|
|
|
|
|
|
|
|
/* Select hyperslab in space1 containing entire extent */
|
|
|
|
|
ret = H5Sselect_hyperslab(space1, H5S_SELECT_SET, start, NULL, dims, NULL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Check that space1's selection is valid */
|
|
|
|
|
select_valid = H5Sselect_valid(space1);
|
|
|
|
|
CHECK(select_valid, FAIL, "H5Sselect_valid");
|
|
|
|
|
VERIFY(select_valid, TRUE, "H5Sselect_valid result");
|
|
|
|
|
|
|
|
|
|
/* Close dataspaces */
|
|
|
|
|
ret = H5Sclose(space1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Sclose(space2);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
} /* test_h5s_bug1() */
|
|
|
|
|
|
1997-09-04 21:03:31 +08:00
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
1998-04-29 06:33:07 +08:00
|
|
|
|
** test_h5s(): Main H5S (dataspace) testing routine.
|
2005-08-14 04:53:35 +08:00
|
|
|
|
**
|
1997-09-04 21:03:31 +08:00
|
|
|
|
****************************************************************/
|
2005-08-14 04:53:35 +08:00
|
|
|
|
void
|
1998-04-29 06:33:07 +08:00
|
|
|
|
test_h5s(void)
|
1997-09-04 21:03:31 +08:00
|
|
|
|
{
|
|
|
|
|
/* Output message about test being performed */
|
|
|
|
|
MESSAGE(5, ("Testing Dataspaces\n"));
|
|
|
|
|
|
1998-04-29 06:33:07 +08:00
|
|
|
|
test_h5s_basic(); /* Test basic H5S code */
|
2004-04-09 05:23:19 +08:00
|
|
|
|
test_h5s_null(); /* Test Null dataspace H5S code */
|
2011-04-08 05:56:38 +08:00
|
|
|
|
test_h5s_zero_dim(); /* Test dataspace with zero dimension size */
|
2004-07-22 05:30:26 +08:00
|
|
|
|
test_h5s_encode(); /* Test encoding and decoding */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
test_h5s_scalar_write(); /* Test scalar H5S writing code */
|
2004-07-22 05:30:26 +08:00
|
|
|
|
test_h5s_scalar_read(); /* Test scalar H5S reading code */
|
|
|
|
|
|
1998-04-29 06:33:07 +08:00
|
|
|
|
test_h5s_compound_scalar_write(); /* Test compound datatype scalar H5S writing code */
|
|
|
|
|
test_h5s_compound_scalar_read(); /* Test compound datatype scalar H5S reading code */
|
2001-10-03 00:58:16 +08:00
|
|
|
|
|
|
|
|
|
/* This test was added later to exercise a bug in chunked I/O */
|
|
|
|
|
test_h5s_chunk(); /* Exercise bug fix for chunked I/O */
|
2005-11-07 11:13:53 +08:00
|
|
|
|
|
|
|
|
|
test_h5s_extent_equal(); /* Test extent comparison code */
|
2015-02-26 01:29:30 +08:00
|
|
|
|
test_h5s_extent_copy(); /* Test extent copy code */
|
2015-08-29 03:43:03 +08:00
|
|
|
|
test_h5s_bug1(); /* Test bug in offset initialization */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
} /* test_h5s() */
|
1998-07-03 08:57:00 +08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: cleanup_h5s
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Cleanup temporary test files
|
|
|
|
|
*
|
|
|
|
|
* Return: none
|
|
|
|
|
*
|
|
|
|
|
* Programmer: Albert Cheng
|
|
|
|
|
* July 2, 1998
|
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
cleanup_h5s(void)
|
|
|
|
|
{
|
2001-04-01 11:25:53 +08:00
|
|
|
|
remove(DATAFILE);
|
2004-08-02 22:03:40 +08:00
|
|
|
|
remove(NULLFILE);
|
2004-07-28 00:55:19 +08:00
|
|
|
|
remove(BASICFILE);
|
2011-04-11 23:59:41 +08:00
|
|
|
|
remove(ZEROFILE);
|
1998-07-03 08:57:00 +08:00
|
|
|
|
}
|