hdf5_ep

 * 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://support.hdfgroup.org/ftp/HDF5/releases.  *

 * If you do not have access to either file, you may request a copy from     *

 * help@hdfgroup.org.                                                        *

 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

​

/***********************************************************

*

*

* Test the Variable-Length String functionality

*

*************************************************************/

​

#include "testhdf5.h"

​

#define DATAFILE   "tvlstr.h5"

#define DATAFILE2  "tvlstr2.h5"

​

/* 1-D dataset with fixed dimensions */

​

​

/* Definitions for the VL re-writing test */

#define REWRITE_NDATASETS       32

​

/* String for testing attributes */

static const char *string_att = "This is the string for the attribute";

static char *string_att_write=NULL;

​

void *test_vlstr_alloc_custom(size_t size, void *info);

void test_vlstr_free_custom(void *mem, void *info);

​

    /*

     *  This weird contortion is required on the DEC Alpha to keep the

     *  alignment correct - QAK

     */

    extra=MAX(sizeof(void *),sizeof(size_t));

​

    if(_mem!=NULL) {

        mem=((unsigned char *)_mem)-extra;

        HDfree(mem);

    } /* end if */

}

​

/****************************************************************

**

**  test_vlstrings_basic(): Test basic VL string code.

**      Tests simple VL string I/O

**

****************************************************************/

    const char *wdata[SPACE1_DIM1]= {

        "Four score and seven years ago our forefathers brought forth on this continent a new nation,",

        "conceived in liberty and dedicated to the proposition that all men are created equal.",

        "Now we are engaged in a great civil war,",

        "testing whether that nation or any nation so conceived and so dedicated can long endure."

        };   /* Information to write */

    char *rdata[SPACE1_DIM1];   /* Information read in */

    char *wdata2;

    hid_t dataspace, dataset2;

    hid_t       xfer_pid;   /* Dataset transfer property list ID */

    hsize_t     size;       /* Number of bytes which will be used */

    unsigned       i;          /* counting variable */

    size_t         str_used;   /* String data in memory */

    size_t         mem_used=0; /* Memory used during allocation */

​

    /* Output message about test being performed */

    MESSAGE(5, ("Testing Basic VL String Functionality\n"));

​

    /* Create file */

    fid1 = H5Fcreate(DATAFILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);

    CHECK(fid1, FAIL, "H5Fcreate");

​

    /* Create dataspace for datasets */

    sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);

    ret=H5Pset_vlen_mem_manager(xfer_pid,test_vlstr_alloc_custom,&mem_used,test_vlstr_free_custom,&mem_used);

    CHECK(ret, FAIL, "H5Pset_vlen_mem_manager");

​

    /* Make certain the correct amount of memory will be used */

    ret=H5Dvlen_get_buf_size(dataset,tid1,sid1,&size);

    CHECK(ret, FAIL, "H5Dvlen_get_buf_size");

​

    /* Count the actual number of bytes used by the strings */

    for(i=0,str_used=0; i<SPACE1_DIM1; i++)

​

    /* Compare against the strings actually written */

    VERIFY(size,(hsize_t)str_used,"H5Dvlen_get_buf_size");

​

    /* Read dataset from disk */

    ret = H5Dread(dataset, tid1, H5S_ALL, H5S_ALL, xfer_pid, rdata);

    CHECK(ret, FAIL, "H5Dread");

​

    /* Make certain the correct amount of memory has been used */

    VERIFY(mem_used,str_used,"H5Dread");

​

    /* Compare data read in */

    for(i = 0; i < SPACE1_DIM1; i++) {

        if(HDstrlen(wdata[i]) != HDstrlen(rdata[i])) {

            continue;

        } /* end if */

        if(HDstrcmp(wdata[i], rdata[i]) != 0 ) {

            TestErrPrintf("VL data values don't match!, wdata[%d]=%s, rdata[%d]=%s\n",(int)i,wdata[i],(int)i,rdata[i]);

            continue;

        } /* end if */

    } /* end for */

​

    /* Reclaim the read VL data */

    ret = H5Dvlen_reclaim(tid1,sid1,xfer_pid,rdata);

**

****************************************************************/

static void

test_vlstrings_special(void)

{

    const char *wdata[SPACE1_DIM1] = {"", "two", "three", "\0"};

    const char *wdata2[SPACE1_DIM1] = {NULL, NULL, NULL, NULL};

    char *rdata[SPACE1_DIM1];   /* Information read in */

    char *fill;                 /* Fill value */

    unsigned       i;          /* counting variable */

​

    /* Output message about test being performed */

    MESSAGE(5, ("Testing Special VL Strings\n"));

​

    /* Create file */

    fid1 = H5Fcreate(DATAFILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);

    CHECK(fid1, FAIL, "H5Fcreate");

​

    /* Create dataspace for datasets */

    sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);

    CHECK(ret, FAIL, "H5Dwrite");

​

    /* Read dataset from disk */

    ret = H5Dread(dataset, tid1, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata);

    CHECK(ret, FAIL, "H5Dread");

