summaryrefslogtreecommitdiffstats
path: root/test/farray.c
diff options
context:
space:
mode:
Diffstat (limited to 'test/farray.c')
-rw-r--r--test/farray.c1659
1 files changed, 1659 insertions, 0 deletions
diff --git a/test/farray.c b/test/farray.c
new file mode 100644
index 0000000..c7a2796
--- /dev/null
+++ b/test/farray.c
@@ -0,0 +1,1659 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group. *
+ * 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. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * This file is modified based on earray.c.
+ */
+#include "h5test.h"
+
+/*
+ * This file needs to access private datatypes from the H5FA package.
+ * This file also needs to access the fixed array testing code.
+ */
+#define H5FA_PACKAGE
+#define H5FA_TESTING
+#include "H5FApkg.h" /* Fixed Arrays */
+
+/* Other private headers that this test requires */
+#include "H5Iprivate.h" /* IDs */
+#include "H5Vprivate.h" /* Vectors and arrays */
+
+
+/* Local macros */
+
+/* Max. testfile name length */
+#define FARRAY_FILENAME_LEN 1024
+
+/* Fixed array creation values */
+#define ELMT_SIZE sizeof(uint64_t)
+#define MAX_DBLOCK_PAGE_NELMTS_BITS 10 /* 2^10 = 1024 elements per data block page */
+
+/* Testing # of elements in the Fixed Array */
+#define TEST_NELMTS 20000
+
+/* Convenience macros for computing earray state */
+#define FA_HDR_SIZE 28 /* hard-coded */
+#define DBLOCK_PREFIX 18 /* hard-coded */
+
+/* 4 giga-elements: max chunk size */
+#define MAX_NELMTS ((unsigned long long)4*1024*1024*1024) /* 4 giga-elements */
+
+/* Iterator parameter values */
+#define FA_CYC_COUNT 4
+
+
+/* Local typedefs */
+
+/* Types of tests to perform */
+typedef enum {
+ FARRAY_TEST_NORMAL, /* "Normal" test, with no testing parameters set */
+ FARRAY_TEST_REOPEN, /* Set the reopen_array flag */
+ FARRAY_TEST_NTESTS /* The number of test types, must be last */
+} farray_test_type_t;
+
+/* Types of iteration to perform */
+typedef enum {
+ FARRAY_ITER_FW, /* "Forward" iteration */
+ FARRAY_ITER_RV, /* "Reverse" iteration */
+ FARRAY_ITER_RND, /* "Random" iteration */
+ FARRAY_ITER_CYC, /* "Cyclic" iteration */
+ FARRAY_ITER_NITERS /* The number of iteration types, must be last */
+} farray_iter_type_t;
+
+
+/* Fixed array state information */
+typedef struct farray_state_t {
+ hsize_t hdr_size; /* Size of header */
+ hsize_t dblk_size; /* Size of data block */
+ hsize_t nelmts; /* # of elements */
+} farray_state_t;
+
+/* Forward decl. */
+typedef struct farray_test_param_t farray_test_param_t;
+
+/* Fixed array iterator class */
+typedef struct farray_iter_t {
+ void *(*init)(const H5FA_create_t *cparam, const farray_test_param_t *tparam,
+ hsize_t cnt); /* Initialize/allocate iterator private info */
+ hssize_t (*next)(void *info); /* Get the next element to test */
+ herr_t (*term)(void *info); /* Shutdown/free iterator private info */
+} farray_iter_t;
+
+
+/* Testing parameters */
+struct farray_test_param_t {
+ farray_test_type_t reopen_array; /* Whether to re-open the array during the test */
+ hsize_t nelmts; /* # of elements to set for the fixed array */
+ const farray_iter_t *fiter; /* Iterator to use for this test */
+};
+
+/* Local variables */
+const char *FILENAME[] = {
+ "farray",
+ NULL
+};
+
+/* Filename to use for all tests */
+char filename_g[FARRAY_FILENAME_LEN];
+
+/* Empty file size */
+h5_stat_size_t empty_size_g;
+
+
+/*-------------------------------------------------------------------------
+ * Function: init_cparam
+ *
+ * Purpose: Initialize array creation parameter structure
+ *
+ * Return: Success: 0
+ * Failure: -1
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+init_cparam(H5FA_create_t *cparam, farray_test_param_t *tparam)
+{
+ /* Wipe out background */
+ HDmemset(cparam, 0, sizeof(*cparam));
+
+ cparam->cls = H5FA_CLS_TEST;
+ cparam->raw_elmt_size = ELMT_SIZE;
+ cparam->max_dblk_page_nelmts_bits = MAX_DBLOCK_PAGE_NELMTS_BITS;
+ cparam->nelmts = tparam->nelmts;
+
+ return(0);
+} /* init_cparam() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: create_file
+ *
+ * Purpose: Create file and retrieve pointer to internal file object
+ *
+ * Return: Success: 0
+ * Failure: -1
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+create_file(hid_t fapl, hid_t *file, H5F_t **f)
+{
+ /* Create the file to work on */
+ if((*file = H5Fcreate(filename_g, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
+ FAIL_STACK_ERROR
+
+ /* Get a pointer to the internal file object */
+ if(NULL == (*f = (H5F_t *)H5I_object(*file)))
+ FAIL_STACK_ERROR
+
+ /* Success */
+ return(0);
+
+error:
+ return(-1);
+} /* create_file() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: check_stats
+ *
+ * Purpose: Verify stats for a fixed array
+ *
+ * Return: Success: 0
+ * Failure: -1
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+check_stats(const H5FA_t *fa, const farray_state_t *state)
+{
+ H5FA_stat_t farray_stats; /* Statistics about the array */
+
+ /* Get statistics for fixed array and verify they are correct */
+ if(H5FA_get_stats(fa, &farray_stats) < 0)
+ FAIL_STACK_ERROR
+
+ /* Compare information */
+ if(farray_stats.hdr_size != state->hdr_size) {
+ HDfprintf(stdout, "farray_stats.hdr_size = %Hu, state->hdr_size = %Hu\n",
+ farray_stats.hdr_size, state->hdr_size);
+ TEST_ERROR
+ } /* end if */
+
+ if(farray_stats.dblk_size != state->dblk_size) {
+ HDfprintf(stdout, "farray_stats.dblk_size = %Hu, state->dblk_size = %Hu\n",
+ farray_stats.dblk_size, state->dblk_size);
+ TEST_ERROR
+ } /* end if */
+
+ if(farray_stats.nelmts != state->nelmts) {
+ HDfprintf(stdout, "farray_stats.nelmts = %Hu, state->nelmts = %Hu\n",
+ farray_stats.nelmts, state->nelmts);
+ TEST_ERROR
+ } /* end if */
+
+ /* All tests passed */
+ return(0);
+
+error:
+ return(-1);
+} /* check_stats() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: set_fa_state
+ *
+ * Purpose: Set the state of the Fixed Array
+ *
+ * Return: does not fail
+ *
+ * Programmer: Vailin Choi; 5th August, 2009
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+set_fa_state(const H5FA_create_t *cparam, farray_state_t *state)
+{
+ size_t dblk_page_nelmts; /* # of elements per page */
+
+ /* Sanity check */
+ HDassert(cparam);
+ HDassert(state);
+
+ /* Compute the state of the fixed array */
+ state->hdr_size = FA_HDR_SIZE;
+ state->nelmts = cparam->nelmts;
+
+ dblk_page_nelmts = (size_t)1 << cparam->max_dblk_page_nelmts_bits;
+ if(state->nelmts > dblk_page_nelmts) {
+ size_t npages = (size_t)(((state->nelmts + dblk_page_nelmts) - 1) / dblk_page_nelmts);
+ size_t dblk_page_init_size = (npages + 7) / 8;
+ hsize_t checksum_size = npages * 4;
+
+ state->dblk_size = DBLOCK_PREFIX + dblk_page_init_size + checksum_size +
+ state->nelmts * cparam->raw_elmt_size;
+ } else
+ state->dblk_size = DBLOCK_PREFIX + state->nelmts * cparam->raw_elmt_size;
+
+ return(0);
+} /* end set_fa_state() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: reopen_file
+ *
+ * Purpose: Perform common "re-open" operations on file & array for testing
+ *
+ * Return: Success: 0
+ * Failure: -1
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+reopen_file(hid_t *file, H5F_t **f, hid_t fapl, hid_t dxpl,
+ H5FA_t **fa, haddr_t fa_addr, const H5FA_class_t *fa_cls,
+ const farray_test_param_t *tparam)
+{
+ /* Check for closing & re-opening the array */
+ /* (actually will close & re-open the file as well) */
+ if(tparam->reopen_array) {
+ /* Close array, if given */
+ if(fa) {
+ if(H5FA_close(*fa, dxpl) < 0)
+ FAIL_STACK_ERROR
+ *fa = NULL;
+ } /* end if */
+
+ /* Close file */
+ if(H5Fclose(*file) < 0)
+ FAIL_STACK_ERROR
+ *file = (-1);
+ *f = NULL;
+
+ /* Re-open the file */
+ if((*file = H5Fopen(filename_g, H5F_ACC_RDWR, fapl)) < 0)
+ FAIL_STACK_ERROR
+
+ /* Get a pointer to the internal file object */
+ if(NULL == (*f = (H5F_t *)H5I_object(*file)))
+ FAIL_STACK_ERROR
+
+ /* Re-open array, if given */
+ if(fa) {
+ if(NULL == (*fa = H5FA_open(*f, dxpl, fa_addr, fa_cls, NULL)))
+ FAIL_STACK_ERROR
+ } /* end if */
+ } /* end if */
+
+ /* Success */
+ return(0);
+
+error:
+ return(-1);
+} /* reopen_file() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: create_array
+ *
+ * Purpose: Create a fixed array and perform initial checks
+ *
+ * Return: Success: 0
+ * Failure: -1
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+create_array(H5F_t *f, hid_t dxpl, const H5FA_create_t *cparam,
+ H5FA_t **fa, haddr_t *fa_addr, void *cb)
+{
+ farray_state_t state; /* State of extensible array */
+
+ /* Create array */
+ if(NULL == (*fa = H5FA_create(f, dxpl, cparam, cb)))
+ FAIL_STACK_ERROR
+
+ /* Check status of array */
+ if(H5FA_get_addr(*fa, fa_addr) < 0)
+ FAIL_STACK_ERROR
+ if(!H5F_addr_defined(*fa_addr))
+ TEST_ERROR
+ HDmemset(&state, 0, sizeof(state));
+ state.hdr_size = FA_HDR_SIZE;
+ state.nelmts = cparam->nelmts;
+ if(check_stats(*fa, &state))
+ TEST_ERROR
+
+ /* Success */
+ return(0);
+
+error:
+ return(-1);
+} /* create_array() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: verify_cparam
+ *
+ * Purpose: Verify creation parameters are correct
+ *
+ * Return: Success: 0
+ * Failure: -1
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+verify_cparam(const H5FA_t *fa, const H5FA_create_t *cparam)
+{
+ H5FA_create_t test_cparam; /* Creation parameters for array */
+
+ /* Retrieve creation parameters */
+ HDmemset(&test_cparam, 0, sizeof(H5FA_create_t));
+ if(H5FA_get_cparam_test(fa, &test_cparam) < 0)
+ FAIL_STACK_ERROR
+
+ /* Verify creation parameters */
+ if(H5FA_cmp_cparam_test(cparam, &test_cparam))
+ TEST_ERROR
+
+ /* Success */
+ return(0);
+
+error:
+ return(-1);
+} /* verify_cparam() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: finish
+ *
+ * Purpose: Close array, delete array, close file and verify that file
+ * is empty size
+ *
+ * Return: Success: 0
+ * Failure: -1
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+finish(hid_t file, hid_t fapl, H5F_t *f, H5FA_t *fa, haddr_t fa_addr)
+{
+ h5_stat_size_t file_size; /* File size, after deleting array */
+
+ /* Close the fixed array */
+ if(H5FA_close(fa, H5P_DATASET_XFER_DEFAULT) < 0)
+ FAIL_STACK_ERROR
+
+ /* Delete array */
+ if(H5FA_delete(f, H5P_DATASET_XFER_DEFAULT, fa_addr) < 0)
+ FAIL_STACK_ERROR
+
+ /* Close the file */
+ if(H5Fclose(file) < 0)
+ FAIL_STACK_ERROR
+
+ /* Get the size of the file */
+ if((file_size = h5_get_file_size(filename_g, fapl)) < 0)
+ TEST_ERROR
+
+ /* Verify the file is correct size */
+ if(file_size != empty_size_g)
+ TEST_ERROR
+
+ /* Success */
+ return(0);
+
+error:
+ return(-1);
+} /* finish() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_create
+ *
+ * Purpose: Test creating fixed array
+ *
+ * Return: Success: 0
+ * Failure: 1
+ *
+ *-------------------------------------------------------------------------
+ */
+static unsigned
+test_create(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t UNUSED *tparam)
+{
+ hid_t file = -1; /* File ID */
+ H5F_t *f = NULL; /* Internal file object pointer */
+ H5FA_t *fa = NULL; /* Fixed array wrapper */
+ haddr_t fa_addr = HADDR_UNDEF; /* Array address in file */
+
+ /* Create file & retrieve pointer to internal file object */
+ if(create_file(fapl, &file, &f) < 0)
+ TEST_ERROR
+
+ /*
+ * Display testing message
+ */
+ TESTING("invalid fixed array creation parameters");
+
+#ifndef NDEBUG
+{
+ H5FA_create_t test_cparam; /* Creation parameters for array */
+
+ /* Set invalid element size */
+ HDmemcpy(&test_cparam, cparam, sizeof(test_cparam));
+ test_cparam.raw_elmt_size = 0;
+ H5E_BEGIN_TRY {
+ fa = H5FA_create(f, H5P_DATASET_XFER_DEFAULT, &test_cparam, NULL);
+ } H5E_END_TRY;
+ if(fa) {
+ /* Close opened fixed array */
+ H5FA_close(fa, H5P_DATASET_XFER_DEFAULT);
+ fa = NULL;
+
+ /* Indicate error */
+ TEST_ERROR
+ } /* end if */
+
+ /* Set invalid max. # of elements bits */
+ HDmemcpy(&test_cparam, cparam, sizeof(test_cparam));
+ test_cparam.max_dblk_page_nelmts_bits = 0;
+ H5E_BEGIN_TRY {
+ fa = H5FA_create(f, H5P_DATASET_XFER_DEFAULT, &test_cparam, NULL);
+ } H5E_END_TRY;
+ if(fa) {
+ /* Close opened fixed array */
+ H5FA_close(fa, H5P_DATASET_XFER_DEFAULT);
+ fa = NULL;
+
+ /* Indicate error */
+ TEST_ERROR
+ } /* end if */
+
+ /* Set invalid max. # of elements */
+ HDmemcpy(&test_cparam, cparam, sizeof(test_cparam));
+ test_cparam.nelmts = 0;
+ H5E_BEGIN_TRY {
+ fa = H5FA_create(f, H5P_DATASET_XFER_DEFAULT, &test_cparam, NULL);
+ } H5E_END_TRY;
+ if(fa) {
+ /* Close opened fixed array */
+ H5FA_close(fa, H5P_DATASET_XFER_DEFAULT);
+ fa = NULL;
+
+ /* Indicate error */
+ TEST_ERROR
+ } /* end if */
+
+ PASSED()
+}
+#else /* NDEBUG */
+ SKIPPED();
+ puts(" Not tested when assertions are disabled");
+#endif /* NDEBUG */
+
+ /*
+ * Display testing message
+ */
+ TESTING("fixed array creation");
+
+ /* Create array */
+ if(create_array(f, H5P_DATASET_XFER_DEFAULT, cparam, &fa, &fa_addr, NULL) < 0)
+ TEST_ERROR
+
+ PASSED()
+
+ /* Verify the creation parameters */
+ TESTING("verify array creation parameters");
+
+ /* Verify the creation parameters */
+ if(verify_cparam(fa, cparam) < 0)
+ TEST_ERROR
+
+ /* Close array, delete array, close file & verify file is empty */
+ if(finish(file, fapl, f, fa, fa_addr) < 0)
+ TEST_ERROR
+
+ /* All tests passed */
+ PASSED()
+
+ return 0;
+
+error:
+ H5E_BEGIN_TRY {
+ if(fa)
+ H5FA_close(fa, H5P_DATASET_XFER_DEFAULT);
+ H5Fclose(file);
+ } H5E_END_TRY;
+
+ return 1;
+} /* end test_create() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_reopen
+ *
+ * Purpose: Create & reopen a fixed array
+ *
+ * Return: Success: 0
+ * Failure: 1
+ *
+ *-------------------------------------------------------------------------
+ */
+static unsigned
+test_reopen(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t *tparam)
+{
+ hid_t file = -1; /* File ID */
+ H5F_t *f = NULL; /* Internal file object pointer */
+ H5FA_t *fa = NULL; /* Fixed array wrapper */
+ haddr_t fa_addr = HADDR_UNDEF; /* Array address in file */
+
+ /* Create file & retrieve pointer to internal file object */
+ if(create_file(fapl, &file, &f) < 0)
+ TEST_ERROR
+
+ /*
+ * Display testing message
+ */
+ TESTING("create, close & reopen fixed array");
+
+ /* Create array */
+ if(create_array(f, H5P_DATASET_XFER_DEFAULT, cparam, &fa, &fa_addr, NULL) < 0)
+ TEST_ERROR
+
+ /* Close the fixed array */
+ if(H5FA_close(fa, H5P_DATASET_XFER_DEFAULT) < 0)
+ FAIL_STACK_ERROR
+
+ /* Check for closing & re-opening the file */
+ if(reopen_file(&file, &f, fapl, H5P_DATASET_XFER_DEFAULT, NULL, HADDR_UNDEF, NULL, tparam) < 0)
+ TEST_ERROR
+
+ /* Re-open the array */
+ if(NULL == (fa = H5FA_open(f, H5P_DATASET_XFER_DEFAULT, fa_addr, cparam->cls, NULL)))
+ FAIL_STACK_ERROR
+
+ /* Verify the creation parameters */
+ if(verify_cparam(fa, cparam) < 0)
+ TEST_ERROR
+
+ /* Close array, delete array, close file & verify file is empty */
+ if(finish(file, fapl, f, fa, fa_addr) < 0)
+ TEST_ERROR
+
+ /* All tests passed */
+ PASSED()
+
+ return 0;
+
+error:
+ H5E_BEGIN_TRY {
+ if(fa)
+ H5FA_close(fa, H5P_DATASET_XFER_DEFAULT);
+ H5Fclose(file);
+ } H5E_END_TRY;
+
+ return 1;
+} /* test_reopen() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_open_twice
+ *
+ * Purpose: Open an extensible array twice
+ *
+ * Return: Success: 0
+ * Failure: 1
+ *
+ *-------------------------------------------------------------------------
+ */
+static unsigned
+test_open_twice(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t *tparam)
+{
+ hid_t file = -1; /* File ID */
+ hid_t file2 = -1; /* File ID */
+ H5F_t *f = NULL; /* Internal file object pointer */
+ H5F_t *f2 = NULL; /* Internal file object pointer */
+ H5FA_t *fa = NULL; /* Fixed array wrapper */
+ H5FA_t *fa2 = NULL; /* Fixed array wrapper */
+ haddr_t fa_addr = HADDR_UNDEF; /* Array address in file */
+
+ /* Create file & retrieve pointer to internal file object */
+ if(create_file(fapl, &file, &f) < 0)
+ TEST_ERROR
+
+ /*
+ * Display testing message
+ */
+ TESTING("open fixed array twice");
+
+ /* Create array */
+ if(create_array(f, H5P_DATASET_XFER_DEFAULT, cparam, &fa, &fa_addr, NULL) < 0)
+ TEST_ERROR
+
+ /* Open the array again, through the first file handle */
+ if(NULL == (fa2 = H5FA_open(f, H5P_DATASET_XFER_DEFAULT, fa_addr, cparam->cls, NULL)))
+ FAIL_STACK_ERROR
+
+ /* Verify the creation parameters */
+ if(verify_cparam(fa, cparam) < 0)
+ TEST_ERROR
+ if(verify_cparam(fa2, cparam) < 0)
+ TEST_ERROR
+
+ /* Close the second fixed array wrapper */
+ if(H5FA_close(fa2, H5P_DATASET_XFER_DEFAULT) < 0)
+ FAIL_STACK_ERROR
+ fa2 = NULL;
+
+ /* Check for closing & re-opening the file */
+ if(reopen_file(&file, &f, fapl, H5P_DATASET_XFER_DEFAULT, &fa, fa_addr, cparam->cls, tparam) < 0)
+ TEST_ERROR
+
+ /* Re-open the file */
+ if((file2 = H5Freopen(file)) < 0)
+ FAIL_STACK_ERROR
+
+ /* Get a pointer to the internal file object */
+ if(NULL == (f2 = (H5F_t *)H5I_object(file2)))
+ FAIL_STACK_ERROR
+
+ /* Open the fixed array through the second file handle */
+ if(NULL == (fa2 = H5FA_open(f2, H5P_DATASET_XFER_DEFAULT, fa_addr, cparam->cls, NULL))) FAIL_STACK_ERROR
+
+ /* Verify the creation parameters */
+ if(verify_cparam(fa, cparam) < 0)
+ TEST_ERROR
+
+ /* Close the first extensible array wrapper */
+ if(H5FA_close(fa, H5P_DATASET_XFER_DEFAULT) < 0)
+ FAIL_STACK_ERROR
+ fa = NULL;
+
+ /* Close the first file */
+ /* (close before second file, to detect error on internal array header's
+ * shared file information)
+ */
+ if(H5Fclose(file) < 0)
+ FAIL_STACK_ERROR
+
+ /* Close array, delete array, close file & verify file is empty */
+ if(finish(file2, fapl, f2, fa2, fa_addr) < 0)
+ TEST_ERROR
+
+ /* All tests passed */
+ PASSED()
+
+ return 0;
+
+error:
+ H5E_BEGIN_TRY {
+ if(fa)
+ H5FA_close(fa, H5P_DATASET_XFER_DEFAULT);
+ if(fa2)
+ H5FA_close(fa2, H5P_DATASET_XFER_DEFAULT);
+ H5Fclose(file);
+ H5Fclose(file2);
+ } H5E_END_TRY;
+
+ return 1;
+} /* test_open_twice() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_delete_open
+ *
+ * Purpose: Delete opened fixed array (& open deleted array)
+ *
+ * Return: Success: 0
+ * Failure: 1
+ *
+ *-------------------------------------------------------------------------
+ */
+static unsigned
+test_delete_open(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t *tparam)
+{
+ hid_t file = -1; /* File ID */
+ H5F_t *f = NULL; /* Internal file object pointer */
+ H5FA_t *fa = NULL; /* Fixed array wrapper */
+ H5FA_t *fa2 = NULL; /* Fixed array wrapper */
+ haddr_t fa_addr = HADDR_UNDEF; /* Array address in file */
+ h5_stat_size_t file_size; /* File size, after deleting array */
+
+ /* Create file & retrieve pointer to internal file object */
+ if(create_file(fapl, &file, &f) < 0)
+ TEST_ERROR
+
+ /*
+ * Display testing message
+ */
+ TESTING("deleting open fixed array");
+
+ /* Create array */
+ if(create_array(f, H5P_DATASET_XFER_DEFAULT, cparam, &fa, &fa_addr, NULL) < 0)
+ TEST_ERROR
+
+ /* Open the array again */
+ if(NULL == (fa2 = H5FA_open(f, H5P_DATASET_XFER_DEFAULT, fa_addr, cparam->cls, NULL)))
+ FAIL_STACK_ERROR
+
+ /* Request that the array be deleted */
+ if(H5FA_delete(f, H5P_DATASET_XFER_DEFAULT, fa_addr) < 0)
+ FAIL_STACK_ERROR
+
+ /* Verify the creation parameters */
+ if(verify_cparam(fa, cparam) < 0)
+ TEST_ERROR
+ if(verify_cparam(fa2, cparam) < 0)
+ TEST_ERROR
+
+ /* Close the second fixed array wrapper */
+ if(H5FA_close(fa2, H5P_DATASET_XFER_DEFAULT) < 0)
+ FAIL_STACK_ERROR
+ fa2 = NULL;
+
+ /* Try re-opening the array again (should fail, as array will be deleted) */
+ H5E_BEGIN_TRY {
+ fa2 = H5FA_open(f, H5P_DATASET_XFER_DEFAULT, fa_addr, cparam->cls, NULL);
+ } H5E_END_TRY;
+ if(fa2) {
+ /* Close opened array */
+ H5FA_close(fa2, H5P_DATASET_XFER_DEFAULT);
+
+ /* Indicate error */
+ TEST_ERROR
+ } /* end if */
+
+ /* Close the first fixed array wrapper */
+ if(H5FA_close(fa, H5P_DATASET_XFER_DEFAULT) < 0)
+ FAIL_STACK_ERROR
+ fa = NULL;
+
+ /* Check for closing & re-opening the file */
+ if(reopen_file(&file, &f, fapl, H5P_DATASET_XFER_DEFAULT, NULL, HADDR_UNDEF, NULL, tparam) < 0)
+ TEST_ERROR
+
+ /* Try re-opening the array again (should fail, as array is now deleted) */
+ H5E_BEGIN_TRY {
+ fa = H5FA_open(f, H5P_DATASET_XFER_DEFAULT, fa_addr, cparam->cls, NULL);
+ } H5E_END_TRY;
+ if(fa) {
+ /* Close opened array */
+ H5FA_close(fa, H5P_DATASET_XFER_DEFAULT);
+
+ /* Indicate error */
+ TEST_ERROR
+ } /* end if */
+
+ /* Close the file */
+ if(H5Fclose(file) < 0)
+ FAIL_STACK_ERROR
+
+ /* Get the size of the file */
+ if((file_size = h5_get_file_size(filename_g, fapl)) < 0)
+ TEST_ERROR
+
+ /* Verify the file is correct size */
+ if(file_size != empty_size_g)
+ TEST_ERROR
+
+ /* All tests passed */
+ PASSED()
+
+ return 0;
+
+error:
+ H5E_BEGIN_TRY {
+ if(fa)
+ H5FA_close(fa, H5P_DATASET_XFER_DEFAULT);
+ if(fa2)
+ H5FA_close(fa2, H5P_DATASET_XFER_DEFAULT);
+ H5Fclose(file);
+ } H5E_END_TRY;
+
+ return 1;
+} /* test_delete_open() */
+
+/* Fixed array iterator info for forward iteration */
+typedef struct fiter_fw_t {
+ hsize_t idx; /* Index of next array location */
+} fiter_fw_t;
+
+
+/*-------------------------------------------------------------------------
+ * Function: fiter_fw_init
+ *
+ * Purpose: Initialize element interator (forward iteration)
+ *
+ * Return: Success: Pointer to iteration status object
+ * Failure: NULL
+ *
+ *-------------------------------------------------------------------------
+ */
+static void *
+fiter_fw_init(const H5FA_create_t UNUSED *cparam, const farray_test_param_t UNUSED *tparam,
+ hsize_t UNUSED cnt)
+{
+ fiter_fw_t *fiter; /* Forward element iteration object */
+
+ /* Allocate space for the element iteration object */
+ fiter = (fiter_fw_t *)HDmalloc(sizeof(fiter_fw_t));
+ HDassert(fiter);
+
+ /* Initialize the element iteration object */
+ fiter->idx = 0;
+
+ /* Return iteration object */
+ return(fiter);
+} /* end fiter_fw_init() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: fiter_fw_next
+ *
+ * Purpose: Get next element index (forward iteration)
+ *
+ * Return: Success: Non-negative
+ * Failure: Negative
+ *
+ *-------------------------------------------------------------------------
+ */
+static hssize_t
+fiter_fw_next(void *_fiter)
+{
+ fiter_fw_t *fiter = (fiter_fw_t *)_fiter;
+ hssize_t ret_val;
+
+ /* Sanity check */
+ HDassert(fiter);
+
+ /* Get the next array index to test */
+ ret_val = (hssize_t)fiter->idx++;
+
+ return(ret_val);
+} /* end fiter_fw_next() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: fiter_term
+ *
+ * Purpose: Shut down element interator (simple iterators)
+ *
+ * Return: Success: 0
+ * Failure: -1
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+fiter_term(void *fiter)
+{
+ /* Sanity check */
+ HDassert(fiter);
+
+ /* Free iteration object */
+ HDfree(fiter);
+
+ return(0);
+} /* end fiter_term() */
+
+/* Fixed array iterator class for forward iteration */
+static const farray_iter_t fa_iter_fw = {
+ fiter_fw_init, /* Iterator init */
+ fiter_fw_next, /* Next array index */
+ fiter_term /* Iterator term */
+};
+
+/* Fixed array iterator info for reverse iteration */
+typedef struct fiter_rv_t {
+ hsize_t idx; /* Index of next array location */
+} fiter_rv_t;
+
+
+/*-------------------------------------------------------------------------
+ * Function: fiter_rv_init
+ *
+ * Purpose: Initialize element interator (reverse iteration)
+ *
+ * Return: Success: Pointer to iteration status object
+ * Failure: NULL
+ *
+ *-------------------------------------------------------------------------
+ */
+static void *
+fiter_rv_init(const H5FA_create_t *cparam, const farray_test_param_t UNUSED *tparam,
+ hsize_t UNUSED cnt)
+{
+ fiter_rv_t *fiter; /* Reverse element iteration object */
+
+ /* Allocate space for the element iteration object */
+ fiter = (fiter_rv_t *)HDmalloc(sizeof(fiter_rv_t));
+ HDassert(fiter);
+
+ /* Initialize reverse iteration info */
+ fiter->idx = cparam->nelmts - 1;
+
+ /* Return iteration object */
+ return(fiter);
+} /* end fiter_rv_init() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: fiter_rv_next
+ *
+ * Purpose: Get next element index (reverse iteration)
+ *
+ * Return: Success: Non-negative
+ * Failure: Negative
+ *
+ *-------------------------------------------------------------------------
+ */
+static hssize_t
+fiter_rv_next(void *_fiter)
+{
+ fiter_rv_t *fiter = (fiter_rv_t *)_fiter;
+ hssize_t ret_val;
+
+ /* Sanity check */
+ HDassert(fiter);
+
+ /* Get the next array index to test */
+ ret_val = (hssize_t)fiter->idx--;
+
+ return(ret_val);
+} /* end fiter_rv_next() */
+
+/* Fixed array iterator class for reverse iteration */
+static const farray_iter_t fa_iter_rv = {
+ fiter_rv_init, /* Iterator init */
+ fiter_rv_next, /* Next array index */
+ fiter_term /* Iterator term */
+};
+
+/* Fixed array iterator info for random iteration */
+typedef struct fiter_rnd_t {
+ hsize_t pos; /* Position in shuffled array */
+ hsize_t *idx; /* Array of shuffled indices */
+} fiter_rnd_t;
+
+
+/*-------------------------------------------------------------------------
+ * Function: fiter_rnd_init
+ *
+ * Purpose: Initialize element interator (random iteration)
+ *
+ * Return: Success: Pointer to iteration status object
+ * Failure: NULL
+ *
+ *-------------------------------------------------------------------------
+ */
+static void *
+fiter_rnd_init(const H5FA_create_t UNUSED *cparam, const farray_test_param_t UNUSED *tparam,
+ hsize_t cnt)
+{
+ fiter_rnd_t *fiter; /* Random element iteration object */
+ size_t u; /* Local index variable */
+
+ /* Allocate space for the element iteration object */
+ fiter = (fiter_rnd_t *)HDmalloc(sizeof(fiter_rnd_t));
+ HDassert(fiter);
+
+ /* Allocate space for the array of shuffled indices */
+ fiter->idx = (hsize_t *)HDmalloc(sizeof(hsize_t) * (size_t)cnt);
+ HDassert(fiter->idx);
+
+ /* Initialize reverse iteration info */
+ fiter->pos = 0;
+ for(u = 0; u < (size_t)cnt; u++)
+ fiter->idx[u] = (hsize_t)u;
+
+ /* Randomly shuffle array indices */
+ if(cnt > 1) {
+ for(u = 0; u < (size_t)cnt; u++) {
+ size_t swap_idx; /* Location to swap with when shuffling */
+ hsize_t temp_idx; /* Temporary index */
+
+ swap_idx = ((size_t)HDrandom() % ((size_t)cnt - u)) + u;
+ temp_idx = fiter->idx[u];
+ fiter->idx[u] = fiter->idx[swap_idx];
+ fiter->idx[swap_idx] = temp_idx;
+ } /* end for */
+ } /* end if */
+
+ /* Return iteration object */
+ return(fiter);
+} /* end fiter_rnd_init() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: fiter_rnd_next
+ *
+ * Purpose: Get next element index (random iteration)
+ *
+ * Return: Success: Non-negative
+ * Failure: Negative
+ *
+ *-------------------------------------------------------------------------
+ */
+static hssize_t
+fiter_rnd_next(void *_fiter)
+{
+ fiter_rnd_t *fiter = (fiter_rnd_t *)_fiter;
+ hssize_t ret_val;
+
+ /* Sanity check */
+ HDassert(fiter);
+
+ /* Get the next array index to test */
+ ret_val = (hssize_t)fiter->idx[fiter->pos];
+ fiter->pos++;
+
+ return(ret_val);
+} /* end fiter_rnd_next() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: fiter_rnd_term
+ *
+ * Purpose: Shut down element interator (random iteration)
+ *
+ * Return: Success: 0
+ * Failure: -1
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+fiter_rnd_term(void *_fiter)
+{
+ fiter_rnd_t *fiter = (fiter_rnd_t *)_fiter;
+
+ /* Sanity check */
+ HDassert(fiter);
+ HDassert(fiter->idx);
+
+ /* Free shuffled index array */
+ HDfree(fiter->idx);
+
+ /* Free iteration object */
+ HDfree(fiter);
+
+ return(0);
+} /* end fiter_rnd_term() */
+
+/* Fixed array iterator class for random iteration */
+static const farray_iter_t fa_iter_rnd = {
+ fiter_rnd_init, /* Iterator init */
+ fiter_rnd_next, /* Next array index */
+ fiter_rnd_term /* Iterator term */
+};
+
+/* Fixed array iterator info for cyclic iteration */
+typedef struct fiter_cyc_t {
+ hsize_t pos; /* Position in shuffled array */
+ hsize_t cnt; /* # of elements to store */
+ hsize_t cyc; /* Cycle of elements to choose from */
+} fiter_cyc_t;
+
+
+/*-------------------------------------------------------------------------
+ * Function: fiter_cyc_init
+ *
+ * Purpose: Initialize element interator (cyclic iteration)
+ *
+ * Return: Success: Pointer to iteration status object
+ * Failure: NULL
+ *
+ *-------------------------------------------------------------------------
+ */
+static void *
+fiter_cyc_init(const H5FA_create_t UNUSED *cparam, const farray_test_param_t UNUSED *tparam,
+ hsize_t cnt)
+{
+ fiter_cyc_t *fiter; /* Cyclic element iteration object */
+
+ /* Allocate space for the element iteration object */
+ fiter = (fiter_cyc_t *)HDmalloc(sizeof(fiter_cyc_t));
+ HDassert(fiter);
+
+ /* Initialize reverse iteration info */
+ fiter->pos = 0;
+ fiter->cnt = cnt;
+ fiter->cyc = 0;
+
+ /* Return iteration object */
+ return(fiter);
+} /* end fiter_cyc_init() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: fiter_cyc_next
+ *
+ * Purpose: Get next element index (cyclic iteration)
+ *
+ * Return: Success: Non-negative
+ * Failure: Negative
+ *
+ *-------------------------------------------------------------------------
+ */
+static hssize_t
+fiter_cyc_next(void *_fiter)
+{
+ fiter_cyc_t *fiter = (fiter_cyc_t *)_fiter;
+ hssize_t ret_val;
+
+ /* Sanity check */
+ HDassert(fiter);
+
+ /* Get the next array index to test */
+ ret_val = (hssize_t)fiter->pos;
+ fiter->pos += FA_CYC_COUNT;
+ if(fiter->pos >= fiter->cnt)
+ fiter->pos = ++fiter->cyc;
+
+ return(ret_val);
+} /* end fiter_cyc_next() */
+
+
+/* Fixed array iterator class for cyclic iteration */
+static const farray_iter_t fa_iter_cyc = {
+ fiter_cyc_init, /* Iterator init */
+ fiter_cyc_next, /* Next array index */
+ fiter_term /* Iterator term */
+};
+
+
+/*-------------------------------------------------------------------------
+ * Function: check_elmt
+ *
+ * Purpose: Check whether _relmt is the same as in _welmt
+ *
+ * Return: Success: 0
+ * Failure: 1
+ *
+ * Programmer: Vailin Choi; 6th August, 2009
+ *
+ *-------------------------------------------------------------------------
+ */
+static int
+check_elmt(farray_test_param_t *tparam, void *_relmt, void *_welmt)
+{
+ uint64_t *relmt = (uint64_t *)_relmt;
+ uint64_t *welmt = (uint64_t *)_welmt;
+
+ if(welmt == NULL) { /* check for fill value */
+ if(*relmt != H5FA_TEST_FILL)
+ TEST_ERROR
+ } /* end if */
+ else {
+ if(*relmt != *welmt)
+ TEST_ERROR
+ } /* end else */
+
+ return(0);
+
+error:
+ return(-1);
+} /* end check_elmt() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_set_elmts
+ *
+ * Purpose: Set all elements from 0 to ('nelmts' - 1) in fixed array
+ * ("nelmts" is the # of elements to be set in the fixed array)
+ *
+ * Return: Success: 0
+ * Failure: 1
+ *
+ *-------------------------------------------------------------------------
+ */
+static unsigned
+test_set_elmts(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t *tparam,
+ hsize_t nelmts, const char *test_str)
+{
+ hid_t file = -1; /* File ID */
+ H5F_t *f = NULL; /* Internal file object pointer */
+ H5FA_t *fa = NULL; /* Fixed array wrapper */
+ void *fiter_info; /* Fixed array iterator info */
+ farray_state_t state; /* State of fixed array */
+ uint64_t welmt; /* Element to write */
+ uint64_t relmt; /* Element to read */
+ hsize_t cnt; /* Count of array indices */
+ hssize_t sidx; /* Index value of next element in the fixed array */
+ hsize_t idx; /* Index value of next element in the fixed array */
+ hsize_t fa_nelmts; /* # of elements in fixed array */
+ haddr_t fa_addr = HADDR_UNDEF; /* Array address in file */
+
+ HDassert(nelmts);
+ /*
+ * Display testing message
+ */
+ TESTING(test_str);
+
+ /* Create file & retrieve pointer to internal file object */
+ if(create_file(fapl, &file, &f) < 0)
+ TEST_ERROR
+
+ /* Create array */
+ if(create_array(f, H5P_DATASET_XFER_DEFAULT, cparam, &fa, &fa_addr, NULL) < 0)
+ TEST_ERROR
+
+ /* Verify the creation parameters */
+ if(verify_cparam(fa, cparam) < 0)
+ TEST_ERROR
+
+ /* Check for closing & re-opening the file */
+ if(reopen_file(&file, &f, fapl, H5P_DATASET_XFER_DEFAULT, &fa, fa_addr, cparam->cls, tparam) < 0)
+ TEST_ERROR
+
+ if(H5FA_get_nelmts(fa, &fa_nelmts) < 0)
+ FAIL_STACK_ERROR
+
+ if(nelmts > fa_nelmts)
+ TEST_ERROR
+
+ /* Verify array state */
+ HDmemset(&state, 0, sizeof(state));
+ state.hdr_size = FA_HDR_SIZE;
+ state.nelmts = cparam->nelmts;
+ state.dblk_size = 0;
+ if(check_stats(fa, &state))
+ TEST_ERROR
+
+ /* Get all elements from empty array */
+
+ /* Initialize iterator */
+ if(NULL == (fiter_info = tparam->fiter->init(cparam, tparam, nelmts)))
+ TEST_ERROR
+
+ /* Get elements of array */
+ for(cnt = 0; cnt < nelmts; cnt++) {
+ /* Get the array index */
+ if((sidx = tparam->fiter->next(fiter_info)) < 0)
+ TEST_ERROR
+ idx = (hsize_t)sidx;
+
+ /* Retrieve element of array (not set yet) */
+ relmt = (uint64_t)0;
+ if(H5FA_get(fa, H5P_DATASET_XFER_DEFAULT, idx, &relmt) < 0)
+ FAIL_STACK_ERROR
+
+ /* Verify that the retrieved is correct */
+ if(check_elmt(tparam, &relmt, NULL))
+ TEST_ERROR
+ } /* end for */
+
+ /* Shutdown iterator */
+ if(tparam->fiter->term(fiter_info) < 0)
+ TEST_ERROR
+
+
+ /* Set (& get) all elements from empty array */
+
+ /* Initialize iterator */
+ if(NULL == (fiter_info = tparam->fiter->init(cparam, tparam, nelmts)))
+ TEST_ERROR
+
+ /* Set elements of array */
+ for(cnt = 0; cnt < nelmts; cnt++) {
+ /* Get the array index */
+ if((sidx = tparam->fiter->next(fiter_info)) < 0)
+ TEST_ERROR
+ idx = (hsize_t)sidx;
+
+ relmt = (uint64_t)0;
+ if(H5FA_get(fa, H5P_DATASET_XFER_DEFAULT, idx, &relmt) < 0)
+ FAIL_STACK_ERROR
+
+ /* Verify that the retrieved element is correct */
+ if(check_elmt(tparam, &relmt, NULL))
+ TEST_ERROR
+
+ /* Set element of array */
+ welmt = (uint64_t)7 + idx;
+ if(H5FA_set(fa, H5P_DATASET_XFER_DEFAULT, idx, &welmt) < 0)
+ FAIL_STACK_ERROR
+
+ /* Retrieve element of array (set now) */
+ relmt = (uint64_t)0;
+ if(H5FA_get(fa, H5P_DATASET_XFER_DEFAULT, idx, &relmt) < 0)
+ FAIL_STACK_ERROR
+
+ /* Verify that the retrieved element is correct */
+ if(check_elmt(tparam, &relmt, &welmt))
+ TEST_ERROR
+ } /* end for */
+
+ /* Verify array state */
+ HDmemset(&state, 0, sizeof(state));
+ set_fa_state(cparam, &state);
+ if(check_stats(fa, &state))
+ TEST_ERROR
+
+ /* Shutdown iterator */
+ if(tparam->fiter->term(fiter_info) < 0)
+ TEST_ERROR
+
+ /* Close array, delete array, close file & verify file is empty */
+ if(finish(file, fapl, f, fa, fa_addr) < 0)
+ TEST_ERROR
+
+ /* All tests passed */
+ PASSED()
+
+ return 0;
+
+error:
+ H5E_BEGIN_TRY {
+ if(fa)
+ H5FA_close(fa, H5P_DATASET_XFER_DEFAULT);
+ H5Fclose(file);
+ } H5E_END_TRY;
+
+ return 1;
+} /* test_set_elmts() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: test_skip_elmts
+ *
+ * Purpose: Set the element "skip_elmts" in the fixed array
+ * ("skip_elmts" is the index of the fixed array to be set.)
+ *
+ * Return: Success: 0
+ * Failure: 1
+ *
+ *-------------------------------------------------------------------------
+ */
+static unsigned
+test_skip_elmts(hid_t fapl, H5FA_create_t *cparam, farray_test_param_t *tparam,
+ hsize_t skip_elmts, hbool_t check_rest, const char *test_str)
+{
+ hid_t file = -1; /* File ID */
+ H5F_t *f = NULL; /* Internal file object pointer */
+ H5FA_t *fa = NULL; /* Extensible array wrapper */
+ farray_state_t state; /* State of extensible array */
+ uint64_t welmt; /* Element to write */
+ uint64_t relmt; /* Element to read */
+ hsize_t idx; /* Index value of element to get */
+ hsize_t cnt; /* Count of array indices */
+ hsize_t fa_nelmts; /* # of elements in fixed array */
+ haddr_t fa_addr = HADDR_UNDEF; /* Array address in file */
+
+ /*
+ * Display testing message
+ */
+ TESTING(test_str);
+
+ /* Create file & retrieve pointer to internal file object */
+ if(create_file(fapl, &file, &f) < 0)
+ TEST_ERROR
+
+ /* Create array */
+ if(create_array(f, H5P_DATASET_XFER_DEFAULT, cparam, &fa, &fa_addr, NULL) < 0)
+ TEST_ERROR
+
+ /* Verify the creation parameters */
+ if(verify_cparam(fa, cparam) < 0)
+ TEST_ERROR
+
+ /* Check for closing & re-opening the file */
+ if(reopen_file(&file, &f, fapl, H5P_DATASET_XFER_DEFAULT, &fa, fa_addr, cparam->cls, tparam) < 0)
+ TEST_ERROR
+
+ if(H5FA_get_nelmts(fa, &fa_nelmts) < 0)
+ FAIL_STACK_ERROR
+
+ if(skip_elmts >= fa_nelmts)
+ TEST_ERROR
+
+ /* Verify array state */
+ HDmemset(&state, 0, sizeof(state));
+ state.hdr_size = FA_HDR_SIZE;
+ state.nelmts = cparam->nelmts;
+ state.dblk_size = 0;
+ if(check_stats(fa, &state))
+ TEST_ERROR
+
+ /* Set (& get) element after skipping elements */
+ idx = skip_elmts;
+
+ /* Retrieve element of array (not set yet) */
+ relmt = (uint64_t)0;
+ if(H5FA_get(fa, H5P_DATASET_XFER_DEFAULT, idx, &relmt) < 0)
+ FAIL_STACK_ERROR
+
+ /* Verify that the retrieved is correct */
+ if(check_elmt(tparam, &relmt, NULL))
+ TEST_ERROR
+
+ /* Set element of array */
+ welmt = (uint64_t)7 + idx;
+ if(H5FA_set(fa, H5P_DATASET_XFER_DEFAULT, idx, &welmt) < 0)
+ FAIL_STACK_ERROR
+
+ /* Verify array state */
+ HDmemset(&state, 0, sizeof(state));
+ set_fa_state(cparam, &state);
+ if(check_stats(fa, &state))
+ TEST_ERROR
+
+ /* Retrieve element of array (set now) */
+ relmt = (uint64_t)0;
+ if(H5FA_get(fa, H5P_DATASET_XFER_DEFAULT, idx, &relmt) < 0)
+ FAIL_STACK_ERROR
+
+ /* Verify that the retrieved is correct */
+ if(check_elmt(tparam, &relmt, &welmt))
+ TEST_ERROR
+
+ if(check_rest) {
+ /* Get unset elements of array */
+ for(cnt = 0; cnt < skip_elmts; cnt++) {
+ /* Retrieve element of array (not set yet) */
+ relmt = (uint64_t)0;
+ if(H5FA_get(fa, H5P_DATASET_XFER_DEFAULT, cnt, &relmt) < 0)
+ FAIL_STACK_ERROR
+
+ /* Verify that the retrieved is correct */
+ if(check_elmt(tparam, &relmt, NULL))
+ TEST_ERROR
+ } /* end for */
+ } /* end if */
+
+ /* Close array, delete array, close file & verify file is empty */
+ if(finish(file, fapl, f, fa, fa_addr) < 0)
+ TEST_ERROR
+
+ /* All tests passed */
+ PASSED()
+
+ return 0;
+
+error:
+ H5E_BEGIN_TRY {
+ if(fa)
+ H5FA_close(fa, H5P_DATASET_XFER_DEFAULT);
+ H5Fclose(file);
+ } H5E_END_TRY;
+
+ return 1;
+} /* test_skip_elmts() */
+
+
+/*-------------------------------------------------------------------------
+ * Function: main
+ *
+ * Purpose: Test the fixed array code
+ *
+ * Return: Success: 0
+ * Failure: 1
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+main(void)
+{
+ H5FA_create_t cparam; /* Creation parameters for fixed array */
+ farray_test_param_t tparam; /* Testing parameters */
+ farray_test_type_t curr_test; /* Current test being worked on */
+ farray_iter_type_t curr_iter; /* Current iteration type being worked on */
+ hid_t fapl = -1; /* File access property list for data files */
+ unsigned nerrors = 0; /* Cumulative error count */
+ time_t curr_time; /* Current time, for seeding random number generator */
+ int ExpressMode; /* Test express value */
+
+ /* Reset library */
+ h5_reset();
+ fapl = h5_fileaccess();
+ ExpressMode = GetTestExpress();
+ if(ExpressMode > 1)
+ printf("***Express test mode on. Some tests may be skipped\n");
+
+ /* Set the filename to use for this test (dependent on fapl) */
+ h5_fixname(FILENAME[0], fapl, filename_g, sizeof(filename_g));
+
+ /* Seed random #'s */
+ curr_time = HDtime(NULL);
+ HDsrandom((unsigned long)curr_time);
+
+ /* Create an empty file to retrieve size */
+ {
+ hid_t file; /* File ID */
+
+ if((file = H5Fcreate(filename_g, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
+ FAIL_STACK_ERROR
+
+ /* Close file */
+ if(H5Fclose(file) < 0)
+ FAIL_STACK_ERROR
+
+ /* Get the size of a file w/no array */
+ if((empty_size_g = h5_get_file_size(filename_g, fapl)) < 0)
+ TEST_ERROR
+ }
+
+ /* Iterate over the testing parameters */
+ for(curr_test = FARRAY_TEST_NORMAL; curr_test < FARRAY_TEST_NTESTS; curr_test++) {
+
+ /* Initialize the testing parameters */
+ HDmemset(&tparam, 0, sizeof(tparam));
+ tparam.nelmts = TEST_NELMTS;
+
+ /* Set appropriate testing parameters for each test */
+ switch(curr_test) {
+ /* "Normal" testing parameters */
+ case FARRAY_TEST_NORMAL:
+ puts("Testing with NORMAL PARAMETERS");
+ break;
+
+ /* "Re-open array" testing parameters */
+ case FARRAY_TEST_REOPEN:
+ puts("Testing with reopen array flag set");
+ tparam.reopen_array = FARRAY_TEST_REOPEN;
+ break;
+
+ /* An unknown test? */
+ case FARRAY_TEST_NTESTS:
+ default:
+ goto error;
+ } /* end switch */
+
+ /* Initialize fixed array creation parameters */
+ init_cparam(&cparam, &tparam);
+
+ /* Basic capability tests */
+ nerrors += test_create(fapl, &cparam, &tparam);
+ nerrors += test_reopen(fapl, &cparam, &tparam);
+ nerrors += test_open_twice(fapl, &cparam, &tparam);
+ nerrors += test_delete_open(fapl, &cparam, &tparam);
+
+ /* Iterate over the type of capacity tests */
+ for(curr_iter = FARRAY_ITER_FW; curr_iter < FARRAY_ITER_NITERS; curr_iter++) {
+
+ /* Set appropriate parameters for each type of iteration */
+ switch(curr_iter) {
+ /* "Forward" testing parameters */
+ case FARRAY_ITER_FW:
+ puts("Testing with forward iteration");
+ tparam.fiter = &fa_iter_fw;
+ break;
+
+ /* "Reverse" testing parameters */
+ case FARRAY_ITER_RV:
+ puts("Testing with reverse iteration");
+ tparam.fiter = &fa_iter_rv;
+ break;
+
+ /* "Random" testing parameters */
+ case FARRAY_ITER_RND:
+ puts("Testing with random iteration");
+ tparam.fiter = &fa_iter_rnd;
+ break;
+
+ /* "Cyclic" testing parameters */
+ case FARRAY_ITER_CYC:
+ puts("Testing with cyclic iteration");
+ tparam.fiter = &fa_iter_cyc;
+ break;
+
+ /* An unknown iteration? */
+ case FARRAY_ITER_NITERS:
+ default:
+ goto error;
+ } /* end switch */
+
+ /* Basic capacity tests */
+ nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)1, "setting 1 element of the array");
+ nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(tparam.nelmts/2), "setting half of the array's elements ");
+ nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)tparam.nelmts, "setting all the array elements");
+ } /* end for */
+
+ /* Check skipping elements */
+ nerrors += test_skip_elmts(fapl, &cparam, &tparam, (hsize_t)1, TRUE, "skipping to first element");
+ nerrors += test_skip_elmts(fapl, &cparam, &tparam, ((hsize_t)1 << cparam.max_dblk_page_nelmts_bits), TRUE, "skipping to first element in data block page");
+ nerrors += test_skip_elmts(fapl, &cparam, &tparam, (hsize_t)(tparam.nelmts - 1), TRUE, "skipping to last element");
+
+ /* Create Fixed Array of MAX_NELMTS elements */
+ /*
+ * MAX_NELMTS succeeds on jam and smirom.
+ * The value was adjusted for linew due to the following:
+ Linew failed with "H5FD_sec2_truncate(): unable to extend file properly"
+ Linew failed with "H5FD_sec2_truncate(): File too large"
+ */
+ tparam.nelmts = MAX_NELMTS/17;
+ init_cparam(&cparam, &tparam);
+
+ /* Set the last element in the Fixed Array */
+ nerrors += test_skip_elmts(fapl, &cparam, &tparam, (hsize_t)(tparam.nelmts - 1), FALSE, "skipping to last element");
+ } /* end for */
+
+ if(nerrors)
+ goto error;
+ puts("All fixed array tests passed.");
+
+ /* Clean up file used */
+ h5_cleanup(FILENAME, fapl);
+
+ return 0;
+
+error:
+ puts("*** TESTS FAILED ***");
+
+ H5E_BEGIN_TRY {
+ H5Pclose(fapl);
+ } H5E_END_TRY;
+
+ return 1;
+} /* end main() */
+