hdf5/c++/test/tfile.cpp

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 * 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://www.hdfgroup.org/licenses.               *
 * If you do not have access to either file, you may request a copy from     *
 * help@hdfgroup.org.                                                        *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/*****************************************************************************
   FILE
   tfile.cpp - HDF5 C++ testing the file I/O features

   EXTERNAL ROUTINES/VARIABLES:
     These routines are in the test directory of the C library:
        h5_fileaccess() -- in h5test.c, returns a file access template

 ***************************************************************************/
#include <iostream>
using std::cerr;
using std::endl;

#include <string>
#include "H5Cpp.h" // C++ API header file
using namespace H5;

#include "h5test.h"
#include "h5cpputil.h" // C++ utilility header file

const hsize_t      F1_USERBLOCK_SIZE = 0;
const size_t       F1_OFFSET_SIZE    = sizeof(haddr_t);
const size_t       F1_LENGTH_SIZE    = sizeof(hsize_t);
const unsigned     F1_SYM_LEAF_K     = 4;
const unsigned     F1_SYM_INTERN_K   = 16;
const H5std_string FILE1("tfile1.h5");

const hsize_t      F2_USERBLOCK_SIZE = 512;
const size_t       F2_OFFSET_SIZE    = 8;
const size_t       F2_LENGTH_SIZE    = 8;
const unsigned     F2_SYM_LEAF_K     = 8;
const unsigned     F2_SYM_INTERN_K   = 32;
const unsigned     F2_ISTORE         = 64;
const H5std_string FILE2("tfile2.h5");

const hsize_t      F3_USERBLOCK_SIZE = 0;
const size_t       F3_OFFSET_SIZE    = F2_OFFSET_SIZE;
const size_t       F3_LENGTH_SIZE    = F2_LENGTH_SIZE;
const unsigned     F3_SYM_LEAF_K     = F2_SYM_LEAF_K;
const unsigned     F3_SYM_INTERN_K   = F2_SYM_INTERN_K;
const H5std_string FILE3("tfile3.h5");

const int          KB = 1024;
const H5std_string FILE4("tfile4.h5");

/*-------------------------------------------------------------------------
 * Function:    test_file_create
 *
 * Purpose      Test file and template creations
 *
 * Return       None
 *-------------------------------------------------------------------------
 */
