/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* 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;
}