mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2024-12-03 02:32:04 +08:00
Code Issues Packages Projects Releases Wiki Activity
e4aae4fd9b
hdf5/test/cmpd_dset.c
Robb Matzke a34534c9b8 [svn-r546] Changes since 19980724 
----------------------

./MANIFEST
./doc/html/H5.format.html
./src/H5O.c
./src/H5Oprivate.h
./src/H5Omtime.c	[NEW]
./src/H5private.h
./src/Makefile.in
	Added the modification time message.  If an object header has
	this message then it's value is updated with the current time
	whenever anything changes in the object header.

./acconfig.h
./configure.in
	Alas, there seems to be no standard way to convert a string
	time like 19980727122800 in UTC to a time_t since mktime()
	only converts local times to time_t.  So I've modified the
	configuration to check for various ways of getting the time
	zone information:

	   * Added checks for the `tm_gmtoff' field of `struct tm'.
	   * Added a check for the `timezone' global variable.
	   * Added a check for `struct timezone'.
	   * Added a check for BSDgettimeofday().
	   * Added a check for gettimeofday() although it doesn't
	     actually set the timezone argument on some systems.
	   * Added a check to see if `tm_zone' is a member of `struct tm'.
	   * Added a check to see if `tzname' is a global variable.
	   * Added a check to see if `struct tm' is defined in time.h
	     or sys/time.h.

	It's not difficult to get the right UTC modification message
	into the object header, but some systems might have problems
	getting the right time back out (Irix64 is one) and those
	systems will report zero for the H5G_stat_t.mtime from an
	H5Gstat() call as if the mtime message isn't even present.  It
	will, however, continue to be updated as normal.

./src/H5G.c
./src/H5Gpublic.h
	The H5G_stat_t struct now contains an `mtime' field which will
	hold the object modification time.  If the object has no
	object modification time then the `mtime' will be initialized
	to zero.

	Fixed a bug in H5G_stat() that caused the `objno' field of the
	H5G_stat_t to be set incorrectly on some machines.

./src/H5D.c
	Writing to external datasets fail if the hdf5 file is not open
	for writing.

	A modification time message is added to the dataset object
	header when it's created and H5O_touch() is called from
	H5D_write() to update that message.

./src/H5T.c
	Fixed a bug in H5Tget_member_dims() that caused a segmentation
	fault if one of the output array arguments was the null
	pointer.

	Relaxed the member dimension checking in H5Tinsert_array() so
	it can also be used for scalar members.

./test/Makefile.in
	Added additional file names to the `mostlyclean' target.

./tools/h5dump.c
./tools/h5tools.h
	Increased the temporary buffer size to 1MB.

	Added support for printing compound data types with array
	members.

	When printing H5T_NATIVE_CHAR and H5T_NATIVE_UCHAR we escape
	double quote characters.

./tools/h5ls.c
	Changed the output format a little because we were starting to
	get too much info to fit on a line.  Without `--verbose' each
	object occupies one line of output.  Otherwise, additional
	information is printed below the object name: object file
	address, comment, and modification time.  If `--dump' is given
	then the data is printed after the other information.

./test/cmpd_dset.c
	Changed the way the dataset is initialized to be more uniform.
1998-07-29 11:43:59 -05:00

