//--------------------------------------------------------------------------
// Function: Exception::clearErrorStack
///\brief Clears the error stack for the current thread.
///\par Description
/// The stack is also cleared whenever a C API function is
/// called, with certain exceptions (for instance, \c H5Eprint).
// Programmer Binh-Minh Ribler - 2000
//--------------------------------------------------------------------------
void Exception::clearErrorStack()
{
// calls the C API routine H5Eclear to clear the error stack
herr_t ret_value = H5Eclear2(H5E_DEFAULT);
if( ret_value < 0 )
throw Exception( "Exception::clearErrorStack", "H5Eclear failed" );
}
/*-------------------------------------------------------------------------
* Function: test_long_desc
*
* Purpose: Test long error description handling
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Quincey Koziol
* January 19, 2005
*
*-------------------------------------------------------------------------
*/
static herr_t
test_long_desc(void)
{
const char *format = "Testing very long description string, %s";
char *long_desc = NULL;
char *full_desc = NULL;
size_t u;
const char *test_FUNC = "test_long_desc";
/* Allocate space for the error description info */
if(NULL == (long_desc = (char*)HDmalloc(LONG_DESC_SIZE))) TEST_ERROR;
if(NULL == (full_desc = (char*)HDmalloc(LONG_DESC_SIZE + 128))) TEST_ERROR;
/* Create the long part of the error description */
for(u = 0; u < LONG_DESC_SIZE; u++)
long_desc[u] = 'A' + (u % 26);
long_desc[LONG_DESC_SIZE - 1] = '\0';
/* Clear the default error stack */
if(H5Eclear2(H5E_DEFAULT) < 0) TEST_ERROR;
/* Push an error with a long description */
if(H5Epush(H5E_DEFAULT, __FILE__, test_FUNC, __LINE__, ERR_CLS, ERR_MAJ_TEST, ERR_MIN_SUBROUTINE, format, long_desc) < 0) TEST_ERROR;
/* Create the string that should be in the description. Must use HDsnprintf here
* because snprintf is _snprintf on Windows */
HDsnprintf(full_desc, (size_t)(LONG_DESC_SIZE + 128), format, long_desc);
/* Make certain that the description is correct */
if(H5Ewalk2(H5E_DEFAULT, H5E_WALK_UPWARD, long_desc_cb, full_desc) < 0) TEST_ERROR;
/* Clear the default error stack again */
if(H5Eclear2(H5E_DEFAULT) < 0) TEST_ERROR;
HDfree(long_desc);
HDfree(full_desc);
return(0);
error:
if(long_desc)
HDfree(long_desc);
if(full_desc)
HDfree(full_desc);
return(-1);
} /* end test_long_desc() */
/*-------------------------------------------------------------------------
* Function: test_3
*
* Purpose: Creates a few global heap objects and then removes them all.
* The collection should also be removed.
*
* Return: Success: 0
*
* Failure: number of errors
*
* Programmer: Robb Matzke
* Tuesday, March 31, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_3 (hid_t fapl)
{
hid_t file = -1;
H5F_t *f = NULL;
H5HG_t obj[1024];
uint8_t out[1024];
int i;
size_t size;
herr_t status;
int nerrors = 0;
char filename[1024];
TESTING("complete object removal");
/* 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;
if(NULL == (f = (H5F_t *)H5I_object(file))) {
H5_FAILED();
puts(" Unable to create file");
goto error;
}
/* Create some stuff */
for (i=0; i<1024; i++) {
size = i%30+100;
memset (out, 'A'+i%26, size);
H5Eclear2(H5E_DEFAULT);
status = H5HG_insert (f, H5P_DATASET_XFER_DEFAULT, size, out, obj+i);
if (status<0) {
H5_FAILED();
puts(" Unable to insert object into global heap");
nerrors++;
}
}
/* Remove everything */
for (i=0; i<1024; i++) {
status = H5HG_remove (f, H5P_DATASET_XFER_DEFAULT, obj+i);
if (status<0) {
H5_FAILED();
puts(" Unable to remove object");
nerrors++;
}
}
if (H5Fclose(file)<0) goto error;
if (nerrors) goto error;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Fclose(file);
} H5E_END_TRY;
return MAX(1, nerrors);
}
/*
* Class: hdf_hdf5lib_H5
* Method: H5Eclear2
* Signature: (J)V
*/
JNIEXPORT void JNICALL
Java_hdf_hdf5lib_H5_H5Eclear2
(JNIEnv *env, jclass cls, jlong stk_id)
{
if (stk_id < 0) {
h5badArgument(env, "H5Eclear2: invalid argument");
} /* end if */
else if (H5Eclear2((hid_t)stk_id) < 0)
h5libraryError(env);
} /* end Java_hdf_hdf5lib_H5_H5Eclear2 */
/*-------------------------------------------------------------------------
* Function: H5FD_stdio_init
*
* Purpose: Initialize this driver by registering the driver with the
* library.
*
* Return: Success: The driver ID for the stdio driver.
*
* Failure: Negative.
*
* Programmer: Robb Matzke
* Thursday, July 29, 1999
*
*-------------------------------------------------------------------------
*/
hid_t
H5FD_stdio_init(void)
{
/* Clear the error stack */
H5Eclear2(H5E_DEFAULT);
if (H5I_VFL!=H5Iget_type(H5FD_STDIO_g))
H5FD_STDIO_g = H5FDregister(&H5FD_stdio_g);
return H5FD_STDIO_g;
} /* end H5FD_stdio_init() */
/*-------------------------------------------------------------------------
* Function: H5Pset_fapl_stdio
*
* Purpose: Modify the file access property list to use the H5FD_STDIO
* driver defined in this source file. There are no driver
* specific properties.
*
* Return: Non-negative on success/Negative on failure
*
* Programmer: Robb Matzke
* Thursday, February 19, 1998
*
*-------------------------------------------------------------------------
*/
herr_t
H5Pset_fapl_stdio(hid_t fapl_id)
{
static const char *func = "H5FDset_fapl_stdio"; /*for error reporting*/
/*NO TRACE*/
/* Clear the error stack */
H5Eclear2(H5E_DEFAULT);
if(0 == H5Pisa_class(fapl_id, H5P_FILE_ACCESS))
H5Epush_ret(func, H5E_ERR_CLS, H5E_PLIST, H5E_BADTYPE, "not a file access property list", -1)
return H5Pset_driver(fapl_id, H5FD_STDIO, NULL);
} /* end H5Pset_fapl_stdio() */
/*-------------------------------------------------------------------------
* Function: H5FD_stdio_open
*
* Purpose: Create and/or opens a Standard C file as an HDF5 file.
*
* Errors:
* IO CANTOPENFILE File doesn't exist and CREAT wasn't
* specified.
* IO CANTOPENFILE fopen() failed.
* IO FILEEXISTS File exists but CREAT and EXCL were
* specified.
*
* Return:
* Success: A pointer to a new file data structure. The
* public fields will be initialized by the
* caller, which is always H5FD_open().
*
* Failure: NULL
*
* Programmer: Robb Matzke
* Wednesday, October 22, 1997
*
*-------------------------------------------------------------------------
*/
static H5FD_t *
H5FD_stdio_open( const char *name, unsigned flags, hid_t fapl_id,
haddr_t maxaddr)
{
FILE *f = NULL;
unsigned write_access = 0; /* File opened with write access? */
H5FD_stdio_t *file = NULL;
static const char *func = "H5FD_stdio_open"; /* Function Name for error reporting */
#ifdef H5_HAVE_WIN32_API
struct _BY_HANDLE_FILE_INFORMATION fileinfo;
#else /* H5_HAVE_WIN32_API */
struct stat sb;
#endif /* H5_HAVE_WIN32_API */
/* Sanity check on file offsets */
assert(sizeof(file_offset_t) >= sizeof(size_t));
/* Quiet compiler */
fapl_id = fapl_id;
/* Clear the error stack */
H5Eclear2(H5E_DEFAULT);
/* Check arguments */
if (!name || !*name)
H5Epush_ret(func, H5E_ERR_CLS, H5E_ARGS, H5E_BADVALUE, "invalid file name", NULL)
if (0 == maxaddr || HADDR_UNDEF == maxaddr)
H5Epush_ret(func, H5E_ERR_CLS, H5E_ARGS, H5E_BADRANGE, "bogus maxaddr", NULL)
if (ADDR_OVERFLOW(maxaddr))
H5Epush_ret(func, H5E_ERR_CLS, H5E_ARGS, H5E_OVERFLOW, "maxaddr too large", NULL)
/* Tentatively open file in read-only mode, to check for existence */
if(flags & H5F_ACC_RDWR)
f = fopen(name, "rb+");
else
f = fopen(name, "rb");
if(!f) {
/* File doesn't exist */
if(flags & H5F_ACC_CREAT) {
assert(flags & H5F_ACC_RDWR);
f = fopen(name, "wb+");
write_access = 1; /* Note the write access */
}
else
H5Epush_ret(func, H5E_ERR_CLS, H5E_IO, H5E_CANTOPENFILE, "file doesn't exist and CREAT wasn't specified", NULL)
} else if(flags & H5F_ACC_EXCL) {
/*-------------------------------------------------------------------------
* Function: H5FD_stdio_open
*
* Purpose: Create and/or opens a Standard C file as an HDF5 file.
*
* Bugs: H5F_ACC_EXCL has a race condition. (? -QAK)
*
* Errors:
* IO CANTOPENFILE File doesn't exist and CREAT wasn't
* specified.
* IO CANTOPENFILE Fopen failed.
* IO FILEEXISTS File exists but CREAT and EXCL were
* specified.
*
* Return: Success: A pointer to a new file data structure. The
* public fields will be initialized by the
* caller, which is always H5FD_open().
*
* Failure: NULL
*
* Programmer: Robb Matzke
* Wednesday, October 22, 1997
*
* Modifications:
* Ported to VFL/H5FD layer - QAK, 10/18/99
*
*-------------------------------------------------------------------------
*/
static H5FD_t *
H5FD_stdio_open( const char *name, unsigned flags, hid_t fapl_id,
haddr_t maxaddr)
{
FILE *f = NULL;
unsigned write_access=0; /* File opened with write access? */
H5FD_stdio_t *file=NULL;
static const char *func="H5FD_stdio_open"; /* Function Name for error reporting */
#ifdef _WIN32
HFILE filehandle;
struct _BY_HANDLE_FILE_INFORMATION fileinfo;
int fd;
#else /* _WIN32 */
struct stat sb;
#endif /* _WIN32 */
/* Sanity check on file offsets */
assert(sizeof(file_offset_t)>=sizeof(size_t));
/* Shut compiler up */
fapl_id=fapl_id;
/* Clear the error stack */
H5Eclear2(H5E_DEFAULT);
/* Check arguments */
if (!name || !*name)
H5Epush_ret(func, H5E_ERR_CLS, H5E_ARGS, H5E_BADVALUE, "invalid file name", NULL)
if (0==maxaddr || HADDR_UNDEF==maxaddr)
H5Epush_ret(func, H5E_ERR_CLS, H5E_ARGS, H5E_BADRANGE, "bogus maxaddr", NULL)
if (ADDR_OVERFLOW(maxaddr))
H5Epush_ret(func, H5E_ERR_CLS, H5E_ARGS, H5E_OVERFLOW, "maxaddr too large", NULL)
if (access(name, F_OK) < 0) {
if ((flags & H5F_ACC_CREAT) && (flags & H5F_ACC_RDWR)) {
f = fopen(name, "wb+");
write_access=1; /* Note the write access */
}
else
H5Epush_ret(func, H5E_ERR_CLS, H5E_IO, H5E_CANTOPENFILE, "file doesn't exist and CREAT wasn't specified", NULL)
} else if ((flags & H5F_ACC_CREAT) && (flags & H5F_ACC_EXCL)) {
/*-------------------------------------------------------------------------
* Function: test_create
*
* Purpose: Test creating an empty error stack
*
* Return: Success: 0
* Failure: -1
*
* Programmer: Quincey Koziol
* November 1, 2007
*
*-------------------------------------------------------------------------
*/
static herr_t
test_create(void)
{
const char *err_func = "test_create"; /* Function name for pushing error */
const char *err_msg = "Error message"; /* Error message for pushing error */
int err_num; /* Number of errors on stack */
hid_t estack_id; /* Error stack ID */
/* Create an empty error stack */
if((estack_id = H5Ecreate_stack()) < 0) TEST_ERROR
/* Check the number of errors on stack */
err_num = H5Eget_num(estack_id);
if(err_num != 0) TEST_ERROR
/* Push an error with a long description */
if(H5Epush(estack_id, __FILE__, err_func, __LINE__, ERR_CLS, ERR_MAJ_TEST, ERR_MIN_SUBROUTINE, err_msg) < 0) TEST_ERROR;
/* Check the number of errors on stack */
err_num = H5Eget_num(estack_id);
if(err_num != 1) TEST_ERROR
/* Clear the error stack */
if(H5Eclear2(estack_id) < 0) TEST_ERROR
/* Check the number of errors on stack */
err_num = H5Eget_num(estack_id);
if(err_num != 0) TEST_ERROR
/* Close error stack */
if(H5Eclose_stack(estack_id) < 0) TEST_ERROR
return(0);
error:
return(-1);
} /* end test_create() */
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Test error API.
*
* Programmer: Raymond Lu
* July 10, 2003
*
*-------------------------------------------------------------------------
*/
int
main(void)
{
hid_t file, fapl;
hid_t estack_id;
char filename[1024];
const char *FUNC_main = "main";
HDfprintf(stderr, " This program tests the Error API. There're supposed to be some error messages\n");
/* Initialize errors */
if(init_error() < 0)
TEST_ERROR;
fapl = h5_fileaccess();
h5_fixname(FILENAME[0], fapl, filename, sizeof filename);
if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
TEST_ERROR;
/* Test error stack */
if(error_stack() < 0) {
/* Push an error onto error stack */
if(H5Epush(ERR_STACK, __FILE__, FUNC_main, __LINE__, ERR_CLS, ERR_MAJ_TEST, ERR_MIN_ERRSTACK,
"Error stack test failed") < 0) TEST_ERROR;
/* Delete an error from the top of error stack */
H5Epop(ERR_STACK, 1);
/* Make sure we can use other class's major or minor errors. */
H5Epush(ERR_STACK, __FILE__, FUNC_main, __LINE__, ERR_CLS2, ERR_MAJ_TEST, ERR_MIN_ERRSTACK,
"Error stack test failed");
/* Print out the errors on stack */
dump_error(ERR_STACK);
/* Empty error stack */
H5Eclear2(ERR_STACK);
/* Close error stack */
H5Eclose_stack(ERR_STACK);
} /* end if */
/* Test error API */
if(test_error(file) < 0) {
H5Epush(H5E_DEFAULT, __FILE__, FUNC_main, __LINE__, ERR_CLS, ERR_MAJ_TEST, ERR_MIN_SUBROUTINE,
"Error test failed, %s", "it's wrong");
estack_id = H5Eget_current_stack();
H5Eprint2(estack_id, stderr);
H5Eclose_stack(estack_id);
} /* end if */
/* Test pushing a very long error description */
if(test_long_desc() < 0) TEST_ERROR;
/* Test creating a new error stack */
if(test_create() < 0) TEST_ERROR;
/* Test copying a new error stack */
if(test_copy() < 0) TEST_ERROR;
if(H5Fclose(file) < 0) TEST_ERROR;
/* Close error information */
if(close_error() < 0)
TEST_ERROR;
/* Test error message during data reading when filter isn't registered
* Use default FAPL to avoid some VFD drivers by the check-vfd test because
* the test file was pre-generated. */
h5_fixname(DATAFILE, H5P_DEFAULT, filename, sizeof filename);
if(test_filter_error(filename) < 0)
TEST_ERROR;
h5_clean_files(FILENAME, fapl);
HDfprintf(stderr, "\nAll error API tests passed.\n");
return 0;
error:
HDfprintf(stderr, "\n***** ERROR TEST FAILED (real problem)! *****\n");
return 1;
}
/*-------------------------------------------------------------------------
* Function: test_1
*
* Purpose: Writes a sequence of objects to the global heap where each
* object is larger than the one before.
*
* Return: Success: 0
*
* Failure: number of errors
*
* Programmer: Robb Matzke
* Tuesday, March 31, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_1 (hid_t fapl)
{
hid_t file = -1;
H5F_t *f = NULL;
H5HG_t obj[1024];
uint8_t out[1024];
uint8_t in[1024];
int i;
size_t size;
herr_t status;
int nerrors = 0;
char filename[1024];
TESTING("monotonically increasing lengths");
/* 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;
if(NULL == (f = (H5F_t *)H5I_object(file))) {
H5_FAILED();
puts(" Unable to create file");
goto error;
}
/*
* Write the objects, monotonically increasing in length. Since this is
* a clean file, the addresses allocated for the collections should also
* be monotonically increasing.
*/
for(i = 0; i < 1024; i++) {
size = i + 1;
HDmemset(out, 'A' + i % 26, size);
H5Eclear2(H5E_DEFAULT);
status = H5HG_insert(f, H5P_DATASET_XFER_DEFAULT, size, out, obj + i);
if(status < 0) {
H5_FAILED();
puts(" Unable to insert object into global heap");
nerrors++;
} else if(i && H5F_addr_gt(obj[i - 1].addr, obj[i].addr)) {
H5_FAILED();
puts(" Collection addresses are not monotonically increasing");
nerrors++;
}
}
/*
* Now try to read each object back.
*/
for(i = 0; i < 1024; i++) {
size = i + 1;
HDmemset(out, 'A' + i % 26, size);
H5Eclear2(H5E_DEFAULT);
if(NULL == H5HG_read(f, H5P_DATASET_XFER_DEFAULT, obj + i, 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++;
}
}
if(H5Fclose(file) < 0) goto error;
if(nerrors) goto error;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Fclose(file);
} H5E_END_TRY;
return MAX(1, nerrors);
}
/*-------------------------------------------------------------------------
* Function: test_ooo_indices
*
* 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
*
* Failure: number of errors
*
* Programmer: Neil Fortner
* Monday, October 26, 2009
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
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];
TESTING("out of order indices");
if(NULL == (obj = (H5HG_t *)HDmalloc(2000 * sizeof(*obj))))
goto error;
/* Open a clean file */
h5_fixname(FILENAME[4], fapl, filename, sizeof filename);
if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
goto error;
if(NULL == (f = (H5F_t *)H5I_object(file))) {
H5_FAILED();
puts(" Unable to create file");
goto error;
} /* end if */
/* Alternately insert 1000 entries and remove the previous group of 1000
* entries, until the indices wrap around */
for(i=0; i<66; i++) {
/* Insert 1000 entries. The index into the obj array will alternate up
* and down by 1000 so the previous set of insertions is preserved and
* can be deleted. */
for(j=1000*((~i&1)); j<1000*((~i&1)+1); j++) {
H5Eclear2(H5E_DEFAULT);
status = H5HG_insert(f, H5P_DATASET_XFER_DEFAULT, sizeof(j), &j, &obj[j]);
if (status<0)
GHEAP_REPEATED_ERR(" Unable to insert object into global heap")
/* Check that the index is as expected */
if(obj[j].idx != ((1000 * i) + j - (1000 * ((~i & 1)))) % ((1u << 16) - 1) + 1)
GHEAP_REPEATED_ERR(" Unexpected global heap index");
} /* end for */
/* Remove the previous 1000 entries */
if(i>0)
for(j=1000*(i&1); j<1000*((i&1)+1); j++) {
H5Eclear2(H5E_DEFAULT);
status = H5HG_remove(f, H5P_DATASET_XFER_DEFAULT, &obj[j]);
if (status<0)
GHEAP_REPEATED_ERR(" Unable to remove object from global heap");
} /* end for */
} /* end for */
/* The indices should have "wrapped around" on the last iteration */
HDassert(obj[534].idx == 65535);
HDassert(obj[535].idx == 1);
/* Reopen the file */
if (H5Fclose(file)<0) goto error;
if((file = H5Fopen(filename, H5F_ACC_RDWR, fapl)) < 0)
goto error;
if(NULL == (f = (H5F_t *)H5I_object(file))) {
H5_FAILED();
puts(" Unable to open file");
goto error;
} /* end if */
/* Read the objects to make sure the heap is still readable */
for(i=0; i<1000; i++) {
if(NULL == H5HG_read(f, H5P_DATASET_XFER_DEFAULT, &obj[i], &j, NULL))
goto error;
if(i != j) {
H5_FAILED();
puts(" Incorrect read value");
goto error;
} /* end if */
} /* end for */
if (H5Fclose(file)<0) goto error;
if (nerrors) goto error;
HDfree(obj);
obj = NULL;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Fclose(file);
} H5E_END_TRY;
if(obj)
HDfree(obj);
return MAX(1, nerrors);
} /* end test_ooo_indices */
/*-------------------------------------------------------------------------
* 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.
*
* Return: Success: 0
*
* Failure: number of errors
*
* Programmer: Robb Matzke
* Tuesday, March 31, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_4 (hid_t fapl)
{
hid_t file = -1;
H5F_t *f = NULL;
H5HG_t obj[1024];
uint8_t out[1024];
int i;
size_t size;
herr_t status;
int nerrors = 0;
char filename[1024];
TESTING("partial object removal");
/* 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;
if(NULL == (f = (H5F_t *)H5I_object(file))) {
H5_FAILED();
puts(" Unable to create file");
goto error;
}
for (i=0; i<1024; i++) {
/* Insert */
size = i%30+100;
memset (out, 'A'+i%26, size);
H5Eclear2(H5E_DEFAULT);
status = H5HG_insert (f, H5P_DATASET_XFER_DEFAULT, size, out, obj+i);
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==i%3) {
H5Eclear2(H5E_DEFAULT);
status = H5HG_remove (f, H5P_DATASET_XFER_DEFAULT, obj+i-1);
if (status<0) {
H5_FAILED();
puts(" Unable to remove object");
nerrors++;
}
memset (obj+i-1, 0, sizeof *obj);
}
}
if (H5Fclose(file)<0) goto error;
if (nerrors) goto error;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Fclose(file);
} H5E_END_TRY;
return MAX(1, nerrors);
}
/*-------------------------------------------------------------------------
* Function: test_2
*
* Purpose: Writes a sequence of objects to the global heap where each
* object is smaller than the one before.
*
* Return: Success: 0
*
* Failure: number of errors
*
* Programmer: Robb Matzke
* Tuesday, March 31, 1998
*
* Modifications:
*
*-------------------------------------------------------------------------
*/
static int
test_2 (hid_t fapl)
{
hid_t file = -1;
H5F_t *f = NULL;
H5HG_t obj[1024];
uint8_t out[1024];
uint8_t in[1024];
int i;
size_t size;
int nerrors = 0;
char filename[1024];
TESTING("monotonically decreasing lengths");
/* 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;
if(NULL == (f = (H5F_t *)H5I_object(file))) {
H5_FAILED();
puts(" Unable to create file");
goto error;
}
/*
* Write the objects, monotonically decreasing in length.
*/
for (i=0; i<1024; i++) {
size = 1024-i;
memset (out, 'A'+i%26, size);
H5Eclear2(H5E_DEFAULT);
if (H5HG_insert (f, H5P_DATASET_XFER_DEFAULT, size, out, obj+i)<0) {
H5_FAILED();
puts(" Unable to insert object into global heap");
nerrors++;
}
}
/*
* Now try to read each object back.
*/
for (i=0; i<1024; i++) {
size = 1024-i;
memset (out, 'A'+i%26, size);
H5Eclear2(H5E_DEFAULT);
if (NULL==H5HG_read (f, H5P_DATASET_XFER_DEFAULT, obj+i, 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++;
}
}
if (H5Fclose(file)<0) goto error;
if (nerrors) goto error;
PASSED();
return 0;
error:
H5E_BEGIN_TRY {
H5Fclose(file);
} H5E_END_TRY;
return MAX(1, nerrors);
}
