/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * 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://support.hdfgroup.org/ftp/HDF5/releases.  *
 * If you do not have access to either file, you may request a copy from     *
 * help@hdfgroup.org.                                                        *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*
 * Purpose:    Tests the plugin module (H5PL)
 */

#include "h5test.h"
#include "H5srcdir.h"

/*
 * This file needs to access private datatypes from the H5Z and H5PL package.
 */
#define H5PL_FRIEND
#include "H5PLpkg.h"
#define H5Z_FRIEND
#include "H5Zpkg.h"

/* Filters for HDF5 internal test */
#define H5Z_FILTER_DYNLIB1      257
#define H5Z_FILTER_DYNLIB2      258
#define H5Z_FILTER_DYNLIB3      259
#define H5Z_FILTER_DYNLIB4      260

const char *FILENAME[] = {
    "plugin",
    NULL
};
#define FILENAME_BUF_SIZE       1024

/* Dataset names for testing filters */
#define DSET_DEFLATE_NAME    "deflate"
#define DSET_DYNLIB1_NAME    "dynlib1"
#define DSET_DYNLIB2_NAME    "dynlib2"
#define DSET_DYNLIB4_NAME    "dynlib4"

/* Parameters for internal filter test */
#define FILTER_CHUNK_DIM1       2
#define FILTER_CHUNK_DIM2       25
#define FILTER_HS_OFFSET1       7
#define FILTER_HS_OFFSET2       30
#define FILTER_HS_SIZE1         4
#define FILTER_HS_SIZE2         50

/* Shared global arrays */
#define DSET_DIM1       100
#define DSET_DIM2       200

/* Limit random number within 20000 */
#define RANDOM_LIMIT    20000

#define GROUP_ITERATION 1000

int    points_deflate[DSET_DIM1][DSET_DIM2],
       points_dynlib1[DSET_DIM1][DSET_DIM2],
       points_dynlib2[DSET_DIM1][DSET_DIM2],
       points_dynlib4[DSET_DIM1][DSET_DIM2],
       points_bzip2[DSET_DIM1][DSET_DIM2];


/*-------------------------------------------------------------------------
 * Function:  test_filter_internal
 *
 * Purpose:   Tests writing entire data and partial data with filters
 *
 * Return:    Success:    0
 *            Failure:    -1
 *-------------------------------------------------------------------------
 */
