diff options
author | Vailin Choi <vchoi@jam.ad.hdfgroup.org> | 2017-11-25 08:12:26 (GMT) |
---|---|---|
committer | Vailin Choi <vchoi@jam.ad.hdfgroup.org> | 2017-11-25 08:22:24 (GMT) |
commit | 96784c9873433b57de813c5afadd5d9771103686 (patch) | |
tree | c180d5c2a0163c2c273cb72b7b7df006e7be7a3f /test/filter_plugin.c | |
parent | a7ba8af0d145fee16a758ae4150316c7f2a38263 (diff) | |
parent | f3fd3f293f2734fea98f508f190bf531edc72f7a (diff) | |
download | hdf5-96784c9873433b57de813c5afadd5d9771103686.zip hdf5-96784c9873433b57de813c5afadd5d9771103686.tar.gz hdf5-96784c9873433b57de813c5afadd5d9771103686.tar.bz2 |
(1) Merge branch 'develop' into bugfix/version_bounds
(2) Add two new options to h5repack for low and high bounds as in H5Pset_libver_bounds.
(3) Modify message pre_copy callbacks so that H5Ocopy can handle version bounds check.
(4) Add version bounds check for cache image feature.
Diffstat (limited to 'test/filter_plugin.c')
-rw-r--r-- | test/filter_plugin.c | 1511 |
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() */ + |