static void
test_file_create()
{
    // Output message about test being performed
    SUBTEST("File Creation I/O");

    // 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.c_str());

    // Setting this to NULL for cleaning up in failure situations
    H5File *file1 = NULL;
    try {
        // Create file FILE1
        file1 = new H5File(FILE1, H5F_ACC_EXCL);

        // Try to create the same file with H5F_ACC_TRUNC. This should fail
        // because file1 is the same file and is currently open.
        try {
            H5File file2(FILE1, H5F_ACC_TRUNC); // should throw E

            // Should FAIL but didn't, so throw an invalid action exception
            throw InvalidActionException("H5File constructor", "Attempted to create an existing file.");
        }
        catch (FileIException &E) // catch truncating existing file
        {
        } // do nothing, FAIL expected

        // Close file1
        delete file1;
        file1 = NULL;

        // Try again with H5F_ACC_EXCL. This should fail because the file
        // already exists from the previous steps.
        try {
            H5File file2(FILE1, H5F_ACC_EXCL); // should throw E

            // Should FAIL but didn't, so throw an invalid action exception
            throw InvalidActionException("H5File constructor", "File already exists.");
        }
        catch (FileIException &E) // catching creating existing file
        {
        } // do nothing, FAIL expected

        // Test create with H5F_ACC_TRUNC. This will truncate the existing file.
        file1 = new H5File(FILE1, H5F_ACC_TRUNC);

        // Try to create first file again. This should fail because file1
        // is the same file and is currently open.
        try {
            H5File file2(FILE1, H5F_ACC_TRUNC); // should throw E

            // Should FAIL but didn't, so throw an invalid action exception
            throw InvalidActionException("H5File constructor", "H5F_ACC_TRUNC attempt on an opened file.");
        }
        catch (FileIException &E) // catching truncating opened file
        {
        } // do nothing, FAIL expected

        // Try with H5F_ACC_EXCL. This should fail too because the file already
        // exists.
        try {
            H5File file3(FILE1, H5F_ACC_EXCL); // should throw E

            // Should FAIL but didn't, so throw an invalid action exception
            throw InvalidActionException("H5File constructor", "H5F_ACC_EXCL attempt on an existing file.");
        }
        catch (FileIException &E) // catching H5F_ACC_EXCL on existing file
        {
        } // do nothing, FAIL expected

        // Get the file-creation template
        FileCreatPropList tmpl1 = file1->getCreatePlist();

        hsize_t ublock = tmpl1.getUserblock();
        verify_val(static_cast<long>(ublock), static_cast<long>(F1_USERBLOCK_SIZE),
                   "FileCreatPropList::getUserblock", __LINE__, __FILE__);

        size_t parm1, parm2; // file-creation parameters
        tmpl1.getSizes(parm1, parm2);
        verify_val(parm1, F1_OFFSET_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);
        verify_val(parm2, F1_LENGTH_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);

        unsigned iparm1, iparm2; // file-creation parameters
        tmpl1.getSymk(iparm1, iparm2);
        verify_val(iparm1, F1_SYM_INTERN_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);
        verify_val(iparm2, F1_SYM_LEAF_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);

        // tmpl1 is automatically closed; if error occurs, it'll be
        // caught in the catch block

        // Close first file
        delete file1;
    }
    catch (InvalidActionException &E) {
        cerr << " *FAILED*" << endl;
        cerr << "    <<<  " << E.getDetailMsg() << "  >>>" << endl << endl;
        // clean up
        delete file1;
    }
    // catch all other exceptions
    catch (Exception &E) {
        issue_fail_msg("test_file_create()", __LINE__, __FILE__, E.getCDetailMsg());
        // clean up
        delete file1;
    }

    // Setting this to NULL for cleaning up in failure situations
    FileCreatPropList *tmpl1 = NULL;
    try {
        // Create a new file with a non-standard file-creation template
        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 file2(FILE2, H5F_ACC_TRUNC, *tmpl1);

        // Release file-creation template
        delete tmpl1;
        tmpl1 = NULL;

        // Get the file-creation template
        tmpl1 = new FileCreatPropList(file2.getCreatePlist());

        // Get the file-creation parameters
        hsize_t ublock = tmpl1->getUserblock();
        verify_val(static_cast<long>(ublock), static_cast<long>(F2_USERBLOCK_SIZE),
                   "FileCreatPropList::getUserblock", __LINE__, __FILE__);

        size_t parm1, parm2; // file-creation parameters
        tmpl1->getSizes(parm1, parm2);
        verify_val(parm1, F2_OFFSET_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);
        verify_val(parm2, F2_LENGTH_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);

        unsigned iparm1, iparm2; // file-creation parameters
        tmpl1->getSymk(iparm1, iparm2);
        verify_val(iparm1, F2_SYM_INTERN_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);
        verify_val(iparm2, F2_SYM_LEAF_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);

        // Clone the file-creation template
        FileCreatPropList tmpl2;
        tmpl2.copy(*tmpl1);

        // Release file-creation template
        delete tmpl1;
        tmpl1 = NULL;

        // Set the new file-creation parameter
        tmpl2.setUserblock(F3_USERBLOCK_SIZE);

        // Try to create second file, with non-standard file-creation template
        // params
        H5File file3(FILE3, H5F_ACC_TRUNC, tmpl2);

        // Get the file-creation template
        tmpl1 = new FileCreatPropList(file3.getCreatePlist());

        // Get the file-creation parameters
        ublock = tmpl1->getUserblock();
        verify_val(static_cast<long>(ublock), static_cast<long>(F3_USERBLOCK_SIZE),
                   "FileCreatPropList::getUserblock", __LINE__, __FILE__);

        tmpl1->getSizes(parm1, parm2);
        verify_val(parm1, F3_OFFSET_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);
        verify_val(parm2, F3_LENGTH_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);

        tmpl1->getSymk(iparm1, iparm2);
        verify_val(iparm1, F3_SYM_INTERN_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);
        verify_val(iparm2, F3_SYM_LEAF_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);

        // Release file-creation template
        delete tmpl1;
        PASSED();
    }
    // catch all exceptions
    catch (Exception &E) {
        issue_fail_msg("test_file_create()", __LINE__, __FILE__, E.getCDetailMsg());
        // clean up
        delete tmpl1;
    }
} // test_file_create()

/*-------------------------------------------------------------------------
 * Function:    test_file_open
 *
 * Purpose      Test file accesses
 *
 * Return       None
 *-------------------------------------------------------------------------
 */