static herr_t
test_filter_internal(hid_t fid, const char *name, hid_t dcpl)
{
    herr_t       ret_value = -1;
    hid_t        dataset = -1;          /* Dataset ID */
    hid_t        dxpl = -1;             /* Dataset xfer property list ID */
    hid_t        write_dxpl = -1;       /* Dataset xfer property list ID for writing */
    hid_t        sid = -1;              /* Dataspace ID */
    const hsize_t    size[2] = {DSET_DIM1, DSET_DIM2};                      /* Dataspace dimensions */
    const hsize_t    hs_offset[2] = {FILTER_HS_OFFSET1, FILTER_HS_OFFSET2}; /* Hyperslab offset */
    const hsize_t    hs_size[2] = {FILTER_HS_SIZE1, FILTER_HS_SIZE2};       /* Hyperslab size */
    void        *tconv_buf = NULL;      /* Temporary conversion buffer */
    int          points[DSET_DIM1][DSET_DIM2], check[DSET_DIM1][DSET_DIM2];
    size_t       i, j;                  /* Local index variables */
    int          n = 0;

    /* Create the data space */
    if((sid = H5Screate_simple(2, size, NULL)) < 0) TEST_ERROR

    /*
     * Create a small conversion buffer to test strip mining. We
     * might as well test all we can!
     */
    if((dxpl = H5Pcreate(H5P_DATASET_XFER)) < 0) TEST_ERROR
    tconv_buf = HDmalloc((size_t)1000);
    if(H5Pset_buffer(dxpl, (size_t)1000, tconv_buf, NULL) < 0) TEST_ERROR
    if((write_dxpl = H5Pcopy(dxpl)) < 0) TEST_ERROR;

    TESTING("    filters (setup)");

    /* Check if all the filters are available */
    if(H5Pall_filters_avail(dcpl) != TRUE) {
        H5_FAILED();
        HDprintf("    Line %d: Incorrect filter availability\n", __LINE__);
        TEST_ERROR
    } /* end if */

    /* Create the dataset */
    if((dataset = H5Dcreate2(fid, name, H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl, H5P_DEFAULT)) < 0) TEST_ERROR

    PASSED();

    /*----------------------------------------------------------------------
     * STEP 1: Read uninitialized data.  It should be zero.
     *----------------------------------------------------------------------
     */
    TESTING("    filters (uninitialized read)");

    if(H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, check) < 0) TEST_ERROR;

    for(i=0; i<(size_t)size[0]; i++)
        for(j=0; j<(size_t)size[1]; j++)
            if(0 != check[i][j]) {
                H5_FAILED();
                HDprintf("    Read a non-zero value.\n");
                HDprintf("    At index %lu,%lu\n", (unsigned long)i, (unsigned long)j);
                TEST_ERROR
            } /* end if */
    PASSED();

    /*----------------------------------------------------------------------
     * STEP 2: Test filters by setting up a chunked dataset and writing
     * to it.
     *----------------------------------------------------------------------
     */
    TESTING("    filters (write)");

    n = 0;
    for(i=0; i<size[0]; i++)
        for(j=0; j<size[1]; j++)
            points[i][j] = (int)(n++);

    if(H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, write_dxpl, points) < 0) TEST_ERROR;

    PASSED();

    /*----------------------------------------------------------------------
     * STEP 3: Try to read the data we just wrote.
     *----------------------------------------------------------------------
     */
    TESTING("    filters (read)");

    /* Read the dataset back */
    if(H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, check) < 0) TEST_ERROR;

    /* Check that the values read are the same as the values written */
    for(i=0; i<size[0]; i++)
        for(j=0; j<size[1]; j++)
            if(points[i][j] != check[i][j]) {
                H5_FAILED();
                HDfprintf(stderr,"    Read different values than written.\n");
                HDfprintf(stderr,"    At index %lu,%lu\n", (unsigned long)i, (unsigned long)j);
                HDfprintf(stderr,"    At original: %d\n", (int)points[i][j]);
                HDfprintf(stderr,"    At returned: %d\n", (int)check[i][j]);
                TEST_ERROR
            } /* end if */

    PASSED();

    /*----------------------------------------------------------------------
     * STEP 4: Write new data over the top of the old data.  The new data is
     * random thus not very compressible, and will cause the chunks to move
     * around as they grow.  We only change values for the left half of the
     * dataset although we rewrite the whole thing.
     *----------------------------------------------------------------------
     */
    TESTING("    filters (modify)");

    for(i=0; i<size[0]; i++)
        for(j=0; j<size[1]/2; j++)
            points[i][j] = (int)HDrandom () % RANDOM_LIMIT;

    if(H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, write_dxpl, points) < 0) TEST_ERROR;

    /* Read the dataset back and check it */
    if(H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, check) < 0) TEST_ERROR;

    /* Check that the values read are the same as the values written */
    for(i=0; i<size[0]; i++)
        for(j=0; j<size[1]; j++)
            if(points[i][j] != check[i][j]) {
                H5_FAILED();
                HDprintf("    Read different values than written.\n");
                HDprintf("    At index %lu,%lu\n", (unsigned long)i, (unsigned long)j);
                TEST_ERROR
            } /* end if */

    PASSED();

    /*----------------------------------------------------------------------
     * STEP 5: Close the dataset and then open it and read it again.  This
     * insures that the filters message is picked up properly from the
     * object header.
     *----------------------------------------------------------------------
     */
    TESTING("    filters (re-open)");

    if(H5Dclose(dataset) < 0) TEST_ERROR;
    if((dataset = H5Dopen2(fid, name, H5P_DEFAULT)) < 0) TEST_ERROR;

    if(H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl, check) < 0) TEST_ERROR;

    /* Check that the values read are the same as the values written */
    for(i = 0; i < size[0]; i++)
        for(j = 0; j < size[1]; j++)
            if(points[i][j] != check[i][j]) {
                H5_FAILED();
                HDprintf("    Read different values than written.\n");
                HDprintf("    At index %lu,%lu\n", (unsigned long)i, (unsigned long)j);
                TEST_ERROR
            } /* end if */

    PASSED();

    /*----------------------------------------------------------------------
     * STEP 6: Test partial I/O by writing to and then reading from a
     * hyperslab of the dataset.  The hyperslab does not line up on chunk
     * boundaries (we know that case already works from above tests).
     *----------------------------------------------------------------------
     */
    TESTING("    filters (partial I/O)");

    for(i=0; i<(size_t)hs_size[0]; i++)
        for(j=0; j<(size_t)hs_size[1]; j++)
            points[(size_t)hs_offset[0]+i][(size_t)hs_offset[1]+j] = (int)HDrandom() % RANDOM_LIMIT;

    if(H5Sselect_hyperslab(sid, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL) < 0) TEST_ERROR;
    /* (Use the "read" DXPL because partial I/O on corrupted data test needs to ignore errors during writing) */
    if(H5Dwrite(dataset, H5T_NATIVE_INT, sid, sid, dxpl, points) < 0) TEST_ERROR;

    if(H5Dread(dataset, H5T_NATIVE_INT, sid, sid, dxpl, check) < 0) TEST_ERROR;

    /* Check that the values read are the same as the values written */
    for(i=0; i<(size_t)hs_size[0]; i++)
        for(j=0; j<(size_t)hs_size[1]; j++)
            if(points[(size_t)hs_offset[0]+i][(size_t)hs_offset[1]+j] != check[(size_t)hs_offset[0]+i][(size_t)hs_offset[1]+j]) {
                H5_FAILED();
                HDfprintf(stderr,"    Read different values than written.\n");
                HDfprintf(stderr,"    At index %lu,%lu\n", (unsigned long)((size_t)hs_offset[0]+i), (unsigned long)((size_t)hs_offset[1]+j));
                HDfprintf(stderr,"    At original: %d\n", (int)points[(size_t)hs_offset[0]+i][(size_t)hs_offset[1]+j]);
                HDfprintf(stderr,"    At returned: %d\n", (int)check[(size_t)hs_offset[0]+i][(size_t)hs_offset[1]+j]);
                TEST_ERROR
            } /* end if */

    PASSED();

    /* Save the data written to the file for later comparison when the file
     * is reopened for read test */
    for(i=0; i<size[0]; i++)
        for(j=0; j<size[1]; j++)
            if(!HDstrcmp(name, DSET_DEFLATE_NAME))
                points_deflate[i][j] = points[i][j];
            else if(!HDstrcmp(name, DSET_DYNLIB1_NAME))
                points_dynlib1[i][j] = points[i][j];
            else if(!HDstrcmp(name, DSET_DYNLIB2_NAME))
                points_dynlib2[i][j] = points[i][j];
            else if(!HDstrcmp(name, DSET_DYNLIB4_NAME))
                points_dynlib4[i][j] = points[i][j];

    ret_value = 0;

