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
|
|
|
* 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 *
|
2021-02-17 22:52:04 +08:00
|
|
|
* distribution tree, or in https://www.hdfgroup.org/licenses. *
|
2017-04-15 00:54:16 +08:00
|
|
|
* 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
|
|
|
|
|
|
|
|
/***********************************************************
|
2020-09-30 22:27:10 +08:00
|
|
|
*
|
|
|
|
|
* Test program: th5s
|
|
|
|
|
*
|
|
|
|
|
* Test the dataspace functionality
|
|
|
|
|
*
|
|
|
|
|
*************************************************************/
|
1997-09-04 21:03:31 +08:00
|
|
|
|
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
|
|
|
|
2018-03-08 05:49:14 +08:00
|
|
|
#include "H5Iprivate.h"
|
|
|
|
|
#include "H5Pprivate.h"
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This file needs to access private information from the H5S package.
|
|
|
|
|
* This file also needs to access the dataspace testing code.
|
|
|
|
|
*/
|
2020-09-30 22:27:10 +08:00
|
|
|
#define H5S_FRIEND /*suppress error about including H5Spkg */
|
|
|
|
|
#define H5S_TESTING /*suppress warning about H5S testing funcs*/
|
|
|
|
|
#include "H5Spkg.h" /* Dataspaces */
|
2018-03-08 05:49:14 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* This file needs to access private information from the H5O package.
|
|
|
|
|
* This file also needs to access the dataspace testing code.
|
|
|
|
|
*/
|
2020-09-30 22:27:10 +08:00
|
|
|
#define H5O_FRIEND /*suppress error about including H5Opkg */
|
2018-03-08 05:49:14 +08:00
|
|
|
#define H5O_TESTING
|
2020-09-30 22:27:10 +08:00
|
|
|
#include "H5Opkg.h" /* Object header */
|
2018-03-10 06:57:54 +08:00
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
#define TESTFILE "th5s.h5"
|
|
|
|
|
#define DATAFILE "th5s1.h5"
|
|
|
|
|
#define NULLFILE "th5s2.h5"
|
|
|
|
|
#define BASICFILE "th5s3.h5"
|
|
|
|
|
#define ZEROFILE "th5s4.h5"
|
2011-04-08 05:56:38 +08:00
|
|
|
#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"
|
2020-09-30 22:27:10 +08:00
|
|
|
#define BASICATTR "basic_attribute"
|
|
|
|
|
#define NULLDATASET "null_dataset"
|
|
|
|
|
#define NULLATTR "null_attribute"
|
|
|
|
|
#define EXTFILE_NAME "ext_file"
|
1997-09-04 21:03:31 +08:00
|
|
|
|
|
|
|
|
/* 3-D dataset with fixed dimensions */
|
2020-09-30 22:27:10 +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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
#define SPACE2_RANK 4
|
|
|
|
|
#define SPACE2_DIM1 0
|
|
|
|
|
#define SPACE2_DIM2 15
|
|
|
|
|
#define SPACE2_DIM3 13
|
|
|
|
|
#define SPACE2_DIM4 23
|
|
|
|
|
#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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
#define SPACE3_RANK 0
|
|
|
|
|
unsigned space3_data = 65;
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
|
|
|
/* Scalar dataset with compound datatype */
|
2020-09-30 22:27:10 +08:00
|
|
|
#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;
|
1998-04-29 06:33:07 +08:00
|
|
|
struct space4_struct {
|
2020-09-30 22:27:10 +08:00
|
|
|
char c1;
|
1998-06-19 05:03:30 +08:00
|
|
|
unsigned u;
|
2020-09-30 22:27:10 +08:00
|
|
|
float f;
|
|
|
|
|
char c2;
|
|
|
|
|
} space4_data = {'v', 987123, -3.14F, 'g'}; /* Test data for 4th dataspace */
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Testing configuration defines used by:
|
|
|
|
|
* test_h5s_encode_regular_hyper()
|
|
|
|
|
* test_h5s_encode_irregular_hyper()
|
|
|
|
|
* test_h5s_encode_points()
|
|
|
|
|
*/
|
2020-09-30 22:27:10 +08:00
|
|
|
#define CONFIG_8 1
|
|
|
|
|
#define CONFIG_16 2
|
|
|
|
|
#define CONFIG_32 3
|
2021-01-29 20:55:18 +08:00
|
|
|
#define POWER8 256 /* 2^8 */
|
|
|
|
|
#define POWER16 65536 /* 2^16 */
|
2020-09-30 22:27:10 +08:00
|
|
|
#define POWER32 4294967296 /* 2^32 */
|
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
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t fid1; /* HDF5 File IDs */
|
|
|
|
|
hid_t sid1, sid2; /* Dataspace ID */
|
|
|
|
|
hid_t dset1; /* Dataset ID */
|
|
|
|
|
hid_t aid1; /* Attribute ID */
|
|
|
|
|
int rank; /* Logical rank of dataspace */
|
|
|
|
|
hsize_t dims1[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
|
|
|
|
|
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};
|
|
|
|
|
hsize_t tdims[4]; /* Dimension array to test with */
|
|
|
|
|
hsize_t tmax[4];
|
Subfiling VFD (#1883)
* Added support for vector I/O calls to the VFD layer, and
associated test code. Note that this includes the optimization
to allow shortened sizes and types arrays to allow more space
efficient representations of vectors in which all entries are
of the same size and/or type. See the Selection I/o RFC for
further details.
Tested serial and parallel, debug and production on Charis.
serial and parallel debug only on Jelly.
* ran code formatter
quick serial build and test on jelly
* Add H5FD_read_selection() and H5FD_write_selection(). Currently only
translate to scalar calls. Fix const buf in H5FD_write_vector().
* Format source
* Fix comments
* Add selection I/O to chunk code, used when: not using chunk cache, no
datatype conversion, no I/O filters, no page buffer, not using collective
I/O. Requires global variable H5_use_selection_io_g be set to TRUE.
Implemented selection to vector I/O transaltion at the file driver
layer.
* Fix formatting unrelated to previous change to stop github from
complaining.
* Add full API support for selection I/O. Add tests for this.
* Implement selection I/O for contiguous datasets. Fix bug in selection
I/O translation. Add const qualifiers to some internal selection I/O
routines to maintain const-correctness while avoiding memcpys.
* Added vector read / write support to the MPIO VFD, with associated
test code (see testpar/t_vfd.c).
Note that this implementation does NOT support vector entries of
size greater than 2 GB. This must be repaired before release,
but it should be good enough for correctness testing.
As MPIO requires vector I/O requests to be sorted in increasing
address order, also added a vector sort utility in H5FDint.c This
function is tested in passing by the MPIO vector I/O extension.
In passing, repaired a bug in size / type vector extension management
in H5FD_read/write_vector()
Tested parallel debug and production on charis and Jelly.
* Ran source code formatter
* Add support for independent parallel I/O with selection I/O. Add
HDF5_USE_SELECTION_IO env var to control selection I/O (default off).
* Implement parallel collective support for selection I/O.
* Fix comments and run formatter.
* Update selection IO branch with develop (#1215)
Merged branch 'develop' into selection_io
* Sync with develop (#1262)
Updated the branch with develop changes.
* Implement big I/O support for vector I/O requests in the MPIO file
driver.
* Free arrays in H5FD__mpio_read/write_vector() as soon as they're not
needed, to cut down on memory usage during I/O.
* Address comments from code review. Fix const warnings with
H5S_SEL_ITER_INIT().
* Committing clang-format changes
* Feature/subfiling (#1464)
* Initial checkin of merged sub-filing VFD.
Passes regression tests (debug/shared/paralle) on Jelly.
However, bugs and many compiler warnings remain -- not suitable
for merge to develop.
* Minor mods to src/H5FDsubfile_mpi.c to address errors reported by autogen.sh
* Code formatting run -- no test
* Merged my subfiling code fixes into the new selection_io_branch
* Forgot to add the FindMERCURY.cmake file. This will probably disappear soon
* attempting to make a more reliable subfile file open which doesn't return errors. For some unknown reason, the regular posix open will occasionally fail to create a subfile. Some better error handling for file close has been added.
* added NULL option for H5FD_subfiling_config_t in H5Pset_fapl_subfiling (#1034)
* NULL option automatically stacks IOC VFD for subfiling and returns a valid fapl.
* added doxygen subfiling APIs
* Various fixes which allow the IOR benchmark to run correctly
* Lots of updates including the packaging up of the mercury_util source files to enable easier builds for our Benchmarking
* Interim checkin of selection_io_with_subfiling_vfd branch
Moddified testpar/t_vfd.c to test the subfiling vfd with default configuration.
Must update this code to run with a variety of configurations -- most particularly
multiple IO concentrators, and stripe depth small enough to test the other IO
concentrators.
testpar/t_vfd.c exposed a large number of race condidtions -- symtoms included:
1) Crashes (usually seg faults)
2) Heap corruption
3) Stack corruption
4) Double frees of heap space
5) Hangs
6) Out of order execution of I/O requests / violations of POSIX semantics
7) Swapped write requests
Items 1 - 4 turned out to be primarily caused by file close issues --
specifically, the main I/O concentrator thread and its pool of worker threads
were not being shut down properly on file close. Addressing this issue in
combination with some other minor fixes seems to have addressed these issues.
Items 5 & 6 appear to have been caused by issue of I/O requests to the
thread pool in an order that did not maintain POSIX semantics. A rewrite of
the I/O request dispatch code appears to have solved these issues.
Item 7 seems to have been caused by multiple write requests from a given
rank being read by the wrong worker thread. Code to issue "unique" tags for
each write request via the ACK message appears to have cleaned this up.
Note that the code is still in poor condtition. A partial list of known
defects includes:
a) Race condiditon on file close that allows superblock writes to arrive
at the I/O concentrator after it has been shutdown. This defect is
most evident when testpar/t_subfiling_vfd is run with 8 ranks.
b) No error reporting from I/O concentrators -- must design and implement
this. For now, mostly just asserts, which suggests that it should be
run in debug mode.
c) Much commented out and/or un-used code.
d) Code orgnaization
e) Build system with bits of Mercury is awkward -- think of shifting
to pthreads with our own thread pool code.
f) Need to add native support for vector and selection I/O to the subfiling
VFD.
g) Need to review, and posibly rework configuration code.
h) Need to store subfile configuration data in a superblock extension message,
and add code to use this data on file open.
i) Test code is inadequate -- expect more issues as it is extended.
In particular, there is no unit test code for the I/O request dispatch code.
While I think it is correct at present, we need test code to verify this.
Similarly, we need to test with multiple I/O concentrators and much smaller
stripe depth.
My actual code changes were limited to:
src/H5FDioc.c
src/H5FDioc_threads.c
src/H5FDsubfile_int.c
src/H5FDsubfile_mpi.c
src/H5FDsubfiling.c
src/H5FDsubfiling.h
src/H5FDsubfiling_priv.h
testpar/t_subfiling_vfd.c
testpar/t_vfd.c
I'm not sure what is going on with the deletions in src/mercury/src/util.
Tested parallel/debug on Charis and Jelly
* subfiling with selection IO (#1219)
Merged branch 'selection_io' into subfiling branch.
* Subfile name fixes (#1250)
* fixed subfiling naming convention, and added leading zero to rank names.
* Merge branch 'selection_io' into selection_io_with_subfiling_vfd (#1265)
* Added script to join subfiles into a single HDF5 file (#1350)
* Modified H5FD__subfiling_query() to report that the sub-filing VFD supports MPI
This exposed issues with truncate and get EOF in the sub-filing VFD.
I believe I have addressed these issues (get EOF not as fully tested as it should be), howeer,
it exposed race conditions resulting in hangs. As of this writing, I have not been able
to chase these down.
Note that the tests that expose these race conditions are in testpar/t_subfiling_vfd.c, and
are currently skipped. Unskip these tests to reproduce the race conditions.
tested (to the extent possible) debug/parallel on charis and jelly.
* Committing clang-format changes
* fixed H5MM_free
Co-authored-by: mainzer <mainzer#hdfgroup.org>
Co-authored-by: jrmainzer <72230804+jrmainzer@users.noreply.github.com>
Co-authored-by: Richard Warren <Richard.Warren@hdfgroup.org>
Co-authored-by: Richard.Warren <richard.warren@jelly.ad.hdfgroup.org>
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
* Move Subfiling VFD components into H5FDsubfiling source directory
* Update Autotools build and add H5_HAVE_SUBFILING_VFD macro to H5pubconf.h
* Tidy up CMake build of subfiling sources
* Merge branch 'develop' into feature/subfiling (#1539)
Merge branch 'develop' into feature/subfiling
* Add VFD interface version field to Subfiling and IOC VFDs
* Merge branch 'develop' into feature/subfiling (#1557)
Merge branch 'develop' into feature/subfiling
* Merge branch 'develop' into feature/subfiling (#1563)
Merge branch 'develop' into feature/subfiling
* Tidy up merge artifacts after rebase on develop
* Fix incorrect variable in mirror VFD utils CMake
* Ensure VFD values are always defined
* Add subfiling to CMake VFD_LIST if built
* Mark MPI I/O driver self-initialization global as static
* Add Subfiling VFD to predefined VFDs for HDF5_DRIVER env. variable
* Initial progress towards separating private vs. public subfiling code
* include libgen.h in t_vfd tests for correct dirname/basename
* Committing clang-format changes
* removed mercury option, included subfiling header path (#1577)
Added subfiling status to configure output, installed h5fuse.sh to build directory for use in future tests.
* added check for stdatomic.h (#1578)
* added check for stdatomic.h with subfiling
* added H5_HAVE_SUBFILING_VFD for cmake
* fix old-style-definition warning (#1582)
* fix old-style-definition warning
* added test for enable parallel with subfiling VFD (#1586)
Fails if subfiling VFD is not used with parallel support.
* Subfiling/IOC VFD fixes and tidying (#1619)
* Rename CMake option for Subfiling VFD to be consistent with other VFDs
* Miscellaneous Subfiling fixes
Add error message for unset MPI communicator
Support dynamic loading of subfiling VFD with default configuration
* Temporary fix for subfile name issue
* Added subfile checks (#1634)
* added subfile checks
* Feature/subfiling (#1655)
* Subfiling/IOC VFD cleanup
Fix misuse of MPI_COMM_WORLD in IOC VFD
Propagate Subfiling FAPL MPI settings down to IOC FAPL in default
configuration case
Cleanup IOC VFD debugging code
Change sprintf to snprintf in a few places
* Major work on separating Subfiling and IOC VFDs from each other
* Re-write async_completion func to not overuse stack
* Replace usage of MPI_COMM_WORLD with file's actual MPI communicator
* Refactor H5FDsubfile_mpi.c
* Remove empty file H5FDsubfile_mpi.c
* Separate IOC VFD errors to its own error stack
* Committing clang-format changes
* Remove H5TRACE macros from H5FDioc.c
* Integrate H5FDioc_threads.c with IOC error stack
* Fix for subfile name generation
Use number of I/O concentrators from existing subfiling configuration file, if one exists
* Add temporary barrier in "Get EOF" operation to prevent races on EOF
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
* Fix for retrieval of machine Host ID
* Default to MPI_COMM_WORLD if no MPI params set
* added libs rt and pthreads (#1673)
* added libs rt and pthreads
* Feature/subfiling (#1689)
* More tidying of IOC VFD and subfiling debug code
* Remove old unused log file code
* Clear FID from active file map on failure
* Fix bug in generation of subfile names when truncating file
* Change subfile names to start from 1 instead of 0
* Use long long for user-specified stripe size from environment variable
* Skip 0-sized I/Os in low-level IOC I/O routines
* Don't update EOF on read
* Convert printed warning about data size mismatch to assertion
* Don't add base file address to I/O addresses twice
Base address should already be applied as part of H5FDwrite/read_vector calls
* Account for 0-sized I/O vector entries in subfile write/read functions
* Rewrite init_indep_io for clarity
* Correction for IOC wraparound calculations
* Some corrections to iovec calculations
* Remove temporary barrier on EOF retrieval
* Complete work request queue entry on error instead of skipping over
* Account for stripe size wraparound for sf_col_offset calculation
* Committing clang-format changes
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
* Re-write and fix bugs in I/O vector filling routines (#1703)
* Rewrite I/O vector filling routines for clarity
* Fix bug with iovec_fill_last when last I/O size is 0
* added subfiling_dir line read (#1714)
* added subfiling_dir line read and use it
* shellcheck fixes
* I/O request dispatch logic update (#1731)
Short-circuit I/O request dispatch when head of I/O queue is an
in-progress get EOF or truncate operation. This prevents an issue where
a write operation can be dispatched alongside a get EOF/truncate
operation, whereas all I/O requests are supposed to be ineligible for
dispatch until the get EOF/truncate is completed
* h5fuse.sh.in clean-up (#1757)
* Added command-line options
* Committing clang-format changes
* Align with changes from develop
* Mimic MPI I/O VFD for EOF handling
* Initialize context_id field for work request objects
* Use logfile for some debugging information
* Use atomic store to set IOC ready flag
* Use separate communicator for sending file EOF data
Minor IOC cleanup
* Use H5_subfile_fid_to_context to get context ID for file in Subfiling
VFD
* IOVEC calculation fixes
* Updates for debugging code
* Minor fixes for threaded code
* Committing clang-format changes
* Use separate MPI communicator for barrier operations
* Committing clang-format changes
* Rewrite EOF routine to use nonblocking MPI communication
* Committing clang-format changes
* Always dispatch I/O work requests in IOC main loop
* Return distinct MPI communicator to library when requested
* Minor warning cleanup
* Committing clang-format changes
* Generate h5fuse.sh from h5fuse.sh.in in CMake
* Send truncate messages to correct IOC rank
* Committing clang-format changes
* Miscellaneous cleanup
Post some MPI receives before sends
Free some duplicated MPI communicator/Info objects
Remove unnecessary extra MPI_Barrier
* Warning cleanup
* Fix for leaked MPI communicator
* Retrieve file EOF on single rank and bcast it
* Fixes for a few failure paths
* Cleanup of IOC file opens
* Committing clang-format changes
* Use plan MPI_Send for send of EOF messages
* Always check MPI thread support level during Subfiling init
* Committing clang-format changes
* Handle a hang on failure when IOCs can't open subfiles
* Committing clang-format changes
* Refactor file open status consensus check
* Committing clang-format changes
* Fix for MPI_Comm_free being called after MPI_Finalize
* Fix VFD test by setting MPI params before setting subfiling on FAPL
* Update Subfiling VFD error handling and error stack usage
* Improvements for Subfiling logfiles
* Remove prototypes for currently unused routines
* Disable I/O queue stat collecting by default
* Remove unused serialization mutex variable
* Update VFD testing to take subfiling VFD into account
* Fix usage of global subfiling application layout object
* Minor fixes for failure pathways
* Keep track of the number of failures in an IOC I/O queue
* Make sure not to exceed MPI_TAG_UB value for data communication messages
* Committing clang-format changes
* Update for rename of some H5FD 'ctl' opcodes
* Always include Subfiling's public header files in hdf5.h
* Remove old unused code and comments
* Implement support for per-file I/O queues
Allows the subfiling VFD to have multiple HDF5 files open simultaneously
* Use simple MPI_Iprobe over unnecessary MPI_Improbe
* Committing clang-format changes
* Update HDF5 testing to query driver for H5FD_FEAT_DEFAULT_VFD_COMPATIBLE
flag
* Fix a few bugs related to file multi-opens
* Avoid calling MPI routines if subfiling gets reinitialized
* Fix issue when files are closed in a random order
* Update HDF5 testing to query VFD for "using MPI" feature flag
* Register atexit handler in subfiling VFD to call MPI_Finalize after HDF5
closes
* Fail for collective I/O requests until support is implemented
* Correct VOL test function prototypes
* Minor cleanup of old code and comments
* Update mercury dependency
* Cleanup of subfiling configuration structure
* Committing clang-format changes
* Build system updates for Subfiling VFD
* Fix possible hang on failure in t_vfd tests caused by mismatched
MPI_Barrier calls
* Copy subfiling IOC fapl in "fapl get" method
* Mirror subfiling superblock writes to stub file for legacy POSIX-y HDF5
applications
* Allow collective I/O for MPI_BYTE types and rank 0 bcast strategy
* Committing clang-format changes
* Use different scheme for subfiling write message MPI tag calculations
* Committing clang-format changes
* Avoid performing fstat calls on all MPI ranks
* Add MPI_Barrier before finalizing IOC threads
* Use try_lock in I/O queue dispatch to minimize contention from worker threads
* Use simple Waitall for nonblocking I/O waits
* Add configurable IOC main thread delay and try_lock option to I/O queue dispatch
* Fix bug that could cause serialization of non-overlapping I/O requests
* Temporarily treat collective subfiling vector I/O calls as independent
* Removed unused mercury bits
* Add stubs for subfiling and IOC file delete callback
* Update VFD testing for Subfiling VFD
* Work around HDF5 metadata cache bug for Subfiling VFD when MPI Comm size
= 1
* Committing clang-format changes
Co-authored-by: mainzer <mainzer#hdfgroup.org>
Co-authored-by: Neil Fortner <nfortne2@hdfgroup.org>
Co-authored-by: Scot Breitenfeld <brtnfld@hdfgroup.org>
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: jrmainzer <72230804+jrmainzer@users.noreply.github.com>
Co-authored-by: Richard Warren <Richard.Warren@hdfgroup.org>
Co-authored-by: Richard.Warren <richard.warren@jelly.ad.hdfgroup.org>
2022-07-23 04:03:12 +08:00
|
|
|
hssize_t n; /* Number of dataspace elements */
|
|
|
|
|
hbool_t driver_is_default_compatible;
|
2020-09-30 22:27:10 +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");
|
2020-09-30 22:27:10 +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");
|
2020-09-30 22:27:10 +08:00
|
|
|
VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0, "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");
|
2020-09-30 22:27:10 +08:00
|
|
|
VERIFY(n, SPACE2_DIM1 * SPACE2_DIM2 * SPACE2_DIM3 * SPACE2_DIM4, "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");
|
2020-09-30 22:27:10 +08:00
|
|
|
VERIFY(HDmemcmp(tdims, dims2, SPACE2_RANK * sizeof(hsize_t)), 0, "H5Sget_simple_extent_dims");
|
|
|
|
|
VERIFY(HDmemcmp(tmax, max2, SPACE2_RANK * sizeof(hsize_t)), 0, "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");
|
2020-09-30 22:27:10 +08:00
|
|
|
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");
|
2004-07-21 00:26:40 +08:00
|
|
|
|
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
|
|
|
/*
|
2019-07-31 04:34:53 +08:00
|
|
|
* Check to be sure we can't create a simple dataspace that has too many
|
1998-10-27 03:55:54 +08:00
|
|
|
* dimensions.
|
|
|
|
|
*/
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
sid1 = H5Screate_simple(H5S_MAX_RANK + 1, dims3, NULL);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY;
|
1998-10-27 03:55:54 +08:00
|
|
|
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
|
|
|
*/
|
Subfiling VFD (#1883)
* Added support for vector I/O calls to the VFD layer, and
associated test code. Note that this includes the optimization
to allow shortened sizes and types arrays to allow more space
efficient representations of vectors in which all entries are
of the same size and/or type. See the Selection I/o RFC for
further details.
Tested serial and parallel, debug and production on Charis.
serial and parallel debug only on Jelly.
* ran code formatter
quick serial build and test on jelly
* Add H5FD_read_selection() and H5FD_write_selection(). Currently only
translate to scalar calls. Fix const buf in H5FD_write_vector().
* Format source
* Fix comments
* Add selection I/O to chunk code, used when: not using chunk cache, no
datatype conversion, no I/O filters, no page buffer, not using collective
I/O. Requires global variable H5_use_selection_io_g be set to TRUE.
Implemented selection to vector I/O transaltion at the file driver
layer.
* Fix formatting unrelated to previous change to stop github from
complaining.
* Add full API support for selection I/O. Add tests for this.
* Implement selection I/O for contiguous datasets. Fix bug in selection
I/O translation. Add const qualifiers to some internal selection I/O
routines to maintain const-correctness while avoiding memcpys.
* Added vector read / write support to the MPIO VFD, with associated
test code (see testpar/t_vfd.c).
Note that this implementation does NOT support vector entries of
size greater than 2 GB. This must be repaired before release,
but it should be good enough for correctness testing.
As MPIO requires vector I/O requests to be sorted in increasing
address order, also added a vector sort utility in H5FDint.c This
function is tested in passing by the MPIO vector I/O extension.
In passing, repaired a bug in size / type vector extension management
in H5FD_read/write_vector()
Tested parallel debug and production on charis and Jelly.
* Ran source code formatter
* Add support for independent parallel I/O with selection I/O. Add
HDF5_USE_SELECTION_IO env var to control selection I/O (default off).
* Implement parallel collective support for selection I/O.
* Fix comments and run formatter.
* Update selection IO branch with develop (#1215)
Merged branch 'develop' into selection_io
* Sync with develop (#1262)
Updated the branch with develop changes.
* Implement big I/O support for vector I/O requests in the MPIO file
driver.
* Free arrays in H5FD__mpio_read/write_vector() as soon as they're not
needed, to cut down on memory usage during I/O.
* Address comments from code review. Fix const warnings with
H5S_SEL_ITER_INIT().
* Committing clang-format changes
* Feature/subfiling (#1464)
* Initial checkin of merged sub-filing VFD.
Passes regression tests (debug/shared/paralle) on Jelly.
However, bugs and many compiler warnings remain -- not suitable
for merge to develop.
* Minor mods to src/H5FDsubfile_mpi.c to address errors reported by autogen.sh
* Code formatting run -- no test
* Merged my subfiling code fixes into the new selection_io_branch
* Forgot to add the FindMERCURY.cmake file. This will probably disappear soon
* attempting to make a more reliable subfile file open which doesn't return errors. For some unknown reason, the regular posix open will occasionally fail to create a subfile. Some better error handling for file close has been added.
* added NULL option for H5FD_subfiling_config_t in H5Pset_fapl_subfiling (#1034)
* NULL option automatically stacks IOC VFD for subfiling and returns a valid fapl.
* added doxygen subfiling APIs
* Various fixes which allow the IOR benchmark to run correctly
* Lots of updates including the packaging up of the mercury_util source files to enable easier builds for our Benchmarking
* Interim checkin of selection_io_with_subfiling_vfd branch
Moddified testpar/t_vfd.c to test the subfiling vfd with default configuration.
Must update this code to run with a variety of configurations -- most particularly
multiple IO concentrators, and stripe depth small enough to test the other IO
concentrators.
testpar/t_vfd.c exposed a large number of race condidtions -- symtoms included:
1) Crashes (usually seg faults)
2) Heap corruption
3) Stack corruption
4) Double frees of heap space
5) Hangs
6) Out of order execution of I/O requests / violations of POSIX semantics
7) Swapped write requests
Items 1 - 4 turned out to be primarily caused by file close issues --
specifically, the main I/O concentrator thread and its pool of worker threads
were not being shut down properly on file close. Addressing this issue in
combination with some other minor fixes seems to have addressed these issues.
Items 5 & 6 appear to have been caused by issue of I/O requests to the
thread pool in an order that did not maintain POSIX semantics. A rewrite of
the I/O request dispatch code appears to have solved these issues.
Item 7 seems to have been caused by multiple write requests from a given
rank being read by the wrong worker thread. Code to issue "unique" tags for
each write request via the ACK message appears to have cleaned this up.
Note that the code is still in poor condtition. A partial list of known
defects includes:
a) Race condiditon on file close that allows superblock writes to arrive
at the I/O concentrator after it has been shutdown. This defect is
most evident when testpar/t_subfiling_vfd is run with 8 ranks.
b) No error reporting from I/O concentrators -- must design and implement
this. For now, mostly just asserts, which suggests that it should be
run in debug mode.
c) Much commented out and/or un-used code.
d) Code orgnaization
e) Build system with bits of Mercury is awkward -- think of shifting
to pthreads with our own thread pool code.
f) Need to add native support for vector and selection I/O to the subfiling
VFD.
g) Need to review, and posibly rework configuration code.
h) Need to store subfile configuration data in a superblock extension message,
and add code to use this data on file open.
i) Test code is inadequate -- expect more issues as it is extended.
In particular, there is no unit test code for the I/O request dispatch code.
While I think it is correct at present, we need test code to verify this.
Similarly, we need to test with multiple I/O concentrators and much smaller
stripe depth.
My actual code changes were limited to:
src/H5FDioc.c
src/H5FDioc_threads.c
src/H5FDsubfile_int.c
src/H5FDsubfile_mpi.c
src/H5FDsubfiling.c
src/H5FDsubfiling.h
src/H5FDsubfiling_priv.h
testpar/t_subfiling_vfd.c
testpar/t_vfd.c
I'm not sure what is going on with the deletions in src/mercury/src/util.
Tested parallel/debug on Charis and Jelly
* subfiling with selection IO (#1219)
Merged branch 'selection_io' into subfiling branch.
* Subfile name fixes (#1250)
* fixed subfiling naming convention, and added leading zero to rank names.
* Merge branch 'selection_io' into selection_io_with_subfiling_vfd (#1265)
* Added script to join subfiles into a single HDF5 file (#1350)
* Modified H5FD__subfiling_query() to report that the sub-filing VFD supports MPI
This exposed issues with truncate and get EOF in the sub-filing VFD.
I believe I have addressed these issues (get EOF not as fully tested as it should be), howeer,
it exposed race conditions resulting in hangs. As of this writing, I have not been able
to chase these down.
Note that the tests that expose these race conditions are in testpar/t_subfiling_vfd.c, and
are currently skipped. Unskip these tests to reproduce the race conditions.
tested (to the extent possible) debug/parallel on charis and jelly.
* Committing clang-format changes
* fixed H5MM_free
Co-authored-by: mainzer <mainzer#hdfgroup.org>
Co-authored-by: jrmainzer <72230804+jrmainzer@users.noreply.github.com>
Co-authored-by: Richard Warren <Richard.Warren@hdfgroup.org>
Co-authored-by: Richard.Warren <richard.warren@jelly.ad.hdfgroup.org>
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
* Move Subfiling VFD components into H5FDsubfiling source directory
* Update Autotools build and add H5_HAVE_SUBFILING_VFD macro to H5pubconf.h
* Tidy up CMake build of subfiling sources
* Merge branch 'develop' into feature/subfiling (#1539)
Merge branch 'develop' into feature/subfiling
* Add VFD interface version field to Subfiling and IOC VFDs
* Merge branch 'develop' into feature/subfiling (#1557)
Merge branch 'develop' into feature/subfiling
* Merge branch 'develop' into feature/subfiling (#1563)
Merge branch 'develop' into feature/subfiling
* Tidy up merge artifacts after rebase on develop
* Fix incorrect variable in mirror VFD utils CMake
* Ensure VFD values are always defined
* Add subfiling to CMake VFD_LIST if built
* Mark MPI I/O driver self-initialization global as static
* Add Subfiling VFD to predefined VFDs for HDF5_DRIVER env. variable
* Initial progress towards separating private vs. public subfiling code
* include libgen.h in t_vfd tests for correct dirname/basename
* Committing clang-format changes
* removed mercury option, included subfiling header path (#1577)
Added subfiling status to configure output, installed h5fuse.sh to build directory for use in future tests.
* added check for stdatomic.h (#1578)
* added check for stdatomic.h with subfiling
* added H5_HAVE_SUBFILING_VFD for cmake
* fix old-style-definition warning (#1582)
* fix old-style-definition warning
* added test for enable parallel with subfiling VFD (#1586)
Fails if subfiling VFD is not used with parallel support.
* Subfiling/IOC VFD fixes and tidying (#1619)
* Rename CMake option for Subfiling VFD to be consistent with other VFDs
* Miscellaneous Subfiling fixes
Add error message for unset MPI communicator
Support dynamic loading of subfiling VFD with default configuration
* Temporary fix for subfile name issue
* Added subfile checks (#1634)
* added subfile checks
* Feature/subfiling (#1655)
* Subfiling/IOC VFD cleanup
Fix misuse of MPI_COMM_WORLD in IOC VFD
Propagate Subfiling FAPL MPI settings down to IOC FAPL in default
configuration case
Cleanup IOC VFD debugging code
Change sprintf to snprintf in a few places
* Major work on separating Subfiling and IOC VFDs from each other
* Re-write async_completion func to not overuse stack
* Replace usage of MPI_COMM_WORLD with file's actual MPI communicator
* Refactor H5FDsubfile_mpi.c
* Remove empty file H5FDsubfile_mpi.c
* Separate IOC VFD errors to its own error stack
* Committing clang-format changes
* Remove H5TRACE macros from H5FDioc.c
* Integrate H5FDioc_threads.c with IOC error stack
* Fix for subfile name generation
Use number of I/O concentrators from existing subfiling configuration file, if one exists
* Add temporary barrier in "Get EOF" operation to prevent races on EOF
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
* Fix for retrieval of machine Host ID
* Default to MPI_COMM_WORLD if no MPI params set
* added libs rt and pthreads (#1673)
* added libs rt and pthreads
* Feature/subfiling (#1689)
* More tidying of IOC VFD and subfiling debug code
* Remove old unused log file code
* Clear FID from active file map on failure
* Fix bug in generation of subfile names when truncating file
* Change subfile names to start from 1 instead of 0
* Use long long for user-specified stripe size from environment variable
* Skip 0-sized I/Os in low-level IOC I/O routines
* Don't update EOF on read
* Convert printed warning about data size mismatch to assertion
* Don't add base file address to I/O addresses twice
Base address should already be applied as part of H5FDwrite/read_vector calls
* Account for 0-sized I/O vector entries in subfile write/read functions
* Rewrite init_indep_io for clarity
* Correction for IOC wraparound calculations
* Some corrections to iovec calculations
* Remove temporary barrier on EOF retrieval
* Complete work request queue entry on error instead of skipping over
* Account for stripe size wraparound for sf_col_offset calculation
* Committing clang-format changes
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
* Re-write and fix bugs in I/O vector filling routines (#1703)
* Rewrite I/O vector filling routines for clarity
* Fix bug with iovec_fill_last when last I/O size is 0
* added subfiling_dir line read (#1714)
* added subfiling_dir line read and use it
* shellcheck fixes
* I/O request dispatch logic update (#1731)
Short-circuit I/O request dispatch when head of I/O queue is an
in-progress get EOF or truncate operation. This prevents an issue where
a write operation can be dispatched alongside a get EOF/truncate
operation, whereas all I/O requests are supposed to be ineligible for
dispatch until the get EOF/truncate is completed
* h5fuse.sh.in clean-up (#1757)
* Added command-line options
* Committing clang-format changes
* Align with changes from develop
* Mimic MPI I/O VFD for EOF handling
* Initialize context_id field for work request objects
* Use logfile for some debugging information
* Use atomic store to set IOC ready flag
* Use separate communicator for sending file EOF data
Minor IOC cleanup
* Use H5_subfile_fid_to_context to get context ID for file in Subfiling
VFD
* IOVEC calculation fixes
* Updates for debugging code
* Minor fixes for threaded code
* Committing clang-format changes
* Use separate MPI communicator for barrier operations
* Committing clang-format changes
* Rewrite EOF routine to use nonblocking MPI communication
* Committing clang-format changes
* Always dispatch I/O work requests in IOC main loop
* Return distinct MPI communicator to library when requested
* Minor warning cleanup
* Committing clang-format changes
* Generate h5fuse.sh from h5fuse.sh.in in CMake
* Send truncate messages to correct IOC rank
* Committing clang-format changes
* Miscellaneous cleanup
Post some MPI receives before sends
Free some duplicated MPI communicator/Info objects
Remove unnecessary extra MPI_Barrier
* Warning cleanup
* Fix for leaked MPI communicator
* Retrieve file EOF on single rank and bcast it
* Fixes for a few failure paths
* Cleanup of IOC file opens
* Committing clang-format changes
* Use plan MPI_Send for send of EOF messages
* Always check MPI thread support level during Subfiling init
* Committing clang-format changes
* Handle a hang on failure when IOCs can't open subfiles
* Committing clang-format changes
* Refactor file open status consensus check
* Committing clang-format changes
* Fix for MPI_Comm_free being called after MPI_Finalize
* Fix VFD test by setting MPI params before setting subfiling on FAPL
* Update Subfiling VFD error handling and error stack usage
* Improvements for Subfiling logfiles
* Remove prototypes for currently unused routines
* Disable I/O queue stat collecting by default
* Remove unused serialization mutex variable
* Update VFD testing to take subfiling VFD into account
* Fix usage of global subfiling application layout object
* Minor fixes for failure pathways
* Keep track of the number of failures in an IOC I/O queue
* Make sure not to exceed MPI_TAG_UB value for data communication messages
* Committing clang-format changes
* Update for rename of some H5FD 'ctl' opcodes
* Always include Subfiling's public header files in hdf5.h
* Remove old unused code and comments
* Implement support for per-file I/O queues
Allows the subfiling VFD to have multiple HDF5 files open simultaneously
* Use simple MPI_Iprobe over unnecessary MPI_Improbe
* Committing clang-format changes
* Update HDF5 testing to query driver for H5FD_FEAT_DEFAULT_VFD_COMPATIBLE
flag
* Fix a few bugs related to file multi-opens
* Avoid calling MPI routines if subfiling gets reinitialized
* Fix issue when files are closed in a random order
* Update HDF5 testing to query VFD for "using MPI" feature flag
* Register atexit handler in subfiling VFD to call MPI_Finalize after HDF5
closes
* Fail for collective I/O requests until support is implemented
* Correct VOL test function prototypes
* Minor cleanup of old code and comments
* Update mercury dependency
* Cleanup of subfiling configuration structure
* Committing clang-format changes
* Build system updates for Subfiling VFD
* Fix possible hang on failure in t_vfd tests caused by mismatched
MPI_Barrier calls
* Copy subfiling IOC fapl in "fapl get" method
* Mirror subfiling superblock writes to stub file for legacy POSIX-y HDF5
applications
* Allow collective I/O for MPI_BYTE types and rank 0 bcast strategy
* Committing clang-format changes
* Use different scheme for subfiling write message MPI tag calculations
* Committing clang-format changes
* Avoid performing fstat calls on all MPI ranks
* Add MPI_Barrier before finalizing IOC threads
* Use try_lock in I/O queue dispatch to minimize contention from worker threads
* Use simple Waitall for nonblocking I/O waits
* Add configurable IOC main thread delay and try_lock option to I/O queue dispatch
* Fix bug that could cause serialization of non-overlapping I/O requests
* Temporarily treat collective subfiling vector I/O calls as independent
* Removed unused mercury bits
* Add stubs for subfiling and IOC file delete callback
* Update VFD testing for Subfiling VFD
* Work around HDF5 metadata cache bug for Subfiling VFD when MPI Comm size
= 1
* Committing clang-format changes
Co-authored-by: mainzer <mainzer#hdfgroup.org>
Co-authored-by: Neil Fortner <nfortne2@hdfgroup.org>
Co-authored-by: Scot Breitenfeld <brtnfld@hdfgroup.org>
Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: jrmainzer <72230804+jrmainzer@users.noreply.github.com>
Co-authored-by: Richard Warren <Richard.Warren@hdfgroup.org>
Co-authored-by: Richard.Warren <richard.warren@jelly.ad.hdfgroup.org>
2022-07-23 04:03:12 +08:00
|
|
|
ret = h5_driver_is_default_vfd_compatible(H5P_DEFAULT, &driver_is_default_compatible);
|
|
|
|
|
CHECK_I(ret, "h5_driver_is_default_vfd_compatible");
|
|
|
|
|
|
|
|
|
|
if (driver_is_default_compatible) {
|
2020-09-30 22:27:10 +08:00
|
|
|
const char *testfile = H5_get_srcdir_filename(TESTFILE); /* Corrected test file name */
|
|
|
|
|
|
|
|
|
|
fid1 = H5Fopen(testfile, H5F_ACC_RDONLY, H5P_DEFAULT);
|
|
|
|
|
CHECK_I(fid1, "H5Fopen");
|
|
|
|
|
if (fid1 >= 0) {
|
|
|
|
|
dset1 = H5Dopen2(fid1, "dset", H5P_DEFAULT);
|
|
|
|
|
VERIFY(dset1, FAIL, "H5Dopen2");
|
|
|
|
|
ret = H5Fclose(fid1);
|
|
|
|
|
CHECK_I(ret, "H5Fclose");
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
HDprintf("***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;
|
2020-09-30 22:27:10 +08:00
|
|
|
sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
|
2007-01-18 04:48:58 +08:00
|
|
|
VERIFY(sid1, FAIL, "H5Screate_simple");
|
|
|
|
|
|
|
|
|
|
dims1[0] = H5S_UNLIMITED;
|
2020-09-30 22:27:10 +08:00
|
|
|
sid1 = H5Screate(H5S_SIMPLE);
|
2000-04-13 06:02:26 +08:00
|
|
|
CHECK(sid1, FAIL, "H5Screate");
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
ret = H5Sset_extent_simple(sid1, SPACE1_RANK, dims1, NULL);
|
2000-04-13 06:02:26 +08:00
|
|
|
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");
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
dims1[0] = SPACE1_DIM1;
|
2004-07-28 00:55:19 +08:00
|
|
|
|
|
|
|
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
dset1 = H5Dcreate2(fid1, BASICDATASET, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
|
|
|
|
}
|
|
|
|
|
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) */
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, sid1, H5S_ALL, H5P_DEFAULT, &n);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY
|
2004-07-28 00:55:19 +08:00
|
|
|
VERIFY(ret, FAIL, "H5Dwrite");
|
|
|
|
|
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, &n);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY
|
2004-07-28 00:55:19 +08:00
|
|
|
VERIFY(ret, FAIL, "H5Dwrite");
|
|
|
|
|
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, sid1, sid1, H5P_DEFAULT, &n);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY
|
2004-07-28 00:55:19 +08:00
|
|
|
VERIFY(ret, FAIL, "H5Dwrite");
|
|
|
|
|
|
|
|
|
|
/* Try to iterate using the bad dataspace */
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret = H5Diterate(&n, H5T_NATIVE_INT, sid1, NULL, NULL);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY
|
2004-07-28 00:55:19 +08:00
|
|
|
VERIFY(ret, FAIL, "H5Diterate");
|
|
|
|
|
|
|
|
|
|
/* Try to fill using the bad dataspace */
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret = H5Dfill(NULL, H5T_NATIVE_INT, &n, H5T_NATIVE_INT, sid1);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
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 */
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
aid1 = H5Acreate2(dset1, BASICATTR, H5T_NATIVE_INT, sid1, H5P_DEFAULT, H5P_DEFAULT);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +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 */
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, sid1, H5S_ALL, H5P_DEFAULT, &n);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY
|
2004-07-28 00:55:19 +08:00
|
|
|
VERIFY(ret, FAIL, "H5Dread");
|
|
|
|
|
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, &n);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY
|
2004-07-28 00:55:19 +08:00
|
|
|
VERIFY(ret, FAIL, "H5Dread");
|
|
|
|
|
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret = H5Dread(dset1, H5T_NATIVE_INT, sid1, sid1, H5P_DEFAULT, &n);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY
|
2004-07-28 00:55:19 +08:00
|
|
|
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");
|
2020-09-30 22:27:10 +08:00
|
|
|
} /* test_h5s_basic() */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
2004-04-09 05:23:19 +08:00
|
|
|
/****************************************************************
|
|
|
|
|
**
|
2019-07-31 04:34:53 +08:00
|
|
|
** test_h5s_null(): Test NULL dataspace
|
2004-04-09 05:23:19 +08:00
|
|
|
**
|
|
|
|
|
****************************************************************/
|
|
|
|
|
static void
|
|
|
|
|
test_h5s_null(void)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t fid; /* File ID */
|
|
|
|
|
hid_t sid; /* Dataspace IDs */
|
|
|
|
|
hid_t dset_sid, dset_sid2; /* Dataspace IDs */
|
|
|
|
|
hid_t attr_sid; /* Dataspace IDs */
|
|
|
|
|
hid_t did; /* Dataset ID */
|
|
|
|
|
hid_t attr; /*Attribute ID */
|
|
|
|
|
H5S_class_t stype; /* dataspace type */
|
|
|
|
|
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 */
|
|
|
|
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
hsize_t start[1] = {0};
|
|
|
|
|
hsize_t count[1] = {0};
|
2004-04-18 04:32:01 +08:00
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL, count, NULL);
|
|
|
|
|
}
|
|
|
|
|
H5E_END_TRY;
|
2004-04-18 04:32:01 +08:00
|
|
|
VERIFY(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Check to be sure we can't set a point selection on a null dataspace */
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
hsize_t coord[1][1]; /* Coordinates for point selection */
|
2004-04-18 04:32:01 +08:00
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
coord[0][0] = 0;
|
|
|
|
|
ret = H5Sselect_elements(sid, H5S_SELECT_SET, (size_t)1, (const hsize_t *)coord);
|
|
|
|
|
}
|
|
|
|
|
H5E_END_TRY;
|
2004-04-18 04:32:01 +08:00
|
|
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
ret = H5Aclose(attr);
|
2004-04-09 05:23:19 +08:00
|
|
|
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
|
|
|
/*============================================
|
2019-07-31 04:34:53 +08:00
|
|
|
* Reopen the file to check the dataspace
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
ret = H5Aclose(attr);
|
2004-04-09 05:23:19 +08:00
|
|
|
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)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t fid1; /* HDF5 File IDs */
|
|
|
|
|
hid_t sid1, attr_sid; /* Dataspace ID */
|
|
|
|
|
hid_t sid_chunk; /* Dataspace ID for chunked dataset */
|
|
|
|
|
hid_t dset1; /* Dataset ID */
|
|
|
|
|
hid_t plist_id; /* Dataset creation property list */
|
|
|
|
|
hid_t attr; /* Attribute ID */
|
|
|
|
|
int rank; /* Logical rank of dataspace */
|
|
|
|
|
hsize_t dims1[] = {0, SPACE1_DIM2, SPACE1_DIM3};
|
|
|
|
|
hsize_t max_dims[] = {SPACE1_DIM1 + 1, SPACE1_DIM2, SPACE1_DIM3};
|
|
|
|
|
hsize_t extend_dims[] = {SPACE1_DIM1, SPACE1_DIM2, SPACE1_DIM3};
|
|
|
|
|
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 */
|
|
|
|
|
H5D_alloc_time_t alloc_time; /* Space allocation time */
|
|
|
|
|
herr_t ret; /* Generic return value */
|
|
|
|
|
unsigned int i, j, k;
|
2011-04-08 05:56:38 +08:00
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
|
|
|
|
MESSAGE(5, ("Testing Dataspace with zero dimension size\n"));
|
|
|
|
|
|
|
|
|
|
/* Initialize the data */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < SPACE1_DIM2; i++)
|
|
|
|
|
for (j = 0; j < SPACE1_DIM3; j++) {
|
|
|
|
|
wdata[i][j] = (int)(i + j);
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < SPACE1_DIM1; i++)
|
|
|
|
|
for (j = 0; j < SPACE1_DIM2; j++)
|
|
|
|
|
for (k = 0; k < SPACE1_DIM3; k++)
|
2016-07-23 06:43:18 +08:00
|
|
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (alloc_time = H5D_ALLOC_TIME_EARLY; alloc_time <= H5D_ALLOC_TIME_INCR; 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;
|
2020-09-30 22:27:10 +08:00
|
|
|
sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
|
2012-03-13 05:45:38 +08:00
|
|
|
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. */
|
2020-09-30 22:27:10 +08:00
|
|
|
ret = H5Sset_extent_simple(sid1, SPACE1_RANK, dims1, NULL);
|
2012-03-13 05:45:38 +08:00
|
|
|
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");
|
|
|
|
|
|
|
|
|
|
/*============================================
|
2018-03-08 05:49:14 +08:00
|
|
|
* Make sure we can use 0-dimension to create
|
|
|
|
|
* contiguous, chunked, compact, and external
|
2012-03-13 05:45:38 +08:00
|
|
|
* 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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < SPACE1_DIM2; i++) {
|
|
|
|
|
for (j = 0; j < SPACE1_DIM3; j++) {
|
|
|
|
|
if (rdata[i][j] != 7) {
|
2012-03-13 05:45:38 +08:00
|
|
|
H5_FAILED();
|
2020-09-30 22:27:10 +08:00
|
|
|
HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata[i][j]);
|
2012-03-13 05:45:38 +08:00
|
|
|
}
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < SPACE1_DIM2; i++) {
|
|
|
|
|
for (j = 0; j < SPACE1_DIM3; j++) {
|
|
|
|
|
if (rdata_short[i][j] != 7) {
|
2012-03-13 05:45:38 +08:00
|
|
|
H5_FAILED();
|
2020-09-30 22:27:10 +08:00
|
|
|
HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata_short[i][j]);
|
2012-03-13 05:45:38 +08:00
|
|
|
}
|
2011-04-08 05:56:38 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-03-08 05:49:14 +08:00
|
|
|
/* Select a hyperslab beyond its current dimension sizes, then try to write
|
2012-03-13 05:45:38 +08:00
|
|
|
* 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
|
|
|
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, wdata);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY;
|
2012-03-13 05:45:38 +08:00
|
|
|
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
|
|
|
|
2018-03-08 05:49:14 +08:00
|
|
|
/* Select a point beyond the dimension size, then try to write the data.
|
2012-03-13 05:45:38 +08:00
|
|
|
* It should fail. */
|
2020-09-30 22:27:10 +08:00
|
|
|
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);
|
2012-03-13 05:45:38 +08:00
|
|
|
CHECK(ret, FAIL, "H5Sselect_elements");
|
2011-04-08 05:56:38 +08:00
|
|
|
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret = H5Dwrite(dset1, H5T_NATIVE_INT, H5S_ALL, sid1, H5P_DEFAULT, &val);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY;
|
2012-03-13 05:45:38 +08:00
|
|
|
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
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
dset1 =
|
|
|
|
|
H5Dcreate2(fid1, BASICDATASET1, H5T_NATIVE_INT, sid_chunk, H5P_DEFAULT, plist_id, H5P_DEFAULT);
|
2012-03-13 05:45:38 +08:00
|
|
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
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();
|
2020-09-30 22:27:10 +08:00
|
|
|
HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata[i][j]);
|
2011-04-11 23:59:41 +08:00
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
}
|
2011-04-11 23:59:41 +08:00
|
|
|
|
2018-03-08 05:49:14 +08:00
|
|
|
/* Now extend the dataset to SPACE1_DIM1*SPACE1_DIM2*SPACE1_DIM3 and make sure
|
|
|
|
|
* we can write data to it */
|
2012-03-13 05:45:38 +08:00
|
|
|
extend_dims[0] = SPACE1_DIM1;
|
2020-09-30 22:27:10 +08:00
|
|
|
ret = H5Dset_extent(dset1, extend_dims);
|
2012-03-13 05:45:38 +08:00
|
|
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
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]) {
|
2012-03-13 05:45:38 +08:00
|
|
|
H5_FAILED();
|
2020-09-30 22:27:10 +08:00
|
|
|
HDprintf("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]);
|
2012-03-13 05:45:38 +08:00
|
|
|
}
|
|
|
|
|
}
|
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;
|
2020-09-30 22:27:10 +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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < SPACE1_DIM2; i++)
|
|
|
|
|
for (j = 0; j < SPACE1_DIM3; j++) {
|
|
|
|
|
if (rdata[i][j] != 7) {
|
2012-03-13 05:45:38 +08:00
|
|
|
H5_FAILED();
|
2020-09-30 22:27:10 +08:00
|
|
|
HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata[i][j]);
|
2012-03-13 05:45:38 +08:00
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
}
|
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. */
|
2020-09-30 22:27:10 +08:00
|
|
|
extend_dims[0] = SPACE1_DIM1 * 3;
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret = H5Dset_extent(dset1, extend_dims);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY;
|
2012-03-13 05:45:38 +08:00
|
|
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < SPACE1_DIM2; i++)
|
|
|
|
|
for (j = 0; j < SPACE1_DIM3; j++) {
|
|
|
|
|
if (rdata[i][j] != 7) {
|
2012-03-13 05:45:38 +08:00
|
|
|
H5_FAILED();
|
2020-09-30 22:27:10 +08:00
|
|
|
HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata[i][j]);
|
2012-03-13 05:45:38 +08:00
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
}
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < SPACE1_DIM2; i++) {
|
|
|
|
|
for (j = 0; j < SPACE1_DIM3; j++) {
|
|
|
|
|
if (rdata[i][j] != 7) {
|
2012-03-13 05:45:38 +08:00
|
|
|
H5_FAILED();
|
2020-09-30 22:27:10 +08:00
|
|
|
HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata[i][j]);
|
2012-03-13 05:45:38 +08:00
|
|
|
}
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
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();
|
2020-09-30 22:27:10 +08:00
|
|
|
HDprintf("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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < SPACE1_DIM2; i++) {
|
|
|
|
|
for (j = 0; j < SPACE1_DIM3; j++) {
|
|
|
|
|
if (rdata_short[i][j] != 7) {
|
2012-03-13 05:45:38 +08:00
|
|
|
H5_FAILED();
|
2020-09-30 22:27:10 +08:00
|
|
|
HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata_short[i][j]);
|
2012-03-13 05:45:38 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
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");
|
|
|
|
|
|
|
|
|
|
/*===============================================================
|
2018-03-08 05:49:14 +08:00
|
|
|
* Extend the dimension to make it a normal dataspace (3x15x13).
|
|
|
|
|
* Verify that data can be written to and read from the chunked
|
|
|
|
|
* dataset now.
|
|
|
|
|
*===============================================================
|
2012-03-13 05:45:38 +08:00
|
|
|
*/
|
2020-09-30 22:27:10 +08:00
|
|
|
dims1[0] = SPACE1_DIM1;
|
|
|
|
|
ret = H5Sset_extent_simple(sid_chunk, SPACE1_RANK, dims1, max_dims);
|
2012-03-13 05:45:38 +08:00
|
|
|
CHECK(ret, FAIL, "H5Sset_extent_simple");
|
|
|
|
|
|
|
|
|
|
nelem = H5Sget_simple_extent_npoints(sid_chunk);
|
|
|
|
|
CHECK(nelem, FAIL, "H5Sget_simple_extent_npoints");
|
2020-09-30 22:27:10 +08:00
|
|
|
VERIFY(nelem, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3, "H5Sget_simple_extent_npoints");
|
2012-03-13 05:45:38 +08:00
|
|
|
|
|
|
|
|
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");
|
2020-09-30 22:27:10 +08:00
|
|
|
VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0, "H5Sget_simple_extent_dims");
|
2012-03-13 05:45:38 +08:00
|
|
|
|
|
|
|
|
/* 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");
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
dset1 =
|
|
|
|
|
H5Dcreate2(fid1, BASICDATASET4, H5T_NATIVE_INT, sid_chunk, H5P_DEFAULT, plist_id, H5P_DEFAULT);
|
2012-03-13 05:45:38 +08:00
|
|
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
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]) {
|
2012-03-13 05:45:38 +08:00
|
|
|
H5_FAILED();
|
2020-09-30 22:27:10 +08:00
|
|
|
HDprintf("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]);
|
2012-03-13 05:45:38 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
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. */
|
2020-09-30 22:27:10 +08:00
|
|
|
dims1[0] = dims1[1] = dims1[2] = 0;
|
|
|
|
|
ret = H5Sset_extent_simple(sid_chunk, SPACE1_RANK, dims1, NULL);
|
2012-03-13 05:45:38 +08:00
|
|
|
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");
|
|
|
|
|
|
|
|
|
|
/*============================================
|
2019-07-31 04:34:53 +08:00
|
|
|
* Reopen the file to check the dataspace
|
2012-03-13 05:45:38 +08:00
|
|
|
*============================================
|
|
|
|
|
*/
|
|
|
|
|
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");
|
|
|
|
|
|
2022-08-18 07:31:54 +08:00
|
|
|
/* Get the space of the dataset and query it */
|
2012-03-13 05:45:38 +08:00
|
|
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < SPACE1_DIM2; i++) {
|
|
|
|
|
for (j = 0; j < SPACE1_DIM3; j++) {
|
|
|
|
|
if (rdata[i][j] != 7) {
|
2012-03-13 05:45:38 +08:00
|
|
|
H5_FAILED();
|
2020-09-30 22:27:10 +08:00
|
|
|
HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata[i][j]);
|
2012-03-13 05:45:38 +08:00
|
|
|
}
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < SPACE1_DIM2; i++) {
|
|
|
|
|
for (j = 0; j < SPACE1_DIM3; j++) {
|
|
|
|
|
if (rdata_short[i][j] != 7) {
|
2012-03-13 05:45:38 +08:00
|
|
|
H5_FAILED();
|
2020-09-30 22:27:10 +08:00
|
|
|
HDprintf("element [%d][%d] is %d but should have been 7\n", i, j, rdata_short[i][j]);
|
2012-03-13 05:45:38 +08:00
|
|
|
}
|
2011-04-08 05:56:38 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-03-13 05:45:38 +08:00
|
|
|
/* Close attribute */
|
2020-09-30 22:27:10 +08:00
|
|
|
ret = H5Aclose(attr);
|
2012-03-13 05:45:38 +08:00
|
|
|
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
|
|
|
**
|
2019-04-07 05:55:14 +08:00
|
|
|
** Note: See "RFC: H5Sencode/H5Sdecode Format Change".
|
|
|
|
|
**
|
2004-07-22 05:30:26 +08:00
|
|
|
****************************************************************/
|
2005-08-14 04:53:35 +08:00
|
|
|
static void
|
2019-04-07 05:55:14 +08:00
|
|
|
test_h5s_encode(H5F_libver_t low, H5F_libver_t high)
|
2004-07-22 05:30:26 +08:00
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t sid1, sid2, sid3; /* Dataspace ID */
|
|
|
|
|
hid_t decoded_sid1, decoded_sid2, decoded_sid3;
|
|
|
|
|
int rank; /* Logical rank of dataspace */
|
|
|
|
|
hid_t fapl = -1; /* File access property list ID */
|
|
|
|
|
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 */
|
|
|
|
|
hsize_t start[] = {0, 0, 0};
|
|
|
|
|
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;
|
|
|
|
|
hid_t ret_id; /* Generic hid_t return value */
|
|
|
|
|
herr_t ret; /* Generic return value */
|
2004-07-22 05:30:26 +08:00
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
|
|
|
|
MESSAGE(5, ("Testing Dataspace Encoding and Decoding\n"));
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Test encoding and decoding of simple dataspace and hyperslab selection.
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
2020-04-21 07:12:00 +08:00
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Create the file access property list */
|
|
|
|
|
fapl = H5Pcreate(H5P_FILE_ACCESS);
|
|
|
|
|
CHECK(fapl, FAIL, "H5Pcreate");
|
|
|
|
|
|
|
|
|
|
/* Set low/high bounds in the fapl */
|
|
|
|
|
ret = H5Pset_libver_bounds(fapl, low, high);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pset_libver_bounds");
|
|
|
|
|
|
|
|
|
|
/* Create the dataspace */
|
2004-07-22 05:30:26 +08:00
|
|
|
sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
|
|
|
|
|
CHECK(sid1, FAIL, "H5Screate_simple");
|
|
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Set the hyperslab selection */
|
2004-07-22 05:30:26 +08:00
|
|
|
ret = H5Sselect_hyperslab(sid1, H5S_SELECT_SET, start, stride, count, block);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Encode simple dataspace in a buffer with the fapl setting */
|
2019-04-07 05:55:14 +08:00
|
|
|
ret = H5Sencode2(sid1, NULL, &sbuf_size, fapl);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode2");
|
2004-07-22 05:30:26 +08:00
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if (sbuf_size > 0) {
|
|
|
|
|
sbuf = (unsigned char *)HDcalloc((size_t)1, sbuf_size);
|
2021-03-25 00:25:50 +08:00
|
|
|
CHECK_PTR(sbuf, "HDcalloc");
|
2019-04-07 05:55:14 +08:00
|
|
|
}
|
2004-07-22 05:30:26 +08:00
|
|
|
|
2004-07-28 11:51:43 +08:00
|
|
|
/* Try decoding bogus buffer */
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret_id = H5Sdecode(sbuf);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +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
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Encode the simple dataspace in a buffer with the fapl setting */
|
2019-04-07 05:55:14 +08:00
|
|
|
ret = H5Sencode2(sid1, sbuf, &sbuf_size, fapl);
|
2004-07-22 05:30:26 +08:00
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
|
|
|
|
/* Decode from the dataspace buffer and return an object handle */
|
2020-09-30 22:27:10 +08:00
|
|
|
decoded_sid1 = H5Sdecode(sbuf);
|
2004-07-22 05:30:26 +08:00
|
|
|
CHECK(decoded_sid1, FAIL, "H5Sdecode");
|
|
|
|
|
|
|
|
|
|
/* Verify the decoded dataspace */
|
|
|
|
|
n = H5Sget_simple_extent_npoints(decoded_sid1);
|
|
|
|
|
CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
|
2020-09-30 22:27:10 +08:00
|
|
|
VERIFY(n, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3, "H5Sget_simple_extent_npoints");
|
2004-07-22 05:30:26 +08:00
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Retrieve and verify the dataspace rank */
|
2004-07-22 05:30:26 +08:00
|
|
|
rank = H5Sget_simple_extent_ndims(decoded_sid1);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
|
|
|
|
|
VERIFY(rank, SPACE1_RANK, "H5Sget_simple_extent_ndims");
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
/* Retrieve and verify the dataspace dimensions */
|
2004-07-22 05:30:26 +08:00
|
|
|
rank = H5Sget_simple_extent_dims(decoded_sid1, tdims, NULL);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
|
2020-09-30 22:27:10 +08:00
|
|
|
VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0, "H5Sget_simple_extent_dims");
|
2004-07-22 05:30:26 +08:00
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Verify the type of dataspace selection */
|
2004-07-22 05:30:26 +08:00
|
|
|
sel_type = H5Sget_select_type(decoded_sid1);
|
|
|
|
|
VERIFY(sel_type, H5S_SEL_HYPERSLABS, "H5Sget_select_type");
|
|
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Verify the number of hyperslab blocks */
|
2004-07-22 05:30:26 +08:00
|
|
|
nblocks = H5Sget_select_hyper_nblocks(decoded_sid1);
|
2020-09-30 22:27:10 +08:00
|
|
|
VERIFY(nblocks, 2 * 2 * 2, "H5Sget_select_hyper_nblocks");
|
2004-07-22 05:30:26 +08:00
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Close the dataspaces */
|
2004-07-22 05:30:26 +08:00
|
|
|
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
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Encode null dataspace in a buffer */
|
2019-04-07 05:55:14 +08:00
|
|
|
ret = H5Sencode2(sid2, NULL, &null_size, fapl);
|
2004-07-22 05:30:26 +08:00
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if (null_size > 0) {
|
|
|
|
|
null_sbuf = (unsigned char *)HDcalloc((size_t)1, null_size);
|
2021-03-25 00:25:50 +08:00
|
|
|
CHECK_PTR(null_sbuf, "HDcalloc");
|
2019-04-07 05:55:14 +08:00
|
|
|
}
|
2004-07-22 05:30:26 +08:00
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Encode the null dataspace in the buffer */
|
2019-04-07 05:55:14 +08:00
|
|
|
ret = H5Sencode2(sid2, null_sbuf, &null_size, fapl);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode2");
|
2004-07-22 05:30:26 +08:00
|
|
|
|
|
|
|
|
/* Decode from the dataspace buffer and return an object handle */
|
2020-09-30 22:27:10 +08:00
|
|
|
decoded_sid2 = H5Sdecode(null_sbuf);
|
2004-07-22 05:30:26 +08:00
|
|
|
CHECK(decoded_sid2, FAIL, "H5Sdecode");
|
|
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Verify the decoded dataspace type */
|
2004-07-22 05:30:26 +08:00
|
|
|
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
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Close the dataspaces */
|
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");
|
|
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Encode scalar dataspace in a buffer */
|
2019-04-07 05:55:14 +08:00
|
|
|
ret = H5Sencode2(sid3, NULL, &scalar_size, fapl);
|
2004-07-22 05:30:26 +08:00
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if (scalar_size > 0) {
|
|
|
|
|
scalar_buf = (unsigned char *)HDcalloc((size_t)1, scalar_size);
|
2021-03-25 00:25:50 +08:00
|
|
|
CHECK_PTR(scalar_buf, "HDcalloc");
|
2019-04-07 05:55:14 +08:00
|
|
|
}
|
2004-07-22 05:30:26 +08:00
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Encode the scalar dataspace in the buffer */
|
2019-04-07 05:55:14 +08:00
|
|
|
ret = H5Sencode2(sid3, scalar_buf, &scalar_size, fapl);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode2");
|
2004-07-22 05:30:26 +08:00
|
|
|
|
|
|
|
|
/* Decode from the dataspace buffer and return an object handle */
|
2020-09-30 22:27:10 +08:00
|
|
|
decoded_sid3 = H5Sdecode(scalar_buf);
|
2004-07-22 05:30:26 +08:00
|
|
|
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");
|
|
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Retrieve and verify the dataspace rank */
|
2004-07-22 05:30:26 +08:00
|
|
|
rank = H5Sget_simple_extent_ndims(decoded_sid3);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
|
|
|
|
|
VERIFY(rank, 0, "H5Sget_simple_extent_ndims");
|
|
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Close the dataspaces */
|
2004-07-22 05:30:26 +08:00
|
|
|
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");
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
/* Close the file access property list */
|
2019-04-07 05:55:14 +08:00
|
|
|
ret = H5Pclose(fapl);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pclose");
|
|
|
|
|
|
|
|
|
|
/* Release resources */
|
2020-09-30 22:27:10 +08:00
|
|
|
if (sbuf)
|
2019-04-07 05:55:14 +08:00
|
|
|
HDfree(sbuf);
|
2020-09-30 22:27:10 +08:00
|
|
|
if (null_sbuf)
|
2019-04-07 05:55:14 +08:00
|
|
|
HDfree(null_sbuf);
|
2020-09-30 22:27:10 +08:00
|
|
|
if (scalar_buf)
|
2019-04-07 05:55:14 +08:00
|
|
|
HDfree(scalar_buf);
|
|
|
|
|
} /* test_h5s_encode() */
|
|
|
|
|
|
2019-04-09 01:33:45 +08:00
|
|
|
#ifndef H5_NO_DEPRECATED_SYMBOLS
|
|
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_encode(): Test H5S (dataspace) encoding and decoding.
|
|
|
|
|
**
|
|
|
|
|
****************************************************************/
|
|
|
|
|
static void
|
|
|
|
|
test_h5s_encode1(void)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
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 */
|
|
|
|
|
hsize_t start[] = {0, 0, 0};
|
|
|
|
|
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;
|
|
|
|
|
hid_t ret_id; /* Generic hid_t return value */
|
|
|
|
|
herr_t ret; /* Generic return value */
|
2019-04-09 01:33:45 +08:00
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
|
|
|
|
MESSAGE(5, ("Testing Dataspace Encoding (H5Sencode1) and Decoding\n"));
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Test encoding and decoding of simple dataspace and hyperslab selection.
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
/* Create the dataspace */
|
|
|
|
|
sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);
|
|
|
|
|
CHECK(sid1, FAIL, "H5Screate_simple");
|
|
|
|
|
|
|
|
|
|
/* Set the hyperslab selection */
|
|
|
|
|
ret = H5Sselect_hyperslab(sid1, H5S_SELECT_SET, start, stride, count, block);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Encode simple dataspace in a buffer with the fapl setting */
|
2019-04-09 01:33:45 +08:00
|
|
|
ret = H5Sencode1(sid1, NULL, &sbuf_size);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode2");
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if (sbuf_size > 0) {
|
|
|
|
|
sbuf = (unsigned char *)HDcalloc((size_t)1, sbuf_size);
|
2021-03-25 00:25:50 +08:00
|
|
|
CHECK_PTR(sbuf, "HDcalloc");
|
2019-04-09 01:33:45 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Try decoding bogus buffer */
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret_id = H5Sdecode(sbuf);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY;
|
2019-04-09 01:33:45 +08:00
|
|
|
VERIFY(ret_id, FAIL, "H5Sdecode");
|
|
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Encode the simple dataspace in a buffer */
|
2019-04-09 01:33:45 +08:00
|
|
|
ret = H5Sencode1(sid1, sbuf, &sbuf_size);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
|
|
|
|
/* Decode from the dataspace buffer and return an object handle */
|
2020-09-30 22:27:10 +08:00
|
|
|
decoded_sid1 = H5Sdecode(sbuf);
|
2019-04-09 01:33:45 +08:00
|
|
|
CHECK(decoded_sid1, FAIL, "H5Sdecode");
|
|
|
|
|
|
|
|
|
|
/* Verify the decoded dataspace */
|
|
|
|
|
n = H5Sget_simple_extent_npoints(decoded_sid1);
|
|
|
|
|
CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
|
2020-09-30 22:27:10 +08:00
|
|
|
VERIFY(n, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3, "H5Sget_simple_extent_npoints");
|
2019-04-09 01:33:45 +08:00
|
|
|
|
|
|
|
|
/* Retrieve and verify the dataspace rank */
|
|
|
|
|
rank = H5Sget_simple_extent_ndims(decoded_sid1);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
|
|
|
|
|
VERIFY(rank, SPACE1_RANK, "H5Sget_simple_extent_ndims");
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
/* Retrieve and verify the dataspace dimensions */
|
2019-04-09 01:33:45 +08:00
|
|
|
rank = H5Sget_simple_extent_dims(decoded_sid1, tdims, NULL);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
|
2020-09-30 22:27:10 +08:00
|
|
|
VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0, "H5Sget_simple_extent_dims");
|
2019-04-09 01:33:45 +08:00
|
|
|
|
|
|
|
|
/* Verify the type of dataspace selection */
|
|
|
|
|
sel_type = H5Sget_select_type(decoded_sid1);
|
|
|
|
|
VERIFY(sel_type, H5S_SEL_HYPERSLABS, "H5Sget_select_type");
|
|
|
|
|
|
|
|
|
|
/* Verify the number of hyperslab blocks */
|
|
|
|
|
nblocks = H5Sget_select_hyper_nblocks(decoded_sid1);
|
2020-09-30 22:27:10 +08:00
|
|
|
VERIFY(nblocks, 2 * 2 * 2, "H5Sget_select_hyper_nblocks");
|
2019-04-09 01:33:45 +08:00
|
|
|
|
|
|
|
|
/* Close the dataspaces */
|
|
|
|
|
ret = H5Sclose(sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(decoded_sid1);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Test encoding and decoding of null dataspace.
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
sid2 = H5Screate(H5S_NULL);
|
|
|
|
|
CHECK(sid2, FAIL, "H5Screate");
|
|
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Encode null dataspace in a buffer */
|
2019-04-09 01:33:45 +08:00
|
|
|
ret = H5Sencode1(sid2, NULL, &null_size);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if (null_size > 0) {
|
|
|
|
|
null_sbuf = (unsigned char *)HDcalloc((size_t)1, null_size);
|
2021-03-25 00:25:50 +08:00
|
|
|
CHECK_PTR(null_sbuf, "HDcalloc");
|
2019-04-09 01:33:45 +08:00
|
|
|
}
|
|
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Encode the null dataspace in the buffer */
|
2019-04-09 01:33:45 +08:00
|
|
|
ret = H5Sencode1(sid2, null_sbuf, &null_size);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode2");
|
|
|
|
|
|
|
|
|
|
/* Decode from the dataspace buffer and return an object handle */
|
2020-09-30 22:27:10 +08:00
|
|
|
decoded_sid2 = H5Sdecode(null_sbuf);
|
2019-04-09 01:33:45 +08:00
|
|
|
CHECK(decoded_sid2, FAIL, "H5Sdecode");
|
|
|
|
|
|
|
|
|
|
/* Verify the decoded dataspace type */
|
|
|
|
|
space_type = H5Sget_simple_extent_type(decoded_sid2);
|
|
|
|
|
VERIFY(space_type, H5S_NULL, "H5Sget_simple_extent_type");
|
|
|
|
|
|
|
|
|
|
/* Close the dataspaces */
|
|
|
|
|
ret = H5Sclose(sid2);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(decoded_sid2);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Test encoding and decoding of scalar dataspace.
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
/* Create scalar dataspace */
|
|
|
|
|
sid3 = H5Screate(H5S_SCALAR);
|
2019-07-31 04:34:53 +08:00
|
|
|
CHECK(sid3, FAIL, "H5Screate");
|
2019-04-09 01:33:45 +08:00
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Encode scalar dataspace in a buffer */
|
2019-04-09 01:33:45 +08:00
|
|
|
ret = H5Sencode1(sid3, NULL, &scalar_size);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if (scalar_size > 0) {
|
|
|
|
|
scalar_buf = (unsigned char *)HDcalloc((size_t)1, scalar_size);
|
2021-03-25 00:25:50 +08:00
|
|
|
CHECK_PTR(scalar_buf, "HDcalloc");
|
2019-04-09 01:33:45 +08:00
|
|
|
}
|
|
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Encode the scalar dataspace in the buffer */
|
2019-04-09 01:33:45 +08:00
|
|
|
ret = H5Sencode1(sid3, scalar_buf, &scalar_size);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode2");
|
|
|
|
|
|
|
|
|
|
/* Decode from the dataspace buffer and return an object handle */
|
2020-09-30 22:27:10 +08:00
|
|
|
decoded_sid3 = H5Sdecode(scalar_buf);
|
2019-04-09 01:33:45 +08:00
|
|
|
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");
|
|
|
|
|
|
|
|
|
|
/* Retrieve and verify the dataspace rank */
|
|
|
|
|
rank = H5Sget_simple_extent_ndims(decoded_sid3);
|
|
|
|
|
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
|
|
|
|
|
VERIFY(rank, 0, "H5Sget_simple_extent_ndims");
|
|
|
|
|
|
|
|
|
|
/* Close the dataspaces */
|
|
|
|
|
ret = H5Sclose(sid3);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(decoded_sid3);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
/* Release resources */
|
2020-09-30 22:27:10 +08:00
|
|
|
if (sbuf)
|
2019-04-09 01:33:45 +08:00
|
|
|
HDfree(sbuf);
|
2020-09-30 22:27:10 +08:00
|
|
|
if (null_sbuf)
|
2019-04-09 01:33:45 +08:00
|
|
|
HDfree(null_sbuf);
|
2020-09-30 22:27:10 +08:00
|
|
|
if (scalar_buf)
|
2019-04-09 01:33:45 +08:00
|
|
|
HDfree(scalar_buf);
|
|
|
|
|
} /* test_h5s_encode1() */
|
|
|
|
|
|
|
|
|
|
#endif /* H5_NO_DEPRECATED_SYMBOLS */
|
|
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/****************************************************************
|
|
|
|
|
**
|
2020-04-21 07:12:00 +08:00
|
|
|
** test_h5s_check_encoding():
|
2019-04-07 05:55:14 +08:00
|
|
|
** This is the helper routine to verify that H5Sencode2()
|
|
|
|
|
** works as specified in the RFC for the library format setting
|
|
|
|
|
** in the file access property list.
|
|
|
|
|
** See "RFC: H5Sencode/H5Sdeocde Format Change".
|
|
|
|
|
**
|
|
|
|
|
** This routine is used by:
|
|
|
|
|
** test_h5s_encode_regular_hyper()
|
|
|
|
|
** test_h5s_encode_irregular_hyper()
|
|
|
|
|
** test_h5s_encode_points()
|
|
|
|
|
**
|
|
|
|
|
****************************************************************/
|
|
|
|
|
static herr_t
|
2020-09-30 22:27:10 +08:00
|
|
|
test_h5s_check_encoding(hid_t in_fapl, hid_t in_sid, uint32_t expected_version, uint8_t expected_enc_size,
|
|
|
|
|
hbool_t expected_to_fail)
|
2019-04-07 05:55:14 +08:00
|
|
|
{
|
2022-07-27 05:45:46 +08:00
|
|
|
char *buf = NULL; /* Pointer to the encoded buffer */
|
2020-09-30 22:27:10 +08:00
|
|
|
size_t buf_size; /* Size of the encoded buffer */
|
|
|
|
|
hid_t d_sid = -1; /* The decoded dataspace ID */
|
|
|
|
|
htri_t check;
|
|
|
|
|
hsize_t in_low_bounds[1]; /* The low bounds for the selection for in_sid */
|
|
|
|
|
hsize_t in_high_bounds[1]; /* The high bounds for the selection for in_sid */
|
|
|
|
|
hsize_t d_low_bounds[1]; /* The low bounds for the selection for d_sid */
|
|
|
|
|
hsize_t d_high_bounds[1]; /* The high bounds for the selection for d_sid */
|
|
|
|
|
herr_t ret; /* Return value */
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
/* Get buffer size for encoding with the format setting in in_fapl */
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
ret = H5Sencode2(in_sid, NULL, &buf_size, in_fapl);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY
|
2019-04-07 05:55:14 +08:00
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if (expected_to_fail) {
|
2019-04-07 05:55:14 +08:00
|
|
|
VERIFY(ret, FAIL, "H5Screate_simple");
|
2020-09-30 22:27:10 +08:00
|
|
|
}
|
|
|
|
|
else {
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode2");
|
|
|
|
|
|
|
|
|
|
/* Allocate the buffer for encoding */
|
|
|
|
|
buf = (char *)HDmalloc(buf_size);
|
2021-03-25 00:25:50 +08:00
|
|
|
CHECK_PTR(buf, "H5Dmalloc");
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
/* Encode according to the setting in in_fapl */
|
|
|
|
|
ret = H5Sencode2(in_sid, buf, &buf_size, in_fapl);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sencode2");
|
|
|
|
|
|
|
|
|
|
/* Decode the buffer */
|
|
|
|
|
d_sid = H5Sdecode(buf);
|
|
|
|
|
CHECK(d_sid, FAIL, "H5Sdecode");
|
|
|
|
|
|
|
|
|
|
/* Verify the number of selected points for in_sid and d_sid */
|
|
|
|
|
VERIFY(H5Sget_select_npoints(in_sid), H5Sget_select_npoints(d_sid), "Compare npoints");
|
|
|
|
|
|
|
|
|
|
/* Verify if the two dataspace selections (in_sid, d_sid) are the same shape */
|
2019-07-31 04:34:53 +08:00
|
|
|
check = H5Sselect_shape_same(in_sid, d_sid);
|
|
|
|
|
VERIFY(check, TRUE, "H5Sselect_shape_same");
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
/* Compare the starting/ending coordinates of the bounding box for in_sid and d_sid */
|
|
|
|
|
ret = H5Sget_select_bounds(in_sid, in_low_bounds, in_high_bounds);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sget_select_bounds");
|
|
|
|
|
ret = H5Sget_select_bounds(d_sid, d_low_bounds, d_high_bounds);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sget_select_bounds");
|
|
|
|
|
VERIFY(in_low_bounds[0], d_low_bounds[0], "Compare selection low bounds");
|
|
|
|
|
VERIFY(in_high_bounds[0], d_high_bounds[0], "Compare selection high bounds");
|
|
|
|
|
|
2020-04-21 07:12:00 +08:00
|
|
|
/*
|
2019-04-07 05:55:14 +08:00
|
|
|
* See "RFC: H5Sencode/H5Sdeocde Format Change" for the verification of:
|
|
|
|
|
* H5S_SEL_POINTS:
|
|
|
|
|
* --the expected version for point selection info
|
|
|
|
|
* --the expected encoded size (version 2 points selection info)
|
|
|
|
|
* H5S_SEL_HYPERSLABS:
|
|
|
|
|
* --the expected version for hyperslab selection info
|
|
|
|
|
* --the expected encoded size (version 3 hyperslab selection info)
|
|
|
|
|
*/
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if (H5Sget_select_type(in_sid) == H5S_SEL_POINTS) {
|
2020-04-21 07:12:00 +08:00
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Verify the version */
|
|
|
|
|
VERIFY((uint32_t)buf[35], expected_version, "Version for point selection");
|
|
|
|
|
|
|
|
|
|
/* Verify the encoded size for version 2 */
|
2020-09-30 22:27:10 +08:00
|
|
|
if (expected_version == 2)
|
2019-04-07 05:55:14 +08:00
|
|
|
VERIFY((uint8_t)buf[39], expected_enc_size, "Encoded size of point selection info");
|
|
|
|
|
}
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if (H5Sget_select_type(in_sid) == H5S_SEL_HYPERSLABS) {
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
/* Verify the version */
|
|
|
|
|
VERIFY((uint32_t)buf[35], expected_version, "Version for hyperslab selection info");
|
|
|
|
|
|
|
|
|
|
/* Verify the encoded size for version 3 */
|
2020-09-30 22:27:10 +08:00
|
|
|
if (expected_version == 3)
|
2019-04-07 05:55:14 +08:00
|
|
|
VERIFY((uint8_t)buf[40], expected_enc_size, "Encoded size of selection info");
|
|
|
|
|
|
|
|
|
|
} /* hyperslab selection */
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(d_sid);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
2020-09-30 22:27:10 +08:00
|
|
|
if (buf)
|
2019-04-07 05:55:14 +08:00
|
|
|
HDfree(buf);
|
|
|
|
|
}
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
return (0);
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
} /* test_h5s_check_encoding */
|
|
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_encode_regular_hyper():
|
|
|
|
|
** This test verifies that H5Sencode2() works as specified in
|
|
|
|
|
** the RFC for regular hyperslabs.
|
|
|
|
|
** See "RFC: H5Sencode/H5Sdeocde Format Change".
|
|
|
|
|
**
|
|
|
|
|
****************************************************************/
|
|
|
|
|
static void
|
|
|
|
|
test_h5s_encode_regular_hyper(H5F_libver_t low, H5F_libver_t high)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t fapl = -1; /* File access property list ID */
|
|
|
|
|
hid_t sid = -1; /* Dataspace ID */
|
|
|
|
|
hsize_t numparticles = 8388608; /* Used to calculate dimension size */
|
|
|
|
|
unsigned num_dsets = 513; /* Used to calculate dimension size */
|
|
|
|
|
hsize_t total_particles = numparticles * num_dsets;
|
|
|
|
|
hsize_t vdsdims[1] = {total_particles}; /* Dimension size */
|
|
|
|
|
hsize_t start, stride, count, block; /* Selection info */
|
|
|
|
|
unsigned config; /* Testing configuration */
|
|
|
|
|
unsigned unlim; /* H5S_UNLIMITED setting or not */
|
|
|
|
|
herr_t ret; /* Generic return value */
|
|
|
|
|
uint32_t expected_version = 0; /* Expected version for selection info */
|
|
|
|
|
uint8_t expected_enc_size = 0; /* Expected encoded size for selection info */
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
|
|
|
|
MESSAGE(5, ("Testing Dataspace encoding of regular hyperslabs\n"));
|
|
|
|
|
|
|
|
|
|
/* Create the file access property list */
|
|
|
|
|
fapl = H5Pcreate(H5P_FILE_ACCESS);
|
|
|
|
|
CHECK(fapl, FAIL, "H5Pcreate");
|
|
|
|
|
|
|
|
|
|
/* Set the low/high bounds in the fapl */
|
|
|
|
|
ret = H5Pset_libver_bounds(fapl, low, high);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pset_libver_bounds");
|
|
|
|
|
|
|
|
|
|
/* Create the dataspace */
|
|
|
|
|
sid = H5Screate_simple(1, vdsdims, NULL);
|
|
|
|
|
CHECK(sid, FAIL, "H5Screate_simple");
|
|
|
|
|
|
|
|
|
|
/* Testing with each configuration */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (config = CONFIG_16; config <= CONFIG_32; config++) {
|
2019-04-07 05:55:14 +08:00
|
|
|
hbool_t expected_to_fail = FALSE;
|
|
|
|
|
|
|
|
|
|
/* Testing with unlimited or not */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (unlim = 0; unlim <= 1; unlim++) {
|
2019-04-07 05:55:14 +08:00
|
|
|
start = 0;
|
2020-09-30 22:27:10 +08:00
|
|
|
count = unlim ? H5S_UNLIMITED : 2;
|
2019-04-07 05:55:14 +08:00
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if ((high <= H5F_LIBVER_V18) && (unlim || config == CONFIG_32))
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_to_fail = TRUE;
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if (low >= H5F_LIBVER_V112)
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_version = 3;
|
2020-09-30 22:27:10 +08:00
|
|
|
else if (config == CONFIG_16 && !unlim)
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_version = 1;
|
2020-04-21 07:12:00 +08:00
|
|
|
else
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_version = 2;
|
|
|
|
|
|
|
|
|
|
/* test 1 */
|
2020-09-30 22:27:10 +08:00
|
|
|
switch (config) {
|
2019-04-07 05:55:14 +08:00
|
|
|
case CONFIG_16:
|
2020-09-30 22:27:10 +08:00
|
|
|
stride = POWER16 - 1;
|
|
|
|
|
block = 4;
|
2019-12-12 00:44:56 +08:00
|
|
|
expected_enc_size = (uint8_t)(expected_version == 3 ? 2 : 4);
|
2019-04-07 05:55:14 +08:00
|
|
|
break;
|
|
|
|
|
case CONFIG_32:
|
2020-09-30 22:27:10 +08:00
|
|
|
stride = POWER32 - 1;
|
|
|
|
|
block = 4;
|
2019-12-12 00:44:56 +08:00
|
|
|
expected_enc_size = (uint8_t)(expected_version == 3 ? 4 : 8);
|
2020-04-21 07:12:00 +08:00
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
HDassert(0);
|
|
|
|
|
break;
|
|
|
|
|
} /* end switch */
|
|
|
|
|
|
|
|
|
|
/* Set the hyperslab selection */
|
|
|
|
|
ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, &start, &stride, &count, &block);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Verify the version and encoded size expected for this configuration */
|
|
|
|
|
ret = test_h5s_check_encoding(fapl, sid, expected_version, expected_enc_size, expected_to_fail);
|
|
|
|
|
CHECK(ret, FAIL, "test_h5s_check_encoding");
|
|
|
|
|
|
|
|
|
|
/* test 2 */
|
2020-09-30 22:27:10 +08:00
|
|
|
switch (config) {
|
2019-04-07 05:55:14 +08:00
|
|
|
case CONFIG_16:
|
2020-09-30 22:27:10 +08:00
|
|
|
stride = POWER16 - 1;
|
|
|
|
|
block = POWER16 - 2;
|
2019-12-12 00:44:56 +08:00
|
|
|
expected_enc_size = (uint8_t)(expected_version == 3 ? 2 : 4);
|
2019-04-07 05:55:14 +08:00
|
|
|
break;
|
|
|
|
|
case CONFIG_32:
|
2020-09-30 22:27:10 +08:00
|
|
|
stride = POWER32 - 1;
|
|
|
|
|
block = POWER32 - 2;
|
2019-12-12 00:44:56 +08:00
|
|
|
expected_enc_size = (uint8_t)(expected_version == 3 ? 4 : 8);
|
2019-04-07 05:55:14 +08:00
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
HDassert(0);
|
|
|
|
|
break;
|
|
|
|
|
} /* end switch */
|
|
|
|
|
|
|
|
|
|
/* Set the hyperslab selection */
|
|
|
|
|
ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, &start, &stride, &count, &block);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Verify the version and encoded size for this configuration */
|
|
|
|
|
ret = test_h5s_check_encoding(fapl, sid, expected_version, expected_enc_size, expected_to_fail);
|
|
|
|
|
CHECK(ret, FAIL, "test_h5s_check_encoding");
|
|
|
|
|
|
|
|
|
|
/* test 3 */
|
2020-09-30 22:27:10 +08:00
|
|
|
switch (config) {
|
2019-04-07 05:55:14 +08:00
|
|
|
case CONFIG_16:
|
2020-09-30 22:27:10 +08:00
|
|
|
stride = POWER16 - 1;
|
|
|
|
|
block = POWER16 - 1;
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_enc_size = 4;
|
|
|
|
|
break;
|
|
|
|
|
case CONFIG_32:
|
2020-09-30 22:27:10 +08:00
|
|
|
stride = POWER32 - 1;
|
|
|
|
|
block = POWER32 - 1;
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_enc_size = 8;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
HDassert(0);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set the hyperslab selection */
|
|
|
|
|
ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, &start, &stride, &count, &block);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Verify the version and encoded size expected for this configuration */
|
|
|
|
|
ret = test_h5s_check_encoding(fapl, sid, expected_version, expected_enc_size, expected_to_fail);
|
|
|
|
|
CHECK(ret, FAIL, "test_h5s_check_encoding");
|
|
|
|
|
|
|
|
|
|
/* test 4 */
|
2020-09-30 22:27:10 +08:00
|
|
|
switch (config) {
|
2019-04-07 05:55:14 +08:00
|
|
|
case CONFIG_16:
|
2020-09-30 22:27:10 +08:00
|
|
|
stride = POWER16;
|
|
|
|
|
block = POWER16 - 2;
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_enc_size = 4;
|
|
|
|
|
break;
|
|
|
|
|
case CONFIG_32:
|
2020-09-30 22:27:10 +08:00
|
|
|
stride = POWER32;
|
|
|
|
|
block = POWER32 - 2;
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_enc_size = 8;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
HDassert(0);
|
|
|
|
|
break;
|
|
|
|
|
} /* end switch */
|
|
|
|
|
|
|
|
|
|
/* Set the hyperslab selection */
|
|
|
|
|
ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, &start, &stride, &count, &block);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Verify the version and encoded size expected for this configuration */
|
|
|
|
|
ret = test_h5s_check_encoding(fapl, sid, expected_version, expected_enc_size, expected_to_fail);
|
|
|
|
|
CHECK(ret, FAIL, "test_h5s_check_encoding");
|
|
|
|
|
|
|
|
|
|
/* test 5 */
|
2020-09-30 22:27:10 +08:00
|
|
|
switch (config) {
|
2019-04-07 05:55:14 +08:00
|
|
|
case CONFIG_16:
|
2020-09-30 22:27:10 +08:00
|
|
|
stride = POWER16;
|
|
|
|
|
block = 1;
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_enc_size = 4;
|
|
|
|
|
break;
|
|
|
|
|
case CONFIG_32:
|
2020-09-30 22:27:10 +08:00
|
|
|
stride = POWER32;
|
|
|
|
|
block = 1;
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_enc_size = 8;
|
|
|
|
|
break;
|
|
|
|
|
default:
|
|
|
|
|
HDassert(0);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set the hyperslab selection */
|
|
|
|
|
ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, &start, &stride, &count, &block);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Verify the version and encoded size expected for this configuration */
|
|
|
|
|
ret = test_h5s_check_encoding(fapl, sid, expected_version, expected_enc_size, expected_to_fail);
|
|
|
|
|
CHECK(ret, FAIL, "test_h5s_check_encoding");
|
|
|
|
|
|
|
|
|
|
} /* for unlim */
|
2020-09-30 22:27:10 +08:00
|
|
|
} /* for config */
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
ret = H5Sclose(sid);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
ret = H5Pclose(fapl);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pclose");
|
|
|
|
|
|
|
|
|
|
} /* test_h5s_encode_regular_hyper() */
|
|
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
2020-04-21 07:12:00 +08:00
|
|
|
** test_h5s_encode_irregular_hyper():
|
2019-04-07 05:55:14 +08:00
|
|
|
** This test verifies that H5Sencode2() works as specified in
|
|
|
|
|
** the RFC for irregular hyperslabs.
|
|
|
|
|
** See "RFC: H5Sencode/H5Sdeocde Format Change".
|
|
|
|
|
**
|
|
|
|
|
****************************************************************/
|
|
|
|
|
static void
|
|
|
|
|
test_h5s_encode_irregular_hyper(H5F_libver_t low, H5F_libver_t high)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t fapl = -1; /* File access property list ID */
|
|
|
|
|
hid_t sid; /* Dataspace ID */
|
|
|
|
|
hsize_t numparticles = 8388608; /* Used to calculate dimension size */
|
|
|
|
|
unsigned num_dsets = 513; /* Used to calculate dimension size */
|
|
|
|
|
hsize_t total_particles = numparticles * num_dsets;
|
|
|
|
|
hsize_t vdsdims[1] = {total_particles}; /* Dimension size */
|
|
|
|
|
hsize_t start, stride, count, block; /* Selection info */
|
|
|
|
|
htri_t is_regular; /* Is this a regular hyperslab */
|
|
|
|
|
unsigned config; /* Testing configuration */
|
|
|
|
|
herr_t ret; /* Generic return value */
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
|
|
|
|
MESSAGE(5, ("Testing Dataspace encoding of irregular hyperslabs\n"));
|
|
|
|
|
|
|
|
|
|
/* Create the file access property list */
|
|
|
|
|
fapl = H5Pcreate(H5P_FILE_ACCESS);
|
|
|
|
|
CHECK(fapl, FAIL, "H5Pcreate");
|
|
|
|
|
|
|
|
|
|
/* Set the low/high bounds in the fapl */
|
|
|
|
|
ret = H5Pset_libver_bounds(fapl, low, high);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pset_libver_bounds");
|
|
|
|
|
|
|
|
|
|
/* Create the dataspace */
|
|
|
|
|
sid = H5Screate_simple(1, vdsdims, NULL);
|
|
|
|
|
CHECK(sid, FAIL, "H5Screate_simple");
|
|
|
|
|
|
|
|
|
|
/* Testing with each configuration */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (config = CONFIG_8; config <= CONFIG_32; config++) {
|
|
|
|
|
hbool_t expected_to_fail = FALSE; /* Whether H5Sencode2 is expected to fail */
|
|
|
|
|
uint32_t expected_version = 0; /* Expected version for selection info */
|
2019-12-04 10:52:55 +08:00
|
|
|
uint32_t expected_enc_size = 0; /* Expected encoded size for selection info */
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
start = 0;
|
|
|
|
|
count = 2;
|
|
|
|
|
block = 4;
|
|
|
|
|
|
|
|
|
|
/* H5Sencode2 is expected to fail for library v110 and below
|
|
|
|
|
when the selection exceeds the 32 bits integer limit */
|
2020-09-30 22:27:10 +08:00
|
|
|
if (high <= H5F_LIBVER_V110 && config == CONFIG_32)
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_to_fail = TRUE;
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if (low >= H5F_LIBVER_V112 || config == CONFIG_32)
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_version = 3;
|
|
|
|
|
else
|
|
|
|
|
expected_version = 1;
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
switch (config) {
|
2019-04-07 05:55:14 +08:00
|
|
|
case CONFIG_8:
|
|
|
|
|
stride = POWER8 - 2;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CONFIG_16:
|
|
|
|
|
stride = POWER16 - 2;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CONFIG_32:
|
|
|
|
|
stride = POWER32 - 2;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
|
|
|
|
HDassert(0);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set the hyperslab selection */
|
|
|
|
|
ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, &start, &stride, &count, &block);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
start = 8;
|
|
|
|
|
count = 5;
|
|
|
|
|
block = 2;
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
switch (config) {
|
2019-04-07 05:55:14 +08:00
|
|
|
case CONFIG_8:
|
2020-09-30 22:27:10 +08:00
|
|
|
stride = POWER8;
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_enc_size = expected_version == 3 ? 2 : 4;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CONFIG_16:
|
2020-09-30 22:27:10 +08:00
|
|
|
stride = POWER16;
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_enc_size = 4;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case CONFIG_32:
|
2020-09-30 22:27:10 +08:00
|
|
|
stride = POWER32;
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_enc_size = 8;
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
2020-10-24 08:13:05 +08:00
|
|
|
HDassert(0);
|
2019-04-07 05:55:14 +08:00
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Set the hyperslab selection */
|
|
|
|
|
ret = H5Sselect_hyperslab(sid, H5S_SELECT_OR, &start, &stride, &count, &block);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Should be irregular hyperslab */
|
|
|
|
|
is_regular = H5Sis_regular_hyperslab(sid);
|
|
|
|
|
VERIFY(is_regular, FALSE, "H5Sis_regular_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Verify the version and encoded size expected for the configuration */
|
2019-12-12 00:44:56 +08:00
|
|
|
HDassert(expected_enc_size <= 255);
|
2020-09-30 22:27:10 +08:00
|
|
|
ret = test_h5s_check_encoding(fapl, sid, expected_version, (uint8_t)expected_enc_size,
|
|
|
|
|
expected_to_fail);
|
2019-04-07 05:55:14 +08:00
|
|
|
CHECK(ret, FAIL, "test_h5s_check_encoding");
|
|
|
|
|
|
|
|
|
|
} /* for config */
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(sid);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
} /* test_h5s_encode_irregular_hyper() */
|
|
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_encode_points():
|
|
|
|
|
** This test verifies that H5Sencode2() works as specified in
|
|
|
|
|
** the RFC for point selection.
|
|
|
|
|
** See "RFC: H5Sencode/H5Sdeocde Format Change".
|
|
|
|
|
**
|
|
|
|
|
****************************************************************/
|
|
|
|
|
static void
|
|
|
|
|
test_h5s_encode_points(H5F_libver_t low, H5F_libver_t high)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t fapl = -1; /* File access property list ID */
|
|
|
|
|
hid_t sid; /* Dataspace ID */
|
2021-12-07 22:27:29 +08:00
|
|
|
hsize_t numparticles = 8388608; /* Used to calculate dimension size */
|
2020-09-30 22:27:10 +08:00
|
|
|
unsigned num_dsets = 513; /* used to calculate dimension size */
|
|
|
|
|
hsize_t total_particles = numparticles * num_dsets;
|
|
|
|
|
hsize_t vdsdims[1] = {total_particles}; /* Dimension size */
|
|
|
|
|
hsize_t coord[4]; /* The point coordinates */
|
|
|
|
|
herr_t ret; /* Generic return value */
|
|
|
|
|
hbool_t expected_to_fail = FALSE; /* Expected to fail or not */
|
|
|
|
|
uint32_t expected_version = 0; /* Expected version for selection info */
|
|
|
|
|
uint8_t expected_enc_size = 0; /* Expected encoded size of selection info */
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
|
|
|
|
MESSAGE(5, ("Testing Dataspace encoding of points selection\n"));
|
|
|
|
|
|
|
|
|
|
/* Create the file access property list */
|
|
|
|
|
fapl = H5Pcreate(H5P_FILE_ACCESS);
|
|
|
|
|
CHECK(fapl, FAIL, "H5Pcreate");
|
|
|
|
|
|
|
|
|
|
/* Set the low/high bounds in the fapl */
|
|
|
|
|
ret = H5Pset_libver_bounds(fapl, low, high);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pset_libver_bounds");
|
|
|
|
|
|
|
|
|
|
/* Create the dataspace */
|
|
|
|
|
sid = H5Screate_simple(1, vdsdims, NULL);
|
|
|
|
|
CHECK(sid, FAIL, "H5Screate_simple");
|
|
|
|
|
|
|
|
|
|
/* test 1 */
|
|
|
|
|
coord[0] = 5;
|
|
|
|
|
coord[1] = 15;
|
|
|
|
|
coord[2] = POWER16;
|
|
|
|
|
coord[3] = 19;
|
2020-09-30 22:27:10 +08:00
|
|
|
ret = H5Sselect_elements(sid, H5S_SELECT_SET, (size_t)4, coord);
|
2019-04-07 05:55:14 +08:00
|
|
|
CHECK(ret, FAIL, "H5Sselect_elements");
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
expected_to_fail = FALSE;
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_enc_size = 4;
|
2020-09-30 22:27:10 +08:00
|
|
|
expected_version = 1;
|
2019-04-07 05:55:14 +08:00
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if (low >= H5F_LIBVER_V112)
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_version = 2;
|
|
|
|
|
|
|
|
|
|
/* Verify the version and encoded size expected for the configuration */
|
|
|
|
|
ret = test_h5s_check_encoding(fapl, sid, expected_version, expected_enc_size, expected_to_fail);
|
|
|
|
|
CHECK(ret, FAIL, "test_h5s_check_encoding");
|
|
|
|
|
|
|
|
|
|
/* test 2 */
|
|
|
|
|
coord[0] = 5;
|
|
|
|
|
coord[1] = 15;
|
|
|
|
|
coord[2] = POWER32 - 1;
|
|
|
|
|
coord[3] = 19;
|
2020-09-30 22:27:10 +08:00
|
|
|
ret = H5Sselect_elements(sid, H5S_SELECT_SET, (size_t)4, coord);
|
2019-04-07 05:55:14 +08:00
|
|
|
CHECK(ret, FAIL, "H5Sselect_elements");
|
|
|
|
|
|
|
|
|
|
/* Expected result same as test 1 */
|
|
|
|
|
ret = test_h5s_check_encoding(fapl, sid, expected_version, expected_enc_size, expected_to_fail);
|
|
|
|
|
CHECK(ret, FAIL, "test_h5s_check_encoding");
|
|
|
|
|
|
|
|
|
|
/* test 3 */
|
2020-09-30 22:27:10 +08:00
|
|
|
if (high <= H5F_LIBVER_V110)
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_to_fail = TRUE;
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
if (high >= H5F_LIBVER_V112) {
|
|
|
|
|
expected_version = 2;
|
2019-04-07 05:55:14 +08:00
|
|
|
expected_enc_size = 8;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
coord[0] = 5;
|
|
|
|
|
coord[1] = 15;
|
|
|
|
|
coord[2] = POWER32 + 1;
|
|
|
|
|
coord[3] = 19;
|
2020-09-30 22:27:10 +08:00
|
|
|
ret = H5Sselect_elements(sid, H5S_SELECT_SET, (size_t)4, coord);
|
2019-04-07 05:55:14 +08:00
|
|
|
CHECK(ret, FAIL, "H5Sselect_elements");
|
|
|
|
|
|
|
|
|
|
/* Verify the version and encoded size expected for the configuration */
|
|
|
|
|
ret = test_h5s_check_encoding(fapl, sid, expected_version, expected_enc_size, expected_to_fail);
|
|
|
|
|
CHECK(ret, FAIL, "test_h5s_check_encoding");
|
|
|
|
|
|
|
|
|
|
/* Close the dataspace */
|
|
|
|
|
ret = H5Sclose(sid);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
} /* test_h5s_encode_points() */
|
2004-04-09 05:23:19 +08:00
|
|
|
|
2019-04-06 00:34:58 +08:00
|
|
|
/****************************************************************
|
|
|
|
|
**
|
2020-04-21 07:12:00 +08:00
|
|
|
** test_h5s_encode_length():
|
2019-04-06 00:34:58 +08:00
|
|
|
** Test to verify HDFFV-10271 is fixed.
|
|
|
|
|
** Verify that version 2 hyperslab encoding length is correct.
|
|
|
|
|
**
|
2020-04-21 07:12:00 +08:00
|
|
|
** See "RFC: H5Sencode/H5Sdecode Format Change" for the
|
2019-04-06 00:34:58 +08:00
|
|
|
** description of the encoding format.
|
|
|
|
|
**
|
|
|
|
|
****************************************************************/
|
|
|
|
|
static void
|
|
|
|
|
test_h5s_encode_length(void)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t sid; /* Dataspace ID */
|
|
|
|
|
hid_t decoded_sid; /* Dataspace ID from H5Sdecode2 */
|
|
|
|
|
size_t sbuf_size = 0; /* Buffer size for H5Sencode2/1 */
|
|
|
|
|
unsigned char *sbuf = NULL; /* Buffer for H5Sencode2/1 */
|
|
|
|
|
hsize_t dims[1] = {500}; /* Dimension size */
|
|
|
|
|
hsize_t start, count, block, stride; /* Hyperslab selection specifications */
|
|
|
|
|
herr_t ret; /* Generic return value */
|
2019-04-06 00:34:58 +08:00
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
|
|
|
|
MESSAGE(5, ("Testing Version 2 Hyperslab Encoding Length is correct\n"));
|
|
|
|
|
|
|
|
|
|
/* Create dataspace */
|
|
|
|
|
sid = H5Screate_simple(1, dims, NULL);
|
|
|
|
|
CHECK(sid, FAIL, "H5Screate_simple");
|
|
|
|
|
|
|
|
|
|
/* Setting H5S_UNLIMITED in count will use version 2 for hyperslab encoding */
|
2020-09-30 22:27:10 +08:00
|
|
|
start = 0;
|
2019-04-06 00:34:58 +08:00
|
|
|
stride = 10;
|
2020-09-30 22:27:10 +08:00
|
|
|
block = 4;
|
|
|
|
|
count = H5S_UNLIMITED;
|
2019-04-06 00:34:58 +08:00
|
|
|
|
|
|
|
|
/* Set hyperslab selection */
|
|
|
|
|
ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, &start, &stride, &count, &block);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Encode simple dataspace in a buffer */
|
2019-04-07 05:55:14 +08:00
|
|
|
ret = H5Sencode2(sid, NULL, &sbuf_size, H5P_DEFAULT);
|
2019-04-06 00:34:58 +08:00
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
|
|
|
|
/* Allocate the buffer */
|
2020-09-30 22:27:10 +08:00
|
|
|
if (sbuf_size > 0) {
|
|
|
|
|
sbuf = (unsigned char *)HDcalloc((size_t)1, sbuf_size);
|
2021-03-25 00:25:50 +08:00
|
|
|
CHECK_PTR(sbuf, "H5Sencode2");
|
2019-04-06 00:34:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Encode the dataspace */
|
2019-04-07 05:55:14 +08:00
|
|
|
ret = H5Sencode2(sid, sbuf, &sbuf_size, H5P_DEFAULT);
|
2019-04-06 00:34:58 +08:00
|
|
|
CHECK(ret, FAIL, "H5Sencode");
|
|
|
|
|
|
|
|
|
|
/* Verify that length stored at this location in the buffer is correct */
|
|
|
|
|
VERIFY((uint32_t)sbuf[40], 36, "Length for encoding version 2");
|
|
|
|
|
VERIFY((uint32_t)sbuf[35], 2, "Hyperslab encoding version is 2");
|
|
|
|
|
|
|
|
|
|
/* Decode from the dataspace buffer and return an object handle */
|
|
|
|
|
decoded_sid = H5Sdecode(sbuf);
|
|
|
|
|
CHECK(decoded_sid, FAIL, "H5Sdecode");
|
|
|
|
|
|
|
|
|
|
/* Verify that the original and the decoded dataspace are equal */
|
|
|
|
|
VERIFY(H5Sget_select_npoints(sid), H5Sget_select_npoints(decoded_sid), "Compare npoints");
|
|
|
|
|
|
|
|
|
|
/* Close the decoded dataspace */
|
|
|
|
|
ret = H5Sclose(decoded_sid);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
/* Free the buffer */
|
2020-09-30 22:27:10 +08:00
|
|
|
if (sbuf)
|
2019-04-06 00:34:58 +08:00
|
|
|
HDfree(sbuf);
|
|
|
|
|
|
|
|
|
|
/* Close the original dataspace */
|
|
|
|
|
ret = H5Sclose(sid);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
|
|
|
|
|
} /* test_h5s_encode_length() */
|
|
|
|
|
|
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)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t fid1; /* HDF5 File IDs */
|
|
|
|
|
hid_t dataset; /* Dataset ID */
|
|
|
|
|
hid_t sid1; /* Dataspace ID */
|
|
|
|
|
int rank; /* Logical rank of dataspace */
|
|
|
|
|
hsize_t tdims[4]; /* Dimension array to test with */
|
|
|
|
|
hssize_t n; /* Number of dataspace elements */
|
|
|
|
|
H5S_class_t ext_type; /* Extent type */
|
|
|
|
|
herr_t ret; /* Generic return value */
|
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 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. */
|
2021-03-17 23:25:39 +08:00
|
|
|
H5E_BEGIN_TRY
|
|
|
|
|
{
|
|
|
|
|
sid1 = H5Screate_simple(SPACE1_RANK, NULL, NULL);
|
|
|
|
|
}
|
2020-09-30 22:27:10 +08:00
|
|
|
H5E_END_TRY
|
[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(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");
|
|
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Retrieve the number of elements in the dataspace selection */
|
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
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Get the dataspace rank */
|
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
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Get the dataspace dimension sizes */
|
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
|
|
|
|
2019-04-07 05:55:14 +08:00
|
|
|
/* Write to the dataset */
|
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");
|
2020-09-30 22:27:10 +08:00
|
|
|
} /* test_h5s_scalar_write() */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** 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)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t fid1; /* HDF5 File IDs */
|
|
|
|
|
hid_t dataset; /* Dataset ID */
|
|
|
|
|
hid_t sid1; /* Dataspace ID */
|
|
|
|
|
int rank; /* Logical rank of dataspace */
|
|
|
|
|
hsize_t tdims[4]; /* Dimension array to test with */
|
|
|
|
|
hssize_t n; /* Number of dataspace elements */
|
|
|
|
|
unsigned rdata; /* Scalar data read in */
|
|
|
|
|
herr_t ret; /* Generic return value */
|
|
|
|
|
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");
|
2020-09-30 22:27:10 +08:00
|
|
|
} /* test_h5s_scalar_read() */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** 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)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t fid1; /* HDF5 File IDs */
|
|
|
|
|
hid_t dataset; /* Dataset ID */
|
|
|
|
|
hid_t tid1; /* Attribute datatype ID */
|
|
|
|
|
hid_t sid1; /* Dataspace ID */
|
|
|
|
|
int rank; /* Logical rank of dataspace */
|
|
|
|
|
hsize_t tdims[4]; /* Dimension array to test with */
|
|
|
|
|
hssize_t n; /* Number of dataspace elements */
|
|
|
|
|
herr_t ret; /* Generic return value */
|
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 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. */
|
2020-09-30 22:27:10 +08:00
|
|
|
tid1 = H5Tcreate(H5T_COMPOUND, sizeof(struct space4_struct));
|
1998-04-29 06:33:07 +08:00
|
|
|
CHECK(tid1, FAIL, "H5Tcreate");
|
2020-09-30 22:27:10 +08:00
|
|
|
space4_field1_off = HOFFSET(struct space4_struct, c1);
|
|
|
|
|
ret = H5Tinsert(tid1, SPACE4_FIELDNAME1, space4_field1_off, H5T_NATIVE_SCHAR);
|
1998-04-29 06:33:07 +08:00
|
|
|
CHECK(ret, FAIL, "H5Tinsert");
|
2020-09-30 22:27:10 +08:00
|
|
|
space4_field2_off = HOFFSET(struct space4_struct, u);
|
|
|
|
|
ret = H5Tinsert(tid1, SPACE4_FIELDNAME2, space4_field2_off, H5T_NATIVE_UINT);
|
1998-04-29 06:33:07 +08:00
|
|
|
CHECK(ret, FAIL, "H5Tinsert");
|
2020-09-30 22:27:10 +08:00
|
|
|
space4_field3_off = HOFFSET(struct space4_struct, f);
|
|
|
|
|
ret = H5Tinsert(tid1, SPACE4_FIELDNAME3, space4_field3_off, H5T_NATIVE_FLOAT);
|
1998-04-29 06:33:07 +08:00
|
|
|
CHECK(ret, FAIL, "H5Tinsert");
|
2020-09-30 22:27:10 +08:00
|
|
|
space4_field4_off = HOFFSET(struct space4_struct, c2);
|
|
|
|
|
ret = H5Tinsert(tid1, SPACE4_FIELDNAME4, space4_field4_off, 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");
|
2020-09-30 22:27:10 +08:00
|
|
|
} /* test_h5s_compound_scalar_write() */
|
1998-04-29 06:33:07 +08:00
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** 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)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t fid1; /* HDF5 File IDs */
|
|
|
|
|
hid_t dataset; /* Dataset ID */
|
|
|
|
|
hid_t sid1; /* Dataspace ID */
|
|
|
|
|
hid_t type; /* Datatype */
|
|
|
|
|
int rank; /* Logical rank of dataspace */
|
|
|
|
|
hsize_t tdims[4]; /* Dimension array to test with */
|
|
|
|
|
hssize_t n; /* Number of dataspace elements */
|
|
|
|
|
struct space4_struct rdata; /* Scalar data read in */
|
|
|
|
|
herr_t ret; /* Generic return value */
|
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 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
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
type = H5Dget_type(dataset);
|
1998-04-29 06:33:07 +08:00
|
|
|
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");
|
2021-03-11 02:42:35 +08:00
|
|
|
if (HDmemcmp(&space4_data, &rdata, sizeof(struct space4_struct)) != 0) {
|
2020-09-30 22:27:10 +08:00
|
|
|
HDprintf("scalar data different: space4_data.c1=%c, read_data4.c1=%c\n", space4_data.c1, rdata.c1);
|
|
|
|
|
HDprintf("scalar data different: space4_data.u=%u, read_data4.u=%u\n", space4_data.u, rdata.u);
|
|
|
|
|
HDprintf("scalar data different: space4_data.f=%f, read_data4.f=%f\n", (double)space4_data.f,
|
|
|
|
|
(double)rdata.f);
|
|
|
|
|
TestErrPrintf("scalar data different: space4_data.c1=%c, read_data4.c1=%c\n", space4_data.c1,
|
|
|
|
|
rdata.c2);
|
|
|
|
|
} /* 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");
|
2020-09-30 22:27:10 +08:00
|
|
|
} /* end test_h5s_compound_scalar_read() */
|
2020-01-16 01:32:01 +08:00
|
|
|
|
|
|
|
|
/* Data array sizes for chunk test */
|
2020-09-30 22:27:10 +08:00
|
|
|
#define CHUNK_DATA_NX 50000
|
|
|
|
|
#define CHUNK_DATA_NY 3
|
2001-10-03 00:58:16 +08:00
|
|
|
|
|
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** 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)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
herr_t status;
|
|
|
|
|
hid_t fileID, dsetID;
|
|
|
|
|
hid_t plist_id;
|
|
|
|
|
hid_t space_id;
|
|
|
|
|
hsize_t dims[2];
|
|
|
|
|
hsize_t csize[2];
|
|
|
|
|
double **chunk_data_dbl = NULL;
|
2022-07-27 05:45:46 +08:00
|
|
|
double *chunk_data_dbl_data = NULL;
|
|
|
|
|
float **chunk_data_flt = NULL;
|
|
|
|
|
float *chunk_data_flt_data = NULL;
|
2020-09-30 22:27:10 +08:00
|
|
|
int i, j;
|
2001-10-03 00:58:16 +08:00
|
|
|
|
2020-01-16 01:32:01 +08:00
|
|
|
/* Allocate memory */
|
|
|
|
|
chunk_data_dbl_data = (double *)HDcalloc(CHUNK_DATA_NX * CHUNK_DATA_NY, sizeof(double));
|
|
|
|
|
CHECK_PTR(chunk_data_dbl_data, "HDcalloc");
|
|
|
|
|
chunk_data_dbl = (double **)HDcalloc(CHUNK_DATA_NX, sizeof(chunk_data_dbl_data));
|
|
|
|
|
CHECK_PTR(chunk_data_dbl, "HDcalloc");
|
|
|
|
|
for (i = 0; i < CHUNK_DATA_NX; i++)
|
|
|
|
|
chunk_data_dbl[i] = chunk_data_dbl_data + (i * CHUNK_DATA_NY);
|
|
|
|
|
|
|
|
|
|
chunk_data_flt_data = (float *)HDcalloc(CHUNK_DATA_NX * CHUNK_DATA_NY, sizeof(float));
|
|
|
|
|
CHECK_PTR(chunk_data_flt_data, "HDcalloc");
|
|
|
|
|
chunk_data_flt = (float **)HDcalloc(CHUNK_DATA_NX, sizeof(chunk_data_flt_data));
|
|
|
|
|
CHECK_PTR(chunk_data_flt, "HDcalloc");
|
|
|
|
|
for (i = 0; i < CHUNK_DATA_NX; i++)
|
|
|
|
|
chunk_data_flt[i] = chunk_data_flt_data + (i * CHUNK_DATA_NY);
|
|
|
|
|
|
[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");
|
|
|
|
|
|
2020-01-16 01:32:01 +08:00
|
|
|
csize[0] = CHUNK_DATA_NX;
|
|
|
|
|
csize[1] = CHUNK_DATA_NY;
|
2020-09-30 22:27:10 +08:00
|
|
|
status = H5Pset_chunk(plist_id, 2, csize);
|
2001-10-03 00:58:16 +08:00
|
|
|
CHECK(status, FAIL, "H5Pset_chunk");
|
|
|
|
|
|
2019-07-31 04:34:53 +08:00
|
|
|
/* Create the dataspace */
|
2020-09-30 22:27:10 +08:00
|
|
|
dims[0] = CHUNK_DATA_NX;
|
|
|
|
|
dims[1] = CHUNK_DATA_NY;
|
2001-10-03 00:58:16 +08:00
|
|
|
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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < CHUNK_DATA_NX; i++)
|
|
|
|
|
for (j = 0; j < CHUNK_DATA_NY; 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
|
|
|
|
2020-01-16 01:32:01 +08:00
|
|
|
status = H5Dwrite(dsetID, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, chunk_data_flt_data);
|
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 */
|
2020-01-16 01:32:01 +08:00
|
|
|
HDmemset(chunk_data_dbl_data, 0, sizeof(double) * CHUNK_DATA_NX * CHUNK_DATA_NY);
|
|
|
|
|
HDmemset(chunk_data_flt_data, 0, sizeof(float) * CHUNK_DATA_NX * CHUNK_DATA_NY);
|
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
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
status = H5Dread(dsetID, H5T_NATIVE_DOUBLE, H5S_ALL, H5S_ALL, H5P_DEFAULT, chunk_data_dbl_data);
|
2001-10-03 00:58:16 +08:00
|
|
|
CHECK(status, FAIL, "H5Dread");
|
2020-09-30 22:27:10 +08:00
|
|
|
status = H5Dread(dsetID, H5T_NATIVE_FLOAT, H5S_ALL, H5S_ALL, H5P_DEFAULT, chunk_data_flt_data);
|
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");
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < CHUNK_DATA_NX; i++) {
|
|
|
|
|
for (j = 0; j < CHUNK_DATA_NY; j++) {
|
2007-03-12 23:52:52 +08:00
|
|
|
/* Check if the two values are within 0.001% range. */
|
2021-05-08 00:45:05 +08:00
|
|
|
if (!H5_DBL_REL_EQUAL(chunk_data_dbl[i][j], (double)chunk_data_flt[i][j], 0.00001))
|
2020-09-30 22:27:10 +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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
} /* end for */
|
2020-01-16 01:32:01 +08:00
|
|
|
|
|
|
|
|
HDfree(chunk_data_dbl);
|
|
|
|
|
HDfree(chunk_data_dbl_data);
|
|
|
|
|
HDfree(chunk_data_flt);
|
|
|
|
|
HDfree(chunk_data_flt_data);
|
2001-10-03 00:58:16 +08:00
|
|
|
} /* 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)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
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 */
|
2005-11-07 11:13:53 +08:00
|
|
|
|
|
|
|
|
/* 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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t tmp_space = -1;
|
2015-02-26 01:29:30 +08:00
|
|
|
hsize_t d1_dims1[1] = {10}, /* 1-D dimensions */
|
2020-09-30 22:27:10 +08:00
|
|
|
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};
|
|
|
|
|
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() */
|
|
|
|
|
htri_t ext_equal; /* Whether two dataspace extents are equal */
|
2015-02-26 01:29:30 +08:00
|
|
|
const unsigned num_spaces = sizeof(spaces) / sizeof(spaces[0]);
|
2020-09-30 22:27:10 +08:00
|
|
|
unsigned i, j;
|
|
|
|
|
herr_t ret; /* Generic error return */
|
2015-02-26 01:29:30 +08:00
|
|
|
|
|
|
|
|
/* 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];
|
2020-09-30 22:27:10 +08:00
|
|
|
spaces[3] = H5Screate_simple(1, d1_dims2, NULL);
|
2015-02-26 01:29:30 +08:00
|
|
|
CHECK(spaces[3], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
npoints[3] = d1_dims2[0];
|
2020-09-30 22:27:10 +08:00
|
|
|
spaces[4] = H5Screate_simple(1, d1_dims1, d1_dims2);
|
2015-02-26 01:29:30 +08:00
|
|
|
CHECK(spaces[4], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
npoints[4] = d1_dims1[0];
|
2020-09-30 22:27:10 +08:00
|
|
|
spaces[5] = H5Screate_simple(1, d1_dims1, d1_dims3);
|
2015-02-26 01:29:30 +08:00
|
|
|
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];
|
2020-09-30 22:27:10 +08:00
|
|
|
spaces[7] = H5Screate_simple(2, d2_dims2, NULL);
|
2015-02-26 01:29:30 +08:00
|
|
|
CHECK(spaces[7], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
npoints[7] = d2_dims2[0] * d2_dims2[1];
|
2020-09-30 22:27:10 +08:00
|
|
|
spaces[8] = H5Screate_simple(2, d2_dims1, d2_dims2);
|
2015-02-26 01:29:30 +08:00
|
|
|
CHECK(spaces[8], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
npoints[8] = d2_dims1[0] * d2_dims1[1];
|
2020-09-30 22:27:10 +08:00
|
|
|
spaces[9] = H5Screate_simple(2, d2_dims1, d2_dims3);
|
2015-02-26 01:29:30 +08:00
|
|
|
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];
|
2020-09-30 22:27:10 +08:00
|
|
|
spaces[11] = H5Screate_simple(3, d3_dims2, NULL);
|
2015-02-26 01:29:30 +08:00
|
|
|
CHECK(spaces[11], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
npoints[11] = d3_dims2[0] * d3_dims2[1] * d3_dims2[2];
|
2020-09-30 22:27:10 +08:00
|
|
|
spaces[12] = H5Screate_simple(3, d3_dims1, d3_dims2);
|
2015-02-26 01:29:30 +08:00
|
|
|
CHECK(spaces[12], FAIL, "H5Screate");
|
2015-04-01 22:22:16 +08:00
|
|
|
npoints[12] = d3_dims1[0] * d3_dims1[1] * d3_dims1[2];
|
2020-09-30 22:27:10 +08:00
|
|
|
spaces[13] = H5Screate_simple(3, d3_dims1, d3_dims3);
|
2015-02-26 01:29:30 +08:00
|
|
|
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. */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < num_spaces; i++)
|
|
|
|
|
for (j = i; j < num_spaces; j++) {
|
2015-02-26 01:29:30 +08:00
|
|
|
/* 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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (i = 0; i < num_spaces; i++) {
|
2015-02-26 01:29:30 +08:00
|
|
|
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)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
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 */
|
2015-08-29 03:43:03 +08:00
|
|
|
|
|
|
|
|
/* 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() */
|
|
|
|
|
|
2022-09-27 11:51:52 +08:00
|
|
|
/****************************************************************
|
|
|
|
|
**
|
|
|
|
|
** test_h5s_bug2(): Test combining hyperslabs in a way that used
|
|
|
|
|
** to trip up H5S__hyper_update_diminfo()
|
|
|
|
|
**
|
|
|
|
|
****************************************************************/
|
|
|
|
|
static void
|
|
|
|
|
test_h5s_bug2(void)
|
|
|
|
|
{
|
|
|
|
|
hid_t space; /* Dataspace to copy extent to */
|
|
|
|
|
hsize_t dims[2] = {1, 5}; /* Dimensions */
|
|
|
|
|
hsize_t start[2] = {0, 0}; /* Hyperslab start */
|
|
|
|
|
hsize_t count[2] = {1, 1}; /* Hyperslab start */
|
|
|
|
|
htri_t select_valid; /* Whether the dataspace selection is valid */
|
|
|
|
|
hssize_t elements_selected; /* Number of elements selected */
|
|
|
|
|
herr_t ret; /* Generic error return */
|
|
|
|
|
|
|
|
|
|
/* Create dataspace */
|
|
|
|
|
space = H5Screate_simple(2, dims, NULL);
|
|
|
|
|
CHECK(space, FAIL, "H5Screate");
|
|
|
|
|
|
|
|
|
|
/* Select hyperslab in space containing first element */
|
|
|
|
|
ret = H5Sselect_hyperslab(space, H5S_SELECT_SET, start, NULL, count, NULL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Add hyperslab in space containing last element */
|
|
|
|
|
start[1] = 4;
|
|
|
|
|
ret = H5Sselect_hyperslab(space, H5S_SELECT_OR, start, NULL, count, NULL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Add hyperslab in space containing the first 3 elements */
|
|
|
|
|
start[1] = 0;
|
|
|
|
|
count[1] = 3;
|
|
|
|
|
ret = H5Sselect_hyperslab(space, H5S_SELECT_OR, start, NULL, count, NULL);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sselect_hyperslab");
|
|
|
|
|
|
|
|
|
|
/* Check that space's selection is valid */
|
|
|
|
|
select_valid = H5Sselect_valid(space);
|
|
|
|
|
CHECK(select_valid, FAIL, "H5Sselect_valid");
|
|
|
|
|
VERIFY(select_valid, TRUE, "H5Sselect_valid result");
|
|
|
|
|
|
|
|
|
|
/* Check that 4 elements are selected */
|
|
|
|
|
elements_selected = H5Sget_select_npoints(space);
|
|
|
|
|
CHECK(elements_selected, FAIL, "H5Sselect_valid");
|
|
|
|
|
VERIFY(elements_selected, 4, "H5Sselect_valid result");
|
|
|
|
|
|
|
|
|
|
/* Close dataspaces */
|
|
|
|
|
ret = H5Sclose(space);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
} /* test_h5s_bug2() */
|
|
|
|
|
|
2018-03-08 05:49:14 +08:00
|
|
|
/*-------------------------------------------------------------------------
|
|
|
|
|
* Function: test_versionbounds
|
|
|
|
|
*
|
|
|
|
|
* Purpose: Tests version bounds with dataspace.
|
|
|
|
|
*
|
|
|
|
|
* Description:
|
|
|
|
|
* This function creates a file with lower bounds then later
|
|
|
|
|
* reopens it with higher bounds to show that the dataspace
|
|
|
|
|
* version is upgraded appropriately.
|
|
|
|
|
*
|
|
|
|
|
* Return: Success: 0
|
|
|
|
|
* Failure: number of errors
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
2020-09-30 22:27:10 +08:00
|
|
|
#define VERBFNAME "tverbounds_dspace.h5"
|
|
|
|
|
#define BASIC_DSET "Basic Dataset"
|
|
|
|
|
#define LATEST_DSET "Latest Dataset"
|
2018-03-08 05:49:14 +08:00
|
|
|
static void
|
|
|
|
|
test_versionbounds(void)
|
|
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
hid_t file = -1; /* File ID */
|
|
|
|
|
hid_t space = -1; /* Dataspace ID */
|
|
|
|
|
hid_t dset = -1; /* Dataset ID */
|
|
|
|
|
hid_t fapl = -1; /* File access property list ID */
|
|
|
|
|
hid_t dset_space = -1; /* Retrieved dataset's dataspace ID */
|
|
|
|
|
hsize_t dim[1]; /* Dataset dimensions */
|
|
|
|
|
H5F_libver_t low, high; /* File format bounds */
|
2022-07-27 05:45:46 +08:00
|
|
|
H5S_t *spacep = NULL; /* Pointer to internal dataspace */
|
2020-09-30 22:27:10 +08:00
|
|
|
herr_t ret = 0; /* Generic return value */
|
2018-03-08 05:49:14 +08:00
|
|
|
|
|
|
|
|
/* Output message about test being performed */
|
|
|
|
|
MESSAGE(5, ("Testing Version Bounds\n"));
|
|
|
|
|
|
|
|
|
|
/* Create a file access property list */
|
|
|
|
|
fapl = H5Pcreate(H5P_FILE_ACCESS);
|
|
|
|
|
CHECK(fapl, FAIL, "H5Pcreate");
|
|
|
|
|
|
|
|
|
|
/* Create dataspace */
|
|
|
|
|
dim[0] = 10;
|
2020-09-30 22:27:10 +08:00
|
|
|
space = H5Screate_simple(1, dim, NULL);
|
2018-03-08 05:49:14 +08:00
|
|
|
CHECK(space, FAIL, "H5Screate");
|
|
|
|
|
|
|
|
|
|
/* Its version should be H5O_SDSPACE_VERSION_1 */
|
|
|
|
|
spacep = (H5S_t *)H5I_object(space);
|
2021-03-25 00:25:50 +08:00
|
|
|
CHECK_PTR(spacep, "H5I_object");
|
2018-03-08 05:49:14 +08:00
|
|
|
VERIFY(spacep->extent.version, H5O_SDSPACE_VERSION_1, "basic dataspace version bound");
|
|
|
|
|
|
|
|
|
|
/* Set high bound to V18 */
|
2020-09-30 22:27:10 +08:00
|
|
|
low = H5F_LIBVER_EARLIEST;
|
2018-03-08 05:49:14 +08:00
|
|
|
high = H5F_LIBVER_V18;
|
2020-09-30 22:27:10 +08:00
|
|
|
ret = H5Pset_libver_bounds(fapl, low, high);
|
2018-03-08 05:49:14 +08:00
|
|
|
CHECK(ret, FAIL, "H5Pset_libver_bounds");
|
|
|
|
|
|
|
|
|
|
/* Create the file */
|
|
|
|
|
file = H5Fcreate(VERBFNAME, H5F_ACC_TRUNC, H5P_DEFAULT, fapl);
|
|
|
|
|
CHECK(file, FAIL, "H5Fcreate");
|
|
|
|
|
|
|
|
|
|
/* Create a basic dataset */
|
|
|
|
|
dset = H5Dcreate2(file, BASIC_DSET, H5T_NATIVE_INT, space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
|
|
|
|
if (dset > 0) /* dataset created successfully */
|
|
|
|
|
{
|
|
|
|
|
/* Get the internal dataspace pointer */
|
|
|
|
|
dset_space = H5Dget_space(dset);
|
|
|
|
|
CHECK(dset_space, FAIL, "H5Dget_space");
|
|
|
|
|
spacep = (H5S_t *)H5I_object(dset_space);
|
2021-03-25 00:25:50 +08:00
|
|
|
CHECK_PTR(spacep, "H5I_object");
|
2018-03-08 05:49:14 +08:00
|
|
|
|
|
|
|
|
/* Dataspace version should remain as H5O_SDSPACE_VERSION_1 */
|
|
|
|
|
VERIFY(spacep->extent.version, H5O_SDSPACE_VERSION_1, "basic dataspace version bound");
|
|
|
|
|
|
|
|
|
|
/* Close dataspace */
|
|
|
|
|
ret = H5Sclose(dset_space);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Close basic dataset and the file */
|
|
|
|
|
ret = H5Dclose(dset);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
|
|
|
ret = H5Fclose(file);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fclose");
|
|
|
|
|
|
|
|
|
|
/* Set low and high bounds to latest to trigger the increment of the
|
|
|
|
|
dataspace version */
|
2020-09-30 22:27:10 +08:00
|
|
|
low = H5F_LIBVER_LATEST;
|
2018-03-08 05:49:14 +08:00
|
|
|
high = H5F_LIBVER_LATEST;
|
2020-09-30 22:27:10 +08:00
|
|
|
ret = H5Pset_libver_bounds(fapl, low, high);
|
2018-03-08 05:49:14 +08:00
|
|
|
CHECK(ret, FAIL, "H5Pset_libver_bounds");
|
|
|
|
|
|
|
|
|
|
/* Reopen the file with new version bounds, LATEST/LATEST */
|
|
|
|
|
file = H5Fopen(VERBFNAME, H5F_ACC_RDWR, fapl);
|
|
|
|
|
|
|
|
|
|
/* Create another dataset using the same dspace as the previous dataset */
|
|
|
|
|
dset = H5Dcreate2(file, LATEST_DSET, H5T_NATIVE_INT, space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
|
|
|
|
|
CHECK(dset, FAIL, "H5Dcreate2");
|
|
|
|
|
|
|
|
|
|
/* Dataset created successfully. Verify that dataspace version has been
|
|
|
|
|
upgraded per the low bound */
|
|
|
|
|
|
|
|
|
|
/* Get the internal dataspace pointer */
|
|
|
|
|
dset_space = H5Dget_space(dset);
|
|
|
|
|
CHECK(dset_space, FAIL, "H5Dget_space");
|
|
|
|
|
spacep = (H5S_t *)H5I_object(dset_space);
|
2021-03-25 00:25:50 +08:00
|
|
|
CHECK_PTR(spacep, "H5I_object");
|
2018-03-08 05:49:14 +08:00
|
|
|
|
|
|
|
|
/* Verify the dataspace version */
|
|
|
|
|
VERIFY(spacep->extent.version, H5O_sdspace_ver_bounds[low], "upgraded dataspace version");
|
|
|
|
|
|
|
|
|
|
/* Close everything */
|
|
|
|
|
ret = H5Sclose(dset_space);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Dclose(dset);
|
|
|
|
|
CHECK(ret, FAIL, "H5Dclose");
|
|
|
|
|
|
|
|
|
|
ret = H5Sclose(space);
|
|
|
|
|
CHECK(ret, FAIL, "H5Sclose");
|
|
|
|
|
ret = H5Pclose(fapl);
|
|
|
|
|
CHECK(ret, FAIL, "H5Pclose");
|
|
|
|
|
ret = H5Fclose(file);
|
|
|
|
|
CHECK(ret, FAIL, "H5Fclose");
|
|
|
|
|
} /* end test_versionbounds() */
|
|
|
|
|
|
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
|
|
|
{
|
2020-09-30 22:27:10 +08:00
|
|
|
H5F_libver_t low, high; /* Low and high bounds */
|
2019-04-07 05:55:14 +08:00
|
|
|
|
1997-09-04 21:03:31 +08:00
|
|
|
/* Output message about test being performed */
|
|
|
|
|
MESSAGE(5, ("Testing Dataspaces\n"));
|
|
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
test_h5s_basic(); /* Test basic H5S code */
|
|
|
|
|
test_h5s_null(); /* Test Null dataspace H5S code */
|
|
|
|
|
test_h5s_zero_dim(); /* Test dataspace with zero dimension size */
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
/* Loop through all the combinations of low/high version bounds */
|
2020-09-30 22:27:10 +08:00
|
|
|
for (low = H5F_LIBVER_EARLIEST; low < H5F_LIBVER_NBOUNDS; low++) {
|
|
|
|
|
for (high = H5F_LIBVER_EARLIEST; high < H5F_LIBVER_NBOUNDS; high++) {
|
2019-04-07 05:55:14 +08:00
|
|
|
|
|
|
|
|
/* Invalid combinations, just continue */
|
2020-09-30 22:27:10 +08:00
|
|
|
if (high == H5F_LIBVER_EARLIEST || high < low)
|
2019-04-07 05:55:14 +08:00
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
test_h5s_encode(low, high); /* Test encoding and decoding */
|
|
|
|
|
test_h5s_encode_regular_hyper(low, high); /* Test encoding regular hyperslabs */
|
|
|
|
|
test_h5s_encode_irregular_hyper(low, high); /* Test encoding irregular hyperslabs */
|
|
|
|
|
test_h5s_encode_points(low, high); /* Test encoding points */
|
|
|
|
|
|
|
|
|
|
} /* end high bound */
|
2020-09-30 22:27:10 +08:00
|
|
|
} /* end low bound */
|
2019-04-07 05:55:14 +08:00
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
test_h5s_encode_length(); /* Test version 2 hyperslab encoding length is correct */
|
2019-04-09 01:33:45 +08:00
|
|
|
#ifndef H5_NO_DEPRECATED_SYMBOLS
|
2020-09-30 22:27:10 +08:00
|
|
|
test_h5s_encode1(); /* Test operations with old API routine (H5Sencode1) */
|
|
|
|
|
#endif /* H5_NO_DEPRECATED_SYMBOLS */
|
2019-04-09 01:33:45 +08:00
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
test_h5s_scalar_write(); /* Test scalar H5S writing code */
|
|
|
|
|
test_h5s_scalar_read(); /* Test scalar H5S reading code */
|
2004-07-22 05:30:26 +08:00
|
|
|
|
2020-09-30 22:27:10 +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 */
|
2020-09-30 22:27:10 +08:00
|
|
|
test_h5s_chunk(); /* Exercise bug fix for chunked I/O */
|
2005-11-07 11:13:53 +08:00
|
|
|
|
2020-09-30 22:27:10 +08:00
|
|
|
test_h5s_extent_equal(); /* Test extent comparison code */
|
|
|
|
|
test_h5s_extent_copy(); /* Test extent copy code */
|
|
|
|
|
test_h5s_bug1(); /* Test bug in offset initialization */
|
2022-09-27 11:51:52 +08:00
|
|
|
test_h5s_bug2(); /* Test bug found in H5S__hyper_update_diminfo() */
|
2020-09-30 22:27:10 +08:00
|
|
|
test_versionbounds(); /* Test version bounds with dataspace */
|
1998-04-29 06:33:07 +08:00
|
|
|
} /* test_h5s() */
|
1998-07-03 08:57:00 +08:00
|
|
|
|
|
|
|
|
/*-------------------------------------------------------------------------
|
2018-03-08 05:49:14 +08:00
|
|
|
* Function: cleanup_h5s
|
1998-07-03 08:57:00 +08:00
|
|
|
*
|
2018-03-08 05:49:14 +08:00
|
|
|
* Purpose: Cleanup temporary test files
|
1998-07-03 08:57:00 +08:00
|
|
|
*
|
2018-03-08 05:49:14 +08:00
|
|
|
* Return: none
|
1998-07-03 08:57:00 +08:00
|
|
|
*
|
2018-03-08 05:49:14 +08:00
|
|
|
* Programmer: Albert Cheng
|
1998-07-03 08:57:00 +08:00
|
|
|
* July 2, 1998
|
|
|
|
|
*
|
|
|
|
|
* Modifications:
|
|
|
|
|
*
|
|
|
|
|
*-------------------------------------------------------------------------
|
|
|
|
|
*/
|
|
|
|
|
void
|
|
|
|
|
cleanup_h5s(void)
|
|
|
|
|
{
|
2020-10-24 08:13:05 +08:00
|
|
|
HDremove(DATAFILE);
|
|
|
|
|
HDremove(NULLFILE);
|
|
|
|
|
HDremove(BASICFILE);
|
|
|
|
|
HDremove(ZEROFILE);
|
|
|
|
|
HDremove(VERBFNAME);
|
1998-07-03 08:57:00 +08:00
|
|
|
}
|