static void
test_file_open()
{
    // Output message about test being performed
    SUBTEST("File Opening I/O");

    try {

        // Open first file
        H5File file1(FILE2, H5F_ACC_RDWR);

        // Get the file-creation template
        FileCreatPropList tmpl1 = file1.getCreatePlist();

        // Get the file-creation parameters
        hsize_t ublock = tmpl1.getUserblock();
        verify_val(static_cast<long>(ublock), static_cast<long>(F2_USERBLOCK_SIZE),
                   "FileCreatPropList::getUserblock", __LINE__, __FILE__);

        size_t parm1, parm2; // file-creation parameters
        tmpl1.getSizes(parm1, parm2);
        verify_val(parm1, F2_OFFSET_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);
        verify_val(parm2, F2_LENGTH_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);

        unsigned iparm1, iparm2; // file-creation parameters
        tmpl1.getSymk(iparm1, iparm2);
        verify_val(iparm1, F2_SYM_INTERN_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);
        verify_val(iparm2, F2_SYM_LEAF_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);

        // Test H5File constructor with existing file id
        H5File file2(file1.getId());
        file1.close();

        // Try truncating the file, and it should fail because the file is
        // still opened with file2.
        try {
            H5File file3(FILE2, H5F_ACC_TRUNC); // should throw E

            // Should FAIL but didn't, so throw an invalid action exception
            throw InvalidActionException("H5File constructor", "Attempt truncating an opened file.");
        }
        catch (FileIException &E) // catching H5F_ACC_TRUNC on opened file
        {
        } // do nothing, FAIL expected

        // Now, really close the file.
        file2.close();

        // Truncating should succeed now.
        H5File file3(FILE2, H5F_ACC_TRUNC);

        // Opening another file to file3 object, FILE2 should be closed, so
        // the next attempt to truncate FILE2 should succeed.
        file3.openFile(FILE1, H5F_ACC_RDONLY);
        H5File file4(FILE2, H5F_ACC_TRUNC);

        PASSED();
    } // end of try block

    catch (Exception &E) {
        issue_fail_msg("test_file_open()", __LINE__, __FILE__, E.getCDetailMsg());
    }
} // test_file_open()

/*-------------------------------------------------------------------------
 * Function:    test_file_size
 *
 * Purpose      Test file size.
 *
 * Return       None
 *-------------------------------------------------------------------------
 */
static void
test_file_size()
{
    // Output message about test being performed
    SUBTEST("File Size");

    hid_t fapl_id;
    fapl_id = h5_fileaccess(); // in h5test.c, returns a file access template

    try {
        // Use the file access template id to create a file access prop.
        // list object to pass in H5File::H5File
        FileAccPropList fapl(fapl_id);

        // Set to sec2 driver.  Do we want to test other file drivers?
        // They're not tested in C++.
        // File drivers seem not implemented.
        // fapl.setSec2();

        // Create a file
        H5File file4(FILE4, H5F_ACC_TRUNC, FileCreatPropList::DEFAULT, fapl);

        // Get file size
        hsize_t file_size = file4.getFileSize();

        // Check if file size is reasonable.  It's supposed to be 2KB now.
        if (file_size < 1 * KB || file_size > 4 * KB)
            issue_fail_msg("test_file_size()", __LINE__, __FILE__,
                           "getFileSize() returned unreasonable value");

        // Get the amount of free space in the file
        hssize_t free_space = file4.getFreeSpace();

        // Check if it's reasonable.  It's 0 now.
        if (free_space < 0 || free_space > 4 * KB)
            issue_fail_msg("test_file_size()", __LINE__, __FILE__,
                           "getFreeSpace returned unreasonable value");

        PASSED();
    } // end of try block

    catch (Exception &E) {
        issue_fail_msg("test_file_size()", __LINE__, __FILE__, E.getCDetailMsg());
    }

    // use C test utility routine to close property list.
    herr_t ret = H5Pclose(fapl_id);
    if (ret < 0)
        issue_fail_msg("test_file_size()", __LINE__, __FILE__, "H5Pclose failed");

} // test_file_size()

/*-------------------------------------------------------------------------
 * Function:    test_file_num
 *
 * Purpose      Test file number.
 *
 * Return       None
 *-------------------------------------------------------------------------
 */
static void
test_file_num()
{
    // Output message about test being performed
    SUBTEST("File Number");

    hid_t fapl_id;
    fapl_id = h5_fileaccess(); // in h5test.c, returns a file access template

    try {
        // Use the file access template id to create a file access prop.
        // list object to pass in H5File::H5File
        FileAccPropList fapl(fapl_id);

        // Create two files
        H5File file1(FILE1, H5F_ACC_TRUNC, FileCreatPropList::DEFAULT, fapl);
        H5File file2(FILE2, H5F_ACC_TRUNC, FileCreatPropList::DEFAULT, fapl);

        // Open the first file again
        H5File file3(FILE1, H5F_ACC_RDWR);

        // Get file numbers
        unsigned long file_num1 = file1.getFileNum();
        unsigned long file_num2 = file2.getFileNum();
        unsigned long file_num3 = file3.getFileNum();

        // Check file numbers
        if (file_num1 == file_num2)
            issue_fail_msg("test_file_num()", __LINE__, __FILE__, "getFileNum() returned wrong value");
        if (file_num1 != file_num3)
            issue_fail_msg("test_file_num()", __LINE__, __FILE__, "getFileNum() returned wrong value");

        PASSED();
    } // end of try block

    catch (Exception &E) {
        issue_fail_msg("test_file_num()", __LINE__, __FILE__, E.getCDetailMsg());
    }

    // use C test utility routine to close property list.
    herr_t ret = H5Pclose(fapl_id);
    if (ret < 0)
        issue_fail_msg("test_file_num()", __LINE__, __FILE__, "H5Pclose failed");

} // test_file_num()

