mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2025-03-31 17:10:47 +08:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup overuse of include files

Browse Source
This commit is contained in:
Allen Byrne 2018-02-14 10:08:09 -06:00
parent 66ea3b8fb9
commit 205d33f332
20 changed files with 3926 additions and 3955 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
test/chunk_info.c
View File

@ -21,7 +21,6 @@
*/
#include "hdf5.h"
#include "h5test.h"
#define PRINT_DATA

103
test/dangle.c
View File

@ -15,10 +15,9 @@
* Programmer: Quincey Koziol <koziol@ncsa.uiuc.edu>
* Tuesday, May 13, 2003
*
* Purpose: Test dangling IDs
* Purpose: Test dangling IDs
*/
#include "h5test.h"
#include "H5private.h"
const char *FILENAME[] = {
"dangle",
@ -32,17 +31,17 @@ const char *FILENAME[] = {
#define TYPENAME "Type"
#define ATTRNAME "Attribute"
/*-------------------------------------------------------------------------
* Function: test_dangle_dataset
* Function: test_dangle_dataset
*
* Purpose: Check for dangling dataset IDs causing problems on library
* Purpose: Check for dangling dataset IDs causing problems on library
* shutdown
*
* Return: Success: zero
* Failure: non-zero
* Return: Success: zero
* Failure: non-zero
*
* Programmer: Quincey Koziol
* Programmer: Quincey Koziol
* Tuesday, May 13, 2003
*
* Modifications:
@ -52,7 +51,7 @@ const char *FILENAME[] = {
static int
test_dangle_dataset(H5F_close_degree_t degree)
{
char filename[1024];
char filename[1024];
hid_t fid; /* File ID */
hid_t fapl; /* File access property list */
hid_t dsid; /* Dataset ID */
@ -128,17 +127,17 @@ error:
return 1;
}
/*-------------------------------------------------------------------------
* Function: test_dangle_group
* Function: test_dangle_group
*
* Purpose: Check for dangling group IDs causing problems on library
* Purpose: Check for dangling group IDs causing problems on library
* shutdown
*
* Return: Success: zero
* Failure: non-zero
* Return: Success: zero
* Failure: non-zero
*
* Programmer: Quincey Koziol
* Programmer: Quincey Koziol
* Tuesday, May 13, 2003
*
* Modifications:
@ -148,7 +147,7 @@ error:
static int
test_dangle_group(H5F_close_degree_t degree)
{
char filename[1024];
char filename[1024];
hid_t fid; /* File ID */
hid_t fapl; /* File access property list */
hid_t gid; /* Group ID */
@ -219,17 +218,17 @@ error:
return 1;
}
/*-------------------------------------------------------------------------
* Function: test_dangle_datatype1
* Function: test_dangle_datatype1
*
* Purpose: Check for dangling datatype IDs causing problems on library
* Purpose: Check for dangling datatype IDs causing problems on library
* shutdown
*
* Return: Success: zero
* Failure: non-zero
* Return: Success: zero
* Failure: non-zero
*
* Programmer: Quincey Koziol
* Programmer: Quincey Koziol
* Tuesday, May 13, 2003
*
* Modifications:
@ -239,7 +238,7 @@ error:
static int
test_dangle_datatype1(H5F_close_degree_t degree)
{
char filename[1024];
char filename[1024];
hid_t fid; /* File ID */
hid_t fapl; /* File access property list */
hid_t tid; /* Datatype ID */
@ -315,17 +314,17 @@ error:
return 1;
}
/*-------------------------------------------------------------------------
* Function: test_dangle_datatype2
* Function: test_dangle_datatype2
*
* Purpose: Check for dangling datatype IDs causing problems on library
* Purpose: Check for dangling datatype IDs causing problems on library
* shutdown
*
* Return: Success: zero
* Failure: non-zero
* Return: Success: zero
* Failure: non-zero
*
* Programmer: Quincey Koziol
* Programmer: Quincey Koziol
* Thursday, August 25, 2005
*
* Modifications:
@ -335,7 +334,7 @@ error:
static int
test_dangle_datatype2(H5F_close_degree_t degree)
{
char filename[1024];
char filename[1024];
hid_t fid; /* File ID */
hid_t fapl; /* File access property list */
hid_t did; /* Dataset ID */
@ -402,17 +401,17 @@ error:
return 1;
}
/*-------------------------------------------------------------------------
* Function: test_dangle_attribute
* Function: test_dangle_attribute
*
* Purpose: Check for dangling attribute IDs causing problems on library
* Purpose: Check for dangling attribute IDs causing problems on library
* shutdown
*
* Return: Success: zero
* Failure: non-zero
* Return: Success: zero
* Failure: non-zero
*
* Programmer: Quincey Koziol
* Programmer: Quincey Koziol
* Wednesday, June 18, 2003
*
* Modifications:
@ -422,7 +421,7 @@ error:
static int
test_dangle_attribute(H5F_close_degree_t degree)
{
char filename[1024];
char filename[1024];
hid_t fid; /* File ID */
hid_t fapl; /* File access property list */
hid_t dsid; /* Dataset ID */
@ -509,17 +508,17 @@ error:
return 1;
}
/*-------------------------------------------------------------------------
* Function: test_dangle_force
* Function: test_dangle_force
*
* Purpose: Shut down all danging IDs with generic file & ID routines,
* Purpose: Shut down all danging IDs with generic file & ID routines,
* instead of letting library shut then down.
*
* Return: Success: zero
* Failure: non-zero
* Return: Success: zero
* Failure: non-zero
*
* Programmer: Quincey Koziol
* Programmer: Quincey Koziol
* Friday, October 29, 2010
*
*-------------------------------------------------------------------------
@ -527,7 +526,7 @@ error:
static int
test_dangle_force(void)
{
char filename[1024];
char filename[1024];
hid_t fid; /* File ID */
hid_t gid, gid2; /* Group IDs */
hid_t dsid, dsid2; /* Dataset IDs */
@ -625,7 +624,7 @@ test_dangle_force(void)
/* Release object ID array */
HDfree(objs);
PASSED();
return 0;
@ -635,16 +634,16 @@ error:
return 1;
}
/*-------------------------------------------------------------------------
* Function: main
* Function: main
*
* Purpose: Executes dangling ID tests
* Purpose: Executes dangling ID tests
*
* Return: Success: zero
* Failure: non-zero
* Return: Success: zero
* Failure: non-zero
*
* Programmer: Quincey Koziol
* Programmer: Quincey Koziol
* Tuesday, May 13, 2003
*
* Modifications:
@ -654,7 +653,7 @@ error:
int
main(void)
{
int nerrors=0;
int nerrors=0;
/* Run tests w/weak file close */
puts("Testing dangling objects with weak file close:");

45
test/gen_cross.c
View File