error:
    /* Clean up objects used for this test */
    H5E_BEGIN_TRY {
        H5Dclose(dataset);
        H5Sclose(sid);
        H5Pclose(dxpl);
    } H5E_END_TRY

    if(tconv_buf)
        HDfree(tconv_buf);
    return ret_value;
}

/*-------------------------------------------------------------------------
 * Function:  test_filters_for_datasets
 *
 * Purpose:   Tests creating datasets and writing data with dynamically loaded filters
 *
 * Return:    Success:    0
 *            Failure:    -1
 *-------------------------------------------------------------------------
 */
static herr_t
test_filters_for_datasets(hid_t file)
{
    herr_t           ret_value = -1;
    hid_t            dc = -1;    /* Dataset creation property list ID */
    const hsize_t    chunk_size[2] = {FILTER_CHUNK_DIM1, FILTER_CHUNK_DIM2};  /* Chunk dimensions */
    unsigned int     compress_level = 9;
    unsigned int     dynlib4_values[4];

    /*----------------------------------------------------------
     * STEP 1: Test deflation by itself.
     *----------------------------------------------------------
     */
    HDputs("Testing deflate filter");
#ifdef H5_HAVE_FILTER_DEFLATE
    if((dc = H5Pcreate(H5P_DATASET_CREATE)) < 0) TEST_ERROR
    if(H5Pset_chunk(dc, 2, chunk_size) < 0) TEST_ERROR
    if(H5Pset_deflate(dc, 6) < 0) TEST_ERROR

    if(test_filter_internal(file, DSET_DEFLATE_NAME, dc) < 0) TEST_ERROR
    /* Clean up objects used for this test */
    if(H5Pclose(dc) < 0) TEST_ERROR
#else /* H5_HAVE_FILTER_DEFLATE */
    SKIPPED();
    HDputs("    Deflate filter not enabled");
#endif /* H5_HAVE_FILTER_DEFLATE */

    /*----------------------------------------------------------
     * STEP 2: Test DYNLIB1 by itself.
     *----------------------------------------------------------
     */
    HDputs("    DYNLIB1 filter");
    if((dc = H5Pcreate(H5P_DATASET_CREATE)) < 0) TEST_ERROR
    if(H5Pset_chunk(dc, 2, chunk_size) < 0) TEST_ERROR
    if(H5Pset_filter(dc, H5Z_FILTER_DYNLIB1, H5Z_FLAG_MANDATORY, (size_t)1, &compress_level) < 0) TEST_ERROR

    if(test_filter_internal(file, DSET_DYNLIB1_NAME, dc) < 0) TEST_ERROR

    /* Clean up objects used for this test */
    if(H5Pclose(dc) < 0) TEST_ERROR

    /* Unregister the dynamic filter DYNLIB1 for testing purpose. The next time when this test is run for
     * the new file format, the library's H5PL code has to search in the table of loaded plugin libraries
     * for this filter. */
    if(H5Zunregister(H5Z_FILTER_DYNLIB1) < 0) TEST_ERROR

    /*----------------------------------------------------------
     * STEP 3: Test DYNLIB2 by itself.
     *----------------------------------------------------------
     */
    HDputs("    DYNLIB2 filter");
    if((dc = H5Pcreate(H5P_DATASET_CREATE)) < 0) TEST_ERROR
    if(H5Pset_chunk(dc, 2, chunk_size) < 0) TEST_ERROR
    if(H5Pset_filter(dc, H5Z_FILTER_DYNLIB2, H5Z_FLAG_MANDATORY, 0, NULL) < 0) TEST_ERROR

    if(test_filter_internal(file,DSET_DYNLIB2_NAME,dc) < 0) TEST_ERROR

    /* Clean up objects used for this test */
    if(H5Pclose(dc) < 0) TEST_ERROR

    /* Unregister the dynamic filter DYNLIB2 for testing purpose. The next time when this test is run for
     * the new file format, the library's H5PL code has to search in the table of loaded plugin libraries
     * for this filter. */
    if(H5Zunregister(H5Z_FILTER_DYNLIB2) < 0) TEST_ERROR

    /*----------------------------------------------------------
     * STEP 4: Test DYNLIB4 by itself.
     *----------------------------------------------------------
     */
    HDputs("    DYNLIB4 filter");
    if((dc = H5Pcreate(H5P_DATASET_CREATE)) < 0) TEST_ERROR
    if(H5Pset_chunk(dc, 2, chunk_size) < 0) TEST_ERROR
    dynlib4_values[0] = 9;
    if(H5get_libversion(&dynlib4_values[1], &dynlib4_values[2], &dynlib4_values[3]) < 0) TEST_ERROR
    if(H5Pset_filter(dc, H5Z_FILTER_DYNLIB4, H5Z_FLAG_MANDATORY, (size_t)4, dynlib4_values) < 0) TEST_ERROR

    if(test_filter_internal(file, DSET_DYNLIB4_NAME, dc) < 0) TEST_ERROR

    /* Clean up objects used for this test */
    if(H5Pclose(dc) < 0) TEST_ERROR

    /* Unregister the dynamic filter DYNLIB4 for testing purpose. The next time when this test is run for
     * the new file format, the library's H5PL code has to search in the table of loaded plugin libraries
     * for this filter. */
    if(H5Zunregister(H5Z_FILTER_DYNLIB4) < 0) TEST_ERROR

    ret_value = 0;

error:
    /* Clean up objects used for this test */
    H5E_BEGIN_TRY {
        H5Pclose(dc);
    } H5E_END_TRY

    return ret_value;
}

