summaryrefslogtreecommitdiffstats
path: root/test
diff options
context:
space:
mode:
authorQuincey Koziol <koziol@hdfgroup.org>2010-10-19 19:11:23 (GMT)
committerQuincey Koziol <koziol@hdfgroup.org>2010-10-19 19:11:23 (GMT)
commit63ebb100e4aa4d2cc1117ca7ebc67a2f071119d1 (patch)
tree1a4395f0c53513b3b824b861ca4b27ac74d5db16 /test
parent3c470c9db63424d8a07c1fb789ee8e8c513dd2a6 (diff)
downloadhdf5-63ebb100e4aa4d2cc1117ca7ebc67a2f071119d1.zip
hdf5-63ebb100e4aa4d2cc1117ca7ebc67a2f071119d1.tar.gz
hdf5-63ebb100e4aa4d2cc1117ca7ebc67a2f071119d1.tar.bz2
[svn-r19641] Description:
Bring r19542:19639 from trunk to revise_chunks branch. Tested on: FreeBSD/32 6.3 (duty) in debug mode FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode Linux/32 2.6 (jam) w/PGI compilers, w/default API=1.8.x, w/C++ & FORTRAN, w/threadsafe, in debug mode Linux/64-amd64 2.6 (amani) w/Intel compilers, w/default API=1.6.x, w/C++ & FORTRAN, in production mode Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN, w/szip filter, w/threadsafe, in production mode Linux/PPC 2.6 (heiwa) w/C++ & FORTRAN, w/threadsafe, in debug mode Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN, in production mode Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in debug mode Mac OS X/32 10.6.4 (amazon) in debug mode Mac OS X/32 10.6.4 (amazon) w/C++ & FORTRAN, w/threadsafe, in production mode Mac OS X/32 10.6.4 (amazon) w/parallel, in debug mode
Diffstat (limited to 'test')
-rw-r--r--test/CMakeLists.txt1
-rw-r--r--test/Makefile.am6
-rw-r--r--test/Makefile.in69
-rw-r--r--test/accum.c1809
-rw-r--r--test/err_compat.c394
-rw-r--r--test/ohdr.c175
-rw-r--r--test/testerror.sh.in2
-rw-r--r--test/testfiles/err_compat_140
8 files changed, 2374 insertions, 122 deletions
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 7e12026..2bed576 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -241,6 +241,7 @@ ADD_TEST (
)
SET (H5_TESTS
+ accum
lheap
ohdr
stab
diff --git a/test/Makefile.am b/test/Makefile.am
index 42545d1..1a29873 100644
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -36,8 +36,8 @@ SCRIPT_DEPEND = error_test$(EXEEXT) err_compat$(EXEEXT)
# These tests (fheap, btree2) are under development and are not used by
# the library yet. Move them to the end so that their failure do not block
# other current library code tests.
-TEST_PROG=testhdf5 lheap ohdr stab gheap cache cache_api cache_tagging \
- pool hyperslab istore bittests dt_arith \
+TEST_PROG= testhdf5 lheap ohdr stab gheap cache cache_api cache_tagging \
+ pool accum hyperslab istore bittests dt_arith \
dtypes dsets cmpd_dset filter_fail extend external objcopy links unlink \
big mtime fillval mount flush1 flush2 app_ref enum \
set_extent ttsafe \
@@ -106,7 +106,7 @@ flush2.chkexe_: flush1.chkexe_
# specifying a file prefix or low-level driver. Changing the file
# prefix or low-level driver with environment variables will influence
# the temporary file name in ways that the makefile is not aware of.
-CHECK_CLEANFILES+=cmpd_dset.h5 compact_dataset.h5 dataset.h5 \
+CHECK_CLEANFILES+=accum.h5 cmpd_dset.h5 compact_dataset.h5 dataset.h5 \
dset_offset.h5 \
max_compact_dataset.h5 simple.h5 set_local.h5 random_chunks.h5 \
huge_chunks.h5 chunk_cache.h5 big_chunk.h5 chunk_fast.h5 \
diff --git a/test/Makefile.in b/test/Makefile.in
index 89a2e30..1d42982 100644
--- a/test/Makefile.in
+++ b/test/Makefile.in
@@ -81,18 +81,18 @@ libh5test_la_OBJECTS = $(am_libh5test_la_OBJECTS)
am__installdirs = "$(DESTDIR)$(bindir)"
am__EXEEXT_1 = testhdf5$(EXEEXT) lheap$(EXEEXT) ohdr$(EXEEXT) \
stab$(EXEEXT) gheap$(EXEEXT) cache$(EXEEXT) cache_api$(EXEEXT) \
- cache_tagging$(EXEEXT) pool$(EXEEXT) hyperslab$(EXEEXT) \
- istore$(EXEEXT) bittests$(EXEEXT) dt_arith$(EXEEXT) \
- dtypes$(EXEEXT) dsets$(EXEEXT) cmpd_dset$(EXEEXT) \
- filter_fail$(EXEEXT) extend$(EXEEXT) external$(EXEEXT) \
- objcopy$(EXEEXT) links$(EXEEXT) unlink$(EXEEXT) big$(EXEEXT) \
- mtime$(EXEEXT) fillval$(EXEEXT) mount$(EXEEXT) flush1$(EXEEXT) \
- flush2$(EXEEXT) app_ref$(EXEEXT) enum$(EXEEXT) \
- set_extent$(EXEEXT) ttsafe$(EXEEXT) getname$(EXEEXT) \
- vfd$(EXEEXT) ntypes$(EXEEXT) dangle$(EXEEXT) \
- dtransform$(EXEEXT) reserved$(EXEEXT) cross_read$(EXEEXT) \
- freespace$(EXEEXT) mf$(EXEEXT) farray$(EXEEXT) earray$(EXEEXT) \
- btree2$(EXEEXT) fheap$(EXEEXT)
+ cache_tagging$(EXEEXT) pool$(EXEEXT) accum$(EXEEXT) \
+ hyperslab$(EXEEXT) istore$(EXEEXT) bittests$(EXEEXT) \
+ dt_arith$(EXEEXT) dtypes$(EXEEXT) dsets$(EXEEXT) \
+ cmpd_dset$(EXEEXT) filter_fail$(EXEEXT) extend$(EXEEXT) \
+ external$(EXEEXT) objcopy$(EXEEXT) links$(EXEEXT) \
+ unlink$(EXEEXT) big$(EXEEXT) mtime$(EXEEXT) fillval$(EXEEXT) \
+ mount$(EXEEXT) flush1$(EXEEXT) flush2$(EXEEXT) \
+ app_ref$(EXEEXT) enum$(EXEEXT) set_extent$(EXEEXT) \
+ ttsafe$(EXEEXT) getname$(EXEEXT) vfd$(EXEEXT) ntypes$(EXEEXT) \
+ dangle$(EXEEXT) dtransform$(EXEEXT) reserved$(EXEEXT) \
+ cross_read$(EXEEXT) freespace$(EXEEXT) mf$(EXEEXT) \
+ farray$(EXEEXT) earray$(EXEEXT) btree2$(EXEEXT) fheap$(EXEEXT)
am__EXEEXT_2 = gen_bad_ohdr$(EXEEXT) gen_bogus$(EXEEXT) \
gen_cross$(EXEEXT) gen_deflate$(EXEEXT) gen_filters$(EXEEXT) \
gen_idx$(EXEEXT) gen_new_array$(EXEEXT) gen_new_fill$(EXEEXT) \
@@ -102,6 +102,10 @@ am__EXEEXT_2 = gen_bad_ohdr$(EXEEXT) gen_bogus$(EXEEXT) \
space_overflow$(EXEEXT) gen_filespace$(EXEEXT) \
gen_specmetaread$(EXEEXT) gen_sizes_lheap$(EXEEXT)
PROGRAMS = $(bin_PROGRAMS) $(noinst_PROGRAMS)
+accum_SOURCES = accum.c
+accum_OBJECTS = accum.$(OBJEXT)
+accum_LDADD = $(LDADD)
+accum_DEPENDENCIES = libh5test.la $(LIBHDF5)
app_ref_SOURCES = app_ref.c
app_ref_OBJECTS = app_ref.$(OBJEXT)
app_ref_LDADD = $(LDADD)
@@ -405,22 +409,7 @@ CCLD = $(CC)
LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
$(LDFLAGS) -o $@
-SOURCES = $(libh5test_la_SOURCES) app_ref.c big.c bittests.c btree2.c \
- cache.c cache_api.c cache_tagging.c cmpd_dset.c cross_read.c \
- dangle.c dsets.c dt_arith.c dtransform.c dtypes.c earray.c \
- enum.c err_compat.c error_test.c extend.c external.c farray.c \
- fheap.c fillval.c filter_fail.c flush1.c flush2.c freespace.c \
- gen_bad_ohdr.c gen_bogus.c gen_cross.c gen_deflate.c \
- gen_filespace.c gen_filters.c gen_idx.c gen_new_array.c \
- gen_new_fill.c gen_new_group.c gen_new_mtime.c gen_new_super.c \
- gen_noencoder.c gen_nullspace.c gen_sizes_lheap.c \
- gen_specmetaread.c gen_udlinks.c getname.c gheap.c hyperslab.c \
- istore.c lheap.c links.c mf.c mount.c mtime.c ntypes.c \
- objcopy.c ohdr.c pool.c reserved.c set_extent.c \
- space_overflow.c stab.c swmr_generator.c swmr_reader.c \
- swmr_writer.c tcheck_version.c $(testhdf5_SOURCES) testmeta.c \
- $(ttsafe_SOURCES) unlink.c vfd.c
-DIST_SOURCES = $(libh5test_la_SOURCES) app_ref.c big.c bittests.c \
+SOURCES = $(libh5test_la_SOURCES) accum.c app_ref.c big.c bittests.c \
btree2.c cache.c cache_api.c cache_tagging.c cmpd_dset.c \
cross_read.c dangle.c dsets.c dt_arith.c dtransform.c dtypes.c \
earray.c enum.c err_compat.c error_test.c extend.c external.c \
@@ -436,6 +425,22 @@ DIST_SOURCES = $(libh5test_la_SOURCES) app_ref.c big.c bittests.c \
swmr_reader.c swmr_writer.c tcheck_version.c \
$(testhdf5_SOURCES) testmeta.c $(ttsafe_SOURCES) unlink.c \
vfd.c
+DIST_SOURCES = $(libh5test_la_SOURCES) accum.c app_ref.c big.c \
+ bittests.c btree2.c cache.c cache_api.c cache_tagging.c \
+ cmpd_dset.c cross_read.c dangle.c dsets.c dt_arith.c \
+ dtransform.c dtypes.c earray.c enum.c err_compat.c \
+ error_test.c extend.c external.c farray.c fheap.c fillval.c \
+ filter_fail.c flush1.c flush2.c freespace.c gen_bad_ohdr.c \
+ gen_bogus.c gen_cross.c gen_deflate.c gen_filespace.c \
+ gen_filters.c gen_idx.c gen_new_array.c gen_new_fill.c \
+ gen_new_group.c gen_new_mtime.c gen_new_super.c \
+ gen_noencoder.c gen_nullspace.c gen_sizes_lheap.c \
+ gen_specmetaread.c gen_udlinks.c getname.c gheap.c hyperslab.c \
+ istore.c lheap.c links.c mf.c mount.c mtime.c ntypes.c \
+ objcopy.c ohdr.c pool.c reserved.c set_extent.c \
+ space_overflow.c stab.c swmr_generator.c swmr_reader.c \
+ swmr_writer.c tcheck_version.c $(testhdf5_SOURCES) testmeta.c \
+ $(ttsafe_SOURCES) unlink.c vfd.c
ETAGS = etags
CTAGS = ctags
am__tty_colors = \
@@ -715,7 +720,7 @@ TRACE = perl $(top_srcdir)/bin/trace
# specifying a file prefix or low-level driver. Changing the file
# prefix or low-level driver with environment variables will influence
# the temporary file name in ways that the makefile is not aware of.
-CHECK_CLEANFILES = *.chkexe *.chklog *.clog cmpd_dset.h5 \
+CHECK_CLEANFILES = *.chkexe *.chklog *.clog accum.h5 cmpd_dset.h5 \
compact_dataset.h5 dataset.h5 dset_offset.h5 \
max_compact_dataset.h5 simple.h5 set_local.h5 random_chunks.h5 \
huge_chunks.h5 chunk_cache.h5 big_chunk.h5 chunk_fast.h5 \
@@ -753,7 +758,7 @@ SCRIPT_DEPEND = error_test$(EXEEXT) err_compat$(EXEEXT)
# the library yet. Move them to the end so that their failure do not block
# other current library code tests.
TEST_PROG = testhdf5 lheap ohdr stab gheap cache cache_api cache_tagging \
- pool hyperslab istore bittests dt_arith \
+ pool accum hyperslab istore bittests dt_arith \
dtypes dsets cmpd_dset filter_fail extend external objcopy links unlink \
big mtime fillval mount flush1 flush2 app_ref enum \
set_extent ttsafe \
@@ -927,6 +932,9 @@ clean-noinstPROGRAMS:
list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
echo " rm -f" $$list; \
rm -f $$list
+accum$(EXEEXT): $(accum_OBJECTS) $(accum_DEPENDENCIES)
+ @rm -f accum$(EXEEXT)
+ $(LINK) $(accum_OBJECTS) $(accum_LDADD) $(LIBS)
app_ref$(EXEEXT): $(app_ref_OBJECTS) $(app_ref_DEPENDENCIES)
@rm -f app_ref$(EXEEXT)
$(LINK) $(app_ref_OBJECTS) $(app_ref_LDADD) $(LIBS)
@@ -1144,6 +1152,7 @@ mostlyclean-compile:
distclean-compile:
-rm -f *.tab.c
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/accum.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/app_ref.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/big.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bittests.Po@am__quote@
diff --git a/test/accum.c b/test/accum.c
new file mode 100644
index 0000000..c5f6610
--- /dev/null
+++ b/test/accum.c
@@ -0,0 +1,1809 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by the Board of Trustees of the University of Illinois. *
+ * All rights reserved. *
+ * *
+ * This file is part of HDF5. The full HDF5 copyright notice, including *
+ * terms governing use, modification, and redistribution, is contained in *
+ * the files COPYING and Copyright.html. COPYING can be found at the root *
+ * of the source code distribution tree; Copyright.html can be found at the *
+ * root level of an installed copy of the electronic HDF5 document set and *
+ * is linked from the top-level documents page. It can also be found at *
+ * http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
+ * access to either file, you may request a copy from help@hdfgroup.org. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/* Programmer: Mike McGreevy
+ * October 7, 2010
+ */
+#include "h5test.h"
+
+#define H5F_PACKAGE
+#include "H5Fpkg.h"
+#include "H5FDprivate.h"
+#include "H5Iprivate.h"
+
+/* Filename */
+#define FILENAME "accum.h5"
+
+/* "big" I/O test values */
+#define BIG_BUF_SIZE (6 * 1024 * 1024)
+
+/* Random I/O test values */
+#define RANDOM_BUF_SIZE (1 * 1024 * 1024)
+#define MAX_RANDOM_SEGMENTS (5 * 1024)
+#define RAND_SEG_LEN (1024)
+#define RANDOM_BASE_OFF (1024 * 1024)
+
+/* Make file global to all tests */
+H5F_t * f = NULL;
+
+/* Function Prototypes */
+unsigned test_write_read(void);
+unsigned test_write_read_nonacc_front(void);
+unsigned test_write_read_nonacc_end(void);
+unsigned test_accum_overlap(void);
+unsigned test_accum_overlap_clean(void);
+unsigned test_accum_overlap_size(void);
+unsigned test_accum_non_overlap_size(void);
+unsigned test_accum_adjust(void);
+unsigned test_read_after(void);
+unsigned test_free(void);
+unsigned test_big(void);
+unsigned test_random_write(void);
+
+/* Helper Function Prototypes */
+void accum_printf(void);
+
+/* Private Test H5Faccum Function Wrappers */
+#define accum_write(a,s,b) H5F_block_write(f, H5FD_MEM_DEFAULT, (haddr_t)(a), (size_t)(s), H5P_DATASET_XFER_DEFAULT, (b))
+#define accum_read(a,s,b) H5F_block_read(f, H5FD_MEM_DEFAULT, (haddr_t)(a), (size_t)(s), H5P_DATASET_XFER_DEFAULT, (b))
+#define accum_free(a,s) H5F_accum_free(f, H5P_DATASET_XFER_DEFAULT, H5FD_MEM_DEFAULT, (haddr_t)(a), (hsize_t)(s))
+#define accum_flush() H5F_accum_flush(f, H5P_DATASET_XFER_DEFAULT)
+#define accum_reset() H5F_accum_reset(f, H5P_DATASET_XFER_DEFAULT, TRUE)
+
+/* ================= */
+/* Main Test Routine */
+/* ================= */
+
+
+/*-------------------------------------------------------------------------
+ * Function: main
+ *
+ * Purpose: Test the metadata accumulator code
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Mike McGreevy
+ * October 7, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+main(void)
+{
+ unsigned nerrors = 0; /* track errors */
+ hid_t fid = -1;
+
+ /* Test Setup */
+ puts("Testing the metadata accumulator");
+
+ /* Create a test file */
+ if((fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) FAIL_STACK_ERROR
+
+ /* Get H5F_t * to internal file structure */
+ if(NULL == (f = (H5F_t *)H5I_object(fid))) FAIL_STACK_ERROR
+
+ /* We'll be writing lots of garbage data, so extend the
+ file a ways. 10MB should do. */
+ if(H5FD_set_eoa(f->shared->lf, H5FD_MEM_DEFAULT, (haddr_t)(1024*1024*10)) < 0) FAIL_STACK_ERROR
+
+ /* Reset metadata accumulator for the file */
+ if(accum_reset() < 0) FAIL_STACK_ERROR
+
+ /* Test Functions */
+ nerrors += test_write_read();
+ nerrors += test_write_read_nonacc_front();
+ nerrors += test_write_read_nonacc_end();
+ nerrors += test_accum_overlap();
+ nerrors += test_accum_overlap_clean();
+ nerrors += test_accum_overlap_size();
+ nerrors += test_accum_non_overlap_size();
+ nerrors += test_accum_adjust();
+ nerrors += test_read_after();
+ nerrors += test_free();
+ nerrors += test_big();
+ nerrors += test_random_write();
+
+ /* End of test code, close and delete file */
+ if(H5Fclose(fid) < 0) TEST_ERROR
+ HDremove(FILENAME);
+
+ if(nerrors)
+ goto error;
+ puts("All metadata accumulator tests passed.");
+
+ return 0;
+
+error:
+ puts("*** TESTS FAILED ***");
+ return 1;
+} /* end main() */
+
+/* ============================= */
+/* Individual Unit Test Routines */
+/* ============================= */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_write_read
+ *
+ * Purpose: Simple test to write to then read from metadata accumulator.
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Mike McGreevy
+ * October 7, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+unsigned
+test_write_read(void)
+{
+ int i = 0;
+ int *write_buf, *read_buf;
+
+ TESTING("simple write/read to/from metadata accumulator");
+
+ /* Allocate buffers */
+ write_buf = (int *)HDmalloc(1024 * sizeof(int));
+ HDassert(write_buf);
+ read_buf = (int *)HDcalloc(1024, sizeof(int));
+ HDassert(read_buf);
+
+ /* Fill buffer with data, zero out read buffer */
+ for(i = 0; i < 1024; i++)
+ write_buf[i] = i + 1;
+
+ /* Do a simple write/read/verify of data */
+ /* Write 1KB at Address 0 */
+ if(accum_write(0, 1024, write_buf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(0, 1024, read_buf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(write_buf, read_buf, 1024) != 0) TEST_ERROR;
+
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ PASSED();
+
+ /* Release memory */
+ HDfree(write_buf);
+ HDfree(read_buf);
+
+ return 0;
+
+error:
+ /* Release memory */
+ HDfree(write_buf);
+ HDfree(read_buf);
+
+ return 1;
+} /* test_write_read */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_write_read_nonacc_front
+ *
+ * Purpose: Simple test to write to then read from before metadata accumulator.
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Allen Byrne
+ * October 8, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+unsigned
+test_write_read_nonacc_front(void)
+{
+ int i = 0;
+ int *write_buf, *read_buf;
+
+ TESTING("simple write/read to/from before metadata accumulator");
+
+ /* Allocate buffers */
+ write_buf = (int *)HDmalloc(2048 * sizeof(int));
+ HDassert(write_buf);
+ read_buf = (int *)HDcalloc(2048, sizeof(int));
+ HDassert(read_buf);
+
+ /* Fill buffer with data, zero out read buffer */
+ for(i = 0; i < 2048; i++)
+ write_buf[i] = i + 1;
+
+ /* Do a simple write/read/verify of data */
+ /* Write 1KB at Address 0 */
+ if(accum_write(0, 1024, write_buf) < 0) FAIL_STACK_ERROR;
+ if(accum_flush() < 0) FAIL_STACK_ERROR;
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+ if(accum_write(1024, 1024, write_buf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(0, 1024, read_buf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(write_buf, read_buf, 1024) != 0) TEST_ERROR;
+
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ PASSED();
+
+ /* Release memory */
+ HDfree(write_buf);
+ HDfree(read_buf);
+
+ return 0;
+
+error:
+ /* Release memory */
+ HDfree(write_buf);
+ HDfree(read_buf);
+
+ return 1;
+} /* test_write_read */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_write_read_nonacc_end
+ *
+ * Purpose: Simple test to write to then read from after metadata accumulator.
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Allen Byrne
+ * October 8, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+unsigned
+test_write_read_nonacc_end(void)
+{
+ int i = 0;
+ int *write_buf, *read_buf;
+
+ TESTING("simple write/read to/from after metadata accumulator");
+
+ /* Allocate buffers */
+ write_buf = (int *)HDmalloc(2048 * sizeof(int));
+ HDassert(write_buf);
+ read_buf = (int *)HDcalloc(2048, sizeof(int));
+ HDassert(read_buf);
+
+ /* Fill buffer with data, zero out read buffer */
+ for(i = 0; i < 2048; i++)
+ write_buf[i] = i + 1;
+
+ /* Do a simple write/read/verify of data */
+ /* Write 1KB at Address 0 */
+ if(accum_write(1024, 1024, write_buf) < 0) FAIL_STACK_ERROR;
+ if(accum_flush() < 0) FAIL_STACK_ERROR;
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+ if(accum_write(0, 1024, write_buf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(1024, 1024, read_buf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(write_buf, read_buf, 1024) != 0) TEST_ERROR;
+
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ PASSED();
+
+ /* Release memory */
+ HDfree(write_buf);
+ HDfree(read_buf);
+
+ return 0;
+
+error:
+ /* Release memory */
+ HDfree(write_buf);
+ HDfree(read_buf);
+
+ return 1;
+} /* test_write_read */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_free
+ *
+ * Purpose: Simple test to free metadata accumulator.
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Raymond Lu
+ * October 8, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+unsigned
+test_free(void)
+{
+ int i = 0;
+ int32_t *wbuf = NULL;
+ int32_t *rbuf = NULL;
+ int32_t *expect = NULL;
+
+ TESTING("simple freeing metadata accumulator");
+
+ /* Write and free the whole accumulator. */
+ wbuf = (int32_t *)HDmalloc(256 * sizeof(int32_t));
+ HDassert(wbuf);
+ rbuf = (int32_t *)HDmalloc(256 * sizeof(int32_t));
+ HDassert(rbuf);
+ expect = (int32_t *)HDmalloc(256 * sizeof(int32_t));
+ HDassert(expect);
+
+ /* Fill buffer with data */
+ for(i = 0; i < 256; i++)
+ wbuf[i] = (int32_t)(i + 1);
+
+ if(accum_write(0, 256 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+
+ if(accum_free(0, 256 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR;
+
+ /* Free an empty accumulator */
+ if(accum_free(0, 256 * 1024 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR;
+
+ /* Write second quarter of the accumulator */
+ if(accum_write(64 * sizeof(int32_t), 64 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Free the second quarter of the accumulator, the requested area
+ * is bigger than the data region on the right side. */
+ if(accum_free(64 * sizeof(int32_t), 65 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR;
+
+
+ /* Write half of the accumulator. */
+ if(accum_write(0, 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Free the first block of 4B */
+ if(accum_free(0, sizeof(int32_t)) < 0) FAIL_STACK_ERROR;
+
+ /* Check that the accumulator still contains the correct data */
+ if(accum_read(1 * sizeof(int32_t), 127 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf + 1, rbuf, 127 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Free the block of 4B at 127*4B */
+ if(accum_free(127 * sizeof(int32_t), sizeof(int32_t)) < 0) FAIL_STACK_ERROR;
+
+ /* Check that the accumulator still contains the correct data */
+ if(accum_read(1 * sizeof(int32_t), 126 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf + 1, rbuf, 126 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Free the block of 4B at 2*4B */
+ if(accum_free(2 * sizeof(int32_t), sizeof(int32_t)) < 0) FAIL_STACK_ERROR;
+
+ /* Check that the accumulator still contains the correct data */
+ if(accum_read(1 * sizeof(int32_t), 1 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf + 1, rbuf, 1 * sizeof(int32_t)) != 0) TEST_ERROR;
+ if(accum_read(3 * sizeof(int32_t), 124 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf + 3, rbuf, 124 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+
+ /* Test freeing section that overlaps the start of the accumulator and is
+ * entirely before dirty section */
+ if(accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ HDmemcpy(expect + 64, wbuf, 128 * sizeof(int32_t));
+ if(accum_flush() < 0) FAIL_STACK_ERROR;
+ if(accum_write(68 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ HDmemcpy(expect + 68, wbuf, 4 * sizeof(int32_t));
+ if(accum_free(62 * sizeof(int32_t), 4 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR;
+
+ /* Check that the accumulator still contains the correct data */
+ if(accum_read(66 * sizeof(int32_t), 126 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(expect + 66, rbuf, 126 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+
+ /* Test freeing section that overlaps the start of the accumulator and
+ * completely contains dirty section */
+ if(accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ HDmemcpy(expect + 64, wbuf, 128 * sizeof(int32_t));
+ if(accum_flush() < 0) FAIL_STACK_ERROR;
+ if(accum_write(68 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ HDmemcpy(expect + 68, wbuf, 4 * sizeof(int32_t));
+ if(accum_free(62 * sizeof(int32_t), 16 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR;
+
+ /* Check that the accumulator still contains the correct data */
+ if(accum_read(78 * sizeof(int32_t), 114 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(expect + 78, rbuf, 114 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+
+ /* Test freeing section completely contained in accumulator and is entirely
+ * before dirty section */
+ if(accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ HDmemcpy(expect + 64, wbuf, 128 * sizeof(int32_t));
+ if(accum_flush() < 0) FAIL_STACK_ERROR;
+ if(accum_write(72 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ HDmemcpy(expect + 72, wbuf, 4 * sizeof(int32_t));
+ if(accum_free(66 * sizeof(int32_t), 4 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR;
+
+ /* Check that the accumulator still contains the correct data */
+ if(accum_read(70 * sizeof(int32_t), 122 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(expect + 70, rbuf, 122 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+
+ /* Test freeing section completely contained in accumulator, starts before
+ * dirty section, and ends in dirty section */
+ if(accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ HDmemcpy(expect + 64, wbuf, 128 * sizeof(int32_t));
+ if(accum_flush() < 0) FAIL_STACK_ERROR;
+ if(accum_write(72 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ HDmemcpy(expect + 72, wbuf, 4 * sizeof(int32_t));
+ if(accum_free(70 * sizeof(int32_t), 4 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR;
+
+ /* Check that the accumulator still contains the correct data */
+ if(accum_read(74 * sizeof(int32_t), 118 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(expect + 74, rbuf, 118 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+
+ /* Test freeing section completely contained in accumulator and completely
+ * contains dirty section */
+ if(accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ HDmemcpy(expect + 64, wbuf, 128 * sizeof(int32_t));
+ if(accum_flush() < 0) FAIL_STACK_ERROR;
+ if(accum_write(72 * sizeof(int32_t), 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ HDmemcpy(expect + 72, wbuf, 4 * sizeof(int32_t));
+ if(accum_free(70 * sizeof(int32_t), 8 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR;
+
+ /* Check that the accumulator still contains the correct data */
+ if(accum_read(78 * sizeof(int32_t), 114 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(expect + 78, rbuf, 114 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+
+ /* Test freeing section completely contained in accumulator, starts at start
+ * of dirty section, and ends in dirty section */
+ if(accum_write(64 * sizeof(int32_t), 128 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ HDmemcpy(expect + 64, wbuf, 128 * sizeof(int32_t));
+ if(accum_flush() < 0) FAIL_STACK_ERROR;
+ if(accum_write(72 * sizeof(int32_t), 8 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ HDmemcpy(expect + 72, wbuf, 8 * sizeof(int32_t));
+ if(accum_free(72 * sizeof(int32_t), 4 * sizeof(int32_t)) < 0) FAIL_STACK_ERROR;
+
+ /* Check that the accumulator still contains the correct data */
+ if(accum_read(76 * sizeof(int32_t), 116 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(expect + 76, rbuf, 116 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ HDfree(wbuf);
+ HDfree(rbuf);
+ HDfree(expect);
+
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ PASSED();
+
+ return 0;
+
+error:
+ HDfree(wbuf);
+ HDfree(rbuf);
+ HDfree(expect);
+
+ return 1;
+} /* test_free */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_accum_overlap
+ *
+ * Purpose: This test will write a series of pieces of data
+ * to the accumulator with the goal of overlapping
+ * the writes in various different ways.
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Mike McGreevy
+ * October 7, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+unsigned
+test_accum_overlap(void)
+{
+ int i = 0;
+ int32_t *wbuf, *rbuf;
+
+ TESTING("overlapping write to metadata accumulator");
+
+ /* Allocate buffers */
+ wbuf = (int32_t *)HDmalloc(4096 * sizeof(int32_t));
+ HDassert(wbuf);
+ rbuf = (int32_t *)HDcalloc(4096, sizeof(int32_t));
+ HDassert(rbuf);
+
+ /* Case 1: No metadata in accumulator */
+ /* Write 10 1's at address 40 */
+ /* @0:| 1111111111| */
+ /* Put some data in the accumulator initially */
+ for(i = 0; i < 10; i++)
+ wbuf[i] = 1;
+ if(accum_write(40, 10 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(40, 10 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 10 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 2: End of new piece aligns with start of accumulated data */
+ /* Write 5 2's at address 20 */
+ /* @0:| 222221111111111| */
+ for(i = 0; i < 5; i++)
+ wbuf[i] = 2;
+ if(accum_write(20, 5 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(20, 5 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 5 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 3: Start of new piece aligns with start of accumulated data */
+ /* Write 3 3's at address 20 */
+ /* @0:| 333221111111111| */
+ for(i = 0; i < 3; i++)
+ wbuf[i] = 3;
+ if(accum_write(20, 3 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(20, 3 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 4: New piece overlaps start of accumulated data */
+ /* Write 5 4's at address 8 */
+ /* @0:| 444443221111111111| */
+ for(i = 0; i < 5; i++)
+ wbuf[i] = 4;
+ if(accum_write(8, 5 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(8, 5 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 5 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 5: New piece completely within accumulated data */
+ /* Write 4 5's at address 48 */
+ /* @0:| 444443221155551111| */
+ for(i = 0; i < 4; i++)
+ wbuf[i] = 5;
+ if(accum_write(48, 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(48, 4 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 4 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 6: End of new piece aligns with end of accumulated data */
+ /* Write 3 6's at address 68 */
+ /* @0:| 444443221155551666| */
+ for(i = 0; i < 3; i++)
+ wbuf[i] = 6;
+ if(accum_write(68, 3 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(68, 3 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 7: New piece overlaps end of accumulated data */
+ /* Write 5 7's at address 76 */
+ /* @0:| 4444432211555516677777| */
+ for(i = 0; i < 5; i++)
+ wbuf[i] = 7;
+ if(accum_write(76, 5 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(76, 5 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 5 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 8: Start of new piece aligns with end of accumulated data */
+ /* Write 3 8's at address 96 */
+ /* @0:| 4444432211555516677777888| */
+ for(i = 0; i < 3; i++)
+ wbuf[i] = 8;
+ if(accum_write(96, 3 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(96, 3 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Set up expected data buffer and verify contents of
+ accumulator as constructed by cases 1-8, above */
+ for(i = 0; i < 5; i++)
+ wbuf[i] = 4;
+ for(i = 5; i < 6; i++)
+ wbuf[i] = 3;
+ for(i = 6; i < 8; i++)
+ wbuf[i] = 2;
+ for(i = 8; i < 10; i++)
+ wbuf[i] = 1;
+ for(i = 10; i < 14; i++)
+ wbuf[i] = 5;
+ for(i = 14; i < 15; i++)
+ wbuf[i] = 1;
+ for(i = 15; i < 17; i++)
+ wbuf[i] = 6;
+ for(i = 17; i < 22; i++)
+ wbuf[i] = 7;
+ for(i = 22; i < 25; i++)
+ wbuf[i] = 8;
+ if(accum_read(8, 25 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 25 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 9: New piece completely before accumulated data */
+ /* Write 1 9 at address 0 */
+ /* @0:|9 4444432211555516677777888| */
+ for(i = 0; i < 1; i++)
+ wbuf[i] = 9;
+ if(accum_write(0, 1 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(0, 1 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 1 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 10: New piece completely after accumulated data */
+ /* Write 4 3's at address 116 */
+ /* @0:|9 4444432211555516677777888 3333| */
+ for(i = 0; i < 4; i++)
+ wbuf[i] = 3;
+ if(accum_write(116, 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(116, 4 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 4 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 11: New piece completely overlaps accumulated data */
+ /* Write 6 4's at address 112 */
+ /* @0:|9 4444432211555516677777888 444444| */
+ for(i = 0; i < 6; i++)
+ wbuf[i] = 4;
+ if(accum_write(112, 6 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(112, 6 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 6 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ PASSED();
+
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+
+ return 0;
+
+error:
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+
+ return 1;
+} /* test_accum_overlap */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_accum_overlap_clean
+ *
+ * Purpose: This test will write a series of pieces of data
+ * to the accumulator with the goal of overlapping
+ * the writes in various different ways, with clean
+ * areas in the accumulator.
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Neil Fortner
+ * October 8, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+unsigned
+test_accum_overlap_clean(void)
+{
+ int i = 0;
+ int32_t *wbuf, *rbuf;
+
+ TESTING("overlapping write to partially clean metadata accumulator");
+
+ /* Allocate buffers */
+ wbuf = (int32_t *)HDmalloc(4096 * sizeof(int32_t));
+ HDassert(wbuf);
+ rbuf = (int32_t *)HDcalloc(4096, sizeof(int32_t));
+ HDassert(rbuf);
+
+ /* Case 1: No metadata in accumulator */
+ /* Write 10 1's at address 40 */
+ /* @0:| 1111111111| */
+ /* Put some data in the accumulator initially */
+ for(i = 0; i < 10; i++)
+ wbuf[i] = 1;
+ if(accum_write(40, 10 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(40, 10 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 10 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 2: End of new piece aligns with start of clean accumulated data */
+ /* Write 5 2's at address 20 */
+ /* @0:| 222221111111111| */
+ if(accum_flush() < 0) FAIL_STACK_ERROR;
+ for(i = 0; i < 5; i++)
+ wbuf[i] = 2;
+ if(accum_write(20, 5 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(20, 5 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 5 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 3: Start of new piece aligns with start of accumulated data,
+ * completely encloses dirty section of accumulator */
+ /* Write 6 3's at address 20 */
+ /* @0:| 333333111111111| */
+ for(i = 0; i < 6; i++)
+ wbuf[i] = 3;
+ if(accum_write(20, 6 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(20, 6 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 6 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 4: New piece completely within accumulated data, overlaps
+ * end of dirty section of accumulator */
+ /* Write 2 4's at address 40 */
+ /* @0:| 333334411111111| */
+ for(i = 0; i < 2; i++)
+ wbuf[i] = 4;
+ if(accum_write(40, 2 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(40, 2 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 2 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 5: New piece completely within accumulated data, completely
+ * after dirty section of accumulator */
+ /* Write 2 5's at address 52 */
+ /* @0:| 333334415511111| */
+ for(i = 0; i < 2; i++)
+ wbuf[i] = 5;
+ if(accum_write(52, 2 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(52, 2 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 2 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 6: New piece completely within clean accumulated data */
+ /* Write 3 6's at address 44 */
+ /* @0:| 333334666511111| */
+ if(accum_flush() < 0) FAIL_STACK_ERROR;
+ for(i = 0; i < 3; i++)
+ wbuf[i] = 6;
+ if(accum_write(44, 3 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(44, 3 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 7: New piece overlaps start of clean accumulated data */
+ /* Write 2 7's at address 16 */
+ /* @0:| 7733334666511111| */
+ if(accum_flush() < 0) FAIL_STACK_ERROR;
+ for(i = 0; i < 2; i++)
+ wbuf[i] = 7;
+ if(accum_write(16, 2 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(16, 2 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 2 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 8: New piece overlaps start of accumulated data, completely
+ * encloses dirty section of accumulator */
+ /* Write 4 8's at address 12 */
+ /* @0:| 88883334666511111| */
+ for(i = 0; i < 4; i++)
+ wbuf[i] = 8;
+ if(accum_write(12, 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(12, 4 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 4 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 9: Start of new piece aligns with end of clean accumulated data */
+ /* Write 3 9's at address 80 */
+ /* @0:| 88883334666511111999| */
+ if(accum_flush() < 0) FAIL_STACK_ERROR;
+ for(i = 0; i < 3; i++)
+ wbuf[i] = 9;
+ if(accum_write(80, 3 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(80, 3 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 3 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 10: New piece overlaps end of clean accumulated data */
+ /* Write 3 2's at address 88 */
+ /* @0:| 888833346665111119922| */
+ if(accum_flush() < 0) FAIL_STACK_ERROR;
+ for(i = 0; i < 2; i++)
+ wbuf[i] = 2;
+ if(accum_write(88, 2 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(88, 2 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 2 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 11: New piece overlaps end of accumulated data, completely encloses
+ * dirty section of accumulator */
+ /* Write 4 7's at address 84 */
+ /* @0:| 8888333466651111197777| */
+ for(i = 0; i < 4; i++)
+ wbuf[i] = 7;
+ if(accum_write(84, 4 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(84, 4 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 4 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Set up expected data buffer and verify contents of
+ accumulator as constructed by cases 1-11, above */
+ for(i = 0; i < 4; i++)
+ wbuf[i] = 8;
+ for(i = 4; i < 7; i++)
+ wbuf[i] = 3;
+ for(i = 7; i < 8; i++)
+ wbuf[i] = 4;
+ for(i = 8; i < 11; i++)
+ wbuf[i] = 6;
+ for(i = 11; i < 12; i++)
+ wbuf[i] = 5;
+ for(i = 12; i < 17; i++)
+ wbuf[i] = 1;
+ for(i = 17; i < 18; i++)
+ wbuf[i] = 9;
+ for(i = 18; i < 22; i++)
+ wbuf[i] = 7;
+ if(accum_read(12, 22 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 22 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ PASSED();
+
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+
+ return 0;
+
+error:
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+
+ return 1;
+} /* test_accum_overlap_clean */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_accum_non_overlap_size
+ *
+ * Purpose: This test will write a series of pieces of data
+ * to the accumulator with the goal of not overlapping
+ * the writes with a data size larger then the accum size.
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Allen Byrne
+ * October 8, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+unsigned
+test_accum_non_overlap_size(void)
+{
+ int i = 0;
+ int32_t *wbuf, *rbuf;
+
+ TESTING("non-overlapping write to accumulator larger then accum_size");
+
+ /* Allocate buffers */
+ wbuf = (int *)HDmalloc(4096 * sizeof(int32_t));
+ HDassert(wbuf);
+ rbuf = (int *)HDcalloc(4096, sizeof(int32_t));
+ HDassert(rbuf);
+
+ /* Case 1: No metadata in accumulator */
+ /* Write 10 1's at address 140 */
+ /* @0:| 1111111111| */
+ /* Put some data in the accumulator initially */
+ for(i = 0; i < 10; i++)
+ wbuf[i] = 1;
+ if(accum_write(140, 10 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(140, 10 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 10 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 9: New piece completely before accumulated data */
+ /* Write 20 9 at address 0 */
+ /* @0:|9 1111111111| */
+ for(i = 0; i < 20; i++)
+ wbuf[i] = 9;
+ if(accum_write(0, 20 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(0, 20 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 20 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ PASSED();
+
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+
+ return 0;
+
+error:
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+
+ return 1;
+} /* test_accum_non_overlap_size */
+
+/*-------------------------------------------------------------------------
+ * Function: test_accum_overlap_size
+ *
+ * Purpose: This test will write a series of pieces of data
+ * to the accumulator with the goal of overlapping
+ * the writes with a data size completely overlapping
+ * the accumulator at both ends.
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Allen Byrne
+ * October 8, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+unsigned
+test_accum_overlap_size(void)
+{
+ int i = 0;
+ int32_t *wbuf, *rbuf;
+
+ TESTING("overlapping write to accumulator larger then accum_size");
+
+ /* Allocate buffers */
+ wbuf = (int32_t *)HDmalloc(4096 * sizeof(int32_t));
+ HDassert(wbuf);
+ rbuf = (int32_t *)HDcalloc(4096, sizeof(int32_t));
+ HDassert(rbuf);
+
+ /* Case 1: No metadata in accumulator */
+ /* Write 10 1's at address 64 */
+ /* @0:| 1111111111| */
+ /* Put some data in the accumulator initially */
+ for(i = 0; i < 10; i++)
+ wbuf[i] = 1;
+ if(accum_write(64, 10 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(64, 10 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 10 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ /* Case 9: New piece completely before accumulated data */
+ /* Write 72 9 at address 60 */
+ /* @0:|9 1111111111| */
+ for(i = 0; i < 72; i++)
+ wbuf[i] = 9;
+ if(accum_write(60, 72 * sizeof(int32_t), wbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(60, 72 * sizeof(int32_t), rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 72 * sizeof(int32_t)) != 0) TEST_ERROR;
+
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ PASSED();
+
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+
+ return 0;
+
+error:
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+
+ return 1;
+} /* test_accum_overlap_size */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_accum_adjust
+ *
+ * Purpose: This test examines the various ways the accumulator might
+ * adjust itself as a result of data appending or prepending
+ * to it.
+ *
+ * This test program covers all the code in H5F_accum_adjust,
+ * but NOT all possible paths through said code. It only covers
+ * six potential paths through the function. (Again, though, each
+ * piece of code within an if/else statement in H5F_accum_adjust is
+ * covered by one of the paths in this test function). Since there
+ * are a ridiculous number of total possible paths through this
+ * function due to its large number of embedded if/else statements,
+ * that's certainly a lot of different test cases to write by hand.
+ * (Though if someone comes across this code and has some free
+ * time, go for it).
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Mike McGreevy
+ * October 11, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+unsigned
+test_accum_adjust(void)
+{
+ int i = 0;
+ int s = 1048576; /* size of buffer */
+ int32_t *wbuf, *rbuf;
+
+ TESTING("accumulator adjustments after append/prepend of data");
+
+ /* Allocate buffers */
+ wbuf = (int32_t *)HDmalloc((size_t)s * sizeof(int32_t));
+ HDassert(wbuf);
+ rbuf = (int32_t *)HDcalloc((size_t)s, sizeof(int32_t));
+ HDassert(rbuf);
+
+ /* Fill up write buffer */
+ for(i = 0; i < s; i++)
+ wbuf[i] = i + 1;
+
+ /* ================================================================ */
+ /* CASE 1: Prepending small block to large, fully dirty accumulator */
+ /* ================================================================ */
+
+ /* Write data to the accumulator to fill it just under 1MB (max size),
+ * but not quite full. This will force the accumulator to, on subsequent
+ * writes, a) have to adjust since it's nearly full, and b) prevent
+ * an increase in size because it's already at it's maximum size */
+ if(accum_write((1024 * 1024), (1024 * 1024) - 1, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write a small (1KB) block that prepends to the front of the accumulator. */
+ /* ==> Accumulator will need more buffer space */
+ /* ==> Accumulator will try to resize, but see that it's getting too big */
+ /* ==> Size of new block is less than half maximum size of accumulator */
+ /* ==> New block is being prepended to accumulator */
+ /* ==> Accumulator is dirty, it will be flushed. */
+ /* ==> Dirty region overlaps region to eliminate from accumulator */
+ if(accum_write((1024 * 1024) - 1024, 1024, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read back and verify first write */
+ if(accum_read((1024 * 1024), (1024 * 1024) - 1, rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, (1024 * 1024) - 1) != 0) TEST_ERROR;
+
+ /* Read back and verify second write */
+ if(accum_read((1024 * 1024) - 1024, 1024, rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 1024) != 0) TEST_ERROR;
+
+ /* Reset accumulator for next case */
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ /* ================================================================ */
+ /* Case 2: Prepending large block to large, fully dirty accumulator */
+ /* ================================================================ */
+
+ /* Write data to the accumulator to fill it just under 1MB (max size),
+ * but not quite full. This will force the accumulator to, on subsequent
+ * writes, a) have to adjust since it's nearly full, and b) prevent
+ * an increase in size because it's already at it's maximum size */
+ if(accum_write((1024 * 1024), (1024 * 1024) - 1, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write a large (just under 1MB) block to the front of the accumulator. */
+ /* ==> Accumulator will need more buffer space */
+ /* ==> Accumulator will try to resize, but see that it's getting too big */
+ /* ==> Size of new block is larger than half maximum size of accumulator */
+ /* ==> New block is being prepended to accumulator */
+ /* ==> Accumulator is dirty, it will be flushed. */
+ /* ==> Dirty region overlaps region to eliminate from accumulator */
+ if(accum_write(5, (1024 * 1024) - 5, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read back and verify both pieces of data */
+ if(accum_read(1048576, 1048575, rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 1048576) != 0) TEST_ERROR;
+
+ if(accum_read(5, 1048571, rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 1048571) != 0) TEST_ERROR;
+
+ /* Reset accumulator for next case */
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ /* ========================================================= */
+ /* Case 3: Appending small block to large, clean accumulator */
+ /* ========================================================= */
+
+ /* Write data to the accumulator to fill it just under 1MB (max size),
+ * but not quite full. This will force the accumulator to, on subsequent
+ * writes, a) have to adjust since it's nearly full, and b) prevent
+ * an increase in size because it's already at it's maximum size */
+ if(accum_write(0, (1024 * 1024) - 1, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Flush the accumulator -- we want to test the case when
+ accumulator contains clean data */
+ if(accum_flush() < 0) FAIL_STACK_ERROR
+
+ /* Write a small (1KB) block to the end of the accumulator */
+ /* ==> Accumulator will need more buffer space */
+ /* ==> Accumulator will try to resize, but see that it's getting too big */
+ /* ==> Size of new block is larger than half maximum size of accumulator */
+ /* ==> New block being appended to accumulator */
+ /* ==> Accumulator is NOT dirty */
+ /* ==> Since we're appending, need to adjust location of accumulator */
+ if(accum_write((1024 * 1024) - 1, 1024, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write a piece of metadata outside current accumulator to force write
+ to disk */
+ if(accum_write(0, 1, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read in the piece we wrote to disk above, and then verify that
+ the data is as expected */
+ if(accum_read((1024 * 1024) - 1, 1024, rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 1024) != 0) TEST_ERROR;
+
+ /* Reset accumulator for next case */
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ /* ==================================================================== */
+ /* Case 4: Appending small block to large, partially dirty accumulator, */
+ /* with existing dirty region NOT aligning with the new block */
+ /* ==================================================================== */
+
+ /* Write data to the accumulator to fill it just under 1MB (max size),
+ * but not quite full. This will force the accumulator to, on subsequent
+ * writes, a) have to adjust since it's nearly full, and b) prevent
+ * an increase in size because it's already at it's maximum size */
+ if(accum_write(0, (1024 * 1024) - 5, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Flush the accumulator to clean it */
+ if(accum_flush() < 0) FAIL_STACK_ERROR
+
+ /* write to part of the accumulator so just the start of it is dirty */
+ if(accum_write(0, 5, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write a small (~340KB) piece of data to the other end of the accumulator */
+ /* ==> Accumulator will need more buffer space */
+ /* ==> Accumulator will try to resize, but see that it's getting too big */
+ /* ==> Size of new block is less than than half maximum size of accumulator */
+ /* ==> New block being appended to accumulator */
+ /* ==> We can slide the dirty region down, to accomodate the request */
+ /* ==> Max Buffer Size - (dirty offset + adjust size) >= 2 * size) */
+ /* ==> Need to adjust location of accumulator while appending */
+ /* ==> Accumulator will need to be reallocated */
+ if(accum_write(1048571, 349523, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write a piece of metadata outside current accumulator to force write
+ to disk */
+ if(accum_write(1398900, 1, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read in the piece we wrote to disk above, and then verify that
+ the data is as expected */
+ if(accum_read(1048571, 349523, rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 349523) != 0) TEST_ERROR;
+
+ /* Reset accumulator for next case */
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ /* ==================================================================== */
+ /* Case 5: Appending small block to large, partially dirty accumulator, */
+ /* with existing dirty region aligning with new block */
+ /* ==================================================================== */
+
+ /* Write data to the accumulator to fill it just under max size (but not full) */
+ if(accum_write(0, (1024 * 1024) - 5, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Flush the accumulator to clean it */
+ if(accum_flush() < 0) FAIL_STACK_ERROR
+
+ /* write to part of the accumulator so it's dirty, but not entirely dirty */
+ /* (just the begging few bytes will be clean) */
+ if(accum_write(10, (1024 * 1024) - 15, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write a small piece of data to the dirty end of the accumulator */
+ /* ==> Accumulator will need more buffer space */
+ /* ==> Accumulator will try to resize, but see that it's getting too big */
+ /* ==> Size of new block is less than than half maximum size of accumulator */
+ /* ==> New block being appended to accumulator */
+ /* ==> We can slide the dirty region down, to accomodate the request */
+ /* ==> Max Buffer Size - (dirty offset + adjust size) < 2 * size) */
+ /* ==> Need to adjust location of accumulator while appending */
+ if(accum_write((1024 * 1024) - 5, 10, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write a piece of metadata outside current accumulator to force write
+ to disk */
+ if(accum_write(0, 1, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read in the piece we wrote to disk above, and then verify that
+ the data is as expected */
+ if(accum_read((1024 * 1024) - 5, 10, rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 10) != 0) TEST_ERROR;
+
+ /* Reset accumulator for next case */
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ /* ================================================================= */
+ /* Case 6: Appending small block to large, fully dirty accumulator */
+ /* ================================================================= */
+
+ /* Write data to the accumulator to fill it just under 1MB (max size),
+ * but not quite full. This will force the accumulator to, on subsequent
+ * writes, a) have to adjust since it's nearly full, and b) prevent
+ * an increase in size because it's already at it's maximum size */
+ if(accum_write(0, (1024 * 1024) - 5, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write a small (~340KB) piece of data to the end of the accumulator */
+ /* ==> Accumulator will need more buffer space */
+ /* ==> Accumulator will try to resize, but see that it's getting too big */
+ /* ==> Size of new block is less than than half maximum size of accumulator */
+ /* ==> New block being appended to accumulator */
+ /* ==> We cannot slide dirty region down, it's all dirty */
+ /* ==> Dirty region overlaps region to eliminate from accumulator */
+ /* ==> Need to adjust location of accumulator while appending */
+ if(accum_write(1048571, 349523, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write a piece of metadata outside current accumulator to force write
+ to disk */
+ if(accum_write(1398900, 1, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read in the piece we wrote to disk above, and then verify that
+ the data is as expected */
+ if(accum_read(1048571, 349523, rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 349523) != 0) TEST_ERROR;
+
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ PASSED();
+
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+
+ return 0;
+
+error:
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+
+ return 1;
+} /* test_accum_adjust */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_read_after
+ *
+ * Purpose: This test will verify the case when metadata is read partly
+ * from the accumulator and partly from disk. The test will
+ * write a block of data at address 512, force the data to be
+ * written to disk, write new data partially overlapping the
+ * original block from below, then read data at address 512.
+ * The data read should be partly new and partly original.
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Larry Knox
+ * October 8, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+unsigned
+test_read_after(void)
+{
+ int i = 0;
+ int s = 128; /* size of buffer */
+ int32_t *wbuf, *rbuf;
+
+ TESTING("reading data from both accumulator and disk");
+
+ /* Allocate buffers */
+ wbuf = (int32_t *)HDmalloc((size_t)s * sizeof(int32_t));
+ HDassert(wbuf);
+ rbuf = (int32_t *)HDcalloc((size_t)s, sizeof(int32_t));
+ HDassert(rbuf);
+
+ /* Fill up write buffer with 1s */
+ for(i = 0; i < s; i++)
+ wbuf[i] = 1;
+
+ /* Write data to the accumulator to fill it. */
+ if(accum_write(512, 512, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write a piece of metadata outside current accumulator to force write
+ to disk */
+ if(accum_write(0, 1, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Fill up write buffer with 2s */
+ for(i = 0; i < s; i++)
+ wbuf[i] = 2;
+
+ /* Write a block of 2s of the original size that will overlap the lower half
+ of the original block */
+ if(accum_write(256, 512, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read 128 bytes at the original address, and then */
+ if(accum_read(512, 512, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Set the second half of wbuf back to 1s */
+ for(i = 64; i < s; i++)
+ wbuf[i] = 1;
+
+ /* Read in the piece we wrote to disk above, and then verify that
+ the data is as expected */
+ if(accum_read(512, 512, rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf, rbuf, 128) != 0) TEST_ERROR;
+
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ PASSED();
+
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+
+ return 0;
+
+error:
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+
+ return 1;
+} /* end test_read_after */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_big
+ *
+ * Purpose: This test exercises writing large pieces of metadata to the
+ * file.
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Quincey Koziol
+ * October 12, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+unsigned
+test_big(void)
+{
+ uint8_t *wbuf, *wbuf2, *rbuf, *zbuf; /* Buffers for reading & writing, etc */
+ unsigned u; /* Local index variable */
+
+ /* Allocate space for the write & read buffers */
+ wbuf = (uint8_t *)HDmalloc(BIG_BUF_SIZE);
+ HDassert(wbuf);
+ wbuf2 = (uint8_t *)HDmalloc(BIG_BUF_SIZE);
+ HDassert(wbuf2);
+ rbuf = (uint8_t *)HDcalloc(BIG_BUF_SIZE + 1536, 1);
+ HDassert(rbuf);
+ zbuf = (uint8_t *)HDcalloc(BIG_BUF_SIZE + 1536, 1);
+ HDassert(zbuf);
+
+ /* Initialize write buffers */
+ for(u = 0; u < BIG_BUF_SIZE; u++) {
+ wbuf[u] = (uint8_t)u;
+ wbuf2[u] = (uint8_t)(u + 1);
+ } /* end for */
+
+ TESTING("large metadata I/O operations");
+
+ /* Write large data segment to file */
+ if(accum_write(0, BIG_BUF_SIZE, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read entire segment back from file */
+ if(accum_read(0, BIG_BUF_SIZE, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Verify data read */
+ if(HDmemcmp(wbuf, rbuf, BIG_BUF_SIZE) != 0) TEST_ERROR;
+
+
+ /* Reset data in file back to zeros & reset the read buffer */
+ if(accum_write(0, BIG_BUF_SIZE, zbuf) < 0) FAIL_STACK_ERROR;
+ HDmemset(rbuf, 0, BIG_BUF_SIZE);
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+
+ /* Write small section to middle of accumulator */
+ if(accum_write(1024, 1024, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read entire segment back from file */
+ /* (Read covers entire dirty region) */
+ if(accum_read(0, BIG_BUF_SIZE, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Verify data read */
+ if(HDmemcmp(zbuf, rbuf, 1024) != 0) TEST_ERROR;
+ if(HDmemcmp(wbuf, rbuf + 1024, 1024) != 0) TEST_ERROR;
+ if(HDmemcmp(zbuf, rbuf + 2048, (BIG_BUF_SIZE - 2048)) != 0) TEST_ERROR;
+
+
+ /* Reset data in file back to zeros & reset the read buffer */
+ if(accum_write(1024, 1024, zbuf) < 0) FAIL_STACK_ERROR;
+ HDmemset(rbuf, 0, BIG_BUF_SIZE);
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+
+ /* Write small section to overlap with end of "big" region */
+ if(accum_write(BIG_BUF_SIZE - 512, 1024, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read entire segment back from file */
+ /* (Read covers bottom half of dirty region) */
+ if(accum_read(0, BIG_BUF_SIZE, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Verify data read */
+ if(HDmemcmp(zbuf, rbuf, (BIG_BUF_SIZE - 512)) != 0) TEST_ERROR;
+ if(HDmemcmp(wbuf, rbuf + (BIG_BUF_SIZE - 512), 512) != 0) TEST_ERROR;
+
+
+ /* Reset data in file back to zeros & reset the read buffer */
+ if(accum_write(BIG_BUF_SIZE - 512, 1024, zbuf) < 0) FAIL_STACK_ERROR;
+ HDmemset(rbuf, 0, BIG_BUF_SIZE);
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+
+ /* Write small section to overlap with beginning of "big" region */
+ if(accum_write(0, 1024, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read entire segment back from file */
+ /* (Read covers bottom half of dirty region) */
+ if(accum_read(512, BIG_BUF_SIZE, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Verify data read */
+ if(HDmemcmp(wbuf + 512, rbuf, 512) != 0) TEST_ERROR;
+ if(HDmemcmp(zbuf, rbuf + 512, (BIG_BUF_SIZE - 512)) != 0) TEST_ERROR;
+
+
+ /* Reset data in file back to zeros & reset the read buffer */
+ if(accum_write(0, 1024, zbuf) < 0) FAIL_STACK_ERROR;
+ HDmemset(rbuf, 0, BIG_BUF_SIZE);
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+
+ /* Write small section to middle of accumulator */
+ /* (With write buffer #1) */
+ if(accum_write(1024, 1024, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write entire segment to from file */
+ /* (With write buffer #2) */
+ /* (Write covers entire dirty region) */
+ if(accum_write(0, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR;
+
+ /* Read entire segment back from file */
+ if(accum_read(0, BIG_BUF_SIZE, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Verify data read */
+ if(HDmemcmp(wbuf2, rbuf, BIG_BUF_SIZE) != 0) TEST_ERROR;
+
+
+ /* Reset data in file back to zeros & reset the read buffer */
+ if(accum_write(0, BIG_BUF_SIZE, zbuf) < 0) FAIL_STACK_ERROR;
+ HDmemset(rbuf, 0, BIG_BUF_SIZE);
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+
+ /* Write small section to overlap with end of "big" region */
+ /* (With write buffer #1) */
+ if(accum_write(BIG_BUF_SIZE - 512, 1024, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write entire segment to from file */
+ /* (With write buffer #2) */
+ /* (Read covers bottom half of dirty region) */
+ if(accum_write(0, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR;
+
+ /* Read both segments back from file */
+ if(accum_read(0, BIG_BUF_SIZE + 512, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Verify data read */
+ if(HDmemcmp(wbuf2, rbuf, BIG_BUF_SIZE) != 0) TEST_ERROR;
+ if(HDmemcmp(wbuf + 512, rbuf + BIG_BUF_SIZE, 512) != 0) TEST_ERROR;
+
+
+ /* Reset data in file back to zeros & reset the read buffer */
+ if(accum_write(0, BIG_BUF_SIZE + 512, zbuf) < 0) FAIL_STACK_ERROR;
+ HDmemset(rbuf, 0, BIG_BUF_SIZE + 512);
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+
+ /* Write small section to be past "big" region */
+ /* (With write buffer #1) */
+ if(accum_write(BIG_BUF_SIZE + 512, 1024, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read section before "big" region */
+ /* (To enlarge accumulator, to it will intersect with big write) */
+ if(accum_read(BIG_BUF_SIZE - 512, 1024, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write entire segment to from file */
+ /* (With write buffer #2) */
+ /* (Doesn't overlap with small section) */
+ if(accum_write(0, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR;
+
+ /* Read both segments & gap back from file */
+ if(accum_read(0, BIG_BUF_SIZE + 1024, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Verify data read */
+ if(HDmemcmp(wbuf2, rbuf, BIG_BUF_SIZE) != 0) TEST_ERROR;
+ if(HDmemcmp(zbuf, rbuf + BIG_BUF_SIZE, 512) != 0) TEST_ERROR;
+ if(HDmemcmp(wbuf, rbuf + BIG_BUF_SIZE + 512, 512) != 0) TEST_ERROR;
+
+
+ /* Reset data in file back to zeros & reset the read buffer */
+ if(accum_write(0, BIG_BUF_SIZE + 1536, zbuf) < 0) FAIL_STACK_ERROR;
+ HDmemset(rbuf, 0, BIG_BUF_SIZE + 1024);
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+
+ /* Write small section to be past "big" region */
+ /* (With write buffer #1) */
+ if(accum_write(BIG_BUF_SIZE + 512, 1024, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read section before "big" region */
+ /* (To enlarge accumulator, so it will intersect with big write) */
+ if(accum_read(BIG_BUF_SIZE - 512, 1024, rbuf) < 0) FAIL_STACK_ERROR;
+ if(accum_read(BIG_BUF_SIZE + 1536, 1024, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write entire segment to from file */
+ /* (With write buffer #2) */
+ /* (Overwriting dirty region, but not invalidating entire accumulator) */
+ if(accum_write(1536, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR;
+
+ /* Read both segments & gap back from file */
+ if(accum_read(0, BIG_BUF_SIZE + 1536, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Verify data read */
+ if(HDmemcmp(zbuf, rbuf, 1536) != 0) TEST_ERROR;
+ if(HDmemcmp(wbuf2, rbuf + 1536, BIG_BUF_SIZE) != 0) TEST_ERROR;
+
+
+ /* Reset data in file back to zeros & reset the read buffer */
+ if(accum_write(1536, BIG_BUF_SIZE, zbuf) < 0) FAIL_STACK_ERROR;
+ HDmemset(rbuf, 0, BIG_BUF_SIZE + 1536);
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+
+ /* Write small section before "big" region */
+ /* (With write buffer #1) */
+ if(accum_write(1024, 1024, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read section before "big" region */
+ /* (To enlarge accumulator, so it will intersect with big write) */
+ if(accum_read(0, 1024, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write entire segment to from file */
+ /* (With write buffer #2) */
+ /* (Overwriting dirty region, but not invalidating entire accumulator) */
+ if(accum_write(512, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR;
+
+ /* Read both segments & gap back from file */
+ if(accum_read(0, BIG_BUF_SIZE + 512, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Verify data read */
+ if(HDmemcmp(zbuf, rbuf, 512) != 0) TEST_ERROR;
+ if(HDmemcmp(wbuf2, rbuf + 512, BIG_BUF_SIZE) != 0) TEST_ERROR;
+
+
+ /* Reset data in file back to zeros & reset the read buffer */
+ if(accum_write(512, BIG_BUF_SIZE, zbuf) < 0) FAIL_STACK_ERROR;
+ HDmemset(rbuf, 0, BIG_BUF_SIZE + 512);
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+
+ /* Write small section before "big" region */
+ /* (With write buffer #1) */
+ if(accum_write(0, 1024, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read section before "big" region */
+ /* (To enlarge accumulator, so it will intersect with big write) */
+ if(accum_read(1024, 1024, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write entire segment to from file */
+ /* (With write buffer #2) */
+ /* (Avoiding dirty region, and not invalidating entire accumulator) */
+ if(accum_write(1536, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR;
+
+ /* Read both segments & gap back from file */
+ if(accum_read(0, BIG_BUF_SIZE + 1536, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Verify data read */
+ if(HDmemcmp(wbuf, rbuf, 1024) != 0) TEST_ERROR;
+ if(HDmemcmp(zbuf, rbuf + 1024, 512) != 0) TEST_ERROR;
+ if(HDmemcmp(wbuf2, rbuf + 1536, BIG_BUF_SIZE) != 0) TEST_ERROR;
+
+
+ /* Reset data in file back to zeros & reset the read buffer */
+ if(accum_write(0, BIG_BUF_SIZE + 1536, zbuf) < 0) FAIL_STACK_ERROR;
+ HDmemset(rbuf, 0, BIG_BUF_SIZE + 1536);
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+
+ /* Write small section before "big" region */
+ /* (With write buffer #1) */
+ if(accum_write(0, 1024, wbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Read section before "big" region */
+ /* (To enlarge accumulator, so it will intersect with big write) */
+ if(accum_read(1024, 1024, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Write entire segment to from file */
+ /* (With write buffer #2) */
+ /* (Partially overwriting dirty region, and not invalidating entire accumulator) */
+ if(accum_write(512, BIG_BUF_SIZE, wbuf2) < 0) FAIL_STACK_ERROR;
+
+ /* Read both segments back from file */
+ if(accum_read(0, BIG_BUF_SIZE + 512, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Verify data read */
+ if(HDmemcmp(wbuf, rbuf, 512) != 0) TEST_ERROR;
+ if(HDmemcmp(wbuf2, rbuf + 512, BIG_BUF_SIZE) != 0) TEST_ERROR;
+
+
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ PASSED();
+
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(wbuf2);
+ HDfree(rbuf);
+ HDfree(zbuf);
+
+ return 0;
+
+error:
+ HDfree(wbuf);
+ HDfree(wbuf2);
+ HDfree(rbuf);
+ HDfree(zbuf);
+
+ return 1;
+} /* end test_big() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_random_write
+ *
+ * Purpose: This test writes random pieces of data to the file and
+ * then reads it all back.
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Quincey Koziol
+ * October 11, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+unsigned
+test_random_write(void)
+{
+ uint8_t *wbuf, *rbuf; /* Buffers for reading & writing */
+ unsigned long seed = 0; /* Random # seed */
+ size_t *off; /* Offset of buffer segments to write */
+ size_t *len; /* Size of buffer segments to write */
+ size_t cur_off; /* Current offset */
+ size_t nsegments; /* Number of segments to write */
+ size_t swap; /* Position to swap with */
+ unsigned u; /* Local index variable */
+
+ /* Allocate space for the write & read buffers */
+ wbuf = (uint8_t *)malloc(RANDOM_BUF_SIZE);
+ HDassert(wbuf);
+ rbuf = (uint8_t *)calloc(RANDOM_BUF_SIZE, 1);
+ HDassert(rbuf);
+
+ /* Initialize write buffer */
+ for(u = 0; u < RANDOM_BUF_SIZE; u++)
+ wbuf[u] = (uint8_t)u;
+
+ TESTING("random writes to accumulator");
+
+ /* Choose random # seed */
+ seed = (unsigned long)HDtime(NULL);
+#ifdef QAK
+/* seed = (unsigned long)1155438845; */
+HDfprintf(stderr, "Random # seed was: %lu\n", seed);
+#endif /* QAK */
+ HDsrandom(seed);
+
+ /* Allocate space for the segment length buffer */
+ off = (size_t *)malloc(MAX_RANDOM_SEGMENTS * sizeof(size_t));
+ HDassert(off);
+ len = (size_t *)malloc(MAX_RANDOM_SEGMENTS * sizeof(size_t));
+ HDassert(len);
+
+ /* Randomly choose lengths of segments */
+ cur_off = 0;
+ for(u = 0; u < MAX_RANDOM_SEGMENTS; ) {
+ size_t length = 0; /* Length of current segment */
+
+ /* Choose random length of segment, allowing for variance */
+ do {
+ length += (size_t)(HDrandom() % RAND_SEG_LEN) + 1;
+ } while((HDrandom() & 256) >= 128); /* end while */
+
+ /* Check for going off end of buffer */
+ if((cur_off + length) > RANDOM_BUF_SIZE)
+ length = RANDOM_BUF_SIZE - cur_off;
+
+ /* Set offset & length of segment */
+ off[u] = cur_off;
+ len[u] = length;
+
+ /* Advance array offset */
+ u++;
+
+ /* Advance current offset */
+ cur_off += length;
+
+ /* If we've used up entire buffer before hitting limit of segments, get out */
+ if(cur_off >= RANDOM_BUF_SIZE)
+ break;
+ } /* end for */
+ nsegments = u;
+
+ /* Increase length of last segment, if it doesn't reach end of buffer */
+ if(nsegments < MAX_RANDOM_SEGMENTS)
+ len[nsegments - 1] = RANDOM_BUF_SIZE - off[nsegments - 1];
+
+ /* Shuffle order of segments, to randomize positions to write */
+ for(u = 0; u < nsegments; u++) {
+ size_t tmp; /* Temporary holder for offset & length values */
+
+ /* Choose value within next few elements to to swap with */
+ swap = ((size_t)HDrandom() % 8) + u;
+ if(swap >= nsegments)
+ swap = nsegments - 1;
+
+ /* Swap values */
+ tmp = off[u]; off[u] = off[swap]; off[swap] = tmp;
+ tmp = len[u]; len[u] = len[swap]; len[swap] = tmp;
+ } /* end for */
+
+ /* Write data segments to file */
+ for(u = 0; u < nsegments; u++) {
+ if(accum_write(RANDOM_BASE_OFF + off[u], len[u], wbuf + off[u]) < 0) FAIL_STACK_ERROR;
+
+ /* Verify individual reads */
+ if(accum_read(RANDOM_BASE_OFF + off[u], len[u], rbuf) < 0) FAIL_STACK_ERROR;
+ if(HDmemcmp(wbuf + off[u], rbuf, len[u]) != 0) TEST_ERROR;
+ } /* end for */
+
+ /* Read entire region back from file */
+ if(accum_read(RANDOM_BASE_OFF, RANDOM_BUF_SIZE, rbuf) < 0) FAIL_STACK_ERROR;
+
+ /* Verify data read back in */
+ if(HDmemcmp(wbuf, rbuf, RANDOM_BUF_SIZE) != 0) TEST_ERROR;
+
+ if(accum_reset() < 0) FAIL_STACK_ERROR;
+
+ PASSED();
+
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+ HDfree(off);
+ HDfree(len);
+
+ return 0;
+
+error:
+ /* Release memory */
+ HDfree(wbuf);
+ HDfree(rbuf);
+ HDfree(off);
+ HDfree(len);
+
+ HDfprintf(stderr, "Random # seed was: %lu\n", seed);
+ return 1;
+} /* end test_random_write() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: accum_printf
+ *
+ * Purpose: Debug function to print some stats about the accumulator
+ *
+ * Return: Success: SUCCEED
+ * Failure: FAIL
+ *
+ * Programmer: Mike McGreevy
+ * October 7, 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+void
+accum_printf(void)
+{
+ H5F_meta_accum_t * accum = &f->shared->accum;
+
+ printf("\n");
+ printf("Current contents of accumulator:\n");
+ if (accum->alloc_size == 0) {
+ printf("=====================================================\n");
+ printf(" No accumulator allocated.\n");
+ printf("=====================================================\n");
+ } else {
+ printf("=====================================================\n");
+ printf(" accumulator allocated size == %lu\n", (unsigned long)accum->alloc_size);
+ printf(" accumulated data size == %lu\n", (unsigned long)accum->size);
+ printf(" accumulator dirty? == %d\n", accum->dirty);
+ printf("=====================================================\n");
+ printf(" start of accumulated data, loc = %llu\n", accum->loc);
+ if (accum->dirty) printf(" start of dirty region, loc = %llu\n", accum->loc + accum->dirty_off);
+ if (accum->dirty) printf(" end of dirty region, loc = %llu\n", accum->loc + accum->dirty_off + accum->dirty_len);
+ printf(" end of accumulated data, loc = %llu\n", accum->loc + accum->size);
+ printf(" end of accumulator allocation, loc = %llu\n", accum->loc + accum->alloc_size);
+ printf("=====================================================\n");
+ }
+ printf("\n\n");
+} /* accum_printf() */
+
diff --git a/test/err_compat.c b/test/err_compat.c
index be86a2d..c08e259 100644
--- a/test/err_compat.c
+++ b/test/err_compat.c
@@ -42,20 +42,187 @@ int ipoints2[DIM0][DIM1], icheck2[DIM0][DIM1];
#define DSET_NAME "a_dataset"
#define FAKE_ID -1
-herr_t custom_print_cb(int n, H5E_error1_t *err_desc, void* client_data);
+herr_t custom_print_cb1(int n, H5E_error1_t *err_desc, void* client_data);
+herr_t custom_print_cb2(int n, H5E_error2_t *err_desc, void* client_data);
/*-------------------------------------------------------------------------
- * Function: test_error
+ * Function: user_print1
*
- * Purpose: Test error API functions
+ * Purpose: This function is a user-defined old-style printing function.
+ * This is just a convenience function for H5Ewalk1() with a
+ * function that prints error messages.
+ *
+ * Return: Non-negative on success/Negative on failure
+ *
+ * Programmer: Raymond Lu
+ * 4 October 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+user_print1(FILE *stream)
+{
+ /* Customized way to print errors */
+ fprintf(stderr, "\n********* Print error stack in customized way *********\n");
+ if(H5Ewalk1(H5E_WALK_UPWARD, (H5E_walk1_t)custom_print_cb1, stream) < 0)
+ TEST_ERROR;
+
+ return 0;
+
+ error:
+ return -1;
+
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: user_print2
+ *
+ * Purpose: This function is a user-defined new-style printing function.
+ * This is just a convenience function for H5Ewalk2() with a
+ * function that prints error messages.
+ *
+ * Return: Non-negative on success/Negative on failure
+ *
+ * Programmer: Raymond Lu
+ * 4 October 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+user_print2(hid_t err_stack, FILE *stream)
+{
+ /* Customized way to print errors */
+ fprintf(stderr, "\n********* Print error stack in customized way *********\n");
+ if(H5Ewalk2(err_stack, H5E_WALK_UPWARD, (H5E_walk2_t)custom_print_cb2, stream) < 0)
+ TEST_ERROR;
+
+ return 0;
+
+ error:
+ return -1;
+
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: custom_print_cb1
+ *
+ * Purpose: Callback function to print error stack in customized way
+ * for H5Ewalk1.
*
* Return: Success: 0
*
* Failure: -1
*
* Programmer: Raymond Lu
- * July 10, 2003
+ * 4 October 2010
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+custom_print_cb1(int n, H5E_error1_t *err_desc, void* client_data)
+{
+ FILE *stream = (FILE *)client_data;
+ char *maj = NULL;
+ char *min = NULL;
+ const int indent = 4;
+
+ if(NULL == (min = H5Eget_minor(err_desc->min_num)))
+ TEST_ERROR;
+
+ if(NULL == (maj = H5Eget_major(err_desc->maj_num)))
+ TEST_ERROR;
+
+ fprintf(stream, "%*serror #%03d: %s in %s(): line %u\n",
+ indent, "", n, err_desc->file_name,
+ err_desc->func_name, err_desc->line);
+
+ fprintf(stream, "%*smajor: %s\n", indent * 2, "", maj);
+ fprintf(stream, "%*sminor: %s\n", indent * 2, "", min);
+
+ HDfree(maj);
+ HDfree(min);
+
+ return 0;
+
+error:
+ if(maj)
+ HDfree(maj);
+ if(min)
+ HDfree(min);
+
+ return -1;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: custom_print_cb2
+ *
+ * Purpose: Callback function to print error stack in customized way
+ * for H5Ewalk1.
+ *
+ * Return: Success: 0
+ *
+ * Failure: -1
+ *
+ * Programmer: Raymond Lu
+ * 4 October 2010
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+custom_print_cb2(int n, H5E_error2_t *err_desc, void* client_data)
+{
+ FILE *stream = (FILE *)client_data;
+ char *maj = NULL;
+ char *min = NULL;
+ const int indent = 4;
+
+ if(NULL == (min = H5Eget_minor(err_desc->min_num)))
+ TEST_ERROR;
+
+ if(NULL == (maj = H5Eget_major(err_desc->maj_num)))
+ TEST_ERROR;
+
+ fprintf(stream, "%*serror #%03d: %s in %s(): line %u\n",
+ indent, "", n, err_desc->file_name,
+ err_desc->func_name, err_desc->line);
+
+ fprintf(stream, "%*smajor: %s\n", indent * 2, "", maj);
+ fprintf(stream, "%*sminor: %s\n", indent * 2, "", min);
+
+ HDfree(maj);
+ HDfree(min);
+
+ return 0;
+
+error:
+ if(maj)
+ HDfree(maj);
+ if(min)
+ HDfree(min);
+
+ return -1;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_error1
+ *
+ * Purpose: Test the backward compatibility of H5Eset/get_auto.
+ *
+ * Return: Success: 0
+ *
+ * Failure: -1
+ *
+ * Programmer: Raymond Lu
+ * 17 September 2010
*
*
* Modifications:
@@ -63,13 +230,143 @@ herr_t custom_print_cb(int n, H5E_error1_t *err_desc, void* client_data);
*-------------------------------------------------------------------------
*/
static herr_t
-test_error(hid_t file)
+test_error1(void)
{
hid_t dataset, space;
hsize_t dims[2];
- const char *FUNC_test_error="test_error";
- H5E_auto1_t old_func;
+ H5E_auto1_t old_func1;
+ H5E_auto2_t old_func2;
void *old_data;
+ herr_t ret;
+
+ TESTING("error API H5Eset/get_auto");
+ fprintf(stderr, "\n");
+
+ /* Create the data space */
+ dims[0] = DIM0;
+ dims[1] = DIM1;
+ if ((space = H5Screate_simple(2, dims, NULL))<0) TEST_ERROR;
+
+ /* Use H5Eget_auto2 to query the default printing function. The library
+ *should indicate H5Eprint2 as the default. */
+ if (H5Eget_auto2(H5E_DEFAULT, &old_func2, &old_data)<0)
+ TEST_ERROR;
+ if (old_data != NULL)
+ TEST_ERROR;
+ if (!old_func2 || (H5E_auto2_t)H5Eprint2 != old_func2)
+ TEST_ERROR;
+
+ /* This function sets the default printing function to be H5Eprint2. */
+ if(H5Eset_auto2(H5E_DEFAULT, old_func2, old_data)<0)
+ TEST_ERROR;
+
+ /* Try the printing function. Dataset creation should fail because the file
+ * doesn't exist. */
+ dataset = H5Dcreate2(FAKE_ID, DSET_NAME, H5T_STD_I32BE, space, H5P_DEFAULT,
+ H5P_DEFAULT, H5P_DEFAULT);
+ if(dataset >= 0)
+ TEST_ERROR;
+
+ /* This call should work. It simply returns H5Eprint1. */
+ if((ret = H5Eget_auto1(&old_func1, &old_data))<0)
+ TEST_ERROR;
+ if (old_data != NULL)
+ TEST_ERROR;
+ if (!old_func1 || (H5E_auto1_t)H5Eprint1 != old_func1)
+ TEST_ERROR;
+
+ /* This function changes the old-style printing function to be user_print1. */
+ if(H5Eset_auto1((H5E_auto1_t)user_print1, stderr)<0)
+ TEST_ERROR;
+
+ /* Try the printing function. Dataset creation should fail because the file
+ * doesn't exist. */
+ dataset = H5Dcreate2(FAKE_ID, DSET_NAME, H5T_STD_I32BE, space, H5P_DEFAULT,
+ H5P_DEFAULT, H5P_DEFAULT);
+ if(dataset >= 0)
+ TEST_ERROR;
+
+ /* This call should fail because the test mixes H5Eget_auto2 with H5Eset_auto1.
+ * Once the H5Eset_auto1 is called with a user-defined printing function,
+ * a call to H5Eget_auto2 will fail. But keep in mind the printing function is
+ * user_print1. */
+ if((ret = H5Eget_auto2(H5E_DEFAULT, &old_func2, &old_data))>=0)
+ TEST_ERROR;
+
+ /* This function changes the new-style printing function to be user_print2. */
+ if(H5Eset_auto2(H5E_DEFAULT, (H5E_auto2_t)user_print2, stderr)<0)
+ TEST_ERROR;
+
+ /* Try the printing function. Dataset creation should fail because the file
+ * doesn't exist. */
+ dataset = H5Dcreate2(FAKE_ID, DSET_NAME, H5T_STD_I32BE, space, H5P_DEFAULT,
+ H5P_DEFAULT, H5P_DEFAULT);
+ if(dataset >= 0)
+ TEST_ERROR;
+
+ /* This function changes the new-style printing function back to the default H5Eprint2. */
+ if(H5Eset_auto2(H5E_DEFAULT, (H5E_auto2_t)H5Eprint2, NULL)<0)
+ TEST_ERROR;
+
+ /* This call should work because the H5Eset_auto2 above restored the default printing
+ * function H5Eprint2. It simply returns user_print1. */
+ if((ret = H5Eget_auto1(&old_func1, &old_data))<0)
+ TEST_ERROR;
+ if (old_data != NULL)
+ TEST_ERROR;
+ if (!old_func1 || (H5E_auto1_t)user_print1 != old_func1)
+ TEST_ERROR;
+
+ /* This function changes the new-style printing function back to the default H5Eprint1. */
+ if(H5Eset_auto1((H5E_auto1_t)H5Eprint1, NULL)<0)
+ TEST_ERROR;
+
+ /* This call should work because the H5Eset_auto1 above restored the default printing
+ * function H5Eprint1. It simply returns H5Eprint2. */
+ if((ret = H5Eget_auto2(H5E_DEFAULT, &old_func2, &old_data))<0)
+ TEST_ERROR;
+ if (old_data != NULL)
+ TEST_ERROR;
+ if (!old_func2 || (H5E_auto2_t)H5Eprint2 != old_func2)
+ TEST_ERROR;
+
+ /* Try the printing function. Dataset creation should fail because the file
+ * doesn't exist. */
+ dataset = H5Dcreate2(FAKE_ID, DSET_NAME, H5T_STD_I32BE, space, H5P_DEFAULT,
+ H5P_DEFAULT, H5P_DEFAULT);
+ if(dataset >= 0)
+ TEST_ERROR;
+
+ return 0;
+
+ error:
+ return -1;
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_error2
+ *
+ * Purpose: Test error API functions, mainly on H5Epush1.
+ *
+ * Return: Success: 0
+ *
+ * Failure: -1
+ *
+ * Programmer: Raymond Lu
+ * July 10, 2003
+ *
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_error2(hid_t file)
+{
+ hid_t dataset, space;
+ hsize_t dims[2];
+ const char *FUNC_test_error="test_error2";
TESTING("error API based on data I/O");
fprintf(stderr, "\n");
@@ -92,22 +389,12 @@ test_error(hid_t file)
goto error;
}
- /* Test enabling and disabling default printing */
- if (H5Eget_auto1(&old_func, &old_data)<0)
- TEST_ERROR;
- if (old_data != NULL)
- TEST_ERROR;
- if (!old_func)
- TEST_ERROR;
-#ifdef H5_USE_16_API
- if (old_func != (H5E_auto1_t)H5Eprint1)
- TEST_ERROR;
-#else /* H5_USE_16_API */
- if (old_func != (H5E_auto1_t)H5Eprint2)
- TEST_ERROR;
-#endif /* H5_USE_16_API */
-
- if(H5Eset_auto1(NULL, NULL)<0)
+ /* Disable the library's default printing function */
+#ifdef H5_USE_16_API_DEFAULT
+ if(H5Eset_auto(NULL, NULL)<0)
+#else
+ if(H5Eset_auto(H5E_DEFAULT, NULL, NULL)<0)
+#endif
TEST_ERROR;
/* Make H5Dwrite fail, verify default print is disabled */
@@ -117,9 +404,6 @@ test_error(hid_t file)
goto error;
}
- if(H5Eset_auto1(old_func, old_data)<0)
- TEST_ERROR;
-
/* In case program comes to this point, close dataset */
if(H5Dclose(dataset)<0) TEST_ERROR;
@@ -157,7 +441,7 @@ dump_error(void)
/* Customized way to print errors */
fprintf(stderr, "\n********* Print error stack in customized way *********\n");
- if(H5Ewalk1(H5E_WALK_UPWARD, custom_print_cb, stderr) < 0)
+ if(H5Ewalk1(H5E_WALK_UPWARD, custom_print_cb1, stderr) < 0)
TEST_ERROR;
return 0;
@@ -166,57 +450,6 @@ dump_error(void)
return -1;
}
-/*-------------------------------------------------------------------------
- * Function: custom_print_cb
- *
- * Purpose: Callback function to print error stack in customized way.
- *
- * Return: Success: 0
- *
- * Failure: -1
- *
- * Programmer: Raymond Lu
- * July 17, 2003
- *
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-herr_t
-custom_print_cb(int n, H5E_error1_t *err_desc, void* client_data)
-{
- FILE *stream = (FILE *)client_data;
- char *maj = NULL;
- char *min = NULL;
- const int indent = 4;
-
- if(NULL == (min = H5Eget_minor(err_desc->min_num)))
- TEST_ERROR;
-
- if(NULL == (maj = H5Eget_major(err_desc->maj_num)))
- TEST_ERROR;
-
- fprintf(stream, "%*serror #%03d: %s in %s(): line %u\n",
- indent, "", n, err_desc->file_name,
- err_desc->func_name, err_desc->line);
-
- fprintf(stream, "%*smajor: %s\n", indent * 2, "", maj);
- fprintf(stream, "%*sminor: %s\n", indent * 2, "", min);
-
- HDfree(maj);
- HDfree(min);
-
- return 0;
-
-error:
- if(maj)
- HDfree(maj);
- if(min)
- HDfree(min);
-
- return -1;
-}
/*-------------------------------------------------------------------------
@@ -258,7 +491,9 @@ main(void)
H5Eclear1();
/* Test error API */
- if(test_error(file) < 0) {
+ if(test_error1() < 0) TEST_ERROR ;
+
+ if(test_error2(file) < 0) {
H5Epush1(__FILE__, FUNC_main, __LINE__, H5E_ERROR, H5E_BADMESG,
"Error test failed");
H5Eprint1(stderr);
@@ -275,4 +510,3 @@ main(void)
return 1;
}
#endif /* H5_NO_DEPRECATED_SYMBOLS */
-
diff --git a/test/ohdr.c b/test/ohdr.c
index dad06cf..8494d51 100644
--- a/test/ohdr.c
+++ b/test/ohdr.c
@@ -80,10 +80,10 @@ test_cont(char *filename, hid_t fapl)
HDmemset(&oh_locA, 0, sizeof(oh_locA));
HDmemset(&oh_locB, 0, sizeof(oh_locB));
- if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)H5O_MIN_SIZE, H5P_GROUP_CREATE_DEFAULT, &oh_locA/*out*/) < 0)
+ if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)H5O_MIN_SIZE, (size_t)0, H5P_GROUP_CREATE_DEFAULT, &oh_locA/*out*/) < 0)
FAIL_STACK_ERROR
- if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)H5O_MIN_SIZE, H5P_GROUP_CREATE_DEFAULT, &oh_locB/*out*/) < 0)
+ if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)H5O_MIN_SIZE, (size_t)0, H5P_GROUP_CREATE_DEFAULT, &oh_locB/*out*/) < 0)
FAIL_STACK_ERROR
time_new = 11111111;
@@ -107,6 +107,10 @@ test_cont(char *filename, hid_t fapl)
if(H5O_msg_create(&oh_locA, H5O_NAME_ID, 0, 0, &short_name, H5P_DATASET_XFER_DEFAULT) < 0)
FAIL_STACK_ERROR
+ if(1 != H5O_link(&oh_locA, 1, H5P_DATASET_XFER_DEFAULT))
+ FAIL_STACK_ERROR
+ if(1 != H5O_link(&oh_locB, 1, H5P_DATASET_XFER_DEFAULT))
+ FAIL_STACK_ERROR
if(H5AC_flush(f, H5P_DATASET_XFER_DEFAULT) < 0)
FAIL_STACK_ERROR
if(H5O_expunge_chunks_test(&oh_locA, H5P_DATASET_XFER_DEFAULT) < 0)
@@ -148,6 +152,149 @@ error:
return -1;
} /* test_cont() */
+/*
+ * Verify that object headers are held in the cache until they are linked
+ * to a location in the graph, or assigned an ID. This is done by
+ * creating an object header, then forcing it out of the cache by creating
+ * local heaps until the object header is evicted from the cache, then
+ * modifying the object header. The refcount on the object header is
+ * checked as verifying that the object header has remained in the cache.
+ */
+static herr_t
+test_ohdr_cache(char *filename, hid_t fapl)
+{
+ hid_t file = -1; /* File ID */
+ hid_t my_fapl; /* FAPL ID */
+ hid_t my_dxpl; /* DXPL ID */
+ H5AC_cache_config_t mdc_config; /* Metadata cache configuration info */
+ H5F_t *f = NULL; /* File handle */
+ H5HL_t *lheap, *lheap2, *lheap3; /* Pointer to local heaps */
+ haddr_t lheap_addr, lheap_addr2, lheap_addr3; /* Local heap addresses */
+ H5O_loc_t oh_loc; /* Object header location */
+ time_t time_new; /* Time value for modification time message */
+ unsigned rc; /* Refcount for object */
+
+ TESTING("object header creation in cache");
+
+ /* Make a copy of the FAPL */
+ if((my_fapl = H5Pcopy(fapl)) < 0)
+ FAIL_STACK_ERROR
+
+ /* Tweak down the size of the metadata cache to only 64K */
+ mdc_config.version = H5AC__CURR_CACHE_CONFIG_VERSION;
+ if(H5Pget_mdc_config(my_fapl, &mdc_config) < 0)
+ FAIL_STACK_ERROR
+ mdc_config.set_initial_size = TRUE;
+ mdc_config.initial_size = 32 * 1024;
+ mdc_config.max_size = 64 * 1024;
+ mdc_config.min_size = 8 * 1024;
+ if(H5Pset_mdc_config(my_fapl, &mdc_config) < 0)
+ FAIL_STACK_ERROR
+
+ /* Make a copy of the default DXPL */
+ if((my_dxpl = H5Pcopy(H5P_DATASET_XFER_DEFAULT)) < 0)
+ FAIL_STACK_ERROR
+
+ /* Create the file to operate on */
+ if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0)
+ FAIL_STACK_ERROR
+ if(H5Pclose(my_fapl) < 0)
+ FAIL_STACK_ERROR
+ if(NULL == (f = (H5F_t *)H5I_object(file)))
+ FAIL_STACK_ERROR
+ if(H5AC_ignore_tags(f) < 0)
+ FAIL_STACK_ERROR
+
+ /* Create object (local heap) that occupies most of cache */
+ if(H5HL_create(f, my_dxpl, (31 * 1024), &lheap_addr) < 0)
+ FAIL_STACK_ERROR
+
+ /* Protect local heap (which actually pins it in the cache) */
+ if(NULL == (lheap = H5HL_protect(f, my_dxpl, lheap_addr, H5AC_READ)))
+ FAIL_STACK_ERROR
+
+ /* Create an object header */
+ HDmemset(&oh_loc, 0, sizeof(oh_loc));
+ if(H5O_create(f, my_dxpl, (size_t)2048, (size_t)1, H5P_GROUP_CREATE_DEFAULT, &oh_loc/*out*/) < 0)
+ FAIL_STACK_ERROR
+
+ /* Query object header information */
+ rc = 0;
+ if(H5O_get_rc(&oh_loc, my_dxpl, &rc) < 0)
+ FAIL_STACK_ERROR
+ if(0 != rc)
+ TEST_ERROR
+
+ /* Create object (local heap) that occupies most of cache */
+ if(H5HL_create(f, my_dxpl, (31 * 1024), &lheap_addr2) < 0)
+ FAIL_STACK_ERROR
+
+ /* Protect local heap (which actually pins it in the cache) */
+ if(NULL == (lheap2 = H5HL_protect(f, my_dxpl, lheap_addr2, H5AC_READ)))
+ FAIL_STACK_ERROR
+
+ /* Unprotect local heap (which actually unpins it from the cache) */
+ if(H5HL_unprotect(lheap2) < 0)
+ FAIL_STACK_ERROR
+
+ /* Create object header message in new object header */
+ time_new = 11111111;
+ if(H5O_msg_create(&oh_loc, H5O_MTIME_NEW_ID, 0, 0, &time_new, my_dxpl) < 0)
+ FAIL_STACK_ERROR
+
+ /* Create object (local heap) that occupies most of cache */
+ if(H5HL_create(f, my_dxpl, (31 * 1024), &lheap_addr3) < 0)
+ FAIL_STACK_ERROR
+
+ /* Protect local heap (which actually pins it in the cache) */
+ if(NULL == (lheap3 = H5HL_protect(f, my_dxpl, lheap_addr3, H5AC_READ)))
+ FAIL_STACK_ERROR
+
+ /* Unprotect local heap (which actually unpins it from the cache) */
+ if(H5HL_unprotect(lheap3) < 0)
+ FAIL_STACK_ERROR
+
+ /* Query object header information */
+ /* (Note that this is somewhat of a weak test, since it doesn't actually
+ * verify that the object header was evicted from the cache, but it's
+ * very difficult to verify when an entry is evicted from the cache in
+ * a non-invasive way -QAK)
+ */
+ rc = 0;
+ if(H5O_get_rc(&oh_loc, my_dxpl, &rc) < 0)
+ FAIL_STACK_ERROR
+ if(0 != rc)
+ TEST_ERROR
+
+ /* Decrement reference count o object header */
+ if(H5O_dec_rc_by_loc(&oh_loc, my_dxpl) < 0)
+ FAIL_STACK_ERROR
+
+ /* Close object header created */
+ if(H5O_close(&oh_loc) < 0)
+ FAIL_STACK_ERROR
+
+ /* Unprotect local heap (which actually unpins it from the cache) */
+ if(H5HL_unprotect(lheap) < 0)
+ FAIL_STACK_ERROR
+
+ if(H5Pclose(my_dxpl) < 0)
+ FAIL_STACK_ERROR
+ if(H5Fclose(file) < 0)
+ FAIL_STACK_ERROR
+
+ PASSED();
+
+ return 0;
+
+error:
+ H5E_BEGIN_TRY {
+ H5Fclose(file);
+ } H5E_END_TRY;
+
+ return -1;
+} /* test_ohdr_cache() */
+
/*-------------------------------------------------------------------------
* Function: main
@@ -216,7 +363,7 @@ main(void)
*/
TESTING("object header creation");
HDmemset(&oh_loc, 0, sizeof(oh_loc));
- if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)64, H5P_GROUP_CREATE_DEFAULT, &oh_loc/*out*/) < 0)
+ if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)64, (size_t)0, H5P_GROUP_CREATE_DEFAULT, &oh_loc/*out*/) < 0)
FAIL_STACK_ERROR
PASSED();
@@ -226,6 +373,8 @@ main(void)
time_new = 11111111;
if(H5O_msg_create(&oh_loc, H5O_MTIME_NEW_ID, 0, 0, &time_new, H5P_DATASET_XFER_DEFAULT) < 0)
FAIL_STACK_ERROR
+ if(1 != H5O_link(&oh_loc, 1, H5P_DATASET_XFER_DEFAULT))
+ FAIL_STACK_ERROR
if(H5AC_flush(f, H5P_DATASET_XFER_DEFAULT) < 0)
FAIL_STACK_ERROR
if(H5AC_expunge_entry(f, H5P_DATASET_XFER_DEFAULT, H5AC_OHDR, oh_loc.addr, H5AC__NO_FLAGS_SET) < 0)
@@ -378,12 +527,16 @@ main(void)
*/
TESTING("locking messages");
HDmemset(&oh_loc, 0, sizeof(oh_loc));
- if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)64, H5P_GROUP_CREATE_DEFAULT, &oh_loc/*out*/) < 0)
+ if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)64, (size_t)0, H5P_GROUP_CREATE_DEFAULT, &oh_loc/*out*/) < 0)
+ FAIL_STACK_ERROR
+ if(1 != H5O_link(&oh_loc, 1, H5P_DATASET_XFER_DEFAULT))
FAIL_STACK_ERROR
/* Create second object header, to guarantee that first object header uses multiple chunks */
HDmemset(&oh_loc2, 0, sizeof(oh_loc2));
- if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)64, H5P_GROUP_CREATE_DEFAULT, &oh_loc2/*out*/) < 0)
+ if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)64, (size_t)0, H5P_GROUP_CREATE_DEFAULT, &oh_loc2/*out*/) < 0)
+ FAIL_STACK_ERROR
+ if(1 != H5O_link(&oh_loc2, 1, H5P_DATASET_XFER_DEFAULT))
FAIL_STACK_ERROR
/* Fill object header with messages, creating multiple chunks */
@@ -452,12 +605,16 @@ main(void)
/* Open first object header */
HDmemset(&oh_loc, 0, sizeof(oh_loc));
- if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)64, H5P_GROUP_CREATE_DEFAULT, &oh_loc/*out*/) < 0)
+ if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)64, (size_t)0, H5P_GROUP_CREATE_DEFAULT, &oh_loc/*out*/) < 0)
+ FAIL_STACK_ERROR
+ if(1 != H5O_link(&oh_loc, 1, H5P_DATASET_XFER_DEFAULT))
FAIL_STACK_ERROR
/* Create second object header, to guarantee that first object header uses multiple chunks */
HDmemset(&oh_loc2, 0, sizeof(oh_loc2));
- if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)64, H5P_GROUP_CREATE_DEFAULT, &oh_loc2/*out*/) < 0)
+ if(H5O_create(f, H5P_DATASET_XFER_DEFAULT, (size_t)64, (size_t)0, H5P_GROUP_CREATE_DEFAULT, &oh_loc2/*out*/) < 0)
+ FAIL_STACK_ERROR
+ if(1 != H5O_link(&oh_loc2, 1, H5P_DATASET_XFER_DEFAULT))
FAIL_STACK_ERROR
/* Add message to move to object header */
@@ -632,6 +789,10 @@ main(void)
/* Close the file we created */
if(H5Fclose(file) < 0)
TEST_ERROR
+
+ /* Test object header creation metadata cache issues */
+ if(test_ohdr_cache(filename, fapl) < 0)
+ TEST_ERROR
} /* end for */
puts("All object header tests passed.");
diff --git a/test/testerror.sh.in b/test/testerror.sh.in
index 7f9657a..440be4f 100644
--- a/test/testerror.sh.in
+++ b/test/testerror.sh.in
@@ -71,6 +71,8 @@ TEST() {
-e 's/line [0-9]*/line (number)/' \
-e 's/v[1-9]*\.[0-9]*\./version (number)\./' \
-e 's/[1-9]*\.[0-9]*\.[0-9]*[^)]*/version (number)/' \
+ -e 's/H5Eget_auto[1-2]*/H5Eget_auto(1 or 2)/' \
+ -e 's/H5Eset_auto[1-2]*/H5Eset_auto(1 or 2)/' \
$actual_err > $actual_ext
cat $actual_ext >> $actual
diff --git a/test/testfiles/err_compat_1 b/test/testfiles/err_compat_1
index 032e7bc..e2b37ab 100644
--- a/test/testfiles/err_compat_1
+++ b/test/testfiles/err_compat_1
@@ -1,7 +1,7 @@
#############################
Expected output for err_compat
#############################
-Testing error API based on data I/O All error API tests passed.
+Testing error API H5Eset/get_auto Testing error API based on data I/O All error API tests passed.
This program tests the Error API compatible with HDF5 version (number). There're supposed to be some error messages
********* Print error stack in HDF5 default way *********
HDF5-DIAG: Error detected in HDF5 (version (number)) thread (IDs):
@@ -15,10 +15,46 @@ HDF5-DIAG: Error detected in HDF5 (version (number)) thread (IDs):
minor: Bad value
HDF5-DIAG: Error detected in HDF5 (version (number)) thread (IDs):
+ #000: (file name) line (number) in H5Dcreate2(): not a location ID
+ major: Invalid arguments to routine
+ minor: Inappropriate type
+ #001: (file name) line (number) in H5G_loc(): invalid object ID
+ major: Invalid arguments to routine
+ minor: Bad value
+
+********* Print error stack in customized way *********
+ error #000: (file name) in H5G_loc(): line (number)
+ major: Invalid arguments to routine
+ minor: Bad value
+ error #001: (file name) in H5Dcreate2(): line (number)
+ major: Invalid arguments to routine
+ minor: Inappropriate type
+
+********* Print error stack in customized way *********
+ error #000: (file name) in H5Eget_auto(1 or 2)(): line (number)
+ major: Error API
+ minor: Can't get value
+
+********* Print error stack in customized way *********
+ error #000: (file name) in H5G_loc(): line (number)
+ major: Invalid arguments to routine
+ minor: Bad value
+ error #001: (file name) in H5Dcreate2(): line (number)
+ major: Invalid arguments to routine
+ minor: Inappropriate type
+HDF5-DIAG: Error detected in HDF5 (version (number)) thread (IDs):
+ #000: (file name) line (number) in H5Dcreate2(): not a location ID
+ major: Invalid arguments to routine
+ minor: Inappropriate type
+ #001: (file name) line (number) in H5G_loc(): invalid object ID
+ major: Invalid arguments to routine
+ minor: Bad value
+
+HDF5-DIAG: Error detected in HDF5 (version (number)) thread (IDs):
#000: (file name) line (number) in main(): Error test failed
major: Error API
minor: Unrecognized message
- #001: (file name) line (number) in test_error(): H5Dwrite shouldn't succeed
+ #001: (file name) line (number) in test_error2(): H5Dwrite shouldn't succeed
major: Error API
minor: Write failed
#002: (file name) line (number) in H5Dwrite(): not a dataset
generated by cgit v0.12 at 2024-11-17 09:03:42 (GMT)