@ -26,7 +26,6 @@
* worth keeping around for now.
*/
#include <stdio.h>
#include "h5test.h"
#define H5FILE_NAME "data.h5"
@ -79,7 +78,7 @@ int create_szip_dsets_float(hid_t fid, hid_t fsid, hid_t msid);
int create_shuffle_dsets_float(hid_t fid, hid_t fsid, hid_t msid);
int create_nbit_dsets_float(hid_t fid, hid_t fsid, hid_t msid);
/*-------------------------------------------------------------------------
* Function: create_normal_dset
*
@ -108,8 +107,8 @@ create_normal_dset(hid_t fid, hid_t fsid, hid_t msid)
* Data and output buffer initialization.
*/
for (j = 0; j < NX; j++) {
for (i = 0; i < NY; i++)
data[j][i] = ((float)(i + j + 1)) / 3;
for (i = 0; i < NY; i++)
data[j][i] = ((float)(i + j + 1)) / 3;
}
/*
* 1/3 2/3 3/3 4/3 5/3 6/3
@ -143,7 +142,7 @@ create_normal_dset(hid_t fid, hid_t fsid, hid_t msid)
if(H5Dwrite(dataset, H5T_NATIVE_FLOAT, msid, fsid, H5P_DEFAULT, data) < 0)
TEST_ERROR
/*
/*
* Close dataset
*/
if(H5Dclose(dataset) < 0)
@ -163,7 +162,7 @@ create_normal_dset(hid_t fid, hid_t fsid, hid_t msid)
if(H5Dwrite(dataset, H5T_NATIVE_FLOAT, msid, fsid, H5P_DEFAULT, data) < 0)
TEST_ERROR
/*
/*
* Close dataset
*/
if(H5Dclose(dataset) < 0)
@ -186,7 +185,7 @@ error:
return -1;
}
/*-------------------------------------------------------------------------
* Function: create_scale_offset_dsets_float
*
@ -277,7 +276,7 @@ error:
return -1;
}
/*-------------------------------------------------------------------------
* Function: create_scale_offset_dsets_double
*
@ -307,8 +306,8 @@ create_scale_offset_dsets_double(hid_t fid, hid_t fsid, hid_t msid)
* Data and output buffer initialization.
*/
for (j = 0; j < NX; j++) {
for (i = 0; i < NY; i++)
data[j][i] = ((double)(i + j + 1))/3;
for (i = 0; i < NY; i++)
data[j][i] = ((double)(i + j + 1))/3;
}
/*
@ -368,7 +367,7 @@ error:
return -1;
}
/*-------------------------------------------------------------------------
* Function: create_scale_offset_dset_char
*
@ -467,7 +466,7 @@ error:
return -1;
}
/*-------------------------------------------------------------------------
* Function: create_scale_offset_dset_short
*
@ -566,7 +565,7 @@ error:
return -1;
}
/*-------------------------------------------------------------------------
* Function: create_scale_offset_dset_int
*
@ -596,8 +595,8 @@ create_scale_offset_dsets_int(hid_t fid, hid_t fsid, hid_t msid)
* Data and output buffer initialization.
*/
for (j = 0; j < NX; j++) {
for (i = 0; i < NY; i++)
data[j][i] = i + j;
for (i = 0; i < NY; i++)
data[j][i] = i + j;
}
/*
* 0 1 2 3 4 5
@ -665,7 +664,7 @@ error:
return -1;
}
/*-------------------------------------------------------------------------
* Function: create_scale_offset_dset_long_long
*
@ -765,7 +764,7 @@ error:
return -1;
}
/*-------------------------------------------------------------------------
* Function: create_fletcher_dsets_float
*
@ -856,7 +855,7 @@ error:
return -1;
}
/*-------------------------------------------------------------------------
* Function: create_deflate_dsets_float
*
@ -957,7 +956,7 @@ error:
}
#ifdef H5_HAVE_FILTER_SZIP
/*-------------------------------------------------------------------------
* Function: create_szip_dsets_float
*
@ -1049,7 +1048,7 @@ error:
}
#endif /* H5_HAVE_FILTER_SZIP */
/*-------------------------------------------------------------------------
* Function: create_shuffle_dsets_float
*
@ -1140,7 +1139,7 @@ error:
return -1;
}
/*-------------------------------------------------------------------------
* Function: create_nbit_dsets_float
*
@ -1225,7 +1224,7 @@ create_nbit_dsets_float(hid_t fid, hid_t fsid, hid_t msid)
TEST_ERROR
/* Now create a dataset with a big-endian type */
if(H5Tset_order(datatype, H5T_ORDER_BE) < 0)
if(H5Tset_order(datatype, H5T_ORDER_BE) < 0)
TEST_ERROR
if((dataset = H5Dcreate2(fid, DATASETNAME23, datatype, fsid,
H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0)
@ -1252,7 +1251,7 @@ error:
return -1;
}
/*-------------------------------------------------------------------------
* Function: main
*

394
test/gheap.c
View File

@ -15,14 +15,12 @@
* Programmer: Robb Matzke <matzke@llnl.gov>
* Tuesday, March 31, 1998
*
* Purpose: Tests the global heap. The global heap is the set of all
* collections but the collections are not related to one
* another by anything that appears in the file format.
* Purpose: Tests the global heap. The global heap is the set of all
* collections but the collections are not related to one
* another by anything that appears in the file format.
*/
#include "h5test.h"
#include "H5private.h"
#include "H5ACprivate.h"
#include "H5Eprivate.h"
#include "H5Fprivate.h"
#include "H5Gprivate.h"
#include "H5HGprivate.h"
@ -56,18 +54,18 @@ const char *FILENAME[] = {
NULL
};
/*-------------------------------------------------------------------------
* Function: test_1
* Function: test_1
*
* Purpose: Writes a sequence of objects to the global heap where each
* object is larger than the one before.
* Purpose: Writes a sequence of objects to the global heap where each
* object is larger than the one before.
*
* Return: Success: 0
* Return: Success: 0
*
* Failure: number of errors
* Failure: number of errors
*
* Programmer: Robb Matzke
* Programmer: Robb Matzke
* Tuesday, March 31, 1998
*
* Modifications:
@ -77,16 +75,16 @@ const char *FILENAME[] = {
static int
test_1 (hid_t fapl)
{
hid_t file = -1;
H5F_t *f = NULL;
H5HG_t *obj = NULL;
uint8_t out[GHEAP_TEST_NOBJS];
uint8_t in[GHEAP_TEST_NOBJS];
size_t u;
size_t size;
herr_t status;
int nerrors = 0;
char filename[1024];
hid_t file = -1;
H5F_t *f = NULL;
H5HG_t *obj = NULL;
uint8_t out[GHEAP_TEST_NOBJS];
uint8_t in[GHEAP_TEST_NOBJS];
size_t u;
size_t size;
herr_t status;
int nerrors = 0;
char filename[1024];
TESTING("monotonically increasing lengths");
@ -97,11 +95,11 @@ test_1 (hid_t fapl)
/* Open a clean file */
h5_fixname(FILENAME[0], fapl, filename, sizeof filename);
if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
goto error;
goto error;
if(NULL == (f = (H5F_t *)H5I_object(file))) {
H5_FAILED();
puts(" Unable to create file");
goto error;
H5_FAILED();
puts(" Unable to create file");
goto error;
}
/*
@ -110,37 +108,37 @@ test_1 (hid_t fapl)
* be monotonically increasing.
*/
for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
size = u + 1;
HDmemset(out, (int)('A' + u % 26), size);
H5Eclear2(H5E_DEFAULT);
status = H5HG_insert(f, H5AC_ind_read_dxpl_id, size, out, obj + u);
if(status < 0) {
H5_FAILED();
puts(" Unable to insert object into global heap");
nerrors++;
} else if(u && H5F_addr_gt(obj[u - 1].addr, obj[u].addr)) {
H5_FAILED();
puts(" Collection addresses are not monotonically increasing");
nerrors++;
}
size = u + 1;
HDmemset(out, (int)('A' + u % 26), size);
H5Eclear2(H5E_DEFAULT);
status = H5HG_insert(f, H5AC_ind_read_dxpl_id, size, out, obj + u);
if(status < 0) {
H5_FAILED();
puts(" Unable to insert object into global heap");
nerrors++;
} else if(u && H5F_addr_gt(obj[u - 1].addr, obj[u].addr)) {
H5_FAILED();
puts(" Collection addresses are not monotonically increasing");
nerrors++;
}
}
/*
* Now try to read each object back.
*/
for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
size = u + 1;
HDmemset(out, (int)('A' + u % 26), size);
H5Eclear2(H5E_DEFAULT);
if(NULL == H5HG_read(f, H5AC_ind_read_dxpl_id, obj + u, in, NULL)) {
H5_FAILED();
puts(" Unable to read object");
nerrors++;
} else if(HDmemcmp(in, out, size)) {
H5_FAILED();
puts(" Value read doesn't match value written");
nerrors++;
}
size = u + 1;
HDmemset(out, (int)('A' + u % 26), size);
H5Eclear2(H5E_DEFAULT);
if(NULL == H5HG_read(f, H5AC_ind_read_dxpl_id, obj + u, in, NULL)) {
H5_FAILED();
puts(" Unable to read object");
nerrors++;
} else if(HDmemcmp(in, out, size)) {
H5_FAILED();
puts(" Value read doesn't match value written");
nerrors++;
}
}
/* Release buffer */
@ -155,25 +153,25 @@ test_1 (hid_t fapl)
error:
H5E_BEGIN_TRY {
H5Fclose(file);
H5Fclose(file);
} H5E_END_TRY;
if(obj)
HDfree(obj);
return MAX(1, nerrors);
}
/*-------------------------------------------------------------------------
* Function: test_2
* Function: test_2
*
* Purpose: Writes a sequence of objects to the global heap where each
* object is smaller than the one before.
* Purpose: Writes a sequence of objects to the global heap where each
* object is smaller than the one before.
*
* Return: Success: 0
* Return: Success: 0
*
* Failure: number of errors
* Failure: number of errors
*
* Programmer: Robb Matzke
* Programmer: Robb Matzke
* Tuesday, March 31, 1998
*
* Modifications:
@ -183,15 +181,15 @@ error:
static int
test_2 (hid_t fapl)
{
hid_t file = -1;
H5F_t *f = NULL;
H5HG_t *obj = NULL;
uint8_t out[GHEAP_TEST_NOBJS];
uint8_t in[GHEAP_TEST_NOBJS];
size_t u;
size_t size;
int nerrors = 0;
char filename[1024];
hid_t file = -1;
H5F_t *f = NULL;
H5HG_t *obj = NULL;
uint8_t out[GHEAP_TEST_NOBJS];
uint8_t in[GHEAP_TEST_NOBJS];
size_t u;
size_t size;
int nerrors = 0;
char filename[1024];
TESTING("monotonically decreasing lengths");
@ -202,43 +200,43 @@ test_2 (hid_t fapl)
/* Open a clean file */
h5_fixname(FILENAME[1], fapl, filename, sizeof filename);
if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
goto error;
goto error;
if(NULL == (f = (H5F_t *)H5I_object(file))) {
H5_FAILED();
puts(" Unable to create file");
goto error;
H5_FAILED();
puts(" Unable to create file");
goto error;
}
/*
* Write the objects, monotonically decreasing in length.
*/
for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
size = GHEAP_TEST_NOBJS - u;
HDmemset(out, (int)('A' + u % 26), size);
H5Eclear2(H5E_DEFAULT);
if (H5HG_insert (f, H5AC_ind_read_dxpl_id, size, out, obj + u) < 0) {
H5_FAILED();
puts(" Unable to insert object into global heap");
nerrors++;
}
size = GHEAP_TEST_NOBJS - u;
HDmemset(out, (int)('A' + u % 26), size);
H5Eclear2(H5E_DEFAULT);
if (H5HG_insert (f, H5AC_ind_read_dxpl_id, size, out, obj + u) < 0) {
H5_FAILED();
puts(" Unable to insert object into global heap");
nerrors++;
}
}
/*
* Now try to read each object back.
*/
for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
size = GHEAP_TEST_NOBJS - u;
HDmemset(out, (int)('A' + u % 26), size);
H5Eclear2(H5E_DEFAULT);
if (NULL==H5HG_read (f, H5AC_ind_read_dxpl_id, obj + u, in, NULL)) {
H5_FAILED();
puts(" Unable to read object");
nerrors++;
} else if (memcmp (in, out, size)) {
H5_FAILED();
puts(" Value read doesn't match value written");
nerrors++;
}
size = GHEAP_TEST_NOBJS - u;
HDmemset(out, (int)('A' + u % 26), size);
H5Eclear2(H5E_DEFAULT);
if (NULL==H5HG_read (f, H5AC_ind_read_dxpl_id, obj + u, in, NULL)) {
H5_FAILED();
puts(" Unable to read object");
nerrors++;
} else if (memcmp (in, out, size)) {
H5_FAILED();
puts(" Value read doesn't match value written");
nerrors++;
}
}
/* Release buffer */
@ -253,25 +251,25 @@ test_2 (hid_t fapl)
error:
H5E_BEGIN_TRY {
H5Fclose(file);
H5Fclose(file);
} H5E_END_TRY;
if(obj)
HDfree(obj);
return MAX(1, nerrors);
}
/*-------------------------------------------------------------------------
* Function: test_3
* Function: test_3
*
* Purpose: Creates a few global heap objects and then removes them all.
* The collection should also be removed.
* Purpose: Creates a few global heap objects and then removes them all.
* The collection should also be removed.
*
* Return: Success: 0
* Return: Success: 0
*
* Failure: number of errors
* Failure: number of errors
*
* Programmer: Robb Matzke
* Programmer: Robb Matzke
* Tuesday, March 31, 1998
*
* Modifications:
@ -281,15 +279,15 @@ test_2 (hid_t fapl)
static int
test_3 (hid_t fapl)
{
hid_t file = -1;
H5F_t *f = NULL;
H5HG_t *obj = NULL;
uint8_t out[GHEAP_TEST_NOBJS];
size_t u;
size_t size;
herr_t status;
int nerrors = 0;
char filename[1024];
hid_t file = -1;
H5F_t *f = NULL;
H5HG_t *obj = NULL;
uint8_t out[GHEAP_TEST_NOBJS];
size_t u;
size_t size;
herr_t status;
int nerrors = 0;
char filename[1024];
TESTING("complete object removal");
@ -300,34 +298,34 @@ test_3 (hid_t fapl)
/* Open a clean file */
h5_fixname(FILENAME[2], fapl, filename, sizeof filename);
if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
goto error;
goto error;
if(NULL == (f = (H5F_t *)H5I_object(file))) {
H5_FAILED();
puts(" Unable to create file");
goto error;
H5_FAILED();
puts(" Unable to create file");
goto error;
}
/* Create some stuff */
for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
size = u % 30 + 100;
HDmemset(out, (int)('A' + u % 26), size);
H5Eclear2(H5E_DEFAULT);
status = H5HG_insert (f, H5AC_ind_read_dxpl_id, size, out, obj + u);
if (status<0) {
H5_FAILED();
puts(" Unable to insert object into global heap");
nerrors++;
}
size = u % 30 + 100;
HDmemset(out, (int)('A' + u % 26), size);
H5Eclear2(H5E_DEFAULT);
status = H5HG_insert (f, H5AC_ind_read_dxpl_id, size, out, obj + u);
if (status<0) {
H5_FAILED();
puts(" Unable to insert object into global heap");
nerrors++;
}
}
/* Remove everything */
for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
status = H5HG_remove (f, H5AC_ind_read_dxpl_id, obj + u);
if (status<0) {
H5_FAILED();
puts(" Unable to remove object");
nerrors++;
}
status = H5HG_remove (f, H5AC_ind_read_dxpl_id, obj + u);
if (status<0) {
H5_FAILED();
puts(" Unable to remove object");
nerrors++;
}
}
/* Release buffer */
@ -342,26 +340,26 @@ test_3 (hid_t fapl)
error:
H5E_BEGIN_TRY {
H5Fclose(file);
H5Fclose(file);
} H5E_END_TRY;
if(obj)
HDfree(obj);
return MAX(1, nerrors);
}
/*-------------------------------------------------------------------------
* Function: test_4
* Function: test_4
*
* Purpose: Tests the H5HG_remove() feature by writing lots of objects
* and occassionally removing some. When we're done they're all
* removed.
* Purpose: Tests the H5HG_remove() feature by writing lots of objects
* and occassionally removing some. When we're done they're all
* removed.
*
* Return: Success: 0
* Return: Success: 0
*
* Failure: number of errors
* Failure: number of errors
*
* Programmer: Robb Matzke
* Programmer: Robb Matzke
* Tuesday, March 31, 1998
*
* Modifications:
@ -371,15 +369,15 @@ test_3 (hid_t fapl)
static int
test_4 (hid_t fapl)
{
hid_t file = -1;
H5F_t *f = NULL;
H5HG_t *obj = NULL;
uint8_t out[GHEAP_TEST_NOBJS];
size_t u;
size_t size;
herr_t status;
int nerrors = 0;
char filename[1024];
hid_t file = -1;
H5F_t *f = NULL;
H5HG_t *obj = NULL;
uint8_t out[GHEAP_TEST_NOBJS];
size_t u;
size_t size;
herr_t status;
int nerrors = 0;
char filename[1024];
TESTING("partial object removal");
@ -390,40 +388,40 @@ test_4 (hid_t fapl)
/* Open a clean file */
h5_fixname(FILENAME[3], fapl, filename, sizeof filename);
if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
goto error;
goto error;
if(NULL == (f = (H5F_t *)H5I_object(file))) {
H5_FAILED();
puts(" Unable to create file");
goto error;
H5_FAILED();
puts(" Unable to create file");
goto error;
}
for(u = 0; u < GHEAP_TEST_NOBJS; u++) {
/* Insert */
size = u % 30 + 100;
HDmemset(out, (int)('A' + u % 26), size);
H5Eclear2(H5E_DEFAULT);
status = H5HG_insert (f, H5AC_ind_read_dxpl_id, size, out, obj + u);
if (status<0) {
H5_FAILED();
puts(" Unable to insert object into global heap");
nerrors++;
}
/* Insert */
size = u % 30 + 100;
HDmemset(out, (int)('A' + u % 26), size);
H5Eclear2(H5E_DEFAULT);
status = H5HG_insert (f, H5AC_ind_read_dxpl_id, size, out, obj + u);
if (status<0) {
H5_FAILED();
puts(" Unable to insert object into global heap");
nerrors++;
}
/*
* Remove every third one beginning with the second, but after the
* next one has already been inserted. That is, insert A, B, C;
* remove B, insert D, E, F; remove E; etc.
*/
if(1 == (u % 3)) {
H5Eclear2(H5E_DEFAULT);
status = H5HG_remove (f, H5AC_ind_read_dxpl_id, obj + u - 1);
if (status<0) {
H5_FAILED();
puts(" Unable to remove object");
nerrors++;
}
HDmemset(obj + u - 1, 0, sizeof *obj);
}
/*
* Remove every third one beginning with the second, but after the
* next one has already been inserted. That is, insert A, B, C;
* remove B, insert D, E, F; remove E; etc.
*/
if(1 == (u % 3)) {
H5Eclear2(H5E_DEFAULT);
status = H5HG_remove (f, H5AC_ind_read_dxpl_id, obj + u - 1);
if (status<0) {
H5_FAILED();
puts(" Unable to remove object");
nerrors++;
}
HDmemset(obj + u - 1, 0, sizeof *obj);
}
}
/* Release buffer */
@ -438,27 +436,27 @@ test_4 (hid_t fapl)
error:
H5E_BEGIN_TRY {
H5Fclose(file);
H5Fclose(file);
} H5E_END_TRY;
if(obj)
HDfree(obj);
return MAX(1, nerrors);
}
/*-------------------------------------------------------------------------
* Function: test_ooo_indices
* Function: test_ooo_indices
*
* Purpose: Tests that indices can be stored out of order. This can
* Purpose: Tests that indices can be stored out of order. This can
* happen when the indices "wrap around" due to many
* insertions and deletions (for example, from rewriting a
* VL dataset).
*
* Return: Success: 0
* Return: Success: 0
*
* Failure: number of errors
* Failure: number of errors
*
* Programmer: Neil Fortner
* Programmer: Neil Fortner
* Monday, October 26, 2009
*
* Modifications:
@ -468,13 +466,13 @@ test_4 (hid_t fapl)
static int
test_ooo_indices(hid_t fapl)
{
hid_t file = -1;
H5F_t *f = NULL;
unsigned i, j;
H5HG_t *obj = NULL;
herr_t status;
int nerrors=0;
char filename[1024];
hid_t file = -1;
H5F_t *f = NULL;
unsigned i, j;
H5HG_t *obj = NULL;
herr_t status;
int nerrors=0;
char filename[1024];
TESTING("out of order indices");
@ -552,24 +550,24 @@ test_ooo_indices(hid_t fapl)
error:
H5E_BEGIN_TRY {
H5Fclose(file);
H5Fclose(file);
} H5E_END_TRY;
if(obj)
HDfree(obj);
return MAX(1, nerrors);
} /* end test_ooo_indices */
/*-------------------------------------------------------------------------
* Function: main
* Function: main
*
* Purpose: Tests global heap.
* Purpose: Tests global heap.
*
* Return: Success: zero
* Return: Success: zero
*
* Failure: non-zero
* Failure: non-zero
*
* Programmer: Robb Matzke
* Programmer: Robb Matzke
* Tuesday, March 31, 1998
*
* Modifications:
@ -579,8 +577,8 @@ test_ooo_indices(hid_t fapl)
int
main (void)
{
int nerrors=0;
hid_t fapl;
int nerrors=0;
hid_t fapl;
h5_reset();
fapl = h5_fileaccess();

5
test/h5test.h
View File

@ -20,8 +20,13 @@
#ifndef _H5TEST_H
#define _H5TEST_H
/*
* Include required headers. This file tests internal library functions,
* so we include the private headers here.
*/
#include "hdf5.h"
#include "H5private.h"
#include "H5Eprivate.h"
/*
* Predefined test verbosity levels.

410
test/hyperslab.c
View File

@ -11,110 +11,108 @@
* help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Programmer: Robb Matzke <matzke@llnl.gov>
* Friday, October 10, 1997
/* Programmer: Robb Matzke <matzke@llnl.gov>
* Friday, October 10, 1997
*
* Purpose: Hyperslab operations are rather complex, so this file
* attempts to test them extensively so we can be relatively
* sure they really work. We only test 1d, 2d, and 3d cases
* because testing general dimensionalities would require us to
* rewrite much of the hyperslab stuff.
* Purpose: Hyperslab operations are rather complex, so this file
* attempts to test them extensively so we can be relatively
* sure they really work. We only test 1d, 2d, and 3d cases
* because testing general dimensionalities would require us to
* rewrite much of the hyperslab stuff.
*/
#include "h5test.h"
#include "H5private.h"
#include "H5Eprivate.h"
#include "H5VMprivate.h"
#define TEST_SMALL 0x0001
#define TEST_MEDIUM 0x0002
#define TEST_SMALL 0x0001
#define TEST_MEDIUM 0x0002
#define VARIABLE_SRC 0
#define VARIABLE_DST 1
#define VARIABLE_BOTH 2
#define VARIABLE_SRC 0
#define VARIABLE_DST 1
#define VARIABLE_BOTH 2
#define ARRAY_FILL_SIZE 4
#define ARRAY_OFFSET_NDIMS 3
/*-------------------------------------------------------------------------
* Function: init_full
* Function: init_full
*
* Purpose: Initialize full array.
* Purpose: Initialize full array.
*
* Return: void
* Return: void
*
* Programmer: Robb Matzke
* Friday, October 10, 1997
* Programmer: Robb Matzke
* Friday, October 10, 1997
*
*-------------------------------------------------------------------------
*/
static unsigned
init_full(uint8_t *array, size_t nx, size_t ny, size_t nz)
{
uint8_t acc = 128;
unsigned total = 0;
size_t i, j, k;
uint8_t acc = 128;
unsigned total = 0;
size_t i, j, k;
for(i = 0; i < nx; i++)
for(j = 0; j < ny; j++)
for(k = 0; k < nz; k++) {
total += acc;
*array = acc;
acc++;
array++;
} /* end for */
for(j = 0; j < ny; j++)
for(k = 0; k < nz; k++) {
total += acc;
*array = acc;
acc++;
array++;
} /* end for */
return total;
} /* end init_full() */
/*-------------------------------------------------------------------------
* Function: print_array
* Function: print_array
*
* Purpose: Prints the values in an array
* Purpose: Prints the values in an array
*
* Return: void
* Return: void
*
* Programmer: Robb Matzke
* Friday, October 10, 1997
* Programmer: Robb Matzke
* Friday, October 10, 1997
*
*-------------------------------------------------------------------------
*/
static void
print_array(uint8_t *array, size_t nx, size_t ny, size_t nz)
{
size_t i, j, k;
size_t i, j, k;
for(i = 0; i < nx; i++) {
if(nz > 1)
printf("i=%lu:\n", (unsigned long)i);
else
printf("%03lu:", (unsigned long)i);
if(nz > 1)
printf("i=%lu:\n", (unsigned long)i);
else
printf("%03lu:", (unsigned long)i);
for(j = 0; j < ny; j++) {
if(nz > 1)
printf("%03lu:", (unsigned long)j);
for(k = 0; k < nz; k++)
printf(" %3d", *array++);
if(nz > 1)
printf("\n");
} /* end for */
printf("\n");
for(j = 0; j < ny; j++) {
if(nz > 1)
printf("%03lu:", (unsigned long)j);
for(k = 0; k < nz; k++)
printf(" %3d", *array++);
if(nz > 1)
printf("\n");
} /* end for */
printf("\n");
} /* end for */
} /* end print_array() */
/*-------------------------------------------------------------------------
* Function: print_ref
* Function: print_ref
*
* Purpose: Prints the reference value
* Purpose: Prints the reference value
*
* Return: Success: 0
* Return: Success: 0
*
* Failure:
* Failure:
*
* Programmer: Robb Matzke
* Friday, October 10, 1997
* Programmer: Robb Matzke
* Friday, October 10, 1997
*
*-------------------------------------------------------------------------
*/
@ -131,37 +129,37 @@ print_ref(size_t nx, size_t ny, size_t nz)
} /* end if */
} /* end print_ref() */
/*-------------------------------------------------------------------------
* Function: test_fill
* Function: test_fill
*
* Purpose: Tests the H5VM_hyper_fill() function.
* Purpose: Tests the H5VM_hyper_fill() function.
*
* Return: Success: SUCCEED
* Return: Success: SUCCEED
*
* Failure: FAIL
* Failure: FAIL
*
* Programmer: Robb Matzke
* Saturday, October 11, 1997
* Programmer: Robb Matzke
* Saturday, October 11, 1997
*
*-------------------------------------------------------------------------
*/
static herr_t
test_fill(size_t nx, size_t ny, size_t nz,
size_t di, size_t dj, size_t dk,
size_t ddx, size_t ddy, size_t ddz)
size_t di, size_t dj, size_t dk,
size_t ddx, size_t ddy, size_t ddz)
{
uint8_t *dst = NULL; /*destination array */
hsize_t hs_size[3]; /*hyperslab size */
hsize_t dst_size[3]; /*destination total size */
uint8_t *dst = NULL; /*destination array */
hsize_t hs_size[3]; /*hyperslab size */
hsize_t dst_size[3]; /*destination total size */
hsize_t dst_offset[3]; /*offset of hyperslab in dest */
unsigned ref_value; /*reference value */
unsigned acc; /*accumulator */
size_t i, j, k, dx, dy, dz; /*counters */
unsigned ref_value; /*reference value */
unsigned acc; /*accumulator */
size_t i, j, k, dx, dy, dz; /*counters */
size_t u, v, w;
unsigned ndims; /*hyperslab dimensionality */
char dim[64], s[256]; /*temp string */
unsigned fill_value; /*fill value */
unsigned ndims; /*hyperslab dimensionality */
char dim[64], s[256]; /*temp string */
unsigned fill_value; /*fill value */
/*
* Dimensionality.
@ -190,7 +188,7 @@ test_fill(size_t nx, size_t ny, size_t nz,
/* Allocate array */
if(NULL == (dst = (uint8_t *)HDcalloc((size_t)1, nx * ny * nz)))
TEST_ERROR
init_full(dst, nx, ny, nz);
for(i = 0; i < nx; i += di) {
@ -279,52 +277,52 @@ error:
return FAIL;
} /* end test_fill() */
/*-------------------------------------------------------------------------
* Function: test_copy
* Function: test_copy
*
* Purpose: Tests H5VM_hyper_copy().
* Purpose: Tests H5VM_hyper_copy().
*
* The NX, NY, and NZ arguments are the size for the source and
* destination arrays. You may pass zero for NZ or for NY and
* NZ to test the 2-d and 1-d cases respectively.
* The NX, NY, and NZ arguments are the size for the source and
* destination arrays. You may pass zero for NZ or for NY and
* NZ to test the 2-d and 1-d cases respectively.
*
* A hyperslab is copied from/to (depending on MODE) various
* places in SRC and DST beginning at 0,0,0 and increasing
* location by DI,DJ,DK in the x, y, and z directions.
* A hyperslab is copied from/to (depending on MODE) various
* places in SRC and DST beginning at 0,0,0 and increasing
* location by DI,DJ,DK in the x, y, and z directions.
*
* For each hyperslab location, various sizes of hyperslabs are
* tried beginning with 1x1x1 and increasing the size in each
* dimension by DDX,DDY,DDZ.
* For each hyperslab location, various sizes of hyperslabs are
* tried beginning with 1x1x1 and increasing the size in each
* dimension by DDX,DDY,DDZ.
*
* Return: Success: SUCCEED
* Return: Success: SUCCEED
*
* Failure: FAIL
* Failure: FAIL
*
* Programmer: Robb Matzke
* Friday, October 10, 1997
* Programmer: Robb Matzke
* Friday, October 10, 1997
*
*-------------------------------------------------------------------------
*/
static herr_t
test_copy(int mode,
size_t nx, size_t ny, size_t nz,
size_t di, size_t dj, size_t dk,
size_t ddx, size_t ddy, size_t ddz)
size_t nx, size_t ny, size_t nz,
size_t di, size_t dj, size_t dk,
size_t ddx, size_t ddy, size_t ddz)
{
uint8_t *src = NULL; /*source array */
uint8_t *dst = NULL; /*destination array */
hsize_t hs_size[3]; /*hyperslab size */
hsize_t dst_size[3]; /*destination total size */
hsize_t src_size[3]; /*source total size */
hsize_t dst_offset[3]; /*offset of hyperslab in dest */
uint8_t *src = NULL; /*source array */
uint8_t *dst = NULL; /*destination array */
hsize_t hs_size[3]; /*hyperslab size */
hsize_t dst_size[3]; /*destination total size */
hsize_t src_size[3]; /*source total size */
hsize_t dst_offset[3]; /*offset of hyperslab in dest */
hsize_t src_offset[3]; /*offset of hyperslab in source */
unsigned ref_value; /*reference value */
unsigned acc; /*accumulator */
hsize_t i, j, k, dx, dy, dz; /*counters */
unsigned ref_value; /*reference value */
unsigned acc; /*accumulator */
hsize_t i, j, k, dx, dy, dz; /*counters */
hsize_t u, v, w;
unsigned ndims; /*hyperslab dimensionality */
char dim[64], s[256]; /*temp string */
unsigned ndims; /*hyperslab dimensionality */
char dim[64], s[256]; /*temp string */
const char *sub;
/*
@ -493,7 +491,7 @@ test_copy(int mode,
(unsigned long)dy,
(unsigned long)dz);
print_ref(nx, ny, nz);
printf("\n Destination array is:\n");
printf("\n Destination array is:\n");
print_array(dst, nx, ny, nz);
} /* end if */
goto error;
@ -535,7 +533,7 @@ test_copy(int mode,
(unsigned long)dy,
(unsigned long)dz);
print_ref(nx, ny, nz);
printf("\n Destination array is:\n");
printf("\n Destination array is:\n");
print_array(dst, nx, ny, nz);
} /* end if */
goto error;
@ -563,38 +561,38 @@ error:
return FAIL;
} /* end test_copy() */
/*-------------------------------------------------------------------------
* Function: test_multifill
* Function: test_multifill
*
* Purpose: Tests the H5VM_stride_copy() function by using it to fill a
* hyperslab by replicating a multi-byte sequence. This might
* be useful to initialize an array of structs with a default
* struct value, or to initialize an array of floating-point
* values with a default bit-pattern.
* Purpose: Tests the H5VM_stride_copy() function by using it to fill a
* hyperslab by replicating a multi-byte sequence. This might
* be useful to initialize an array of structs with a default
* struct value, or to initialize an array of floating-point
* values with a default bit-pattern.
*
* Return: Success: SUCCEED
* Return: Success: SUCCEED
*
* Failure: FAIL
* Failure: FAIL
*
* Programmer: Robb Matzke
* Saturday, October 11, 1997
* Programmer: Robb Matzke
* Saturday, October 11, 1997
*
*-------------------------------------------------------------------------
*/
static herr_t
test_multifill(size_t nx)
{
hsize_t size;
hsize_t src_stride;
hsize_t dst_stride;
char s[64];
hsize_t size;
hsize_t src_stride;
hsize_t dst_stride;
char s[64];
struct a_struct {
int left;
double mid;
int right;
} fill, *src = NULL, *dst = NULL;
hsize_t i, j;
hsize_t i, j;
printf("%-70s", "Testing multi-byte fill value");
fflush(stdout);
@ -615,7 +613,7 @@ test_multifill(size_t nx)
} /* end for */
/*
* Describe the fill value. The zero stride says to read the same thing
* Describe the fill value. The zero stride says to read the same thing
* over and over again.
*/
fill.left = 55555555;
@ -684,32 +682,32 @@ error:
return FAIL;
} /* end test_multifill() */
/*-------------------------------------------------------------------------
* Function: test_endian
* Function: test_endian
*
* Purpose: Tests the H5VM_stride_copy() function by using it to copy an
* array of integers and swap the byte ordering from little
* endian to big endian or vice versa depending on the hardware.
* Purpose: Tests the H5VM_stride_copy() function by using it to copy an
* array of integers and swap the byte ordering from little
* endian to big endian or vice versa depending on the hardware.
*
* Return: Success: SUCCEED
* Return: Success: SUCCEED
*
* Failure: FAIL
* Failure: FAIL
*
* Programmer: Robb Matzke
* Saturday, October 11, 1997
* Programmer: Robb Matzke
* Saturday, October 11, 1997
*
*-------------------------------------------------------------------------
*/
static herr_t
test_endian(size_t nx)
{
uint8_t *src = NULL; /*source array */
uint8_t *dst = NULL; /*destination array */
hssize_t src_stride[2]; /*source strides */
hssize_t dst_stride[2]; /*destination strides */
hsize_t size[2]; /*size vector */
hsize_t i, j;
uint8_t *src = NULL; /*source array */
uint8_t *dst = NULL; /*destination array */
hssize_t src_stride[2]; /*source strides */
hssize_t dst_stride[2]; /*destination strides */
hsize_t size[2]; /*size vector */
hsize_t i, j;
printf("%-70s", "Testing endian conversion by stride");
fflush(stdout);
@ -747,7 +745,7 @@ test_endian(size_t nx)
printf(" i=%lu, j=%lu\n", (unsigned long)i, (unsigned long)j);
printf(" Source array is:\n");
print_array(src, nx, (size_t)4, (size_t)1);
printf("\n Result is:\n");
printf("\n Result is:\n");
print_array(dst, nx, (size_t)4, (size_t)1);
} /* end if */
goto error;
@ -771,31 +769,31 @@ error:
return FAIL;
} /* end test_endian() */
/*-------------------------------------------------------------------------
* Function: test_transpose
* Function: test_transpose
*
* Purpose: Copy a 2d array from here to there and transpose the elements
* as it's copied.
* Purpose: Copy a 2d array from here to there and transpose the elements
* as it's copied.
*
* Return: Success: SUCCEED
* Return: Success: SUCCEED
*
* Failure: FAIL
* Failure: FAIL
*
* Programmer: Robb Matzke
* Saturday, October 11, 1997
* Programmer: Robb Matzke
* Saturday, October 11, 1997
*
*-------------------------------------------------------------------------
*/
static herr_t
test_transpose(size_t nx, size_t ny)
{
int *src = NULL;
int *dst = NULL;
hsize_t src_stride[2], dst_stride[2];
hsize_t size[2];
char s[256];
hsize_t i, j;
int *src = NULL;
int *dst = NULL;
hsize_t src_stride[2], dst_stride[2];
hsize_t size[2];
char s[256];
hsize_t i, j;
sprintf(s, "Testing 2d transpose by stride %4lux%-lud", (unsigned long)nx,
(unsigned long)ny);
@ -843,7 +841,7 @@ test_transpose(size_t nx, size_t ny)
printf(" %6d", src[i * ny + j]);
printf("\n");
} /* end for */
printf("\n Destination is:\n");
printf("\n Destination is:\n");
for (i = 0; i < ny; i++) {
printf("%3lu:", (unsigned long)i);
for(j = 0; j < nx; j++)
@ -872,35 +870,35 @@ error:
return FAIL;
} /* end test_transpose() */
/*-------------------------------------------------------------------------
* Function: test_sub_super
* Function: test_sub_super
*
* Purpose: Tests H5VM_stride_copy() to reduce the resolution of an image
* by copying half the pixels in the X and Y directions. Then
* we use the small image and duplicate every pixel to result in
* a 2x2 square.
* Purpose: Tests H5VM_stride_copy() to reduce the resolution of an image
* by copying half the pixels in the X and Y directions. Then
* we use the small image and duplicate every pixel to result in
* a 2x2 square.
*
* Return: Success: SUCCEED
* Return: Success: SUCCEED
*
* Failure: FAIL
* Failure: FAIL
*
* Programmer: Robb Matzke
* Monday, October 13, 1997
* Programmer: Robb Matzke
* Monday, October 13, 1997
*
*-------------------------------------------------------------------------
*/
static herr_t
test_sub_super(size_t nx, size_t ny)
{
uint8_t *full = NULL; /*original image */
uint8_t *half = NULL; /*image at 1/2 resolution */
uint8_t *twice = NULL; /*2x2 pixels */
hsize_t src_stride[4]; /*source stride info */
hsize_t dst_stride[4]; /*destination stride info */
hsize_t size[4]; /*number of sample points */
hsize_t i, j;
char s[256];
uint8_t *full = NULL; /*original image */
uint8_t *half = NULL; /*image at 1/2 resolution */
uint8_t *twice = NULL; /*2x2 pixels */
hsize_t src_stride[4]; /*source stride info */
hsize_t dst_stride[4]; /*destination stride info */
hsize_t size[4]; /*number of sample points */
hsize_t i, j;
char s[256];
sprintf(s, "Testing image sampling %4lux%-4lu to %4lux%-4lu ",
(unsigned long)(2 * nx), (unsigned long)(2 * ny),
@ -942,7 +940,7 @@ test_sub_super(size_t nx, size_t ny)
(unsigned long)i, (unsigned long)j);
printf(" full is:\n");
print_array(full, 2 * nx, 2 * ny, (size_t)1);
printf("\n half is:\n");
printf("\n half is:\n");
print_array(half, nx, ny, (size_t)1);
} /* end if */
goto error;
@ -1005,7 +1003,7 @@ test_sub_super(size_t nx, size_t ny)
AT();
printf(" %s\n Half is:\n", s);
print_array(half, nx, ny, (size_t)1);
printf("\n Twice is:\n");
printf("\n Twice is:\n");
print_array(twice, 2 * nx, 2 * ny, (size_t)1);
} /* end if */
goto error;
@ -1032,20 +1030,20 @@ error:
return FAIL;
} /* test_sub_super() */
/*-------------------------------------------------------------------------
* Function: test_array_fill
* Function: test_array_fill
*
* Purpose: Tests H5VM_array_fill routine by copying a multibyte value
* Purpose: Tests H5VM_array_fill routine by copying a multibyte value
* (an array of ints, in our case) into all the elements of an
* array.
*
* Return: Success: SUCCEED
* Return: Success: SUCCEED
*
* Failure: FAIL
* Failure: FAIL
*
* Programmer: Quincey Koziol
* Monday, April 21, 2003
* Programmer: Quincey Koziol
* Monday, April 21, 2003
*
*-------------------------------------------------------------------------
*/
@ -1054,8 +1052,8 @@ test_array_fill(size_t lo, size_t hi)
{
int *dst = NULL; /* Destination */
int src[ARRAY_FILL_SIZE]; /* Source to duplicate */
size_t u, v, w; /* Local index variables */
char s[256];
size_t u, v, w; /* Local index variables */
char s[256];
sprintf(s, "array filling %4lu-%-4lu elements", (unsigned long)lo,(unsigned long)hi);
TESTING(s);
@ -1093,20 +1091,20 @@ error:
return FAIL;
} /* end test_array_fill() */
/*-------------------------------------------------------------------------
* Function: test_array_offset_n_calc
* Function: test_array_offset_n_calc
*
* Purpose: Tests H5VM_array_offset and H5VM_array_calc routines by comparing
* Purpose: Tests H5VM_array_offset and H5VM_array_calc routines by comparing
* computed array offsets against calculated ones and then going
* back to the coordinates from the offset and checking those.
*
* Return: Success: SUCCEED
* Return: Success: SUCCEED
*
* Failure: FAIL
* Failure: FAIL
*
* Programmer: Quincey Koziol
* Monday, April 21, 2003
* Programmer: Quincey Koziol
* Monday, April 21, 2003
*
*-------------------------------------------------------------------------
*/
@ -1116,11 +1114,11 @@ test_array_offset_n_calc(size_t n, size_t x, size_t y, size_t z)
hsize_t *a = NULL;
hsize_t *temp_a; /* Array for stored calculated offsets */
hsize_t off; /* Offset in array */
size_t u, v, w; /* Local index variables */
size_t u, v, w; /* Local index variables */
hsize_t dims[ARRAY_OFFSET_NDIMS]; /* X, Y & X coordinates of array to check */
hsize_t coords[ARRAY_OFFSET_NDIMS]; /* X, Y & X coordinates to check offset of */
hsize_t new_coords[ARRAY_OFFSET_NDIMS]; /* X, Y & X coordinates of offset */
char s[256];
char s[256];
sprintf(s, "array offset %4lux%4lux%4lu elements", (unsigned long)z,(unsigned long)y,(unsigned long)x);
TESTING(s);
@ -1178,29 +1176,29 @@ error:
return FAIL;
} /* end test_array_offset_n_calc() */
/*-------------------------------------------------------------------------
* Function: main
* Function: main
*
* Purpose: Test various hyperslab operations. Give the words
* `small' and/or `medium' on the command line or only `small'
* is assumed.
* Purpose: Test various hyperslab operations. Give the words
* `small' and/or `medium' on the command line or only `small'
* is assumed.
*
* Return: Success: exit(EXIT_SUCCESS)
* Return: Success: exit(EXIT_SUCCESS)
*
* Failure: exit(EXIT_FAILURE)
* Failure: exit(EXIT_FAILURE)
*
* Programmer: Robb Matzke
* Friday, October 10, 1997
* Programmer: Robb Matzke
* Friday, October 10, 1997
*
*-------------------------------------------------------------------------
*/
int
main(int argc, char *argv[])
{
herr_t status;
int nerrors = 0;
unsigned size_of_test;
herr_t status;
int nerrors = 0;
unsigned size_of_test;
/* Parse arguments or assume `small' & `medium' */
if(1 == argc)

494
test/istore.c
View File

@ -11,24 +11,22 @@
* help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Programmer: Robb Matzke <matzke@llnl.gov>
* Wednesday, October 15, 1997
/* Programmer: Robb Matzke <matzke@llnl.gov>
* Wednesday, October 15, 1997
*
* Purpose: Tests various aspects of indexed raw data storage.
* Purpose: Tests various aspects of indexed raw data storage.
*/
#define H5F_FRIEND /*suppress error about including H5Fpkg */
#define H5F_FRIEND /*suppress error about including H5Fpkg */
#include "h5test.h"
#include "H5private.h"
#include "H5Dprivate.h"
#include "H5Eprivate.h"
#include "H5Iprivate.h"
#include "H5Pprivate.h"
#include "H5Fpkg.h"
#include "H5Gprivate.h"
#include "H5Oprivate.h"
#include "H5Pprivate.h"
#include "H5VMprivate.h"
const char *FILENAME[] = {
@ -37,9 +35,9 @@ const char *FILENAME[] = {
};
#define TEST_SMALL 0x0001
#define TEST_MEDIUM 0x0002
#define TEST_LARGE 0x0004
#define TEST_SMALL 0x0001
#define TEST_MEDIUM 0x0002
#define TEST_LARGE 0x0004
/* The datatype of the dataset operated on by this test */
#define TEST_DATATYPE H5T_NATIVE_UCHAR
@ -50,19 +48,19 @@ const char *FILENAME[] = {
hsize_t chunk_dims[H5O_LAYOUT_NDIMS];
hsize_t zero[H5O_LAYOUT_NDIMS];
/*-------------------------------------------------------------------------
* Function: is_sparse
* Function: is_sparse
*
* Purpose: Determines if the file system of the current working
* directory supports holes.
* Purpose: Determines if the file system of the current working
* directory supports holes.
*
* Return: Success: Non-zero if holes are supported; zero
* otherwise.
* Return: Success: Non-zero if holes are supported; zero
* otherwise.
*
* Failure: zero
* Failure: zero
*
* Programmer: Robb Matzke
* Programmer: Robb Matzke
* Wednesday, July 15, 1998
*
*-------------------------------------------------------------------------
@ -70,8 +68,8 @@ hsize_t zero[H5O_LAYOUT_NDIMS];
static int
is_sparse(void)
{
int fd;
h5_stat_t sb;
int fd;
h5_stat_t sb;
if ((fd = HDopen("x.h5", O_RDWR|O_TRUNC|O_CREAT, H5_POSIX_CREATE_MODE_RW)) < 0) return 0;
if (HDlseek(fd, (off_t)(1024*1024), SEEK_SET)!=1024*1024) return 0;
@ -86,16 +84,16 @@ is_sparse(void)
#endif
}
/*-------------------------------------------------------------------------
* Function: print_array
* Function: print_array
*
* Purpose: Prints the values in an array
* Purpose: Prints the values in an array
*
* Return: void
* Return: void
*
* Programmer: Robb Matzke
* Friday, October 10, 1997
* Programmer: Robb Matzke
* Friday, October 10, 1997
*
* Modifications:
*
@ -104,41 +102,41 @@ is_sparse(void)
static void
print_array(uint8_t *array, size_t nx, size_t ny, size_t nz)
{
size_t i, j, k;
size_t i, j, k;
for (i = 0; i < nx; i++) {
if (nz > 1) {
fprintf(stderr,"i=%lu:\n", (unsigned long)i);
} else {
fprintf(stderr,"%03lu:", (unsigned long)i);
}
if (nz > 1) {
fprintf(stderr,"i=%lu:\n", (unsigned long)i);
} else {
fprintf(stderr,"%03lu:", (unsigned long)i);
}
for (j = 0; j < ny; j++) {
if (nz > 1)
fprintf(stderr,"%03lu:", (unsigned long)j);
for (k = 0; k < nz; k++) {
fprintf(stderr," %3d", *array++);
}
if (nz > 1)
fprintf(stderr,"\n");
}
fprintf(stderr,"\n");
for (j = 0; j < ny; j++) {
if (nz > 1)
fprintf(stderr,"%03lu:", (unsigned long)j);
for (k = 0; k < nz; k++) {
fprintf(stderr," %3d", *array++);
}
if (nz > 1)
fprintf(stderr,"\n");
}
fprintf(stderr,"\n");
}
}
/*-------------------------------------------------------------------------
* Function: new_object
* Function: new_object
*
* Purpose: Creates a new object that refers to a indexed storage of raw
* data. No raw data is stored.
* Purpose: Creates a new object that refers to a indexed storage of raw
* data. No raw data is stored.
*
* Return: Success: ID of dataset
* Return: Success: ID of dataset
*
* Failure: -1
* Failure: -1
*
* Programmer: Robb Matzke
* Wednesday, October 15, 1997
* Programmer: Robb Matzke
* Wednesday, October 15, 1997
*
* Modifications:
* Converted to use datasets instead of directly messing with
@ -182,19 +180,19 @@ error:
return -1;
}
/*-------------------------------------------------------------------------
* Function: test_create
* Function: test_create
*
* Purpose: Creates a named object that refers to indexed storage of raw
* data. No raw data is stored.
* Purpose: Creates a named object that refers to indexed storage of raw
* data. No raw data is stored.
*
* Return: Success: SUCCEED
* Return: Success: SUCCEED
*
* Failure: FAIL
* Failure: FAIL
*
* Programmer: Robb Matzke
* Wednesday, October 15, 1997
* Programmer: Robb Matzke
* Wednesday, October 15, 1997
*
* Modifications:
*
@ -217,9 +215,9 @@ test_create(hid_t f, const char *prefix)
dims[u] = my_chunk_dims[u] = 2;
/* Create chunked dataset of this dimensionality */
HDsnprintf(name, sizeof name, "%s_%02u", prefix, u);
if ((dataset=new_object(f, name, (int)u, dims, my_chunk_dims)) < 0)
return FAIL;
HDsnprintf(name, sizeof name, "%s_%02u", prefix, u);
if ((dataset=new_object(f, name, (int)u, dims, my_chunk_dims)) < 0)
return FAIL;
/* Close dataset created */
if(H5Dclose(dataset) < 0)
@ -230,20 +228,20 @@ test_create(hid_t f, const char *prefix)
return SUCCEED;
}
/*-------------------------------------------------------------------------
* Function: test_extend
* Function: test_extend
*
* Purpose: Creates an empty object and then writes to it in such a way
* as to always extend the object's domain without creating
* holes and without causing the object to become concave.
* Purpose: Creates an empty object and then writes to it in such a way
* as to always extend the object's domain without creating
* holes and without causing the object to become concave.
*
* Return: Success: SUCCEED
* Return: Success: SUCCEED
*
* Failure: FAIL
* Failure: FAIL
*
* Programmer: Robb Matzke
* Wednesday, October 15, 1997
* Programmer: Robb Matzke
* Wednesday, October 15, 1997
*
* Modifications:
*
@ -251,35 +249,35 @@ test_create(hid_t f, const char *prefix)
*/
static herr_t
test_extend(hid_t f, const char *prefix,
size_t nx, size_t ny, size_t nz)
size_t nx, size_t ny, size_t nz)
{
hid_t dataset; /* Dataset ID */
hid_t fspace; /* Dataset's file dataspace */
hid_t mspace; /* Dataset's memory dataspace */
size_t i, j, k, ctr;
int ndims;
uint8_t *buf = NULL, *check = NULL, *whole = NULL;
char dims[64], s[256], name[256];
hsize_t offset[3];
hsize_t max_corner[3];
hsize_t size[3];
hsize_t whole_size[3];
hsize_t nelmts;
size_t i, j, k, ctr;
int ndims;
uint8_t *buf = NULL, *check = NULL, *whole = NULL;
char dims[64], s[256], name[256];
hsize_t offset[3];
hsize_t max_corner[3];
hsize_t size[3];
hsize_t whole_size[3];
hsize_t nelmts;
if (!nz) {
if (!ny) {
ndims = 1;
ny = nz = 1;
sprintf(dims, "%lu", (unsigned long) nx);
} else {
ndims = 2;
nz = 1;
sprintf(dims, "%lux%lu", (unsigned long) nx, (unsigned long) ny);
}
if (!ny) {
ndims = 1;
ny = nz = 1;
sprintf(dims, "%lu", (unsigned long) nx);
} else {
ndims = 3;
sprintf(dims, "%lux%lux%lu",
(unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
ndims = 2;
nz = 1;
sprintf(dims, "%lux%lu", (unsigned long) nx, (unsigned long) ny);
}
} else {
ndims = 3;
sprintf(dims, "%lux%lux%lu",
(unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
}
sprintf(s, "istore extend: %s", dims);
@ -298,57 +296,57 @@ test_extend(hid_t f, const char *prefix,
/* Build the new empty object */
sprintf(name, "%s_%s", prefix, dims);
if ((dataset=new_object(f, name, ndims, whole_size, whole_size)) < 0) {
fprintf(stderr," Cannot create %u-d object `%s'\n", ndims, name);
goto error;
fprintf(stderr," Cannot create %u-d object `%s'\n", ndims, name);
goto error;
}
/* Get dataset's dataspace */
if((fspace=H5Dget_space(dataset)) < 0) TEST_ERROR;
for (ctr = 0;
H5VM_vector_lt_u((unsigned)ndims, max_corner, whole_size);
ctr++) {
H5VM_vector_lt_u((unsigned)ndims, max_corner, whole_size);
ctr++) {
/* Size and location */
if (0 == ctr) {
offset[0] = offset[1] = offset[2] = 0;
size[0] = size[1] = size[2] = 1;
nelmts = 1;
} else {
for (i=0, nelmts=1; i<(size_t)ndims; i++) {
if (ctr % (size_t)ndims == i) {
offset[i] = max_corner[i];
size[i] = MIN(1, whole_size[i] - offset[i]);
} else {
offset[i] = 0;
size[i] = max_corner[i];
}
nelmts *= size[i];
}
}
/* Size and location */
if (0 == ctr) {
offset[0] = offset[1] = offset[2] = 0;
size[0] = size[1] = size[2] = 1;
nelmts = 1;
} else {
for (i=0, nelmts=1; i<(size_t)ndims; i++) {
if (ctr % (size_t)ndims == i) {
offset[i] = max_corner[i];
size[i] = MIN(1, whole_size[i] - offset[i]);
} else {
offset[i] = 0;
size[i] = max_corner[i];
}
nelmts *= size[i];
}
}
#if 0
if (0 == ctr)
fprintf(stderr,"\n");
fprintf(stderr," Insert: ctr=%lu, corner=(%ld", (unsigned long)ctr, (long)offset[0]);
if (ndims > 1)
fprintf(stderr,",%ld", (long)offset[1]);
if (ndims > 2)
fprintf(stderr,",%ld", (long)offset[2]);
fprintf(stderr,"), size=(%lu", (unsigned long)size[0]);
if (ndims > 1)
fprintf(stderr,",%lu", (unsigned long)size[1]);
if (ndims > 2)
fprintf(stderr,",%lu", (unsigned long)size[2]);
fprintf(stderr,"), %lu element%s", (unsigned long)nelmts, 1 == nelmts ? "" : "s");
if (0 == nelmts)
fprintf(stderr," *SKIPPED*");
fprintf(stderr,"\n");
if (0 == ctr)
fprintf(stderr,"\n");
fprintf(stderr," Insert: ctr=%lu, corner=(%ld", (unsigned long)ctr, (long)offset[0]);
if (ndims > 1)
fprintf(stderr,",%ld", (long)offset[1]);
if (ndims > 2)
fprintf(stderr,",%ld", (long)offset[2]);
fprintf(stderr,"), size=(%lu", (unsigned long)size[0]);
if (ndims > 1)
fprintf(stderr,",%lu", (unsigned long)size[1]);
if (ndims > 2)
fprintf(stderr,",%lu", (unsigned long)size[2]);
fprintf(stderr,"), %lu element%s", (unsigned long)nelmts, 1 == nelmts ? "" : "s");
if (0 == nelmts)
fprintf(stderr," *SKIPPED*");
fprintf(stderr,"\n");
#endif
/* Fill the source array */
if (0 == nelmts) continue;
HDmemset(buf, (signed)(128+ctr), (size_t)nelmts);
/* Fill the source array */
if (0 == nelmts) continue;
HDmemset(buf, (signed)(128+ctr), (size_t)nelmts);
/* Create dataspace for selection in memory */
if((mspace=H5Screate_simple(1,&nelmts,NULL)) < 0) TEST_ERROR;
@ -356,72 +354,72 @@ test_extend(hid_t f, const char *prefix,
/* Select region in file dataspace */
if(H5Sselect_hyperslab(fspace,H5S_SELECT_SET,offset,NULL,size,NULL) < 0) TEST_ERROR;
/* Write to disk */
if (H5Dwrite(dataset, TEST_DATATYPE, mspace, fspace, H5P_DEFAULT, buf) < 0) {
H5_FAILED();
fprintf(stderr," Write failed: ctr=%lu\n", (unsigned long)ctr);
goto error;
}
/* Write to disk */
if (H5Dwrite(dataset, TEST_DATATYPE, mspace, fspace, H5P_DEFAULT, buf) < 0) {
H5_FAILED();
fprintf(stderr," Write failed: ctr=%lu\n", (unsigned long)ctr);
goto error;
}
/* Read from disk */
HDmemset(check, 0xff, (size_t)nelmts);
if (H5Dread(dataset, TEST_DATATYPE, mspace, fspace, H5P_DEFAULT, check) < 0) {
H5_FAILED();
fprintf(stderr," Read failed: ctr=%lu\n", (unsigned long)ctr);
goto error;
}
if (HDmemcmp(buf, check, (size_t)nelmts)) {
H5_FAILED();
fprintf(stderr," Read check failed: ctr=%lu\n", (unsigned long)ctr);
fprintf(stderr," Wrote:\n");
print_array(buf, (size_t)size[0], (size_t)size[1],
(size_t)size[2]);
fprintf(stderr," Read:\n");
print_array(check, (size_t)size[0], (size_t)size[1],
(size_t)size[2]);
goto error;
}
/* Read from disk */
HDmemset(check, 0xff, (size_t)nelmts);
if (H5Dread(dataset, TEST_DATATYPE, mspace, fspace, H5P_DEFAULT, check) < 0) {
H5_FAILED();
fprintf(stderr," Read failed: ctr=%lu\n", (unsigned long)ctr);
goto error;
}
if (HDmemcmp(buf, check, (size_t)nelmts)) {
H5_FAILED();
fprintf(stderr," Read check failed: ctr=%lu\n", (unsigned long)ctr);
fprintf(stderr," Wrote:\n");
print_array(buf, (size_t)size[0], (size_t)size[1],
(size_t)size[2]);
fprintf(stderr," Read:\n");
print_array(check, (size_t)size[0], (size_t)size[1],
(size_t)size[2]);
goto error;
}
/* Close memory dataspace */
if(H5Sclose(mspace) < 0) TEST_ERROR;
/* Write to `whole' buffer for later checking */
H5VM_hyper_copy((unsigned)ndims, size,
whole_size, offset, whole, /*dst*/
size, H5VM_ZERO, buf); /*src*/
/* Write to `whole' buffer for later checking */
H5VM_hyper_copy((unsigned)ndims, size,
whole_size, offset, whole, /*dst*/
size, H5VM_ZERO, buf); /*src*/
/* Update max corner */
for (i=0; i<(size_t)ndims; i++)
max_corner[i] = MAX(max_corner[i], offset[i]+size[i]);
/* Update max corner */
for (i=0; i<(size_t)ndims; i++)
max_corner[i] = MAX(max_corner[i], offset[i]+size[i]);
}
/* Now read the entire array back out and check it */
HDmemset(buf, 0xff, nx * ny * nz);
if (H5Dread(dataset, TEST_DATATYPE, H5S_ALL, H5S_ALL, H5P_DEFAULT, buf) < 0) {
H5_FAILED();
fprintf(stderr," Read failed for whole array.\n");
goto error;
H5_FAILED();
fprintf(stderr," Read failed for whole array.\n");
goto error;
}
for (i=0; i<nx; i++) {
for (j=0; j<ny; j++) {
for (k=0; k<nz; k++) {
if (whole[i*ny*nz + j*nz + k] != buf[i*ny*nz + j*nz + k]) {
H5_FAILED();
fprintf(stderr," Check failed at i=%lu", (unsigned long)i);
if (ndims > 1) {
fprintf(stderr,", j=%lu", (unsigned long)j);
}
if (ndims > 2) {
fprintf(stderr,", k=%lu", (unsigned long)k);
}
fprintf(stderr,"\n Check array is:\n");
print_array(whole, nx, ny, nz);
fprintf(stderr," Value read is:\n");
print_array(buf, nx, ny, nz);
goto error;
}
}
}
for (j=0; j<ny; j++) {
for (k=0; k<nz; k++) {
if (whole[i*ny*nz + j*nz + k] != buf[i*ny*nz + j*nz + k]) {
H5_FAILED();
fprintf(stderr," Check failed at i=%lu", (unsigned long)i);
if (ndims > 1) {
fprintf(stderr,", j=%lu", (unsigned long)j);
}
if (ndims > 2) {
fprintf(stderr,", k=%lu", (unsigned long)k);
}
fprintf(stderr,"\n Check array is:\n");
print_array(whole, nx, ny, nz);
fprintf(stderr," Value read is:\n");
print_array(buf, nx, ny, nz);
goto error;
}
}
}
}
/* Close dataset's dataspace */
@ -445,19 +443,19 @@ error:
return FAIL;
}
/*-------------------------------------------------------------------------
* Function: test_sparse
* Function: test_sparse
*
* Purpose: Creates a sparse matrix consisting of NBLOCKS randomly placed
* blocks each of size NX,NY,NZ.
* Purpose: Creates a sparse matrix consisting of NBLOCKS randomly placed
* blocks each of size NX,NY,NZ.
*
* Return: Success: SUCCEED
* Return: Success: SUCCEED
*
* Failure: FAIL
* Failure: FAIL
*
* Programmer: Robb Matzke
* Wednesday, October 22, 1997
* Programmer: Robb Matzke
* Wednesday, October 22, 1997
*
* Modifications:
*
@ -465,34 +463,34 @@ error:
*/
static herr_t
test_sparse(hid_t f, const char *prefix, size_t nblocks,
size_t nx, size_t ny, size_t nz, int skip_test)
size_t nx, size_t ny, size_t nz, int skip_test)
{
hid_t dataset; /* Dataset ID */
hid_t fspace; /* Dataset's file dataspace */
hid_t mspace; /* Dataset's memory dataspace */
int ndims;
hsize_t ctr;
char dims[64], s[256], name[256];
hsize_t offset[3];
hsize_t size[3], total = 0;
uint8_t *buf = NULL;
hsize_t whole_size[3]; /* Size of dataset's dataspace */
int ndims;
hsize_t ctr;
char dims[64], s[256], name[256];
hsize_t offset[3];
hsize_t size[3], total = 0;
uint8_t *buf = NULL;
hsize_t whole_size[3]; /* Size of dataset's dataspace */
size_t u; /* Local index variable */
if (!nz) {
if (!ny) {
ndims = 1;
ny = nz = 1;
sprintf(dims, "%lu", (unsigned long) nx);
} else {
ndims = 2;
nz = 1;
sprintf(dims, "%lux%lu", (unsigned long) nx, (unsigned long) ny);
}
if (!ny) {
ndims = 1;
ny = nz = 1;
sprintf(dims, "%lu", (unsigned long) nx);
} else {
ndims = 3;
sprintf(dims, "%lux%lux%lu",
(unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
ndims = 2;
nz = 1;
sprintf(dims, "%lux%lu", (unsigned long) nx, (unsigned long) ny);
}
} else {
ndims = 3;
sprintf(dims, "%lux%lux%lu",
(unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
}
sprintf(s, "istore sparse: %s", dims);
@ -516,8 +514,8 @@ test_sparse(hid_t f, const char *prefix, size_t nblocks,
/* Build the new empty object */
sprintf(name, "%s_%s", prefix, dims);
if ((dataset=new_object(f, name, ndims, whole_size, chunk_dims)) < 0) {
printf(" Cannot create %u-d object `%s'\n", ndims, name);
goto error;
printf(" Cannot create %u-d object `%s'\n", ndims, name);
goto error;
}
/* Get dataset's dataspace */
@ -534,29 +532,29 @@ test_sparse(hid_t f, const char *prefix, size_t nblocks,
/* Select region in file dataspace */
if(H5Sselect_hyperslab(fspace,H5S_SELECT_SET,offset,NULL,size,NULL) < 0) TEST_ERROR;
/* write to disk */
if (H5Dwrite(dataset, TEST_DATATYPE, mspace, fspace, H5P_DEFAULT, buf) < 0) {
H5_FAILED();
printf(" Write failed: ctr=%lu\n", (unsigned long)ctr);
printf(" offset=(%lu", (unsigned long) (offset[0]));
if (ndims > 1)
printf(",%lu", (unsigned long) (offset[1]));
if (ndims > 2)
printf(",%lu", (unsigned long) (offset[2]));
printf("), size=(%lu", (unsigned long) (size[0]));
if (ndims > 1)
printf(",%lu", (unsigned long) (size[1]));
if (ndims > 2)
printf(",%lu", (unsigned long) (size[2]));
printf(")\n");
goto error;
}
total += nx * ny * nz;
/* write to disk */
if (H5Dwrite(dataset, TEST_DATATYPE, mspace, fspace, H5P_DEFAULT, buf) < 0) {
H5_FAILED();
printf(" Write failed: ctr=%lu\n", (unsigned long)ctr);
printf(" offset=(%lu", (unsigned long) (offset[0]));
if (ndims > 1)
printf(",%lu", (unsigned long) (offset[1]));
if (ndims > 2)
printf(",%lu", (unsigned long) (offset[2]));
printf("), size=(%lu", (unsigned long) (size[0]));
if (ndims > 1)
printf(",%lu", (unsigned long) (size[1]));
if (ndims > 2)
printf(",%lu", (unsigned long) (size[2]));
printf(")\n");
goto error;
}
total += nx * ny * nz;
#if 0
HDfprintf(stderr,"ctr: ctr=%Zu, total=%Zu\n", ctr, total);
HDfprintf(stderr,"ctr: ctr=%Zu, total=%Zu\n", ctr, total);
#endif
/* We don't test reading yet.... */
/* We don't test reading yet.... */
}
/* Close memory dataspace */
@ -577,18 +575,18 @@ error:
return FAIL;
}
/*-------------------------------------------------------------------------
* Function: main
* Function: main
*
* Purpose: Tests indexed storage stuff.
* Purpose: Tests indexed storage stuff.
*
* Return: Success: exit(EXIT_SUCCESS)
* Return: Success: exit(EXIT_SUCCESS)
*
* Failure: exit(EXIT_FAILURE)
* Failure: exit(EXIT_FAILURE)
*
* Programmer: Robb Matzke
* Wednesday, October 15, 1997
* Programmer: Robb Matzke
* Wednesday, October 15, 1997
*
* Modifications:
*
@ -597,12 +595,12 @@ error:
int
main(int argc, char *argv[])
{
hid_t fapl=-1, file=-1, fcpl=-1;
herr_t status;
int nerrors = 0;
unsigned size_of_test;
hid_t fapl=-1, file=-1, fcpl=-1;
herr_t status;
int nerrors = 0;
unsigned size_of_test;
unsigned u; /* Local index variable */
char filename[1024];
char filename[1024];
int skip_test = 0;
int has_sparse_support = 0;
@ -610,7 +608,7 @@ main(int argc, char *argv[])
if (1 == argc) {
size_of_test = TEST_SMALL | TEST_MEDIUM | TEST_LARGE;
} else {
int i;
int i;
for (i = 1, size_of_test = 0; i < argc; i++) {
if (!strcmp(argv[i], "small")) {
size_of_test |= TEST_SMALL;

1
test/swmr.c
View File

@ -24,7 +24,6 @@
*
*************************************************************/
#include "hdf5.h"
#include "h5test.h"
#include "H5Iprivate.h"

96
test/tattr.c
View File

@ -20,8 +20,6 @@
*************************************************************/
#include "testhdf5.h"
#include "h5test.h"
#include "hdf5.h"
/*
* This file needs to access private information from the H5O package.
@ -153,7 +151,7 @@ static herr_t attr_op1(hid_t loc_id, const char *name, const H5A_info_t *ainfo,
void *op_data);
/****************************************************************
**
** test_attr_basic_write(): Test basic H5A (attribute) code.
@ -393,7 +391,7 @@ test_attr_basic_write(hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_basic_write() */
/****************************************************************
**
** test_attr_basic_read(): Test basic H5A (attribute) code.
@ -484,7 +482,7 @@ test_attr_basic_read(hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_basic_read() */
/****************************************************************
**
** test_attr_flush(): Test H5A (attribute) code for performing
@ -551,7 +549,7 @@ test_attr_flush(hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_flush() */
/****************************************************************
**
** test_attr_plist(): Test Attribute Creation Property Lists
@ -664,7 +662,7 @@ test_attr_plist(hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_plist() */
/****************************************************************
**
** test_attr_compound_write(): Test H5A (attribute) code.
@ -753,7 +751,7 @@ test_attr_compound_write(hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_compound_write() */
/****************************************************************
**
** test_attr_compound_read(): Test basic H5A (attribute) code.
@ -903,7 +901,7 @@ test_attr_compound_read(hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_compound_read() */
/****************************************************************
**
** test_attr_scalar_write(): Test scalar H5A (attribute) writing code.
@ -969,7 +967,7 @@ test_attr_scalar_write(hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_scalar_write() */
/****************************************************************
**
** test_attr_scalar_read(): Test scalar H5A (attribute) reading code.
@ -1040,7 +1038,7 @@ test_attr_scalar_read(hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_scalar_read() */
/****************************************************************
**
** test_attr_mult_write(): Test basic H5A (attribute) code.
@ -1161,7 +1159,7 @@ test_attr_mult_write(hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_mult_write() */
/****************************************************************
**
** test_attr_mult_read(): Test basic H5A (attribute) code.
@ -1383,7 +1381,7 @@ test_attr_mult_read(hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_mult_read() */
/****************************************************************
**
** attr_op1(): Attribute operator
@ -1423,7 +1421,7 @@ attr_op1(hid_t H5_ATTR_UNUSED loc_id, const char *name, const H5A_info_t H5_ATTR
return(ret);
} /* end attr_op1() */
/****************************************************************
**
** test_attr_iterate(): Test H5A (attribute) iterator code.
@ -1495,7 +1493,7 @@ test_attr_iterate(hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_iterate() */
/****************************************************************
**
** test_attr_delete(): Test H5A (attribute) code for deleting objects.
@ -1615,7 +1613,7 @@ test_attr_delete(hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_delete() */
/****************************************************************
**
** test_attr_dtype_shared(): Test H5A (attribute) code for using
@ -1792,7 +1790,7 @@ test_attr_dtype_shared(hid_t fapl)
VERIFY(filesize, empty_filesize, "h5_get_file_size");
} /* test_attr_dtype_shared() */
/****************************************************************
**
** test_attr_duplicate_ids(): Test operations with more than
@ -2037,7 +2035,7 @@ test_attr_duplicate_ids(hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_duplicate_ids() */
/****************************************************************
**
** test_attr_dense_verify(): Test basic H5A (attribute) code.
@ -2107,7 +2105,7 @@ test_attr_dense_verify(hid_t loc_id, unsigned max_attr)
return(-1);
} /* test_attr_dense_verify() */
/****************************************************************
**
** test_attr_dense_create(): Test basic H5A (attribute) code.
@ -2238,7 +2236,7 @@ test_attr_dense_create(hid_t fcpl, hid_t fapl)
VERIFY(filesize, empty_filesize, "h5_get_file_size");
} /* test_attr_dense_create() */
/****************************************************************
**
** test_attr_dense_open(): Test basic H5A (attribute) code.
@ -2377,7 +2375,7 @@ test_attr_dense_open(hid_t fcpl, hid_t fapl)
VERIFY(filesize, empty_filesize, "h5_get_file_size");
} /* test_attr_dense_open() */
/****************************************************************
**
** test_attr_dense_delete(): Test basic H5A (attribute) code.
@ -2555,7 +2553,7 @@ test_attr_dense_delete(hid_t fcpl, hid_t fapl)
VERIFY(filesize, empty_filesize, "h5_get_file_size");
} /* test_attr_dense_delete() */
/****************************************************************
**
** test_attr_dense_rename(): Test basic H5A (attribute) code.
@ -2714,7 +2712,7 @@ test_attr_dense_rename(hid_t fcpl, hid_t fapl)
VERIFY(filesize, empty_filesize, "h5_get_file_size");
} /* test_attr_dense_rename() */
/****************************************************************
**
** test_attr_dense_unlink(): Test basic H5A (attribute) code.
@ -2844,7 +2842,7 @@ test_attr_dense_unlink(hid_t fcpl, hid_t fapl)
VERIFY(filesize, empty_filesize, "h5_get_file_size");
} /* test_attr_dense_unlink() */
/****************************************************************
**
** test_attr_dense_limits(): Test basic H5A (attribute) code.
@ -3009,7 +3007,7 @@ test_attr_dense_limits(hid_t fcpl, hid_t fapl)
VERIFY(filesize, empty_filesize, "h5_get_file_size");
} /* test_attr_dense_limits() */
/****************************************************************
**
** test_attr_dense_dup_ids(): Test operations with multiple ID
@ -3532,7 +3530,7 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_dense_dup_ids() */
/****************************************************************
**
** test_attr_big(): Test basic H5A (attribute) code.
@ -3802,7 +3800,7 @@ test_attr_big(hid_t fcpl, hid_t fapl)
VERIFY(filesize, empty_filesize, "h5_get_file_size");
} /* test_attr_big() */
/****************************************************************
**
** test_attr_null_space(): Test basic H5A (attribute) code.
@ -4020,7 +4018,7 @@ test_attr_null_space(hid_t fcpl, hid_t fapl)
VERIFY(filesize, empty_filesize, "h5_get_file_size");
} /* test_attr_null_space() */
/****************************************************************
**
** test_attr_deprec(): Test basic H5A (attribute) code.
@ -4129,7 +4127,7 @@ test_attr_deprec(hid_t fcpl, hid_t fapl)
#endif /* H5_NO_DEPRECATED_SYMBOLS */
} /* test_attr_deprec() */
/****************************************************************
**
** test_attr_many(): Test basic H5A (attribute) code.
@ -4258,7 +4256,7 @@ test_attr_many(hbool_t new_format, hid_t fcpl, hid_t fapl)
CHECK(ret, FAIL, "H5Sclose");
} /* test_attr_many() */
/****************************************************************
**
** test_attr_corder_create_empty(): Test basic H5A (attribute) code.
@ -4374,7 +4372,7 @@ test_attr_corder_create_basic(hid_t fcpl, hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_corder_create_basic() */
/****************************************************************
**
** test_attr_corder_create_compact(): Test basic H5A (attribute) code.
@ -4572,7 +4570,7 @@ test_attr_corder_create_compact(hid_t fcpl, hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_corder_create_compact() */
/****************************************************************
**
** test_attr_corder_create_dense(): Test basic H5A (attribute) code.
@ -4799,7 +4797,7 @@ test_attr_corder_create_dense(hid_t fcpl, hid_t fapl)
CHECK(ret, FAIL, "H5Fclose");
} /* test_attr_corder_create_dense() */
/****************************************************************
**
** test_attr_corder_create_reopen(): Test basic H5A (attribute) code.
@ -4907,7 +4905,7 @@ test_attr_corder_create_reopen(hid_t fcpl, hid_t fapl)
CHECK(ret, FAIL, "H5Sclose");
} /* test_attr_corder_create_reopen() */
/****************************************************************
**
** test_attr_corder_transition(): Test basic H5A (attribute) code.
@ -5313,7 +5311,7 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl)
CHECK(ret, FAIL, "H5Sclose");
} /* test_attr_corder_transition() */
/****************************************************************
**
** test_attr_corder_delete(): Test basic H5A (attribute) code.
@ -5514,7 +5512,7 @@ test_attr_corder_delete(hid_t fcpl, hid_t fapl)
CHECK(ret, FAIL, "H5Sclose");
} /* test_attr_corder_delete() */
/*-------------------------------------------------------------------------
* Function: attr_info_by_idx_check
*
@ -5661,7 +5659,7 @@ attr_info_by_idx_check(hid_t obj_id, const char *attrname, hsize_t n,
return(-1);
} /* end attr_info_by_idx_check() */
/****************************************************************
**
** test_attr_info_by_idx(): Test basic H5A (attribute) code.
@ -5871,7 +5869,7 @@ test_attr_info_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl)
CHECK(ret, FAIL, "H5Sclose");
} /* test_attr_info_by_idx() */
/****************************************************************
**
** test_attr_delete_by_idx(): Test basic H5A (attribute) code.
@ -6403,7 +6401,7 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl)
CHECK(ret, FAIL, "H5Sclose");
} /* test_attr_delete_by_idx() */
/****************************************************************
**
** attr_iterate2_cb(): Revised attribute operator
@ -6477,7 +6475,7 @@ HDfprintf(stderr, "op_data->curr = %Hd\n", op_data->curr);
} /* end attr_iterate2_cb() */
#ifndef H5_NO_DEPRECATED_SYMBOLS
/****************************************************************
**
** attr_iterate1_cb(): Attribute operator
@ -6490,7 +6488,7 @@ attr_iterate1_cb(hid_t loc_id, const char *attr_name, void *_op_data)
} /* end attr_iterate1_cb() */
#endif /* H5_NO_DEPRECATED_SYMBOLS */
/*-------------------------------------------------------------------------
* Function: attr_iterate2_fail_cb
*
@ -6512,7 +6510,7 @@ attr_iterate2_fail_cb(hid_t H5_ATTR_UNUSED group_id, const char H5_ATTR_UNUSED *
return(H5_ITER_ERROR);
} /* end attr_iterate2_fail_cb() */
/*-------------------------------------------------------------------------
* Function: attr_iterate_check
*
@ -6812,7 +6810,7 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id,
return(-1);
} /* end attr_iterate_check() */
/****************************************************************
**
** test_attr_iterate2(): Test basic H5A (attribute) code.
@ -7116,7 +7114,7 @@ test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl)
HDfree(visited);
} /* test_attr_iterate2() */
/*-------------------------------------------------------------------------
* Function: attr_open_by_idx_check
*
@ -7176,7 +7174,7 @@ attr_open_by_idx_check(hid_t obj_id, H5_index_t idx_type, H5_iter_order_t order,
return(-1);
} /* end attr_open_by_idx_check() */
/****************************************************************
**
** test_attr_open_by_idx(): Test basic H5A (attribute) code.
@ -7438,7 +7436,7 @@ test_attr_open_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl)
CHECK(ret, FAIL, "H5Sclose");
} /* test_attr_open_by_idx() */
/*-------------------------------------------------------------------------
* Function: attr_open_check
*
@ -7524,7 +7522,7 @@ attr_open_check(hid_t fid, const char *dsetname, hid_t obj_id,
return(-1);
} /* end attr_open_check() */
/****************************************************************
**
** test_attr_open_by_name(): Test basic H5A (attribute) code.
@ -7779,7 +7777,7 @@ test_attr_open_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl)
CHECK(ret, FAIL, "H5Sclose");
} /* test_attr_open_by_name() */
/****************************************************************
**
** test_attr_create_by_name(): Test basic H5A (attribute) code.
@ -10866,7 +10864,7 @@ test_attr(void)
CHECK(ret, FAIL, "H5Pclose");
} /* test_attr() */
/*-------------------------------------------------------------------------
* Function: cleanup_attr
*

27
test/testhdf5.h
View File

@ -18,13 +18,6 @@
#ifndef TESTHDF5_H
#define TESTHDF5_H
/*
* Include required headers. This file tests internal library functions,
* so we include the private headers here.
*/
#include "H5private.h"
#include "H5Eprivate.h"
/* Include generic testing header also */
#include "h5test.h"
@ -204,12 +197,12 @@ void test_vlstrings(void);
void test_iterate(void);
void test_array(void);
void test_genprop(void);
void test_configure(void);
void test_misc(void);
void test_ids(void);
void test_skiplist(void);
void test_sohm(void);
void test_unicode(void);
void test_configure(void);
void test_misc(void);
void test_ids(void);
void test_skiplist(void);
void test_sohm(void);
void test_unicode(void);
/* Prototypes for the cleanup routines */
void cleanup_metadata(void);
@ -227,10 +220,10 @@ void cleanup_vlstrings(void);
void cleanup_iterate(void);
void cleanup_array(void);
void cleanup_genprop(void);
void cleanup_configure(void);
void cleanup_sohm(void);
void cleanup_misc(void);
void cleanup_unicode(void);
void cleanup_configure(void);
void cleanup_sohm(void);
void cleanup_misc(void);
void cleanup_unicode(void);
#ifdef __cplusplus
}

272
test/th5s.c
View File

@ -13,13 +13,12 @@
/***********************************************************
*
* Test program: th5s
* Test program: th5s
*
* Test the dataspace functionality
*
*************************************************************/
#include "hdf5.h"
#include "testhdf5.h"
#include "H5srcdir.h"
@ -42,7 +41,6 @@
#define H5O_TESTING
#include "H5Opkg.h" /* Object header */
#include "H5private.h"
#include "H5Bprivate.h"
#include "H5Sprivate.h"
#include "H5Pprivate.h"
@ -63,31 +61,31 @@
#define EXTFILE_NAME "ext_file"
/* 3-D dataset with fixed dimensions */
#define SPACE1_RANK 3
#define SPACE1_DIM1 3
#define SPACE1_DIM2 15
#define SPACE1_DIM3 13
#define SPACE1_RANK 3
#define SPACE1_DIM1 3
#define SPACE1_DIM2 15
#define SPACE1_DIM3 13
/* 4-D dataset with one unlimited dimension */
#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
#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
/* Scalar dataset with simple datatype */
#define SPACE3_RANK 0
#define SPACE3_RANK 0
unsigned space3_data=65;
/* Scalar dataset with compound datatype */
#define SPACE4_FIELDNAME1 "c1"
#define SPACE4_FIELDNAME2 "u"
#define SPACE4_FIELDNAME3 "f"
#define SPACE4_FIELDNAME4 "c2"
#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;
@ -107,21 +105,21 @@ struct space4_struct {
static void
test_h5s_basic(void)
{
hid_t fid1; /* HDF5 File IDs */
hid_t sid1, sid2; /* Dataspace ID */
hid_t dset1; /* Dataset ID */
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];
hssize_t n; /* Number of dataspace elements */
herr_t ret; /* Generic return value */
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];
hssize_t n; /* Number of dataspace elements */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(5, ("Testing Dataspace Manipulation\n"));
@ -132,7 +130,7 @@ test_h5s_basic(void)
n = H5Sget_simple_extent_npoints(sid1);
CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
VERIFY(n, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3,
"H5Sget_simple_extent_npoints");
"H5Sget_simple_extent_npoints");
rank = H5Sget_simple_extent_ndims(sid1);
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
@ -141,7 +139,7 @@ test_h5s_basic(void)
rank = H5Sget_simple_extent_dims(sid1, tdims, NULL);
CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
"H5Sget_simple_extent_dims");
"H5Sget_simple_extent_dims");
sid2 = H5Screate_simple(SPACE2_RANK, dims2, max2);
CHECK(sid2, FAIL, "H5Screate_simple");
@ -149,7 +147,7 @@ test_h5s_basic(void)
n = H5Sget_simple_extent_npoints(sid2);
CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
VERIFY(n, SPACE2_DIM1 * SPACE2_DIM2 * SPACE2_DIM3 * SPACE2_DIM4,
"H5Sget_simple_extent_npoints");
"H5Sget_simple_extent_npoints");
rank = H5Sget_simple_extent_ndims(sid2);
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
@ -158,9 +156,9 @@ test_h5s_basic(void)
rank = H5Sget_simple_extent_dims(sid2, tdims, tmax);
CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
VERIFY(HDmemcmp(tdims, dims2, SPACE2_RANK * sizeof(hsize_t)), 0,
"H5Sget_simple_extent_dims");
"H5Sget_simple_extent_dims");
VERIFY(HDmemcmp(tmax, max2, SPACE2_RANK * sizeof(hsize_t)), 0,
"H5Sget_simple_extent_dims");
"H5Sget_simple_extent_dims");
/* Change max dims to be equal to the dimensions */
ret = H5Sset_extent_simple(sid1, SPACE1_RANK, dims1, NULL);
@ -168,9 +166,9 @@ test_h5s_basic(void)
rank = H5Sget_simple_extent_dims(sid1, tdims, tmax);
CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
"H5Sget_simple_extent_dims");
"H5Sget_simple_extent_dims");
VERIFY(HDmemcmp(tmax, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
"H5Sget_simple_extent_dims");
"H5Sget_simple_extent_dims");
ret = H5Sclose(sid1);
CHECK(ret, FAIL, "H5Sclose");
@ -183,7 +181,7 @@ test_h5s_basic(void)
* dimensions.
*/
H5E_BEGIN_TRY {
sid1 = H5Screate_simple(H5S_MAX_RANK+1, dims3, NULL);
sid1 = H5Screate_simple(H5S_MAX_RANK+1, dims3, NULL);
} H5E_END_TRY;
VERIFY(sid1, FAIL, "H5Screate_simple");
@ -306,7 +304,7 @@ test_h5s_basic(void)
CHECK(ret, FAIL, "H5Sclose");
ret = H5Fclose(fid1);
CHECK(ret, FAIL, "H5Fclose");
} /* test_h5s_basic() */
} /* test_h5s_basic() */
/****************************************************************
**
@ -366,16 +364,16 @@ test_h5s_null(void)
hsize_t start[1]={0};
hsize_t count[1]={0};
ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL, count, NULL);
ret = H5Sselect_hyperslab(sid, H5S_SELECT_SET, start, NULL, count, NULL);
} H5E_END_TRY;
VERIFY(ret, FAIL, "H5Sselect_hyperslab");
/* Check to be sure we can't set a point selection on a null dataspace */
H5E_BEGIN_TRY {
hsize_t coord[1][1]; /* Coordinates for point selection */
hsize_t coord[1][1]; /* Coordinates for point selection */
coord[0][0]=0;
ret = H5Sselect_elements(sid, H5S_SELECT_SET, (size_t)1, (const hsize_t *)coord);
ret = H5Sselect_elements(sid, H5S_SELECT_SET, (size_t)1, (const hsize_t *)coord);
} H5E_END_TRY;
VERIFY(ret, FAIL, "H5Sselect_elements");
@ -536,18 +534,18 @@ test_h5s_null(void)
static void
test_h5s_zero_dim(void)
{
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 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};
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 */
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];
@ -557,12 +555,12 @@ test_h5s_zero_dim(void)
int val = 3;
hsize_t start[] = {0, 0, 0};
hsize_t count[] = {3, 15, 13};
hsize_t coord[1][3]; /* Coordinates for point selection */
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 */
herr_t ret; /* Generic return value */
unsigned int i, j, k;
/* Output message about test being performed */
@ -638,8 +636,8 @@ test_h5s_zero_dim(void)
CHECK(sid_chunk, FAIL, "H5Screate_simple");
/*============================================
* Make sure we can use 0-dimension to create
* contiguous, chunked, compact, and external
* Make sure we can use 0-dimension to create
* contiguous, chunked, compact, and external
* datasets, and also attribute.
*============================================
*/
@ -703,7 +701,7 @@ test_h5s_zero_dim(void)
}
}
/* Select a hyperslab beyond its current dimension sizes, then try to write
/* Select a hyperslab beyond its current dimension sizes, then try to write
* the data. It should fail. */
ret = H5Sselect_hyperslab(sid1, H5S_SELECT_SET, start, NULL, count, NULL);
CHECK(ret, FAIL, "H5Sselect_hyperslab");
@ -717,7 +715,7 @@ test_h5s_zero_dim(void)
ret = H5Sselect_none(sid1);
CHECK(ret, FAIL, "H5Sselect_none");
/* Select a point beyond the dimension size, then try to write the data.
/* Select a point beyond the dimension size, then try to write the data.
* It should fail. */
coord[0][0]=2; coord[0][1]=5; coord[0][2]=3;
ret = H5Sselect_elements(sid1, H5S_SELECT_SET, (size_t)1, (const hsize_t *)coord);
@ -769,8 +767,8 @@ test_h5s_zero_dim(void)
}
}
/* Now extend the dataset to SPACE1_DIM1*SPACE1_DIM2*SPACE1_DIM3 and make sure
* we can write data to it */
/* Now extend the dataset to SPACE1_DIM1*SPACE1_DIM2*SPACE1_DIM3 and make sure
* we can write data to it */
extend_dims[0] = SPACE1_DIM1;
ret = H5Dset_extent(dset1, extend_dims);
CHECK(ret, FAIL, "H5Dset_extent");
@ -970,10 +968,10 @@ test_h5s_zero_dim(void)
CHECK(ret, FAIL, "H5Aclose");
/*===============================================================
* Extend the dimension to make it a normal dataspace (3x15x13).
* Verify that data can be written to and read from the chunked
* dataset now.
*===============================================================
* Extend the dimension to make it a normal dataspace (3x15x13).
* Verify that data can be written to and read from the chunked
* dataset now.
*===============================================================
*/
dims1[0]=SPACE1_DIM1;
ret = H5Sset_extent_simple(sid_chunk,SPACE1_RANK,dims1,max_dims);
@ -1174,14 +1172,14 @@ test_h5s_zero_dim(void)
static void
test_h5s_encode(void)
{
hid_t sid1, sid2, sid3; /* Dataspace ID */
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};
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 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};
@ -1189,8 +1187,8 @@ test_h5s_encode(void)
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 */
hid_t ret_id; /* Generic hid_t return value */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(5, ("Testing Dataspace Encoding and Decoding\n"));
@ -1214,7 +1212,7 @@ test_h5s_encode(void)
/* Try decoding bogus buffer */
H5E_BEGIN_TRY {
ret_id = H5Sdecode(sbuf);
ret_id = H5Sdecode(sbuf);
} H5E_END_TRY;
VERIFY(ret_id, FAIL, "H5Sdecode");
@ -1229,7 +1227,7 @@ test_h5s_encode(void)
n = H5Sget_simple_extent_npoints(decoded_sid1);
CHECK(n, FAIL, "H5Sget_simple_extent_npoints");
VERIFY(n, SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3,
"H5Sget_simple_extent_npoints");
"H5Sget_simple_extent_npoints");
rank = H5Sget_simple_extent_ndims(decoded_sid1);
CHECK(rank, FAIL, "H5Sget_simple_extent_ndims");
@ -1238,7 +1236,7 @@ test_h5s_encode(void)
rank = H5Sget_simple_extent_dims(decoded_sid1, tdims, NULL);
CHECK(rank, FAIL, "H5Sget_simple_extent_dims");
VERIFY(HDmemcmp(tdims, dims1, SPACE1_RANK * sizeof(hsize_t)), 0,
"H5Sget_simple_extent_dims");
"H5Sget_simple_extent_dims");
/* Verify hyperslabe selection */
sel_type = H5Sget_select_type(decoded_sid1);
@ -1328,7 +1326,7 @@ test_h5s_encode(void)
HDfree(sbuf);
HDfree(null_sbuf);
HDfree(scalar_buf);
} /* test_h5s_encode() */
} /* test_h5s_encode() */
/****************************************************************
**
@ -1338,14 +1336,14 @@ test_h5s_encode(void)
static void
test_h5s_scalar_write(void)
{
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 */
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 */
herr_t ret; /* Generic return value */
/* Output message about test being performed */
MESSAGE(5, ("Testing Scalar Dataspace Manipulation during Writing\n"));
@ -1397,7 +1395,7 @@ test_h5s_scalar_write(void)
/* Close file */
ret = H5Fclose(fid1);
CHECK(ret, FAIL, "H5Fclose");
} /* test_h5s_scalar_write() */
} /* test_h5s_scalar_write() */
/****************************************************************
**
@ -1407,14 +1405,14 @@ test_h5s_scalar_write(void)
static void
test_h5s_scalar_read(void)
{
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 */
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 */
/* Output message about test being performed */
@ -1461,7 +1459,7 @@ test_h5s_scalar_read(void)
/* Close file */
ret = H5Fclose(fid1);
CHECK(ret, FAIL, "H5Fclose");
} /* test_h5s_scalar_read() */
} /* test_h5s_scalar_read() */
/****************************************************************
**
@ -1472,14 +1470,14 @@ test_h5s_scalar_read(void)
static void
test_h5s_compound_scalar_write(void)
{
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 */
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 */
/* Output message about test being performed */
MESSAGE(5, ("Testing Scalar Dataspace Manipulation for Writing Compound Datatypes\n"));
@ -1493,19 +1491,19 @@ test_h5s_compound_scalar_write(void)
CHECK(tid1, FAIL, "H5Tcreate");
space4_field1_off=HOFFSET(struct space4_struct, c1);
ret = H5Tinsert(tid1, SPACE4_FIELDNAME1, space4_field1_off,
H5T_NATIVE_SCHAR);
H5T_NATIVE_SCHAR);
CHECK(ret, FAIL, "H5Tinsert");
space4_field2_off=HOFFSET(struct space4_struct, u);
ret = H5Tinsert(tid1, SPACE4_FIELDNAME2, space4_field2_off,
H5T_NATIVE_UINT);
H5T_NATIVE_UINT);
CHECK(ret, FAIL, "H5Tinsert");
space4_field3_off=HOFFSET(struct space4_struct, f);
ret = H5Tinsert(tid1, SPACE4_FIELDNAME3, space4_field3_off,
H5T_NATIVE_FLOAT);
H5T_NATIVE_FLOAT);
CHECK(ret, FAIL, "H5Tinsert");
space4_field4_off=HOFFSET(struct space4_struct, c2);
ret = H5Tinsert(tid1, SPACE4_FIELDNAME4, space4_field4_off,
H5T_NATIVE_SCHAR);
H5T_NATIVE_SCHAR);
CHECK(ret, FAIL, "H5Tinsert");
/* Create scalar dataspace */
@ -1545,7 +1543,7 @@ test_h5s_compound_scalar_write(void)
/* Close file */
ret = H5Fclose(fid1);
CHECK(ret, FAIL, "H5Fclose");
} /* test_h5s_compound_scalar_write() */
} /* test_h5s_compound_scalar_write() */
/****************************************************************
**
@ -1556,15 +1554,15 @@ test_h5s_compound_scalar_write(void)
static void
test_h5s_compound_scalar_read(void)
{
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 */
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 */
/* Output message about test being performed */
MESSAGE(5, ("Testing Scalar Dataspace Manipulation for Reading Compound Datatypes\n"));
@ -1618,7 +1616,7 @@ test_h5s_compound_scalar_read(void)
/* Close file */
ret = H5Fclose(fid1);
CHECK(ret, FAIL, "H5Fclose");
} /* test_h5s_compound_scalar_read() */
} /* test_h5s_compound_scalar_read() */
/* Data arrays for chunk test */
double chunk_data_dbl[50000][3];
@ -2384,7 +2382,7 @@ test_h5s_bug1(void)
CHECK(ret, FAIL, "H5Sclose");
} /* test_h5s_bug1() */
/*-------------------------------------------------------------------------
* Function: test_versionbounds
*
@ -2395,8 +2393,8 @@ test_h5s_bug1(void)
* reopens it with higher bounds to show that the dataspace
* version is upgraded appropriately.
*
* Return: Success: 0
* Failure: number of errors
* Return: Success: 0
* Failure: number of errors
*
*-------------------------------------------------------------------------
*/
@ -2501,13 +2499,13 @@ test_versionbounds(void)
ret = H5Sclose(space);
CHECK(ret, FAIL, "H5Sclose");
ret = H5Pclose(fapl);
ret = H5Pclose(fapl);
CHECK(ret, FAIL, "H5Pclose");
ret = H5Fclose(file);
CHECK(ret, FAIL, "H5Fclose");
} /* end test_versionbounds() */
/****************************************************************
**
** test_h5s(): Main H5S (dataspace) testing routine.
@ -2519,34 +2517,34 @@ test_h5s(void)
/* Output message about test being performed */
MESSAGE(5, ("Testing Dataspaces\n"));
test_h5s_basic(); /* Test basic H5S code */
test_h5s_null(); /* Test Null dataspace H5S code */
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 */
test_h5s_encode(); /* Test encoding and decoding */
test_h5s_scalar_write(); /* Test scalar H5S writing code */
test_h5s_scalar_read(); /* Test scalar H5S reading code */
test_h5s_scalar_write(); /* Test scalar H5S writing code */
test_h5s_scalar_read(); /* Test scalar H5S reading code */
test_h5s_compound_scalar_write(); /* Test compound datatype scalar H5S writing code */
test_h5s_compound_scalar_read(); /* Test compound datatype scalar H5S reading code */
test_h5s_compound_scalar_write(); /* Test compound datatype scalar H5S writing code */
test_h5s_compound_scalar_read(); /* Test compound datatype scalar H5S reading code */
/* This test was added later to exercise a bug in chunked I/O */
test_h5s_chunk(); /* Exercise bug fix for chunked I/O */
test_h5s_chunk(); /* Exercise bug fix for chunked I/O */
test_h5s_extent_equal(); /* Test extent comparison code */
test_h5s_extent_equal(); /* Test extent comparison code */
test_h5s_extent_copy(); /* Test extent copy code */
test_h5s_bug1(); /* Test bug in offset initialization */
test_versionbounds(); /* Test version bounds with dataspace */
} /* test_h5s() */
/*-------------------------------------------------------------------------
* Function: cleanup_h5s
* Function: cleanup_h5s
*
* Purpose: Cleanup temporary test files
* Purpose: Cleanup temporary test files
*
* Return: none
* Return: none
*
* Programmer: Albert Cheng
* Programmer: Albert Cheng
* July 2, 1998
*
* Modifications:

3
test/ttsafe.h
View File

@ -22,9 +22,6 @@
* Include required headers. This file tests internal library functions,
* so we include the private headers here.
*/
#include "hdf5.h"
#include "H5private.h"
#include "H5Eprivate.h"
#include "testhdf5.h"