/*-------------------------------------------------------------------------
 * Function:  test_read_data
 *
 * Purpose:   Tests reading data and compares values
 *
 * Return:    Success:    0
 *            Failure:    -1
 *-------------------------------------------------------------------------
 */
static herr_t
test_read_data(hid_t dataset, int *origin_data)
{
    herr_t        ret_value = -1;
    int           check[DSET_DIM1][DSET_DIM2];
    const hsize_t size[2] = {DSET_DIM1, DSET_DIM2};   /* Dataspace dimensions */
    int          *data_p = origin_data;
    size_t        i, j;        /* Local index variables */

    /* Read the dataset back */
    if(H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, check) < 0) TEST_ERROR;

    /* Check that the values read are the same as the values written */
    for(i=0; i<size[0]; i++)
        for(j=0; j<size[1]; j++) {
            if(*data_p != check[i][j]) {
                H5_FAILED();
                HDfprintf(stderr,"    Read different values than written.\n");
                HDfprintf(stderr,"    At index %lu,%lu\n", (unsigned long)i, (unsigned long)j);
                HDfprintf(stderr,"    At original: %d\n", *data_p);
                HDfprintf(stderr,"    At returned: %d\n", (int)check[i][j]);
                TEST_ERROR
            } /* end if */
           data_p++;
        }

    PASSED();
    ret_value = 0;

error:
    return ret_value;
}

/*-------------------------------------------------------------------------
 * Function:  test_read_with_filters
 *
 * Purpose:   Tests reading dataset created with dynamically loaded filters
 *
 * Return:    Success:    0
 *            Failure:    -1
 *-------------------------------------------------------------------------
 */
static herr_t
test_read_with_filters(hid_t file)
{
    herr_t  ret_value = -1;
    hid_t   dset = -1;                 /* Dataset ID */

    /*----------------------------------------------------------
     * STEP 1: Test deflation by itself.
     *----------------------------------------------------------
     */
    TESTING("deflate filter");

#ifdef H5_HAVE_FILTER_DEFLATE
    if(H5Zfilter_avail(H5Z_FILTER_DEFLATE) != TRUE) TEST_ERROR

    if((dset = H5Dopen2(file,DSET_DEFLATE_NAME,H5P_DEFAULT)) < 0) TEST_ERROR

    if(test_read_data(dset, (int *)points_deflate) < 0) TEST_ERROR

    if(H5Dclose(dset) < 0) TEST_ERROR

    /* Clean up objects used for this test */
#else /* H5_HAVE_FILTER_DEFLATE */
    SKIPPED();
    HDputs("    Deflate filter not enabled");
#endif /* H5_HAVE_FILTER_DEFLATE */

    /*----------------------------------------------------------
     * STEP 2: Test DYNLIB1 by itself.
     *----------------------------------------------------------
     */
    TESTING("    DYNLIB1 filter");

    if((dset = H5Dopen2(file, DSET_DYNLIB1_NAME, H5P_DEFAULT)) < 0) TEST_ERROR

    if(test_read_data(dset, (int *)points_dynlib1) < 0) TEST_ERROR

    if(H5Dclose(dset) < 0) TEST_ERROR

    /*----------------------------------------------------------
     * STEP 3: Test Bogus2 by itself.
     *----------------------------------------------------------
     */
    TESTING("    DYNLIB2 filter");

    if((dset = H5Dopen2(file, DSET_DYNLIB2_NAME, H5P_DEFAULT)) < 0) TEST_ERROR

    if(test_read_data(dset, (int *)points_dynlib2) < 0) TEST_ERROR

    if(H5Dclose(dset) < 0) TEST_ERROR

    /*----------------------------------------------------------
     * STEP 4: Test DYNLIB4 by itself.
     *----------------------------------------------------------
     */
    TESTING("    DYNLIB4 filter");

    if((dset = H5Dopen2(file,DSET_DYNLIB4_NAME,H5P_DEFAULT)) < 0) TEST_ERROR

    if(test_read_data(dset, (int *)points_dynlib4) < 0) TEST_ERROR

    if(H5Dclose(dset) < 0) TEST_ERROR

    ret_value = 0;

error:
    /* Clean up objects used for this test */
    H5E_BEGIN_TRY {
        H5Dclose(dset);
    } H5E_END_TRY

    return ret_value;
}

