Plugin test rework

Cleanup of plugin test code. Renames many files. Prep for VOL branch merge.

1 files changed, 1511 insertions, 0 deletions

diff --git a/test/filter_plugin.c b/test/filter_plugin.c
new file mode 100644
index 0000000..8b7e0e4
--- /dev/null
+++ b/test/filter_plugin.c
@@ -0,0 +1,1511 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * 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 IDs for test filter plugins */
+#define FILTER1_ID          257
+#define FILTER2_ID          258
+#define FILTER3_ID          259
+#define FILTER4_ID          260
+
+const char *FILENAME[] = {
+    "filter_plugin",
+    NULL
+};
+#define FILENAME_BUF_SIZE       1024
+
+/* Dataset names */
+#define DSET_DEFLATE_NAME    "deflate dset"
+#define DSET_FILTER1_NAME    "filter 1 dset"
+#define DSET_FILTER2_NAME    "filter 2 dset"
+#define DSET_FILTER3_NAME    "filter 3 dset"
+
+/* Array sizes used throughout the test */
+#define DSET_DIM1               100
+#define DSET_DIM2               200
+#define CHUNK_DIM1              2
+#define CHUNK_DIM2              25
+#define HYPERSLAB_OFFSET1       7
+#define HYPERSLAB_OFFSET2       30
+#define HYPERSLAB_SIZE1         4
+#define HYPERSLAB_SIZE2         50
+
+/* Global size arrays */
+const hsize_t sizes_g[2] = {DSET_DIM1, DSET_DIM2};                      /* Dataset dimensions   */
+const hsize_t hs_sizes_g[2] = {HYPERSLAB_SIZE1, HYPERSLAB_SIZE2};       /* Hyperslab sizes      */
+const hsize_t hs_offsets_g[2] = {HYPERSLAB_OFFSET1, HYPERSLAB_OFFSET2}; /* Hyperslab offsets    */
+const hsize_t chunk_sizes_g[2] = {CHUNK_DIM1, CHUNK_DIM2};              /* Chunk dimensions     */
+
+/* Limit random number within 20000 */
+#define RANDOM_LIMIT    20000
+
+/* Things used in the groups + filter plugins test */
+#define N_SUBGROUPS             1000
+#define SUBGROUP_PREFIX         "subgroup_"
+#define TOP_LEVEL_GROUP_NAME    "top-level group"
+
+/* Global arrays in which to save data */
+int **orig_deflate_g  = NULL;
+int **orig_dynlib1_g  = NULL;
+int **orig_dynlib2_g  = NULL;
+int **orig_dynlib4_g  = NULL;
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:  free_2D_array
+ *
+ * Purpose:   Free up a dynamic 2D pseudo array and set the pointer to NULL
+ *            Designed to be callable in error conditions so NULLs are okay
+ *
+ * Return:    SUCCEED (always)
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+free_2D_array(int ***arr) {
+
+    if (arr && *arr && (*arr)[0])
+        HDfree((*arr)[0]);
+    if (arr && *arr)
+        HDfree(*arr);
+    *arr = NULL;
+
+    return SUCCEED;
+} /* end free_2D_array() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:  allocate_and_init_2D_array
+ *
+ * Purpose:   Initialize an array as a pseudo 2D array and copy in some
+ *            initial values.
+ *
+ * Return:    SUCCEED/FAIL
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+allocate_and_init_2D_array(int ***arr, const hsize_t *sizes, int **initial_values) {
+
+    size_t r, c;        /* Data rows and columns    */
+    size_t i;           /* Iterator                 */
+    size_t n_bytes;     /* # of bytes to copy       */
+
+    r = (size_t)sizes[0];
+    c = (size_t)sizes[1];
+
+    /* Allocate and set up pseudo-2D array */
+    if (NULL == (*arr = (int **)HDcalloc(r, sizeof(int *))))
+        TEST_ERROR;
+    if (NULL == ((*arr)[0] = (int *)HDcalloc(r * c, sizeof(int))))
+        TEST_ERROR;
+    for (i = 0; i < r; i++)
+        (*arr)[i] = (**arr + c * i);
+
+    /* Copy over the data elements */
+    if (initial_values) {
+        n_bytes = r * c * sizeof(int);
+        HDmemcpy((*arr)[0], initial_values[0], n_bytes);
+    }
+
+    return SUCCEED;
+error:
+    free_2D_array(arr);
+    
+    return FAIL;
+} /* end allocate_and_init_2D_array() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:  compare_2D_arrays
+ *
+ * Purpose:   Compare two pseudo 2D arrays
+ *
+ * Return:    SUCCEED/FAIL
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+compare_2D_arrays(int **dset1, int **dset2, const hsize_t *sizes, /*OUT*/ hbool_t *are_same) {
+    hsize_t i, j;           /* index variables */
+
+    *are_same = TRUE;
+
+    /* Check all the array values. This could optionally emit any
+     * bad data, but it's not clear how that would help debugging.
+     */
+    for (i = 0; i < sizes[0]; i++)
+        for (j = 0; j < sizes[1]; j++)
+            if (dset1[i][j] != dset2[i][j]) {
+                *are_same = FALSE;
+                return SUCCEED;
+            }
+
+    return SUCCEED;
+    
+} /* end compare_2D_arrays() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:  ensure_filter_works
+ *
+ * Purpose:   Tests writing entire data and partial data with filters
+ *
+ * Return:    SUCCEED/FAIL
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+ensure_filter_works(hid_t fid, const char *name, hid_t dcpl_id)
+{
+    hid_t           did = -1;                       /* Dataset ID                                   */
+    hid_t           dxpl_id = -1;                   /* Dataset xfer property list ID                */
+    hid_t           write_dxpl_id = -1;             /* Dataset xfer property list ID for writing    */
+    hid_t           sid = -1;                       /* Dataspace ID                                 */
+    void           *tconv_buf = NULL;               /* Temporary conversion buffer                  */
+    int           **orig = NULL;                    /* Data written to the dataset                  */
+    int           **read = NULL;                    /* Data read from the dataset                   */
+    size_t          r, c;                           /* Data rows and columns                        */
+    size_t          hs_r, hs_c, hs_offr, hs_offc;   /* Hypserslab sizes and offsets                 */
+    size_t          i, j;                           /* Local index variables                        */
+    int             n = 0;                          /* Value written to point array                 */
+    hbool_t         are_same;                       /* Output from dataset compare function         */
+    int          ***save_array = NULL;              /* (Global) array where the final data go       */
+
+    /* initialize */
+    r = (size_t)sizes_g[0];
+    c = (size_t)sizes_g[1];
+
+    /* Create the data space */
+    if ((sid = H5Screate_simple(2, sizes_g, NULL)) < 0)
+        TEST_ERROR;
+
+    /* Allocate memory for the data buffers
+     * We're using the hacky way of doing 2D arrays that uses a
+     * single data buffer but which allows normal 2D access.
+     */
+    if (allocate_and_init_2D_array(&orig, sizes_g, NULL) < 0)
+        TEST_ERROR;
+    if (allocate_and_init_2D_array(&read, sizes_g, NULL) < 0)
+        TEST_ERROR;
+
+    /* Create a small conversion buffer to test strip mining. We
+     * might as well test all we can!
+     */
+    if ((dxpl_id = H5Pcreate(H5P_DATASET_XFER)) < 0)
+        TEST_ERROR;
+    if (NULL == (tconv_buf = HDcalloc((size_t)1000, sizeof(char))))
+        TEST_ERROR;
+    if (H5Pset_buffer(dxpl_id, (size_t)1000, tconv_buf, NULL) < 0)
+        TEST_ERROR;
+    if ((write_dxpl_id = H5Pcopy(dxpl_id)) < 0)
+        TEST_ERROR;
+
+    TESTING("    filters (setup)");
+
+    /* Check if all the filters are available */
+    if (H5Pall_filters_avail(dcpl_id) != TRUE)
+        TEST_ERROR;
+
+    /* Create the dataset */
+    if ((did = H5Dcreate2(fid, name, H5T_NATIVE_INT, sid, H5P_DEFAULT, dcpl_id, H5P_DEFAULT)) < 0)
+        TEST_ERROR;
+
+    PASSED();
+
+    /*----------------------------------------------------------------------
+     * STEP 1: Read uninitialized data.  It should be zero.
+     *----------------------------------------------------------------------
+     */
+    TESTING("    filters (uninitialized read)");
+
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl_id, *read) < 0)
+        TEST_ERROR;
+
+    /* The input buffer was calloc'd and has not been initialized yet */
+    if (compare_2D_arrays(orig, read, sizes_g, &are_same) < 0)
+        TEST_ERROR;
+    if (FALSE == are_same)
+        TEST_ERROR;
+
+    PASSED();
+
+    /*----------------------------------------------------------------------
+     * STEP 2: Test filters by setting up a chunked dataset and writing
+     * to it.
+     *----------------------------------------------------------------------
+     */
+    TESTING("    filters (write)");
+
+    n = 0;
+    for (i = 0; i < r; i++)
+        for (j = 0; j < c; j++)
+            orig[i][j] = n++;
+
+    if (H5Dwrite(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, write_dxpl_id, *orig) < 0)
+        TEST_ERROR;
+
+    PASSED();
+
+    /*----------------------------------------------------------------------
+     * STEP 3: Try to read the data we just wrote.
+     *----------------------------------------------------------------------
+     */
+    TESTING("    filters (read)");
+
+    /* Read the dataset back */
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl_id, *read) < 0)
+        TEST_ERROR;
+
+    /* Check that the values read are the same as the values written */
+    if (compare_2D_arrays(orig, read, sizes_g, &are_same) < 0)
+        TEST_ERROR;
+    if (FALSE == are_same)
+        TEST_ERROR;
+
+    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 < r; i++)
+        for (j = 0; j < c / 2; j++)
+            orig[i][j] = (int)HDrandom() % RANDOM_LIMIT;
+
+    if (H5Dwrite(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, write_dxpl_id, *orig) < 0)
+        TEST_ERROR;
+
+    /* Read the dataset back and check it */
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl_id, *read) < 0)
+        TEST_ERROR;
+
+    /* Check that the values read are the same as the values written */
+    if (compare_2D_arrays(orig, read, sizes_g, &are_same) < 0)
+        TEST_ERROR;
+    if (FALSE == are_same)
+        TEST_ERROR;
+
+    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(did) < 0)
+        TEST_ERROR;
+    if ((did = H5Dopen2(fid, name, H5P_DEFAULT)) < 0)
+        TEST_ERROR;
+
+    if (H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, dxpl_id, *read) < 0)
+        TEST_ERROR;
+
+    /* Check that the values read are the same as the values written */
+    if (compare_2D_arrays(orig, read, sizes_g, &are_same) < 0)
+        TEST_ERROR;
+    if (FALSE == are_same)
+        TEST_ERROR;
+
+    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)");
+
+    hs_r = (size_t)hs_sizes_g[0];
+    hs_c = (size_t)hs_sizes_g[1];
+    hs_offr = (size_t)hs_offsets_g[0];
+    hs_offc = (size_t)hs_offsets_g[1];
+    for (i = 0; i < hs_r; i++)
+        for (j = 0; j < hs_c; j++)
+            orig[hs_offr + i][hs_offc + j] = (int)HDrandom() % RANDOM_LIMIT;
+
+    if (H5Sselect_hyperslab(sid, H5S_SELECT_SET, hs_offsets_g, NULL, hs_sizes_g, NULL) < 0)
+        TEST_ERROR;
+
+    /* Use the "read" DXPL because partial I/O on corrupted data test
+     * needs to ignore errors during writing
+     */
+    if (H5Dwrite(did, H5T_NATIVE_INT, sid, sid, dxpl_id, *orig) < 0)
+        TEST_ERROR;
+
+    if (H5Dread(did, H5T_NATIVE_INT, sid, sid, dxpl_id, *read) < 0)
+        TEST_ERROR;
+
+    /* Check that the values read are the same as the values written */
+    if (compare_2D_arrays(orig, read, sizes_g, &are_same) < 0)
+        TEST_ERROR;
+    if (FALSE == are_same)
+        TEST_ERROR;
+
+    PASSED();
+
+    /* Save the data written to the file for later comparison when the file
+     * is reopened for read test.
+     */
+    if (!HDstrcmp(name, DSET_DEFLATE_NAME))
+        save_array = &orig_deflate_g;
+    else if (!HDstrcmp(name, DSET_FILTER1_NAME))
+        save_array = &orig_dynlib1_g;
+    else if (!HDstrcmp(name, DSET_FILTER2_NAME))
+        save_array = &orig_dynlib2_g;
+    else if (!HDstrcmp(name, DSET_FILTER3_NAME))
+        save_array = &orig_dynlib4_g;
+    else
+        TEST_ERROR;
+    if (allocate_and_init_2D_array(save_array, sizes_g, orig) < 0)
+        TEST_ERROR;
+
+    /* Clean up and exit */
+    if (H5Dclose(did) < 0)
+        TEST_ERROR;
+    if (H5Sclose(sid) < 0)
+        TEST_ERROR;
+    if (H5Pclose(dxpl_id) < 0)
+        TEST_ERROR;
+    if (H5Pclose(write_dxpl_id) < 0)
+        TEST_ERROR;
+
+    free_2D_array(&orig);
+    free_2D_array(&read);
+
+    HDfree(tconv_buf);
+
+    return SUCCEED;
+
+error:
+    /* Clean up objects used for this test */
+    H5E_BEGIN_TRY {
+        H5Dclose(did);
+        H5Sclose(sid);
+        H5Pclose(dxpl_id);
+        H5Pclose(write_dxpl_id);
+    } H5E_END_TRY
+
+    /* NULLs are okay here */
+    free_2D_array(&orig);
+    free_2D_array(&read);
+
+    if (tconv_buf)
+        HDfree(tconv_buf);
+
+    return FAIL;
+} /* end ensure_filter_works() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:  test_dataset_write_with_filters
+ *
+ * Purpose:   Tests creating datasets and writing data with dynamically loaded filters
+ *
+ * Return:    SUCCEED/FAIL
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_dataset_write_with_filters(hid_t fid)
+{
+    hid_t           dcpl_id = -1;           /* Dataset creation property list ID        */
+    unsigned int    compress_level;         /* Deflate compression level                */
+    unsigned int    filter1_data;           /* Data used by filter 1                    */
+    unsigned int    libver_values[4];       /* Used w/ the filter that makes HDF5 calls */
+
+    /*----------------------------------------------------------
+     * STEP 1: Test deflation by itself.
+     *----------------------------------------------------------
+     */
+    HDputs("Testing dataset writes with deflate filter");
+#ifdef H5_HAVE_FILTER_DEFLATE
+    if ((dcpl_id = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        TEST_ERROR;
+    if (H5Pset_chunk(dcpl_id, 2, chunk_sizes_g) < 0)
+        TEST_ERROR;
+    compress_level = 6;
+    if (H5Pset_deflate(dcpl_id, compress_level) < 0)
+        TEST_ERROR;
+
+    /* Ensure the filter works */
+    if (ensure_filter_works(fid, DSET_DEFLATE_NAME, dcpl_id) < 0)
+        TEST_ERROR;
+
+    /* Clean up objects used for this test */
+    if (H5Pclose(dcpl_id) < 0)
+        TEST_ERROR;
+#else /* H5_HAVE_FILTER_DEFLATE */
+    SKIPPED();
+    HDputs("    Deflate filter not enabled");
+#endif /* H5_HAVE_FILTER_DEFLATE */
+
+    /*----------------------------------------------------------
+     * STEP 2: Test filter plugin 1 by itself.
+     *----------------------------------------------------------
+     */
+    HDputs("    dataset writes with filter plugin 1");
+    if ((dcpl_id = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        TEST_ERROR;
+    if (H5Pset_chunk(dcpl_id, 2, chunk_sizes_g) < 0)
+        TEST_ERROR;
+
+    /* Set up the filter, passing in the amount the filter will add and subtract
+     * from each data element. Note that this value has an arbitrary max of 9.
+     */
+    filter1_data = 9;
+    if (H5Pset_filter(dcpl_id, FILTER1_ID, H5Z_FLAG_MANDATORY, (size_t)1, &filter1_data) < 0)
+        TEST_ERROR;
+
+    /* Ensure the filter works */
+    if (ensure_filter_works(fid, DSET_FILTER1_NAME, dcpl_id) < 0)
+        TEST_ERROR;
+
+    /* Clean up objects used for this test */
+    if (H5Pclose(dcpl_id) < 0)
+        TEST_ERROR;
+
+    /* Unregister the dynamic filter 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(FILTER1_ID) < 0)
+        TEST_ERROR;
+
+    /*----------------------------------------------------------
+     * STEP 3: Test filter plugin 2 by itself.
+     *----------------------------------------------------------
+     */
+    HDputs("    dataset writes with filter plugin 2");
+    if ((dcpl_id = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        TEST_ERROR;
+    if (H5Pset_chunk(dcpl_id, 2, chunk_sizes_g) < 0)
+        TEST_ERROR;
+    if (H5Pset_filter(dcpl_id, FILTER2_ID, H5Z_FLAG_MANDATORY, 0, NULL) < 0)
+        TEST_ERROR;
+
+    /* Ensure the filter works */
+    if (ensure_filter_works(fid, DSET_FILTER2_NAME, dcpl_id) < 0)
+        TEST_ERROR;
+
+    /* Clean up objects used for this test */
+    if (H5Pclose(dcpl_id) < 0)
+        TEST_ERROR;
+
+    /* Unregister the dynamic filter 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(FILTER2_ID) < 0)
+        TEST_ERROR;
+
+    /*----------------------------------------------------------
+     * STEP 4: Test filter plugin 3 by itself.
+     *         (This filter plugin makes HDF5 API calls)
+     *----------------------------------------------------------
+     */
+    HDputs("    dataset writes with filter plugin 3");
+    if ((dcpl_id = H5Pcreate(H5P_DATASET_CREATE)) < 0)
+        TEST_ERROR;
+    if (H5Pset_chunk(dcpl_id, 2, chunk_sizes_g) < 0)
+        TEST_ERROR;
+
+    /* Set the add/subtract value for the filter */
+    libver_values[0] = 9;
+
+    /* Get the library bounds and add to the filter data */
+    if (H5get_libversion(&libver_values[1], &libver_values[2], &libver_values[3]) < 0)
+        TEST_ERROR;
+    if (H5Pset_filter(dcpl_id, FILTER3_ID, H5Z_FLAG_MANDATORY, (size_t)4, libver_values) < 0)
+        TEST_ERROR;
+
+    /* Ensure the filter works */
+    if (ensure_filter_works(fid, DSET_FILTER3_NAME, dcpl_id) < 0)
+        TEST_ERROR;
+
+    /* Clean up objects used for this test */
+    if (H5Pclose(dcpl_id) < 0)
+        TEST_ERROR;
+
+    /* Unregister the dynamic filter 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(FILTER3_ID) < 0)
+        TEST_ERROR;
+
+    return SUCCEED;
+
+error:
+    /* Clean up objects used for this test */
+    H5E_BEGIN_TRY {
+        H5Pclose(dcpl_id);
+    } H5E_END_TRY
+
+    return FAIL;
+} /* end test_dataset_write_with_filters() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:  test_read_data
+ *
+ * Purpose:   Tests reading data and compares values
+ *
+ * Return:    SUCCEED/FAIL
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_read_data(hid_t did, int *origin_data)
+{
+    int           **check = NULL;
+    int          *data_p = origin_data;
+    size_t        i, j;        /* Local index variables */
+
+    if (allocate_and_init_2D_array(&check, sizes_g, NULL) < 0)
+        TEST_ERROR;
+
+    /* Read the dataset back */
+    if (H5Dread(did, 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 < sizes_g[0]; i++)
+        for(j = 0; j < sizes_g[1]; j++) {
+            if(*data_p != check[i][j])
+                TEST_ERROR
+            data_p++;
+        }
+
+    free_2D_array(&check);
+
+    PASSED();
+    
+    return SUCCEED;
+
+error:
+    free_2D_array(&check);
+
+    return FAIL;
+} /* end test_read_data() */
+
+
+
+/*-------------------------------------------------------------------------
+ * Function:  test_dataset_read_with_filters
+ *
+ * Purpose:   Tests reading datasets created with dynamically-loaded
+ *            filter plugins.
+ *
+ * Return:    SUCCEED/FAIL
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_dataset_read_with_filters(hid_t fid)
+{
+    hid_t   did = -1;                   /* Dataset ID */
+
+    /*----------------------------------------------------------
+     * STEP 1: Test deflation by itself.
+     *----------------------------------------------------------
+     */
+    TESTING("dataset read I/O with deflate filter");
+
+#ifdef H5_HAVE_FILTER_DEFLATE
+    if (H5Zfilter_avail(H5Z_FILTER_DEFLATE) != TRUE)
+        TEST_ERROR;
+
+    if ((did = H5Dopen2(fid, DSET_DEFLATE_NAME, H5P_DEFAULT)) < 0)
+        TEST_ERROR;
+
+    if (test_read_data(did, orig_deflate_g[0]) < 0)
+        TEST_ERROR;
+
+    if (H5Dclose(did) < 0)
+        TEST_ERROR;
+
+#else /* H5_HAVE_FILTER_DEFLATE */
+    SKIPPED();
+    HDputs("    Deflate filter not enabled");
+#endif /* H5_HAVE_FILTER_DEFLATE */
+
+    /*----------------------------------------------------------
+     * STEP 2: Test filter plugin 1 by itself.
+     *----------------------------------------------------------
+     */
+    TESTING("    dataset reads with filter plugin 1");
+
+    if ((did = H5Dopen2(fid, DSET_FILTER1_NAME, H5P_DEFAULT)) < 0)
+        TEST_ERROR;
+
+    if (test_read_data(did, orig_dynlib1_g[0]) < 0)
+        TEST_ERROR;
+
+    if (H5Dclose(did) < 0)
+        TEST_ERROR;
+
+    /*----------------------------------------------------------
+     * STEP 3: Test filter plugin 2 by itself.
+     *----------------------------------------------------------
+     */
+    TESTING("    dataset reads with filter plugin 2");
+
+    if ((did = H5Dopen2(fid, DSET_FILTER2_NAME, H5P_DEFAULT)) < 0)
+        TEST_ERROR;
+
+    if (test_read_data(did, orig_dynlib2_g[0]) < 0)
+        TEST_ERROR;
+
+    if (H5Dclose(did) < 0)
+        TEST_ERROR;
+
+    /*----------------------------------------------------------
+     * STEP 4: Test filter plugin 3 by itself.
+     *----------------------------------------------------------
+     */
+    TESTING("    dataset reads with filter plugin 3");
+
+    if ((did = H5Dopen2(fid, DSET_FILTER3_NAME, H5P_DEFAULT)) < 0)
+        TEST_ERROR;
+
+    if (test_read_data(did, orig_dynlib4_g[0]) < 0)
+        TEST_ERROR;
+
+    if (H5Dclose(did) < 0)
+        TEST_ERROR;
+
+    return SUCCEED;
+
+error:
+    /* Clean up objects used for this test */
+    H5E_BEGIN_TRY {
+        H5Dclose(did);
+    } H5E_END_TRY
+
+    return FAIL;
+} /* end test_dataset_read_with_filters() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:  ensure_data_read_fails
+ *
+ * Purpose:   Tests not reading data
+ *
+ * Return:    SUCCEED/FAIL
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+ensure_data_read_fails(hid_t did)
+{
+    int       **check = NULL;
+    herr_t      ret = FAIL;
+
+    if (allocate_and_init_2D_array(&check, sizes_g, NULL) < 0)
+        TEST_ERROR;
+
+    /* Read the dataset back (should fail) */
+    H5E_BEGIN_TRY {
+        ret = H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, *check);
+    } H5E_END_TRY
+    if(ret >= 0)
+        TEST_ERROR;
+
+    free_2D_array(&check);
+
+    PASSED();
+
+    return SUCCEED;
+
+error:
+    free_2D_array(&check);
+    return FAIL;
+} /* end ensure_data_read_fails() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:  test_no_read_when_plugins_disabled
+ *
+ * Purpose:   Ensures we can't read data from a dataset that requires a
+ *            filter located in a plugin.
+ *
+ * Return:    SUCCEED/FAIL
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_no_read_when_plugins_disabled(hid_t fid)
+{
+    hid_t       did = -1;               /* Dataset ID */
+    unsigned    plugin_flags;           /* Plugin access flags */
+
+    TESTING("filter plugin 1 with filter plugins disabled");
+
+    /* Get the existing plugin flags */
+    if (H5PLget_loading_state(&plugin_flags) < 0)
+        TEST_ERROR;
+
+    /* Disable filter plugins and use the new flags */
+    plugin_flags &= (unsigned)(~H5PL_FILTER_PLUGIN);
+    if (H5PLset_loading_state(plugin_flags) < 0)
+        TEST_ERROR;
+
+    /* Open a dataset that requires a filter plugin to read the data */
+    if ((did = H5Dopen2(fid, DSET_FILTER1_NAME, H5P_DEFAULT)) < 0)
+        TEST_ERROR;
+
+    /* Make sure we can't read the data */
+    if (ensure_data_read_fails(did) < 0)
+        TEST_ERROR;
+
+    /* Close down */
+    if (H5Dclose(did) < 0)
+        TEST_ERROR;
+
+    /* Re-enable filter plugins */
+    plugin_flags |= (unsigned)H5PL_FILTER_PLUGIN;
+    if (H5PLset_loading_state(plugin_flags) < 0)
+        TEST_ERROR;
+
+    return SUCCEED;
+
+error:
+    /* Clean up objects used for this test */
+    H5E_BEGIN_TRY {
+        plugin_flags |= (unsigned)H5PL_FILTER_PLUGIN;
+        H5PLset_loading_state(plugin_flags);
+        H5Dclose(did);
+    } H5E_END_TRY
+
+    return FAIL;
+} /* end test_no_read_when_plugins_disabled() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:  test_creating_groups_using_plugins
+ *
+ * Purpose:   Tests creating group with dynamically loaded filters
+ *
+ * Return:    SUCCEED/FAIL
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_creating_groups_using_plugins(hid_t fid)
+{
+    hid_t    gcpl_id = -1;
+    hid_t    gid = -1;
+    hid_t    sub_gid = -1;
+    int      i;
+    char     subgroup_name[256];
+
+    TESTING("creating groups with filter plugin 4");
+
+    if ((gcpl_id = H5Pcreate(H5P_GROUP_CREATE)) < 0)
+        TEST_ERROR;
+
+    /* Use a filter plugin for creating groups */
+    if (H5Pset_filter(gcpl_id, FILTER4_ID, H5Z_FLAG_MANDATORY, (size_t)0, NULL) < 0)
+        TEST_ERROR;
+
+    /* Create a group using this filter */
+    if ((gid = H5Gcreate2(fid, TOP_LEVEL_GROUP_NAME, H5P_DEFAULT, gcpl_id, H5P_DEFAULT)) < 0)
+        TEST_ERROR;
+
+    /* Create multiple groups under the top-level group */
+    for (i = 0; i < N_SUBGROUPS; i++) {
+        char *sp = subgroup_name;
+
+        sp += HDsprintf(subgroup_name, SUBGROUP_PREFIX);
+        HDsprintf(sp, "%d", i);
+
+        if ((sub_gid = H5Gcreate2(gid, subgroup_name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0)
+            TEST_ERROR;
+        if (H5Gclose(sub_gid) < 0)
+            TEST_ERROR;
+    }
+
+    /* Close everything */
+    if (H5Gclose(gid) < 0)
+        TEST_ERROR;
+    if (H5Pclose(gcpl_id) < 0)
+        TEST_ERROR;
+
+    PASSED();
+
+    return SUCCEED;
+
+error:
+    /* Clean up objects used for this test */
+    H5E_BEGIN_TRY {
+        H5Gclose(sub_gid);
+        H5Gclose(gid);
+        H5Pclose(gcpl_id);
+    } H5E_END_TRY
+
+    return FAIL;
+} /* end test_creating_groups_using_plugins() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    test_opening_groups_using_plugins
+ *
+ * Purpose:     Tests opening group with dynamically loaded filters
+ *
+ * Return:      SUCCEED/FAIL
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+test_opening_groups_using_plugins(hid_t fid)
+{
+    hid_t       gid = -1;
+    hid_t       sub_gid = -1;
+    int         i;
+    char        subgroup_name[256];
+
+    TESTING("opening groups with filter plugin 4");
+
+    /* Open the top group */
+    if ((gid = H5Gopen2(fid, TOP_LEVEL_GROUP_NAME, H5P_DEFAULT)) < 0)
+        TEST_ERROR;
+
+    /* Open all the sub-groups under the top-level group */
+    for (i = 0; i < N_SUBGROUPS; i++) {
+        char *sp = subgroup_name;
+
+        sp += HDsprintf(subgroup_name, SUBGROUP_PREFIX);
+        HDsprintf(sp, "%d", i);
+
+        if ((sub_gid = H5Gopen2(gid, subgroup_name, H5P_DEFAULT)) < 0)
+            TEST_ERROR;
+        if (H5Gclose(sub_gid) < 0)
+            TEST_ERROR;
+    }
+
+    /* Close the top-level group */
+    if (H5Gclose(gid) < 0)
+        TEST_ERROR;
+
+    PASSED();
+
+    return SUCCEED;
+
+error:
+    /* Clean up objects used for this test */
+    H5E_BEGIN_TRY {
+        H5Gclose(gid);
+        H5Gclose(sub_gid);
+    } H5E_END_TRY
+
+    return FAIL;
+} /* end test_opening_groups_using_plugins() */
+
+
+
+/*-------------------------------------------------------------------------
+ * 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(FILTER1_ID) != 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:  disable_chunk_cache
+ *
+ * Purpose:   Turns the chunk cache off
+ *
+ * Return:    SUCCEED/FAIL
+ * 
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+disable_chunk_cache(hid_t fapl_id) {
+    int         mdc_nelmts;
+    size_t      rdcc_nelmts;
+    size_t      rdcc_nbytes;
+    double      rdcc_w0;
+
+    if (H5Pget_cache(fapl_id, &mdc_nelmts, &rdcc_nelmts, &rdcc_nbytes, &rdcc_w0) < 0)
+        TEST_ERROR;
+    rdcc_nbytes = 0;
+    if (H5Pset_cache(fapl_id, mdc_nelmts, rdcc_nelmts, rdcc_nbytes, rdcc_w0) < 0)
+        TEST_ERROR;
+
+    return SUCCEED;
+error:
+    return FAIL;
+} /* end disable_chunk_cache() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    main
+ *
+ * Purpose:     Tests the plugin module (H5PL)
+ *
+ * Return:      EXIT_SUCCESS/EXIT_FAILURE
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+main(void)
+{
+    char        filename[FILENAME_BUF_SIZE];
+    hid_t       fid = -1;
+    hid_t       old_ff_fapl_id = -1;
+    hid_t       new_ff_fapl_id = -1;
+    unsigned    new_format;
+    int         nerrors = 0;
+
+    /* Testing setup */
+    h5_reset();
+
+    /*******************************************************************/
+    /* ENSURE THAT WRITING TO DATASETS AND CREATING GROUPS WORKS       */
+    /*******************************************************************/
+
+    /* Get a VFD-dependent filename */
+    if ((old_ff_fapl_id = h5_fileaccess()) < 0)
+        TEST_ERROR;
+
+    /* Turn off the chunk cache, so all the chunks are immediately written to disk */
+    if (disable_chunk_cache(old_ff_fapl_id) < 0)
+        TEST_ERROR;
+
+    /* Copy the file access property list and set the latest file format on it */
+    if ((new_ff_fapl_id = H5Pcopy(old_ff_fapl_id)) < 0)
+        TEST_ERROR;
+    if (H5Pset_libver_bounds(new_ff_fapl_id, H5F_LIBVER_LATEST, H5F_LIBVER_LATEST) < 0)
+        TEST_ERROR;
+
+    /* Fix up the filename for the VFD */
+    h5_fixname(FILENAME[0], old_ff_fapl_id, filename, sizeof(filename));
+
+    /* Test with old & new format groups */
+    for (new_format = FALSE; new_format <= TRUE; new_format++) {
+        hid_t my_fapl_id;
+
+        /* Set the FAPL for the type of format */
+        if (new_format) {
+            HDputs("\nTesting with new file format:");
+            my_fapl_id = new_ff_fapl_id;
+        }
+        else {
+            HDputs("Testing with old file format:");
+            my_fapl_id = old_ff_fapl_id;
+        }
+
+        /* Create the file for this test */
+        if ((fid = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, my_fapl_id)) < 0)
+            TEST_ERROR;
+
+        /* Test creating datasets and writing to them using plugin filters */
+        nerrors += (test_dataset_write_with_filters(fid) < 0 ? 1 : 0);
+
+        /* Test creating groups using dynamically-loaded plugin filters */
+        nerrors += (test_creating_groups_using_plugins(fid) < 0 ? 1 : 0);
+
+        if (H5Fclose(fid) < 0)
+            TEST_ERROR;
+    } /* end for */
+
+    /* Close FAPLs */
+    if (H5Pclose(old_ff_fapl_id) < 0)
+        TEST_ERROR;
+    if (H5Pclose(new_ff_fapl_id) < 0)
+        TEST_ERROR;
+
+    /* Restore the default error handler (set in h5_reset()) */
+    h5_restore_err();
+
+    /*******************************************************************/
+    /* ENSURE THAT READING FROM DATASETS AND OPENING GROUPS WORKS      */
+    /*******************************************************************/
+
+    HDputs("\nTesting reading data with with dynamic plugin filters:");
+
+    /* Close the library so that all loaded plugin libraries are unloaded */
+    h5_reset();
+    if ((old_ff_fapl_id = h5_fileaccess()) < 0)
+        TEST_ERROR;
+
+    /* Reopen the file for testing data reading */
+    if ((fid = H5Fopen(filename, H5F_ACC_RDONLY, old_ff_fapl_id)) < 0)
+        TEST_ERROR;
+
+    /* Read the data with filters */
+    nerrors += (test_dataset_read_with_filters(fid) < 0 ? 1 : 0);
+
+    /* Test creating groups using dynamically-loaded plugin filters */
+    nerrors += (test_opening_groups_using_plugins(fid) < 0  ? 1 : 0);
+
+    /* Restore the default error handler (set in h5_reset()) */
+    h5_restore_err();
+
+    /*******************************************************************/
+    /* ENSURE THAT DISABLING FILTER PLUGINS VIA THE FILTER FLAGS WORKS */
+    /*******************************************************************/
+
+    /* Close the library so that all loaded plugin libraries are unloaded */
+    h5_reset();
+    if ((old_ff_fapl_id = h5_fileaccess()) < 0)
+        TEST_ERROR;
+
+    /* Reopen the file for testing data reading */
+    if ((fid = H5Fopen(filename, H5F_ACC_RDONLY, old_ff_fapl_id)) < 0)
+        TEST_ERROR;
+
+    /* When filters are disabled, make sure we can't read data from a
+     * dataset that requires a filter plugin.
+     */
+    nerrors += (test_no_read_when_plugins_disabled(fid) < 0  ? 1 : 0);
+
+    if (H5Fclose(fid) < 0)
+        TEST_ERROR;
+
+    /************************************/
+    /* TEST THE FILTER PLUGIN API CALLS */
+    /************************************/
+
+    /* Test the APIs for access to the filter plugin path table */
+    nerrors += (test_path_api_calls() < 0  ? 1 : 0);
+
+    /*********************/
+    /* CLEAN UP AND EXIT */
+    /*********************/
+
+    /* Free up saved arrays */
+    free_2D_array(&orig_deflate_g);
+    free_2D_array(&orig_dynlib1_g);
+    free_2D_array(&orig_dynlib2_g);
+    free_2D_array(&orig_dynlib4_g);
+
+    if (nerrors)
+        TEST_ERROR;
+
+    HDprintf("All plugin tests passed.\n");
+    h5_cleanup(FILENAME, old_ff_fapl_id);
+
+    HDexit(EXIT_SUCCESS);
+
+error:
+    H5E_BEGIN_TRY {
+        H5Fclose(fid);
+        H5Pclose(old_ff_fapl_id);
+        H5Pclose(new_ff_fapl_id);
+    } H5E_END_TRY
+
+    /* Free up saved arrays (NULLs okay) */
+    free_2D_array(&orig_deflate_g);
+    free_2D_array(&orig_dynlib1_g);
+    free_2D_array(&orig_dynlib2_g);
+    free_2D_array(&orig_dynlib4_g);
+
+    nerrors = MAX(1, nerrors);
+    HDprintf("***** %d PLUGIN TEST%s FAILED! *****\n", nerrors, 1 == nerrors ? "" : "S");
+    HDexit(EXIT_FAILURE);
+} /* end main() */
+