/*-------------------------------------------------------------------------
 * Function:    test_file_name
 *
 * Purpose      Test getting file's name.
 *
 * Return       None
 *-------------------------------------------------------------------------
 */
const int          RANK = 2;
const int          NX   = 4;
const int          NY   = 5;
const H5std_string GROUPNAME("group");
const H5std_string DSETNAME("dataset");
const H5std_string DATTRNAME("dataset attribute");
const H5std_string FATTRNAME("file attribute");
const H5std_string DTYPENAME("compound");

// Compound datatype
typedef struct s1_t {
    unsigned int a;
    float        b;
} s1_t;

static void
test_file_name()
{
    // Output message about test being performed.
    SUBTEST("File Name");

    H5std_string file_name;
    try {
        // Create a file using default properties.
        H5File file4(FILE4, H5F_ACC_TRUNC);

        // Get file name from the file instance.
        file_name = file4.getFileName();
        verify_val(file_name, FILE4, "H5File::getFileName", __LINE__, __FILE__);

        // Create a group in the root group.
        Group group(file4.createGroup(GROUPNAME, 0));

        // Get and verify file name via a group.
        file_name = group.getFileName();
        verify_val(file_name, FILE4, "Group::getFileName", __LINE__, __FILE__);

        // Create the data space.
        hsize_t   dims[RANK] = {NX, NY};
        DataSpace space(RANK, dims);

        // Create a new dataset.
        DataSet dataset(file4.createDataSet(DSETNAME, PredType::NATIVE_INT, space));

        // Get and verify file name via a dataset.
        file_name = dataset.getFileName();
        verify_val(file_name, FILE4, "DataSet::getFileName", __LINE__, __FILE__);

        // Create an attribute for the dataset.
        Attribute attr(dataset.createAttribute(DATTRNAME, PredType::NATIVE_INT, space));

        // Get and verify file name via an attribute.
        file_name = attr.getFileName();
        verify_val(file_name, FILE4, "Attribute::getFileName", __LINE__, __FILE__);

        // Create a compound datatype.
        CompType comp_type(sizeof(s1_t));

        // Insert fields.
        comp_type.insertMember("a", HOFFSET(s1_t, a), PredType::NATIVE_INT);
        comp_type.insertMember("b", HOFFSET(s1_t, b), PredType::NATIVE_FLOAT);

        // Save it on file.
        comp_type.commit(file4, DTYPENAME);

        // Get and verify file name via a committed datatype.
        comp_type.getFileName();
        verify_val(file_name, FILE4, "CompType::getFileName", __LINE__, __FILE__);
        PASSED();
    } // end of try block

    catch (Exception &E) {
        issue_fail_msg("test_file_name()", __LINE__, __FILE__, E.getCDetailMsg());
    }
} // test_file_name()

/*-------------------------------------------------------------------------
 *
 * Function:    test_file_attribute
 *
 * Purpose      Test file attributes
 *
 * Return       None
 *-------------------------------------------------------------------------
 */
const int          RANK1      = 1;
const int          ATTR1_DIM1 = 3;
const H5std_string FILE5("tfattrs.h5");
const H5std_string FATTR1_NAME("file attribute 1");
const H5std_string FATTR2_NAME("file attribute 2");
int                fattr_data[ATTR1_DIM1] = {512, -234, 98123}; // Test data for file attribute
int                dattr_data[ATTR1_DIM1] = {256, -123, 1000};  // Test data for dataset attribute