/*-------------------------------------------------------------------------
 * Function:  test_noread_data
 *
 * Purpose:   Tests not reading data
 *
 * Return:    Success:    0
 *            Failure:    -1
 *
 *-------------------------------------------------------------------------
 */
static herr_t
test_noread_data(hid_t dataset)
{
    herr_t     ret_value = -1;
    int        check[DSET_DIM1][DSET_DIM2];
    herr_t     ret = -1;

    /* Read the dataset back */
    H5E_BEGIN_TRY {
        ret = H5Dread(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, check);
    } H5E_END_TRY
    if(ret >= 0)
        TEST_ERROR

    PASSED();
    ret_value = 0;

error:
    return ret_value;
}

/*-------------------------------------------------------------------------
 * Function:  test_noread_with_filters
 *
 * Purpose:   Tests reading dataset created with dynamically loaded filters disabled
 *
 * Return:    Success:    0
 *            Failure:    -1
 *-------------------------------------------------------------------------
 */
static herr_t
test_noread_with_filters(hid_t file)
{
    herr_t      ret_value = -1;
    hid_t       dset = -1;            /* Dataset ID */
    unsigned    plugin_state;         /* status of plugins */

    TESTING("DYNLIB1 filter with plugins disabled");

    /* disable filter plugin */
    if(H5PLget_loading_state(&plugin_state) < 0) TEST_ERROR

    plugin_state = plugin_state & (unsigned)(~H5PL_FILTER_PLUGIN);

    if(H5PLset_loading_state(plugin_state) < 0) TEST_ERROR

    if((dset = H5Dopen2(file, DSET_DYNLIB1_NAME, H5P_DEFAULT)) < 0) TEST_ERROR

    if(test_noread_data(dset) < 0) TEST_ERROR

    if(H5Dclose(dset) < 0) TEST_ERROR

    ret_value = 0;

error:
    /* re-enable filter plugin */
    plugin_state = plugin_state | H5PL_FILTER_PLUGIN;
    H5PLset_loading_state(plugin_state);

    /* Clean up objects used for this test */
    H5E_BEGIN_TRY {
        H5Dclose(dset);
    } H5E_END_TRY

    return ret_value;
}

/*-------------------------------------------------------------------------
 * Function:  test_filters_for_groups
 *
 * Purpose:   Tests creating group with dynamically loaded filters
 *
 * Return:    Success:    0
 *            Failure:    -1
 *-------------------------------------------------------------------------
 */
