hdf5/test/earray.c

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * Copyright by The HDF Group.                                               *
 * 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 COPYING file, which can be found at the root of the source code       *
 * distribution tree, or in https://www.hdfgroup.org/licenses.               *
 * If you do not have access to either file, you may request a copy from     *
 * help@hdfgroup.org.                                                        *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include "h5test.h"

/*
 * This file needs to access private datatypes from the H5EA package.
 * This file also needs to access the extensible array testing code.
 */
#define H5EA_FRIEND /*suppress error about including H5EApkg      */
#define H5EA_TESTING
#include "H5EApkg.h" /* Extensible Arrays            */

/* Other private headers that this test requires */
#include "H5CXprivate.h" /* API Contexts                         */
#include "H5Iprivate.h"  /* IDs                      */
#include "H5VLprivate.h" /* Virtual Object Layer                     */
#include "H5VMprivate.h" /* Vectors and arrays             */

/* Local macros */

/* Max. testfile name length */
#define EARRAY_FILENAME_LEN 1024

/* Extensible array creation values */
#define ELMT_SIZE                   sizeof(uint64_t)
#define MAX_NELMTS_BITS             32 /* i.e. 4 giga-elements */
#define IDX_BLK_ELMTS               4
#define SUP_BLK_MIN_DATA_PTRS       4
#define DATA_BLK_MIN_ELMTS          16
#define MAX_DBLOCK_PAGE_NELMTS_BITS 10 /* i.e. 1024 elements per data block page */

/* Convenience macros for computing earray state */
#define EA_HDR_SIZE    72  /* (hard-coded, current size) */
#define EA_IBLOCK_SIZE 298 /* (hard-coded, current size) */
#define EA_NELMTS(cparam, tparam, idx, sblk_idx)                                                             \
    (hsize_t)(cparam->idx_blk_elmts + tparam->sblk_info[sblk_idx].start_idx +                                \
              ((1 + ((idx - (cparam->idx_blk_elmts + tparam->sblk_info[sblk_idx].start_idx)) /               \
                     tparam->sblk_info[sblk_idx].dblk_nelmts)) *                                             \
               tparam->sblk_info[sblk_idx].dblk_nelmts))
#define EA_NDATA_BLKS(cparam, tparam, idx, sblk_idx)                                                         \
    (1 + tparam->sblk_info[sblk_idx].start_dblk +                                                            \
     ((idx - (cparam->idx_blk_elmts + tparam->sblk_info[sblk_idx].start_idx)) /                              \
      tparam->sblk_info[sblk_idx].dblk_nelmts))

/* Iterator parameter values */
#define EA_RND2_SCALE 100
#define EA_CYC_COUNT  4

/* Local typedefs */

/* Types of tests to perform */
typedef enum {
    EARRAY_TEST_NORMAL, /* "Normal" test, with no testing parameters set */
    EARRAY_TEST_REOPEN, /* Set the reopen_array flag */
    EARRAY_TEST_NTESTS  /* The number of test types, must be last */
} earray_test_type_t;

/* Types of iteration to perform */
typedef enum {
    EARRAY_ITER_FW,    /* "Forward" iteration */
    EARRAY_ITER_RV,    /* "Reverse" iteration */
    EARRAY_ITER_RND,   /* "Random" iteration */
    EARRAY_ITER_CYC,   /* "Cyclic" iteration */
    EARRAY_ITER_RND2,  /* "Random #2" iteration */
    EARRAY_ITER_NITERS /* The number of iteration types, must be last */
} earray_iter_type_t;

/* Orders to operate on entries */
typedef enum {
    EARRAY_DIR_FORWARD, /* Insert objects from 0 -> nobjs */
    EARRAY_DIR_RANDOM,  /* Insert objects randomly from 0 - nobjs */
    EARRAY_DIR_CYCLIC,  /* Insert every n'th object cyclicly: 0, n, 2n, 3n, ..., nobjs/n, 1+nobjs/n,
                           1+n+nobjs/n, 1+2n+nobjs/n, ..., nobjs */
    EARRAY_DIR_REVERSE, /* Insert objects from nobjs -> 0 */
    EARRAY_DIR_INWARD, /* Insert objects from outside to in: 0, nobjs, 1, nobjs-1, 2, nobjs-2, ..., nobjs/2 */
    EARRAY_DIR_OUTWARD, /* Insert objects from inside to out: nobjs/2, (nobjs/2)-1, (nobjs/2)+1, ..., 0, nobjs
                         */
    EARRAY_DIR_NDIRS    /* The number of different insertion orders, must be last */
} earray_test_dir_t;

/* Whether to compress data blocks */
typedef enum {
    EARRAY_TEST_NO_COMPRESS, /* Don't compress data blocks */
    EARRAY_TEST_COMPRESS,    /* Compress data blocks */
    EARRAY_TEST_COMP_N       /* The number of different ways to test compressing array blocks, must be last */
} earray_test_comp_t;

/* Extensible array state information */
typedef struct earray_state_t {
    hsize_t hdr_size;       /* Size of header */
    hsize_t nindex_blks;    /* # of index blocks */
    hsize_t index_blk_size; /* Size of index blocks */
    hsize_t nsuper_blks;    /* # of super blocks */
    hsize_t super_blk_size; /* Size of super blocks */
    hsize_t ndata_blks;     /* # of data blocks */
    hsize_t data_blk_size;  /* Size of data blocks */
    hsize_t max_idx_set; /* Highest element index stored (+1 - i.e. if element 0 has been set, this value with
                            be '1', if no elements have been stored, this value will be '0') */
    hsize_t nelmts;      /* # of elements "realized" */
} earray_state_t;

/* Forward decl. */
typedef struct earray_test_param_t earray_test_param_t;

/* Extensible array iterator class */
typedef struct earray_iter_t {
    void *(*init)(const H5EA_create_t *cparam, const earray_test_param_t *tparam,
                  hsize_t cnt);             /* Initialize/allocate iterator private info */
    hssize_t (*next)(void *info);           /* Get the next element to test */
    hssize_t (*max_elem)(const void *info); /* Get the max. element set */
    int (*state)(void *in_eiter, const H5EA_create_t *cparam, const earray_test_param_t *tparam,
                 earray_state_t *state, hsize_t idx); /* Get the state of the extensible array */
    herr_t (*term)(void *info);                       /* Shutdown/free iterator private info */
} earray_iter_t;

/* Testing parameters */
struct earray_test_param_t {
    earray_test_type_t   reopen_array; /* Whether to re-open the array during the test */
    earray_test_comp_t   comp;         /* Whether to compress the blocks or not */
    const earray_iter_t *eiter;        /* Iterator to use for this test */

    /* Super block information */
    size_t            nsblks;    /* Number of superblocks needed for array */
    H5EA_sblk_info_t *sblk_info; /* Array of information for each super block */
};

/* Flush depend test context */
typedef struct earray_flush_depend_ctx_t {
    bool base_obj;      /* Flag to indicate that base object has been flushed */
    bool idx0_obj;      /* Flag to indicate that index 0's object has been flushed */
    bool idx0_elem;     /* Flag to indicate that index 0's element has been flushed */
    bool idx1_obj;      /* Flag to indicate that index 1's object has been flushed */
    bool idx1_elem;     /* Flag to indicate that index 1's element has been flushed */
    bool idx10000_obj;  /* Flag to indicate that index 10000's object has been flushed */
    bool idx10000_elem; /* Flag to indicate that index 10000's element has been flushed */
} earray_flush_depend_ctx_t;

/* Extensible array test cache object */
typedef struct earray_test_t {
    /* Information for H5AC cache functions, _must_ be first field in structure */
    H5AC_info_t cache_info;

    /* Entry information */
    uint64_t                   idx;     /* Index that entry corresponds to */
    earray_flush_depend_ctx_t *fd_info; /* Context information for flush depend test */
} earray_test_t;

/* Local prototypes */

/* Local variables */
static const char *FILENAME[] = {"earray", "earray_tmp", NULL};