2737
testpar/t_cache.c
View File

File diff suppressed because it is too large Load Diff

679
testpar/t_cache_image.c
View File

File diff suppressed because it is too large Load Diff

113
testpar/t_pflush1.c
View File

@ -15,13 +15,12 @@
* Programmer: Leon Arber <larber@uiuc.edu>
* Sept. 28, 2006.
*
* Purpose: This is the first half of a two-part test that makes sure
* that a file can be read after a parallel application crashes as long
* as the file was flushed first. We simulate a crash by
* calling _exit(0) since this doesn't flush HDF5 caches but
* still exits with success.
* Purpose: This is the first half of a two-part test that makes sure
* that a file can be read after a parallel application crashes as long
* as the file was flushed first. We simulate a crash by
* calling _exit(0) since this doesn't flush HDF5 caches but
* still exits with success.
*/
#include <mpi.h>
#include "h5test.h"
const char *FILENAME[] = {
@ -30,18 +29,18 @@ const char *FILENAME[] = {
NULL
};
static double the_data[100][100];
static double the_data[100][100];
/*-------------------------------------------------------------------------
* Function: create_file
* Function: create_file
*
* Purpose: Creates file used in part 1 of the test
* Purpose: Creates file used in part 1 of the test
*
* Return: Success: 0
* Return: Success: 0
*
* Failure: 1
* Failure: 1
*
* Programmer: Leon Arber
* Programmer: Leon Arber
* Sept. 26, 2006
*
* Modifications:
@ -51,10 +50,10 @@ static double the_data[100][100];
static hid_t
create_file(char* name, hid_t fapl)
{
hid_t file, dcpl, space, dset, groups, grp, plist;
hsize_t ds_size[2] = {100, 100};
hsize_t ch_size[2] = {5, 5};
hsize_t i, j;
hid_t file, dcpl, space, dset, groups, grp, plist;
hsize_t ds_size[2] = {100, 100};
hsize_t ch_size[2] = {5, 5};
hsize_t i, j;
@ -65,7 +64,7 @@ create_file(char* name, hid_t fapl)
if(H5Pset_chunk(dcpl, 2, ch_size) < 0) goto error;
if((space = H5Screate_simple(2, ds_size, NULL)) < 0) goto error;
if((dset = H5Dcreate2(file, "dset", H5T_NATIVE_FLOAT, space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
goto error;
goto error;
plist = H5Pcreate(H5P_DATASET_XFER);
H5Pset_dxpl_mpio(plist, H5FD_MPIO_COLLECTIVE);
@ -73,22 +72,22 @@ create_file(char* name, hid_t fapl)
/* Write some data */
for(i = 0; i < ds_size[0]; i++) {
/*
* The extra cast in the following statement is a bug workaround
* for the Win32 version 5.0 compiler.
* 1998-11-06 ptl
*/
for(j = 0; j < ds_size[1]; j++)
the_data[i][j] = (double)(hssize_t)i/(hssize_t)(j+1);
/*
* The extra cast in the following statement is a bug workaround
* for the Win32 version 5.0 compiler.
* 1998-11-06 ptl
*/
for(j = 0; j < ds_size[1]; j++)
the_data[i][j] = (double)(hssize_t)i/(hssize_t)(j+1);
}
if(H5Dwrite(dset, H5T_NATIVE_DOUBLE, space, space, plist, the_data) < 0) goto error;
/* Create some groups */
if((groups = H5Gcreate2(file, "some_groups", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) goto error;
for(i = 0; i < 100; i++) {
sprintf(name, "grp%02u", (unsigned)i);
if((grp = H5Gcreate2(groups, name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) goto error;
if(H5Gclose(grp) < 0) goto error;
sprintf(name, "grp%02u", (unsigned)i);
if((grp = H5Gcreate2(groups, name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) goto error;
if(H5Gclose(grp) < 0) goto error;
}
return file;
@ -98,20 +97,20 @@ error:
}
/*-------------------------------------------------------------------------
* Function: main
* Function: main
*
* Purpose: Part 1 of a two-part H5Fflush() test.
* Purpose: Part 1 of a two-part H5Fflush() test.
*
* Return: Success: 0
* Return: Success: 0
*
* Failure: 1
* Failure: 1
*
* Programmer: Robb Matzke
* Programmer: Robb Matzke
* Friday, October 23, 1998
*
* Modifications:
* Leon Arber
* Sept. 26, 2006, expand test to check for failure if H5Fflush is not called.
* Leon Arber
* Sept. 26, 2006, expand test to check for failure if H5Fflush is not called.
*
*
*-------------------------------------------------------------------------
@ -120,8 +119,8 @@ int
main(int argc, char* argv[])
{
hid_t file1, file2, fapl;
MPI_File *mpifh_p = NULL;
char name[1024];
MPI_File *mpifh_p = NULL;
char name[1024];
const char *envval = NULL;
int mpi_size, mpi_rank;
MPI_Comm comm = MPI_COMM_WORLD;
@ -135,26 +134,26 @@ main(int argc, char* argv[])
H5Pset_fapl_mpio(fapl, comm, info);
if(mpi_rank == 0)
TESTING("H5Fflush (part1)");
TESTING("H5Fflush (part1)");
envval = HDgetenv("HDF5_DRIVER");
if(envval == NULL)
envval = "nomatch";
if(HDstrcmp(envval, "split")) {
/* Create the file */
h5_fixname(FILENAME[0], fapl, name, sizeof name);
file1 = create_file(name, fapl);
/* Flush and exit without closing the library */
if(H5Fflush(file1, H5F_SCOPE_GLOBAL) < 0) goto error;
/* Create the file */
h5_fixname(FILENAME[0], fapl, name, sizeof name);
file1 = create_file(name, fapl);
/* Flush and exit without closing the library */
if(H5Fflush(file1, H5F_SCOPE_GLOBAL) < 0) goto error;
/* Create the other file which will not be flushed */
h5_fixname(FILENAME[1], fapl, name, sizeof name);
file2 = create_file(name, fapl);
/* Create the other file which will not be flushed */
h5_fixname(FILENAME[1], fapl, name, sizeof name);
file2 = create_file(name, fapl);
if(mpi_rank == 0)
PASSED();
fflush(stdout);
fflush(stderr);
if(mpi_rank == 0)
PASSED();
fflush(stdout);
fflush(stderr);
} /* end if */
else {
SKIPPED();
@ -171,21 +170,21 @@ main(int argc, char* argv[])
/* close file1 */
if(H5Fget_vfd_handle(file1, fapl, (void **)&mpifh_p) < 0) {
printf("H5Fget_vfd_handle for file1 failed\n");
goto error;
printf("H5Fget_vfd_handle for file1 failed\n");
goto error;
} /* end if */
if(MPI_File_close(mpifh_p) != MPI_SUCCESS) {
printf("MPI_File_close for file1 failed\n");
goto error;
printf("MPI_File_close for file1 failed\n");
goto error;
} /* end if */
/* close file2 */
if(H5Fget_vfd_handle(file2, fapl, (void **)&mpifh_p) < 0) {
printf("H5Fget_vfd_handle for file2 failed\n");
goto error;
printf("H5Fget_vfd_handle for file2 failed\n");
goto error;
} /* end if */
if(MPI_File_close(mpifh_p) != MPI_SUCCESS) {
printf("MPI_File_close for file2 failed\n");
goto error;
printf("MPI_File_close for file2 failed\n");
goto error;
} /* end if */
fflush(stdout);

73
testpar/t_pread.c
View File

@ -16,7 +16,6 @@
*
*/
#include "h5test.h"
#include "testpar.h"
/* The collection of files is included below to aid
@ -42,7 +41,7 @@ const char *FILENAMES[NFILENAME + 1]={"t_pread_data_file",
#define COUNT 1000
hbool_t pass = true;
static const char *random_hdf5_text =
static const char *random_hdf5_text =
"Now is the time for all first-time-users of HDF5 to read their \
manual or go thru the tutorials!\n\
While you\'re at it, now is also the time to read up on MPI-IO.";
@ -58,7 +57,7 @@ static int test_parallel_read(MPI_Comm comm, int mpi_rank, int group);
static char *test_argv0 = NULL;
extern char *dirname(char *path); /* Avoids additional includes */
/*-------------------------------------------------------------------------
* Function: generate_test_file
*
@ -79,7 +78,7 @@ extern char *dirname(char *path); /* Avoids additional includes */
* In the overall scheme of running the test, we'll call
* this function twice: first as a collection of all MPI
* processes and then a second time with the processes split
* more or less in half. Each sub group will operate
* more or less in half. Each sub group will operate
* collectively on their assigned file. This split into
* subgroups validates that parallel groups can successfully
* open and read data independantly from the other parallel
@ -93,7 +92,7 @@ extern char *dirname(char *path); /* Avoids additional includes */
* 10/1/17
*
* Modifications:
*
*
*-------------------------------------------------------------------------
*/
static int
@ -110,14 +109,14 @@ generate_test_file( MPI_Comm comm, int mpi_rank, int group_id )
int group_size;
int group_rank;
int local_failure = 0;
int global_failures = 0;
int global_failures = 0;
hsize_t count = COUNT;
hsize_t i;
hsize_t offset;
hsize_t dims[1] = {0};
hid_t file_id = -1;
hid_t memspace = -1;
hid_t filespace = -1;
hid_t memspace = -1;
hid_t filespace = -1;
hid_t fapl_id = -1;
hid_t dxpl_id = -1;
hid_t dset_id = -1;
@ -153,7 +152,7 @@ generate_test_file( MPI_Comm comm, int mpi_rank, int group_id )
if ( pass ) {
if ( comm == MPI_COMM_WORLD ) { /* Test 1 */
file_index = 0;
}
}
else if ( group_id == 0 ) { /* Test 2 group 0 */
file_index = 3;
}
@ -161,8 +160,8 @@ generate_test_file( MPI_Comm comm, int mpi_rank, int group_id )
file_index = 6;
}
/* The 'group_filename' is just a temp variable and
* is used to call into the h5_fixname function. No
/* The 'group_filename' is just a temp variable and
* is used to call into the h5_fixname function. No
* need to worry that we reassign it for each file!
*/
group_filename = FILENAMES[file_index];
@ -234,9 +233,9 @@ generate_test_file( MPI_Comm comm, int mpi_rank, int group_id )
}
}
/* create the data file */
/* create the data file */
if ( pass ) {
if ( (file_id = H5Fcreate(data_filename, H5F_ACC_TRUNC,
if ( (file_id = H5Fcreate(data_filename, H5F_ACC_TRUNC,
H5P_DEFAULT, fapl_id)) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fcreate() failed.\n";
@ -276,7 +275,7 @@ generate_test_file( MPI_Comm comm, int mpi_rank, int group_id )
if ( pass ) {
offset = (hsize_t)group_rank * (hsize_t)COUNT;
if ( (H5Sselect_hyperslab(filespace, H5S_SELECT_SET, &offset,
if ( (H5Sselect_hyperslab(filespace, H5S_SELECT_SET, &offset,
NULL, &count, NULL)) < 0 ) {
pass = FALSE;
failure_mssg = "H5Sselect_hyperslab() failed.\n";
@ -284,8 +283,8 @@ generate_test_file( MPI_Comm comm, int mpi_rank, int group_id )
}
if ( pass ) {
if ( (dset_id = H5Dcreate2(file_id, "dataset0", H5T_NATIVE_FLOAT,
filespace, H5P_DEFAULT, H5P_DEFAULT,
if ( (dset_id = H5Dcreate2(file_id, "dataset0", H5T_NATIVE_FLOAT,
filespace, H5P_DEFAULT, H5P_DEFAULT,
H5P_DEFAULT)) < 0 ) {
pass = false;
failure_mssg = "H5Dcreate2() failed.\n";
@ -293,7 +292,7 @@ generate_test_file( MPI_Comm comm, int mpi_rank, int group_id )
}
if ( pass ) {
if ( (H5Dwrite(dset_id, H5T_NATIVE_FLOAT, memspace,
if ( (H5Dwrite(dset_id, H5T_NATIVE_FLOAT, memspace,
filespace, dxpl_id, data_slice)) < 0 ) {
pass = false;
failure_mssg = "H5Dwrite() failed.\n";
@ -344,15 +343,15 @@ generate_test_file( MPI_Comm comm, int mpi_rank, int group_id )
}
/* Add a userblock to the head of the datafile.
* We will use this to for a functional test of the
* We will use this to for a functional test of the
* file open optimization. This is superblock
* relocation is done by the rank 0 process associated
* with the communicator being used. For test 1, we
* utilize MPI_COMM_WORLD, so group_rank 0 is the
* same as mpi_rank 0. For test 2 which utilizes
* two groups resulting from an MPI_Comm_split, we
* will have parallel groups and hence two
* group_rank(0) processes. Each parallel group
* will have parallel groups and hence two
* group_rank(0) processes. Each parallel group
* will create a unique file with different text
* headers and different data.
*
@ -361,7 +360,7 @@ generate_test_file( MPI_Comm comm, int mpi_rank, int group_id )
if ( group_rank == 0 ) {
const char *text_to_write;
size_t bytes_to_write;
size_t bytes_to_write;
if (group_id == 0)
text_to_write = random_hdf5_text;
@ -406,7 +405,7 @@ generate_test_file( MPI_Comm comm, int mpi_rank, int group_id )
* if h5jam is co-located here. Otherwise, the autotools
* put things into directories, hence the relative path.
*/
if (test_argv0 != NULL) {
if (test_argv0 != NULL) {
HDstrncpy(exe_path, test_argv0, sizeof(exe_path));
if ( (exe_dirname = (char *)dirname(exe_path)) != NULL) {
HDsprintf(cmd, "%s/h5jam", exe_dirname);
@ -430,13 +429,13 @@ generate_test_file( MPI_Comm comm, int mpi_rank, int group_id )
}
/* collect results from other processes.
* Only overwrite the failure message if no preveious error
* Only overwrite the failure message if no preveious error
* has been detected
*/
local_failure = ( pass ? 0 : 1 );
/* This is a global all reduce (NOT group specific) */
if ( MPI_Allreduce(&local_failure, &global_failures, 1,
if ( MPI_Allreduce(&local_failure, &global_failures, 1,
MPI_INT, MPI_SUM, MPI_COMM_WORLD) != MPI_SUCCESS ) {
if ( pass ) {
pass = FALSE;
@ -468,7 +467,7 @@ generate_test_file( MPI_Comm comm, int mpi_rank, int group_id )
} /* generate_test_file() */
/*-------------------------------------------------------------------------
* Function: test_parallel_read
*
@ -511,7 +510,7 @@ test_parallel_read(MPI_Comm comm, int mpi_rank, int group_id)
const char *group_filename = NULL;
char reloc_data_filename[FILENAME_BUF_SIZE];
int local_failure = 0;
int global_failures = 0;
int global_failures = 0;
int group_size;
int group_rank;
hid_t fapl_id = -1;
@ -597,7 +596,7 @@ test_parallel_read(MPI_Comm comm, int mpi_rank, int group_id)
/* open the file -- should have user block, exercising the optimization */
if ( pass ) {
if ( (file_id = H5Fopen(reloc_data_filename,
if ( (file_id = H5Fopen(reloc_data_filename,
H5F_ACC_RDONLY, fapl_id)) < 0 ) {
pass = FALSE;
failure_mssg = "H5Fopen() failed\n";
@ -631,7 +630,7 @@ test_parallel_read(MPI_Comm comm, int mpi_rank, int group_id)
if ( pass ) {
offset = (hsize_t)group_rank * count;
if ( (H5Sselect_hyperslab(filespace, H5S_SELECT_SET,
if ( (H5Sselect_hyperslab(filespace, H5S_SELECT_SET,
&offset, NULL, &count, NULL)) < 0 ) {
pass = FALSE;
failure_mssg = "H5Sselect_hyperslab() failed\n";
@ -640,14 +639,14 @@ test_parallel_read(MPI_Comm comm, int mpi_rank, int group_id)
/* read this processes section of the data */
if ( pass ) {
if ( (H5Dread(dset_id, H5T_NATIVE_FLOAT, memspace,
if ( (H5Dread(dset_id, H5T_NATIVE_FLOAT, memspace,
filespace, H5P_DEFAULT, data_slice)) < 0 ) {
pass = FALSE;
failure_mssg = "H5Dread() failed\n";
}
}
/* verify the data */
/* verify the data */
if ( pass ) {
nextValue = (float)((hsize_t)mpi_rank * count);
i = 0;
@ -708,7 +707,7 @@ test_parallel_read(MPI_Comm comm, int mpi_rank, int group_id)
*/
local_failure = ( pass ? 0 : 1 );
if ( MPI_Allreduce( &local_failure, &global_failures, 1,
if ( MPI_Allreduce( &local_failure, &global_failures, 1,
MPI_INT, MPI_SUM, MPI_COMM_WORLD) != MPI_SUCCESS ) {
if ( pass ) {
pass = FALSE;
@ -739,11 +738,11 @@ test_parallel_read(MPI_Comm comm, int mpi_rank, int group_id)
}
return( ! pass );
return( ! pass );
} /* test_parallel_read() */
/*-------------------------------------------------------------------------
* Function: main
*
@ -830,7 +829,7 @@ main( int argc, char **argv)
/* ------ Create two (2) MPI groups ------
*
* We split MPI_COMM_WORLD into 2 more or less equal sized
* We split MPI_COMM_WORLD into 2 more or less equal sized
* groups. The resulting communicators will be used to generate
* two HDF files which in turn will be opened in parallel and the
* contents verified in the second read test below.
@ -858,7 +857,7 @@ main( int argc, char **argv)
}
goto finish;
}
/* We generate the file used for test 2 */
nerrs += generate_test_file( group_comm, mpi_rank, which_group );
@ -917,7 +916,7 @@ finish:
HDfprintf(stdout, "===================================\n");
if ( nerrs > 0 ) {
HDfprintf(stdout, "***%s detected %d failures***\n", header, nerrs);
}
else {

1698
testpar/t_shapesame.c
View File

File diff suppressed because it is too large Load Diff

704
testpar/t_span_tree.c
View File

File diff suppressed because it is too large Load Diff

25
tools/test/perform/pio_perf.h
View File

@ -15,7 +15,6 @@
#include "io_timer.h"
#ifndef STANDALONE
#include "H5private.h"
#include "h5test.h"
#include "h5tools.h"
#include "h5tools_utils.h"
@ -36,22 +35,22 @@ typedef enum iotype_ {
} iotype;
typedef struct parameters_ {
iotype io_type; /* The type of IO test to perform */
int num_procs; /* Maximum number of processes to use */
long num_files; /* Number of files to create */
long num_dsets; /* Number of datasets to create */
off_t num_bytes; /* Number of bytes in each dset */
iotype io_type; /* The type of IO test to perform */
int num_procs; /* Maximum number of processes to use */
long num_files; /* Number of files to create */
long num_dsets; /* Number of datasets to create */
off_t num_bytes; /* Number of bytes in each dset */
int num_iters; /* Number of times to loop doing the IO */
size_t buf_size; /* Buffer size */
size_t blk_size; /* Block size */
size_t buf_size; /* Buffer size */
size_t blk_size; /* Block size */
unsigned interleaved; /* Interleaved vs. contiguous blocks */
unsigned collective; /* Collective vs. independent I/O */
unsigned dim2d; /* 1D vs. 2D */
hsize_t h5_align; /* HDF5 object alignment */
hsize_t h5_thresh; /* HDF5 object alignment threshold */
int h5_use_chunks; /* Make HDF5 dataset chunked */
int h5_write_only; /* Perform the write tests only */
int verify; /* Verify data correctness */
hsize_t h5_align; /* HDF5 object alignment */
hsize_t h5_thresh; /* HDF5 object alignment threshold */
int h5_use_chunks; /* Make HDF5 dataset chunked */
int h5_write_only; /* Perform the write tests only */
int verify; /* Verify data correctness */
} parameters;
typedef struct results_ {

1
tools/test/perform/sio_perf.h
View File

@ -15,7 +15,6 @@
#include "io_timer.h"
#ifndef STANDALONE
#include "H5private.h"
#include "h5test.h"
#include "h5tools.h"
#include "h5tools_utils.h"