Add initial version of HDF5 API tests (#2877)

1 files changed, 2564 insertions, 0 deletions

diff --git a/test/API/H5_api_file_test.c b/test/API/H5_api_file_test.c
new file mode 100644
index 0000000..279e9e7
--- /dev/null
+++ b/test/API/H5_api_file_test.c
@@ -0,0 +1,2564 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by The HDF Group.                                               *
+ * All rights reserved.                                                      *
+ *                                                                           *
+ * This file is part of HDF5.  The full HDF5 copyright notice, including     *
+ * terms governing use, modification, and redistribution, is contained in    *
+ * the COPYING file, which can be found at the root of the source code       *
+ * distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases.  *
+ * If you do not have access to either file, you may request a copy from     *
+ * help@hdfgroup.org.                                                        *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+#include "H5_api_file_test.h"
+
+static int test_create_file(void);
+static int test_create_file_invalid_params(void);
+static int test_create_file_excl(void);
+static int test_open_file(void);
+static int test_open_file_invalid_params(void);
+static int test_open_nonexistent_file(void);
+static int test_file_open_overlap(void);
+static int test_file_permission(void);
+static int test_reopen_file(void);
+static int test_close_file_invalid_id(void);
+static int test_flush_file(void);
+static int test_file_is_accessible(void);
+static int test_file_property_lists(void);
+static int test_get_file_intent(void);
+static int test_get_file_obj_count(void);
+static int test_file_mounts(void);
+static int test_get_file_name(void);
+
+/*
+ * The array of file tests to be performed.
+ */
+static int (*file_tests[])(void) = {
+    test_create_file,
+    test_create_file_invalid_params,
+    test_create_file_excl,
+    test_open_file,
+    test_open_file_invalid_params,
+    test_open_nonexistent_file,
+    test_file_open_overlap,
+    test_file_permission,
+    test_reopen_file,
+    test_close_file_invalid_id,
+    test_flush_file,
+    test_file_is_accessible,
+    test_file_property_lists,
+    test_get_file_intent,
+    test_get_file_obj_count,
+    test_file_mounts,
+    test_get_file_name,
+};
+
+/*
+ * Tests that a file can be created.
+ */
+static int
+test_create_file(void)
+{
+    hid_t file_id           = H5I_INVALID_HID;
+    char *prefixed_filename = NULL;
+
+    TESTING("H5Fcreate");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC)) {
+        SKIPPED();
+        HDprintf("    API functions for basic file aren't supported with this connector\n");
+        return 0;
+    }
+
+    if (prefix_filename(test_path_prefix, FILE_CREATE_TEST_FILENAME, &prefixed_filename) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+
+    if ((file_id = H5Fcreate(prefixed_filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create file '%s'\n", prefixed_filename);
+        goto error;
+    }
+
+    if (H5Fclose(file_id) < 0)
+        TEST_ERROR;
+
+    HDfree(prefixed_filename);
+    prefixed_filename = NULL;
+
+    PASSED();
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Fclose(file_id);
+    }
+    H5E_END_TRY;
+
+    HDfree(prefixed_filename);
+
+    return 1;
+}
+
+/*
+ * Tests that a file can't be created when H5Fcreate is passed
+ * invalid parameters.
+ */
+static int
+test_create_file_invalid_params(void)
+{
+    hid_t file_id           = H5I_INVALID_HID;
+    char *prefixed_filename = NULL;
+
+    TESTING_MULTIPART("H5Fcreate with invalid parameters");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC)) {
+        SKIPPED();
+        HDprintf("    API functions for basic file aren't supported with this connector\n");
+        return 0;
+    }
+
+    if (prefix_filename(test_path_prefix, FILE_CREATE_INVALID_PARAMS_FILE_NAME, &prefixed_filename) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+
+    BEGIN_MULTIPART
+    {
+        PART_BEGIN(H5Fcreate_invalid_name)
+        {
+            TESTING_2("H5Fcreate with invalid file name");
+
+            H5E_BEGIN_TRY
+            {
+                file_id = H5Fcreate(NULL, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (file_id >= 0) {
+                H5_FAILED();
+                HDprintf("    file was created with a NULL name!\n");
+                H5Fclose(file_id);
+                PART_ERROR(H5Fcreate_invalid_name);
+            }
+
+            H5E_BEGIN_TRY
+            {
+                file_id = H5Fcreate("", H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (file_id >= 0) {
+                H5_FAILED();
+                HDprintf("    file was created with an invalid name of ''!\n");
+                H5Fclose(file_id);
+                PART_ERROR(H5Fcreate_invalid_name);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fcreate_invalid_name);
+
+        PART_BEGIN(H5Fcreate_invalid_flags)
+        {
+            TESTING_2("H5Fcreate with invalid flags");
+
+            H5E_BEGIN_TRY
+            {
+                file_id = H5Fcreate(prefixed_filename, H5F_ACC_RDWR, H5P_DEFAULT, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (file_id >= 0) {
+                H5_FAILED();
+                HDprintf("    file was created with invalid flag H5F_ACC_RDWR!\n");
+                H5Fclose(file_id);
+                PART_ERROR(H5Fcreate_invalid_flags);
+            }
+
+            H5E_BEGIN_TRY
+            {
+                file_id = H5Fcreate(prefixed_filename, H5F_ACC_CREAT, H5P_DEFAULT, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (file_id >= 0) {
+                H5_FAILED();
+                HDprintf("    file was created with invalid flag H5F_ACC_CREAT!\n");
+                H5Fclose(file_id);
+                PART_ERROR(H5Fcreate_invalid_flags);
+            }
+
+            H5E_BEGIN_TRY
+            {
+                file_id = H5Fcreate(prefixed_filename, H5F_ACC_SWMR_READ, H5P_DEFAULT, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (file_id >= 0) {
+                H5_FAILED();
+                HDprintf("    file was created with invalid flag H5F_ACC_SWMR_READ!\n");
+                H5Fclose(file_id);
+                PART_ERROR(H5Fcreate_invalid_flags);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fcreate_invalid_flags);
+
+        PART_BEGIN(H5Fcreate_invalid_fcpl)
+        {
+            TESTING_2("H5Fcreate with invalid FCPL");
+
+            H5E_BEGIN_TRY
+            {
+                file_id = H5Fcreate(prefixed_filename, H5F_ACC_TRUNC, H5I_INVALID_HID, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (file_id >= 0) {
+                H5_FAILED();
+                HDprintf("    file was created with invalid FCPL!\n");
+                H5Fclose(file_id);
+                PART_ERROR(H5Fcreate_invalid_fcpl);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fcreate_invalid_fcpl);
+    }
+    END_MULTIPART;
+
+    HDfree(prefixed_filename);
+    prefixed_filename = NULL;
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        /* Attempt to remove the file if it ended up being created. */
+        H5Fdelete(prefixed_filename, H5P_DEFAULT);
+
+        H5Fclose(file_id);
+    }
+    H5E_END_TRY;
+
+    HDfree(prefixed_filename);
+
+    return 1;
+}
+
+/*
+ * Tests that file creation will fail when a file is created
+ * using the H5F_ACC_EXCL flag while the file already exists.
+ */
+static int
+test_create_file_excl(void)
+{
+    hid_t file_id           = H5I_INVALID_HID;
+    hid_t file_id2          = H5I_INVALID_HID;
+    char *prefixed_filename = NULL;
+
+    TESTING("H5Fcreate with H5F_ACC_EXCL/H5F_ACC_TRUNC flag");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC)) {
+        SKIPPED();
+        HDprintf("    API functions for basic file aren't supported with this connector\n");
+        return 0;
+    }
+
+    if (prefix_filename(test_path_prefix, FILE_CREATE_EXCL_FILE_NAME, &prefixed_filename) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+
+    if ((file_id = H5Fcreate(prefixed_filename, H5F_ACC_EXCL, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create first file\n");
+        goto error;
+    }
+
+    /* Close the file */
+    if (H5Fclose(file_id) < 0)
+        TEST_ERROR;
+
+    /* Try again with H5F_ACC_EXCL. This should fail because the file already
+     * exists on disk from the previous steps.
+     */
+    H5E_BEGIN_TRY
+    {
+        file_id = H5Fcreate(prefixed_filename, H5F_ACC_EXCL, H5P_DEFAULT, H5P_DEFAULT);
+    }
+    H5E_END_TRY;
+
+    if (file_id >= 0) {
+        H5_FAILED();
+        HDprintf("    created already existing file using H5F_ACC_EXCL flag!\n");
+        goto error;
+    }
+
+    /* Test creating with H5F_ACC_TRUNC. This will truncate the existing file on disk. */
+    if ((file_id = H5Fcreate(prefixed_filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't truncate the existing file\n");
+        goto error;
+    }
+
+    if (H5Fclose(file_id) < 0)
+        TEST_ERROR;
+
+    HDfree(prefixed_filename);
+    prefixed_filename = NULL;
+
+    PASSED();
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Fclose(file_id);
+        H5Fclose(file_id2);
+    }
+    H5E_END_TRY;
+
+    HDfree(prefixed_filename);
+
+    return 1;
+}
+
+/*
+ * Tests that a file can be opened.
+ */
+static int
+test_open_file(void)
+{
+    hid_t file_id = H5I_INVALID_HID;
+
+    TESTING_MULTIPART("H5Fopen");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC)) {
+        SKIPPED();
+        HDprintf("    API functions for basic file aren't supported with this connector\n");
+        return 0;
+    }
+
+    BEGIN_MULTIPART
+    {
+        PART_BEGIN(H5Fopen_rdonly)
+        {
+            TESTING_2("H5Fopen in read-only mode");
+
+            if ((file_id = H5Fopen(H5_api_test_filename, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) {
+                H5_FAILED();
+                HDprintf("    unable to open file '%s' in read-only mode\n", H5_api_test_filename);
+                PART_ERROR(H5Fopen_rdonly);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fopen_rdonly);
+
+        if (file_id >= 0) {
+            H5E_BEGIN_TRY
+            {
+                H5Fclose(file_id);
+            }
+            H5E_END_TRY;
+            file_id = H5I_INVALID_HID;
+        }
+
+        PART_BEGIN(H5Fopen_rdwrite)
+        {
+            TESTING_2("H5Fopen in read-write mode");
+
+            if ((file_id = H5Fopen(H5_api_test_filename, H5F_ACC_RDWR, H5P_DEFAULT)) < 0) {
+                H5_FAILED();
+                HDprintf("    unable to open file '%s' in read-write mode\n", H5_api_test_filename);
+                PART_ERROR(H5Fopen_rdwrite);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fopen_rdwrite);
+
+        if (file_id >= 0) {
+            H5E_BEGIN_TRY
+            {
+                H5Fclose(file_id);
+            }
+            H5E_END_TRY;
+            file_id = H5I_INVALID_HID;
+        }
+
+        /*
+         * XXX: SWMR open flags
+         */
+    }
+    END_MULTIPART;
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Fclose(file_id);
+    }
+    H5E_END_TRY;
+
+    return 1;
+}
+
+/*
+ * Tests that a file can't be opened when H5Fopen is given
+ * invalid parameters.
+ */
+static int
+test_open_file_invalid_params(void)
+{
+    hid_t file_id = H5I_INVALID_HID;
+
+    TESTING_MULTIPART("H5Fopen with invalid parameters");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC)) {
+        SKIPPED();
+        HDprintf("    API functions for basic file aren't supported with this connector\n");
+        return 0;
+    }
+
+    BEGIN_MULTIPART
+    {
+        PART_BEGIN(H5Fopen_invalid_name)
+        {
+            TESTING_2("H5Fopen with invalid file name");
+
+            H5E_BEGIN_TRY
+            {
+                file_id = H5Fopen(NULL, H5F_ACC_RDWR, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (file_id >= 0) {
+                H5_FAILED();
+                HDprintf("    file was opened with a NULL name!\n");
+                H5Fclose(file_id);
+                PART_ERROR(H5Fopen_invalid_name);
+            }
+
+            H5E_BEGIN_TRY
+            {
+                file_id = H5Fopen("", H5F_ACC_RDWR, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (file_id >= 0) {
+                H5_FAILED();
+                HDprintf("    file was opened with an invalid name of ''!\n");
+                H5Fclose(file_id);
+                PART_ERROR(H5Fopen_invalid_name);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fopen_invalid_name);
+
+        PART_BEGIN(H5Fopen_invalid_flags)
+        {
+            TESTING_2("H5Fopen with invalid flags");
+
+            H5E_BEGIN_TRY
+            {
+                file_id = H5Fopen(H5_api_test_filename, H5F_ACC_TRUNC, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (file_id >= 0) {
+                H5_FAILED();
+                HDprintf("    file was opened with invalid flag H5F_ACC_TRUNC!\n");
+                H5Fclose(file_id);
+                PART_ERROR(H5Fopen_invalid_flags);
+            }
+
+            H5E_BEGIN_TRY
+            {
+                file_id = H5Fopen(H5_api_test_filename, H5F_ACC_EXCL, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (file_id >= 0) {
+                H5_FAILED();
+                HDprintf("    file was opened with invalid flag H5F_ACC_EXCL!\n");
+                H5Fclose(file_id);
+                PART_ERROR(H5Fopen_invalid_flags);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fopen_invalid_flags);
+    }
+    END_MULTIPART;
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Fclose(file_id);
+    }
+    H5E_END_TRY;
+
+    return 1;
+}
+
+/*
+ * A test to ensure that opening a file which doesn't exist will fail.
+ */
+static int
+test_open_nonexistent_file(void)
+{
+    hid_t file_id           = H5I_INVALID_HID;
+    char *prefixed_filename = NULL;
+
+    TESTING("for invalid opening of a non-existent file");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC)) {
+        SKIPPED();
+        HDprintf("    API functions for basic file aren't supported with this connector\n");
+        return 0;
+    }
+
+    if (prefix_filename(test_path_prefix, NONEXISTENT_FILENAME, &prefixed_filename) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+
+    /* XXX: Make sure to first delete the file so we know for sure it doesn't exist */
+
+    H5E_BEGIN_TRY
+    {
+        file_id = H5Fopen(prefixed_filename, H5F_ACC_RDWR, H5P_DEFAULT);
+    }
+    H5E_END_TRY;
+
+    if (file_id >= 0) {
+        H5_FAILED();
+        HDprintf("    non-existent file was opened!\n");
+        goto error;
+    }
+
+    HDfree(prefixed_filename);
+    prefixed_filename = NULL;
+
+    PASSED();
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Fclose(file_id);
+    }
+    H5E_END_TRY;
+
+    HDfree(prefixed_filename);
+
+    return 1;
+}
+
+/*
+ * Tests that a file can be opened read-only or read-write
+ * and things are handled appropriately.
+ */
+static int
+test_file_permission(void)
+{
+    hid_t  file_id           = H5I_INVALID_HID;
+    hid_t  dset_id           = H5I_INVALID_HID;
+    hid_t  dspace_id         = H5I_INVALID_HID;
+    hid_t  group_id          = H5I_INVALID_HID;
+    hid_t  attr_id           = H5I_INVALID_HID;
+    hid_t  dtype_id          = H5I_INVALID_HID;
+    char  *prefixed_filename = NULL;
+    herr_t h5_ret            = FAIL;
+
+    TESTING_MULTIPART("file permissions (invalid creation of objects in read-only file)");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & (H5VL_CAP_FLAG_FILE_BASIC)) || !(vol_cap_flags_g & H5VL_CAP_FLAG_GROUP_BASIC) ||
+        !(vol_cap_flags_g & H5VL_CAP_FLAG_DATASET_BASIC) || !(vol_cap_flags_g & H5VL_CAP_FLAG_ATTR_BASIC) ||
+        !(vol_cap_flags_g & H5VL_CAP_FLAG_STORED_DATATYPES)) {
+        SKIPPED();
+        HDprintf("    API functions for basic file, group, dataset, attribute, stored datatype aren't "
+                 "supported with this connector\n");
+        return 0;
+    }
+
+    TESTING_2("test setup");
+
+    if (prefix_filename(test_path_prefix, FILE_PERMISSION_TEST_FILENAME, &prefixed_filename) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+
+    if ((file_id = H5Fcreate(prefixed_filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create file '%s'\n", prefixed_filename);
+        goto error;
+    }
+
+    if ((dspace_id = H5Screate(H5S_SCALAR)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create data space\n");
+        goto error;
+    }
+
+    if ((dset_id = H5Dcreate2(file_id, FILE_PERMISSION_TEST_DSET_NAME, H5T_STD_U32LE, dspace_id, H5P_DEFAULT,
+                              H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create data set: %s\n", FILE_PERMISSION_TEST_DSET_NAME);
+        goto error;
+    }
+
+    if (H5Dclose(dset_id) < 0)
+        TEST_ERROR;
+    if (H5Fclose(file_id) < 0)
+        TEST_ERROR;
+
+    /* Open the file (with read-only permission) */
+    if ((file_id = H5Fopen(prefixed_filename, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't open file\n");
+        goto error;
+    }
+
+    PASSED();
+
+    BEGIN_MULTIPART
+    {
+        PART_BEGIN(H5Gcreate_rdonly_file)
+        {
+            TESTING_2("invalid creation of group in read-only file");
+
+            /* Create a group with the read-only file handle (should fail) */
+            H5E_BEGIN_TRY
+            {
+                group_id =
+                    H5Gcreate2(file_id, FILE_PERMISSION_TEST_GRP_NAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (group_id >= 0) {
+                H5_FAILED();
+                HDprintf("    a group was created in a read-only file!\n");
+                PART_ERROR(H5Gcreate_rdonly_file);
+            }
+
+            H5E_BEGIN_TRY
+            {
+                group_id = H5Gcreate_anon(file_id, H5P_DEFAULT, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (group_id >= 0) {
+                H5_FAILED();
+                HDprintf("    a group was created in a read-only file!\n");
+                PART_ERROR(H5Gcreate_rdonly_file);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Gcreate_rdonly_file);
+
+        PART_BEGIN(H5Dcreate_rdonly_file)
+        {
+            TESTING_2("invalid creation of dataset in read-only file");
+
+            /* Create a dataset with the read-only file handle (should fail) */
+            H5E_BEGIN_TRY
+            {
+                dset_id = H5Dcreate2(file_id, FILE_PERMISSION_TEST_DSET2_NAME, H5T_STD_U32LE, dspace_id,
+                                     H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (dset_id >= 0) {
+                H5_FAILED();
+                HDprintf("    a dataset was created in a read-only file!\n");
+                PART_ERROR(H5Dcreate_rdonly_file);
+            }
+
+            H5E_BEGIN_TRY
+            {
+                dset_id = H5Dcreate_anon(file_id, H5T_STD_U32LE, dspace_id, H5P_DEFAULT, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (dset_id >= 0) {
+                H5_FAILED();
+                HDprintf("    a dataset was created in a read-only file!\n");
+                PART_ERROR(H5Dcreate_rdonly_file);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Dcreate_rdonly_file);
+
+        PART_BEGIN(H5Acreate_rdonly_file)
+        {
+            TESTING_2("invalid creation of attribute in read-only file");
+
+            /* Create an attribute with the read-only file handle (should fail) */
+            H5E_BEGIN_TRY
+            {
+                attr_id = H5Acreate2(file_id, FILE_PERMISSION_TEST_ATTR_NAME, H5T_NATIVE_INT, dspace_id,
+                                     H5P_DEFAULT, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (attr_id >= 0) {
+                H5_FAILED();
+                HDprintf("    an attribute was created in a read-only file!\n");
+                PART_ERROR(H5Acreate_rdonly_file);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Acreate_rdonly_file);
+
+        PART_BEGIN(H5Tcommit_rdonly_file)
+        {
+            TESTING_2("invalid creation of committed datatype in read-only file");
+
+            if ((dtype_id = H5Tcopy(H5T_NATIVE_INT)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't copy a native datatype\n");
+                PART_ERROR(H5Tcommit_rdonly_file);
+            }
+
+            /* Commit a datatype with the read-only file handle (should fail) */
+            H5E_BEGIN_TRY
+            {
+                h5_ret = H5Tcommit2(file_id, FILE_PERMISSION_TEST_NAMED_DTYPE, dtype_id, H5P_DEFAULT,
+                                    H5P_DEFAULT, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (h5_ret >= 0) {
+                H5_FAILED();
+                HDprintf("    a named datatype was committed in a read-only file!\n");
+                PART_ERROR(H5Tcommit_rdonly_file);
+            }
+
+            H5E_BEGIN_TRY
+            {
+                h5_ret = H5Tcommit_anon(file_id, dtype_id, H5P_DEFAULT, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (h5_ret >= 0) {
+                H5_FAILED();
+                HDprintf("    a named datatype was committed in a read-only file!\n");
+                PART_ERROR(H5Tcommit_rdonly_file);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Tcommit_rdonly_file);
+    }
+    END_MULTIPART;
+
+    TESTING_2("test cleanup");
+
+    if (H5Tclose(dtype_id) < 0)
+        TEST_ERROR;
+    if (H5Sclose(dspace_id) < 0)
+        TEST_ERROR;
+    if (H5Fclose(file_id) < 0)
+        TEST_ERROR;
+
+    HDfree(prefixed_filename);
+    prefixed_filename = NULL;
+
+    PASSED();
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Sclose(dspace_id);
+        H5Dclose(dset_id);
+        H5Aclose(attr_id);
+        H5Tclose(dtype_id);
+        H5Gclose(group_id);
+        H5Fclose(file_id);
+    }
+    H5E_END_TRY;
+
+    HDfree(prefixed_filename);
+
+    return 1;
+}
+
+/*
+ * A test to check that a file can be re-opened with H5Freopen.
+ */
+static int
+test_reopen_file(void)
+{
+    hid_t file_id  = H5I_INVALID_HID;
+    hid_t file_id2 = H5I_INVALID_HID;
+
+    TESTING("re-open of a file with H5Freopen");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC)) {
+        SKIPPED();
+        HDprintf("    API functions for basic file aren't supported with this connector\n");
+        return 0;
+    }
+
+    if ((file_id = H5Fopen(H5_api_test_filename, H5F_ACC_RDWR, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't open file\n");
+        goto error;
+    }
+
+    if ((file_id2 = H5Freopen(file_id)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't re-open file\n");
+        goto error;
+    }
+
+    if (H5Fclose(file_id) < 0)
+        TEST_ERROR;
+    if (H5Fclose(file_id2) < 0)
+        TEST_ERROR;
+
+    PASSED();
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Fclose(file_id);
+        H5Fclose(file_id2);
+    }
+    H5E_END_TRY;
+
+    return 1;
+}
+
+/*
+ * A test to check that H5Fclose doesn't succeed for an
+ * invalid file ID */
+static int
+test_close_file_invalid_id(void)
+{
+    herr_t err_ret = -1;
+
+    TESTING("H5Fclose with an invalid ID");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC)) {
+        SKIPPED();
+        HDprintf("    API functions for basic file aren't supported with this connector\n");
+        return 0;
+    }
+
+    H5E_BEGIN_TRY
+    {
+        err_ret = H5Fclose(H5I_INVALID_HID);
+    }
+    H5E_END_TRY;
+
+    if (err_ret >= 0) {
+        H5_FAILED();
+        HDprintf("    closed an invalid file ID!\n");
+        goto error;
+    }
+
+    PASSED();
+
+    return 0;
+
+error:
+    return 1;
+}
+
+/*
+ * A test to check that a file can be flushed using H5Fflush.
+ */
+static int
+test_flush_file(void)
+{
+    hid_t    file_id           = H5I_INVALID_HID;
+    hid_t    dspace_id         = H5I_INVALID_HID;
+    hid_t    dset_id           = H5I_INVALID_HID;
+    char    *prefixed_filename = NULL;
+    char     dset_name[32];
+    unsigned u;
+
+    TESTING_MULTIPART("H5Fflush");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & (H5VL_CAP_FLAG_FILE_BASIC)) || !(vol_cap_flags_g & H5VL_CAP_FLAG_DATASET_BASIC) ||
+        !(vol_cap_flags_g & H5VL_CAP_FLAG_FLUSH_REFRESH)) {
+        SKIPPED();
+        HDprintf("    API functions for basic file, dataset, or file flush aren't supported with this "
+                 "connector\n");
+        return 0;
+    }
+
+    TESTING_2("test setup");
+
+    if (prefix_filename(test_path_prefix, FILE_FLUSH_TEST_FILENAME, &prefixed_filename) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+
+    if ((file_id = H5Fcreate(prefixed_filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create file '%s'\n", prefixed_filename);
+        goto error;
+    }
+
+    /* Create multiple small datasets in file */
+    if ((dspace_id = H5Screate(H5S_SCALAR)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create data space\n");
+        goto error;
+    }
+
+    for (u = 0; u < 10; u++) {
+        HDsprintf(dset_name, "Dataset %u", u);
+
+        if ((dset_id = H5Dcreate2(file_id, dset_name, H5T_STD_U32LE, dspace_id, H5P_DEFAULT, H5P_DEFAULT,
+                                  H5P_DEFAULT)) < 0) {
+            H5_FAILED();
+            HDprintf("    couldn't create data set: %s\n", dset_name);
+            goto error;
+        }
+
+        if (H5Dclose(dset_id) < 0)
+            TEST_ERROR;
+    }
+
+    PASSED();
+
+    BEGIN_MULTIPART
+    {
+        PART_BEGIN(H5Fflush_local)
+        {
+            TESTING_2("file flushing at local scope");
+
+            if (H5Fflush(file_id, H5F_SCOPE_LOCAL) < 0) {
+                H5_FAILED();
+                HDprintf("    unable to flush file with scope H5F_SCOPE_LOCAL\n");
+                PART_ERROR(H5Fflush_local);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fflush_local);
+
+        PART_BEGIN(H5Fflush_global)
+        {
+            TESTING_2("file flushing at global scope");
+
+            if (H5Fflush(file_id, H5F_SCOPE_GLOBAL) < 0) {
+                H5_FAILED();
+                HDprintf("    unable to flush file with scope H5F_SCOPE_GLOBAL\n");
+                PART_ERROR(H5Fflush_global);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fflush_global);
+    }
+    END_MULTIPART;
+
+    TESTING_2("test cleanup");
+
+    if (H5Sclose(dspace_id) < 0)
+        TEST_ERROR;
+    if (H5Fclose(file_id) < 0)
+        TEST_ERROR;
+
+    HDfree(prefixed_filename);
+    prefixed_filename = NULL;
+
+    PASSED();
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Sclose(dspace_id);
+        H5Dclose(dset_id);
+        H5Fclose(file_id);
+    }
+    H5E_END_TRY;
+
+    HDfree(prefixed_filename);
+
+    return 1;
+}
+
+/*
+ * A test for H5Fis_accessible.
+ */
+static int
+test_file_is_accessible(void)
+{
+    const char *const fake_filename     = "nonexistent_file.h5";
+    char             *prefixed_filename = NULL;
+    htri_t            is_accessible     = FAIL;
+
+    TESTING_MULTIPART("H5Fis_accessible");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC)) {
+        SKIPPED();
+        HDprintf("    API functions for basic file aren't supported with this connector\n");
+        return 0;
+    }
+
+    if (prefix_filename(test_path_prefix, fake_filename, &prefixed_filename) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+
+    BEGIN_MULTIPART
+    {
+        PART_BEGIN(H5Fis_accessible_valid_file)
+        {
+            TESTING_2("H5Fis_accessible on existing file");
+
+            if ((is_accessible = H5Fis_accessible(H5_api_test_filename, H5P_DEFAULT)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't determine if file '%s' is accessible with default FAPL\n",
+                         H5_api_test_filename);
+                PART_ERROR(H5Fis_accessible_valid_file);
+            }
+
+            if (!is_accessible) {
+                H5_FAILED();
+                HDprintf("    file '%s' is not accessible with default FAPL\n", H5_api_test_filename);
+                PART_ERROR(H5Fis_accessible_valid_file);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fis_accessible_valid_file);
+
+        is_accessible = -1;
+
+        PART_BEGIN(H5Fis_accessible_invalid_file)
+        {
+            TESTING_2("H5Fis_accessible on non-existing file");
+
+            H5E_BEGIN_TRY
+            {
+                is_accessible = H5Fis_accessible(prefixed_filename, H5P_DEFAULT);
+            }
+            H5E_END_TRY;
+
+            if (is_accessible > 0) {
+                H5_FAILED();
+                HDprintf("    non-existent file '%s' was accessible with default FAPL: is_accessible=%d!\n",
+                         prefixed_filename, is_accessible);
+                PART_ERROR(H5Fis_accessible_invalid_file);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fis_accessible_invalid_file);
+    }
+    END_MULTIPART;
+
+    HDfree(prefixed_filename);
+    prefixed_filename = NULL;
+
+    return 0;
+
+error:
+    HDfree(prefixed_filename);
+
+    return 1;
+}
+
+/*
+ * A test to check that a FCPL used for file creation can
+ * be persisted and that a valid copy of that FCPL can be
+ * retrieved later with a call to H5Fget_create_plist. Also
+ * tests that a valid copy of a FAPL used for file access
+ * can be retrieved with a call to H5Fget_access_plist.
+ */
+static int
+test_file_property_lists(void)
+{
+    hsize_t prop_val           = 0;
+    hid_t   file_id1           = H5I_INVALID_HID;
+    hid_t   file_id2           = H5I_INVALID_HID;
+    hid_t   fcpl_id1           = H5I_INVALID_HID;
+    hid_t   fcpl_id2           = H5I_INVALID_HID;
+    hid_t   fapl_id1           = H5I_INVALID_HID;
+    hid_t   fapl_id2           = H5I_INVALID_HID;
+    char   *prefixed_filename1 = NULL;
+    char   *prefixed_filename2 = NULL;
+
+    TESTING_MULTIPART("file property list operations");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC) || !(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_MORE) ||
+        !(vol_cap_flags_g & H5VL_CAP_FLAG_GET_PLIST)) {
+        SKIPPED();
+        HDprintf("    API functions for basic or more file or get property list aren't supported with this "
+                 "connector\n");
+        return 0;
+    }
+
+    TESTING_2("test setup");
+
+    if (prefix_filename(test_path_prefix, FILE_PROPERTY_LIST_TEST_FNAME1, &prefixed_filename1) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+    if (prefix_filename(test_path_prefix, FILE_PROPERTY_LIST_TEST_FNAME2, &prefixed_filename2) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+
+    if ((fcpl_id1 = H5Pcreate(H5P_FILE_CREATE)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create FCPL\n");
+        goto error;
+    }
+
+    if (H5Pset_userblock(fcpl_id1, FILE_PROPERTY_LIST_TEST_FCPL_PROP_VAL) < 0) {
+        H5_FAILED();
+        HDprintf("    failed to set test property on FCPL\n");
+        goto error;
+    }
+
+    if ((file_id1 = H5Fcreate(prefixed_filename1, H5F_ACC_TRUNC, fcpl_id1, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create file\n");
+        goto error;
+    }
+
+    if ((file_id2 = H5Fcreate(prefixed_filename2, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create file\n");
+        goto error;
+    }
+
+    if (H5Pclose(fcpl_id1) < 0)
+        TEST_ERROR;
+
+    PASSED();
+
+    BEGIN_MULTIPART
+    {
+        PART_BEGIN(H5Fget_create_plist)
+        {
+            TESTING_2("H5Fget_create_plist");
+
+            /* Try to receive copies of the two property lists, one which has the property set and one which
+             * does not */
+            if ((fcpl_id1 = H5Fget_create_plist(file_id1)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get FCPL\n");
+                PART_ERROR(H5Fget_create_plist);
+            }
+
+            if ((fcpl_id2 = H5Fget_create_plist(file_id2)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get FCPL\n");
+                PART_ERROR(H5Fget_create_plist);
+            }
+
+            /* Ensure that property list 1 has the property set and property list 2 does not */
+            if (H5Pget_userblock(fcpl_id1, &prop_val) < 0) {
+                H5_FAILED();
+                HDprintf("    failed to retrieve test property from FCPL\n");
+                PART_ERROR(H5Fget_create_plist);
+            }
+
+            if (prop_val != FILE_PROPERTY_LIST_TEST_FCPL_PROP_VAL) {
+                H5_FAILED();
+                HDprintf("    retrieved test property value '%llu' did not match expected value '%llu'\n",
+                         (long long unsigned)prop_val,
+                         (long long unsigned)FILE_PROPERTY_LIST_TEST_FCPL_PROP_VAL);
+                PART_ERROR(H5Fget_create_plist);
+            }
+
+            if (H5Pget_userblock(fcpl_id2, &prop_val) < 0) {
+                H5_FAILED();
+                HDprintf("    failed to retrieve test property from FCPL\n");
+                PART_ERROR(H5Fget_create_plist);
+            }
+
+            if (prop_val == FILE_PROPERTY_LIST_TEST_FCPL_PROP_VAL) {
+                HDprintf("    retrieved test property value '%llu' matched control value '%llu' when it "
+                         "shouldn't have\n",
+                         (long long unsigned)prop_val,
+                         (long long unsigned)FILE_PROPERTY_LIST_TEST_FCPL_PROP_VAL);
+                PART_ERROR(H5Fget_create_plist);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_create_plist);
+
+        PART_BEGIN(H5Fget_access_plist)
+        {
+            TESTING_2("H5Fget_access_plist");
+
+            /* Due to the nature of needing to supply a FAPL with the VOL connector having been set on it to
+             * the H5Fcreate() call, we cannot exactly test using H5P_DEFAULT as the FAPL for one of the
+             * create calls in this test. However, the use of H5Fget_access_plist() will still be used to
+             * check that the FAPL is correct after both creating and opening a file.
+             */
+            if ((fapl_id1 = H5Fget_access_plist(file_id1)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get FAPL\n");
+                PART_ERROR(H5Fget_access_plist);
+            }
+
+            if ((fapl_id2 = H5Fget_access_plist(file_id2)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get FAPL\n");
+                PART_ERROR(H5Fget_access_plist);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_access_plist);
+
+        /* Now see if we can still retrieve copies of the property lists upon opening
+         * (instead of creating) a file. If they were reconstructed properly upon file
+         * open, the creation property lists should also have the same test values
+         * as set before.
+         */
+        if (fcpl_id1 >= 0) {
+            H5E_BEGIN_TRY
+            {
+                H5Pclose(fcpl_id1);
+            }
+            H5E_END_TRY;
+            fcpl_id1 = H5I_INVALID_HID;
+        }
+        if (fcpl_id2 >= 0) {
+            H5E_BEGIN_TRY
+            {
+                H5Pclose(fcpl_id2);
+            }
+            H5E_END_TRY;
+            fcpl_id2 = H5I_INVALID_HID;
+        }
+        if (fapl_id1 >= 0) {
+            H5E_BEGIN_TRY
+            {
+                H5Pclose(fapl_id1);
+            }
+            H5E_END_TRY;
+            fapl_id1 = H5I_INVALID_HID;
+        }
+        if (fapl_id2 >= 0) {
+            H5E_BEGIN_TRY
+            {
+                H5Pclose(fapl_id2);
+            }
+            H5E_END_TRY;
+            fapl_id2 = H5I_INVALID_HID;
+        }
+        if (file_id1 >= 0) {
+            H5E_BEGIN_TRY
+            {
+                H5Fclose(file_id1);
+            }
+            H5E_END_TRY;
+            file_id1 = H5I_INVALID_HID;
+        }
+        if (file_id2 >= 0) {
+            H5E_BEGIN_TRY
+            {
+                H5Fclose(file_id2);
+            }
+            H5E_END_TRY;
+            file_id2 = H5I_INVALID_HID;
+        }
+
+        PART_BEGIN(H5Fget_create_plist_reopened)
+        {
+            TESTING_2("H5Fget_create_plist after re-opening file");
+
+            if ((file_id1 = H5Fopen(prefixed_filename1, H5F_ACC_RDWR, H5P_DEFAULT)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't open file\n");
+                PART_ERROR(H5Fget_create_plist_reopened);
+            }
+
+            if ((file_id2 = H5Fopen(prefixed_filename2, H5F_ACC_RDWR, H5P_DEFAULT)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't open file\n");
+                PART_ERROR(H5Fget_create_plist_reopened);
+            }
+
+            if ((fcpl_id1 = H5Fget_create_plist(file_id1)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get FCPL\n");
+                PART_ERROR(H5Fget_create_plist_reopened);
+            }
+
+            if ((fcpl_id2 = H5Fget_create_plist(file_id2)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get FCPL\n");
+                PART_ERROR(H5Fget_create_plist_reopened);
+            }
+
+            /* Check the values of the test property */
+            if (H5Pget_userblock(fcpl_id1, &prop_val) < 0) {
+                H5_FAILED();
+                HDprintf("    failed to retrieve test property from FCPL\n");
+                PART_ERROR(H5Fget_create_plist_reopened);
+            }
+
+            if (prop_val != FILE_PROPERTY_LIST_TEST_FCPL_PROP_VAL) {
+                H5_FAILED();
+                HDprintf("    retrieved test property value '%llu' did not match expected value '%llu'\n",
+                         (long long unsigned)prop_val,
+                         (long long unsigned)FILE_PROPERTY_LIST_TEST_FCPL_PROP_VAL);
+                PART_ERROR(H5Fget_create_plist_reopened);
+            }
+
+            if (H5Pget_userblock(fcpl_id2, &prop_val) < 0) {
+                H5_FAILED();
+                HDprintf("    failed to retrieve test property from FCPL\n");
+                PART_ERROR(H5Fget_create_plist_reopened);
+            }
+
+            if (prop_val == FILE_PROPERTY_LIST_TEST_FCPL_PROP_VAL) {
+                HDprintf("    retrieved test property value '%llu' matched control value '%llu' when it "
+                         "shouldn't have\n",
+                         (long long unsigned)prop_val,
+                         (long long unsigned)FILE_PROPERTY_LIST_TEST_FCPL_PROP_VAL);
+                PART_ERROR(H5Fget_create_plist_reopened);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_create_plist_reopened);
+    }
+    END_MULTIPART;
+
+    TESTING_2("test cleanup");
+
+    if (H5Pclose(fcpl_id1) < 0)
+        TEST_ERROR;
+    if (H5Pclose(fcpl_id2) < 0)
+        TEST_ERROR;
+    if (H5Fclose(file_id1) < 0)
+        TEST_ERROR;
+    if (H5Fclose(file_id2) < 0)
+        TEST_ERROR;
+
+    HDfree(prefixed_filename1);
+    prefixed_filename1 = NULL;
+    HDfree(prefixed_filename2);
+    prefixed_filename2 = NULL;
+
+    PASSED();
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Pclose(fcpl_id1);
+        H5Pclose(fcpl_id2);
+        H5Pclose(fapl_id1);
+        H5Pclose(fapl_id2);
+        H5Fclose(file_id1);
+        H5Fclose(file_id2);
+    }
+    H5E_END_TRY;
+
+    HDfree(prefixed_filename1);
+    HDfree(prefixed_filename2);
+
+    return 1;
+}
+
+/*
+ * A test to check that the file intent flags can be retrieved.
+ */
+static int
+test_get_file_intent(void)
+{
+    unsigned file_intent;
+    hid_t    file_id           = H5I_INVALID_HID;
+    char    *prefixed_filename = NULL;
+
+    TESTING_MULTIPART("retrieval of file intent with H5Fget_intent");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC) || !(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_MORE)) {
+        SKIPPED();
+        HDprintf("    API functions for basic or more file aren't supported with this connector\n");
+        return 0;
+    }
+
+    TESTING_2("test setup");
+
+    if (prefix_filename(test_path_prefix, FILE_INTENT_TEST_FILENAME, &prefixed_filename) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+
+    /* Test that file intent retrieval works correctly for file create */
+    if ((file_id = H5Fcreate(prefixed_filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create file '%s'\n", prefixed_filename);
+        goto error;
+    }
+
+    PASSED();
+
+    BEGIN_MULTIPART
+    {
+        PART_BEGIN(H5Fget_intent_file_creation)
+        {
+            TESTING_2("H5Fget_intent on newly-created file");
+
+            if (H5Fget_intent(file_id, &file_intent) < 0) {
+                H5_FAILED();
+                HDprintf("    failed to retrieve file intent\n");
+                PART_ERROR(H5Fget_intent_file_creation);
+            }
+
+            if (H5F_ACC_RDWR != file_intent) {
+                H5_FAILED();
+                HDprintf("    received incorrect file intent for file creation\n");
+                PART_ERROR(H5Fget_intent_file_creation);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_intent_file_creation);
+
+        if (file_id >= 0) {
+            H5E_BEGIN_TRY
+            {
+                H5Fclose(file_id);
+            }
+            H5E_END_TRY;
+            file_id = H5I_INVALID_HID;
+        }
+
+        PART_BEGIN(H5Fget_intent_rdonly_file_open)
+        {
+            TESTING_2("H5Fget_intent for file opened read-only");
+
+            /* Test that file intent retrieval works correctly for file open */
+            if ((file_id = H5Fopen(H5_api_test_filename, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't open file '%s'\n", H5_api_test_filename);
+                PART_ERROR(H5Fget_intent_rdonly_file_open);
+            }
+
+            if (H5Fget_intent(file_id, &file_intent) < 0) {
+                H5_FAILED();
+                HDprintf("    failed to retrieve file intent\n");
+                PART_ERROR(H5Fget_intent_rdonly_file_open);
+            }
+
+            if (H5F_ACC_RDONLY != file_intent) {
+                H5_FAILED();
+                HDprintf("    received incorrect file intent for read-only file open\n");
+                PART_ERROR(H5Fget_intent_rdonly_file_open);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_intent_rdonly_file_open);
+
+        if (file_id >= 0) {
+            H5E_BEGIN_TRY
+            {
+                H5Fclose(file_id);
+            }
+            H5E_END_TRY;
+            file_id = H5I_INVALID_HID;
+        }
+
+        PART_BEGIN(H5Fget_intent_rdwrite_file_open)
+        {
+            TESTING_2("H5Fget_intent for file opened read-write");
+
+            if ((file_id = H5Fopen(H5_api_test_filename, H5F_ACC_RDWR, H5P_DEFAULT)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't open file '%s'\n", H5_api_test_filename);
+                PART_ERROR(H5Fget_intent_rdwrite_file_open);
+            }
+
+            if (H5Fget_intent(file_id, &file_intent) < 0) {
+                H5_FAILED();
+                HDprintf("    failed to retrieve file intent\n");
+                PART_ERROR(H5Fget_intent_rdwrite_file_open);
+            }
+
+            if (H5F_ACC_RDWR != file_intent) {
+                H5_FAILED();
+                HDprintf("    received incorrect file intent\n");
+                PART_ERROR(H5Fget_intent_rdwrite_file_open);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_intent_rdwrite_file_open);
+
+        if (file_id >= 0) {
+            H5E_BEGIN_TRY
+            {
+                H5Fclose(file_id);
+            }
+            H5E_END_TRY;
+            file_id = H5I_INVALID_HID;
+        }
+    }
+    END_MULTIPART;
+
+    HDfree(prefixed_filename);
+    prefixed_filename = NULL;
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Fclose(file_id);
+    }
+    H5E_END_TRY;
+
+    HDfree(prefixed_filename);
+
+    return 1;
+}
+
+/*
+ * A test to check that the number of open objects and IDs of objects in a file
+ * can be retrieved.
+ */
+static int
+test_get_file_obj_count(void)
+{
+    ssize_t obj_count;
+    hid_t   file_id            = H5I_INVALID_HID;
+    hid_t   file_id2           = H5I_INVALID_HID;
+    hid_t   group_id           = H5I_INVALID_HID;
+    hid_t   object_id          = H5I_INVALID_HID;
+    hid_t   named_dtype_id     = H5I_INVALID_HID;
+    hid_t   attr_id            = H5I_INVALID_HID;
+    hid_t   dspace_id          = H5I_INVALID_HID;
+    hid_t   dset_id            = H5I_INVALID_HID;
+    char   *prefixed_filename1 = NULL;
+    char   *prefixed_filename2 = NULL;
+
+    TESTING_MULTIPART("retrieval of open object number and IDs");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC) || !(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_MORE) ||
+        !(vol_cap_flags_g & H5VL_CAP_FLAG_DATASET_BASIC) || !(vol_cap_flags_g & H5VL_CAP_FLAG_GROUP_BASIC) ||
+        !(vol_cap_flags_g & H5VL_CAP_FLAG_STORED_DATATYPES) ||
+        !(vol_cap_flags_g & H5VL_CAP_FLAG_ATTR_BASIC)) {
+        SKIPPED();
+        HDprintf("    API functions for basic or more file,  basic dataset, group, datatype, or attribute "
+                 "aren't supported with this connector\n");
+        return 0;
+    }
+
+    TESTING_2("test setup");
+
+    if (prefix_filename(test_path_prefix, GET_OBJ_COUNT_TEST_FILENAME1, &prefixed_filename1) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+    if (prefix_filename(test_path_prefix, GET_OBJ_COUNT_TEST_FILENAME2, &prefixed_filename2) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+
+    if ((file_id = H5Fcreate(prefixed_filename1, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create file '%s'\n", prefixed_filename1);
+        goto error;
+    }
+
+    if ((group_id = H5Gcreate2(file_id, GET_OBJ_COUNT_TEST_GRP_NAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) <
+        0) {
+        H5_FAILED();
+        HDprintf("    couldn't create group '%s'\n", GET_OBJ_COUNT_TEST_GRP_NAME);
+        goto error;
+    }
+
+    /* Create a second file while keeping the first file open */
+    if ((file_id2 = H5Fcreate(prefixed_filename2, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create file '%s'\n", prefixed_filename2);
+        goto error;
+    }
+
+    /* Create a named datatype */
+    if ((named_dtype_id = H5Tcopy(H5T_NATIVE_INT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't copy a native datatype\n");
+        goto error;
+    }
+
+    if (H5Tcommit2(file_id2, GET_OBJ_COUNT_TEST_NAMED_DTYPE, named_dtype_id, H5P_DEFAULT, H5P_DEFAULT,
+                   H5P_DEFAULT) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't commit a named datatype\n");
+        goto error;
+    }
+
+    /* Create a dataspace for the attribute and dataset */
+    if ((dspace_id = H5Screate(H5S_SCALAR)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create data space for attribute\n");
+        goto error;
+    }
+
+    /* Create an attribute for the second file */
+    if ((attr_id = H5Acreate2(file_id2, GET_OBJ_COUNT_TEST_ATTR_NAME, H5T_NATIVE_INT, dspace_id, H5P_DEFAULT,
+                              H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create the attribute '%s'\n", GET_OBJ_COUNT_TEST_ATTR_NAME);
+        goto error;
+    }
+
+    /* Create a dataset for the second file */
+    if ((dset_id = H5Dcreate2(file_id2, GET_OBJ_COUNT_TEST_DSET_NAME, H5T_NATIVE_INT, dspace_id, H5P_DEFAULT,
+                              H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create the dataset '%s'\n", GET_OBJ_COUNT_TEST_DSET_NAME);
+        goto error;
+    }
+
+    PASSED();
+
+    BEGIN_MULTIPART
+    {
+        PART_BEGIN(H5Fget_obj_count_files)
+        {
+            TESTING_2("H5Fget_obj_count for files");
+
+            /* Get the number of files currently opened */
+            if ((obj_count = H5Fget_obj_count((hid_t)H5F_OBJ_ALL, H5F_OBJ_FILE)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get the number of open files\n");
+                PART_ERROR(H5Fget_obj_count_files);
+            }
+
+            if (obj_count != 2) {
+                H5_FAILED();
+                HDprintf("    number of open files (%ld) did not match expected number (2)\n", obj_count);
+                PART_ERROR(H5Fget_obj_count_files);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_obj_count_files);
+
+        PART_BEGIN(H5Fget_obj_count_grps_single_file)
+        {
+            TESTING_2("H5Fget_obj_count for groups in single file");
+
+            /* Get the number of groups */
+            if ((obj_count = H5Fget_obj_count(file_id, H5F_OBJ_GROUP)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't retrieve number of open groups\n");
+                PART_ERROR(H5Fget_obj_count_grps_single_file);
+            }
+
+            if (obj_count != 1) {
+                H5_FAILED();
+                HDprintf("    number of open groups (%ld) did not match expected number (1)\n", obj_count);
+                PART_ERROR(H5Fget_obj_count_grps_single_file);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_obj_count_grps_single_file);
+
+        PART_BEGIN(H5Fget_obj_count_grps)
+        {
+            TESTING_2("H5Fget_obj_count for groups");
+
+            /* Get the number of groups in two opened files */
+            if ((obj_count = H5Fget_obj_count((hid_t)H5F_OBJ_ALL, H5F_OBJ_GROUP)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get the number of open groups\n");
+                PART_ERROR(H5Fget_obj_count_grps);
+            }
+
+            if (obj_count != 1) {
+                H5_FAILED();
+                HDprintf("    number of open groups (%ld) did not match expected number (1)\n", obj_count);
+                PART_ERROR(H5Fget_obj_count_grps);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_obj_count_grps);
+
+        PART_BEGIN(H5Fget_obj_count_types)
+        {
+            TESTING_2("H5Fget_obj_count for datatypes");
+#ifndef WRONG_DATATYPE_OBJ_COUNT
+            /* Get the number of named datatype in two opened files */
+            if ((obj_count = H5Fget_obj_count((hid_t)H5F_OBJ_ALL, H5F_OBJ_DATATYPE)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get the number of open named datatypes\n");
+                PART_ERROR(H5Fget_obj_count_types);
+            }
+
+            if (obj_count != 1) {
+                H5_FAILED();
+                HDprintf("    number of open named datatypes (%ld) did not match expected number (1)\n",
+                         obj_count);
+                PART_ERROR(H5Fget_obj_count_types);
+            }
+
+            PASSED();
+#else
+            SKIPPED();
+            PART_EMPTY(H5Fget_obj_count_types);
+#endif
+        }
+        PART_END(H5Fget_obj_count_types);
+
+        PART_BEGIN(H5Fget_obj_count_attrs)
+        {
+            TESTING_2("H5Fget_obj_count for attributes");
+
+            /* Get the number of attribute in two opened files */
+            if ((obj_count = H5Fget_obj_count((hid_t)H5F_OBJ_ALL, H5F_OBJ_ATTR)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get the number of open attributes\n");
+                PART_ERROR(H5Fget_obj_count_attrs);
+            }
+
+            if (obj_count != 1) {
+                H5_FAILED();
+                HDprintf("    number of open attributes (%ld) did not match expected number (1)\n",
+                         obj_count);
+                PART_ERROR(H5Fget_obj_count_attrs);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_obj_count_attrs);
+
+        PART_BEGIN(H5Fget_obj_count_dsets)
+        {
+            TESTING_2("H5Fget_obj_count for datasets");
+
+            /* Get the number of dataset in two opened files */
+            if ((obj_count = H5Fget_obj_count((hid_t)H5F_OBJ_ALL, H5F_OBJ_DATASET)) < 0 || obj_count != 1) {
+                H5_FAILED();
+                HDprintf("    couldn't get the number of open datasets\n");
+                PART_ERROR(H5Fget_obj_count_dsets);
+            }
+
+            if (obj_count != 1) {
+                H5_FAILED();
+                HDprintf("    number of open datasets (%ld) did not match expected number (1)\n", obj_count);
+                PART_ERROR(H5Fget_obj_count_dsets);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_obj_count_dsets);
+
+        PART_BEGIN(H5Fget_obj_count_all_single_file)
+        {
+            TESTING_2("H5Fget_obj_count for all object types in single file");
+
+            /* Get the number of all open objects */
+            if ((obj_count = H5Fget_obj_count(file_id, H5F_OBJ_ALL)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't retrieve number of open objects\n");
+                PART_ERROR(H5Fget_obj_count_all_single_file);
+            }
+
+            /* One for the file and another for the group */
+            if (obj_count != 2) {
+                H5_FAILED();
+                HDprintf("    number of open objects (%ld) did not match expected number (2)\n", obj_count);
+                PART_ERROR(H5Fget_obj_count_all_single_file);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_obj_count_all_single_file);
+
+        PART_BEGIN(H5Fget_obj_count_all)
+        {
+            TESTING_2("H5Fget_obj_count for all object types");
+#ifndef WRONG_DATATYPE_OBJ_COUNT
+            /* Get the number of all open objects */
+            if ((obj_count = H5Fget_obj_count(H5F_OBJ_ALL, H5F_OBJ_ALL)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't retrieve number of open objects\n");
+                PART_ERROR(H5Fget_obj_count_all);
+            }
+
+            if (obj_count != 6) {
+                H5_FAILED();
+                HDprintf("    number of open objects (%ld) did not match expected number (6)\n", obj_count);
+                PART_ERROR(H5Fget_obj_count_all);
+            }
+
+            PASSED();
+#else
+            SKIPPED();
+            PART_EMPTY(H5Fget_obj_count_all);
+#endif
+        }
+        PART_END(H5Fget_obj_count_all);
+
+        PART_BEGIN(H5Fget_obj_ids_singular_grp)
+        {
+            TESTING_2("H5Fget_obj_ids for a singular group");
+
+            if (H5Fget_obj_ids(file_id, H5F_OBJ_GROUP, (size_t)obj_count, &object_id) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get opened group IDs\n");
+                PART_ERROR(H5Fget_obj_ids_singular_grp);
+            }
+
+            if (object_id != group_id) {
+                H5_FAILED();
+                HDprintf("    opened object ID (%ld) did not match only currently open group ID (%ld)\n",
+                         object_id, group_id);
+                PART_ERROR(H5Fget_obj_ids_singular_grp);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_obj_ids_singular_grp);
+    }
+    END_MULTIPART;
+
+    TESTING_2("test cleanup");
+
+    if (H5Gclose(group_id) < 0)
+        TEST_ERROR;
+    if (H5Sclose(dspace_id) < 0)
+        TEST_ERROR;
+    if (H5Aclose(attr_id) < 0)
+        TEST_ERROR;
+    if (H5Tclose(named_dtype_id) < 0)
+        TEST_ERROR;
+    if (H5Dclose(dset_id) < 0)
+        TEST_ERROR;
+    if (H5Fclose(file_id) < 0)
+        TEST_ERROR;
+    if (H5Fclose(file_id2) < 0)
+        TEST_ERROR;
+
+    HDfree(prefixed_filename1);
+    prefixed_filename1 = NULL;
+    HDfree(prefixed_filename2);
+    prefixed_filename2 = NULL;
+
+    PASSED();
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Gclose(group_id);
+        H5Tclose(named_dtype_id);
+        H5Sclose(dspace_id);
+        H5Aclose(attr_id);
+        H5Dclose(dset_id);
+        H5Fclose(file_id);
+        H5Fclose(file_id2);
+    }
+    H5E_END_TRY;
+
+    HDfree(prefixed_filename1);
+    HDfree(prefixed_filename2);
+
+    return 1;
+}
+
+/*
+ * A test to check that opening files in an overlapping way
+ * works correctly.
+ */
+static int
+test_file_open_overlap(void)
+{
+#ifndef NO_DOUBLE_OBJECT_OPENS
+    ssize_t obj_count;
+    hid_t   file_id           = H5I_INVALID_HID;
+    hid_t   file_id2          = H5I_INVALID_HID;
+    hid_t   group_id          = H5I_INVALID_HID;
+    hid_t   dspace_id         = H5I_INVALID_HID;
+    hid_t   dset_id           = H5I_INVALID_HID;
+    char   *prefixed_filename = NULL;
+#endif
+
+    TESTING("overlapping file opens");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC) || !(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_MORE) ||
+        !(vol_cap_flags_g & H5VL_CAP_FLAG_DATASET_BASIC) || !(vol_cap_flags_g & H5VL_CAP_FLAG_GROUP_BASIC)) {
+        SKIPPED();
+        HDprintf("    API functions for basic or more file, dataset, or group aren't supported with this "
+                 "connector\n");
+        return 0;
+    }
+
+#ifndef NO_DOUBLE_OBJECT_OPENS
+    if (prefix_filename(test_path_prefix, OVERLAPPING_FILENAME, &prefixed_filename) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+
+    if ((file_id = H5Fcreate(prefixed_filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create file '%s'\n", prefixed_filename);
+        goto error;
+    }
+
+    if ((file_id2 = H5Fopen(prefixed_filename, H5F_ACC_RDWR, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't open file '%s'\n", prefixed_filename);
+        goto error;
+    }
+
+    if ((group_id = H5Gcreate2(file_id, OVERLAPPING_OPEN_TEST_GRP_NAME, H5P_DEFAULT, H5P_DEFAULT,
+                               H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create group '%s'\n", OVERLAPPING_OPEN_TEST_GRP_NAME);
+        goto error;
+    }
+
+    /* Create a dataspace for the dataset */
+    if ((dspace_id = H5Screate(H5S_SCALAR)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create data space for dataset\n");
+        goto error;
+    }
+
+    /* Create a dataset in the group of the first file */
+    if ((dset_id = H5Dcreate2(group_id, OVERLAPPING_OPEN_TEST_DSET_NAME, H5T_NATIVE_INT, dspace_id,
+                              H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create the dataset '%s'\n", OVERLAPPING_OPEN_TEST_DSET_NAME);
+        goto error;
+    }
+
+    /* Get the number of objects opened in the first file: 3 == file + dataset + group */
+    if ((obj_count = H5Fget_obj_count(file_id, H5F_OBJ_LOCAL | H5F_OBJ_ALL)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't retrieve the number of objects opened in the file\n");
+        goto error;
+    }
+
+    if (obj_count != 3) {
+        H5_FAILED();
+        HDprintf("    number of objects opened in file (%ld) did not match expected number (3)\n", obj_count);
+        goto error;
+    }
+
+    if (H5Gclose(group_id) < 0)
+        TEST_ERROR;
+    if (H5Dclose(dset_id) < 0)
+        TEST_ERROR;
+    if (H5Fclose(file_id) < 0)
+        TEST_ERROR;
+
+    /* Create a dataset in the second file */
+    if ((dset_id = H5Dcreate2(file_id2, OVERLAPPING_OPEN_TEST_DSET_NAME, H5T_NATIVE_INT, dspace_id,
+                              H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create the dataset '%s'\n", OVERLAPPING_OPEN_TEST_DSET_NAME);
+        goto error;
+    }
+
+    /* Get the number of objects opened in the first file: 2 == file + dataset */
+    if ((obj_count = H5Fget_obj_count(file_id2, H5F_OBJ_ALL)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't retrieve the number of objects opened in the file\n");
+        goto error;
+    }
+
+    if (obj_count != 2) {
+        H5_FAILED();
+        HDprintf("    number of objects opened in the file (%ld) did not match expected number (2)\n",
+                 obj_count);
+        goto error;
+    }
+
+    if (H5Sclose(dspace_id) < 0)
+        TEST_ERROR;
+    if (H5Dclose(dset_id) < 0)
+        TEST_ERROR;
+    if (H5Fclose(file_id2) < 0)
+        TEST_ERROR;
+
+    HDfree(prefixed_filename);
+    prefixed_filename = NULL;
+
+    PASSED();
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Gclose(group_id);
+        H5Sclose(dspace_id);
+        H5Dclose(dset_id);
+        H5Fclose(file_id);
+        H5Fclose(file_id2);
+    }
+    H5E_END_TRY;
+
+    HDfree(prefixed_filename);
+
+    return 1;
+#else
+    SKIPPED();
+    return 0;
+#endif
+}
+
+/*
+ * A test to check that file mounting and unmounting works
+ * correctly.
+ */
+static int
+test_file_mounts(void)
+{
+#ifndef NO_FILE_MOUNTS
+    hid_t file_id           = H5I_INVALID_HID;
+    hid_t child_fid         = H5I_INVALID_HID;
+    hid_t group_id          = H5I_INVALID_HID;
+    char *prefixed_filename = NULL;
+#endif
+
+    TESTING("file mounting/unmounting");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & (H5VL_CAP_FLAG_FILE_BASIC)) || !(vol_cap_flags_g & H5VL_CAP_FLAG_MOUNT) ||
+        !(vol_cap_flags_g & H5VL_CAP_FLAG_GROUP_BASIC)) {
+        SKIPPED();
+        HDprintf("    API functions for basic file,  file mount, or basic group aren't supported with this "
+                 "connector\n");
+        return 0;
+    }
+
+#ifndef NO_FILE_MOUNTS
+    if (prefix_filename(test_path_prefix, FILE_MOUNT_TEST_FILENAME, &prefixed_filename) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+
+    if ((file_id = H5Fcreate(prefixed_filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create file '%s'\n", prefixed_filename);
+        goto error;
+    }
+
+    if ((group_id = H5Gcreate2(file_id, FILE_MOUNT_TEST_GRP_NAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) <
+        0) {
+        H5_FAILED();
+        HDprintf("    couldn't create group '%s'\n", FILE_MOUNT_TEST_GRP_NAME);
+        goto error;
+    }
+
+    if ((child_fid = H5Fopen(H5_api_test_filename, H5F_ACC_RDWR, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't open file '%s'\n", H5_api_test_filename);
+        goto error;
+    }
+
+    /* Mount one file (child_fid) to the group of another file (file_id) */
+    if (H5Fmount(file_id, FILE_MOUNT_TEST_GRP_NAME, child_fid, H5P_DEFAULT) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't mount file\n");
+        goto error;
+    }
+
+    if (H5Funmount(file_id, FILE_MOUNT_TEST_GRP_NAME) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't mount file\n");
+        goto error;
+    }
+
+    if (H5Gclose(group_id) < 0)
+        TEST_ERROR;
+    if (H5Fclose(file_id) < 0)
+        TEST_ERROR;
+    if (H5Fclose(child_fid) < 0)
+        TEST_ERROR;
+
+    HDfree(prefixed_filename);
+    prefixed_filename = NULL;
+
+    PASSED();
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        H5Gclose(group_id);
+        H5Fclose(file_id);
+        H5Fclose(child_fid);
+    }
+    H5E_END_TRY;
+
+    HDfree(prefixed_filename);
+
+    return 1;
+#else
+    SKIPPED();
+    return 0;
+#endif
+}
+
+/*
+ * A test to ensure that a file's name can be retrieved.
+ */
+static int
+test_get_file_name(void)
+{
+    ssize_t file_name_buf_len = 0;
+    hid_t   file_id           = H5I_INVALID_HID;
+    hid_t   group_id          = H5I_INVALID_HID;
+    hid_t   dset_id           = H5I_INVALID_HID;
+    hid_t   dspace_id         = H5I_INVALID_HID;
+    hid_t   attr_id           = H5I_INVALID_HID;
+    hid_t   named_dtype_id    = H5I_INVALID_HID;
+    char   *prefixed_filename = NULL;
+    char   *file_name_buf     = NULL;
+
+    TESTING_MULTIPART("retrieval of file name");
+
+    /* Make sure the connector supports the API functions being tested */
+    if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_BASIC) || !(vol_cap_flags_g & H5VL_CAP_FLAG_FILE_MORE) ||
+        !(vol_cap_flags_g & H5VL_CAP_FLAG_DATASET_BASIC) || !(vol_cap_flags_g & H5VL_CAP_FLAG_GROUP_BASIC) ||
+        !(vol_cap_flags_g & H5VL_CAP_FLAG_STORED_DATATYPES) ||
+        !(vol_cap_flags_g & H5VL_CAP_FLAG_ATTR_BASIC)) {
+        SKIPPED();
+        HDprintf("    API functions for basic or more file, basic dataset, group, datatype, or attribute "
+                 "aren't supported with this connector\n");
+        return 0;
+    }
+
+    TESTING_2("test setup");
+
+    if (prefix_filename(test_path_prefix, GET_FILE_NAME_TEST_FNAME, &prefixed_filename) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't prefix filename\n");
+        goto error;
+    }
+
+    if ((file_id = H5Fcreate(prefixed_filename, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+        H5_FAILED();
+        HDprintf("    couldn't create file '%s'\n", prefixed_filename);
+        goto error;
+    }
+
+    /* Retrieve the size of the file name */
+    if ((file_name_buf_len = H5Fget_name(file_id, NULL, 0)) < 0)
+        TEST_ERROR;
+
+    /* Allocate buffer for file name */
+    if (NULL == (file_name_buf = (char *)HDmalloc((size_t)file_name_buf_len + 1)))
+        TEST_ERROR;
+
+    PASSED();
+
+    BEGIN_MULTIPART
+    {
+        PART_BEGIN(H5Fget_name_file_id)
+        {
+            TESTING_2("H5Fget_name using file ID");
+
+            memset(file_name_buf, 0, (size_t)file_name_buf_len);
+
+            /* Retrieve the actual file name */
+            if (H5Fget_name(file_id, file_name_buf, (size_t)file_name_buf_len + 1) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get file name %s\n", prefixed_filename);
+                PART_ERROR(H5Fget_name_file_id);
+            }
+
+            if (HDstrncmp(file_name_buf, prefixed_filename, (size_t)file_name_buf_len)) {
+                H5_FAILED();
+                HDprintf("    file name '%s' didn't match expected name '%s'\n", file_name_buf,
+                         prefixed_filename);
+                PART_ERROR(H5Fget_name_file_id);
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_name_file_id);
+
+        PART_BEGIN(H5Fget_name_grp_id)
+        {
+            TESTING_2("H5Fget_name using non-root group ID");
+
+            /* Attempt to retrieve the name of the file from an object that isn't the root group */
+            memset(file_name_buf, 0, (size_t)file_name_buf_len);
+
+            if ((group_id = H5Gcreate2(file_id, GET_FILE_NAME_TEST_GRP_NAME, H5P_DEFAULT, H5P_DEFAULT,
+                                       H5P_DEFAULT)) < 0) {
+                H5_FAILED();
+                HDprintf("    failed to create group '%s'\n", GET_FILE_NAME_TEST_GRP_NAME);
+                PART_ERROR(H5Fget_name_grp_id);
+            }
+
+            if (H5Fget_name(group_id, file_name_buf, (size_t)file_name_buf_len + 1) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get file name %s\n", prefixed_filename);
+                PART_ERROR(H5Fget_name_grp_id);
+            }
+
+            if (HDstrncmp(file_name_buf, prefixed_filename, (size_t)file_name_buf_len)) {
+                H5_FAILED();
+                HDprintf("    file name '%s' didn't match expected name '%s'\n", file_name_buf,
+                         prefixed_filename);
+                PART_ERROR(H5Fget_name_grp_id);
+            }
+
+            if (group_id >= 0) {
+                H5E_BEGIN_TRY
+                {
+                    H5Gclose(group_id);
+                }
+                H5E_END_TRY;
+                group_id = H5I_INVALID_HID;
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_name_grp_id);
+
+        PART_BEGIN(H5Fget_name_dset_id)
+        {
+            TESTING_2("H5Fget_name using dataset ID");
+
+            if ((dspace_id = H5Screate(H5S_SCALAR)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't create dataspace\n");
+                PART_ERROR(H5Fget_name_dset_id);
+            }
+
+            /* Create a dataset in the file */
+            if ((dset_id = H5Dcreate2(file_id, GET_FILE_NAME_TEST_DSET_NAME, H5T_NATIVE_INT, dspace_id,
+                                      H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't create the dataset '%s'\n", GET_FILE_NAME_TEST_DSET_NAME);
+                PART_ERROR(H5Fget_name_dset_id);
+            }
+
+            /* Get and verify file name from the dataset */
+            if (H5Fget_name(dset_id, file_name_buf, (size_t)file_name_buf_len + 1) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get file name %s\n", prefixed_filename);
+                PART_ERROR(H5Fget_name_dset_id);
+            }
+
+            if (HDstrncmp(file_name_buf, prefixed_filename, (size_t)file_name_buf_len)) {
+                H5_FAILED();
+                HDprintf("    file name '%s' didn't match expected name '%s'\n", file_name_buf,
+                         prefixed_filename);
+                PART_ERROR(H5Fget_name_dset_id);
+            }
+
+            if (dspace_id >= 0) {
+                H5E_BEGIN_TRY
+                {
+                    H5Sclose(dspace_id);
+                }
+                H5E_END_TRY;
+                dspace_id = H5I_INVALID_HID;
+            }
+            if (dset_id >= 0) {
+                H5E_BEGIN_TRY
+                {
+                    H5Dclose(dset_id);
+                }
+                H5E_END_TRY;
+                dset_id = H5I_INVALID_HID;
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_name_dset_id);
+
+        PART_BEGIN(H5Fget_name_attr_id)
+        {
+            TESTING_2("H5Fget_name using attribute ID");
+
+            if ((dspace_id = H5Screate(H5S_SCALAR)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't create dataspace\n");
+                PART_ERROR(H5Fget_name_attr_id);
+            }
+
+            /* Create an attribute for the dataset */
+            if ((attr_id = H5Acreate2(file_id, GET_FILE_NAME_TEST_ATTR_NAME, H5T_NATIVE_INT, dspace_id,
+                                      H5P_DEFAULT, H5P_DEFAULT)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't create the attribute '%s'\n", GET_FILE_NAME_TEST_ATTR_NAME);
+                PART_ERROR(H5Fget_name_attr_id);
+            }
+
+            /* Get and verify file name from the attribute */
+            if (H5Fget_name(attr_id, file_name_buf, (size_t)file_name_buf_len + 1) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get file name %s\n", prefixed_filename);
+                PART_ERROR(H5Fget_name_attr_id);
+            }
+
+            if (HDstrncmp(file_name_buf, prefixed_filename, (size_t)file_name_buf_len)) {
+                H5_FAILED();
+                HDprintf("    file name '%s' didn't match expected name '%s'\n", file_name_buf,
+                         prefixed_filename);
+                PART_ERROR(H5Fget_name_attr_id);
+            }
+
+            if (dspace_id >= 0) {
+                H5E_BEGIN_TRY
+                {
+                    H5Sclose(dspace_id);
+                }
+                H5E_END_TRY;
+                dspace_id = H5I_INVALID_HID;
+            }
+            if (attr_id >= 0) {
+                H5E_BEGIN_TRY
+                {
+                    H5Aclose(attr_id);
+                }
+                H5E_END_TRY;
+                attr_id = H5I_INVALID_HID;
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_name_attr_id);
+
+        PART_BEGIN(H5Fget_name_dtype_id)
+        {
+            TESTING_2("H5Fget_name using committed datatype ID");
+
+            /* Create a named datatype */
+            if ((named_dtype_id = H5Tcopy(H5T_NATIVE_INT)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't copy a native datatype\n");
+                PART_ERROR(H5Fget_name_dtype_id);
+            }
+
+            if (H5Tcommit2(file_id, GET_FILE_NAME_TEST_NAMED_DTYPE, named_dtype_id, H5P_DEFAULT, H5P_DEFAULT,
+                           H5P_DEFAULT) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't commit a named datatype\n");
+                PART_ERROR(H5Fget_name_dtype_id);
+            }
+
+            /* Get and verify file name from the committed datatype */
+            if (H5Fget_name(named_dtype_id, file_name_buf, (size_t)file_name_buf_len + 1) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't get file name %s\n", prefixed_filename);
+                PART_ERROR(H5Fget_name_dtype_id);
+            }
+
+            if (HDstrncmp(file_name_buf, prefixed_filename, (size_t)file_name_buf_len)) {
+                H5_FAILED();
+                HDprintf("    file name '%s' didn't match expected name '%s'\n", file_name_buf,
+                         prefixed_filename);
+                PART_ERROR(H5Fget_name_dtype_id);
+            }
+
+            if (named_dtype_id >= 0) {
+                H5E_BEGIN_TRY
+                {
+                    H5Tclose(named_dtype_id);
+                }
+                H5E_END_TRY;
+                named_dtype_id = H5I_INVALID_HID;
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_name_dtype_id);
+
+        PART_BEGIN(H5Fget_name_dspace_id)
+        {
+            ssize_t name_len = 0;
+
+            TESTING_2("invalid H5Fget_name using dataspace ID");
+
+            if ((dspace_id = H5Screate(H5S_SCALAR)) < 0) {
+                H5_FAILED();
+                HDprintf("    couldn't create dataspace\n");
+                PART_ERROR(H5Fget_name_dspace_id);
+            }
+
+            /* Try get file name from data space.  Supposed to fail because
+             * it's illegal operation. */
+            H5E_BEGIN_TRY
+            {
+                name_len = H5Fget_name(dspace_id, file_name_buf, (size_t)file_name_buf_len + 1);
+            }
+            H5E_END_TRY;
+
+            if (name_len >= 0) {
+                H5_FAILED();
+                HDprintf("    retrieved file name using H5Fget_name on a dataspace ID!\n");
+                PART_ERROR(H5Fget_name_dspace_id);
+            }
+
+            if (dspace_id >= 0) {
+                H5E_BEGIN_TRY
+                {
+                    H5Sclose(dspace_id);
+                }
+                H5E_END_TRY;
+                dspace_id = H5I_INVALID_HID;
+            }
+
+            PASSED();
+        }
+        PART_END(H5Fget_name_dspace_id);
+    }
+    END_MULTIPART;
+
+    TESTING_2("test cleanup");
+
+    if (file_name_buf) {
+        HDfree(file_name_buf);
+        file_name_buf = NULL;
+    }
+
+    if (H5Fclose(file_id) < 0)
+        TEST_ERROR;
+
+    HDfree(prefixed_filename);
+    prefixed_filename = NULL;
+
+    PASSED();
+
+    return 0;
+
+error:
+    H5E_BEGIN_TRY
+    {
+        if (file_name_buf)
+            HDfree(file_name_buf);
+        H5Tclose(named_dtype_id);
+        H5Sclose(dspace_id);
+        H5Dclose(dset_id);
+        H5Aclose(attr_id);
+        H5Gclose(group_id);
+        H5Fclose(file_id);
+    }
+    H5E_END_TRY;
+
+    HDfree(prefixed_filename);
+
+    return 1;
+}
+
+/*
+ * Cleanup temporary test files
+ */
+static void
+cleanup_files(void)
+{
+    remove_test_file(test_path_prefix, FILE_CREATE_TEST_FILENAME);
+    remove_test_file(test_path_prefix, FILE_CREATE_EXCL_FILE_NAME);
+
+    /* The below file should not get created */
+    /* remove_test_file(test_path_prefix, FILE_CREATE_INVALID_PARAMS_FILE_NAME); */
+
+#ifndef NO_DOUBLE_OBJECT_OPENS
+    remove_test_file(test_path_prefix, OVERLAPPING_FILENAME);
+#endif
+    remove_test_file(test_path_prefix, FILE_PERMISSION_TEST_FILENAME);
+    remove_test_file(test_path_prefix, FILE_FLUSH_TEST_FILENAME);
+    remove_test_file(test_path_prefix, FILE_PROPERTY_LIST_TEST_FNAME1);
+    remove_test_file(test_path_prefix, FILE_PROPERTY_LIST_TEST_FNAME2);
+    remove_test_file(test_path_prefix, FILE_INTENT_TEST_FILENAME);
+    remove_test_file(test_path_prefix, GET_OBJ_COUNT_TEST_FILENAME1);
+    remove_test_file(test_path_prefix, GET_OBJ_COUNT_TEST_FILENAME2);
+#ifndef NO_FILE_MOUNTS
+    remove_test_file(test_path_prefix, FILE_MOUNT_TEST_FILENAME);
+#endif
+    remove_test_file(test_path_prefix, GET_FILE_NAME_TEST_FNAME);
+}
+
+int
+H5_api_file_test(void)
+{
+    size_t i;
+    int    nerrors;
+
+    HDprintf("**********************************************\n");
+    HDprintf("*                                            *\n");
+    HDprintf("*               API File Tests               *\n");
+    HDprintf("*                                            *\n");
+    HDprintf("**********************************************\n\n");
+
+    for (i = 0, nerrors = 0; i < ARRAY_LENGTH(file_tests); i++) {
+        nerrors += (*file_tests[i])() ? 1 : 0;
+    }
+
+    HDprintf("\n");
+
+    HDprintf("Cleaning up testing files\n");
+    cleanup_files();
+
+    return nerrors;
+}