/* Filename to use for all tests */
char filename_g[EARRAY_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(H5EA_create_t *cparam)
{
    /* Wipe out background */
    memset(cparam, 0, sizeof(*cparam));

    /* General parameters */
    cparam->cls                       = H5EA_CLS_TEST;
    cparam->raw_elmt_size             = ELMT_SIZE;
    cparam->max_nelmts_bits           = MAX_NELMTS_BITS;
    cparam->idx_blk_elmts             = IDX_BLK_ELMTS;
    cparam->sup_blk_min_data_ptrs     = SUP_BLK_MIN_DATA_PTRS;
    cparam->data_blk_min_elmts        = DATA_BLK_MIN_ELMTS;
    cparam->max_dblk_page_nelmts_bits = MAX_DBLOCK_PAGE_NELMTS_BITS;

    return (0);
} /* init_cparam() */

/*-------------------------------------------------------------------------
 * Function:    init_tparam
 *
 * Purpose:    Initialize array testing parameter structure
 *
 * Note:    This initialization is the same as that in H5EA_hdr_init()
 *
 * Return:    Success:    0
 *        Failure:    -1
 *
 *-------------------------------------------------------------------------
 */
static int
init_tparam(earray_test_param_t *tparam, const H5EA_create_t *cparam)
{
    hsize_t start_idx;  /* First element index for each super block */
    hsize_t start_dblk; /* First data block index for each super block */
    size_t  u;          /* Local index variable */

    /* Wipe out background */
    memset(tparam, 0, sizeof(*tparam));

    /* Compute general information */
    tparam->nsblks = 1 + (cparam->max_nelmts_bits - H5VM_log2_of2(cparam->data_blk_min_elmts));

    /* Allocate information for each super block */
    tparam->sblk_info = (H5EA_sblk_info_t *)malloc(sizeof(H5EA_sblk_info_t) * tparam->nsblks);
    assert(tparam->sblk_info);

    /* Compute information about each super block */
    start_idx  = 0;
    start_dblk = 0;
    for (u = 0; u < tparam->nsblks; u++) {
        tparam->sblk_info[u].ndblks      = (size_t)H5_EXP2(u / 2);
        tparam->sblk_info[u].dblk_nelmts = (size_t)H5_EXP2((u + 1) / 2) * cparam->data_blk_min_elmts;
        tparam->sblk_info[u].start_idx   = start_idx;
        tparam->sblk_info[u].start_dblk  = start_dblk;

        /* Advance starting indices for next super block */
        start_idx += (hsize_t)tparam->sblk_info[u].ndblks * (hsize_t)tparam->sblk_info[u].dblk_nelmts;
        start_dblk += (hsize_t)tparam->sblk_info[u].ndblks;
    } /* end for */

    return (0);
} /* init_tparam() */

/*-------------------------------------------------------------------------
 * Function:    finish_tparam
 *
 * Purpose:    Close down array testing parameter structure
 *
 * Return:    Success:    0
 *        Failure:    -1
 *
 *-------------------------------------------------------------------------
 */
static int
finish_tparam(earray_test_param_t *tparam)
{
    /* Release super block information */
    free(tparam->sblk_info);
    tparam->sblk_info = NULL;

    return (0);
} /* finish_tparam() */

/*-------------------------------------------------------------------------
 * Function:    create_file
 *
 * Purpose:    Create file and retrieve pointer to internal file object
 *
 * Return:    Success:    0
 *        Failure:    -1
 *
 *-------------------------------------------------------------------------
 */
static int
create_file(unsigned flags, hid_t fapl, hid_t *file, H5F_t **f)
{
    /* Create the file to work on */
    if ((*file = H5Fcreate(filename_g, flags, H5P_DEFAULT, fapl)) < 0)
        FAIL_STACK_ERROR;

    /* Get a pointer to the internal file object */
    if (NULL == (*f = (H5F_t *)H5VL_object(*file)))
        FAIL_STACK_ERROR;

    /* Ignore metadata tags in the file's cache */
    if (H5AC_ignore_tags(*f) < 0)
        FAIL_STACK_ERROR;

    /* Success */
    return (0);

error:
    return (-1);
} /* create_file() */

/*-------------------------------------------------------------------------
 * Function:    check_stats
 *
 * Purpose:    Verify stats for an extensible array
 *
 * Return:    Success:    0
 *        Failure:    -1
 *
 *-------------------------------------------------------------------------
 */
static int
check_stats(const H5EA_t *ea, const earray_state_t *state)
{
    H5EA_stat_t earray_stats; /* Statistics about the array */

    /* Get statistics for extensible array and verify they are correct */
    if (H5EA_get_stats(ea, &earray_stats) < 0)
        FAIL_STACK_ERROR;

    /* Compare information */
    if (earray_stats.stored.max_idx_set != state->max_idx_set) {
        fprintf(stdout,
                "earray_stats.stored.max_idx_set = %" PRIuHSIZE ", state->max_idx_set = %" PRIuHSIZE "\n",
                earray_stats.stored.max_idx_set, state->max_idx_set);
        TEST_ERROR;
    } /* end if */
    if (earray_stats.stored.nelmts != state->nelmts) {
        fprintf(stdout, "earray_stats.stored.nelmts = %" PRIuHSIZE ", state->nelmts = %" PRIuHSIZE "\n",
                earray_stats.stored.nelmts, state->nelmts);
        TEST_ERROR;
    } /* end if */
    if (earray_stats.computed.hdr_size != state->hdr_size) {
        fprintf(stdout, "earray_stats.computed.hdr_size = %" PRIuHSIZE ", state->hdr_size = %" PRIuHSIZE "\n",
                earray_stats.computed.hdr_size, state->hdr_size);
        TEST_ERROR;
    } /* end if */
    if (earray_stats.computed.nindex_blks != state->nindex_blks) {
        fprintf(stdout,
                "earray_stats.computed.nindex_blks = %" PRIuHSIZE ", state->nindex_blks = %" PRIuHSIZE "\n",
                earray_stats.computed.nindex_blks, state->nindex_blks);
        TEST_ERROR;
    } /* end if */
    if (earray_stats.computed.index_blk_size != state->index_blk_size) {
        fprintf(stdout,
                "earray_stats.computed.index_blk_size = %" PRIuHSIZE ", state->index_blk_size = %" PRIuHSIZE
                "\n",
                earray_stats.computed.index_blk_size, state->index_blk_size);
        TEST_ERROR;
    } /* end if */
    if (earray_stats.stored.ndata_blks != state->ndata_blks) {
        fprintf(stdout,
                "earray_stats.stored.ndata_blks = %" PRIuHSIZE ", state->ndata_blks = %" PRIuHSIZE "\n",
                earray_stats.stored.ndata_blks, state->ndata_blks);
        TEST_ERROR;
    } /* end if */
/* Don't compare this currently, it's very hard to compute */
#ifdef NOT_YET
    if (earray_stats.stored.data_blk_size != state->data_blk_size) {
        fprintf(stdout,
                "earray_stats.stored.data_blk_size = %" PRIuHSIZE ", state->data_blk_size = %" PRIuHSIZE "\n",
                earray_stats.stored.data_blk_size, state->data_blk_size);
        TEST_ERROR;
    }  /* end if */
#endif /* NOT_YET */
    if (earray_stats.stored.nsuper_blks != state->nsuper_blks) {
        fprintf(stdout,
                "earray_stats.stored.nsuper_blks = %" PRIuHSIZE ", state->nsuper_blks = %" PRIuHSIZE "\n",
                earray_stats.stored.nsuper_blks, state->nsuper_blks);
        TEST_ERROR;
    } /* end if */
/* Don't compare this currently, it's very hard to compute */
#ifdef NOT_YET
    if (earray_stats.stored.super_blk_size != state->super_blk_size) {
        fprintf(stdout,
                "earray_stats.stored.super_blk_size = %" PRIuHSIZE ", state->super_blk_size = %" PRIuHSIZE
                "\n",
                earray_stats.stored.super_blk_size, state->super_blk_size);
        TEST_ERROR;
    }  /* end if */
#endif /* NOT_YET */

    /* All tests passed */
    return (0);

error:
    return (-1);
} /* check_stats() */

/*-------------------------------------------------------------------------
 * 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, H5EA_t **ea, haddr_t ea_addr,
            const earray_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 (ea && *ea) {
            if (H5EA_close(*ea) < 0)
                FAIL_STACK_ERROR;
            *ea = NULL;
        } /* end if */

        /* Close file */
        if (*file) {
            if (H5Fclose(*file) < 0)
                FAIL_STACK_ERROR;
            *file = (-1);
            *f    = NULL;
        } /* end if */

        /* 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 *)H5VL_object(*file)))
            FAIL_STACK_ERROR;

        /* Ignore metadata tags in the file's cache */
        if (H5AC_ignore_tags(*f) < 0)
            FAIL_STACK_ERROR;

        /* Re-open array, if given */
        if (ea)
            if (NULL == (*ea = H5EA_open(*f, ea_addr, NULL)))
                FAIL_STACK_ERROR;
    } /* end if */

    /* Success */
    return (0);

error:
    return (-1);
} /* reopen_file() */

/*-------------------------------------------------------------------------
 * Function:    create_array
 *
 * Purpose:    Create an extensible array and perform initial checks
 *
 * Return:    Success:    0
 *        Failure:    -1
 *
 *-------------------------------------------------------------------------
 */