660 lines
18 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
* Copyright (C) 1998 NCSA
* All rights reserved.
*
* Programmer: Robb Matzke <matzke@llnl.gov>
* Friday, January 23, 1998
*/
#undef NDEBUG
#include <assert.h>
#include <hdf5.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TEST_FILE_NAME "cmpd_dset.h5"
/* The first dataset */
typedef struct s1_t {
unsigned int a;
unsigned int b;
unsigned int c[4];
unsigned int d;
unsigned int e;
} s1_t;
/* The second dataset (same as first) */
typedef s1_t s2_t;
/* The third dataset (reversed fields of s1) */
typedef struct s3_t {
unsigned int e;
unsigned int d;
unsigned int c[4];
unsigned int b;
unsigned int a;
} s3_t;
/* The fourth dataset (a subset of s1) */
typedef struct s4_t {
unsigned int b;
unsigned int d;
} s4_t;
/* The fifth dataset (a superset of s1) */
typedef struct s5_t {
unsigned int pre;
unsigned int a;
unsigned int b;
unsigned int mid1;
unsigned int c[4];
unsigned int mid2;
unsigned int d;
unsigned int e;
unsigned int post;
} s5_t;
#if 1
# define NX 100u
# define NY 2000u
#else
# define NX 12u
# define NY 9u
#endif
/*-------------------------------------------------------------------------
* Function: cleanup
*
* Purpose: Cleanup temporary test files
*
* Return: none
*
* Programmer: Albert Cheng
* May 28, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static void
cleanup(void)
{
if (!getenv ("HDF5_NOCLEANUP")) {
remove(TEST_FILE_NAME);
}
}
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Creates a simple dataset of a compound type and then reads
* it back. The dataset is read back in various ways to
* exercise the I/O pipeline and compound type conversion.
*
* Return: Success: 0
*
* Failure: 1
*
* Programmer: Robb Matzke
* Friday, January 23, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
int
main (void)
{
/* First dataset */
static s1_t s1[NX*NY];
hid_t s1_tid;
/* Second dataset */
static s2_t s2[NX*NY];
hid_t s2_tid;
/* Third dataset */
static s3_t s3[NX*NY];
hid_t s3_tid;
/* Fourth dataset */
static s4_t s4[NX*NY];
hid_t s4_tid;
/* Fifth dataset */
static s5_t s5[NX*NY];
hid_t s5_tid;
/* Sixth dataset */
/* Seventh dataset */
hid_t s7_sid;
/* Eighth dataset */
s1_t *s8 = NULL;
hid_t s8_f_sid; /*file data space */
hid_t s8_m_sid; /*memory data space */
/* Ninth dataset */
/* Tenth dataset */
/* Eleventh dataset */
s4_t *s11 = NULL;
/* Other variables */
unsigned int i, j;
int ndims;
hid_t file, dataset, space, PRESERVE;
herr_t status;
static hsize_t dim[] = {NX, NY};
hssize_t f_offset[2]; /*offset of hyperslab in file */
hsize_t h_size[2]; /*size of hyperslab */
hsize_t h_sample[2]; /*hyperslab sampling */
size_t memb_size[1] = {4};
/* Create the file */
file = H5Fcreate (TEST_FILE_NAME, H5F_ACC_TRUNC|H5F_ACC_DEBUG,
H5P_DEFAULT, H5P_DEFAULT);
assert (file>=0);
/* Create the data space */
space = H5Screate_simple (2, dim, NULL);
assert (space>=0);
/* Create xfer properties to preserve initialized data */
PRESERVE = H5Pcreate (H5P_DATASET_XFER);
assert (PRESERVE>=0);
status = H5Pset_preserve (PRESERVE, 1);
assert (status>=0);
/*
*######################################################################
* STEP 1: Save the original dataset natively.
*/
printf ("\
STEP 1: Initialize dataset `s1' and store it on disk in native order.\n");
fflush (stdout);
/* Initialize the dataset */
for (i=0; i<NX*NY; i++) {
s1[i].a = 8*i+0;
s1[i].b = 2000+2*i;
s1[i].c[0] = 8*i+2;
s1[i].c[1] = 8*i+3;
s1[i].c[2] = 8*i+4;
s1[i].c[3] = 8*i+5;
s1[i].d = 2001+2*i;
s1[i].e = 8*i+7;
}
/* Create the memory data type */
s1_tid = H5Tcreate (H5T_COMPOUND, sizeof(s1_t));
H5Tinsert (s1_tid, "a", HOFFSET(s1_t,a), H5T_NATIVE_INT);
H5Tinsert (s1_tid, "b", HOFFSET(s1_t,b), H5T_NATIVE_INT);
H5Tinsert_array (s1_tid, "c", HOFFSET(s1_t,c), 1, memb_size, NULL,
H5T_NATIVE_INT);
H5Tinsert (s1_tid, "d", HOFFSET(s1_t,d), H5T_NATIVE_INT);
H5Tinsert (s1_tid, "e", HOFFSET(s1_t,e), H5T_NATIVE_INT);
assert (s1_tid>=0);
/* Create the dataset */
dataset = H5Dcreate (file, "s1", s1_tid, space, H5P_DEFAULT);
assert (dataset>=0);
/* Write the data */
status = H5Dwrite (dataset, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s1);
assert (status>=0);
/*
*######################################################################
* STEP 2: We create a new type ID for the second dataset even though
* it's the same as the first just to test things better, but
* in fact, we could have used s1_tid.
*/
printf ("\
STEP 2: Read the dataset from disk into a new memory buffer which has the\n\
same data type and space. This will be the typical case.\n");
fflush (stdout);
/* Create a data type for s2 */
s2_tid = H5Tcreate (H5T_COMPOUND, sizeof(s2_t));
H5Tinsert (s2_tid, "a", HOFFSET(s2_t,a), H5T_NATIVE_INT);
H5Tinsert (s2_tid, "b", HOFFSET(s2_t,b), H5T_NATIVE_INT);
H5Tinsert_array (s2_tid, "c", HOFFSET(s2_t,c), 1, memb_size, NULL,
H5T_NATIVE_INT);
H5Tinsert (s2_tid, "d", HOFFSET(s2_t,d), H5T_NATIVE_INT);
H5Tinsert (s2_tid, "e", HOFFSET(s2_t,e), H5T_NATIVE_INT);
assert (s2_tid>=0);
/* Read the data */
status = H5Dread (dataset, s2_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s2);
assert (status>=0);
/* Compare s2 with s1. They should be the same */
for (i=0; i<NX*NY; i++) {
assert (s1[i].a==s2[i].a);
assert (s1[i].b==s2[i].b);
assert (s1[i].c[0]==s2[i].c[0]);
assert (s1[i].c[1]==s2[i].c[1]);
assert (s1[i].c[2]==s2[i].c[2]);
assert (s1[i].c[3]==s2[i].c[3]);
assert (s1[i].d==s2[i].d);
assert (s1[i].e==s2[i].e);
}
/*
*######################################################################
* STEP 3: Read the dataset back into a third memory buffer. This buffer
* has the same data space but the data type is different: the
* data type is a struct whose members are in the opposite order.
*/
printf ("\
STEP 3: Read the dataset again with members in a different order.\n");
fflush (stdout);
/* Create a data type for s3 */
s3_tid = H5Tcreate (H5T_COMPOUND, sizeof(s3_t));
H5Tinsert (s3_tid, "a", HOFFSET(s3_t,a), H5T_NATIVE_INT);
H5Tinsert (s3_tid, "b", HOFFSET(s3_t,b), H5T_NATIVE_INT);
H5Tinsert_array (s3_tid, "c", HOFFSET(s3_t,c), 1, memb_size, NULL,
H5T_NATIVE_INT);
H5Tinsert (s3_tid, "d", HOFFSET(s3_t,d), H5T_NATIVE_INT);
H5Tinsert (s3_tid, "e", HOFFSET(s3_t,e), H5T_NATIVE_INT);
assert (s3_tid>=0);
/* Read the data */
status = H5Dread (dataset, s3_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s3);
assert (status>=0);
/* Compare s3 with s1. They should be the same */
for (i=0; i<NX*NY; i++) {
assert (s1[i].a==s3[i].a);
assert (s1[i].b==s3[i].b);
assert (s1[i].c[0]==s3[i].c[0]);
assert (s1[i].c[1]==s3[i].c[1]);
assert (s1[i].c[2]==s3[i].c[2]);
assert (s1[i].c[3]==s3[i].c[3]);
assert (s1[i].d==s3[i].d);
assert (s1[i].e==s3[i].e);
}
/*
*######################################################################
* STEP 4: Read a subset of the members. Of the <a,b,c,d,e> members
* stored on disk we'll read <b,d>.
*/
printf ("\
STEP 4: Read a subset of the members.\n");
fflush (stdout);
/* Create a datatype for s4 */
s4_tid = H5Tcreate (H5T_COMPOUND, sizeof(s4_t));
H5Tinsert (s4_tid, "b", HOFFSET(s4_t,b), H5T_NATIVE_INT);
H5Tinsert (s4_tid, "d", HOFFSET(s4_t,d), H5T_NATIVE_INT);
assert (s4_tid>=0);
/* Read the data */
status = H5Dread (dataset, s4_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s4);
assert (status>=0);
/* Compare s4 with s1 */
for (i=0; i<NX*NY; i++) {
assert (s1[i].b==s4[i].b);
assert (s1[i].d==s4[i].d);
}
/*
*######################################################################
* STEP 5: Read all the members into a struct which has other members
* which have already been initialized.
*/
printf ("\
STEP 5: Read members into a superset which is partially initialized.\n");
fflush (stdout);
/* Initialize some members */
for (i=0; i<NX*NY; i++) {
s5[i].pre = 1000+4*i;
s5[i].mid1 = 1001+4*i;
s5[i].mid2 = 1002+4*i;
s5[i].post = 1003+4*i;
}
/* Create a data type for s5 */
s5_tid = H5Tcreate (H5T_COMPOUND, sizeof(s5_t));
H5Tinsert (s5_tid, "a", HOFFSET(s5_t,a), H5T_NATIVE_INT);
H5Tinsert (s5_tid, "b", HOFFSET(s5_t,b), H5T_NATIVE_INT);
H5Tinsert_array (s5_tid, "c", HOFFSET(s5_t,c), 1, memb_size, NULL,
H5T_NATIVE_INT);
H5Tinsert (s5_tid, "d", HOFFSET(s5_t,d), H5T_NATIVE_INT);
H5Tinsert (s5_tid, "e", HOFFSET(s5_t,e), H5T_NATIVE_INT);
assert (s5_tid>=0);
/* Read the data */
status = H5Dread (dataset, s5_tid, H5S_ALL, H5S_ALL, PRESERVE, s5);
assert (status>=0);
/* Check that the data was read properly */
for (i=0; i<NX*NY; i++) {
assert (s1[i].a==s5[i].a);
assert (s1[i].b==s5[i].b);
assert (s1[i].c[0]==s5[i].c[0]);
assert (s1[i].c[1]==s5[i].c[1]);
assert (s1[i].c[2]==s5[i].c[2]);
assert (s1[i].c[3]==s5[i].c[3]);
assert (s1[i].d==s5[i].d);
assert (s1[i].e==s5[i].e);
}
/* Check that no previous values were clobbered */
for (i=0; i<NX*NY; i++) {
assert (s5[i].pre == 1000+4*i);
assert (s5[i].mid1 == 1001+4*i);
assert (s5[i].mid2 == 1002+4*i);
assert (s5[i].post == 1003+4*i);
}
/*
*######################################################################
* STEP 6: Update fields `b' and `d' on the file leaving the other
* fields unchanged. This tests member alignment and background
* buffers.
*/
printf ("\
STEP 6: Update fields `b' and `d' on the file, leaving the other fields\n\
unchanged.\n");
fflush (stdout);
/* Initialize `s4' with new values */
for (i=0; i<NX*NY; i++) {
s4[i].b = 8*i+1;
s4[i].d = 8*i+6;
}
/* Write the data to file */
status = H5Dwrite (dataset, s4_tid, H5S_ALL, H5S_ALL, PRESERVE, s4);
assert (status>=0);
/* Read the data back */
status = H5Dread (dataset, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s1);
assert (status>=0);
/* Compare */
for (i=0; i<NX*NY; i++) {
assert (s1[i].a == 8*i+0);
assert (s1[i].b == 8*i+1);
assert (s1[i].c[0] == 8*i+2);
assert (s1[i].c[1] == 8*i+3);
assert (s1[i].c[2] == 8*i+4);
assert (s1[i].c[3] == 8*i+5);
assert (s1[i].d == 8*i+6);
assert (s1[i].e == 8*i+7);
}
/*
*######################################################################
* STEP 7. Read the original dataset with an explicit data space. Even
* though these data spaces are equal it tests a different part of the
* library.
*/
printf ("\
STEP 7: Reading original dataset with explicit data space.\n");
fflush (stdout);
/* Create the data space */
s7_sid = H5Screate_simple (2, dim, NULL);
assert (s7_sid>=0);
/* Read the dataset */
status = H5Dread (dataset, s2_tid, s7_sid, H5S_ALL, H5P_DEFAULT, s2);
assert (status>=0);
/* Compare */
for (i=0; i<NX*NY; i++) {
assert (s2[i].a == s1[i].a);
assert (s2[i].b == s1[i].b);
assert (s2[i].c[0] == s1[i].c[0]);
assert (s2[i].c[1] == s1[i].c[1]);
assert (s2[i].c[2] == s1[i].c[2]);
assert (s2[i].c[3] == s1[i].c[3]);
assert (s2[i].d == s1[i].d);
assert (s2[i].e == s1[i].e);
}
/*
*######################################################################
* STEP 8. Read a hyperslab of the file into a complete array in memory.
* The hyperslab is the middle third of the array.
*/
printf ("\
STEP 8: Read middle third hyperslab into memory array.\n");
fflush (stdout);
/* Create the file data space */
s8_f_sid = H5Dget_space (dataset);
assert (s8_f_sid>=0);
f_offset[0] = NX/3;
f_offset[1] = NY/3;
h_size[0] = 2*NX/3 - f_offset[0];
h_size[1] = 2*NY/3 - f_offset[1];
status = H5Sselect_hyperslab (s8_f_sid, H5S_SELECT_SET, f_offset, NULL,
h_size, NULL);
assert (status>=0);
/* Create memory data space */
s8_m_sid = H5Screate_simple (2, h_size, NULL);
assert (s8_m_sid>=0);
/* Read the dataset */
s8 = calloc ((size_t)(h_size[0]*h_size[1]), sizeof(s1_t));
assert (s8);
status = H5Dread (dataset, s1_tid, s8_m_sid, s8_f_sid, H5P_DEFAULT, s8);
assert (status>=0);
/* Compare */
for (i=0; i<h_size[0]; i++) {
for (j=0; j<h_size[1]; j++) {
s1_t *ps1 = s1 + (f_offset[0]+i)*NY + f_offset[1] + j;
s1_t *ps8 = s8 + i*h_size[1] + j;
assert (ps8->a == ps1->a);
assert (ps8->b == ps1->b);
assert (ps8->c[0] == ps1->c[0]);
assert (ps8->c[1] == ps1->c[1]);
assert (ps8->c[2] == ps1->c[2]);
assert (ps8->c[3] == ps1->c[3]);
assert (ps8->d == ps1->d);
assert (ps8->e == ps1->e);
}
}
free (s8);
s8 = NULL;
/*
*######################################################################
* STEP 9. Read a hyperslab of the file into a hyperslab of memory. The
* part of memory not read is already initialized and must not change.
*/
printf ("\
STEP 9: Read middle third of hyperslab into middle third of memory array.\n");
fflush (stdout);
/* Initialize */
for (i=0; i<NX*NY; i++) {
s2[i].a = s2[i].b = s2[i].d = s2[i].e = (unsigned)(-1);
s2[i].c[0] = s2[i].c[1] = s2[i].c[2] = s2[i].c[3] = (unsigned)(-1);
}
/* Read the hyperslab */
status = H5Dread (dataset, s2_tid, s8_f_sid, s8_f_sid, H5P_DEFAULT, s2);
assert (status>=0);
/* Compare */
for (i=0; i<NX; i++) {
for (j=0; j<NY; j++) {
s1_t *ps1 = s1 + i*NY + j;
s2_t *ps2 = s2 + i*NY + j;
if ((hssize_t)i>=f_offset[0] &&
(hsize_t)i<f_offset[0]+h_size[0] &&
(hssize_t)j>=f_offset[1] &&
(hsize_t)j<f_offset[1]+h_size[1]) {
assert (ps2->a == ps1->a);
assert (ps2->b == ps1->b);
assert (ps2->c[0] == ps1->c[0]);
assert (ps2->c[1] == ps1->c[1]);
assert (ps2->c[2] == ps1->c[2]);
assert (ps2->c[3] == ps1->c[3]);
assert (ps2->d == ps1->d);
assert (ps2->e == ps1->e);
} else {
assert (ps2->a == (unsigned)(-1));
assert (ps2->b == (unsigned)(-1));
assert (ps2->c[0] == (unsigned)(-1));
assert (ps2->c[1] == (unsigned)(-1));
assert (ps2->c[2] == (unsigned)(-1));
assert (ps2->c[3] == (unsigned)(-1));
assert (ps2->d == (unsigned)(-1));
assert (ps2->e == (unsigned)(-1));
}
}
}
/*
*######################################################################
* STEP 10. Same as step 9 except the memory array contains some members
* which are already initialized, like step 5.
*/
printf ("\
STEP 10: Read middle third of hyperslab into middle third of memory array\n\
where some of the struct members are already initialized.\n");
fflush (stdout);
/* Initialize */
for (i=0; i<NX*NY; i++) {
s5[i].a = s5[i].b = s5[i].d = s5[i].e = (unsigned)(-1);
s5[i].c[0] = s5[i].c[1] = s5[i].c[2] = s5[i].c[3] = (unsigned)(-1);
s5[i].pre = s5[i].mid1 = s5[i].mid2 = s5[i].post = (unsigned)(-1);
}
/* Read the hyperslab */
status = H5Dread (dataset, s5_tid, s8_f_sid, s8_f_sid, PRESERVE, s5);
assert (status>=0);
/* Compare */
for (i=0; i<NX; i++) {
for (j=0; j<NY; j++) {
s1_t *ps1 = s1 + i*NY + j;
s5_t *ps5 = s5 + i*NY + j;
if ((hssize_t)i>=f_offset[0] &&
(hsize_t)i<f_offset[0]+h_size[0] &&
(hssize_t)j>=f_offset[1] &&
(hsize_t)j<f_offset[1]+h_size[1]) {
assert (ps5->pre == (unsigned)(-1));
assert (ps5->a == ps1->a);
assert (ps5->b == ps1->b);
assert (ps5->mid1 == (unsigned)(-1));
assert (ps5->c[0] == ps1->c[0]);
assert (ps5->c[1] == ps1->c[1]);
assert (ps5->c[2] == ps1->c[2]);
assert (ps5->c[3] == ps1->c[3]);
assert (ps5->mid2 == (unsigned)(-1));
assert (ps5->d == ps1->d);
assert (ps5->e == ps1->e);
assert (ps5->post == (unsigned)(-1));
} else {
assert (ps5->pre == (unsigned)(-1));
assert (ps5->a == (unsigned)(-1));
assert (ps5->b == (unsigned)(-1));
assert (ps5->mid1 == (unsigned)(-1));
assert (ps5->c[0] == (unsigned)(-1));
assert (ps5->c[1] == (unsigned)(-1));
assert (ps5->c[2] == (unsigned)(-1));
assert (ps5->c[3] == (unsigned)(-1));
assert (ps5->mid2 == (unsigned)(-1));
assert (ps5->d == (unsigned)(-1));
assert (ps5->e == (unsigned)(-1));
assert (ps5->post == (unsigned)(-1));
}
}
}
#ifdef OLD_WAY
/*
*######################################################################
* Step 11: Write an array into the middle third of the dataset
* initializeing only members `b' and `d' to -1.
*/
printf ("\
STEP 11: Write an array back to the middle third of the dataset to\n\
initialize the `b' and `d' members to -1.\n");
fflush (stdout);
/* Create the memory array and initialize all fields to zero */
ndims = H5Sget_hyperslab (s8_f_sid, f_offset, h_size, h_sample);
assert (ndims==2);
s11 = malloc ((size_t)h_size[0]*(size_t)h_size[1]*sizeof(s4_t));
assert (s11);
/* Initialize */
for (i=0; i<h_size[0]*h_size[1]; i++) {
s11[i].b = s11[i].d = (unsigned)(-1);
}
/* Write to disk */
status = H5Dwrite (dataset, s4_tid, s8_m_sid, s8_f_sid, PRESERVE, s11);
assert (status>=0);
free (s11);
s11=NULL;
/* Read the whole thing */
status = H5Dread (dataset, s1_tid, H5S_ALL, H5S_ALL, H5P_DEFAULT, s1);
assert (status>=0);
/* Compare */
for (i=0; i<NX; i++) {
for (j=0; j<NY; j++) {
s1_t *ps1 = s1 + i*NY + j;
assert (ps1->a == 8*(i*NY+j)+0);
assert (ps1->c[0] == 8*(i*NY+j)+2);
assert (ps1->c[1] == 8*(i*NY+j)+3);
assert (ps1->c[2] == 8*(i*NY+j)+4);
assert (ps1->c[3] == 8*(i*NY+j)+5);
assert (ps1->e == 8*(i*NY+j)+7);
if ((hssize_t)i>=f_offset[0] &&
(hsize_t)i<f_offset[0]+h_size[0] &&
(hssize_t)j>=f_offset[1] &&
(hsize_t)j<f_offset[1]+h_size[1]) {
assert (ps1->b == (unsigned)(-1));
assert (ps1->d == (unsigned)(-1));
} else {
assert (ps1->b == 8*(i*NY+j)+1);
assert (ps1->d == 8*(i*NY+j)+6);
}
}
}
#endif /* OLD_WAY */
/*
* Release resources.
*/
H5Pclose (PRESERVE);
H5Dclose (dataset);
H5Fclose (file);
cleanup();
return 0;
}
Reference in New Issue View Git Blame Copy Permalink