​

    /* Compare data read in */

    for(i = 0; i < SPACE1_DIM1; i++) {

        if(HDstrlen(wdata[i]) != HDstrlen(rdata[i])) {

            continue;

        } /* end if */

        if((wdata[i] == NULL && rdata[i] != NULL) || (rdata[i] == NULL && wdata[i] != NULL)) {

            TestErrPrintf("VL data values don't match!\n");

            continue;

        } /* end if */

        if(HDstrcmp(wdata[i], rdata[i]) != 0 ) {

            TestErrPrintf("VL data values don't match!, wdata[%d]=%s, rdata[%d]=%s\n",(int)i,wdata[i],(int)i,rdata[i]);

            continue;

        } /* end if */

**  test_compact_vlstring(): Test code for storing VL strings in

**      compact datasets.

**

****************************************************************/

static void

test_compact_vlstring(void)

{

    const char *wdata[SPACE1_DIM1] = {"one", "two", "three", "four"};

    char *rdata[SPACE1_DIM1];   /* Information read in */

    unsigned       i;          /* counting variable */

​

    /* Output message about test being performed */

    MESSAGE(5, ("Testing VL Strings in compact dataset\n"));

​

    /* Create file */

    fid1 = H5Fcreate(DATAFILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);

    CHECK(fid1, FAIL, "H5Fcreate");

​

    /* Create dataspace for datasets */

    sid1 = H5Screate_simple(SPACE1_RANK, dims1, NULL);

    CHECK(ret, FAIL, "H5Dwrite");

​

    /* Read dataset from disk */

    ret = H5Dread(dataset, tid1, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata);

    CHECK(ret, FAIL, "H5Dread");

​

    /* Compare data read in */

    for(i = 0; i < SPACE1_DIM1; i++) {

        if(HDstrlen(wdata[i]) != HDstrlen(rdata[i])) {

            continue;

        } /* end if */

        if(HDstrcmp(wdata[i], rdata[i]) != 0) {

            TestErrPrintf("VL data values don't match!, wdata[%d]=%s, rdata[%d]=%s\n",(int)i,wdata[i],(int)i,rdata[i]);

            continue;

        } /* end if */

    } /* end for */

​

    /* Reclaim the read VL data */

    ret = H5Dvlen_reclaim(tid1, sid1, H5P_DEFAULT, rdata);

    ret = H5Dread(dset, type, space, space, H5P_DEFAULT, &data_read);

    CHECK(ret, FAIL, "H5Dread");

​

    ret = H5Dclose(dset);

    CHECK(ret, FAIL, "H5Dclose");

​

    if(HDstrcmp(data, data_read))

        TestErrPrintf("Expected %s for dataset %s but read %s\n", data, name, data_read);

​

}

​

/****************************************************************

**

**  test_vl_rewrite(): Test basic VL string code.

**      Tests I/O on VL strings when lots of objects in the file

**      have been linked/unlinked.

**

****************************************************************/

static void test_vl_rewrite(void)

    /* Open the files */

    file1 = H5Fcreate(DATAFILE, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);

    CHECK(file1, FAIL, "H5Fcreate");

​

    file2 = H5Fcreate(DATAFILE2, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);

    CHECK(file1, FAIL, "H5Fcreate");

​

    /* Create in file 1 */

    for(i=0; i<REWRITE_NDATASETS; i++) {

        write_scalar_dset(file1, type, space, name, name);

    }

​

    /* Effectively copy data from file 1 to 2 */

    for(i=0; i<REWRITE_NDATASETS; i++) {

        read_scalar_dset(file1, type, space, name, name);

        write_scalar_dset(file2, type, space, name, name);

    }

​

    /* Read back from file 2 */

    for(i = 0; i < REWRITE_NDATASETS; i++) {

        read_scalar_dset(file2, type, space, name, name);

    } /* end for */

​

    /* Remove from file 2. */

    for(i = 0; i < REWRITE_NDATASETS; i++) {

        ret = H5Ldelete(file2, name, H5P_DEFAULT);

        CHECK(ret, FAIL, "H5Ldelete");

    } /* end for */

​

    /* Effectively copy from file 1 to file 2 */

    for(i = 0; i < REWRITE_NDATASETS; i++) {

        read_scalar_dset(file1, type, space, name, name);

        write_scalar_dset(file2, type, space, name, name);

    } /* end for */

​

    /* Close everything */

    ret = H5Tclose(type);

    CHECK(ret, FAIL, "H5Tclose");

​

    ret = H5Sclose(space);

    CHECK(ret, FAIL, "H5Sclose");

​

    /* Test using VL strings in attributes */

    test_write_vl_string_attribute();

    test_read_vl_string_attribute();

​

    /* Test writing VL datasets in files with lots of unlinking */

    test_vl_rewrite();

}   /* test_vlstrings() */

​

/*-------------------------------------------------------------------------

 *

 *

 *

 *              September 10, 1999

 *

 * Modifications:

 *

 *-------------------------------------------------------------------------

 */

void

cleanup_vlstrings(void)

{

    HDremove(DATAFILE);