mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2024-11-21 01:04:10 +08:00
Code Issues Packages Projects Releases Wiki Activity
4261552068
hdf5/test/earray.c
Dana Robinson 44a00ef876
Strip HD prefix from string/char C API calls (#3540) 
* Strip HD prefix from string/char C API calls

* HD(f)(put|get)(s|c)
* HDstr*
* HDv*printf
* HD(s)(print|scan)f
* HDperror

But NOT:

* HDstrcase*
* HDvasprintf
* HDstrtok_r
* HDstrndup

As those are not C99 and have portability work-around
implementations. They will be handled later.

* Fix th5_system.c screwup
2023-09-15 15:13:18 -07:00

2504 lines
81 KiB
C
Raw Blame History

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* 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() */
Reference in New Issue View Git Blame Copy Permalink