static void
test_file_attribute()
{
    int rdata[ATTR1_DIM1];
    int i;

    // Output message about test being performed
    SUBTEST("File Attribute");

    H5std_string file_name;
    try {
        // Create a file using default properties.
        H5File file5(FILE5, H5F_ACC_TRUNC);

        // Create the data space
        hsize_t   dims[RANK1] = {ATTR1_DIM1};
        DataSpace space(RANK1, dims);

        // Create two attributes for the file
        Attribute fattr1(file5.createAttribute(FATTR1_NAME, PredType::NATIVE_FLOAT, space));
        Attribute fattr2(file5.createAttribute(FATTR2_NAME, PredType::NATIVE_INT, space));

        fattr2.write(PredType::NATIVE_INT, fattr_data);

        try {
            // Try to create the same attribute again (should fail)
            Attribute fattr_dup(file5.createAttribute(FATTR2_NAME, PredType::NATIVE_INT, space));
            // Should FAIL but didn't, so throw an invalid action exception
            throw InvalidActionException("H5File createAttribute",
                                         "Attempted to create an existing attribute.");
        }
        catch (AttributeIException &E) // catch creating existing attribute
        {
        } // do nothing, FAIL expected

        // Create a new dataset
        DataSet dataset(file5.createDataSet(DSETNAME, PredType::NATIVE_INT, space));

        // Create an attribute for the dataset
        Attribute dattr(dataset.createAttribute(DATTRNAME, PredType::NATIVE_INT, space));

        // Write data to the second file attribute
        dattr.write(PredType::NATIVE_INT, dattr_data);

        // Test flushing out the data from the attribute object
        dattr.flush(H5F_SCOPE_GLOBAL);

        // Get and verify the number of all objects in the file
        // Current: 1 file, 2 file attr, 1 ds, and 1 ds attr.
        ssize_t num_objs = file5.getObjCount(H5F_OBJ_ALL);
        verify_val(num_objs, 5, "H5File::getObjCount", __LINE__, __FILE__);

        num_objs = file5.getObjCount(H5F_OBJ_GROUP);
        verify_val(num_objs, 0, "H5File::getObjCount(H5F_OBJ_GROUP)", __LINE__, __FILE__);
        num_objs = file5.getObjCount(H5F_OBJ_DATASET);
        verify_val(num_objs, 1, "H5File::getObjCount(H5F_OBJ_DATASET)", __LINE__, __FILE__);
        num_objs = file5.getObjCount(H5F_OBJ_ATTR);
        verify_val(num_objs, 3, "H5File::getObjCount(H5F_OBJ_ATTR)", __LINE__, __FILE__);
        num_objs = file5.getObjCount(H5F_OBJ_DATATYPE);
        verify_val(num_objs, 0, "H5File::getObjCount(H5F_OBJ_DATATYPE)", __LINE__, __FILE__);
        num_objs = file5.getObjCount(H5F_OBJ_FILE);
        verify_val(num_objs, 1, "H5File::getObjCount(H5F_OBJ_FILE)", __LINE__, __FILE__);

        // Get the file name using the attributes
        H5std_string fname = fattr1.getFileName();
        verify_val(fname, FILE5, "H5File::getFileName()", __LINE__, __FILE__);

        fname.clear();
        fname = dattr.getFileName();
        verify_val(fname, FILE5, "H5File::getFileName()", __LINE__, __FILE__);

        // Get the class of a file attribute's datatype
        H5T_class_t atclass = fattr1.getTypeClass();
        verify_val(static_cast<long>(atclass), static_cast<long>(H5T_FLOAT), "Attribute::getTypeClass()",
                   __LINE__, __FILE__);

        // Get and verify the number of attributes attached to a file
        int n_attrs = file5.getNumAttrs();
        verify_val(n_attrs, 2, "H5File::getNumAttrs()", __LINE__, __FILE__);

        // Get and verify the number of attributes attached to a dataset
        n_attrs = 0;
        n_attrs = dataset.getNumAttrs();
        verify_val(n_attrs, 1, "DataSet::getNumAttrs()", __LINE__, __FILE__);

        // Read back attribute's data
        memset(rdata, 0, sizeof(rdata));
        dattr.read(PredType::NATIVE_INT, rdata);
        /* Check results */
        for (i = 0; i < ATTR1_DIM1; i++) {
            if (rdata[i] != dattr_data[i]) {
                H5_FAILED();
                cerr << endl;
                cerr << "element [" << i << "] is " << rdata[i] << "but should have been " << dattr_data[i]
                     << endl;
            }
        }
        PASSED();
    } // end of try block

    catch (Exception &E) {
        issue_fail_msg("test_file_attribute()", __LINE__, __FILE__, E.getCDetailMsg());
    }
} // test_file_attribute()

/*-------------------------------------------------------------------------
 * Function:    test_libver_bounds_real
 *
 * Purpose      Verify that a file created and modified with the
 *              specified libver bounds has the specified object header
 *              versions for the right objects.
 *
 * Return       None
 *-------------------------------------------------------------------------
 */