static int
create_array(H5F_t *f, const H5EA_create_t *cparam, H5EA_t **ea, haddr_t *ea_addr, H5EA__ctx_cb_t *cb)
{
    hsize_t        nelmts; /* Number of elements in array */
    earray_state_t state;  /* State of extensible array */

    /* Create array */
    if (NULL == (*ea = H5EA_create(f, cparam, cb)))
        FAIL_STACK_ERROR;

    /* Check status of array */
    nelmts = (hsize_t)ULLONG_MAX;
    if (H5EA_get_nelmts(*ea, &nelmts) < 0)
        FAIL_STACK_ERROR;
    if (nelmts > 0)
        TEST_ERROR;
    if (H5EA_get_addr(*ea, ea_addr) < 0)
        FAIL_STACK_ERROR;
    if (!H5_addr_defined(*ea_addr))
        TEST_ERROR;
    memset(&state, 0, sizeof(state));
    state.hdr_size = EA_HDR_SIZE;
    if (check_stats(*ea, &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 H5EA_t *ea, const H5EA_create_t *cparam)
{
    H5EA_create_t test_cparam; /* Creation parameters for array */

    /* Retrieve creation parameters */
    memset(&test_cparam, 0, sizeof(H5EA_create_t));
    if (H5EA__get_cparam_test(ea, &test_cparam) < 0)
        FAIL_STACK_ERROR;

    /* Verify creation parameters */
    if (H5EA__cmp_cparam_test(cparam, &test_cparam))
        TEST_ERROR;

    /* Success */
    return SUCCEED;

error:
    return FAIL;
} /* 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, H5EA_t *ea, haddr_t ea_addr)
{
    h5_stat_size_t file_size; /* File size, after deleting array */

    /* Close the extensible array */
    if (H5EA_close(ea) < 0)
        FAIL_STACK_ERROR;

    /* Delete array */
    if (H5EA_delete(f, ea_addr, NULL) < 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 extensible array
 *
 * Return:    Success: 0
 *        Failure: 1
 *
 *-------------------------------------------------------------------------
 */
static unsigned
test_create(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t H5_ATTR_UNUSED *tparam)
{
    hid_t   file    = H5I_INVALID_HID; /* File ID */
    H5F_t  *f       = NULL;            /* Internal file object pointer */
    H5EA_t *ea      = NULL;            /* Extensible array wrapper */
    haddr_t ea_addr = HADDR_UNDEF;     /* Array address in file */

    /* Create file & retrieve pointer to internal file object */
    if (create_file(H5F_ACC_TRUNC, fapl, &file, &f) < 0)
        TEST_ERROR;

    /*
     * Display testing message
     */
    TESTING("invalid extensible array creation parameters");

#ifndef NDEBUG
    {
        H5EA_create_t test_cparam; /* Creation parameters for array */

        /* Set invalid element size */
        memcpy(&test_cparam, cparam, sizeof(test_cparam));
        test_cparam.raw_elmt_size = 0;
        H5E_BEGIN_TRY
        {
            ea = H5EA_create(f, &test_cparam, NULL);
        }
        H5E_END_TRY
        if (ea) {
            /* Close opened extensible array */
            H5EA_close(ea);
            ea = NULL;

            /* Indicate error */
            TEST_ERROR;
        } /* end if */

        /* Set invalid max. # of elements bits */
        memcpy(&test_cparam, cparam, sizeof(test_cparam));
        test_cparam.max_nelmts_bits = 0;
        H5E_BEGIN_TRY
        {
            ea = H5EA_create(f, &test_cparam, NULL);
        }
        H5E_END_TRY
        if (ea) {
            /* Close opened extensible array */
            H5EA_close(ea);
            ea = NULL;

            /* Indicate error */
            TEST_ERROR;
        } /* end if */

        memcpy(&test_cparam, cparam, sizeof(test_cparam));
        test_cparam.max_nelmts_bits = 65;
        H5E_BEGIN_TRY
        {
            ea = H5EA_create(f, &test_cparam, NULL);
        }
        H5E_END_TRY
        if (ea) {
            /* Close opened extensible array */
            H5EA_close(ea);
            ea = NULL;

            /* Indicate error */
            TEST_ERROR;
        } /* end if */

        /* Set invalid min. # of data block pointers in super blocks */
        memcpy(&test_cparam, cparam, sizeof(test_cparam));
        test_cparam.sup_blk_min_data_ptrs = 0;
        H5E_BEGIN_TRY
        {
            ea = H5EA_create(f, &test_cparam, NULL);
        }
        H5E_END_TRY
        if (ea) {
            /* Close opened extensible array */
            H5EA_close(ea);
            ea = NULL;

            /* Indicate error */
            TEST_ERROR;
        } /* end if */
        memcpy(&test_cparam, cparam, sizeof(test_cparam));
        test_cparam.sup_blk_min_data_ptrs = 1;
        H5E_BEGIN_TRY
        {
            ea = H5EA_create(f, &test_cparam, NULL);
        }
        H5E_END_TRY
        if (ea) {
            /* Close opened extensible array */
            H5EA_close(ea);
            ea = NULL;

            /* Indicate error */
            TEST_ERROR;
        } /* end if */
        memcpy(&test_cparam, cparam, sizeof(test_cparam));
        test_cparam.sup_blk_min_data_ptrs = 6;
        H5E_BEGIN_TRY
        {
            ea = H5EA_create(f, &test_cparam, NULL);
        }
        H5E_END_TRY
        if (ea) {
            /* Close opened extensible array */
            H5EA_close(ea);
            ea = NULL;

            /* Indicate error */
            TEST_ERROR;
        } /* end if */

        /* Set invalid min. # of elements per data block */
        memcpy(&test_cparam, cparam, sizeof(test_cparam));
        test_cparam.data_blk_min_elmts = 0;
        H5E_BEGIN_TRY
        {
            ea = H5EA_create(f, &test_cparam, NULL);
        }
        H5E_END_TRY
        if (ea) {
            /* Close opened extensible array */
            H5EA_close(ea);
            ea = NULL;

            /* Indicate error */
            TEST_ERROR;
        } /* end if */

        /* Set invalid max. # of elements per data block page bits */
        if (test_cparam.idx_blk_elmts > 0) {
            memcpy(&test_cparam, cparam, sizeof(test_cparam));
            test_cparam.max_dblk_page_nelmts_bits =
                (uint8_t)(H5VM_log2_gen((uint64_t)test_cparam.idx_blk_elmts) - 1);
            H5E_BEGIN_TRY
            {
                ea = H5EA_create(f, &test_cparam, NULL);
            }
            H5E_END_TRY
            if (ea) {
                /* Close opened extensible array */
                H5EA_close(ea);
                ea = NULL;

                /* Indicate error */
                TEST_ERROR;
            } /* end if */
        }     /* end if */
        memcpy(&test_cparam, cparam, sizeof(test_cparam));
        test_cparam.max_dblk_page_nelmts_bits = 4; /* corresponds to 16 elements in data block page, which is
                                                      less than the 64 elements for the default settings */
        H5E_BEGIN_TRY
        {
            ea = H5EA_create(f, &test_cparam, NULL);
        }
        H5E_END_TRY
        if (ea) {
            /* Close opened extensible array */
            H5EA_close(ea);
            ea = NULL;

            /* Indicate error */
            TEST_ERROR;
        } /* end if */
        memcpy(&test_cparam, cparam, sizeof(test_cparam));
        test_cparam.max_dblk_page_nelmts_bits = (uint8_t)(test_cparam.max_nelmts_bits + 1);
        H5E_BEGIN_TRY
        {
            ea = H5EA_create(f, &test_cparam, NULL);
        }
        H5E_END_TRY
        if (ea) {
            /* Close opened extensible array */
            H5EA_close(ea);
            ea = NULL;

            /* Indicate error */
            TEST_ERROR;
        } /* end if */

        PASSED();
    }
#else  /* NDEBUG */
    SKIPPED();
    puts("    Not tested when assertions are disabled");
#endif /* NDEBUG */

    /*
     * Display testing message
     */
    TESTING("extensible array creation");

    /* Create array */
    if (create_array(f, cparam, &ea, &ea_addr, NULL) < 0)
        TEST_ERROR;

    PASSED();

    /* Verify the creation parameters */
    TESTING("verify array creation parameters");

    /* Verify the creation parameters */
    if (verify_cparam(ea, cparam) < 0)
        TEST_ERROR;

    /* Close array, delete array, close file & verify file is empty */
    if (finish(file, fapl, f, ea, ea_addr) < 0)
        TEST_ERROR;

    /* All tests passed */
    PASSED();

    return 0;

error:
    H5E_BEGIN_TRY
    {
        if (ea)
            H5EA_close(ea);
        H5Fclose(file);
    }
    H5E_END_TRY

    return 1;
} /* end test_create() */

/*-------------------------------------------------------------------------
 * Function:    test_reopen
 *
 * Purpose:    Create & reopen an extensible array
 *
 * Return:    Success:    0
 *        Failure:    1
 *
 *-------------------------------------------------------------------------
 */
static unsigned
test_reopen(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t *tparam)
{
    hid_t   file    = H5I_INVALID_HID; /* File ID */
    H5F_t  *f       = NULL;            /* Internal file object pointer */
    H5EA_t *ea      = NULL;            /* Extensible array wrapper */
    haddr_t ea_addr = HADDR_UNDEF;     /* Array address in file */

    /* Create file & retrieve pointer to internal file object */
    if (create_file(H5F_ACC_TRUNC, fapl, &file, &f) < 0)
        TEST_ERROR;

    /*
     * Display testing message
     */
    TESTING("create, close & reopen extensible array");

    /* Create array */
    if (create_array(f, cparam, &ea, &ea_addr, NULL) < 0)
        TEST_ERROR;

    /* Close the extensible array */
    if (H5EA_close(ea) < 0)
        FAIL_STACK_ERROR;

    /* Check for closing & re-opening the file */
    if (reopen_file(&file, &f, fapl, NULL, HADDR_UNDEF, tparam) < 0)
        TEST_ERROR;

    /* Re-open the array */
    if (NULL == (ea = H5EA_open(f, ea_addr, NULL)))
        FAIL_STACK_ERROR;

    /* Verify the creation parameters */
    if (verify_cparam(ea, cparam) < 0)
        TEST_ERROR;

    /* Close array, delete array, close file & verify file is empty */
    if (finish(file, fapl, f, ea, ea_addr) < 0)
        TEST_ERROR;

    /* All tests passed */
    PASSED();

    return 0;

error:
    H5E_BEGIN_TRY
    {
        if (ea)
            H5EA_close(ea);
        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, H5EA_create_t *cparam, earray_test_param_t *tparam)
{
    hid_t   file    = H5I_INVALID_HID; /* File ID */
    hid_t   file2   = H5I_INVALID_HID; /* File ID */
    H5F_t  *f       = NULL;            /* Internal file object pointer */
    H5F_t  *f2      = NULL;            /* Internal file object pointer */
    H5EA_t *ea      = NULL;            /* Extensible array wrapper */
    H5EA_t *ea2     = NULL;            /* Extensible array wrapper */
    haddr_t ea_addr = HADDR_UNDEF;     /* Array address in file */

    /* Create file & retrieve pointer to internal file object */
    if (create_file(H5F_ACC_TRUNC, fapl, &file, &f) < 0)
        TEST_ERROR;

    /*
     * Display testing message
     */
    TESTING("open extensible array twice");

    /* Create array */
    if (create_array(f, cparam, &ea, &ea_addr, NULL) < 0)
        TEST_ERROR;

    /* Open the array again, through the first file handle */
    if (NULL == (ea2 = H5EA_open(f, ea_addr, NULL)))
        FAIL_STACK_ERROR;

    /* Verify the creation parameters */
    if (verify_cparam(ea, cparam) < 0)
        TEST_ERROR;
    if (verify_cparam(ea2, cparam) < 0)
        TEST_ERROR;

    /* Close the second extensible array wrapper */
    if (H5EA_close(ea2) < 0)
        FAIL_STACK_ERROR;
    ea2 = NULL;

    /* Check for closing & re-opening the file */
    if (reopen_file(&file, &f, fapl, &ea, ea_addr, 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 *)H5VL_object(file2)))
        FAIL_STACK_ERROR;

    /* Open the extensible array through the second file handle */
    if (NULL == (ea2 = H5EA_open(f2, ea_addr, NULL)))
        FAIL_STACK_ERROR;

    /* Verify the creation parameters */
    if (verify_cparam(ea, cparam) < 0)
        TEST_ERROR;

    /* Close the first extensible array wrapper */
    if (H5EA_close(ea) < 0)
        FAIL_STACK_ERROR;
    ea = 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, ea2, ea_addr) < 0)
        TEST_ERROR;

    /* All tests passed */
    PASSED();

    return 0;

error:
    H5E_BEGIN_TRY
    {
        if (ea)
            H5EA_close(ea);
        if (ea2)
            H5EA_close(ea2);
        H5Fclose(file);
        H5Fclose(file2);
    }
    H5E_END_TRY

    return 1;
} /* test_open_twice() */

/*-------------------------------------------------------------------------
 * Function:    test_open_twice_diff
 *
 * Purpose:    Open an extensible array twice, through different "top" file
 *              handles, with an intermediate file open that takes the "shared"
 *              file handle from the first extensible array's file pointer.
 *
 * Return:    Success:    0
 *        Failure:    1
 *
 *-------------------------------------------------------------------------
 */
static unsigned
test_open_twice_diff(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t *tparam)
{
    char    filename_tmp[EARRAY_FILENAME_LEN]; /* Temporary file name */
    hid_t   file    = H5I_INVALID_HID;         /* File ID */
    hid_t   file2   = H5I_INVALID_HID;         /* File ID */
    hid_t   file0   = H5I_INVALID_HID;         /* File ID */
    hid_t   file00  = H5I_INVALID_HID;         /* File ID */
    H5F_t  *f       = NULL;                    /* Internal file object pointer */
    H5F_t  *f2      = NULL;                    /* Internal file object pointer */
    H5EA_t *ea      = NULL;                    /* Extensible array wrapper */
    H5EA_t *ea2     = NULL;                    /* Extensible array wrapper */
    haddr_t ea_addr = HADDR_UNDEF;             /* Array address in file */

    /* Create file & retrieve pointer to internal file object */
    if (create_file(H5F_ACC_TRUNC, fapl, &file, &f) < 0)
        TEST_ERROR;

    /*
     * Display testing message
     */
    TESTING("open extensible array twice, through different file handles");

    /* Create array */
    if (create_array(f, cparam, &ea, &ea_addr, NULL) < 0)
        TEST_ERROR;

    /* Open the array again, through the first file handle */
    if (NULL == (ea2 = H5EA_open(f, ea_addr, NULL)))
        FAIL_STACK_ERROR;

    /* Verify the creation parameters */
    if (verify_cparam(ea, cparam) < 0)
        TEST_ERROR;
    if (verify_cparam(ea2, cparam) < 0)
        TEST_ERROR;

    /* Close the second extensible array wrapper */
    if (H5EA_close(ea2) < 0)
        FAIL_STACK_ERROR;
    ea2 = NULL;

    /* Re-open the file */
    /* (So that there is something holding the file open when the extensible
     *  array is closed)
     */
    if ((file0 = H5Fopen(filename_g, H5F_ACC_RDWR, fapl)) < 0)
        FAIL_STACK_ERROR;

    /* Check for closing & re-opening the file */
    if (reopen_file(&file, &f, fapl, &ea, ea_addr, tparam) < 0)
        TEST_ERROR;

    /* Verify the creation parameters */
    if (verify_cparam(ea, cparam) < 0)
        TEST_ERROR;

    /* Close the first extensible array wrapper */
    if (H5EA_close(ea) < 0)
        FAIL_STACK_ERROR;
    ea = 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;
    file = -1;

    /* Open a different file */
    /* (This re-allocates the 'top' file pointer and assigns it a different
     *  'shared' file pointer, making the file pointer in the extensible array's
     *  header stale)
     */
    h5_fixname(FILENAME[1], fapl, filename_tmp, sizeof(filename_tmp));
    if ((file00 = H5Fcreate(filename_tmp, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
        FAIL_STACK_ERROR;

    /* Re-open the file with the extensible array */
    if ((file2 = H5Fopen(filename_g, H5F_ACC_RDWR, fapl)) < 0)
        FAIL_STACK_ERROR;

    /* Get a pointer to the internal file object */
    if (NULL == (f2 = (H5F_t *)H5VL_object(file2)))
        FAIL_STACK_ERROR;

    /* Open the extensible array through the second file handle */
    if (NULL == (ea2 = H5EA_open(f2, ea_addr, NULL)))
        FAIL_STACK_ERROR;

    /* Verify the creation parameters */
    if (verify_cparam(ea2, cparam) < 0)
        TEST_ERROR;

    /* Close the extra file handles */
    if (H5Fclose(file0) < 0)
        FAIL_STACK_ERROR;
    if (H5Fclose(file00) < 0)
        FAIL_STACK_ERROR;

    /* Close array, delete array, close file & verify file is empty */
    if (finish(file2, fapl, f2, ea2, ea_addr) < 0)
        TEST_ERROR;

    /* All tests passed */
    PASSED();

    return 0;

error:
    H5E_BEGIN_TRY
    {
        if (ea)
            H5EA_close(ea);
        if (ea2)
            H5EA_close(ea2);
        H5Fclose(file);
        H5Fclose(file2);
        H5Fclose(file0);
        H5Fclose(file00);
    }
    H5E_END_TRY

    return 1;
} /* test_open_twice_diff() */

/*-------------------------------------------------------------------------
 * Function:    test_delete_open
 *
 * Purpose:    Delete opened extensible array (& open deleted array)
 *
 * Return:    Success:    0
 *        Failure:    1
 *
 *-------------------------------------------------------------------------
 */
static unsigned
test_delete_open(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t *tparam)
{
    hid_t          file    = H5I_INVALID_HID; /* File ID */
    H5F_t         *f       = NULL;            /* Internal file object pointer */
    H5EA_t        *ea      = NULL;            /* Extensible array wrapper */
    H5EA_t        *ea2     = NULL;            /* Extensible array wrapper */
    haddr_t        ea_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(H5F_ACC_TRUNC, fapl, &file, &f) < 0)
        TEST_ERROR;

    /*
     * Display testing message
     */
    TESTING("deleting open extensible array");

    /* Create array */
    if (create_array(f, cparam, &ea, &ea_addr, NULL) < 0)
        TEST_ERROR;

    /* Open the array again */
    if (NULL == (ea2 = H5EA_open(f, ea_addr, NULL)))
        FAIL_STACK_ERROR;

    /* Request that the array be deleted */
    if (H5EA_delete(f, ea_addr, NULL) < 0)
        FAIL_STACK_ERROR;

    /* Verify the creation parameters */
    if (verify_cparam(ea, cparam) < 0)
        TEST_ERROR;
    if (verify_cparam(ea2, cparam) < 0)
        TEST_ERROR;

    /* Close the second extensible array wrapper */
    if (H5EA_close(ea2) < 0)
        FAIL_STACK_ERROR;
    ea2 = NULL;

    /* Try re-opening the array again (should fail, as array will be deleted) */
    H5E_BEGIN_TRY
    {
        ea2 = H5EA_open(f, ea_addr, NULL);
    }
    H5E_END_TRY
    if (ea2) {
        /* Close opened array */
        H5EA_close(ea2);

        /* Indicate error */
        TEST_ERROR;
    } /* end if */

    /* Close the first extensible array wrapper */
    if (H5EA_close(ea) < 0)
        FAIL_STACK_ERROR;
    ea = NULL;

    /* Check for closing & re-opening the file */
    if (reopen_file(&file, &f, fapl, NULL, HADDR_UNDEF, tparam) < 0)
        TEST_ERROR;

    /* Try re-opening the array again (should fail, as array is now deleted) */
    H5E_BEGIN_TRY
    {
        ea = H5EA_open(f, ea_addr, NULL);
    }
    H5E_END_TRY
    if (ea) {
        /* Close opened array */
        H5EA_close(ea);

        /* 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 (ea)
            H5EA_close(ea);
        if (ea2)
            H5EA_close(ea2);
        H5Fclose(file);
    }
    H5E_END_TRY

    return 1;
} /* test_delete_open() */

/* Extensible array iterator info for forward iteration */
typedef struct eiter_fw_t {
    hsize_t  idx;           /* Index of next array location */
    unsigned base_sblk_idx; /* Starting index for actual superblocks */
} eiter_fw_t;

/*-------------------------------------------------------------------------
 * Function:    eiter_fw_init
 *
 * Purpose:    Initialize element iterator (forward iteration)
 *
 * Return:    Success:    Pointer to iteration status object
 *        Failure:    NULL
 *
 *-------------------------------------------------------------------------
 */
static void *
eiter_fw_init(const H5EA_create_t H5_ATTR_UNUSED *cparam, const earray_test_param_t H5_ATTR_UNUSED *tparam,
              hsize_t H5_ATTR_UNUSED cnt)
{
    eiter_fw_t *eiter; /* Forward element iteration object */

    /* Allocate space for the element iteration object */
    eiter = (eiter_fw_t *)malloc(sizeof(eiter_fw_t));
    assert(eiter);

    /* Initialize the element iteration object */
    eiter->idx           = 0;
    eiter->base_sblk_idx = UINT_MAX;

    /* Return iteration object */
    return (eiter);
} /* end eiter_fw_init() */

/*-------------------------------------------------------------------------
 * Function:    eiter_fw_next
 *
 * Purpose:    Get next element index (forward iteration)
 *
 * Return:    Success:    Non-negative
 *        Failure:    Negative
 *
 *-------------------------------------------------------------------------
 */
static hssize_t
eiter_fw_next(void *in_eiter)
{
    eiter_fw_t *eiter = (eiter_fw_t *)in_eiter;
    hssize_t    ret_val;

    /* Sanity check */
    assert(eiter);

    /* Get the next array index to test */
    ret_val = (hssize_t)eiter->idx++;

    return (ret_val);
} /* end eiter_fw_next() */

/*-------------------------------------------------------------------------
 * Function:    eiter_fw_max
 *
 * Purpose:    Get max. element index (forward iteration)
 *
 * Return:    Success:    Non-negative
 *        Failure:    Negative
 *
 *-------------------------------------------------------------------------
 */
static H5_ATTR_PURE hssize_t
eiter_fw_max(const void *in_eiter)
{
    const eiter_fw_t *eiter = (const eiter_fw_t *)in_eiter;

    /* Sanity check */
    assert(eiter);

    /* Return the max. array index used */
    return ((hssize_t)(eiter->idx - 1));
} /* end eiter_fw_max() */

/*-------------------------------------------------------------------------
 * Function:    eiter_fw_state
 *
 * Purpose:    Get extensible array state (forward iteration)
 *
 * Return:    Success:    Non-negative
 *        Failure:    Negative
 *
 *-------------------------------------------------------------------------
 */
static int
eiter_fw_state(void *in_eiter, const H5EA_create_t *cparam, const earray_test_param_t *tparam,
               earray_state_t *state, hsize_t idx)
{
    eiter_fw_t *eiter = (eiter_fw_t *)in_eiter;

    /* Sanity check */
    assert(eiter);
    assert(cparam);
    assert(tparam);
    assert(state);

    /* Compute the state of the extensible array */
    state->hdr_size       = EA_HDR_SIZE;
    state->nindex_blks    = 1;
    state->index_blk_size = EA_IBLOCK_SIZE;
    state->max_idx_set    = idx + 1;
    if (idx < cparam->idx_blk_elmts) {
        state->nelmts      = (hsize_t)cparam->idx_blk_elmts;
        state->nsuper_blks = state->ndata_blks = (hsize_t)0;
        state->super_blk_size = state->data_blk_size = (hsize_t)0;
    } /* end if */
    else {
        unsigned sblk_idx; /* Which superblock does this index fall in? */

        /* Compute super block index for element index */
        /* (same eqn. as in H5EA__dblock_sblk_idx()) */
        sblk_idx =
            H5VM_log2_gen((uint64_t)(((idx - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
        state->nelmts     = EA_NELMTS(cparam, tparam, idx, sblk_idx);
        state->ndata_blks = EA_NDATA_BLKS(cparam, tparam, idx, sblk_idx);

        /* Check if we have any super blocks yet */
        if (tparam->sblk_info[sblk_idx].ndblks >= cparam->sup_blk_min_data_ptrs) {
            /* Check if this is the first superblock */
            if (sblk_idx < eiter->base_sblk_idx)
                eiter->base_sblk_idx = sblk_idx;

            state->nsuper_blks = (sblk_idx - eiter->base_sblk_idx) + 1;
        } /* end if */
        else
            state->nsuper_blks = 0;
    } /* end else */

    return (0);
} /* end eiter_fw_state() */

/*-------------------------------------------------------------------------
 * Function:    eiter_fw_term
 *
 * Purpose:    Shut down element iterator (forward iteration)
 *
 * Return:    Success:    0
 *        Failure:    -1
 *
 *-------------------------------------------------------------------------
 */
static int
eiter_fw_term(void *eiter)
{
    /* Sanity check */
    assert(eiter);

    /* Free iteration object */
    free(eiter);

    return (0);
} /* end eiter_fw_term() */

/* Extensible array iterator class for forward iteration */
static const earray_iter_t ea_iter_fw = {
    eiter_fw_init,  /* Iterator init */
    eiter_fw_next,  /* Next array index */
    eiter_fw_max,   /* Max. array index */
    eiter_fw_state, /* State of the extensible array */
    eiter_fw_term   /* Iterator term */
};

/* Extensible array iterator info for reverse iteration */
typedef struct eiter_rv_t {
    hsize_t idx;            /* Index of next array location */
    hsize_t max;            /* Index of max. array location */
    hsize_t max_sblk_idx;   /* Which superblock does the max. array location fall in? */
    hsize_t max_nelmts;     /* Max. # of elements for array */
    hsize_t max_ndata_blks; /* Max. # of data blocks for array */
    hsize_t idx_blk_nsblks; /* Number of superblocks directly pointed to in the index block */
} eiter_rv_t;

/*-------------------------------------------------------------------------
 * Function:    eiter_rv_init
 *
 * Purpose:    Initialize element iterator (reverse iteration)
 *
 * Return:    Success:    Pointer to iteration status object
 *        Failure:    NULL
 *
 *-------------------------------------------------------------------------
 */
static void *
eiter_rv_init(const H5EA_create_t *cparam, const earray_test_param_t *tparam, hsize_t cnt)
{
    eiter_rv_t *eiter; /* Reverse element iteration object */

    /* Allocate space for the element iteration object */
    eiter = (eiter_rv_t *)malloc(sizeof(eiter_rv_t));
    assert(eiter);

    /* Initialize reverse iteration info */
    eiter->idx = cnt - 1;
    eiter->max = cnt - 1;
    if (cnt > cparam->idx_blk_elmts) {
        eiter->max_sblk_idx = H5VM_log2_gen(
            (uint64_t)(((eiter->max - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
        eiter->max_nelmts     = EA_NELMTS(cparam, tparam, eiter->max, eiter->max_sblk_idx);
        eiter->max_ndata_blks = EA_NDATA_BLKS(cparam, tparam, eiter->max, eiter->max_sblk_idx);
        eiter->idx_blk_nsblks = 2 * H5VM_log2_of2((uint32_t)cparam->sup_blk_min_data_ptrs);
    } /* end if */
    else {
        eiter->max_sblk_idx   = (hsize_t)0;
        eiter->max_nelmts     = (hsize_t)0;
        eiter->max_ndata_blks = (hsize_t)0;
        eiter->idx_blk_nsblks = (hsize_t)0;
    } /* end else */

    /* Return iteration object */
    return (eiter);
} /* end eiter_rv_init() */

/*-------------------------------------------------------------------------
 * Function:    eiter_rv_next
 *
 * Purpose:    Get next element index (reverse iteration)
 *
 * Return:    Success:    Non-negative
 *        Failure:    Negative
 *
 *-------------------------------------------------------------------------
 */
static hssize_t
eiter_rv_next(void *in_eiter)
{
    eiter_rv_t *eiter = (eiter_rv_t *)in_eiter;
    hssize_t    ret_val;

    /* Sanity check */
    assert(eiter);

    /* Get the next array index to test */
    ret_val = (hssize_t)eiter->idx--;

    return (ret_val);
} /* end eiter_rv_next() */

/*-------------------------------------------------------------------------
 * Function:    eiter_rv_max
 *
 * Purpose:    Get max. element index (reverse iteration)
 *
 * Return:    Success:    Non-negative
 *        Failure:    Negative
 *
 *-------------------------------------------------------------------------
 */
static H5_ATTR_PURE hssize_t
eiter_rv_max(const void *in_eiter)
{
    const eiter_rv_t *eiter = (const eiter_rv_t *)in_eiter;

    /* Sanity check */
    assert(eiter);

    /* Return the max. array index used */
    return ((hssize_t)eiter->max);
} /* end eiter_rv_max() */

/*-------------------------------------------------------------------------
 * Function:    eiter_rv_state
 *
 * Purpose:    Get extensible array state (reverse iteration)
 *
 * Return:    Success:    Non-negative
 *        Failure:    Negative
 *
 *-------------------------------------------------------------------------
 */
static int
eiter_rv_state(void *in_eiter, const H5EA_create_t *cparam, const earray_test_param_t *tparam,
               earray_state_t *state, hsize_t idx)
{
    eiter_rv_t *eiter = (eiter_rv_t *)in_eiter;

    /* Sanity check */
    assert(eiter);
    assert(cparam);
    assert(tparam);
    assert(state);

    /* Compute the state of the extensible array */
    state->hdr_size       = EA_HDR_SIZE;
    state->nindex_blks    = 1;
    state->index_blk_size = EA_IBLOCK_SIZE;
    state->max_idx_set    = eiter->max + 1;
    if (eiter->max < cparam->idx_blk_elmts) {
        state->nelmts      = (hsize_t)cparam->idx_blk_elmts;
        state->nsuper_blks = state->ndata_blks = (hsize_t)0;
    } /* end if */
    else {
        hsize_t  idx_nelmts;       /* # of elements for array index */
        hsize_t  idx_ndata_blks;   /* # of data blocks for array index */
        hsize_t  loc_idx = 0;      /* Local index, for computing an offset in next lower data block */
        unsigned idx_sblk_idx;     /* Which superblock does this index fall in? */
        unsigned loc_sblk_idx = 0; /* Which superblock does the local index fall in? */

        /* Compute super block index for element index */
        /* (same eqn. as in H5EA__dblock_sblk_idx()) */
        if (idx < cparam->idx_blk_elmts + cparam->data_blk_min_elmts)
            idx_sblk_idx = 0;
        else {
            hsize_t tmp_idx;  /* Temporary index in superblock */
            hsize_t dblk_idx; /* Index of data block within superblock */

            idx_sblk_idx =
                H5VM_log2_gen((uint64_t)(((idx - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
            tmp_idx  = idx - (cparam->idx_blk_elmts + tparam->sblk_info[idx_sblk_idx].start_idx);
            dblk_idx = tmp_idx / tparam->sblk_info[idx_sblk_idx].dblk_nelmts;
            if (dblk_idx > 0)
                loc_idx = idx - tparam->sblk_info[idx_sblk_idx].dblk_nelmts;
            else
                loc_idx = cparam->idx_blk_elmts + tparam->sblk_info[idx_sblk_idx].start_idx - 1;
            loc_sblk_idx = H5VM_log2_gen(
                (uint64_t)(((loc_idx - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
        } /* end else */

        if (idx < cparam->idx_blk_elmts + cparam->data_blk_min_elmts)
            idx_nelmts = (hsize_t)cparam->idx_blk_elmts;
        else
            idx_nelmts = EA_NELMTS(cparam, tparam, loc_idx, loc_sblk_idx);
        state->nelmts = (eiter->max_nelmts - idx_nelmts) + cparam->idx_blk_elmts;

        if (idx < cparam->idx_blk_elmts + cparam->data_blk_min_elmts)
            idx_ndata_blks = 0;
        else
            idx_ndata_blks = EA_NDATA_BLKS(cparam, tparam, loc_idx, loc_sblk_idx);
        state->ndata_blks = eiter->max_ndata_blks - idx_ndata_blks;

        /* Check if we have any super blocks yet */
        if (tparam->sblk_info[eiter->max_sblk_idx].ndblks >= cparam->sup_blk_min_data_ptrs) {
            if (idx_sblk_idx > eiter->idx_blk_nsblks)
                state->nsuper_blks = (eiter->max_sblk_idx - idx_sblk_idx) + 1;
            else
                state->nsuper_blks = (eiter->max_sblk_idx - eiter->idx_blk_nsblks) + 1;
        } /* end if */
    }     /* end else */

    return (0);
} /* end eiter_rv_state() */

/*-------------------------------------------------------------------------
 * Function:    eiter_rv_term
 *
 * Purpose:    Shut down element iterator (reverse iteration)
 *
 * Return:    Success:    0
 *        Failure:    -1
 *
 *-------------------------------------------------------------------------
 */
static int
eiter_rv_term(void *eiter)
{
    /* Sanity check */
    assert(eiter);

    /* Free iteration object */
    free(eiter);

    return (0);
} /* end eiter_rv_term() */

/* Extensible array iterator class for reverse iteration */
static const earray_iter_t ea_iter_rv = {
    eiter_rv_init,  /* Iterator init */
    eiter_rv_next,  /* Next array index */
    eiter_rv_max,   /* Max. array index written */
    eiter_rv_state, /* State of the extensible array */
    eiter_rv_term   /* Iterator term */
};

/* Extensible array iterator info for random iteration */
typedef struct eiter_rnd_t {
    hsize_t  max; /* Max. array index used */
    hsize_t  pos; /* Position in shuffled array */
    hsize_t *idx; /* Array of shuffled indices */
} eiter_rnd_t;

/*-------------------------------------------------------------------------
 * Function:    eiter_rnd_init
 *
 * Purpose:    Initialize element iterator (random iteration)
 *
 * Return:    Success:    Pointer to iteration status object
 *        Failure:    NULL
 *
 *-------------------------------------------------------------------------
 */
static void *
eiter_rnd_init(const H5EA_create_t H5_ATTR_UNUSED *cparam, const earray_test_param_t H5_ATTR_UNUSED *tparam,
               hsize_t cnt)
{
    eiter_rnd_t *eiter; /* Random element iteration object */
    size_t       u;     /* Local index variable */

    /* Allocate space for the element iteration object */
    eiter = (eiter_rnd_t *)malloc(sizeof(eiter_rnd_t));
    assert(eiter);

    /* Allocate space for the array of shuffled indices */
    eiter->idx = (hsize_t *)malloc(sizeof(hsize_t) * (size_t)cnt);
    assert(eiter->idx);

    /* Initialize reverse iteration info */
    eiter->max = 0;
    eiter->pos = 0;
    for (u = 0; u < (size_t)cnt; u++)
        eiter->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             = eiter->idx[u];
            eiter->idx[u]        = eiter->idx[swap_idx];
            eiter->idx[swap_idx] = temp_idx;
        } /* end for */
    }     /* end if */

    /* Return iteration object */
    return (eiter);
} /* end eiter_rnd_init() */

/*-------------------------------------------------------------------------
 * Function:    eiter_rnd_next
 *
 * Purpose:    Get next element index (random iteration)
 *
 * Return:    Success:    Non-negative
 *        Failure:    Negative
 *
 *-------------------------------------------------------------------------
 */
static hssize_t
eiter_rnd_next(void *in_eiter)
{
    eiter_rnd_t *eiter = (eiter_rnd_t *)in_eiter;
    hssize_t     ret_val;

    /* Sanity check */
    assert(eiter);

    /* Get the next array index to test */
    ret_val = (hssize_t)eiter->idx[eiter->pos];
    eiter->pos++;

    /* Check for new max. value */
    if ((hsize_t)ret_val > eiter->max)
        eiter->max = (hsize_t)ret_val;

    return (ret_val);
} /* end eiter_rnd_next() */

/*-------------------------------------------------------------------------
 * Function:    eiter_rnd_max
 *
 * Purpose:    Get max. element index (random iteration)
 *
 * Return:    Success:    Non-negative
 *        Failure:    Negative
 *
 *-------------------------------------------------------------------------
 */
static H5_ATTR_PURE hssize_t
eiter_rnd_max(const void *in_eiter)
{
    const eiter_rnd_t *eiter = (const eiter_rnd_t *)in_eiter;

    /* Sanity check */
    assert(eiter);

    /* Return the max. array index used */
    return ((hssize_t)eiter->max);
} /* end eiter_rnd_max() */

/*-------------------------------------------------------------------------
 * Function:    eiter_rnd_term
 *
 * Purpose:    Shut down element iterator (random iteration)
 *
 * Return:    Success:    0
 *        Failure:    -1
 *
 *-------------------------------------------------------------------------
 */
static int
eiter_rnd_term(void *in_eiter)
{
    eiter_rnd_t *eiter = (eiter_rnd_t *)in_eiter;

    /* Sanity check */
    assert(eiter);
    assert(eiter->idx);

    /* Free shuffled index array */
    free(eiter->idx);

    /* Free iteration object */
    free(eiter);

    return (0);
} /* end eiter_rnd_term() */

/* Extensible array iterator class for random iteration */
static const earray_iter_t ea_iter_rnd = {
    eiter_rnd_init, /* Iterator init */
    eiter_rnd_next, /* Next array index */
    eiter_rnd_max,  /* Max. array index written */
    NULL,           /* State of the extensible array */
    eiter_rnd_term  /* Iterator term */
};

/*-------------------------------------------------------------------------
 * Function:    eiter_rnd2_init
 *
 * Purpose:    Initialize element iterator (random #2 iteration)
 *
 * Return:    Success:    Pointer to iteration status object
 *        Failure:    NULL
 *
 *-------------------------------------------------------------------------
 */
static void *
eiter_rnd2_init(const H5EA_create_t H5_ATTR_UNUSED *cparam, const earray_test_param_t H5_ATTR_UNUSED *tparam,
                hsize_t cnt)
{
    eiter_rnd_t *eiter; /* Random element iteration object */
    size_t       u;     /* Local index variable */

    /* Allocate space for the element iteration object */
    eiter = (eiter_rnd_t *)malloc(sizeof(eiter_rnd_t));
    assert(eiter);

    /* Allocate space for the array of shuffled indices */
    eiter->idx = (hsize_t *)malloc(sizeof(hsize_t) * (size_t)cnt);
    assert(eiter->idx);

    /* Initialize reverse iteration info */
    eiter->max = 0;
    eiter->pos = 0;

    /* Randomly shuffle array indices */
    if (cnt > 1) {
        hsize_t *tmp_idx;                                     /* Temporary index array */
        hsize_t  sparse_cnt = (hsize_t)(cnt * EA_RND2_SCALE); /* Sparse range to choose from */

        /* Allocate temporary index array */
        tmp_idx = (hsize_t *)malloc(sizeof(hsize_t) * (size_t)sparse_cnt);
        assert(tmp_idx);

        /* Initialize temporary index array, for shuffling */
        for (u = 0; u < (size_t)sparse_cnt; u++)
            tmp_idx[u] = (hsize_t)u;

        /* Shuffle index elements & store in final array */
        for (u = 0; u < (size_t)cnt; u++) {
            size_t swap_idx; /* Location to swap with when shuffling */

            swap_idx          = ((size_t)HDrandom() % ((size_t)sparse_cnt - u)) + u;
            eiter->idx[u]     = tmp_idx[swap_idx];
            tmp_idx[swap_idx] = tmp_idx[u];
        } /* end for */

        /* Release temporary array */
        free(tmp_idx);
    } /* end if */
    else {
        for (u = 0; u < (size_t)cnt; u++)
            eiter->idx[u] = (hsize_t)u;
    } /* end else */

    /* Return iteration object */
    return (eiter);
} /* end eiter_rnd2_init() */

/* Extensible array iterator class for random iteration */
static const earray_iter_t ea_iter_rnd2 = {
    eiter_rnd2_init, /* Iterator init */
    eiter_rnd_next,  /* Next array index */
    eiter_rnd_max,   /* Max. array index written */
    NULL,            /* State of the extensible array */
    eiter_rnd_term   /* Iterator term */
};

/* Extensible array iterator info for cyclic iteration */
typedef struct eiter_cyc_t {
    hsize_t max; /* Max. array index used */
    hsize_t pos; /* Position in shuffled array */
    hsize_t cnt; /* # of elements to store */
    hsize_t cyc; /* Cycle of elements to choose from */
} eiter_cyc_t;

/*-------------------------------------------------------------------------
 * Function:    eiter_cyc_init
 *
 * Purpose:    Initialize element iterator (cyclic iteration)
 *
 * Return:    Success:    Pointer to iteration status object
 *        Failure:    NULL
 *
 *-------------------------------------------------------------------------
 */
static void *
eiter_cyc_init(const H5EA_create_t H5_ATTR_UNUSED *cparam, const earray_test_param_t H5_ATTR_UNUSED *tparam,
               hsize_t cnt)
{
    eiter_cyc_t *eiter; /* Cyclic element iteration object */

    /* Allocate space for the element iteration object */
    eiter = (eiter_cyc_t *)malloc(sizeof(eiter_cyc_t));
    assert(eiter);

    /* Initialize reverse iteration info */
    eiter->max = 0;
    eiter->pos = 0;
    eiter->cnt = cnt;
    eiter->cyc = 0;

    /* Return iteration object */
    return (eiter);
} /* end eiter_cyc_init() */

/*-------------------------------------------------------------------------
 * Function:    eiter_cyc_next
 *
 * Purpose:    Get next element index (cyclic iteration)
 *
 * Return:    Success:    Non-negative
 *        Failure:    Negative
 *
 *-------------------------------------------------------------------------
 */
static hssize_t
eiter_cyc_next(void *in_eiter)
{
    eiter_cyc_t *eiter = (eiter_cyc_t *)in_eiter;
    hssize_t     ret_val;

    /* Sanity check */
    assert(eiter);

    /* Get the next array index to test */
    ret_val = (hssize_t)eiter->pos;
    eiter->pos += EA_CYC_COUNT;
    if (eiter->pos >= eiter->cnt)
        eiter->pos = ++eiter->cyc;

    /* Check for new max. value */
    if ((hsize_t)ret_val > eiter->max)
        eiter->max = (hsize_t)ret_val;

    return (ret_val);
} /* end eiter_cyc_next() */

/*-------------------------------------------------------------------------
 * Function:    eiter_cyc_max
 *
 * Purpose:    Get max. element index (cyclic iteration)
 *
 * Return:    Success:    Non-negative
 *        Failure:    Negative
 *
 *-------------------------------------------------------------------------
 */
static H5_ATTR_PURE hssize_t
eiter_cyc_max(const void *in_eiter)
{
    const eiter_cyc_t *eiter = (const eiter_cyc_t *)in_eiter;

    /* Sanity check */
    assert(eiter);

    /* Return the max. array index used */
    return ((hssize_t)eiter->max);
} /* end eiter_cyc_max() */

/*-------------------------------------------------------------------------
 * Function:    eiter_cyc_term
 *
 * Purpose:    Shut down element iterator (cyclic iteration)
 *
 * Return:    Success:    0
 *        Failure:    -1
 *
 *-------------------------------------------------------------------------
 */
static int
eiter_cyc_term(void *in_eiter)
{
    eiter_cyc_t *eiter = (eiter_cyc_t *)in_eiter;

    /* Sanity check */
    assert(eiter);

    /* Free iteration object */
    free(eiter);

    return (0);
} /* end eiter_cyc_term() */

/* Extensible array iterator class for cyclic iteration */
static const earray_iter_t ea_iter_cyc = {
    eiter_cyc_init, /* Iterator init */
    eiter_cyc_next, /* Next array index */
    eiter_cyc_max,  /* Max. array index written */
    NULL,           /* State of the extensible array */
    eiter_cyc_term  /* Iterator term */
};

/*-------------------------------------------------------------------------
 * Function:    test_set_elmts
 *
 * Purpose:    Set all elements from 0 through 'nelmts' in extensible array
 *
 * Return:    Success:    0
 *        Failure:    1
 *
 *-------------------------------------------------------------------------
 */
static unsigned
test_set_elmts(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t *tparam, hsize_t nelmts,
               const char *test_str)
{
    hid_t          file = H5I_INVALID_HID; /* File ID */
    H5F_t         *f    = NULL;            /* Internal file object pointer */
    H5EA_t        *ea   = NULL;            /* Extensible array wrapper */
    void          *eiter_info;             /* Extensible array iterator info */
    earray_state_t state;                  /* State of extensible array */
    uint64_t       welmt;                  /* Element to write */
    uint64_t       relmt;                  /* Element to read */
    hsize_t        nelmts_written;         /* Highest element written in array */
    hsize_t        cnt;                    /* Count of array indices */
    hssize_t       smax;                   /* Index value of max. element set */
    hsize_t        max;                    /* Index value of max. element set */
    hssize_t       sidx;                   /* Index value of first element of first data block */
    hsize_t        idx;                    /* Index value of first element of first data block */
    haddr_t        ea_addr = HADDR_UNDEF;  /* Array address in file */

    /*
     * Display testing message
     */
    TESTING(test_str);

    /* Create file & retrieve pointer to internal file object */
    if (create_file(H5F_ACC_TRUNC, fapl, &file, &f) < 0)
        TEST_ERROR;

    /* Create array */
    if (create_array(f, cparam, &ea, &ea_addr, NULL) < 0)
        TEST_ERROR;

    /* Verify the creation parameters */
    if (verify_cparam(ea, cparam) < 0)
        TEST_ERROR;

    /* Check for closing & re-opening the file */
    if (reopen_file(&file, &f, fapl, &ea, ea_addr, tparam) < 0)
        TEST_ERROR;

    /* Verify high-water # of elements written */
    nelmts_written = (hsize_t)ULLONG_MAX;
    if (H5EA_get_nelmts(ea, &nelmts_written) < 0)
        FAIL_STACK_ERROR;
    if (nelmts_written != 0)
        TEST_ERROR;

    /* Verify array state */
    memset(&state, 0, sizeof(state));
    state.hdr_size = EA_HDR_SIZE;
    if (check_stats(ea, &state))
        TEST_ERROR;

    /* Get all elements from empty array */

    /* Initialize iterator */
    if (NULL == (eiter_info = tparam->eiter->init(cparam, tparam, nelmts)))
        TEST_ERROR;

    /* Get elements of array */
    for (cnt = 0; cnt < nelmts; cnt++) {
        /* Get the array index */
        if ((sidx = tparam->eiter->next(eiter_info)) < 0)
            TEST_ERROR;
        idx = (hsize_t)sidx;

        /* Retrieve element of array (not set yet) */
        relmt = (uint64_t)0;
        if (H5EA_get(ea, idx, &relmt) < 0)
            FAIL_STACK_ERROR;

        /* Verify element is fill value for array */
        if (relmt != H5EA_TEST_FILL)
            TEST_ERROR;
    } /* end for */

    /* Shutdown iterator */
    if (tparam->eiter->term(eiter_info) < 0)
        TEST_ERROR;

    /* Set (& get) all elements from empty array */

    /* Initialize iterator */
    if (NULL == (eiter_info = tparam->eiter->init(cparam, tparam, nelmts)))
        TEST_ERROR;

    /* Set elements of array */
    for (cnt = 0; cnt < nelmts; cnt++) {
        /* Get the array index */
        if ((sidx = tparam->eiter->next(eiter_info)) < 0)
            TEST_ERROR;
        idx = (hsize_t)sidx;

        /* Retrieve element of array (not set yet) */
        relmt = (uint64_t)0;
        if (H5EA_get(ea, idx, &relmt) < 0)
            FAIL_STACK_ERROR;

        /* Verify element is fill value for array */
        if (relmt != H5EA_TEST_FILL)
            TEST_ERROR;

        /* Set element of array */
        welmt = (uint64_t)7 + idx;
        if (H5EA_set(ea, idx, &welmt) < 0)
            FAIL_STACK_ERROR;

        /* Get the max. array index */
        if ((smax = tparam->eiter->max_elem(eiter_info)) < 0)
            TEST_ERROR;
        max = (hsize_t)smax;

        /* Verify high-water # of elements written */
        nelmts_written = (hsize_t)ULLONG_MAX;
        if (H5EA_get_nelmts(ea, &nelmts_written) < 0)
            FAIL_STACK_ERROR;
        if (nelmts_written != (max + 1))
            TEST_ERROR;

        /* Check if array state is available */
        if (tparam->eiter->state) {
            /* Get the extensible array state */
            if (tparam->eiter->state(eiter_info, cparam, tparam, &state, idx) < 0)
                TEST_ERROR;

            /* Verify array state */
            if (check_stats(ea, &state))
                TEST_ERROR;
        } /* end if */

        /* Retrieve element of array (set now) */
        relmt = (uint64_t)0;
        if (H5EA_get(ea, idx, &relmt) < 0)
            FAIL_STACK_ERROR;

        /* Verify element is value written */
        if (relmt != welmt)
            TEST_ERROR;
    } /* end for */

    /* Shutdown iterator */
    if (tparam->eiter->term(eiter_info) < 0)
        TEST_ERROR;

    /* Close array, delete array, close file & verify file is empty */
    if (finish(file, fapl, f, ea, ea_addr) < 0)
        TEST_ERROR;

    /* All tests passed */
    PASSED();

    return 0;

error:
    H5E_BEGIN_TRY
    {
        if (ea)
            H5EA_close(ea);
        H5Fclose(file);
    }
    H5E_END_TRY

    return 1;
} /* test_set_elmts() */

/*-------------------------------------------------------------------------
 * Function:    test_skip_elmts
 *
 * Purpose:    Skip some elements when writing element
 *
 * Return:    Success:    0
 *        Failure:    1
 *
 *-------------------------------------------------------------------------
 */
static unsigned
test_skip_elmts(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t *tparam, hsize_t skip_elmts,
                const char *test_str)
{
    hid_t          file = H5I_INVALID_HID; /* File ID */
    H5F_t         *f    = NULL;            /* Internal file object pointer */
    H5EA_t        *ea   = NULL;            /* Extensible array wrapper */
    earray_state_t state;                  /* State of extensible array */
    uint64_t       welmt;                  /* Element to write */
    uint64_t       relmt;                  /* Element to read */
    hsize_t        nelmts_written;         /* Highest element written in array */
    hsize_t        idx;                    /* Index value of element to get */
    hsize_t        cnt;                    /* Count of array indices */
    haddr_t        ea_addr = HADDR_UNDEF;  /* Array address in file */

    /*
     * Display testing message
     */
    TESTING(test_str);

    /* Create file & retrieve pointer to internal file object */
    if (create_file(H5F_ACC_TRUNC, fapl, &file, &f) < 0)
        TEST_ERROR;

    /* Create array */
    if (create_array(f, cparam, &ea, &ea_addr, NULL) < 0)
        TEST_ERROR;

    /* Verify the creation parameters */
    if (verify_cparam(ea, cparam) < 0)
        TEST_ERROR;

    /* Check for closing & re-opening the file */
    if (reopen_file(&file, &f, fapl, &ea, ea_addr, tparam) < 0)
        TEST_ERROR;

    /* Verify high-water # of elements written */
    nelmts_written = (hsize_t)ULLONG_MAX;
    if (H5EA_get_nelmts(ea, &nelmts_written) < 0)
        FAIL_STACK_ERROR;
    if (nelmts_written != 0)
        TEST_ERROR;

    /* Verify array state */
    memset(&state, 0, sizeof(state));
    state.hdr_size = EA_HDR_SIZE;
    if (check_stats(ea, &state))
        TEST_ERROR;

    /* Set (& get) element after skipping elements */
    idx = skip_elmts;

    /* Retrieve element of array (not set yet) */
    relmt = (uint64_t)0;
    if (H5EA_get(ea, idx, &relmt) < 0)
        FAIL_STACK_ERROR;

    /* Verify element is fill value for array */
    if (relmt != H5EA_TEST_FILL)
        TEST_ERROR;

    /* Set element of array */
    welmt = (uint64_t)7 + idx;
    if (H5EA_set(ea, idx, &welmt) < 0)
        FAIL_STACK_ERROR;

    /* Verify high-water # of elements written */
    nelmts_written = (hsize_t)ULLONG_MAX;
    if (H5EA_get_nelmts(ea, &nelmts_written) < 0)
        FAIL_STACK_ERROR;
    if (nelmts_written != (idx + 1))
        TEST_ERROR;

    /* Set array state */
    memset(&state, 0, sizeof(state));
    state.hdr_size       = EA_HDR_SIZE;
    state.nindex_blks    = 1;
    state.index_blk_size = EA_IBLOCK_SIZE;
    state.max_idx_set    = idx + 1;
    if (1 == skip_elmts) {
        state.nelmts      = (hsize_t)cparam->idx_blk_elmts;
        state.nsuper_blks = state.ndata_blks = (hsize_t)0;
    } /* end if */
    else if (cparam->idx_blk_elmts == skip_elmts) {
        state.nelmts      = (hsize_t)cparam->idx_blk_elmts + cparam->data_blk_min_elmts;
        state.ndata_blks  = (hsize_t)1;
        state.nsuper_blks = (hsize_t)0;
    } /* end if */
    else {
        unsigned sblk_idx; /* Which superblock does this index fall in? */

        /* Compute super block index for element index */
        /* (same eqn. as in H5EA__dblock_sblk_idx()) */
        sblk_idx =
            H5VM_log2_gen((uint64_t)(((idx - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
        state.nelmts      = (hsize_t)cparam->idx_blk_elmts + tparam->sblk_info[sblk_idx].dblk_nelmts;
        state.ndata_blks  = (hsize_t)1;
        state.nsuper_blks = (hsize_t)1;
    } /* end if */

    /* Verify array state */
    if (check_stats(ea, &state))
        TEST_ERROR;

    /* Retrieve element of array (set now) */
    relmt = (uint64_t)0;
    if (H5EA_get(ea, idx, &relmt) < 0)
        FAIL_STACK_ERROR;

    /* Verify element is value written */
    if (relmt != welmt)
        TEST_ERROR;

    /* Get unset elements of array */
    for (cnt = 0; cnt < skip_elmts; cnt++) {
        /* Retrieve element of array (not set yet) */
        relmt = (uint64_t)0;
        if (H5EA_get(ea, cnt, &relmt) < 0)
            FAIL_STACK_ERROR;

        /* Verify element is fill value for array */
        if (relmt != H5EA_TEST_FILL)
            TEST_ERROR;
    } /* end for */

    /* Close array, delete array, close file & verify file is empty */
    if (finish(file, fapl, f, ea, ea_addr) < 0)
        TEST_ERROR;

    /* All tests passed */
    PASSED();

    return 0;

error:
    H5E_BEGIN_TRY
    {
        if (ea)
            H5EA_close(ea);
        H5Fclose(file);
    }
    H5E_END_TRY

    return 1;
} /* test_skip_elmts() */

/*-------------------------------------------------------------------------
 * Function:    main
 *
 * Purpose:    Test the extensible array code
 *
 * Return:    Success: 0
 *        Failure: 1
 *
 *-------------------------------------------------------------------------
 */
int
main(void)
{
    H5EA_create_t       cparam;                    /* Creation parameters for extensible array */
    earray_test_param_t tparam;                    /* Testing parameters */
    earray_test_type_t  curr_test;                 /* Current test being worked on */
    earray_iter_type_t  curr_iter;                 /* Current iteration type being worked on */
    hid_t               fapl    = H5I_INVALID_HID; /* 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 */
    bool                api_ctx_pushed = false;    /* Whether API context pushed */

    /* 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));

    /* Push API context */
    if (H5CX_push() < 0)
        FAIL_STACK_ERROR;
    api_ctx_pushed = true;

    /* Seed random #'s */
    curr_time = HDtime(NULL);
    HDsrandom((unsigned)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;
    }

    /* Initialize extensible array creation parameters */
    init_cparam(&cparam);

    /* Iterate over the testing parameters */
    for (curr_test = EARRAY_TEST_NORMAL; curr_test < EARRAY_TEST_NTESTS; curr_test++) {

        /* Initialize the testing parameters */
        init_tparam(&tparam, &cparam);

        /* Set appropriate testing parameters for each test */
        switch (curr_test) {
            /* "Normal" testing parameters */
            case EARRAY_TEST_NORMAL:
                puts("Testing with normal parameters");
                break;

            /* "Re-open array" testing parameters */
            case EARRAY_TEST_REOPEN:
                puts("Testing with reopen array flag set");
                tparam.reopen_array = EARRAY_TEST_REOPEN;
                break;

            /* An unknown test? */
            case EARRAY_TEST_NTESTS:
            default:
                goto error;
        } /* end switch */

        /* Basic capability tests */
        nerrors += test_create(fapl, &cparam, &tparam);
        nerrors += test_reopen(fapl, &cparam, &tparam);
        nerrors += test_open_twice(fapl, &cparam, &tparam);
        nerrors += test_open_twice_diff(fapl, &cparam, &tparam);
        nerrors += test_delete_open(fapl, &cparam, &tparam);

        /* Iterate over the type of capacity tests */
        for (curr_iter = EARRAY_ITER_FW; curr_iter < EARRAY_ITER_NITERS; curr_iter++) {
            hsize_t sblk;          /* Super block index */
            hsize_t dblk;          /* Data block index */
            hsize_t nelmts;        /* # of elements to test */
            char    test_str[128]; /* String for describing test */
            hsize_t ndblks;        /* # of data blocks tested */

            /* Set appropriate parameters for each type of iteration */
            switch (curr_iter) {
                /* "Forward" testing parameters */
                case EARRAY_ITER_FW:
                    puts("Testing with forward iteration");
                    tparam.eiter = &ea_iter_fw;
                    break;

                /* "Reverse" testing parameters */
                case EARRAY_ITER_RV:
                    puts("Testing with reverse iteration");
                    tparam.eiter = &ea_iter_rv;
                    break;

                /* "Random" testing parameters */
                case EARRAY_ITER_RND:
                    puts("Testing with random iteration");
                    tparam.eiter = &ea_iter_rnd;
                    break;

                /* "Random #2" testing parameters */
                case EARRAY_ITER_RND2:
                    puts("Testing with random #2 iteration");
                    tparam.eiter = &ea_iter_rnd2;
                    break;

                /* "Cyclic" testing parameters */
                case EARRAY_ITER_CYC:
                    puts("Testing with cyclic iteration");
                    tparam.eiter = &ea_iter_cyc;
                    break;

                /* An unknown iteration? */
                case EARRAY_ITER_NITERS:
                default:
                    goto error;
            } /* end switch */

            /* Basic capacity tests */
            nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)1, "setting first element of array");
            nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)cparam.idx_blk_elmts,
                                      "setting index block elements of array");

            /* Super Block capacity tests */
            ndblks = 0;
            for (sblk = 0; sblk < 9; sblk++) {
                for (dblk = 0; dblk < tparam.sblk_info[sblk].ndblks; dblk++) {
                    /* Test first element in data block */
                    nelmts = (hsize_t)((hsize_t)1 + cparam.idx_blk_elmts + tparam.sblk_info[sblk].start_idx +
                                       (tparam.sblk_info[sblk].dblk_nelmts * dblk));
                    snprintf(test_str, sizeof(test_str), "setting first element of array's data block #%llu",
                             (unsigned long long)ndblks);
                    nerrors += test_set_elmts(fapl, &cparam, &tparam, nelmts, test_str);

                    /* Test all elements in data block */
                    nelmts = (hsize_t)(cparam.idx_blk_elmts + tparam.sblk_info[sblk].start_idx +
                                       (tparam.sblk_info[sblk].dblk_nelmts * (dblk + 1)));
                    snprintf(test_str, sizeof(test_str), "setting all elements of array's data block #%llu",
                             (unsigned long long)ndblks);
                    nerrors += test_set_elmts(fapl, &cparam, &tparam, nelmts, test_str);

                    /* Increment data block being tested */
                    ndblks++;
                } /* end for */
            }     /* end for */
        }         /* end for */

        /* Check skipping elements */
        nerrors += test_skip_elmts(fapl, &cparam, &tparam, (hsize_t)1, "skipping 1st element");
        nerrors += test_skip_elmts(fapl, &cparam, &tparam, (hsize_t)cparam.idx_blk_elmts,
                                   "skipping index block elements");
        nerrors += test_skip_elmts(fapl, &cparam, &tparam,
                                   (hsize_t)(cparam.idx_blk_elmts + (15 * cparam.data_blk_min_elmts) + 1),
                                   "skipping index block & data block elements");
        nerrors += test_skip_elmts(fapl, &cparam, &tparam,
                                   (hsize_t)(cparam.idx_blk_elmts + (31 * cparam.data_blk_min_elmts) + 1),
                                   "skipping 1st super block elements");
        nerrors += test_skip_elmts(fapl, &cparam, &tparam,
                                   (hsize_t)(cparam.idx_blk_elmts + (63 * cparam.data_blk_min_elmts) + 1),
                                   "skipping 2nd super block elements");
        nerrors += test_skip_elmts(fapl, &cparam, &tparam,
                                   (hsize_t)(cparam.idx_blk_elmts + (127 * cparam.data_blk_min_elmts) + 1),
                                   "skipping 3rd super block elements");
        nerrors += test_skip_elmts(fapl, &cparam, &tparam,
                                   (hsize_t)(cparam.idx_blk_elmts + (255 * cparam.data_blk_min_elmts) + 1),
                                   "skipping 4th super block elements");

        /* Close down testing parameters */
        finish_tparam(&tparam);
    } /* end for */

    /* Verify symbol table messages are cached */
    nerrors += (h5_verify_cached_stabs(FILENAME, fapl) < 0 ? 1 : 0);

    /* Pop API context */
    if (api_ctx_pushed && H5CX_pop(false) < 0)
        FAIL_STACK_ERROR;
    api_ctx_pushed = false;

    if (nerrors)
        goto error;
    puts("All extensible 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

    if (api_ctx_pushed)
        H5CX_pop(false);

    return 1;
} /* end main() */