diff options
Diffstat (limited to 'c++')
| -rw-r--r-- | c++/test/dsets.cpp | 1048 | ||||
| -rw-r--r-- | c++/test/testhdf5.cpp | 312 | ||||
| -rw-r--r-- | c++/test/tfile.cpp | 332 |
3 files changed, 1692 insertions, 0 deletions
diff --git a/c++/test/dsets.cpp b/c++/test/dsets.cpp new file mode 100644 index 0000000..df5be42 --- /dev/null +++ b/c++/test/dsets.cpp @@ -0,0 +1,1048 @@ +/**************************************************************************** + * NCSA HDF * + * Software Development Group * + * National Center for Supercomputing Applications * + * University of Illinois at Urbana-Champaign * + * 605 E. Springfield, Champaign IL 61820 * + * * + * For conditions of distribution and use, see the accompanying * + * hdf/COPYING file. * + * * + ****************************************************************************/ + +/*********************************************************** +* +* Test program: dsets +* +* Test the dataset interface (H5D) +* +*************************************************************/ + +#include <h5test.h> +#include <testhdf5.h> +#include <H5Cpp.h> + +#ifndef H5_NO_NAMESPACE +using namespace H5; +#endif + +const char *FILENAME[] = { + "dataset", + NULL +}; + +#define DSET_DEFAULT_NAME "default" +#define DSET_CHUNKED_NAME "chunked" +#define DSET_SIMPLE_IO_NAME "simple_io" +#define DSET_TCONV_NAME "tconv" +#define DSET_COMPRESS_NAME "compressed" +#define DSET_BOGUS_NAME "bogus" + +#define H5Z_BOGUS 305 + + +/*------------------------------------------------------------------------- + * Function: test_create + * + * Purpose: Attempts to create a dataset. + * + * Return: Success: 0 + * + * Failure: -1 + * + * Programmer: Binh-Minh Ribler + * Friday, January 5, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static herr_t +test_create( H5File& file) +{ + TESTING("create, open, close"); + + try { + /* Create the data space */ + hsize_t dims[2]; + dims[0] = 256; + dims[1] = 512; + DataSpace space (2, dims, NULL); + + /* + * Create a dataset using the default dataset creation properties. + * We're not sure what they are, so we won't check. + */ + DataSet *dataset = new DataSet (file.createDataSet + (DSET_DEFAULT_NAME, PredType::NATIVE_DOUBLE, space)); + + /* Close the dataset */ + delete dataset; + + /* Add a comment to the dataset */ + file.setComment (DSET_DEFAULT_NAME, "This is a dataset"); + + /* + * Try creating a dataset that already exists. This should fail since a + * dataset can only be created once. If an exception is not thrown + * for this action by createDataSet, then display failure information + * and jump to label error: to return. + */ + try { + dataset = new DataSet (file.createDataSet + (DSET_DEFAULT_NAME, PredType::NATIVE_DOUBLE, space)); + // continuation here, that means no exception has been thrown + FAILED(); + cout << " Library allowed overwrite of existing dataset." << endl; + goto error; + } + catch (FileIException E ) // catching invalid creating dataset + { + // Exception is expected. Do nothing here. + } + /* + * Open the dataset we created above and then close it. This is how + * existing datasets are accessed. + */ + dataset = new DataSet (file.openDataSet (DSET_DEFAULT_NAME)); + delete dataset; + + /* + * Try opening a non-existent dataset. This should fail so if an + * exception is not thrown for this action by openDataSet, then + * display failure information and jump to label error: to return. + */ + try { + dataset = new DataSet (file.openDataSet( "does_not_exist" )); + // continuation here, that means no exception has been thrown + FAILED(); + cout << " Opened a non-existent dataset." << endl; + goto error; + } + catch (FileIException E ) // catching creating non-existent dataset + { + // Exception is expected. Do nothing here. + } + + /* + * Create a new dataset that uses chunked storage instead of the default + * layout. + */ + DSetCreatPropList create_parms; + hsize_t csize[2]; + csize[0] = 5; + csize[1] = 100; + create_parms.setChunk( 2, csize ); + + dataset = new DataSet (file.createDataSet + (DSET_CHUNKED_NAME, PredType::NATIVE_DOUBLE, space, create_parms)); + // Note: this one has no error message in C when failure occurs? + + /* + * Close the chunked dataset. + */ + delete dataset; + + PASSED(); + return 0; + } // outer most try block + + // catch all dataset, file, space, plist exceptions + catch (Exception E) { goto error; } + + error: + return -1; +} + +/*------------------------------------------------------------------------- + * Function: check_values + * + * Purpose: Checks a read value against the written value. If they are + * different, the function will + * print out a message and the different values. This function + * is made to reuse the code segment that is used in various + * places throughout test_compression and in test_simple_io. + * Where the C version + * of this code segment "goto error," this function will + * return -1, so that the caller can "goto error." + * + * Return: Success: 0 + * + * Failure: -1 + * + * Programmer: Binh-Minh Ribler (using C code segment for checking values) + * Friday, February 6, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static int +check_values (hsize_t i, hsize_t j, int apoint, int acheck) +{ + if (apoint != acheck) + { + FAILED(); + cout << " Read different values than written.\n" << endl; + cout << " At index " << (unsigned long)i << "," << + (unsigned long)j << endl; + return -1; + } + return 0; +} // check_values + +/*------------------------------------------------------------------------- + * Function: test_simple_io + * + * Purpose: Tests simple I/O. That is, reading and writing a complete + * multi-dimensional array without data type or data space + * conversions, without compression, and stored contiguously. + * + * Return: Success: 0 + * + * Failure: -1 + * + * Programmer: Binh-Minh Ribler (using Robb Matzke's C version) + * Friday, January 5, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static herr_t +test_simple_io( H5File& file) +{ + + TESTING("simple I/O"); + + int points[100][200]; + int check[100][200]; + int i, j, n; + + /* Initialize the dataset */ + for (i = n = 0; i < 100; i++) + { + for (j = 0; j < 200; j++) { + points[i][j] = n++; + } + } + + void* tconv_buf = new char [1000]; + try + { + /* Create the data space */ + hsize_t dims[2]; + dims[0] = 100; + dims[1] = 200; + DataSpace space (2, dims, NULL); + + /* Create a small conversion buffer to test strip mining */ + DSetMemXferPropList xfer; + + //if (H5Pset_buffer (xfer, 1000, tconv_buf, NULL)<0) goto error; + xfer.setBuffer (1000, tconv_buf, NULL); + + /* Create the dataset */ + DataSet dataset (file.createDataSet (DSET_SIMPLE_IO_NAME, PredType::NATIVE_INT, space)); + + /* Write the data to the dataset */ + dataset.write ((void*) points, PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer); + + /* Read the dataset back */ + dataset.read ((void*) check, PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer); + + /* Check that the values read are the same as the values written */ + for (i = 0; i < 100; i++) + for (j = 0; j < 200; j++) + { + int status = check_values (i, j, points[i][j], check[i][j]); + if (status == -1) goto error; + } + + delete [] tconv_buf; + PASSED(); + return 0; + } // end try + + // catch all dataset, space, plist exceptions + catch (Exception E) { goto error; } + + error: + // cleaning up + if (tconv_buf) + delete [] tconv_buf; + return -1; +} + +/*------------------------------------------------------------------------- + * Function: test_tconv + * + * Purpose: Test some simple data type conversion stuff. + * + * Return: Success: 0 + * + * Failure: -1 + * + * Programmer: Binh-Minh Ribler (using Robb Matzke's C version) + * Friday, January 5, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static herr_t +test_tconv( H5File& file) +{ + // Prepare buffers for input/output + char *out=NULL, *in=NULL; + out = new char [4*1000000]; + // assert (out); - should use exception handler for new - BMR + in = new char [4*1000000]; + //assert (in); + + TESTING("data type conversion"); + + /* Initialize the dataset */ + for (int i = 0; i < 1000000; i++) { + out[i*4+0] = 0x11; + out[i*4+1] = 0x22; + out[i*4+2] = 0x33; + out[i*4+3] = 0x44; + } + + try + { + /* Create the data space */ + hsize_t dims[1]; + dims[0] = 1000000; + DataSpace space (1, dims, NULL); + + /* Create the data set */ + DataSet dataset (file.createDataSet (DSET_TCONV_NAME, PredType::STD_I32LE, space)); + + /* Write the data to the dataset */ + dataset.write ((void*) out, PredType::STD_I32LE); + + /* Read data with byte order conversion */ + dataset.read ((void*) in, PredType::STD_I32BE); + + /* Check */ + for (i = 0; i < 1000000; i++) { + if (in[4*i+0]!=out[4*i+3] || + in[4*i+1]!=out[4*i+2] || + in[4*i+2]!=out[4*i+1] || + in[4*i+3]!=out[4*i+0]) + { + FAILED(); + cout << " Read with byte order conversion failed." << endl; + goto error; + } + } + + delete [] out; + delete [] in; + cout << " PASSED" << endl; + return 0; + } // end try + + // catch all dataset and space exceptions + catch (Exception E) { goto error; } + + error: + delete [] out; + delete [] in; + return -1; +} + +/*------------------------------------------------------------------------- + * Function: bogus + * + * Purpose: A bogus compression method that doesn't do anything. + * + * Return: Success: Data chunk size + * + * Failure: 0 + * + * Programmer: Robb Matzke + * Tuesday, April 21, 1998 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static size_t +/*bogus(unsigned int UNUSED flags, size_t UNUSED cd_nelmts, + const unsigned int UNUSED cd_values[], size_t nbytes, + size_t UNUSED *buf_size, void UNUSED **buf) +BMR: removed UNUSED for now until asking Q. or R. to pass compilation*/ +bogus(unsigned int flags, size_t cd_nelmts, + const unsigned int cd_values[], size_t nbytes, + size_t *buf_size, void **buf) +{ + return nbytes; +} + + +/*------------------------------------------------------------------------- + * Function: test_compression + * + * Purpose: Tests dataset compression. If compression is requested when + * it hasn't been compiled into the library (such as when + * updating an existing compressed dataset) then data is sent to + * the file uncompressed but no errors are returned. + * + * Return: Success: 0 + * + * Failure: -1 + * + * Programmer: Binh-Minh Ribler (using Robb Matzke's C version) + * Friday, January 5, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ + +static herr_t +test_compression(H5File& file) +{ + const char *not_supported; + not_supported = " Deflate compression is not supported.\n" + " The zlib was not found when hdf5 was configured."; + + TESTING("compression (setup)"); + + int points[100][200]; + int check[100][200]; + hsize_t i, j, n; + + /* Initialize the dataset */ + for (i = n = 0; i < 100; i++) + { + for (j = 0; j < 200; j++) { + points[i][j] = n++; + } + } + void* tconv_buf = new char [1000]; + + try + { + const hsize_t size[2] = {100, 200}; + /* Create the data space */ + DataSpace space1(2, size, NULL); + + /* + * Create a small conversion buffer to test strip mining. We + * might as well test all we can! + */ + DSetMemXferPropList xfer; + + xfer.setBuffer (1000, tconv_buf, NULL); + + /* Use chunked storage with compression */ + DSetCreatPropList dscreatplist; + + const hsize_t chunk_size[2] = {2, 25}; + dscreatplist.setChunk (2, chunk_size); + dscreatplist.setDeflate (6); + + /* Create the dataset */ + DataSet* dataset = new DataSet (file.createDataSet + (DSET_COMPRESS_NAME, PredType::NATIVE_INT, space1, dscreatplist)); + +#ifdef H5_HAVE_COMPRESS2 + PASSED(); +#else + SKIPPED(); + cout << not_supported << endl; +#endif + + /*---------------------------------------------------------------------- + * STEP 1: Read uninitialized data. It should be zero. + *---------------------------------------------------------------------- + */ + TESTING("compression (uninitialized read)"); + + dataset->read ((void*) check, PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer); + + for (i=0; i<size[0]; i++) { + for (j=0; j<size[1]; j++) { + if (0!=check[i][j]) { + FAILED(); + cout << " Read a non-zero value." << endl; + cout << " At index " << (unsigned long)i << "," << + (unsigned long)j << endl; + goto error; + } + } + } +#ifdef H5_HAVE_COMPRESS2 + PASSED(); +#else + SKIPPED(); + cout << not_supported << endl; +#endif + + /*---------------------------------------------------------------------- + * STEP 2: Test compression by setting up a chunked dataset and writing + * to it. + *---------------------------------------------------------------------- + */ + TESTING("compression (write)"); + + for (i=n=0; i<size[0]; i++) + { + for (j=0; j<size[1]; j++) + { + points[i][j] = n++; + } + } + + //if (H5Dwrite(dataset, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, xfer, points)<0) goto error; + dataset->write ((void*) points, PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer); +#ifdef H5_HAVE_COMPRESS2 + + PASSED(); +#else + SKIPPED(); + cout << not_supported << endl; +#endif + + /*---------------------------------------------------------------------- + * STEP 3: Try to read the data we just wrote. + *---------------------------------------------------------------------- + */ + TESTING("compression (read)"); + + /* Read the dataset back */ + dataset->read ((void*)check, PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer); + + /* 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++) + { + int status = check_values (i, j, points[i][j], check[i][j]); + if (status == -1) goto error; + } + +#ifdef H5_HAVE_COMPRESS2 + PASSED(); +#else + SKIPPED(); + cout << not_supported << endl; +#endif + + /*---------------------------------------------------------------------- + * 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("compression (modify)"); + + for (i=0; i<size[0]; i++) + { + for (j=0; j<size[1]/2; j++) + { + points[i][j] = rand (); + } + } + dataset->write ((void*)points, PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer); + + /* Read the dataset back and check it */ + dataset->read ((void*)check, PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer); + + /* 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++) + { + int status = check_values (i, j, points[i][j], check[i][j]); + if (status == -1) goto error; + } + +#ifdef H5_HAVE_COMPRESS2 + PASSED(); +#else + SKIPPED(); + cout << not_supported << endl; +#endif + + /*---------------------------------------------------------------------- + * STEP 5: Close the dataset and then open it and read it again. This + * insures that the compression message is picked up properly from the + * object header. + *---------------------------------------------------------------------- + */ + TESTING("compression (re-open)"); + + delete dataset; + + //if ((dataset = H5Dopen (file, DSET_COMPRESS_NAME))<0) goto error; + dataset = new DataSet (file.openDataSet (DSET_COMPRESS_NAME)); + dataset->read ((void*)check, PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer); + + /* 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++) + { + int status = check_values (i, j, points[i][j], check[i][j]); + if (status == -1) goto error; + } + +#ifdef H5_HAVE_COMPRESS2 + PASSED(); +#else + SKIPPED(); + cout << not_supported << endl; +#endif + + + /*---------------------------------------------------------------------- + * 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("compression (partial I/O)"); + + const hsize_t hs_size[2] = {4, 50}; + const hssize_t hs_offset[2] = {7, 30}; + for (i = 0; i < hs_size[0]; i++) { + for (j = 0; j < hs_size[1]; j++) { + points[hs_offset[0]+i][hs_offset[1]+j] = rand (); + } + } + space1.selectHyperslab( H5S_SELECT_SET, hs_size, hs_offset ); + dataset->write ((void*)points, PredType::NATIVE_INT, space1, space1, xfer); + dataset->read ((void*)check, PredType::NATIVE_INT, space1, space1, xfer); + + /* Check that the values read are the same as the values written */ + for (i=0; i<hs_size[0]; i++) { + for (j=0; j<hs_size[1]; j++) { + if (points[hs_offset[0]+i][hs_offset[1]+j] != + check[hs_offset[0]+i][hs_offset[1]+j]) { + FAILED(); + cout << " Read different values than written.\n" << endl; + cout << " At index " << (unsigned long)(hs_offset[0]+i) << + "," << (unsigned long)(hs_offset[1]+j) << endl; + + cout << " At original: " << (int)points[hs_offset[0]+i][hs_offset[1]+j] << endl; + cout << " At returned: " << (int)check[hs_offset[0]+i][hs_offset[1]+j] << endl; + goto error; + } + } + } +#ifdef H5_HAVE_COMPRESS2 + PASSED(); +#else + SKIPPED(); + cout << not_supported << endl; +#endif + + /*---------------------------------------------------------------------- + * STEP 7: Register an application-defined compression method and use it + * to write and then read the dataset. + *---------------------------------------------------------------------- + */ + TESTING("compression (app-defined method)"); + + // BMR: not sure how to handle this yet??? + if (H5Zregister (H5Z_BOGUS, DSET_BOGUS_NAME, bogus)<0) goto error; + if (H5Pset_filter (dscreatplist.getId(), H5Z_BOGUS, 0, 0, NULL)<0) goto error; + dscreatplist.setFilter (H5Z_BOGUS, 0, 0, NULL); + delete dataset; + + DataSpace space2 (2, size, NULL); + dataset = new DataSet (file.createDataSet (DSET_BOGUS_NAME, PredType::NATIVE_INT, space2, dscreatplist)); + + dataset->write ((void*)points, PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer); + dataset->read ((void*)check, PredType::NATIVE_INT, DataSpace::ALL, DataSpace::ALL, xfer); + + /* 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++) + { + int status = check_values (i, j, points[i][j], check[i][j]); + if (status == -1) goto error; + } + + PASSED(); + + /*---------------------------------------------------------------------- + * Cleanup + *---------------------------------------------------------------------- + */ + delete dataset; + delete [] tconv_buf; + return 0; + } // end try + + // catch all dataset, file, space, and plist exceptions + catch (Exception E) { goto error; } + + error: + // cleaning up + if (tconv_buf) + delete [] tconv_buf; + return -1; +} + +/*------------------------------------------------------------------------- + * Function: test_multiopen + * + * Purpose: Tests that a bug no longer exists. If a dataset is opened + * twice and one of the handles is used to extend the dataset, + * then the other handle should return the new size when + * queried. + * + * Return: Success: 0 + * + * Failure: -1 + * + * Programmer: Binh-Minh Ribler (using Robb Matzke's C version) + * Saturday, February 17, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static herr_t +test_multiopen (H5File& file) +{ + + TESTING("multi-open with extending"); + try { + + // Create a dataset creation property list + DSetCreatPropList dcpl; + + // Set chunk size to given size + hsize_t cur_size[1] = {10}; + dcpl.setChunk (1, cur_size); + + // Create a simple data space with unlimited size + static hsize_t max_size[1] = {H5S_UNLIMITED}; + DataSpace* space = new DataSpace (1, cur_size, max_size); + + // Create first dataset + DataSet dset1 = file.createDataSet ("multiopen", PredType::NATIVE_INT, *space, dcpl); + + //BMR: Quincey said Rob gave a tweak to have dataset being the first + // argument in this call but actually shouldn't be valid, so just + // ignore the argument dset1. Just open the first dataset again + // from the file to another DataSet object. + // if ((dset2=H5Dopen (dset1, "."))<0) goto error; + DataSet dset2 = file.openDataSet ("multiopen"); + + // Relieve the dataspace + delete space; + + // Extend the dimensionality of the first dataset + cur_size[0] = 20; + dset1.extend (cur_size); + + /* Get the size from the second handle */ + //if ((space = H5Dget_space (dset2))<0) goto error; + space = new DataSpace (dset2.getSpace()); + + hsize_t tmp_size[1]; + //if (H5Sget_simple_extent_dims (space, tmp_size, NULL)<0) goto error; + space->getSimpleExtentDims (tmp_size); + if (cur_size[0]!=tmp_size[0]) + { + FAILED(); + cout << " Got " << (int)tmp_size[0] << " instead of " + << (int)cur_size[0] << "!" << endl; + delete space; + goto error; + } + + delete space; + PASSED(); + return 0; + } // end try block + + // catch all dataset, file, space, and plist exceptions + catch (Exception E) + { goto error; } + + error: + return -1; +} + + +/*------------------------------------------------------------------------- + * Function: test_types + * + * Purpose: Make some datasets with various types so we can test h5ls. + * + * Return: Success: 0 + * + * Failure: -1 + * + * Programmer: Binh-Minh Ribler (using Robb Matzke's C version) + * February 17, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static herr_t +test_types(H5File& file) +{ + size_t i; + + TESTING("various datatypes"); + try { + + // Create a group in the file that was passed in from the caller + Group grp = file.createGroup ("typetests"); + + /* bitfield_1 */ + unsigned char buf[32]; + hsize_t nelmts = sizeof(buf); + DataType type; + try { // block 1 + type.copy (PredType::STD_B8LE); + DataSpace space (1, &nelmts); + DataSet* dset = new DataSet(grp.createDataSet("bitfield_1", type, space)); + + // Fill buffer + for (i=0; i<sizeof buf; i++) + buf[i] = (unsigned char)0xff ^ (unsigned char)i; + + // Write data from buf using all default dataspaces and property + // list; if writing fails, deallocate dset and return. + try { dset->write (buf, type); } + catch(DataSetIException E) + { + delete dset; + goto error; + } + delete dset; + + } // end try block of bitfield_1 + + // catch exceptions thrown in try block of bitfield_1 + catch (Exception E) { goto error; } + + /* bitfield_2 */ + nelmts = sizeof(buf)/2; + try { // bitfield_2 block + + type.copy (PredType::STD_B16LE); + DataSpace space (1, &nelmts); + DataSet* dset = new DataSet(grp.createDataSet("bitfield_2", type, space)); + + // Fill buffer + for (i=0; i<sizeof(buf); i++) + buf[i] = (unsigned char)0xff ^ (unsigned char)i; + + // Write data from buf using all default dataspaces and property + // list; if writing fails, deallocate dset and return. + try { dset->write (buf, type); } + catch(DataSetIException E) + { + delete dset; + goto error; + } + delete dset; + } // end try block of bitfield_2 + + // catch exceptions thrown in try block of bitfield_2 + catch (Exception E) { goto error; } + + /* opaque_1 */ + DataType* optype = new DataType(H5T_OPAQUE, 1); + try { // opaque_1 block + nelmts = sizeof(buf); + DataSpace space (1, &nelmts); + optype->setTag ("testing 1-byte opaque type"); + DataSet* dset = new DataSet(grp.createDataSet("opaque_1", *optype, space)); + + // Fill buffer + for (i=0; i<sizeof buf; i++) + buf[i] = (unsigned char)0xff ^ (unsigned char)i; + + // Write data from buf using all default dataspaces and property + // list; if writing fails, deallocate dset and return. + try { dset->write (buf, *optype); } + catch(DataSetIException E) + { + delete dset; + goto error; + } + delete dset; + delete optype; + } // end try block of opaque_1 + + // catch exceptions thrown in try block of opaque_1 + catch (DataSetIException E) { delete optype; goto error; } + catch (Exception E) { goto error; } + + /* opaque_2 */ + try { // block opaque_2 + nelmts = sizeof(buf)/4; + DataSpace space (1, &nelmts); + optype = new DataType(H5T_OPAQUE, 4); + optype->setTag ("testing 4-byte opaque type"); + DataSet* dset = new DataSet(grp.createDataSet("opaque_2", *optype, space)); + + // Fill buffer + for (i=0; i<sizeof(buf); i++) + buf[i] = (unsigned char)0xff ^ (unsigned char)i; + + // Write data from buf using all default dataspaces and property + // list; if writing fails, deallocate dset and return. + try { dset->write (buf, *optype); } + catch(DataSetIException E) + { + delete dset; + goto error; + } + delete dset; + delete optype; + } //end try block of opaque_2 + catch (DataSetIException E) { delete optype; goto error; } + catch (Exception E) { goto error; } + + PASSED(); + return 0; + } // end top try block + catch (Exception E) { goto error; } // Group and DataType exceptions + + error: + return -1; +} + + +/*------------------------------------------------------------------------- + * Function: test_report + * + * Purpose: Prints out the number of errors for dataset tests if there + * were any failures occurred. If no failure, test_report + * prints out the "All dataset tests passed" message + * + * Return: if any failure has occurred: 1 + * + * if no failure occurs: 0 + * + * Programmer: Binh-Minh Ribler (using C code segment for reporting tests) + * Friday, February 6, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +int test_report( int nerrors ) +{ + if (nerrors) + { + nerrors = MAX(1, nerrors); + if (1 == nerrors) + cout << "***** " << nerrors << " DATASET TEST" + << " FAILED! *****" << endl; + else + cout << "***** " << nerrors << " DATASET TESTS" + << " FAILED! *****" << endl; + return 1; + } + else + { + cout << "All dataset tests passed." << endl; + return 0; + } +} + +/*------------------------------------------------------------------------- + * Function: main + * + * Purpose: Tests the dataset interface (H5D) + * + * Return: Success: exit(0) + * + * Failure: exit(1) + * + * Programmer: Binh-Minh Ribler (using Robb Matzke's C version) + * Friday, January 5, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +int +main(void) +{ + + h5_reset(); // in h5test.c, resets the library by closing it + + hid_t fapl_id; + fapl_id = h5_fileaccess(); // in h5test.c, returns a file access template + // should create an object from this id - BMR + +/* BMR: leave paralell stuff out! +#if 0 + { + // Turn off raw data cache + int mdc_nelmts; + (H5Pget_cache(fapl_id, &mdc_nelmts, NULL, NULL, NULL)<0) goto error; + (H5Pset_cache(fapl_id, mdc_nelmts, 0, 0, 0.0)<0) goto error; + } +#endif +*/ + + char filename[1024]; + h5_fixname(FILENAME[0], fapl_id, filename, sizeof filename); + + int nerrors=0; // keep track of number of failures occurr + try + { + // Turn of the auto-printing when failure occurs so that we can + // handle the errors appropriately since sometime failures are + // caused deliberately and expected. + Exception::dontPrint(); + + // Use the file access template id to create a file access prop. + // list object to pass in H5File::H5File + FileAccPropList* fapl = new FileAccPropList(fapl_id); + + H5File file( filename, H5F_ACC_TRUNC, FileCreatPropList::DEFAULT, *fapl ); + + /* Cause the library to emit initial messages */ + Group grp = file.createGroup( "emit diagnostics", 0); + grp.setComment( ".", "Causes diagnostic messages to be emitted"); + + nerrors += test_create(file)<0 ?1:0; + nerrors += test_simple_io(file)<0 ?1:0; + nerrors += test_tconv(file)<0 ?1:0; + nerrors += test_compression(file)<0 ?1:0; + nerrors += test_multiopen (file)<0 ?1:0; + nerrors += test_types(file)<0 ?1:0; + + // BMR: this is a very unattractive workaround approach, but I used + // it for now, since I want to use already existing utility code from + // the C tests. h5_cleanup calls H5Pclose to close the fapl_id while + // the object 'fapl' is still opened. So, I dynamically allocated + // 'fapl' then deleted it before h5_cleanup, but after incrementing + // 'fapl's ref counter so that the prop list id will not be closed + // when 'fapl' is destroyed. Why did I need to create a + // FileCreatPropList object while I already had the prop list id? + // Because I need to pass it into the constructor H5File::H5File. + // We're trying to avoid introducing id's into the C++ API. + fapl->incRefCount(); + delete fapl; + h5_cleanup(FILENAME, fapl_id); + return( test_report( nerrors )); + } + catch (FileIException error) + { + return( test_report( nerrors )); + } + catch (GroupIException error ) + { + return( test_report( nerrors )); + } +} + + diff --git a/c++/test/testhdf5.cpp b/c++/test/testhdf5.cpp new file mode 100644 index 0000000..28d6a54 --- /dev/null +++ b/c++/test/testhdf5.cpp @@ -0,0 +1,312 @@ +/**************************************************************************** + * NCSA HDF * + * Software Development Group * + * National Center for Supercomputing Applications * + * University of Illinois at Urbana-Champaign * + * 605 E. Springfield, Champaign IL 61820 * + * * + * For conditions of distribution and use, see the accompanying * + * hdf/COPYING file. * + * * + ****************************************************************************/ + +/* + FILE + testhdf5.c - HDF5 testing framework main file. + + REMARKS + General test wrapper for HDF5 base library test programs + + DESIGN + Each test function should be implemented as function having no + parameters and returning void (i.e. no return value). They should be put + into the list of InitTest() calls in main() below. Functions which depend + on other functionality should be placed below the InitTest() call for the + base functionality testing. + Each test module should include testhdf5.h and define a unique set of + names for test files they create. + + BUGS/LIMITATIONS + + EXPORTED ROUTINES/VARIABLES: + Two variables are exported: num_errs, and Verbosity. + + */ + +#if defined __MWERKS__ +#include <console.h> +#endif + +#include <stdarg.h> + +#define MAXNUMOFTESTS 30 +#define HDF5_TEST_MASTER + +/* Internal Variables */ +static int Index = 0; + +/* Global variables */ +int num_errs = 0; +int Verbosity; + +// Use C version of the header file testhdf5.h instead of re-coding it +#include <testhdf5.h> +#include <H5Cpp.h> + +#ifndef H5_NO_NAMESPACE +using namespace H5; +#endif + +struct TestStruct { + int NumErrors; + char Description[64]; + int SkipFlag; + char Name[16]; + void (*Call) (void); + void (*Cleanup) (void); +} Test[MAXNUMOFTESTS]; + +static void InitTest(const char *TheName, void (*TheCall) (void), void (*Cleanup) (void), const char *TheDescr); +static void usage(void); + +static void +InitTest(const char *TheName, void (*TheCall) (void), void (*Cleanup) (void), const char *TheDescr) +{ + if (Index >= MAXNUMOFTESTS) { + print_func("Uh-oh, too many tests added, increase MAXNUMOFTEST!\n"); + exit(-1); + } /* end if */ + HDstrcpy(Test[Index].Description, TheDescr); + HDstrcpy(Test[Index].Name, TheName); + Test[Index].Call = TheCall; + Test[Index].Cleanup = Cleanup; + Test[Index].NumErrors = -1; + Test[Index].SkipFlag = 0; + Index++; +} + +static void +usage(void) +{ + intn i; + + print_func("Usage: testhdf5 [-v[erbose] (l[ow]|m[edium]|h[igh]|0-10)] \n"); + print_func(" [-[e]x[clude] name+] \n"); + print_func(" [-o[nly] name+] \n"); + print_func(" [-b[egin] name] \n"); + print_func(" [-s[ummary]] \n"); + print_func(" [-c[leanoff]] \n"); + print_func(" [-n[ocaching]] \n"); + print_func(" [-h[elp]] \n"); + print_func("\n\n"); + print_func("verbose controls the amount of information displayed\n"); + print_func("exclude to exclude tests by name\n"); + print_func("only to name tests which should be run\n"); + print_func("begin start at the name of the test givin\n"); + print_func("summary prints a summary of test results at the end\n"); + print_func("cleanoff does not delete *.hdf files after execution of tests\n"); + print_func("nocaching do not turn on low-level DD caching\n"); + print_func("help print out this information\n"); + print_func("\n\n"); + print_func("This program currently tests the following: \n\n"); + print_func("%16s %s\n", "Name", "Description"); + print_func("%16s %s\n", "----", "-----------"); + for (i = 0; i < Index; i++) + print_func("%16s %s\n", Test[i].Name, Test[i].Description); + print_func("\n\n"); +} /* end usage() */ + +/* + * This routine is designed to provide equivalent functionality to 'printf' + * and allow easy replacement for environments which don't have stdin/stdout + * available. (i.e. Windows & the Mac) + */ +int +print_func(const char *format,...) +{ + va_list arglist; + int ret_value; + + va_start(arglist, format); + ret_value = vprintf(format, arglist); + va_end(arglist); + return (ret_value); +} + +void +test_tbbt(void) +{ } + +int +main(int argc, char *argv[]) +{ + int CLLoop; /* Command Line Loop */ + int Loop, Loop1; + int Summary = 0; + int CleanUp = 1; + int Cache = 1; + +#if defined __MWERKS__ + argc = ccommand(&argv); +#endif + +#if !(defined MAC || defined __MWERKS__ || defined SYMANTEC_C) + /* Un-buffer the stdout and stderr */ + setbuf(stderr, NULL); + setbuf(stdout, NULL); +#endif + + /* + * Turn off automatic error reporting since we do it ourselves. Besides, + * half the functions this test calls are private, so automatic error + * reporting wouldn't do much good since it's triggered at the API layer. + */ + Exception::dontPrint(); + + // Tests are generally arranged from least to most complexity... + //InitTest("metadata", test_metadata, cleanup_metadata, "Encode/decode metadata code"); + + // C++ API doesn't need this test */ + InitTest("tbbt", test_tbbt, NULL, "Threaded, Balanced, Binary Trees - not tested"); + + // testing file creation and opening in tfile.cpp + InitTest("file", test_file, cleanup_file, "Low-Level File I/O"); + + // Comment out tests that are not done yet. - BMR, Feb 2001 + //InitTest("h5s", test_h5s, cleanup_h5s, "Dataspaces"); + //InitTest("attr", test_attr, cleanup_attr, "Attributes"); + //InitTest("select", test_select, cleanup_select, "Selections"); + //InitTest("time", test_time, cleanup_time, "Time Datatypes"); + //InitTest("reference", test_reference, cleanup_reference, "References"); + //InitTest("vltypes", test_vltypes, cleanup_vltypes, "Variable-Length Datatypes"); + //InitTest("vlstrings", test_vlstrings, cleanup_vlstrings, "Variable-Length Strings"); + //InitTest("iterate", test_iterate, cleanup_iterate, "Group & Attribute Iteration"); + //InitTest("array", test_array, cleanup_array, "Array Datatypes"); + //InitTest("genprop", test_genprop, cleanup_genprop, "Generic Properties"); + + Verbosity = 4; /* Default Verbosity is Low */ + uintn major, minor, release; + H5Library::getLibVersion( major, minor, release); + + print_func("\nFor help use: testhdf5 -help\n"); + print_func("Linked with hdf5 version %u.%u release %u\n", + (unsigned)major, (unsigned)minor, (unsigned)release); + for (CLLoop = 1; CLLoop < argc; CLLoop++) { + if ((argc > CLLoop + 1) && ((HDstrcmp(argv[CLLoop], "-verbose") == 0) || + (HDstrcmp(argv[CLLoop], "-v") == 0))) { + if (argv[CLLoop + 1][0] == 'l') + Verbosity = 4; + else if (argv[CLLoop + 1][0] == 'm') + Verbosity = 6; + else if (argv[CLLoop + 1][0] == 'h') + Verbosity = 10; + else + Verbosity = atoi(argv[CLLoop + 1]); + } /* end if */ + if ((argc > CLLoop) && ((HDstrcmp(argv[CLLoop], "-summary") == 0) || + (HDstrcmp(argv[CLLoop], "-s") == 0))) + Summary = 1; + + if ((argc > CLLoop) && ((HDstrcmp(argv[CLLoop], "-help") == 0) || + (HDstrcmp(argv[CLLoop], "-h") == 0))) { + usage(); + exit(0); + } + if ((argc > CLLoop) && ((HDstrcmp(argv[CLLoop], "-cleanoff") == 0) || + (HDstrcmp(argv[CLLoop], "-c") == 0))) + CleanUp = 0; + + if ((argc > CLLoop) && ((HDstrcmp(argv[CLLoop], "-nocache") == 0) || + (HDstrcmp(argv[CLLoop], "-n") == 0))) { + Cache = 0; + printf ("Cache = %d\n", Cache); + } + + if ((argc > CLLoop + 1) && ((HDstrcmp(argv[CLLoop], "-exclude") == 0) || + (HDstrcmp(argv[CLLoop], "-x") == 0))) { + Loop = CLLoop + 1; + while ((Loop < argc) && (argv[Loop][0] != '-')) { + for (Loop1 = 0; Loop1 < Index; Loop1++) + if (HDstrcmp(argv[Loop], Test[Loop1].Name) == 0) + Test[Loop1].SkipFlag = 1; + Loop++; + } /* end while */ + } /* end if */ + if ((argc > CLLoop + 1) && ((HDstrcmp(argv[CLLoop], "-begin") == 0) || + (HDstrcmp(argv[CLLoop], "-b") == 0))) { + Loop = CLLoop + 1; + while ((Loop < argc) && (argv[Loop][0] != '-')) { + for (Loop1 = 0; Loop1 < Index; Loop1++) { + if (HDstrcmp(argv[Loop], Test[Loop1].Name) != 0) + Test[Loop1].SkipFlag = 1; + if (HDstrcmp(argv[Loop], Test[Loop1].Name) == 0) + Loop1 = Index; + } /* end for */ + Loop++; + } /* end while */ + } /* end if */ + if ((argc > CLLoop + 1) && ((HDstrcmp(argv[CLLoop], "-only") == 0) || + (HDstrcmp(argv[CLLoop], "-o") == 0))) { + for (Loop = 0; Loop < Index; Loop++) + Test[Loop].SkipFlag = 1; + Loop = CLLoop + 1; + while ((Loop < argc) && (argv[Loop][0] != '-')) { + for (Loop1 = 0; Loop1 < Index; Loop1++) + if (HDstrcmp(argv[Loop], Test[Loop1].Name) == 0) + Test[Loop1].SkipFlag = 0; + Loop++; + } /* end while */ + } /* end if */ + } /* end for */ + +#ifdef NOT_YET + if (Cache) /* turn on caching, unless we were instucted not to */ + Hcache(CACHE_ALL_FILES, TRUE); +#endif /* NOT_YET */ + + for (Loop = 0; Loop < Index; Loop++) { + if (Test[Loop].SkipFlag) { + MESSAGE(2, ("Skipping -- %s \n", Test[Loop].Description)); + } else { + MESSAGE(2, ("Testing -- %s (%s) \n", Test[Loop].Description, + Test[Loop].Name)); + MESSAGE(5, ("===============================================\n")); + Test[Loop].NumErrors = num_errs; + (*Test[Loop].Call) (); + Test[Loop].NumErrors = num_errs - Test[Loop].NumErrors; + MESSAGE(5, ("===============================================\n")); + MESSAGE(5, ("There were %d errors detected.\n\n", (int) Test[Loop].NumErrors)); + } /* end else */ + } /* end for */ + + MESSAGE(2, ("\n\n")) + if (num_errs) + print_func("!!! %d Error(s) were detected !!!\n\n", (int) num_errs); + else + print_func("All tests were successful. \n\n"); + + if (Summary) { + print_func("Summary of Test Results:\n"); + print_func("Name of Test Errors Description of Test\n"); + print_func("---------------- ------ --------------------------------------\n"); + + for (Loop = 0; Loop < Index; Loop++) { + if (Test[Loop].NumErrors == -1) + print_func("%16s %6s %s\n", Test[Loop].Name, "N/A", Test[Loop].Description); + else + print_func("%16s %6d %s\n", Test[Loop].Name, (int) Test[Loop].NumErrors, + Test[Loop].Description); + } /* end for */ + print_func("\n\n"); + } /* end if */ + if (CleanUp && !getenv("HDF5_NOCLEANUP")) { + MESSAGE(2, ("\nCleaning Up temp files...\n\n")); + + /* call individual cleanup routines in each source module */ + for (Loop = 0; Loop < Index; Loop++) + if (!Test[Loop].SkipFlag && Test[Loop].Cleanup!=NULL) + (*Test[Loop].Cleanup) (); + } + return (num_errs); +} /* end main() */ + diff --git a/c++/test/tfile.cpp b/c++/test/tfile.cpp new file mode 100644 index 0000000..f359eb7 --- /dev/null +++ b/c++/test/tfile.cpp @@ -0,0 +1,332 @@ +/**************************************************************************** + * NCSA HDF * + * Software Development Group * + * National Center for Supercomputing Applications * + * University of Illinois at Urbana-Champaign * + * 605 E. Springfield, Champaign IL 61820 * + * * + * For conditions of distribution and use, see the accompanying * + * hdf/COPYING file. * + * * + ****************************************************************************/ + +/*********************************************************** +* +* Test program: tfile +* +* Test the low-level file I/O features. +* +*************************************************************/ + +#include <testhdf5.h> +#include <H5Cpp.h> + +#ifndef H5_NO_NAMESPACE +using namespace H5; +#endif + +#include <H5private.h> +#include <H5Bprivate.h> +#include <H5Pprivate.h> + +#define F1_USERBLOCK_SIZE (hsize_t)0 +#define F1_OFFSET_SIZE sizeof(haddr_t) +#define F1_LENGTH_SIZE sizeof(hsize_t) +#define F1_SYM_LEAF_K 4 +#define F1_SYM_INTERN_K 16 +#define FILE1 "tfile1.h5" + +#define F2_USERBLOCK_SIZE (hsize_t)512 +#define F2_OFFSET_SIZE 8 +#define F2_LENGTH_SIZE 8 +#define F2_SYM_LEAF_K 8 +#define F2_SYM_INTERN_K 32 +#define FILE2 "tfile2.h5" + +#define F3_USERBLOCK_SIZE (hsize_t)0 +#define F3_OFFSET_SIZE F2_OFFSET_SIZE +#define F3_LENGTH_SIZE F2_LENGTH_SIZE +#define F3_SYM_LEAF_K F2_SYM_LEAF_K +#define F3_SYM_INTERN_K F2_SYM_INTERN_K +#define FILE3 "tfile3.h5" + + +/*------------------------------------------------------------------------- + * Function: test_file_create + * + * Purpose: Test file and template creations + * + * Return: None + * + * Programmer: Binh-Minh Ribler + * January, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static void +test_file_create(void) +{ + hid_t tmpl1, tmpl2; /*file creation templates */ + int iparm, iparm2; + herr_t ret; /*generic return value */ + + /* Output message about test being performed */ + MESSAGE(5, ("Testing Low-Level File Creation I/O\n")); + + /* Test create with various sequences of H5F_ACC_EXCL and */ + /* H5F_ACC_TRUNC flags */ + + /* Create with H5F_ACC_EXCL */ + /* First ensure the file does not exist */ + //remove(FILE1); + + try { + H5File* fid1 = new H5File (FILE1, H5F_ACC_EXCL); + + /* + * try to create the same file with H5F_ACC_TRUNC. This should fail + * because fid1 is the same file and is currently open. + */ + try { H5File fid2 (FILE1, H5F_ACC_TRUNC); } + catch( FileIException error ) { + // cannot use fid2 here (out of scope), but the exception was + // thrown only if file id was < 0, so -1 is used to verify - 1/15/01 + VERIFY(-1, FAIL, "H5File constructor"); + } + // Close file fid1 + delete fid1; + + /* + * Try again with H5F_ACC_EXCL. This should fail because the file already + * exists from the previous steps. + */ + try { fid1 = new H5File( FILE1, H5F_ACC_EXCL ); } + catch( FileIException error ){ VERIFY(-1, FAIL, "H5File constructor"); } + + // Test create with H5F_ACC_TRUNC. This will truncate the existing file. + fid1 = new H5File (FILE1, H5F_ACC_TRUNC); + + /* + * Try to truncate first file again. This should fail because fid1 is the + * same file and is currently open. + */ + try { H5File fid2 (FILE1, H5F_ACC_TRUNC); } + catch( FileIException error ) { VERIFY(-1, FAIL, "H5File constructor"); } + + /* + * Try with H5F_ACC_EXCL. This should fail too because the file already + * exists. + */ + try { H5File fid3 (FILE1, H5F_ACC_EXCL); } + catch( FileIException error ) { VERIFY(-1, FAIL, "H5File constructor"); } + + /* Get the file-creation template */ + FileCreatPropList tmpl1 = fid1->getCreatePlist(); + + hsize_t ublock = tmpl1.getUserblock(); + VERIFY(ublock, F1_USERBLOCK_SIZE, "FileCreatPropList::H5Pget_userblock"); + + size_t parm1, parm2; /*file-creation parameters */ + tmpl1.getSizes( parm1, parm2); + VERIFY(parm1, F1_OFFSET_SIZE, "FileCreatPropList::getSizes"); + VERIFY(parm2, F1_LENGTH_SIZE, "FileCreatPropList::getSizes"); + + int iparm1, iparm2; /*file-creation parameters */ + tmpl1.getSymk( iparm1, iparm2); + VERIFY(iparm1, F1_SYM_INTERN_K, "FileCreatPropList::getSymk"); + VERIFY(iparm2, F1_SYM_LEAF_K, "FileCreatPropList::getSymk"); + + // tmpl1 is automatically closed; if error occurs, it'll be + // caught in the catch block + + /* Close first file */ + delete fid1; + } + catch( PropListIException error ) { + CHECK(-1, FAIL, error.getCDetailMesg()); + } + catch( FileIException error ) { + CHECK(-1, FAIL, error.getCDetailMesg()); + } + + try + { + /* Create a new file with a non-standard file-creation template */ + FileCreatPropList* tmpl1 = new FileCreatPropList; + + /* Set the new file-creation parameters */ + tmpl1->setUserblock (F2_USERBLOCK_SIZE); + tmpl1->setSizes( F2_OFFSET_SIZE, F2_LENGTH_SIZE ); + tmpl1->setSymk( F2_SYM_INTERN_K, F2_SYM_LEAF_K ); + + /* + * Try to create second file, with non-standard file-creation template + * params. + */ + H5File fid2( FILE2, H5F_ACC_TRUNC, *tmpl1 ); + + /* Release file-creation template */ + delete tmpl1; + + /* Get the file-creation template */ + tmpl1 = new FileCreatPropList (fid2.getCreatePlist()); + + /* Get the file-creation parameters */ + hsize_t ublock = tmpl1->getUserblock(); + VERIFY(ublock, F2_USERBLOCK_SIZE, "FileCreatPropList::getUserblock"); + + size_t parm1, parm2; /*file-creation parameters */ + tmpl1->getSizes( parm1, parm2); + VERIFY(parm1, F2_OFFSET_SIZE, "FileCreatPropList::getSizes"); + VERIFY(parm2, F2_LENGTH_SIZE, "FileCreatPropList::getSizes"); + + int iparm1, iparm2; /*file-creation parameters */ + tmpl1->getSymk( iparm1, iparm2); + VERIFY(iparm1, F2_SYM_INTERN_K, "FileCreatPropList::getSymk"); + VERIFY(iparm2, F2_SYM_LEAF_K, "FileCreatPropList::getSymk"); + + /* Clone the file-creation template */ + FileCreatPropList tmpl2; + tmpl2.copy (*tmpl1); + + /* Dynamically release file-creation template */ + delete tmpl1; + + /* Set the new file-creation parameter */ + tmpl2.setUserblock( F3_USERBLOCK_SIZE ); + + /* + * Try to create second file, with non-standard file-creation template + * params + */ + H5File fid3( FILE3, H5F_ACC_TRUNC, tmpl2 ); + + /* Get the file-creation template */ + tmpl1 = new FileCreatPropList (fid3.getCreatePlist()); + + /* Get the file-creation parameters */ + ublock = tmpl1->getUserblock(); + VERIFY(ublock, F3_USERBLOCK_SIZE, "FileCreatPropList::getUserblock"); + + tmpl1->getSizes( parm1, parm2); + VERIFY(parm1, F3_OFFSET_SIZE, "FileCreatPropList::getSizes"); + VERIFY(parm2, F3_LENGTH_SIZE, "FileCreatPropList::getSizes"); + + tmpl1->getSymk( iparm1, iparm2); + VERIFY(iparm1, F3_SYM_INTERN_K, "FileCreatPropList::getSymk"); + VERIFY(iparm2, F3_SYM_LEAF_K, "FileCreatPropList::getSymk"); + + /* Dynamically release file-creation template */ + delete tmpl1; + } + catch( PropListIException error ) { + CHECK(-1, FAIL, error.getCDetailMesg()); + } + catch( FileIException error ) { + CHECK(-1, FAIL, error.getCDetailMesg()); + } +} /* test_file_create() */ + + +/*------------------------------------------------------------------------- + * Function: test_file_open + * + * Purpose: Test file accesses + * + * Return: None + * + * Programmer: Binh-Minh Ribler + * January, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static void +test_file_open(void) +{ + /* Output message about test being performed */ + MESSAGE(5, ("Testing Low-Level File Opening I/O\n")); + + try { + + /* Open first file */ + H5File fid1 (FILE2, H5F_ACC_RDWR ); + + /* Get the file-creation template */ + //FileCreatPropList tmpl1; + FileCreatPropList tmpl1 = fid1.getCreatePlist(); + + /* Get the file-creation parameters */ + hsize_t ublock = tmpl1.getUserblock(); + VERIFY(ublock, F2_USERBLOCK_SIZE, "FileCreatPropList::getUserblock"); + + size_t parm1, parm2; /*file-creation parameters */ + tmpl1.getSizes( parm1, parm2); + VERIFY(parm1, F2_OFFSET_SIZE, "FileCreatPropList::getSizes"); + VERIFY(parm2, F2_LENGTH_SIZE, "FileCreatPropList::getSizes"); + + int iparm1, iparm2; /*file-creation parameters */ + tmpl1.getSymk( iparm1, iparm2); + VERIFY(iparm1, F2_SYM_INTERN_K, "FileCreatPropList::getSymk"); + VERIFY(iparm2, F2_SYM_LEAF_K, "FileCreatPropList::getSymk"); + } // end of try block + + catch( FileIException error ) { + CHECK(FAIL, FAIL, error.getCDetailMesg()); + } + catch( PropListIException error ) { + CHECK(FAIL, FAIL, error.getCDetailMesg()); + } +} /* test_file_open() */ + + +/*------------------------------------------------------------------------- + * Function: test_file + * + * Purpose: Main program + * + * Return: None + * + * Programmer: Binh-Minh Ribler + * January, 2001 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +void +test_file(void) +{ + /* Output message about test being performed */ + MESSAGE(5, ("Testing Low-Level File I/O\n")); + + test_file_create(); /* Test file creation (also creation templates) */ + test_file_open(); /* Test file opening */ +} /* test_file() */ + + +/*------------------------------------------------------------------------- + * Function: cleanup_file + * + * Purpose: Cleanup temporary test files + * + * Return: none + * + * Programmer: Albert Cheng + * July 2, 1998 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +void +cleanup_file(void) +{ + remove(FILE1); + remove(FILE2); + remove(FILE3); +} + |