const H5std_string FILE6("tfile5.h5");
const H5std_string ROOTGROUP("/");
const H5std_string GROUP1("/G1");
const H5std_string SUBGROUP3("/G1/G3");

static void
test_libver_bounds_real(H5F_libver_t libver_create, unsigned oh_vers_create, H5F_libver_t libver_mod,
                        unsigned oh_vers_mod)
{
    try {

        /*
         * Create a new file using the default creation property and access property
         * with latest library version.
         */
        FileAccPropList fapl;
        fapl.setLibverBounds(libver_create, H5F_LIBVER_LATEST);
        H5File file(FILE6, H5F_ACC_TRUNC, FileCreatPropList::DEFAULT, fapl);

        /*
         * Make sure the root group has the correct object header version
         */
        unsigned obj_version = file.childObjVersion(ROOTGROUP);
        verify_val(obj_version, oh_vers_create, "H5File::childObjVersion", __LINE__, __FILE__);

        // Verify object header version another way
        H5O_native_info_t ninfo;
        memset(&ninfo, 0, sizeof(ninfo));
        file.getNativeObjinfo(ninfo, H5O_NATIVE_INFO_HDR);
        verify_val(ninfo.hdr.version, oh_vers_create, "H5File::getNativeObjinfo", __LINE__, __FILE__);

        /*
         * Reopen the file and make sure the root group still has the correct
         * version
         */
        file.close();

        fapl.setLibverBounds(libver_mod, H5F_LIBVER_LATEST);

        file.openFile(FILE6, H5F_ACC_RDWR, fapl);

        obj_version = file.childObjVersion(ROOTGROUP);
        verify_val(obj_version, oh_vers_create, "H5File::childObjVersion", __LINE__, __FILE__);

        /*
         * Create a group named "/G1" in the file, and make sure it has the correct
         * object header version
         */
        Group group = file.createGroup(GROUP1);

        obj_version = group.objVersion();
        verify_val(obj_version, oh_vers_mod, "Group::objVersion", __LINE__, __FILE__);

        // Verify object header version another way
        memset(&ninfo, 0, sizeof(ninfo));
        group.getNativeObjinfo(ninfo, H5O_NATIVE_INFO_HDR);
        verify_val(ninfo.hdr.version, oh_vers_mod, "Group::getNativeObjinfo", __LINE__, __FILE__);

        group.close(); // close "/G1"

        /*
         * Create a group named "/G1/G3" in the file, and make sure it has the
         * correct object header version
         */
        group = file.createGroup(SUBGROUP3);

        obj_version = group.objVersion();
        verify_val(obj_version, oh_vers_mod, "Group::objVersion", __LINE__, __FILE__);

        group.close(); // close "/G1/G3"

        /*
         * Make sure the root group still has the correct object header version
         */
        obj_version = file.childObjVersion(ROOTGROUP);
        verify_val(obj_version, oh_vers_create, "H5File::childObjVersion", __LINE__, __FILE__);

        // Everything should be closed as they go out of scope
    } // end of try block

    catch (Exception &E) {
        issue_fail_msg("test_libver_bounds_real()", __LINE__, __FILE__, E.getCDetailMsg());
    }

} /* end test_libver_bounds_real() */

/*-------------------------------------------------------------------------
 *
 * Function:    test_libver_bounds
 *
 * Purpose      Verify that a file created and modified with various
 *              libver bounds is handled correctly.
 *
 * Return       None
 *-------------------------------------------------------------------------
 */
static void
test_libver_bounds()
{
    // Output message about test being performed
    SUBTEST("Setting library version bounds");

    /* Run the tests */
    test_libver_bounds_real(H5F_LIBVER_EARLIEST, H5O_VERSION_1, H5F_LIBVER_LATEST, H5O_VERSION_2);
    test_libver_bounds_real(H5F_LIBVER_LATEST, H5O_VERSION_2, H5F_LIBVER_EARLIEST, H5O_VERSION_2);
    PASSED();
} /* end test_libver_bounds() */

/*-------------------------------------------------------------------------
 * Function:    test_commonfg
 *
 * Purpose      Verify that H5File works as a root group.
 *
 * Return       None
 *-------------------------------------------------------------------------
 */
