mirror/hdf5
2
0
Fork 0
mirror of https://github.com/HDFGroup/hdf5.git synced 2024-11-27 02:10:55 +08:00
Code Issues Packages Projects Releases Wiki Activity
9fe6b65c9f
hdf5/test/earray.c
Quincey Koziol 9fe6b65c9f [svn-r16040] Description: 
More tests for extensible arrays.

Tested on:
        Mac OS X/32 10.5.5 (amazon) in debug mode
        Mac OS X/32 10.5.5 (amazon) w/C++ & FORTRAN, w/threadsafe,
                                in production mode
        FreeBSD/32 6.3 (duty) in debug mode
        FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
        Linux/32 2.6 (jam) w/PGI compilers, w/C++ & FORTRAN, w/threadsafe,
                                in debug mode
        Linux/64-amd64 2.6 (smirom) w/Intel compilers w/default API=1.6.x,
                                w/C++ & FORTRAN, in production mode
        Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
                                w/szip filter, in production mode
        Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
                                in production mode
        Linux/64-ia64 2.4 (tg-login3) w/parallel, w/FORTRAN, in production mode
        Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in production mode
2008-11-06 21:17:30 -05:00

1776 lines
64 KiB
C
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Copyright by The HDF Group. *
* Copyright by the Board of Trustees of the University of Illinois. *
* All rights reserved. *
* *
* This file is part of HDF5. The full HDF5 copyright notice, including *
* terms governing use, modification, and redistribution, is contained in *
* the files COPYING and Copyright.html. COPYING can be found at the root *
* of the source code distribution tree; Copyright.html can be found at the *
* root level of an installed copy of the electronic HDF5 document set and *
* is linked from the top-level documents page. It can also be found at *
* http://hdfgroup.org/HDF5/doc/Copyright.html. If you do not have *
* access to either file, you may request a copy from help@hdfgroup.org. *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* Programmer: Quincey Koziol <koziol@hdfgroup.org>
* Tuesday, June 17, 2008
*/
#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_PACKAGE
#define H5EA_TESTING
#include "H5EApkg.h" /* Extensible Arrays */
/* Other private headers that this test requires */
#include "H5Iprivate.h" /* IDs */
#include "H5Vprivate.h" /* Vectors and arrays */
/* Local macros */
/* Max. testfile name length */
#define EARRAY_FILENAME_LEN 1024
/* Extensible array creation values */
#define ELMT_SIZE sizeof(uint64_t)
#define MAX_NELMTS_BITS 32
#define IDX_BLK_ELMTS 4
#define SUP_BLK_MIN_DATA_PTRS 4
#define DATA_BLK_MIN_ELMTS 16
/* Convenience macros for computing earray state */
#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))
/* 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_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 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 nsuper_blks; /* # of super blocks */
hsize_t ndata_blks; /* # of data blocks */
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)(hsize_t cnt); /* Initialize/allocate iterator private info */
hssize_t (*next)(void *info); /* Get the next element to test */
hssize_t (*max)(const void *info); /* Get the max. element set */
int (*state)(void *_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 */
};
/* Local variables */
const char *FILENAME[] = {
"earray",
NULL
};
/* Filename to use for all tests */
char filename_g[EARRAY_FILENAME_LEN];
/* Empty file size */
h5_stat_size_t empty_size_g;
/* Local prototypes */
/*-------------------------------------------------------------------------
* Function: init_cparam
*
* Purpose: Initialize array creation parameter structure
*
* Return: Success: 0
* Failure: -1
*
* Programmer: Quincey Koziol
* Thursday, August 21, 2008
*
*-------------------------------------------------------------------------
*/
static int
init_cparam(H5EA_create_t *cparam)
{
/* Wipe out background */
HDmemset(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;
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
*
* Programmer: Quincey Koziol
* Thursday, September 25, 2008
*
*-------------------------------------------------------------------------
*/
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 */
HDmemset(tparam, 0, sizeof(*tparam));
/* Compute general information */
tparam->nsblks = 1 + (cparam->max_nelmts_bits - H5V_log2_of2(cparam->data_blk_min_elmts));
/* Allocate information for each super block */
tparam->sblk_info = (H5EA_sblk_info_t *)HDmalloc(sizeof(H5EA_sblk_info_t) * tparam->nsblks);
HDassert(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
*
* Programmer: Quincey Koziol
* Thursday, September 25, 2008
*
*-------------------------------------------------------------------------
*/
static int
finish_tparam(earray_test_param_t *tparam)
{
/* Release super block information */
HDfree(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
*
* Programmer: Quincey Koziol
* Thursday, August 28, 2008
*
*-------------------------------------------------------------------------
*/
static int
create_file(hid_t fapl, hid_t *file, H5F_t **f)
{
/* Create the file to work on */
if((*file = H5Fcreate(filename_g, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
FAIL_STACK_ERROR
/* Get a pointer to the internal file object */
if(NULL == (*f = (H5F_t *)H5I_object(*file)))
FAIL_STACK_ERROR
/* Success */
return(0);
error:
return(-1);
} /* create_file() */
/*-------------------------------------------------------------------------
* Function: check_stats
*
* Purpose: Verify stats for an extensible array
*
* Return: Success: 0
* Failure: -1
*
* Programmer: Quincey Koziol
* Thursday, August 21, 2008
*
*-------------------------------------------------------------------------
*/
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.max_idx_set != state->max_idx_set) {
HDfprintf(stdout, "earray_stats.max_idx_set = %Hu, state->max_idx_set = %Hu\n", earray_stats.max_idx_set, state->max_idx_set);
TEST_ERROR
} /* end if */
if(earray_stats.nelmts != state->nelmts) {
HDfprintf(stdout, "earray_stats.nelmts = %Hu, state->nelmts = %Hu\n", earray_stats.nelmts, state->nelmts);
TEST_ERROR
} /* end if */
if(earray_stats.ndata_blks != state->ndata_blks) {
HDfprintf(stdout, "earray_stats.ndata_blks = %Hu, state->ndata_blks = %Hu\n", earray_stats.ndata_blks, state->ndata_blks);
TEST_ERROR
} /* end if */
if(earray_stats.nsuper_blks != state->nsuper_blks) {
HDfprintf(stdout, "earray_stats.nsuper_blks = %Hu, state->nsuper_blks = %Hu\n", earray_stats.nsuper_blks, state->nsuper_blks);
TEST_ERROR
} /* end if */
/* 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
*
* Programmer: Quincey Koziol
* Thursday, August 28, 2008
*
*-------------------------------------------------------------------------
*/
static int
reopen_file(hid_t *file, H5F_t **f, hid_t fapl, hid_t dxpl,
H5EA_t **ea, haddr_t ea_addr, const H5EA_class_t *ea_cls,
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) {
if(H5EA_close(*ea, dxpl) < 0)
FAIL_STACK_ERROR
*ea = NULL;
} /* end if */
/* Close file */
if(H5Fclose(*file) < 0)
FAIL_STACK_ERROR
*file = (-1);
*f = NULL;
/* Re-open the file */
if((*file = H5Fopen(filename_g, H5F_ACC_RDWR, fapl)) < 0)
FAIL_STACK_ERROR
/* Get a pointer to the internal file object */
if(NULL == (*f = (H5F_t *)H5I_object(*file)))
FAIL_STACK_ERROR
/* Re-open array, if given */
if(ea) {
if(NULL == (*ea = H5EA_open(*f, dxpl, ea_addr, ea_cls)))
FAIL_STACK_ERROR
} /* end if */
} /* 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
*
* Programmer: Quincey Koziol
* Thursday, August 28, 2008
*
*-------------------------------------------------------------------------
*/
static int
create_array(H5F_t *f, hid_t dxpl, const H5EA_create_t *cparam,
H5EA_t **ea, haddr_t *ea_addr)
{
hsize_t nelmts; /* Number of elements in array */
earray_state_t state; /* State of extensible array */
/* Create array */
if(NULL == (*ea = H5EA_create(f, dxpl, cparam)))
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(!H5F_addr_defined(*ea_addr))
TEST_ERROR
HDmemset(&state, 0, sizeof(state));
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
*
* Programmer: Quincey Koziol
* Thursday, August 28, 2008
*
*-------------------------------------------------------------------------
*/
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 */
HDmemset(&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(0);
error:
return(-1);
} /* verify_cparam() */
/*-------------------------------------------------------------------------
* Function: finish
*
* Purpose: Close array, delete array, close file and verify that file
* is empty size
*
* Return: Success: 0
* Failure: -1
*
* Programmer: Quincey Koziol
* Thursday, August 28, 2008
*
*-------------------------------------------------------------------------
*/
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, H5P_DATASET_XFER_DEFAULT) < 0)
FAIL_STACK_ERROR
#ifdef QAK
HDfprintf(stderr, "ea_addr = %a\n", ea_addr);
H5Fflush(file, H5F_SCOPE_GLOBAL);
HDsystem("cp earray.h5 earray.h5.save");
#endif /* QAK */
/* Delete array */
if(H5EA_delete(f, H5P_DATASET_XFER_DEFAULT, ea_addr) < 0)
FAIL_STACK_ERROR
/* Close the file */
if(H5Fclose(file) < 0)
FAIL_STACK_ERROR
/* Get the size of the file */
if((file_size = h5_get_file_size(filename_g, fapl)) < 0)
TEST_ERROR
/* Verify the file is correct size */
if(file_size != empty_size_g)
TEST_ERROR
/* Success */
return(0);
error:
return(-1);
} /* finish() */
/*-------------------------------------------------------------------------
* Function: test_create
*
* Purpose: Test creating extensible array
*
* Return: Success: 0
* Failure: 1
*
* Programmer: Quincey Koziol
* Thursday, August 7, 2008
*
*-------------------------------------------------------------------------
*/
static unsigned
test_create(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t UNUSED *tparam)
{
hid_t file = -1; /* 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(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 */
HDmemcpy(&test_cparam, cparam, sizeof(test_cparam));
test_cparam.raw_elmt_size = 0;
H5E_BEGIN_TRY {
ea = H5EA_create(f, H5P_DATASET_XFER_DEFAULT, &test_cparam);
} H5E_END_TRY;
if(ea) {
/* Close opened extensible array */
H5EA_close(ea, H5P_DATASET_XFER_DEFAULT);
/* Indicate error */
TEST_ERROR
} /* end if */
/* Set invalid max. # of elements bits */
HDmemcpy(&test_cparam, cparam, sizeof(test_cparam));
test_cparam.max_nelmts_bits = 0;
H5E_BEGIN_TRY {
ea = H5EA_create(f, H5P_DATASET_XFER_DEFAULT, &test_cparam);
} H5E_END_TRY;
if(ea) {
/* Close opened extensible array */
H5EA_close(ea, H5P_DATASET_XFER_DEFAULT);
/* Indicate error */
TEST_ERROR
} /* end if */
HDmemcpy(&test_cparam, cparam, sizeof(test_cparam));
test_cparam.max_nelmts_bits = 65;
H5E_BEGIN_TRY {
ea = H5EA_create(f, H5P_DATASET_XFER_DEFAULT, &test_cparam);
} H5E_END_TRY;
if(ea) {
/* Close opened extensible array */
H5EA_close(ea, H5P_DATASET_XFER_DEFAULT);
/* Indicate error */
TEST_ERROR
} /* end if */
/* Set invalid min. # of data block pointers in super blocks */
HDmemcpy(&test_cparam, cparam, sizeof(test_cparam));
test_cparam.sup_blk_min_data_ptrs = 0;
H5E_BEGIN_TRY {
ea = H5EA_create(f, H5P_DATASET_XFER_DEFAULT, &test_cparam);
} H5E_END_TRY;
if(ea) {
/* Close opened extensible array */
H5EA_close(ea, H5P_DATASET_XFER_DEFAULT);
/* Indicate error */
TEST_ERROR
} /* end if */
HDmemcpy(&test_cparam, cparam, sizeof(test_cparam));
test_cparam.sup_blk_min_data_ptrs = 1;
H5E_BEGIN_TRY {
ea = H5EA_create(f, H5P_DATASET_XFER_DEFAULT, &test_cparam);
} H5E_END_TRY;
if(ea) {
/* Close opened extensible array */
H5EA_close(ea, H5P_DATASET_XFER_DEFAULT);
/* Indicate error */
TEST_ERROR
} /* end if */
HDmemcpy(&test_cparam, cparam, sizeof(test_cparam));
test_cparam.sup_blk_min_data_ptrs = 6;
H5E_BEGIN_TRY {
ea = H5EA_create(f, H5P_DATASET_XFER_DEFAULT, &test_cparam);
} H5E_END_TRY;
if(ea) {
/* Close opened extensible array */
H5EA_close(ea, H5P_DATASET_XFER_DEFAULT);
/* Indicate error */
TEST_ERROR
} /* end if */
/* Set invalid min. # of elements per data block */
HDmemcpy(&test_cparam, cparam, sizeof(test_cparam));
test_cparam.data_blk_min_elmts = 0;
H5E_BEGIN_TRY {
ea = H5EA_create(f, H5P_DATASET_XFER_DEFAULT, &test_cparam);
} H5E_END_TRY;
if(ea) {
/* Close opened extensible array */
H5EA_close(ea, H5P_DATASET_XFER_DEFAULT);
/* 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, H5P_DATASET_XFER_DEFAULT, cparam, &ea, &ea_addr) < 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, H5P_DATASET_XFER_DEFAULT);
H5Fclose(file);
} H5E_END_TRY;
return 1;
} /* end test_create() */
/*-------------------------------------------------------------------------
* Function: test_reopen
*
* Purpose: Create & reopen an extensible array
*
* Return: Success: 0
* Failure: 1
*
* Programmer: Quincey Koziol
* Thursday, August 28, 2008
*
*-------------------------------------------------------------------------
*/
static unsigned
test_reopen(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t *tparam)
{
hid_t file = -1; /* 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(fapl, &file, &f) < 0)
TEST_ERROR
/*
* Display testing message
*/
TESTING("create, close & reopen extensible array");
/* Create array */
if(create_array(f, H5P_DATASET_XFER_DEFAULT, cparam, &ea, &ea_addr) < 0)
TEST_ERROR
/* Close the extensible array */
if(H5EA_close(ea, H5P_DATASET_XFER_DEFAULT) < 0)
FAIL_STACK_ERROR
/* Check for closing & re-opening the file */
if(reopen_file(&file, &f, fapl, H5P_DATASET_XFER_DEFAULT, NULL, HADDR_UNDEF, NULL, tparam) < 0)
TEST_ERROR
/* Re-open the array */
if(NULL == (ea = H5EA_open(f, H5P_DATASET_XFER_DEFAULT, ea_addr, cparam->cls)))
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, H5P_DATASET_XFER_DEFAULT);
H5Fclose(file);
} H5E_END_TRY;
return 1;
} /* test_reopen() */
/*-------------------------------------------------------------------------
* Function: test_open_twice
*
* Purpose: Open an extensible array twice
*
* Return: Success: 0
* Failure: 1
*
* Programmer: Quincey Koziol
* Thursday, August 28, 2008
*
*-------------------------------------------------------------------------
*/
static unsigned
test_open_twice(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t *tparam)
{
hid_t file = -1; /* File ID */
hid_t file2 = -1; /* File ID */
H5F_t *f = NULL; /* Internal file object pointer */
H5F_t *f2 = NULL; /* Internal file object pointer */
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(fapl, &file, &f) < 0)
TEST_ERROR
/*
* Display testing message
*/
TESTING("open extensible array twice");
/* Create array */
if(create_array(f, H5P_DATASET_XFER_DEFAULT, cparam, &ea, &ea_addr) < 0)
TEST_ERROR
/* Open the array again, through the first file handle */
if(NULL == (ea2 = H5EA_open(f, H5P_DATASET_XFER_DEFAULT, ea_addr, cparam->cls)))
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, H5P_DATASET_XFER_DEFAULT) < 0)
FAIL_STACK_ERROR
ea2 = NULL;
/* Check for closing & re-opening the file */
if(reopen_file(&file, &f, fapl, H5P_DATASET_XFER_DEFAULT, &ea, ea_addr, cparam->cls, tparam) < 0)
TEST_ERROR
/* Re-open the file */
if((file2 = H5Freopen(file)) < 0)
FAIL_STACK_ERROR
/* Get a pointer to the internal file object */
if(NULL == (f2 = (H5F_t *)H5I_object(file2)))
FAIL_STACK_ERROR
/* Open the extensible array through the second file handle */
if(NULL == (ea2 = H5EA_open(f2, H5P_DATASET_XFER_DEFAULT, ea_addr, cparam->cls)))
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, H5P_DATASET_XFER_DEFAULT) < 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, H5P_DATASET_XFER_DEFAULT);
if(ea2)
H5EA_close(ea2, H5P_DATASET_XFER_DEFAULT);
H5Fclose(file);
H5Fclose(file2);
} H5E_END_TRY;
return 1;
} /* test_open_twice() */
/*-------------------------------------------------------------------------
* Function: test_delete_open
*
* Purpose: Delete opened extensible array (& open deleted array)
*
* Return: Success: 0
* Failure: 1
*
* Programmer: Quincey Koziol
* Thursday, August 28, 2008
*
*-------------------------------------------------------------------------
*/
static unsigned
test_delete_open(hid_t fapl, H5EA_create_t *cparam, earray_test_param_t *tparam)
{
hid_t file = -1; /* 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(fapl, &file, &f) < 0)
TEST_ERROR
/*
* Display testing message
*/
TESTING("deleting open extensible array");
/* Create array */
if(create_array(f, H5P_DATASET_XFER_DEFAULT, cparam, &ea, &ea_addr) < 0)
TEST_ERROR
/* Open the array again */
if(NULL == (ea2 = H5EA_open(f, H5P_DATASET_XFER_DEFAULT, ea_addr, cparam->cls)))
FAIL_STACK_ERROR
/* Request that the array be deleted */
if(H5EA_delete(f, H5P_DATASET_XFER_DEFAULT, ea_addr) < 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, H5P_DATASET_XFER_DEFAULT) < 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, H5P_DATASET_XFER_DEFAULT, ea_addr, cparam->cls);
} H5E_END_TRY;
if(ea2) {
/* Close opened array */
H5EA_close(ea2, H5P_DATASET_XFER_DEFAULT);
/* Indicate error */
TEST_ERROR
} /* end if */
/* Close the first extensible array wrapper */
if(H5EA_close(ea, H5P_DATASET_XFER_DEFAULT) < 0)
FAIL_STACK_ERROR
ea = NULL;
/* Check for closing & re-opening the file */
if(reopen_file(&file, &f, fapl, H5P_DATASET_XFER_DEFAULT, NULL, HADDR_UNDEF, NULL, tparam) < 0)
TEST_ERROR
/* Try re-opening the array again (should fail, as array is now deleted) */
H5E_BEGIN_TRY {
ea = H5EA_open(f, H5P_DATASET_XFER_DEFAULT, ea_addr, cparam->cls);
} H5E_END_TRY;
if(ea) {
/* Close opened array */
H5EA_close(ea, H5P_DATASET_XFER_DEFAULT);
/* Indicate error */
TEST_ERROR
} /* end if */
/* Close the file */
if(H5Fclose(file) < 0)
FAIL_STACK_ERROR
/* Get the size of the file */
if((file_size = h5_get_file_size(filename_g, fapl)) < 0)
TEST_ERROR
/* Verify the file is correct size */
if(file_size != empty_size_g)
TEST_ERROR
/* All tests passed */
PASSED()
return 0;
error:
H5E_BEGIN_TRY {
if(ea)
H5EA_close(ea, H5P_DATASET_XFER_DEFAULT);
if(ea2)
H5EA_close(ea2, H5P_DATASET_XFER_DEFAULT);
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 interator (forward iteration)
*
* Return: Success: Pointer to iteration status object
* Failure: NULL
*
* Programmer: Quincey Koziol
* Thursday, October 2, 2008
*
*-------------------------------------------------------------------------
*/
static void *
eiter_fw_init(hsize_t UNUSED cnt)
{
eiter_fw_t *eiter; /* Forward element iteration object */
/* Allocate space for the element iteration object */
eiter = HDmalloc(sizeof(eiter_fw_t));
HDassert(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
*
* Programmer: Quincey Koziol
* Tuesday, November 4, 2008
*
*-------------------------------------------------------------------------
*/
static hssize_t
eiter_fw_next(void *_eiter)
{
eiter_fw_t *eiter = (eiter_fw_t *)_eiter;
hssize_t ret_val;
/* Sanity check */
HDassert(eiter);
/* Get the next array index to test */
ret_val = 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
*
* Programmer: Quincey Koziol
* Tuesday, November 4, 2008
*
*-------------------------------------------------------------------------
*/
static hssize_t
eiter_fw_max(const void *_eiter)
{
const eiter_fw_t *eiter = (const eiter_fw_t *)_eiter;
/* Sanity check */
HDassert(eiter);
/* Return the max. array index used */
return((hsize_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
*
* Programmer: Quincey Koziol
* Tuesday, November 4, 2008
*
*-------------------------------------------------------------------------
*/
static int
eiter_fw_state(void *_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 *)_eiter;
/* Sanity check */
HDassert(eiter);
HDassert(cparam);
HDassert(tparam);
HDassert(state);
/* Reset the state */
HDmemset(state, 0, sizeof(*state));
/* Compute the state of the extensible array */
state->max_idx_set = idx + 1;
if(idx < cparam->idx_blk_elmts)
state->nelmts = (hsize_t)cparam->idx_blk_elmts;
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 = H5V_log2_gen((uint64_t)(((idx - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
#ifdef QAK
HDfprintf(stderr, "idx = %Hu, tparam->sblk_info[%u] = {%Zu, %Zu, %Hu, %Hu}\n", idx, sblk_idx, tparam->sblk_info[sblk_idx].ndblks, tparam->sblk_info[sblk_idx].dblk_nelmts, tparam->sblk_info[sblk_idx].start_idx, tparam->sblk_info[sblk_idx].start_dblk);
#endif /* QAK */
state->nelmts = EA_NELMTS(cparam, tparam, idx, sblk_idx);
#ifdef QAK
HDfprintf(stderr, "state->nelmts = %Hu\n", state->nelmts);
#endif /* QAK */
state->ndata_blks = EA_NDATA_BLKS(cparam, tparam, idx, sblk_idx);
#ifdef QAK
HDfprintf(stderr, "state->ndata_blks = %Hu\n", state->ndata_blks);
#endif /* QAK */
/* 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;
#ifdef QAK
HDfprintf(stderr, "state->nsuper_blks = %Hu\n", state->nsuper_blks);
#endif /* QAK */
} /* end if */
} /* end else */
return(0);
} /* end eiter_fw_state() */
/*-------------------------------------------------------------------------
* Function: eiter_fw_term
*
* Purpose: Shut down element interator (forward iteration)
*
* Return: Success: 0
* Failure: -1
*
* Programmer: Quincey Koziol
* Thursday, October 2, 2008
*
*-------------------------------------------------------------------------
*/
static int
eiter_fw_term(void *eiter)
{
/* Sanity check */
HDassert(eiter);
/* Free iteration object */
HDfree(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 */
} eiter_rv_t;
/*-------------------------------------------------------------------------
* Function: eiter_rv_init
*
* Purpose: Initialize element interator (reverse iteration)
*
* Return: Success: Pointer to iteration status object
* Failure: NULL
*
* Programmer: Quincey Koziol
* Tuesday, November 4, 2008
*
*-------------------------------------------------------------------------
*/
static void *
eiter_rv_init(hsize_t cnt)
{
eiter_rv_t *eiter; /* Reverse element iteration object */
/* Allocate space for the element iteration object */
eiter = HDmalloc(sizeof(eiter_rv_t));
HDassert(eiter);
/* Initialize reverse iteration info */
eiter->idx = cnt - 1;
eiter->max = cnt - 1;
/* 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
*
* Programmer: Quincey Koziol
* Tuesday, November 4, 2008
*
*-------------------------------------------------------------------------
*/
static hssize_t
eiter_rv_next(void *_eiter)
{
eiter_rv_t *eiter = (eiter_rv_t *)_eiter;
hssize_t ret_val;
/* Sanity check */
HDassert(eiter);
/* Get the next array index to test */
ret_val = 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
*
* Programmer: Quincey Koziol
* Tuesday, November 4, 2008
*
*-------------------------------------------------------------------------
*/
static hssize_t
eiter_rv_max(const void *_eiter)
{
const eiter_rv_t *eiter = (const eiter_rv_t *)_eiter;
/* Sanity check */
HDassert(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
*
* Programmer: Quincey Koziol
* Tuesday, November 4, 2008
*
*-------------------------------------------------------------------------
*/
static int
eiter_rv_state(void *_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 *)_eiter;
/* Sanity check */
HDassert(eiter);
HDassert(cparam);
HDassert(tparam);
HDassert(state);
/* Reset the state */
HDmemset(state, 0, sizeof(*state));
/* Compute the state of the extensible array */
state->max_idx_set = eiter->max + 1;
if(eiter->max < cparam->idx_blk_elmts)
state->nelmts = (hsize_t)cparam->idx_blk_elmts;
else {
hsize_t max_nelmts; /* Max. # of elements for array */
hsize_t idx_nelmts; /* # of elements for array index */
hsize_t max_ndata_blks; /* Max. # of data blocks for array */
hsize_t idx_ndata_blks; /* # of data blocks for array index */
hsize_t tmp_idx;
unsigned max_sblk_idx; /* Which superblock does the max. index fall in? */
unsigned idx_sblk_idx; /* Which superblock does this index fall in? */
unsigned tmp_sblk_idx; /* Which superblock does this index fall in? */
/* Compute super block index for element index */
/* (same eqn. as in H5EA__dblock_sblk_idx()) */
max_sblk_idx = H5V_log2_gen((uint64_t)(((eiter->max - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
if(idx < cparam->idx_blk_elmts + cparam->data_blk_min_elmts)
idx_sblk_idx = 0;
else {
hsize_t loc_idx;
hsize_t dblk_idx;
idx_sblk_idx = H5V_log2_gen((uint64_t)(((idx - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
loc_idx = idx - (cparam->idx_blk_elmts + tparam->sblk_info[idx_sblk_idx].start_idx);
dblk_idx = loc_idx / tparam->sblk_info[idx_sblk_idx].dblk_nelmts;
if(dblk_idx > 0)
tmp_idx = idx - tparam->sblk_info[idx_sblk_idx].dblk_nelmts;
else
tmp_idx = cparam->idx_blk_elmts + tparam->sblk_info[idx_sblk_idx].start_idx - 1;
tmp_sblk_idx = H5V_log2_gen((uint64_t)(((tmp_idx - cparam->idx_blk_elmts) / cparam->data_blk_min_elmts) + 1));
} /* end else */
#ifdef QAK
HDfprintf(stderr, "idx = %Hu, tmp_idx = %Hu, max_sblk_idx = %u, idx_sblk_idx = %u, tmp_sblk_idx = %u\n", idx, tmp_idx, max_sblk_idx, idx_sblk_idx, tmp_sblk_idx);
HDfprintf(stderr, "tparam->sblk_info[%u] = {%Zu, %Zu, %Hu, %Hu}\n", idx_sblk_idx, tparam->sblk_info[idx_sblk_idx].ndblks, tparam->sblk_info[idx_sblk_idx].dblk_nelmts, tparam->sblk_info[idx_sblk_idx].start_idx, tparam->sblk_info[idx_sblk_idx].start_dblk);
HDfprintf(stderr, "tparam->sblk_info[%u] = {%Zu, %Zu, %Hu, %Hu}\n", max_sblk_idx, tparam->sblk_info[max_sblk_idx].ndblks, tparam->sblk_info[max_sblk_idx].dblk_nelmts, tparam->sblk_info[max_sblk_idx].start_idx, tparam->sblk_info[max_sblk_idx].start_dblk);
#endif /* QAK */
max_nelmts = EA_NELMTS(cparam, tparam, eiter->max, max_sblk_idx);
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, tmp_idx, tmp_sblk_idx);
state->nelmts = (max_nelmts - idx_nelmts) + cparam->idx_blk_elmts;
#ifdef QAK
HDfprintf(stderr, "max_nelmts = %Hu, idx_nelmts = %Hu, state->nelmts = %Hu\n", max_nelmts, idx_nelmts, state->nelmts);
#endif /* QAK */
max_ndata_blks = EA_NDATA_BLKS(cparam, tparam, eiter->max, max_sblk_idx);
if(idx < cparam->idx_blk_elmts + cparam->data_blk_min_elmts)
idx_ndata_blks = 0;
else
idx_ndata_blks = EA_NDATA_BLKS(cparam, tparam, tmp_idx, tmp_sblk_idx);
state->ndata_blks = max_ndata_blks - idx_ndata_blks;
#ifdef QAK
HDfprintf(stderr, "max_ndata_blks = %Hu, idx_ndata_blks = %Hu, state->ndata_blks = %Hu\n", max_ndata_blks, idx_ndata_blks, state->ndata_blks);
#endif /* QAK */
/* Check if we have any super blocks yet */
if(tparam->sblk_info[max_sblk_idx].ndblks >= cparam->sup_blk_min_data_ptrs) {
hsize_t idx_blk_nsblks = 2 * H5V_log2_of2((uint32_t)cparam->sup_blk_min_data_ptrs);
if(idx_sblk_idx > idx_blk_nsblks)
state->nsuper_blks = (max_sblk_idx - idx_sblk_idx) + 1;
else
state->nsuper_blks = (max_sblk_idx - idx_blk_nsblks) + 1;
#ifdef QAK
HDfprintf(stderr, "idx_blk_nsblks = %Hu, state->nsuper_blks = %Hu\n", idx_blk_nsblks, state->nsuper_blks);
#endif /* QAK */
} /* end if */
} /* end else */
return(0);
} /* end eiter_rv_state() */
/*-------------------------------------------------------------------------
* Function: eiter_rv_term
*
* Purpose: Shut down element interator (reverse iteration)
*
* Return: Success: 0
* Failure: -1
*
* Programmer: Quincey Koziol
* Tuesday, November 4, 2008
*
*-------------------------------------------------------------------------
*/
static int
eiter_rv_term(void *eiter)
{
/* Sanity check */
HDassert(eiter);
/* Free iteration object */
HDfree(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 */
};
/*-------------------------------------------------------------------------
* Function: test_set_elmts
*
* Purpose: Set all elements from 0 through 'nelmts' in extensible array
*
* Return: Success: 0
* Failure: 1
*
* Programmer: Quincey Koziol
* Thursday, September 22, 2008
*
*-------------------------------------------------------------------------
*/
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 = -1; /* 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(fapl, &file, &f) < 0)
TEST_ERROR
/* Create array */
if(create_array(f, H5P_DATASET_XFER_DEFAULT, cparam, &ea, &ea_addr) < 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, H5P_DATASET_XFER_DEFAULT, &ea, ea_addr, cparam->cls, 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 */
HDmemset(&state, 0, sizeof(state));
if(check_stats(ea, &state))
TEST_ERROR
#ifdef OLD_WAY
/* Retrieve elements of array in data block (not set yet) */
for(idx = 0; idx < nelmts; idx++) {
/* Retrieve element of array (not set yet) */
relmt = (uint64_t)0;
if(H5EA_get(ea, H5P_DATASET_XFER_DEFAULT, idx, &relmt) < 0)
FAIL_STACK_ERROR
/* Verify element is fill value for array */
if(relmt != H5EA_TEST_FILL)
TEST_ERROR
} /* end for */
#endif /* OLD_WAY */
/* Initialize iterator */
if(NULL == (eiter_info = tparam->eiter->init(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, H5P_DATASET_XFER_DEFAULT, 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, H5P_DATASET_XFER_DEFAULT, idx, &welmt) < 0)
FAIL_STACK_ERROR
/* Get the max. array index */
if((smax = tparam->eiter->max(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, H5P_DATASET_XFER_DEFAULT, 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, H5P_DATASET_XFER_DEFAULT);
H5Fclose(file);
} H5E_END_TRY;
return 1;
} /* test_set_elmts() */
/*-------------------------------------------------------------------------
* Function: main
*
* Purpose: Test the extensible array code
*
* Return: Success: 0
* Failure: 1
*
* Programmer: Quincey Koziol
* Tuesday, June 17, 2008
*
*-------------------------------------------------------------------------
*/
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 = -1; /* File access property list for data files */
unsigned nerrors = 0; /* Cumulative error count */
int ExpressMode; /* Test express value */
/* Reset library */
h5_reset();
fapl = h5_fileaccess();
ExpressMode = GetTestExpress();
if(ExpressMode > 1)
printf("***Express test mode on. Some tests may be skipped\n");
/* Set the filename to use for this test (dependent on fapl) */
h5_fixname(FILENAME[0], fapl, filename_g, sizeof(filename_g));
/* 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_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++) {
/* 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;
/* An unknown iteration? */
case EARRAY_ITER_NITERS:
default:
goto error;
} /* end switch */
/* Basic capacity tests */
/* Need separate test to read elements from empty array */
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 #0 ("virtual" super block, in index block) */
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + 1), "setting first element of array's 1st data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + cparam.data_blk_min_elmts), "setting all elements of array's 1st data block");
/* Super block #1 ("virtual" super block, in index block) */
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + cparam.data_blk_min_elmts + 1), "setting first element of array's 2nd data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (3 * cparam.data_blk_min_elmts)), "setting all elements of array's 2nd data block");
/* Super block #2 ("virtual" super block, in index block) */
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (3 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 3rd data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (5 * cparam.data_blk_min_elmts)), "setting all elements of array's 3rd data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (5 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 4th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (7 * cparam.data_blk_min_elmts)), "setting all elements of array's 4th data block");
/* Super block #3 ("virtual" super block, in index block) */
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (7 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 5th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (11 * cparam.data_blk_min_elmts)), "setting all elements of array's 5th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (11 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 6th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (15 * cparam.data_blk_min_elmts)), "setting all elements of array's 6th data block");
/* Super block #4 (actual super block, from index block) */
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (15 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 7th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (19 * cparam.data_blk_min_elmts)), "setting all elements of array's 7th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (19 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 8th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (23 * cparam.data_blk_min_elmts)), "setting all elements of array's 8th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (23 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 9th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (27 * cparam.data_blk_min_elmts)), "setting all elements of array's 9th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (27 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 10th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (31 * cparam.data_blk_min_elmts)), "setting all elements of array's 10th data block");
/* Super block #5 (actual super block, from index block) */
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (31 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 11th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (39 * cparam.data_blk_min_elmts)), "setting all elements of array's 11th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (39 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 12th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (47 * cparam.data_blk_min_elmts)), "setting all elements of array's 12th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (47 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 13th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (55 * cparam.data_blk_min_elmts)), "setting all elements of array's 13th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (55 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 14th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (63 * cparam.data_blk_min_elmts)), "setting all elements of array's 14th data block");
/* Super block #6 (actual super block, from index block) */
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (63 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 15th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (71 * cparam.data_blk_min_elmts)), "setting all elements of array's 15th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (71 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 16th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (79 * cparam.data_blk_min_elmts)), "setting all elements of array's 16th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (79 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 17th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (87 * cparam.data_blk_min_elmts)), "setting all elements of array's 17th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (87 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 18th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (95 * cparam.data_blk_min_elmts)), "setting all elements of array's 18th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (95 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 19th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (103 * cparam.data_blk_min_elmts)), "setting all elements of array's 19th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (103 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 20th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (111 * cparam.data_blk_min_elmts)), "setting all elements of array's 20th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (111 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 21st data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (119 * cparam.data_blk_min_elmts)), "setting all elements of array's 21st data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (119 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 22nd data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (127 * cparam.data_blk_min_elmts)), "setting all elements of array's 22nd data block");
/* Super block #7 (actual super block, from index block) */
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (127 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 23rd data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (143 * cparam.data_blk_min_elmts)), "setting all elements of array's 23rd data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (143 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 24th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (159 * cparam.data_blk_min_elmts)), "setting all elements of array's 24th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (159 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 25th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (175 * cparam.data_blk_min_elmts)), "setting all elements of array's 25th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (175 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 26th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (191 * cparam.data_blk_min_elmts)), "setting all elements of array's 26th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (191 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 27th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (207 * cparam.data_blk_min_elmts)), "setting all elements of array's 27th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (207 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 28th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (223 * cparam.data_blk_min_elmts)), "setting all elements of array's 28th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (223 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 29th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (239 * cparam.data_blk_min_elmts)), "setting all elements of array's 29th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (239 * cparam.data_blk_min_elmts) + 1), "setting first element of array's 30th data block");
nerrors += test_set_elmts(fapl, &cparam, &tparam, (hsize_t)(cparam.idx_blk_elmts + (255 * cparam.data_blk_min_elmts)), "setting all elements of array's 30th data block");
} /* end for */
/* Close down testing parameters */
finish_tparam(&tparam);
} /* end for */
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;
return 1;
} /* end main() */
Reference in New Issue View Git Blame Copy Permalink