path: root/c++/test/dsets.cpp

/*
 * Copyright (C) 2001 National Center for Supercomputing Applications
 *                    All rights reserved.
 *
 */

/***********************************************************
*
* Test program:  dsets
*
* Test the dataset interface
*
*************************************************************/

#include <iostream>
#include "H5Cpp.h"
#include "h5test.h"
#include "testhdf5.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 (using C version)
 *		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
	    H5_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
	    H5_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)
    {
	H5_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 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++;
	}
    }

    char* 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 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 (int 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]) 
	    {
		H5_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 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++;
	}
    }
    char* 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_COMPRESSION
    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]) {
		    H5_FAILED();
		    cout << "    Read a non-zero value." << endl;
		    cout << "    At index " << (unsigned long)i << "," << 
		   (unsigned long)j << endl;
		    goto error;
		}
	    }
	}
#ifdef H5_HAVE_COMPRESSION
    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_COMPRESSION
    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_COMPRESSION
    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_COMPRESSION
    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_COMPRESSION
    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]) {
		H5_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_COMPRESSION
    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 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]) 
	{
	    H5_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 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 of bitfield_1
	    // test copying a predefined type
	    type.copy (PredType::STD_B8LE);

	    // Test copying a user-defined type using DataType::copy
	    DataType copied_type;
	    copied_type.copy(type);
	    // Test copying a user-defined type using DataType::operator=
	    DataType another_copied_type;
	    another_copied_type = type;

	    // Test copying a user-defined int type using DataType::operator=
	    IntType orig_int(PredType::STD_B8LE);
	    DataType generic_type;
	    generic_type = orig_int;

	    // Test copying an integer predefined type
	    IntType new_int_type(PredType::STD_B8LE);

	    // Test copying an int predefined type using DataType::operator=
	    IntType another_int_type;
	    another_int_type = new_int_type;

	    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) { 
	    cout << "Failure in " << E.getFuncName() << " - " 
		 << E.getDetailMsg() << endl;
	    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) 
	    {
	    	cout << "Failure in " << E.getFuncName() << " - " 
		 << E.getDetailMsg() << endl;
		delete dset;
		goto error;
	    }
	    delete dset;
	} // end try block of bitfield_2

	// catch exceptions thrown in try block of bitfield_2
	catch (Exception E) {
	    cout << "Failure in " << E.getFuncName() << " - " 
		 << E.getDetailMsg() << endl;
	    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;
	    cout << "Failure in " << E.getFuncName() << " - " 
		 << E.getDetailMsg() << endl;
	    goto error;
	}
	catch (Exception E) {
	    cout << "Failure in " << E.getFuncName() << " - " 
		 << E.getDetailMsg() << endl;
	    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;
	    cout << "Failure in " << E.getFuncName() << " - " 
		 << E.getDetailMsg() << endl;
	    goto error;
	}
	catch (Exception E) {
	    cout << "Failure in " << E.getFuncName() << " - " 
		 << E.getDetailMsg() << endl;
	    goto error;
	}
    
    PASSED();
    return 0;
    } // end top try block

    catch (Exception E) { // Group and DataType exceptions
	    cout << "Failure in " << E.getFuncName() << " - " 
		 << E.getDetailMsg() << endl;
	    goto error;
    }

 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 C version)
 *		Friday, January 5, 2001
 *
 * Modifications:
 *	Nov 12, 01:
 *		- moved h5_cleanup to outside of try block because
 *		  dataset.h5 cannot be removed until "file" is out of
 *		  scope and dataset.h5 is closed. 
 *
 *-------------------------------------------------------------------------
 */
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
    
    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(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;

	// increment the ref count of this property list so that the 
	// property list id won't be closed when fapl goes out of scope.
	// This is a bad hack, but I want to use existing routine h5_cleanup!
	fapl.incRefCount();
    }
    catch (Exception E) 
    {
	return( test_report( nerrors ));
    }
    /* use C test utility routine to clean up data files */
    h5_cleanup(FILENAME, fapl_id);

    /* print out dsets test results */
    return( test_report( nerrors ));
}