static void
test_commonfg()
{
    // Output message about test being performed
    SUBTEST("Root group");

    try {
        // Create a file using default properties.
        H5File file4(FILE4, H5F_ACC_TRUNC);

        // Try opening the root group.
        Group rootgroup(file4.openGroup(ROOTGROUP));

        // Create a group in the root group.
        Group group(rootgroup.createGroup(GROUPNAME, 0));

        // Create the data space.
        hsize_t   dims[RANK] = {NX, NY};
        DataSpace space(RANK, dims);

        // Create a new dataset.
        DataSet dataset(group.createDataSet(DSETNAME, PredType::NATIVE_INT, space));

        // Get and verify file name via a dataset.
        H5std_string file_name = dataset.getFileName();
        verify_val(file_name, FILE4, "DataSet::getFileName", __LINE__, __FILE__);

        // Create an attribute for the dataset.
        Attribute attr(dataset.createAttribute(DATTRNAME, PredType::NATIVE_INT, space));

        // Get and verify file name via an attribute.
        file_name = attr.getFileName();
        verify_val(file_name, FILE4, "Attribute::getFileName", __LINE__, __FILE__);

        // Create an attribute for the file via root group.
        Attribute rootg_attr(rootgroup.createAttribute(FATTRNAME, PredType::NATIVE_INT, space));

        // Get and verify file name via an attribute.
        file_name = attr.getFileName();
        verify_val(file_name, FILE4, "Attribute::getFileName", __LINE__, __FILE__);

        PASSED();
    } // end of try block

    catch (Exception &E) {
        issue_fail_msg("test_commonfg()", __LINE__, __FILE__, E.getCDetailMsg());
    }

} /* end test_commonfg() */

/*-------------------------------------------------------------------------
 * Function:    test_file_info
 *
 * Purpose      Verify that various properties in a file creation property
 *              lists are stored correctly in the file and can be retrieved
 *              when the file is re-opened.
 *
 * Return       None
 *-------------------------------------------------------------------------
 */
const H5std_string FILE7("tfile7.h5");
const hsize_t      FSP_SIZE_DEF = 4096;
const hsize_t      FSP_SIZE512  = 512;