static herr_t
test_filters_for_groups(hid_t file)
{
    herr_t   ret_value = -1;
    hid_t    gcpl = -1;
    hid_t    gid = -1;
    hid_t    group = -1;
    int      i;
    char     gname[256];

    TESTING("DYNLIB3 filter for group");

    if((gcpl = H5Pcreate(H5P_GROUP_CREATE)) < 0) TEST_ERROR

    /* Use DYNLIB3 for creating groups */
    if(H5Pset_filter (gcpl, H5Z_FILTER_DYNLIB3, H5Z_FLAG_MANDATORY, (size_t)0, NULL) < 0) TEST_ERROR

    /* Create a group using this filter */
    if((gid = H5Gcreate2(file, "group1", H5P_DEFAULT, gcpl, H5P_DEFAULT)) < 0) TEST_ERROR

    /* Create multiple groups under "group1" */
    for(i=0; i < GROUP_ITERATION; i++) {
        HDsprintf(gname, "group_%d", i);
        if((group = H5Gcreate2(gid, gname, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) TEST_ERROR
        if(H5Gclose(group) < 0) TEST_ERROR
    }

    /* Close the group */
    if(H5Gclose(gid) < 0) TEST_ERROR

    /* Clean up objects used for this test */
    if(H5Pclose(gcpl) < 0) TEST_ERROR

    PASSED();

    ret_value = 0;

error:
    /* Clean up objects used for this test */
    H5E_BEGIN_TRY {
        H5Gclose(group);
        H5Gclose(gid);
        H5Pclose(gcpl);
    } H5E_END_TRY

    return ret_value;
}

/*-------------------------------------------------------------------------
 * Function:    test_groups_with_filters
 *
 * Purpose:     Tests opening group with dynamically loaded filters
 *
 * Return:      Success:    0
 *              Failure:    -1
 *
 *-------------------------------------------------------------------------
 */
static herr_t
test_groups_with_filters(hid_t file)
{
    herr_t      ret_value = -1;
    hid_t       gid = -1;
    hid_t       group = -1;
    int         i;
    char        gname[256];

    TESTING("opening groups with DYNLIB3 filter");

    /* Open the top group */
    if((gid = H5Gopen2(file, "group1", H5P_DEFAULT)) < 0) TEST_ERROR

    /* Create multiple groups under "group1" */
    for(i=0; i < GROUP_ITERATION; i++) {
        HDsprintf(gname, "group_%d", i);
        if((group = H5Gopen2(gid, gname, H5P_DEFAULT)) < 0) TEST_ERROR
        if(H5Gclose(group) < 0) TEST_ERROR
    }

    /* Close the group */
    if(H5Gclose(gid) < 0) TEST_ERROR

    PASSED();

    ret_value = 0;

error:
    /* Clean up objects used for this test */
    H5E_BEGIN_TRY {
        H5Gclose(group);
        H5Gclose(gid);
    } H5E_END_TRY

    return ret_value;
}


/*-------------------------------------------------------------------------
 * Function:  test_path_api_calls
 *
 * Purpose:   Tests the H5PL API calls that manipulate the plugin search
 *            paths.
 *
 * Return:    SUCCEED/FAIL
 * 
 *-------------------------------------------------------------------------
 */
static herr_t
test_path_api_calls(void)
{
    unsigned int n_starting_paths;
    unsigned int u;                 
    unsigned int n_paths;
    herr_t       ret;
    ssize_t      path_len = -1;
    char         path[256];
    char         temp_name[256];

    HDputs("Testing access to the filter path table");

    if(H5Zfilter_avail(H5Z_FILTER_DYNLIB1) != TRUE)
        TEST_ERROR

    /* Set the number of paths to create for this test.
     *
     * This should be set high enough to ensure that at least one array
     * expansion will take place. See H5PLpath.c for details.
     */
    n_starting_paths = 42;

    /* Check that initialization is correct */
    TESTING("    initialize");

    if(H5PLsize(&n_paths) < 0)
        TEST_ERROR
    if(n_paths != 2)
        TEST_ERROR

    PASSED();

    /****************/
    /* H5PLremove() */
    /****************/

    /* Remove all the current paths */
    TESTING("    remove");

    /* Get the current size */
    if(H5PLsize(&n_paths) < 0)
        TEST_ERROR

    /* Remove all existing paths */
    for(u = n_paths; u > 0; u--)
        if(H5PLremove(u-1) < 0) {
            HDfprintf(stderr,"    at %u: %s\n", u, path);
            TEST_ERROR
        }

    /* Verify the table is empty */
    if(H5PLsize(&n_paths) < 0)
        TEST_ERROR
    if(n_paths > 0)
        TEST_ERROR

    PASSED();


    TESTING("    remove (index 0 in empty table)");

    /* Try to remove index zero in an empty list (SHOULD FAIL) */
    H5E_BEGIN_TRY {
        ret = H5PLremove(0);
    } H5E_END_TRY
    if(ret >= 0)
        TEST_ERROR

    PASSED();


    /****************/
    /* H5PLappend() */
    /****************/

    TESTING("    append");

    /* Add a bunch of paths to the path table */
    for(u = 0; u < n_starting_paths; u++) {
        HDsprintf(path, "a_path_%u", u);
        if(H5PLappend(path) < 0) {
            HDfprintf(stderr,"    at %u: %s\n", u, path);
            TEST_ERROR
        }
    }

    PASSED();


    /**********************/
    /* H5PLremove() again */
    /**********************/

    TESTING("    remove (index too high)");

    /* Try to remove a path where the index is beyond the table capacity (SHOULD FAIL) */
    H5E_BEGIN_TRY {
        ret = H5PLremove(n_starting_paths);
    } H5E_END_TRY

    if(ret >= 0)
        TEST_ERROR

    PASSED();


    /*************/
    /* H5PLget() */
    /*************/

    TESTING("    get (path name)");

    /* Get the path length by passing in NULL */
    if((path_len = H5PLget(0, NULL, 0)) <= 0) {
        HDfprintf(stderr,"    get path 0 length failed\n");
        TEST_ERROR
    }
    if(path_len != 8)
        TEST_ERROR

    /* Get the path */
    if((path_len = H5PLget(0, path, 256)) <= 0) {
        HDfprintf(stderr,"    get 0 len: %u : %s\n", path_len, path);
        TEST_ERROR
    }
    if(HDstrcmp(path, "a_path_0") != 0) {
        HDfprintf(stderr,"    get 0: %s\n", path);
        TEST_ERROR
    }

    PASSED();


    TESTING("    get (high and low indices)");

    /* Get path at index 1 */
    if((path_len = H5PLget(1, path, 256)) <= 0)
        TEST_ERROR
    if(HDstrcmp(path, "a_path_1") != 0) {
        HDfprintf(stderr,"    get 1: %s\n", path);
        TEST_ERROR
    }

    /* Get path at the last index */
    if((path_len = H5PLget(n_starting_paths - 1, path, 256)) <= 0)
        TEST_ERROR
    HDsprintf(temp_name, "a_path_%u", n_starting_paths - 1);
    if(HDstrcmp(path, temp_name) != 0) {
        HDfprintf(stderr,"    get %u: %s\n", n_starting_paths - 1, path);
        TEST_ERROR
    }

    PASSED();


    TESTING("    get (index too high)");

    /* Get path at the last + 1 index (SHOULD FAIL) */
    H5E_BEGIN_TRY {
        path_len = H5PLget(n_starting_paths, NULL, 0);
    } H5E_END_TRY
    if(path_len > 0)
        TEST_ERROR

    PASSED();


    /*****************/
    /* H5PLprepend() */
    /*****************/

    /* We'll remove a path at an arbitrary index and then
     * prepend a new path.
     */

    TESTING("    remove (arbitrary index 1)");

    /* Remove one path */
    if(H5PLremove(8) < 0)
        TEST_ERROR

    /* Verify that the entries were moved */
    if((path_len = H5PLget(8, path, 256)) <= 0)
        TEST_ERROR
    if(HDstrcmp(path, "a_path_9") != 0) {
        HDfprintf(stderr,"    get 8: %s\n", path);
        TEST_ERROR
    }

    /* Verify the table shrank */
    if(H5PLsize(&n_paths) < 0)
        TEST_ERROR
    if(n_paths != n_starting_paths - 1)
        TEST_ERROR

    PASSED();


    TESTING("    prepend");

    /* Prepend one path */
    HDsprintf(path, "a_path_%d", n_starting_paths + 1);
    if(H5PLprepend(path) < 0) {
        HDfprintf(stderr,"    prepend %u: %s\n", n_starting_paths + 1, path);
        TEST_ERROR
    }

    /* Verify the table increased */
    if(H5PLsize(&n_paths) < 0)
        TEST_ERROR
    if(n_paths != n_starting_paths)
        TEST_ERROR

    /* Verify that the entries were moved */
    if(H5PLget(8, path, 256) <= 0)
        TEST_ERROR
    if(HDstrcmp(path, "a_path_7") != 0) {
        HDfprintf(stderr,"    get 8: %s\n", path);
        TEST_ERROR
    }

    /* Verify that the path was inserted at index zero */
    if(H5PLget(0, path, 256) <= 0)
        TEST_ERROR
    HDsprintf(temp_name, "a_path_%d", n_starting_paths + 1);
    if(HDstrcmp(path, temp_name) != 0) {
        HDfprintf(stderr,"    get 0: %s\n", path);
        TEST_ERROR
    }

    PASSED();


    /*****************/
    /* H5PLreplace() */
    /*****************/

    TESTING("    replace");

    /* Replace one path at index 1 */
    HDsprintf(path, "a_path_%u", n_starting_paths + 4);
    if(H5PLreplace(path, 1) < 0) {
        HDfprintf(stderr,"    replace 1: %s\n", path);
        TEST_ERROR
    }

    /* Verify the table size remained the same */
    if(H5PLsize(&n_paths) < 0)
        TEST_ERROR
    if(n_paths != n_starting_paths)
        TEST_ERROR

    /* Verify that the entries were not moved by
     * inspecting the paths at indices +/- 1.
     */

    /* Check path at index 0 */
    if(H5PLget(0, path, 256) <= 0)
        TEST_ERROR
    HDsprintf(temp_name, "a_path_%u", n_starting_paths + 1);
    if(HDstrcmp(path, temp_name) != 0) {
        HDfprintf(stderr,"    get 0: %s\n", path);
        TEST_ERROR
    }

    /* Check path at index 2 */
    if(H5PLget(2, path, 256) <= 0)
        TEST_ERROR
    if(HDstrcmp(path, "a_path_1") != 0) {
        HDfprintf(stderr,"    get 2: %s\n", path);
        TEST_ERROR
    }

    PASSED();


    /****************/
    /* H5PLinsert() */
    /****************/

    /* We'll remove a path at an arbitrary index and then
     * insert a new path.
     */

    TESTING("    remove (arbitrary index 2)");

    /* Remove one path */
    if(H5PLremove(4) < 0)
        TEST_ERROR

    /* Verify that the entries were moved */
    if(H5PLget(4, path, 256) <= 0)
        TEST_ERROR
    if(HDstrcmp(path, "a_path_4") != 0) {
        HDfprintf(stderr,"    get 4: %s\n", path);
        TEST_ERROR
    }

    /* Verify the table size */
    if(H5PLsize(&n_paths) < 0)
        TEST_ERROR
    if(n_paths != n_starting_paths - 1)
        TEST_ERROR
    PASSED();


    TESTING("    insert");

    /* Insert one path at index 3*/
    HDsprintf(path, "a_path_%d", n_starting_paths + 5);
    if(H5PLinsert(path, 3) < 0) {
        HDfprintf(stderr,"    insert 3: %s\n", path);
        TEST_ERROR
    }

    /* Verify that the entries were moved */
    if(H5PLget(4, path, 256) <= 0)
        TEST_ERROR
    if(HDstrcmp(path, "a_path_2") != 0) {
        HDfprintf(stderr,"    get 4: %s\n", path);
        TEST_ERROR
    }

    /* Verify the table size increased */
    if(H5PLsize(&n_paths) < 0)
        TEST_ERROR
    if(n_paths != n_starting_paths)
        TEST_ERROR

    PASSED();


    /****************/
    /* H5PLremove() */
    /****************/

    /* Remove all the current paths */
    TESTING("    remove (all)");

    /* Get the current size */
    if(H5PLsize(&n_paths) < 0)
        TEST_ERROR

    /* Remove all existing paths */
    for(u = n_paths; u > 0; u--)
        if(H5PLremove(u-1) < 0) {
            HDfprintf(stderr,"    at %u: %s\n", u, path);
            TEST_ERROR
        }

    /* Verify the table is empty */
    if(H5PLsize(&n_paths) < 0)
        TEST_ERROR
    if(n_paths > 0)
        TEST_ERROR

    PASSED();


    return SUCCEED;

error:
    return FAIL;
} /* end test_path_api_calls() */


/*-------------------------------------------------------------------------
 * Function:    main
 *
 * Purpose:     Tests the plugin module (H5PL)
 *
 * Return:      EXIT_SUCCESS/EXIT_FAILURE
 *
 *-------------------------------------------------------------------------
 */
int
main(void)
{
    char        filename[FILENAME_BUF_SIZE];
    hid_t       file = -1;
    hid_t       fapl = -1;
    hid_t       fapl2 = -1;
    unsigned    new_format;
    int         mdc_nelmts;
    size_t      rdcc_nelmts;
    size_t      rdcc_nbytes;
    double      rdcc_w0;
    int         nerrors = 0;

    /* Testing setup */
    h5_reset();

    if ((fapl = h5_fileaccess()) < 0)
        TEST_ERROR

    /* Turn off the chunk cache, so all the chunks are immediately written to disk */
    if (H5Pget_cache(fapl, &mdc_nelmts, &rdcc_nelmts, &rdcc_nbytes, &rdcc_w0) < 0)
        TEST_ERROR
    rdcc_nbytes = 0;
    if (H5Pset_cache(fapl, mdc_nelmts, rdcc_nelmts, rdcc_nbytes, rdcc_w0) < 0)
        TEST_ERROR

    /* Copy the file access property list */
    if ((fapl2 = H5Pcopy(fapl)) < 0)
        TEST_ERROR

    /* Set the "use the latest version of the format" bounds for creating objects in the file */
    if (H5Pset_libver_bounds(fapl2, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
        TEST_ERROR

    h5_fixname(FILENAME[0], fapl, filename, sizeof(filename));

    /* Test with old & new format groups */
    for (new_format = FALSE; new_format <= TRUE; new_format++) {
        hid_t my_fapl;

        /* Set the FAPL for the type of format */
        if (new_format) {
            HDputs("\nTesting with new file format:");
            my_fapl = fapl2;
        }
        else {
            HDputs("Testing with old file format:");
            my_fapl = fapl;
        }

        /* Create the file for this test */
        if ((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl)) < 0)
            TEST_ERROR

        /* Test dynamically loaded filters for chunked dataset */
        nerrors += (test_filters_for_datasets(file) < 0    ? 1 : 0);

        /* Test dynamically loaded filters for groups */
        nerrors += (test_filters_for_groups(file) < 0 ? 1 : 0);

        if (H5Fclose(file) < 0)
            TEST_ERROR
    } /* end for */

    /* Close FAPL */
    if (H5Pclose(fapl2) < 0)
        TEST_ERROR
    if (H5Pclose(fapl) < 0)
        TEST_ERROR

    /* Restore the default error handler (set in h5_reset()) */
    h5_restore_err();

    HDputs("\nTesting reading data with with dynamic plugin filters:");

    /* Close the library so that all loaded plugin libraries are unloaded */
    h5_reset();
    if ((fapl = h5_fileaccess()) < 0)
        TEST_ERROR

    /* Reopen the file for testing data reading */
    if ((file = H5Fopen(filename, H5F_ACC_RDONLY, fapl)) < 0)
        TEST_ERROR

    /* Read the data with filters */
    nerrors += (test_read_with_filters(file) < 0 ? 1 : 0);

    /* Open the groups with filters */
    nerrors += (test_groups_with_filters(file) < 0  ? 1 : 0);

    /* Restore the default error handler (set in h5_reset()) */
    h5_restore_err();

    /* Close the library so that all loaded plugin libraries are unloaded */
    h5_reset();
    if ((fapl = h5_fileaccess()) < 0)
        TEST_ERROR

    /* Reopen the file for testing data reading */
    if ((file = H5Fopen(filename, H5F_ACC_RDONLY, fapl)) < 0)
        TEST_ERROR

    /* Read the data with disabled filters */
    nerrors += (test_noread_with_filters(file) < 0  ? 1 : 0);

    if (H5Fclose(file) < 0)
        TEST_ERROR

    /* Test the APIs for access to the filter plugin path table */
    nerrors += (test_path_api_calls() < 0  ? 1 : 0);

    if (nerrors)
        TEST_ERROR

    HDprintf("All plugin tests passed.\n");
    h5_cleanup(FILENAME, fapl);

    HDexit(EXIT_SUCCESS);

error:
    nerrors = MAX(1, nerrors);
    HDprintf("***** %d PLUGIN TEST%s FAILED! *****\n", nerrors, 1 == nerrors ? "" : "S");
    HDexit(EXIT_FAILURE);
} /* end main() */