static void
test_file_info()
{
    // Output message about test being performed
    SUBTEST("File general information");

    hsize_t out_threshold = 0;     // Free space section threshold to get
    hbool_t out_persist   = FALSE; // Persist free-space read
    // File space handling strategy
    H5F_fspace_strategy_t out_strategy = H5F_FSPACE_STRATEGY_FSM_AGGR;

    try {
        // Create a file using default properties.
        H5File tempfile(FILE7, H5F_ACC_TRUNC);

        // Get the file's version information.
        H5F_info2_t finfo;
        tempfile.getFileInfo(finfo);
        verify_val(static_cast<long>(finfo.super.version), 0, "H5File::getFileInfo", __LINE__, __FILE__);
        verify_val(static_cast<long>(finfo.free.version), 0, "H5File::getFileInfo", __LINE__, __FILE__);
        verify_val(static_cast<long>(finfo.sohm.version), 0, "H5File::getFileInfo", __LINE__, __FILE__);

        // Close the file.
        tempfile.close();

        // Create file creation property list.
        FileCreatPropList fcpl;

        // Retrieve file space information.
        fcpl.getFileSpaceStrategy(out_strategy, out_persist, out_threshold);

        // Verify file space information.
        verify_val(static_cast<long>(out_strategy), static_cast<long>(H5F_FSPACE_STRATEGY_FSM_AGGR),
                   "H5File::getFileInfo", __LINE__, __FILE__);
        verify_val(out_persist, FALSE, "H5File::getFileInfo", __LINE__, __FILE__);
        verify_val(static_cast<long>(out_threshold), 1, "H5File::getFileInfo", __LINE__, __FILE__);

        /* Retrieve file space page size */
        hsize_t out_fsp_psize = fcpl.getFileSpacePagesize();
        verify_val(out_fsp_psize, FSP_SIZE_DEF, "FileCreatPropList::getFileSpacePagesize", __LINE__,
                   __FILE__);

        // Set various file information.
        fcpl.setUserblock(F2_USERBLOCK_SIZE);
        fcpl.setSizes(F2_OFFSET_SIZE, F2_LENGTH_SIZE);
        fcpl.setSymk(F2_SYM_INTERN_K, F2_SYM_LEAF_K);
        fcpl.setIstorek(F2_ISTORE);

        hsize_t               threshold = 5;    // Free space section threshold to set
        hbool_t               persist   = TRUE; // Persist free-space to set
        H5F_fspace_strategy_t strategy  = H5F_FSPACE_STRATEGY_PAGE;

        fcpl.setFileSpaceStrategy(strategy, persist, threshold);
        fcpl.setFileSpacePagesize(FSP_SIZE512);

        // Creating a file with the non-default file creation property list
        // should create a version 1 superblock

        // Create file with custom file creation property list.
        H5File file7(FILE7, H5F_ACC_TRUNC, fcpl);

        // Close the file creation property list.
        fcpl.close();

        // Get the file's version information.
        file7.getFileInfo(finfo);
        verify_val(static_cast<long>(finfo.super.version), 2, "H5File::getFileInfo", __LINE__, __FILE__);
        verify_val(static_cast<long>(finfo.free.version), 0, "H5File::getFileInfo", __LINE__, __FILE__);
        verify_val(static_cast<long>(finfo.sohm.version), 0, "H5File::getFileInfo", __LINE__, __FILE__);

        // Close the file.
        file7.close();

        // Re-open the file.
        file7.openFile(FILE7, H5F_ACC_RDONLY);

        // Get the file's creation property list.
        FileCreatPropList fcpl2 = file7.getCreatePlist();

        // Get the file's version information.
        file7.getFileInfo(finfo);
        verify_val(static_cast<long>(finfo.super.version), 2, "H5File::getFileInfo", __LINE__, __FILE__);
        verify_val(static_cast<long>(finfo.free.version), 0, "H5File::getFileInfo", __LINE__, __FILE__);
        verify_val(static_cast<long>(finfo.sohm.version), 0, "H5File::getFileInfo", __LINE__, __FILE__);

        // Retrieve the property values & check them.
        hsize_t userblock = fcpl2.getUserblock();
        verify_val(userblock, F2_USERBLOCK_SIZE, "FileCreatPropList::getUserblock", __LINE__, __FILE__);

        size_t off_size = 0, len_size = 0;
        fcpl2.getSizes(off_size, len_size);
        verify_val(off_size, F2_OFFSET_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);
        verify_val(len_size, F2_LENGTH_SIZE, "FileCreatPropList::getSizes", __LINE__, __FILE__);

        unsigned sym_ik = 0, sym_lk = 0;
        fcpl2.getSymk(sym_ik, sym_lk);
        verify_val(sym_ik, F2_SYM_INTERN_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);
        verify_val(sym_lk, F2_SYM_LEAF_K, "FileCreatPropList::getSymk", __LINE__, __FILE__);

        unsigned istore_ik = fcpl2.getIstorek();
        verify_val(istore_ik, F2_ISTORE, "FileCreatPropList::getIstorek", __LINE__, __FILE__);

        /*  ret=H5Pget_shared_mesg_nindexes(fcpl2,&nindexes);
        CHECK(ret, FAIL, "H5Pget_shared_mesg_nindexes");
        VERIFY(nindexes, MISC11_NINDEXES, "H5Pget_shared_mesg_nindexes");
     */

        // Get and verify the file space info from the creation property list */
        fcpl2.getFileSpaceStrategy(out_strategy, out_persist, out_threshold);
        verify_val(static_cast<long>(out_strategy), static_cast<long>(strategy),
                   "FileCreatPropList::getFileSpaceStrategy", __LINE__, __FILE__);
        verify_val(out_persist, persist, "FileCreatPropList::getFileSpaceStrategy", __LINE__, __FILE__);
        verify_val(out_threshold, threshold, "FileCreatPropList::getFileSpaceStrategy", __LINE__, __FILE__);

        out_fsp_psize = fcpl2.getFileSpacePagesize();
        verify_val(out_fsp_psize, FSP_SIZE512, "FileCreatPropList::getFileSpacePagesize", __LINE__, __FILE__);

        PASSED();
    } // end of try block
    catch (Exception &E) {
        issue_fail_msg("test_filespace_info()", __LINE__, __FILE__, E.getCDetailMsg());
    }
} /* test_file_info() */

/*-------------------------------------------------------------------------
 * Function:    test_file
 *
 * Purpose      Main file testing routine
 *
 * Return       None
 *-------------------------------------------------------------------------
 */
extern "C" void
test_file()
{
    // Output message about test being performed
    MESSAGE(5, ("Testing File I/O Operations\n"));

    test_file_create();    // Test file creation (also creation templates)
    test_file_open();      // Test file opening
    test_file_size();      // Test file size
    test_file_num();       // Test file number
    test_file_name();      // Test getting file's name
    test_file_attribute(); // Test file attribute feature
    test_libver_bounds();  // Test format version
    test_commonfg();       // Test H5File as a root group
    test_file_info();      // Test various file info
} // test_file()

/*-------------------------------------------------------------------------
 * Function:    cleanup_file
 *
 * Purpose      Cleanup temporary test files
 *
 * Return       none
 *-------------------------------------------------------------------------
 */
#ifdef __cplusplus
extern "C"
#endif
    void
    cleanup_file()
{
    HDremove(FILE1.c_str());
    HDremove(FILE2.c_str());
    HDremove(FILE3.c_str());
    HDremove(FILE4.c_str());
    HDremove(FILE5.c_str());
    HDremove(FILE6.c_str());
    HDremove(FILE7.c_str());
} // cleanup_file