diff options
Diffstat (limited to 'test/API/H5_api_group_test.c')
| -rw-r--r-- | test/API/H5_api_group_test.c | 2394 |
1 files changed, 2394 insertions, 0 deletions
diff --git a/test/API/H5_api_group_test.c b/test/API/H5_api_group_test.c new file mode 100644 index 0000000..f652202 --- /dev/null +++ b/test/API/H5_api_group_test.c @@ -0,0 +1,2394 @@ +/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * + * 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_group_test.h" + +static int test_create_group_under_root(void); +static int test_create_group_under_existing_group(void); +static int test_create_many_groups(void); +static int test_create_deep_groups(void); +static int test_create_intermediate_group(void); +static int test_create_group_invalid_params(void); +static int test_create_anonymous_group(void); +static int test_create_anonymous_group_invalid_params(void); +static int test_open_nonexistent_group(void); +static int test_open_group_invalid_params(void); +static int test_close_group_invalid_id(void); +static int test_group_property_lists(void); +static int test_get_group_info(void); +static int test_get_group_info_invalid_params(void); +static int test_flush_group(void); +static int test_flush_group_invalid_params(void); +static int test_refresh_group(void); +static int test_refresh_group_invalid_params(void); +static int create_group_recursive(hid_t parent_gid, unsigned counter); + +/* + * The array of group tests to be performed. + */ +static int (*group_tests[])(void) = { + test_create_group_under_root, + test_create_group_under_existing_group, + test_create_many_groups, + test_create_deep_groups, + test_create_intermediate_group, + test_create_group_invalid_params, + test_create_anonymous_group, + test_create_anonymous_group_invalid_params, + test_open_nonexistent_group, + test_open_group_invalid_params, + test_close_group_invalid_id, + test_group_property_lists, + test_get_group_info, + test_get_group_info_invalid_params, + test_flush_group, + test_flush_group_invalid_params, + test_refresh_group, + test_refresh_group_invalid_params, +}; + +/* + * A test to check that a group can be created under the root group. + */ +static int +test_create_group_under_root(void) +{ + hid_t file_id = H5I_INVALID_HID; + hid_t parent_gid = H5I_INVALID_HID; + + TESTING("creation of group under the root group"); + + /* 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)) { + SKIPPED(); + HDprintf(" API functions for basic file or group 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 '%s'\n", H5_api_test_filename); + goto error; + } + + /* Create the group under the root group of the file */ + if ((parent_gid = + H5Gcreate2(file_id, GROUP_CREATE_UNDER_ROOT_GNAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create group '%s'\n", GROUP_CREATE_UNDER_ROOT_GNAME); + goto error; + } + + if (H5Gclose(parent_gid) < 0) + TEST_ERROR; + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Gclose(parent_gid); + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test to check that a group can be created under an existing + * group which is not the root group. + */ +static int +test_create_group_under_existing_group(void) +{ + hid_t file_id = H5I_INVALID_HID; + hid_t parent_group_id = H5I_INVALID_HID, child_group_id = H5I_INVALID_HID, + grandchild_group_id = H5I_INVALID_HID; + + TESTING("creation of group under existing group using a relative path"); + + /* 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)) { + SKIPPED(); + HDprintf(" API functions for basic file or group 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; + } + + /* Open the already-existing group (/group_tests) in the file as the parent */ + if ((parent_group_id = H5Gopen2(file_id, GROUP_TEST_GROUP_NAME, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't open group\n"); + goto error; + } + + /* Create a new group (/group_tests/child_group) under the already-existing parent Group using a relative + * path */ + if ((child_group_id = H5Gcreate2(parent_group_id, GROUP_CREATE_UNDER_GROUP_REL_GNAME, H5P_DEFAULT, + H5P_DEFAULT, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create group using relative path: %s\n", GROUP_CREATE_UNDER_GROUP_REL_GNAME); + goto error; + } + + /* Create a new group (child_group/grandchild_group) under the already-existing parent Group using an + * absolute path */ + if ((grandchild_group_id = H5Gcreate2(parent_group_id, GROUP_CREATE_UNDER_GROUP_ABS_GNAME, H5P_DEFAULT, + H5P_DEFAULT, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create group using absolute path: %s\n", GROUP_CREATE_UNDER_GROUP_ABS_GNAME); + goto error; + } + + if (H5Gclose(grandchild_group_id) < 0) + TEST_ERROR; + if (H5Gclose(child_group_id) < 0) + TEST_ERROR; + if (H5Gclose(parent_group_id) < 0) + TEST_ERROR; + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Gclose(grandchild_group_id); + H5Gclose(child_group_id); + H5Gclose(parent_group_id); + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test to create many (one million) groups + */ +static int +test_create_many_groups(void) +{ + hid_t file_id = H5I_INVALID_HID; + hid_t container_group = H5I_INVALID_HID; + hid_t parent_group_id = H5I_INVALID_HID, child_group_id = H5I_INVALID_HID; + char group_name[NAME_BUF_SIZE]; + unsigned i; + + TESTING("H5Gcreate many groups"); + + /* 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)) { + SKIPPED(); + HDprintf(" API functions for basic file or group 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 '%s'\n", H5_api_test_filename); + goto error; + } + + if ((container_group = H5Gopen2(file_id, GROUP_TEST_GROUP_NAME, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't open container group\n"); + goto error; + } + + if ((parent_group_id = H5Gcreate2(container_group, MANY_GROUP_CREATIONS_GNAME, H5P_DEFAULT, H5P_DEFAULT, + H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create group '%s'\n", MANY_GROUP_CREATIONS_GNAME); + goto error; + } + + /* Create multiple groups under the parent group */ + HDprintf("\n"); + for (i = 0; i < GROUP_NUMB_MANY; i++) { + HDprintf("\r %u/%u", i + 1, GROUP_NUMB_MANY); + sprintf(group_name, "group %02u", i); + if ((child_group_id = + H5Gcreate2(parent_group_id, group_name, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create group '%s'\n", group_name); + goto error; + } + + if (H5Gclose(child_group_id) < 0) + TEST_ERROR; + } + + if (H5Gclose(parent_group_id) < 0) + TEST_ERROR; + if (H5Gclose(container_group) < 0) + TEST_ERROR; + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Gclose(child_group_id); + H5Gclose(parent_group_id); + H5Gclose(container_group); + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test to create groups of the depth GROUP_DEPTH. + */ +static int +test_create_deep_groups(void) +{ + hid_t file_id = H5I_INVALID_HID; + hid_t container_group = H5I_INVALID_HID; + hid_t group_id = H5I_INVALID_HID; + + TESTING("H5Gcreate groups of great depths"); + + /* 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)) { + SKIPPED(); + HDprintf(" API functions for basic file or group 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 '%s'\n", H5_api_test_filename); + goto error; + } + + if ((container_group = H5Gopen2(file_id, GROUP_TEST_GROUP_NAME, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't open container group\n"); + goto error; + } + + /* Create the group under the root group of the file */ + if ((group_id = H5Gcreate2(container_group, DEEP_GROUP_CREATIONS_GNAME, H5P_DEFAULT, H5P_DEFAULT, + H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create group '%s'\n", DEEP_GROUP_CREATIONS_GNAME); + goto error; + } + + HDprintf("\n"); + if (create_group_recursive(group_id, 1) < 0) + TEST_ERROR; + + if (H5Gclose(group_id) < 0) + TEST_ERROR; + if (H5Gclose(container_group) < 0) + TEST_ERROR; + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Gclose(group_id); + H5Gclose(container_group); + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * Recursive function to create groups of the depth GROUP_DEPTH. + */ +static int +create_group_recursive(hid_t parent_gid, unsigned counter) +{ + hid_t child_gid = H5I_INVALID_HID; + char gname[NAME_BUF_SIZE]; + + HDprintf("\r %u/%u", counter, GROUP_DEPTH); + if (counter == 1) + sprintf(gname, "2nd_child_group"); + else if (counter == 2) + sprintf(gname, "3rd_child_group"); + else + sprintf(gname, "%dth_child_group", counter + 1); + if ((child_gid = H5Gcreate2(parent_gid, gname, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create group '%s'\n", gname); + goto error; + } + + if (counter < GROUP_DEPTH) { + if (create_group_recursive(child_gid, counter + 1) < 0) + TEST_ERROR; + } + + if (H5Gclose(child_gid) < 0) + TEST_ERROR; + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Gclose(child_gid); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test to create groups automatically using H5Pset_create_intermediate_group + */ +static int +test_create_intermediate_group(void) +{ + hid_t file_id = H5I_INVALID_HID; + hid_t container_group = H5I_INVALID_HID; + hid_t group_id = H5I_INVALID_HID; + hid_t crt_intmd_lcpl_id = H5I_INVALID_HID; + + TESTING("H5Gcreate group with intermediate group creation"); + + /* 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)) { + SKIPPED(); + HDprintf(" API functions for basic file or group 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 '%s'\n", H5_api_test_filename); + goto error; + } + + if ((container_group = H5Gopen2(file_id, GROUP_TEST_GROUP_NAME, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't open container group\n"); + goto error; + } + + /* Set up plist for creating intermediate groups */ + if ((crt_intmd_lcpl_id = H5Pcreate(H5P_LINK_CREATE)) < 0) + TEST_ERROR; + if (H5Pset_create_intermediate_group(crt_intmd_lcpl_id, TRUE) < 0) + TEST_ERROR; + + /* Create an intermediate group using a relative path */ + if ((group_id = H5Gcreate2(container_group, + GROUP_CREATE_INTMD_REL_INTMD_NAME "/" GROUP_CREATE_INTMD_REL_END_NAME, + crt_intmd_lcpl_id, H5P_DEFAULT, H5P_DEFAULT)) < 0) + TEST_ERROR; + if (H5Gclose(group_id) < 0) + TEST_ERROR; + group_id = H5I_INVALID_HID; + + /* Verify both groups were created */ + if ((group_id = + H5Gopen2(file_id, GROUP_TEST_GROUP_NAME "/" GROUP_CREATE_INTMD_REL_INTMD_NAME, H5P_DEFAULT)) < 0) + TEST_ERROR; + if (H5Gclose(group_id) < 0) + TEST_ERROR; + group_id = H5I_INVALID_HID; + if ((group_id = H5Gopen2(file_id, + GROUP_TEST_GROUP_NAME "/" GROUP_CREATE_INTMD_REL_INTMD_NAME + "/" GROUP_CREATE_INTMD_REL_END_NAME, + H5P_DEFAULT)) < 0) + TEST_ERROR; + if (H5Gclose(group_id) < 0) + TEST_ERROR; + group_id = H5I_INVALID_HID; + + /* Create an intermediate group using an absolute path */ + if ((group_id = H5Gcreate2(container_group, + "/" GROUP_TEST_GROUP_NAME "/" GROUP_CREATE_INTMD_ABS_INTMD_NAME + "/" GROUP_CREATE_INTMD_ABS_END_NAME, + crt_intmd_lcpl_id, H5P_DEFAULT, H5P_DEFAULT)) < 0) + TEST_ERROR; + if (H5Gclose(group_id) < 0) + TEST_ERROR; + group_id = H5I_INVALID_HID; + + /* Verify both groups were created */ + if ((group_id = + H5Gopen2(file_id, GROUP_TEST_GROUP_NAME "/" GROUP_CREATE_INTMD_ABS_INTMD_NAME, H5P_DEFAULT)) < 0) + TEST_ERROR; + if (H5Gclose(group_id) < 0) + TEST_ERROR; + group_id = H5I_INVALID_HID; + if ((group_id = H5Gopen2(file_id, + GROUP_TEST_GROUP_NAME "/" GROUP_CREATE_INTMD_ABS_INTMD_NAME + "/" GROUP_CREATE_INTMD_ABS_END_NAME, + H5P_DEFAULT)) < 0) + TEST_ERROR; + if (H5Gclose(group_id) < 0) + TEST_ERROR; + group_id = H5I_INVALID_HID; + + /* Create two intermediate groups using an absolute path */ + if ((group_id = H5Gcreate2(container_group, + "/" GROUP_TEST_GROUP_NAME "/" GROUP_CREATE_INTMD_MULT_INTMD1_NAME + "/" GROUP_CREATE_INTMD_MULT_INTMD2_NAME "/" GROUP_CREATE_INTMD_MULT_END_NAME, + crt_intmd_lcpl_id, H5P_DEFAULT, H5P_DEFAULT)) < 0) + TEST_ERROR; + if (H5Gclose(group_id) < 0) + TEST_ERROR; + group_id = H5I_INVALID_HID; + + /* Verify all three groups were created */ + if ((group_id = H5Gopen2(file_id, GROUP_TEST_GROUP_NAME "/" GROUP_CREATE_INTMD_MULT_INTMD1_NAME, + H5P_DEFAULT)) < 0) + TEST_ERROR; + if (H5Gclose(group_id) < 0) + TEST_ERROR; + group_id = H5I_INVALID_HID; + if ((group_id = H5Gopen2(file_id, + GROUP_TEST_GROUP_NAME "/" GROUP_CREATE_INTMD_MULT_INTMD1_NAME + "/" GROUP_CREATE_INTMD_MULT_INTMD2_NAME, + H5P_DEFAULT)) < 0) + TEST_ERROR; + if (H5Gclose(group_id) < 0) + TEST_ERROR; + group_id = H5I_INVALID_HID; + if ((group_id = H5Gopen2(file_id, + GROUP_TEST_GROUP_NAME "/" GROUP_CREATE_INTMD_MULT_INTMD1_NAME + "/" GROUP_CREATE_INTMD_MULT_INTMD2_NAME + "/" GROUP_CREATE_INTMD_MULT_END_NAME, + H5P_DEFAULT)) < 0) + TEST_ERROR; + if (H5Gclose(group_id) < 0) + TEST_ERROR; + group_id = H5I_INVALID_HID; + + if (H5Gclose(container_group) < 0) + TEST_ERROR; + if (H5Fclose(file_id) < 0) + TEST_ERROR; + if (H5Pclose(crt_intmd_lcpl_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Gclose(group_id); + H5Gclose(container_group); + H5Fclose(file_id); + H5Pclose(crt_intmd_lcpl_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test to check that a group can't be created when H5Gcreate + * is passed invalid parameters. + */ +static int +test_create_group_invalid_params(void) +{ + hid_t file_id = H5I_INVALID_HID; + hid_t group_id = H5I_INVALID_HID; + + TESTING_MULTIPART("H5Gcreate with invalid parameters"); + + /* 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)) { + SKIPPED(); + HDprintf(" API functions for basic file or group aren't supported with this connector\n"); + return 0; + } + + TESTING_2("test setup"); + + 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); + goto error; + } + + PASSED(); + + BEGIN_MULTIPART + { + PART_BEGIN(H5Gcreate_invalid_loc_id) + { + TESTING_2("H5Gcreate with an invalid loc_id"); + + H5E_BEGIN_TRY + { + group_id = H5Gcreate2(H5I_INVALID_HID, GROUP_CREATE_INVALID_PARAMS_GROUP_NAME, H5P_DEFAULT, + H5P_DEFAULT, H5P_DEFAULT); + } + H5E_END_TRY; + + if (group_id >= 0) { + H5_FAILED(); + HDprintf(" created group with invalid loc_id!\n"); + H5Gclose(group_id); + PART_ERROR(H5Gcreate_invalid_loc_id); + } + + PASSED(); + } + PART_END(H5Gcreate_invalid_loc_id); + + PART_BEGIN(H5Gcreate_invalid_grp_name) + { + TESTING_2("H5Gcreate with an invalid group name"); + + H5E_BEGIN_TRY + { + group_id = H5Gcreate2(file_id, NULL, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); + } + H5E_END_TRY; + + if (group_id >= 0) { + H5_FAILED(); + HDprintf(" created group with a NULL name!\n"); + H5Gclose(group_id); + PART_ERROR(H5Gcreate_invalid_grp_name); + } + + H5E_BEGIN_TRY + { + group_id = H5Gcreate2(file_id, "", H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); + } + H5E_END_TRY; + + if (group_id >= 0) { + H5_FAILED(); + HDprintf(" created group with an invalid group name of ''!\n"); + H5Gclose(group_id); + PART_ERROR(H5Gcreate_invalid_grp_name); + } + + PASSED(); + } + PART_END(H5Gcreate_invalid_grp_name); + + PART_BEGIN(H5Gcreate_invalid_lcpl) + { + TESTING_2("H5Gcreate with an invalid LCPL"); + + H5E_BEGIN_TRY + { + group_id = H5Gcreate2(file_id, GROUP_CREATE_INVALID_PARAMS_GROUP_NAME, H5I_INVALID_HID, + H5P_DEFAULT, H5P_DEFAULT); + } + H5E_END_TRY; + + if (group_id >= 0) { + H5_FAILED(); + HDprintf(" created group with invalid LCPL!\n"); + H5Gclose(group_id); + PART_ERROR(H5Gcreate_invalid_lcpl); + } + + PASSED(); + } + PART_END(H5Gcreate_invalid_lcpl); + + PART_BEGIN(H5Gcreate_invalid_gcpl) + { + TESTING_2("H5Gcreate with an invalid GCPL"); + + H5E_BEGIN_TRY + { + group_id = H5Gcreate2(file_id, GROUP_CREATE_INVALID_PARAMS_GROUP_NAME, H5P_DEFAULT, + H5I_INVALID_HID, H5P_DEFAULT); + } + H5E_END_TRY; + + if (group_id >= 0) { + H5_FAILED(); + HDprintf(" created group with invalid GCPL!\n"); + H5Gclose(group_id); + PART_ERROR(H5Gcreate_invalid_gcpl); + } + + PASSED(); + } + PART_END(H5Gcreate_invalid_gcpl); + + PART_BEGIN(H5Gcreate_invalid_gapl) + { + TESTING_2("H5Gcreate with an invalid GAPL"); + + H5E_BEGIN_TRY + { + group_id = H5Gcreate2(file_id, GROUP_CREATE_INVALID_PARAMS_GROUP_NAME, H5P_DEFAULT, + H5P_DEFAULT, H5I_INVALID_HID); + } + H5E_END_TRY; + + if (group_id >= 0) { + H5_FAILED(); + HDprintf(" created group with invalid GAPL!\n"); + H5Gclose(group_id); + PART_ERROR(H5Gcreate_invalid_gapl); + } + + PASSED(); + } + PART_END(H5Gcreate_invalid_gapl); + } + END_MULTIPART; + + TESTING_2("test cleanup"); + + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Gclose(group_id); + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test to check that an anonymous group can be created with + * H5Gcreate_anon. + */ +static int +test_create_anonymous_group(void) +{ + hid_t file_id = H5I_INVALID_HID; + hid_t container_group = H5I_INVALID_HID, new_group_id = H5I_INVALID_HID; + + TESTING("creation of anonymous group"); + + /* 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)) { + SKIPPED(); + HDprintf(" API functions for basic file or group 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 ((container_group = H5Gopen2(file_id, GROUP_TEST_GROUP_NAME, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't open group\n"); + goto error; + } + + if ((new_group_id = H5Gcreate_anon(file_id, H5P_DEFAULT, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create anonymous group\n"); + goto error; + } + + if (H5Gclose(new_group_id) < 0) + TEST_ERROR; + if (H5Gclose(container_group) < 0) + TEST_ERROR; + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Gclose(new_group_id); + H5Gclose(container_group); + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test to check that an anonymous group can't be created + * when H5Gcreate_anon is passed invalid parameters. + */ +static int +test_create_anonymous_group_invalid_params(void) +{ + hid_t file_id = H5I_INVALID_HID; + hid_t container_group = H5I_INVALID_HID, new_group_id = H5I_INVALID_HID; + + TESTING_MULTIPART("H5Gcreate_anon with invalid parameters"); + + /* 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)) { + SKIPPED(); + HDprintf(" API functions for basic file or group aren't supported with this connector\n"); + return 0; + } + + TESTING_2("test setup"); + + 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 ((container_group = H5Gopen2(file_id, GROUP_TEST_GROUP_NAME, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't open group\n"); + goto error; + } + + PASSED(); + + BEGIN_MULTIPART + { + PART_BEGIN(H5Gcreate_anon_invalid_loc_id) + { + TESTING_2("H5Gcreate_anon with an invalid loc_id"); + + H5E_BEGIN_TRY + { + new_group_id = H5Gcreate_anon(H5I_INVALID_HID, H5P_DEFAULT, H5P_DEFAULT); + } + H5E_END_TRY; + + if (new_group_id >= 0) { + H5_FAILED(); + HDprintf(" created anonymous group with invalid loc_id!\n"); + H5Gclose(new_group_id); + PART_ERROR(H5Gcreate_anon_invalid_loc_id); + } + + PASSED(); + } + PART_END(H5Gcreate_anon_invalid_loc_id); + + PART_BEGIN(H5Gcreate_anon_invalid_gcpl) + { + TESTING_2("H5Gcreate_anon with an invalid GCPL"); + + H5E_BEGIN_TRY + { + new_group_id = H5Gcreate_anon(container_group, H5I_INVALID_HID, H5P_DEFAULT); + } + H5E_END_TRY; + + if (new_group_id >= 0) { + H5_FAILED(); + HDprintf(" created anonymous group with invalid GCPL!\n"); + H5Gclose(new_group_id); + PART_ERROR(H5Gcreate_anon_invalid_gcpl); + } + + PASSED(); + } + PART_END(H5Gcreate_anon_invalid_gcpl); + + PART_BEGIN(H5Gcreate_anon_invalid_gapl) + { + TESTING_2("H5Gcreate_anon with an invalid GAPL"); + + H5E_BEGIN_TRY + { + new_group_id = H5Gcreate_anon(container_group, H5P_DEFAULT, H5I_INVALID_HID); + } + H5E_END_TRY; + + if (new_group_id >= 0) { + H5_FAILED(); + HDprintf(" created anonymous group with invalid GAPL!\n"); + H5Gclose(new_group_id); + PART_ERROR(H5Gcreate_anon_invalid_gapl); + } + + PASSED(); + } + PART_END(H5Gcreate_anon_invalid_gapl); + } + END_MULTIPART; + + TESTING_2("test cleanup"); + + if (H5Gclose(container_group) < 0) + TEST_ERROR; + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Gclose(new_group_id); + H5Gclose(container_group); + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test to check that a group which doesn't exist cannot + * be opened. + */ +static int +test_open_nonexistent_group(void) +{ + hid_t file_id = H5I_INVALID_HID; + hid_t group_id = H5I_INVALID_HID; + + TESTING("for invalid opening of a nonexistent group"); + + /* 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)) { + SKIPPED(); + HDprintf(" API functions for basic file or group 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; + } + + H5E_BEGIN_TRY + { + group_id = H5Gopen2(file_id, OPEN_NONEXISTENT_GROUP_TEST_GNAME, H5P_DEFAULT); + } + H5E_END_TRY; + + if (group_id >= 0) { + H5_FAILED(); + HDprintf(" opened non-existent group!\n"); + goto error; + } + + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Gclose(group_id); + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test to check that a group can't be opened when H5Gopen + * is passed invalid parameters. + */ +static int +test_open_group_invalid_params(void) +{ + hid_t file_id = H5I_INVALID_HID; + hid_t group_id = H5I_INVALID_HID; + + TESTING_MULTIPART("H5Gopen with invalid parameters"); + + /* 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)) { + SKIPPED(); + HDprintf(" API functions for basic file or group aren't supported with this connector\n"); + return 0; + } + + TESTING_2("test setup"); + + 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); + goto error; + } + + PASSED(); + + BEGIN_MULTIPART + { + PART_BEGIN(H5Gopen_invalid_loc_id) + { + TESTING_2("H5Gopen with an invalid loc_id"); + + H5E_BEGIN_TRY + { + group_id = H5Gopen2(H5I_INVALID_HID, GROUP_TEST_GROUP_NAME, H5P_DEFAULT); + } + H5E_END_TRY; + + if (group_id >= 0) { + H5_FAILED(); + HDprintf(" opened group using an invalid loc_id!\n"); + H5Gclose(group_id); + PART_ERROR(H5Gopen_invalid_loc_id); + } + + PASSED(); + } + PART_END(H5Gopen_invalid_loc_id); + + PART_BEGIN(H5Gopen_invalid_grp_name) + { + TESTING_2("H5Gopen with an invalid group name"); + + H5E_BEGIN_TRY + { + group_id = H5Gopen2(file_id, NULL, H5P_DEFAULT); + } + H5E_END_TRY; + + if (group_id >= 0) { + H5_FAILED(); + HDprintf(" opened group using a NULL name!\n"); + H5Gclose(group_id); + PART_ERROR(H5Gopen_invalid_grp_name); + } + + H5E_BEGIN_TRY + { + group_id = H5Gopen2(file_id, "", H5P_DEFAULT); + } + H5E_END_TRY; + + if (group_id >= 0) { + H5_FAILED(); + HDprintf(" opened group using an invalid name of ''!\n"); + H5Gclose(group_id); + PART_ERROR(H5Gopen_invalid_grp_name); + } + + PASSED(); + } + PART_END(H5Gopen_invalid_grp_name); + + PART_BEGIN(H5Gopen_invalid_gapl) + { + TESTING_2("H5Gopen with an invalid GAPL"); + + H5E_BEGIN_TRY + { + group_id = H5Gopen2(file_id, GROUP_TEST_GROUP_NAME, H5I_INVALID_HID); + } + H5E_END_TRY; + + if (group_id >= 0) { + H5_FAILED(); + HDprintf(" opened group using an invalid GAPL!\n"); + H5Gclose(group_id); + PART_ERROR(H5Gopen_invalid_gapl); + } + + PASSED(); + } + PART_END(H5Gopen_invalid_gapl); + } + END_MULTIPART; + + TESTING_2("test cleanup"); + + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Gclose(group_id); + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test to check that H5Gclose doesn't succeed for an + * invalid group ID. + */ +static int +test_close_group_invalid_id(void) +{ + herr_t err_ret = -1; + + TESTING("H5Gclose with an invalid group ID"); + + /* Make sure the connector supports the API functions being tested */ + if (!(vol_cap_flags_g & H5VL_CAP_FLAG_GROUP_BASIC)) { + SKIPPED(); + HDprintf(" API functions for basic group aren't supported with this connector\n"); + return 0; + } + + H5E_BEGIN_TRY + { + err_ret = H5Gclose(H5I_INVALID_HID); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" close a group with an invalid ID!\n"); + goto error; + } + + PASSED(); + + return 0; + +error: + return 1; +} + +/* + * A test to check that a GCPL used for group creation can + * be persisted and that a valid copy of that GCPL can be + * retrieved later with a call to H5Gget_create_plist. + */ +static int +test_group_property_lists(void) +{ + unsigned dummy_prop_val = GROUP_PROPERTY_LIST_TEST_DUMMY_VAL; + hid_t file_id = H5I_INVALID_HID; + hid_t container_group = H5I_INVALID_HID; + hid_t group_id1 = H5I_INVALID_HID, group_id2 = H5I_INVALID_HID; + hid_t gcpl_id1 = H5I_INVALID_HID, gcpl_id2 = H5I_INVALID_HID; + + TESTING_MULTIPART("group 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_GROUP_BASIC) || + !(vol_cap_flags_g & H5VL_CAP_FLAG_GET_PLIST) || !(vol_cap_flags_g & H5VL_CAP_FLAG_CREATION_ORDER)) { + SKIPPED(); + HDprintf(" API functions for basic file, group, property list, creation order aren't supported " + "with this connector\n"); + return 0; + } + + TESTING_2("test setup"); + + 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 ((container_group = H5Gopen2(file_id, GROUP_TEST_GROUP_NAME, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't open container group\n"); + goto error; + } + + if ((gcpl_id1 = H5Pcreate(H5P_GROUP_CREATE)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create GCPL\n"); + goto error; + } + + if (H5Pset_link_creation_order(gcpl_id1, dummy_prop_val) < 0) { + H5_FAILED(); + HDprintf(" couldn't set property on GCPL\n"); + goto error; + } + + /* Create the group in the file */ + if ((group_id1 = H5Gcreate2(container_group, GROUP_PROPERTY_LIST_TEST_GROUP_NAME1, H5P_DEFAULT, gcpl_id1, + H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create group\n"); + goto error; + } + + /* Create the second group using H5P_DEFAULT for the GCPL */ + if ((group_id2 = H5Gcreate2(container_group, GROUP_PROPERTY_LIST_TEST_GROUP_NAME2, H5P_DEFAULT, + H5P_DEFAULT, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create group\n"); + goto error; + } + + if (H5Pclose(gcpl_id1) < 0) + TEST_ERROR; + + PASSED(); + + BEGIN_MULTIPART + { + PART_BEGIN(H5Gget_create_plist) + { + TESTING_2("H5Gget_create_plist"); + + /* Try to retrieve copies of the two property lists, one which has the property set and one which + * does not */ + if ((gcpl_id1 = H5Gget_create_plist(group_id1)) < 0) { + H5_FAILED(); + HDprintf(" couldn't get GCPL\n"); + PART_ERROR(H5Gget_create_plist); + } + + if ((gcpl_id2 = H5Gget_create_plist(group_id2)) < 0) { + H5_FAILED(); + HDprintf(" couldn't get GCPL\n"); + PART_ERROR(H5Gget_create_plist); + } + + /* Ensure that property list 1 has the property set and property list 2 does not */ + dummy_prop_val = 0; + + if (H5Pget_link_creation_order(gcpl_id1, &dummy_prop_val) < 0) { + H5_FAILED(); + HDprintf(" couldn't retrieve GCPL property value\n"); + PART_ERROR(H5Gget_create_plist); + } + + if (dummy_prop_val != GROUP_PROPERTY_LIST_TEST_DUMMY_VAL) { + H5_FAILED(); + HDprintf(" retrieved GCPL property value '%llu' did not match expected value '%llu'\n", + (unsigned long long)dummy_prop_val, + (unsigned long long)GROUP_PROPERTY_LIST_TEST_DUMMY_VAL); + PART_ERROR(H5Gget_create_plist); + } + + dummy_prop_val = 0; + + if (H5Pget_link_creation_order(gcpl_id2, &dummy_prop_val) < 0) { + H5_FAILED(); + HDprintf(" couldn't retrieve GCPL property value\n"); + PART_ERROR(H5Gget_create_plist); + } + + if (dummy_prop_val == GROUP_PROPERTY_LIST_TEST_DUMMY_VAL) { + H5_FAILED(); + HDprintf(" retrieved GCPL property value '%llu' matched control value '%llu' when it " + "shouldn't have\n", + (unsigned long long)dummy_prop_val, + (unsigned long long)GROUP_PROPERTY_LIST_TEST_DUMMY_VAL); + PART_ERROR(H5Gget_create_plist); + } + + PASSED(); + } + PART_END(H5Gget_create_plist); + + /* Now see if we can still retrieve copies of the property lists upon opening + * (instead of creating) a group. If they were reconstructed properly upon file + * open, the creation property lists should also have the same test values + * as set before. + */ + if (gcpl_id1 >= 0) { + H5E_BEGIN_TRY + { + H5Pclose(gcpl_id1); + } + H5E_END_TRY; + gcpl_id1 = H5I_INVALID_HID; + } + if (gcpl_id2 >= 0) { + H5E_BEGIN_TRY + { + H5Pclose(gcpl_id2); + } + H5E_END_TRY; + gcpl_id2 = H5I_INVALID_HID; + } + if (group_id1 >= 0) { + H5E_BEGIN_TRY + { + H5Gclose(group_id1); + } + H5E_END_TRY; + group_id1 = H5I_INVALID_HID; + } + if (group_id2 >= 0) { + H5E_BEGIN_TRY + { + H5Gclose(group_id2); + } + H5E_END_TRY; + group_id2 = H5I_INVALID_HID; + } + + PART_BEGIN(H5Gget_create_plist_reopened) + { + TESTING_2("H5Gget_create_plist after re-opening a group"); + + if ((group_id1 = H5Gopen2(container_group, GROUP_PROPERTY_LIST_TEST_GROUP_NAME1, H5P_DEFAULT)) < + 0) { + H5_FAILED(); + HDprintf(" couldn't open group\n"); + PART_ERROR(H5Gget_create_plist_reopened); + } + + if ((group_id2 = H5Gopen2(container_group, GROUP_PROPERTY_LIST_TEST_GROUP_NAME2, H5P_DEFAULT)) < + 0) { + H5_FAILED(); + HDprintf(" couldn't open group\n"); + PART_ERROR(H5Gget_create_plist_reopened); + } + + if ((gcpl_id1 = H5Gget_create_plist(group_id1)) < 0) { + H5_FAILED(); + HDprintf(" couldn't get property list\n"); + PART_ERROR(H5Gget_create_plist_reopened); + } + + if ((gcpl_id2 = H5Gget_create_plist(group_id2)) < 0) { + H5_FAILED(); + HDprintf(" couldn't get property list\n"); + PART_ERROR(H5Gget_create_plist_reopened); + } + + /* Re-check the property values */ + dummy_prop_val = 0; + + if (H5Pget_link_creation_order(gcpl_id1, &dummy_prop_val) < 0) { + H5_FAILED(); + HDprintf(" couldn't retrieve GCPL property value\n"); + PART_ERROR(H5Gget_create_plist_reopened); + } + + if (dummy_prop_val != GROUP_PROPERTY_LIST_TEST_DUMMY_VAL) { + H5_FAILED(); + HDprintf(" retrieved GCPL property value '%llu' did not match expected value '%llu'\n", + (unsigned long long)dummy_prop_val, + (unsigned long long)GROUP_PROPERTY_LIST_TEST_DUMMY_VAL); + PART_ERROR(H5Gget_create_plist_reopened); + } + + dummy_prop_val = 0; + + if (H5Pget_link_creation_order(gcpl_id2, &dummy_prop_val) < 0) { + H5_FAILED(); + HDprintf(" couldn't retrieve GCPL property value\n"); + PART_ERROR(H5Gget_create_plist_reopened); + } + + if (dummy_prop_val == GROUP_PROPERTY_LIST_TEST_DUMMY_VAL) { + H5_FAILED(); + HDprintf(" retrieved GCPL property value '%llu' matched control value '%llu' when it " + "shouldn't have\n", + (unsigned long long)dummy_prop_val, + (unsigned long long)GROUP_PROPERTY_LIST_TEST_DUMMY_VAL); + PART_ERROR(H5Gget_create_plist_reopened); + } + + PASSED(); + } + PART_END(H5Gget_create_plist_reopened); + } + END_MULTIPART; + + TESTING_2("test cleanup"); + + if (H5Pclose(gcpl_id1) < 0) + TEST_ERROR; + if (H5Pclose(gcpl_id2) < 0) + TEST_ERROR; + if (H5Gclose(group_id1) < 0) + TEST_ERROR; + if (H5Gclose(group_id2) < 0) + TEST_ERROR; + if (H5Gclose(container_group) < 0) + TEST_ERROR; + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Pclose(gcpl_id1); + H5Pclose(gcpl_id2); + H5Gclose(group_id1); + H5Gclose(group_id2); + H5Gclose(container_group); + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test for the functionality of H5Gget_info(_by_idx). + */ +static int +test_get_group_info(void) +{ + H5G_info_t group_info; + unsigned i; + hid_t file_id = H5I_INVALID_HID; + hid_t container_group = H5I_INVALID_HID; + hid_t parent_group_id = H5I_INVALID_HID, group_id = H5I_INVALID_HID; + hid_t gcpl_id = H5I_INVALID_HID; + char group_name[NAME_BUF_SIZE]; + + TESTING_MULTIPART("retrieval of group info"); + + /* 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_GROUP_MORE) || !(vol_cap_flags_g & H5VL_CAP_FLAG_CREATION_ORDER)) { + SKIPPED(); + HDprintf(" API functions for basic file or group, creation order aren't supported with this " + "connector\n"); + return 0; + } + + TESTING_2("test setup"); + + 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); + goto error; + } + + if ((container_group = H5Gopen2(file_id, GROUP_TEST_GROUP_NAME, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't open container group\n"); + goto error; + } + + if ((gcpl_id = H5Pcreate(H5P_GROUP_CREATE)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create a GCPL\n"); + goto error; + } + + if (H5Pset_link_creation_order(gcpl_id, H5P_CRT_ORDER_TRACKED | H5P_CRT_ORDER_INDEXED) < 0) { + H5_FAILED(); + HDprintf(" couldn't enable link creation order tracking and indexing on GCPL\n"); + goto error; + } + + if ((parent_group_id = H5Gcreate2(container_group, GROUP_GET_INFO_TEST_GROUP_NAME, H5P_DEFAULT, gcpl_id, + H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create group '%s'\n", GROUP_GET_INFO_TEST_GROUP_NAME); + goto error; + } + + /* Create multiple groups under the parent group */ + for (i = 0; i < GROUP_GET_INFO_TEST_GROUP_NUMB; i++) { + /* Create the groups with a reverse-ordering naming scheme to test creation order */ + HDsnprintf(group_name, NAME_BUF_SIZE, "group %02u", + (unsigned)(GROUP_GET_INFO_TEST_GROUP_NUMB - i - 1)); + + if ((group_id = H5Gcreate2(parent_group_id, group_name, H5P_DEFAULT, gcpl_id, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't create group '%s'\n", group_name); + goto error; + } + + if (H5Gclose(group_id) < 0) + TEST_ERROR; + } + + PASSED(); + + BEGIN_MULTIPART + { + PART_BEGIN(H5Gget_info) + { + TESTING_2("retrieval of group info with H5Gget_info"); + + memset(&group_info, 0, sizeof(group_info)); + + /* Retrieve information about the parent group */ + if (H5Gget_info(parent_group_id, &group_info) < 0) { + H5_FAILED(); + HDprintf(" couldn't get group info\n"); + PART_ERROR(H5Gget_info); + } + + if (group_info.nlinks != GROUP_GET_INFO_TEST_GROUP_NUMB) { + H5_FAILED(); + HDprintf(" group's number of links '%lu' doesn't match expected value '%u'\n", + group_info.nlinks, (unsigned int)GROUP_GET_INFO_TEST_GROUP_NUMB); + PART_ERROR(H5Gget_info); + } + + /* + * For the purpose of this test, the max creation order should match + * the number of links in the group. + */ + if (group_info.max_corder != GROUP_GET_INFO_TEST_GROUP_NUMB) { + H5_FAILED(); + HDprintf(" group's max creation order '%lld' doesn't match expected value '%lld'\n", + (long long)group_info.max_corder, (long long)GROUP_GET_INFO_TEST_GROUP_NUMB); + PART_ERROR(H5Gget_info); + } + + /* Ensure that the storage_type field is at least set to a meaningful value */ + if (group_info.storage_type != H5G_STORAGE_TYPE_SYMBOL_TABLE && + group_info.storage_type != H5G_STORAGE_TYPE_COMPACT && + group_info.storage_type != H5G_STORAGE_TYPE_DENSE && + group_info.storage_type != H5G_STORAGE_TYPE_UNKNOWN) { + H5_FAILED(); + HDprintf(" group info's 'storage_type' field wasn't set to a meaningful value\n"); + PART_ERROR(H5Gget_info); + } + + /* Assume that mounted should be FALSE in this case */ + if (group_info.mounted != FALSE) { + H5_FAILED(); + HDprintf(" group info's 'mounted' field was TRUE when it should have been FALSE\n"); + PART_ERROR(H5Gget_info); + } + + PASSED(); + } + PART_END(H5Gget_info); + + PART_BEGIN(H5Gget_info_by_name) + { + TESTING_2("retrieval of group info with H5Gget_info_by_name"); + + memset(&group_info, 0, sizeof(group_info)); + + /* Retrieve information about the parent group */ + if (H5Gget_info_by_name(container_group, GROUP_GET_INFO_TEST_GROUP_NAME, &group_info, + H5P_DEFAULT) < 0) { + H5_FAILED(); + HDprintf(" couldn't get group info by name\n"); + PART_ERROR(H5Gget_info_by_name); + } + + if (group_info.nlinks != GROUP_GET_INFO_TEST_GROUP_NUMB) { + H5_FAILED(); + HDprintf(" group's number of links '%lu' doesn't match expected value '%u'\n", + group_info.nlinks, (unsigned int)GROUP_GET_INFO_TEST_GROUP_NUMB); + PART_ERROR(H5Gget_info_by_name); + } + + /* + * For the purpose of this test, the max creation order should match + * the number of links in the group. + */ + if (group_info.max_corder != GROUP_GET_INFO_TEST_GROUP_NUMB) { + H5_FAILED(); + HDprintf(" group's max creation order '%lld' doesn't match expected value '%lld'\n", + (long long)group_info.max_corder, (long long)GROUP_GET_INFO_TEST_GROUP_NUMB); + PART_ERROR(H5Gget_info_by_name); + } + + /* Ensure that the storage_type field is at least set to a meaningful value */ + if (group_info.storage_type != H5G_STORAGE_TYPE_SYMBOL_TABLE && + group_info.storage_type != H5G_STORAGE_TYPE_COMPACT && + group_info.storage_type != H5G_STORAGE_TYPE_DENSE && + group_info.storage_type != H5G_STORAGE_TYPE_UNKNOWN) { + H5_FAILED(); + HDprintf(" group info's 'storage_type' field wasn't set to a meaningful value\n"); + PART_ERROR(H5Gget_info_by_name); + } + + /* Assume that mounted should be FALSE in this case */ + if (group_info.mounted != FALSE) { + H5_FAILED(); + HDprintf(" group info's 'mounted' field was TRUE when it should have been FALSE\n"); + PART_ERROR(H5Gget_info_by_name); + } + + PASSED(); + } + PART_END(H5Gget_info_by_name); + + PART_BEGIN(H5Gget_info_by_idx_crt_order_increasing) + { + TESTING_2("H5Gget_info_by_idx by creation order in increasing order"); + + for (i = 0; i < GROUP_GET_INFO_TEST_GROUP_NUMB; i++) { + memset(&group_info, 0, sizeof(group_info)); + + /* Retrieve information about each group under the parent group */ + if (H5Gget_info_by_idx(container_group, GROUP_GET_INFO_TEST_GROUP_NAME, H5_INDEX_CRT_ORDER, + H5_ITER_INC, (hsize_t)i, &group_info, H5P_DEFAULT) < 0) { + H5_FAILED(); + HDprintf(" couldn't get group info for group at index %u\n", i); + PART_ERROR(H5Gget_info_by_idx_crt_order_increasing); + } + + if (group_info.nlinks != 0) { + H5_FAILED(); + HDprintf(" group's number of links '%lu' doesn't match expected value '%d'\n", + group_info.nlinks, 0); + PART_ERROR(H5Gget_info_by_idx_crt_order_increasing); + } + + if (group_info.max_corder != 0) { + H5_FAILED(); + HDprintf(" group's max creation order '%lld' doesn't match expected value '%d'\n", + (long long)group_info.max_corder, 0); + PART_ERROR(H5Gget_info_by_idx_crt_order_increasing); + } + + /* Ensure that the storage_type field is at least set to a meaningful value */ + if (group_info.storage_type != H5G_STORAGE_TYPE_SYMBOL_TABLE && + group_info.storage_type != H5G_STORAGE_TYPE_COMPACT && + group_info.storage_type != H5G_STORAGE_TYPE_DENSE && + group_info.storage_type != H5G_STORAGE_TYPE_UNKNOWN) { + H5_FAILED(); + HDprintf(" group info's 'storage_type' field wasn't set to a meaningful value\n"); + PART_ERROR(H5Gget_info_by_idx_crt_order_increasing); + } + + /* Assume that mounted should be FALSE in this case */ + if (group_info.mounted != FALSE) { + H5_FAILED(); + HDprintf(" group info's 'mounted' field was TRUE when it should have been FALSE\n"); + PART_ERROR(H5Gget_info_by_idx_crt_order_increasing); + } + } + + PASSED(); + } + PART_END(H5Gget_info_by_idx_crt_order_increasing); + + PART_BEGIN(H5Gget_info_by_idx_crt_order_decreasing) + { + TESTING_2("H5Gget_info_by_idx by creation order in decreasing order"); + + for (i = 0; i < GROUP_GET_INFO_TEST_GROUP_NUMB; i++) { + memset(&group_info, 0, sizeof(group_info)); + + /* Retrieve information about each group under the parent group */ + if (H5Gget_info_by_idx(container_group, GROUP_GET_INFO_TEST_GROUP_NAME, H5_INDEX_CRT_ORDER, + H5_ITER_DEC, (hsize_t)i, &group_info, H5P_DEFAULT) < 0) { + H5_FAILED(); + HDprintf(" couldn't get group info for group at index %u\n", i); + PART_ERROR(H5Gget_info_by_idx_crt_order_decreasing); + } + + if (group_info.nlinks != 0) { + H5_FAILED(); + HDprintf(" group's number of links '%lu' doesn't match expected value '%d'\n", + group_info.nlinks, 0); + PART_ERROR(H5Gget_info_by_idx_crt_order_decreasing); + } + + if (group_info.max_corder != 0) { + H5_FAILED(); + HDprintf(" group's max creation order '%lld' doesn't match expected value '%d'\n", + (long long)group_info.max_corder, 0); + PART_ERROR(H5Gget_info_by_idx_crt_order_decreasing); + } + + /* Ensure that the storage_type field is at least set to a meaningful value */ + if (group_info.storage_type != H5G_STORAGE_TYPE_SYMBOL_TABLE && + group_info.storage_type != H5G_STORAGE_TYPE_COMPACT && + group_info.storage_type != H5G_STORAGE_TYPE_DENSE && + group_info.storage_type != H5G_STORAGE_TYPE_UNKNOWN) { + H5_FAILED(); + HDprintf(" group info's 'storage_type' field wasn't set to a meaningful value\n"); + PART_ERROR(H5Gget_info_by_idx_crt_order_decreasing); + } + + /* Assume that mounted should be FALSE in this case */ + if (group_info.mounted != FALSE) { + H5_FAILED(); + HDprintf(" group info's 'mounted' field was TRUE when it should have been FALSE\n"); + PART_ERROR(H5Gget_info_by_idx_crt_order_decreasing); + } + } + + PASSED(); + } + PART_END(H5Gget_info_by_idx_crt_order_decreasing); + + PART_BEGIN(H5Gget_info_by_idx_name_order_increasing) + { + TESTING_2("H5Gget_info_by_idx by alphabetical order in increasing order"); + + for (i = 0; i < GROUP_GET_INFO_TEST_GROUP_NUMB; i++) { + memset(&group_info, 0, sizeof(group_info)); + + /* Retrieve information about each group under the parent group */ + if (H5Gget_info_by_idx(container_group, GROUP_GET_INFO_TEST_GROUP_NAME, H5_INDEX_NAME, + H5_ITER_INC, (hsize_t)i, &group_info, H5P_DEFAULT) < 0) { + H5_FAILED(); + HDprintf(" couldn't get group info for group at index %u\n", i); + PART_ERROR(H5Gget_info_by_idx_name_order_increasing); + } + + if (group_info.nlinks != 0) { + H5_FAILED(); + HDprintf(" group's number of links '%lu' doesn't match expected value '%d'\n", + group_info.nlinks, 0); + PART_ERROR(H5Gget_info_by_idx_name_order_increasing); + } + + if (group_info.max_corder != 0) { + H5_FAILED(); + HDprintf(" group's max creation order '%lld' doesn't match expected value '%d'\n", + (long long)group_info.max_corder, 0); + PART_ERROR(H5Gget_info_by_idx_name_order_increasing); + } + + /* Ensure that the storage_type field is at least set to a meaningful value */ + if (group_info.storage_type != H5G_STORAGE_TYPE_SYMBOL_TABLE && + group_info.storage_type != H5G_STORAGE_TYPE_COMPACT && + group_info.storage_type != H5G_STORAGE_TYPE_DENSE && + group_info.storage_type != H5G_STORAGE_TYPE_UNKNOWN) { + H5_FAILED(); + HDprintf(" group info's 'storage_type' field wasn't set to a meaningful value\n"); + PART_ERROR(H5Gget_info_by_idx_name_order_increasing); + } + + /* Assume that mounted should be FALSE in this case */ + if (group_info.mounted != FALSE) { + H5_FAILED(); + HDprintf(" group info's 'mounted' field was TRUE when it should have been FALSE\n"); + PART_ERROR(H5Gget_info_by_idx_name_order_increasing); + } + } + + PASSED(); + } + PART_END(H5Gget_info_by_idx_name_order_increasing); + + PART_BEGIN(H5Gget_info_by_idx_name_order_decreasing) + { + TESTING_2("H5Gget_info_by_idx by alphabetical order in decreasing order"); +#ifndef NO_DECREASING_ALPHA_ITER_ORDER + for (i = 0; i < GROUP_GET_INFO_TEST_GROUP_NUMB; i++) { + memset(&group_info, 0, sizeof(group_info)); + + /* Retrieve information about each group under the parent group */ + if (H5Gget_info_by_idx(container_group, GROUP_GET_INFO_TEST_GROUP_NAME, H5_INDEX_NAME, + H5_ITER_DEC, (hsize_t)i, &group_info, H5P_DEFAULT) < 0) { + H5_FAILED(); + HDprintf(" couldn't get group info for group at index %u\n", i); + PART_ERROR(H5Gget_info_by_idx_name_order_decreasing); + } + + if (group_info.nlinks != 0) { + H5_FAILED(); + HDprintf(" group's number of links '%lld' doesn't match expected value '%lld'\n", + group_info.nlinks, 0); + PART_ERROR(H5Gget_info_by_idx_name_order_decreasing); + } + + if (group_info.max_corder != 0) { + H5_FAILED(); + HDprintf(" group's max creation order '%lld' doesn't match expected value '%lld'\n", + (long long)group_info.max_corder, 0); + PART_ERROR(H5Gget_info_by_idx_name_order_decreasing); + } + + /* Ensure that the storage_type field is at least set to a meaningful value */ + if (group_info.storage_type != H5G_STORAGE_TYPE_SYMBOL_TABLE && + group_info.storage_type != H5G_STORAGE_TYPE_COMPACT && + group_info.storage_type != H5G_STORAGE_TYPE_DENSE && + group_info.storage_type != H5G_STORAGE_TYPE_UNKNOWN) { + H5_FAILED(); + HDprintf(" group info's 'storage_type' field wasn't set to a meaningful value\n"); + PART_ERROR(H5Gget_info_by_idx_name_order_decreasing); + } + + /* Assume that mounted should be FALSE in this case */ + if (group_info.mounted != FALSE) { + H5_FAILED(); + HDprintf(" group info's 'mounted' field was TRUE when it should have been FALSE\n"); + PART_ERROR(H5Gget_info_by_idx_name_order_decreasing); + } + } + + PASSED(); +#else + SKIPPED(); + PART_EMPTY(H5Gget_info_by_idx_name_order_decreasing); +#endif + } + PART_END(H5Gget_info_by_idx_name_order_decreasing); + } + END_MULTIPART; + + TESTING_2("test cleanup"); + + if (H5Pclose(gcpl_id) < 0) + TEST_ERROR; + if (H5Gclose(parent_group_id) < 0) + TEST_ERROR; + if (H5Gclose(container_group) < 0) + TEST_ERROR; + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Pclose(gcpl_id); + H5Gclose(parent_group_id); + H5Gclose(group_id); + H5Gclose(container_group); + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test to check that a group's info can't be retrieved when + * H5Gget_info(_by_name/_by_idx) is passed invalid parameters. + */ +static int +test_get_group_info_invalid_params(void) +{ + H5G_info_t group_info; + herr_t err_ret = -1; + hid_t file_id = H5I_INVALID_HID; + + TESTING_MULTIPART("retrieval of group info with invalid parameters"); + + /* 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_MORE) || + !(vol_cap_flags_g & H5VL_CAP_FLAG_CREATION_ORDER)) { + SKIPPED(); + HDprintf(" API functions for basic file, more group, creation order aren't supported with this " + "connector\n"); + return 0; + } + + TESTING_2("test setup"); + + 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); + goto error; + } + + PASSED(); + + BEGIN_MULTIPART + { + PART_BEGIN(H5Gget_info_invalid_loc_id) + { + TESTING_2("H5Gget_info with an invalid loc_id"); + + H5E_BEGIN_TRY + { + err_ret = H5Gget_info(H5I_INVALID_HID, &group_info); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info with an invalid loc_id!\n"); + PART_ERROR(H5Gget_info_invalid_loc_id); + } + + PASSED(); + } + PART_END(H5Gget_info_invalid_loc_id); + + PART_BEGIN(H5Gget_info_invalid_grp_info_pointer) + { + TESTING_2("H5Gget_info with an invalid group info pointer"); + + H5E_BEGIN_TRY + { + err_ret = H5Gget_info(file_id, NULL); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info with invalid group info pointer!\n"); + PART_ERROR(H5Gget_info_invalid_grp_info_pointer); + } + + PASSED(); + } + PART_END(H5Gget_info_invalid_grp_info_pointer); + + PART_BEGIN(H5Gget_info_by_name_invalid_loc_id) + { + TESTING_2("H5Gget_info_by_name with an invalid loc_id"); + + H5E_BEGIN_TRY + { + err_ret = H5Gget_info_by_name(H5I_INVALID_HID, ".", &group_info, H5P_DEFAULT); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info_by_name with an invalid loc_id!\n"); + PART_ERROR(H5Gget_info_by_name_invalid_loc_id); + } + + PASSED(); + } + PART_END(H5Gget_info_by_name_invalid_loc_id); + + PART_BEGIN(H5Gget_info_by_name_invalid_grp_name) + { + TESTING_2("H5Gget_info_by_name with an invalid group name"); + + H5E_BEGIN_TRY + { + err_ret = H5Gget_info_by_name(file_id, NULL, &group_info, H5P_DEFAULT); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info_by_name with a NULL name!\n"); + PART_ERROR(H5Gget_info_by_name_invalid_grp_name); + } + + H5E_BEGIN_TRY + { + err_ret = H5Gget_info_by_name(file_id, "", &group_info, H5P_DEFAULT); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf( + " retrieved info of group using H5Gget_info_by_name with an invalid name of ''!\n"); + PART_ERROR(H5Gget_info_by_name_invalid_grp_name); + } + + PASSED(); + } + PART_END(H5Gget_info_by_name_invalid_grp_name); + + PART_BEGIN(H5Gget_info_by_name_invalid_grp_info_pointer) + { + TESTING_2("H5Gget_info_by_name with an invalid group info pointer"); + + H5E_BEGIN_TRY + { + err_ret = H5Gget_info_by_name(file_id, ".", NULL, H5P_DEFAULT); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info_by_name with an invalid group info " + "pointer!\n"); + PART_ERROR(H5Gget_info_by_name_invalid_grp_info_pointer); + } + + PASSED(); + } + PART_END(H5Gget_info_by_name_invalid_grp_info_pointer); + + PART_BEGIN(H5Gget_info_by_name_invalid_lapl) + { + TESTING_2("H5Gget_info_by_name with an invalid LAPL"); + + H5E_BEGIN_TRY + { + err_ret = H5Gget_info_by_name(file_id, ".", &group_info, H5I_INVALID_HID); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info_by_name with an invalid LAPL!\n"); + PART_ERROR(H5Gget_info_by_name_invalid_lapl); + } + + PASSED(); + } + PART_END(H5Gget_info_by_name_invalid_lapl); + + PART_BEGIN(H5Gget_info_by_idx_invalid_loc_id) + { + TESTING_2("H5Gget_info_by_idx with an invalid loc_id"); + + H5E_BEGIN_TRY + { + err_ret = H5Gget_info_by_idx(H5I_INVALID_HID, ".", H5_INDEX_NAME, H5_ITER_INC, 0, &group_info, + H5P_DEFAULT); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info_by_idx with an invalid loc_id!\n"); + PART_ERROR(H5Gget_info_by_idx_invalid_loc_id); + } + + PASSED(); + } + PART_END(H5Gget_info_by_idx_invalid_loc_id); + + PART_BEGIN(H5Gget_info_by_idx_invalid_grp_name) + { + TESTING_2("H5Gget_info_by_idx with an invalid group name"); + + H5E_BEGIN_TRY + { + err_ret = H5Gget_info_by_idx(file_id, NULL, H5_INDEX_NAME, H5_ITER_INC, 0, &group_info, + H5P_DEFAULT); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info_by_idx with a NULL group name!\n"); + PART_ERROR(H5Gget_info_by_idx_invalid_grp_name); + } + + H5E_BEGIN_TRY + { + err_ret = + H5Gget_info_by_idx(file_id, "", H5_INDEX_NAME, H5_ITER_INC, 0, &group_info, H5P_DEFAULT); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info_by_idx with an invalid group name of " + "''!\n"); + PART_ERROR(H5Gget_info_by_idx_invalid_grp_name); + } + + PASSED(); + } + PART_END(H5Gget_info_by_idx_invalid_grp_name); + + PART_BEGIN(H5Gget_info_by_idx_invalid_index_type) + { + TESTING_2("H5Gget_info_by_idx with an invalid index type"); + + H5E_BEGIN_TRY + { + err_ret = H5Gget_info_by_idx(file_id, ".", H5_INDEX_UNKNOWN, H5_ITER_INC, 0, &group_info, + H5P_DEFAULT); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info_by_idx with invalid index type " + "H5_INDEX_UNKNOWN!\n"); + PART_ERROR(H5Gget_info_by_idx_invalid_index_type); + } + + H5E_BEGIN_TRY + { + err_ret = + H5Gget_info_by_idx(file_id, ".", H5_INDEX_N, H5_ITER_INC, 0, &group_info, H5P_DEFAULT); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info_by_idx with invalid index type " + "H5_INDEX_N!\n"); + PART_ERROR(H5Gget_info_by_idx_invalid_index_type); + } + + PASSED(); + } + PART_END(H5Gget_info_by_idx_invalid_index_type); + + PART_BEGIN(H5Gget_info_by_idx_invalid_iter_order) + { + TESTING_2("H5Gget_info_by_idx with an invalid iteration order"); + + H5E_BEGIN_TRY + { + err_ret = H5Gget_info_by_idx(file_id, ".", H5_INDEX_NAME, H5_ITER_UNKNOWN, 0, &group_info, + H5P_DEFAULT); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info_by_idx with invalid iteration order " + "H5_ITER_UNKNOWN!\n"); + PART_ERROR(H5Gget_info_by_idx_invalid_iter_order); + } + + H5E_BEGIN_TRY + { + err_ret = + H5Gget_info_by_idx(file_id, ".", H5_INDEX_NAME, H5_ITER_N, 0, &group_info, H5P_DEFAULT); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info_by_idx with invalid iteration order " + "H5_ITER_N!\n"); + PART_ERROR(H5Gget_info_by_idx_invalid_iter_order); + } + + PASSED(); + } + PART_END(H5Gget_info_by_idx_invalid_iter_order); + + PART_BEGIN(H5Gget_info_by_idx_invalid_grp_info_pointer) + { + TESTING_2("H5Gget_info_by_idx with an invalid group info pointer"); + + H5E_BEGIN_TRY + { + err_ret = H5Gget_info_by_idx(file_id, ".", H5_INDEX_NAME, H5_ITER_INC, 0, NULL, H5P_DEFAULT); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info_by_idx with an invalid group info " + "pointer!\n"); + PART_ERROR(H5Gget_info_by_idx_invalid_grp_info_pointer); + } + + PASSED(); + } + PART_END(H5Gget_info_by_idx_invalid_grp_info_pointer); + + PART_BEGIN(H5Gget_info_by_idx_invalid_lapl) + { + TESTING_2("H5Gget_info_by_idx with an invalid LAPL"); + + H5E_BEGIN_TRY + { + err_ret = H5Gget_info_by_idx(file_id, ".", H5_INDEX_NAME, H5_ITER_INC, 0, &group_info, + H5I_INVALID_HID); + } + H5E_END_TRY; + + if (err_ret >= 0) { + H5_FAILED(); + HDprintf(" retrieved info of group using H5Gget_info_by_idx with an invalid LAPL!\n"); + PART_ERROR(H5Gget_info_by_idx_invalid_lapl); + } + + PASSED(); + } + PART_END(H5Gget_info_by_idx_invalid_lapl); + } + END_MULTIPART; + + TESTING_2("test cleanup"); + + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test for H5Gflush. + */ +static int +test_flush_group(void) +{ + hid_t file_id = H5I_INVALID_HID; + hid_t container_group = H5I_INVALID_HID; + hid_t group_id = H5I_INVALID_HID; + + TESTING("H5Gflush"); + + /* 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_FLUSH_REFRESH)) { + SKIPPED(); + HDprintf(" API functions for basic file, more group, creation order 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 '%s'\n", H5_api_test_filename); + goto error; + } + + if ((container_group = H5Gopen2(file_id, GROUP_TEST_GROUP_NAME, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't open container group\n"); + goto error; + } + + if ((group_id = H5Gcreate2(container_group, GROUP_FLUSH_GNAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < + 0) { + H5_FAILED(); + HDprintf(" couldn't create group '%s'\n", GROUP_FLUSH_GNAME); + goto error; + } + + /* Flush the group */ + if (H5Gflush(group_id) < 0) { + H5_FAILED(); + HDprintf(" couldn't flush the group '%s'\n", GROUP_FLUSH_GNAME); + goto error; + } + + if (H5Gclose(group_id) < 0) + TEST_ERROR; + if (H5Gclose(container_group) < 0) + TEST_ERROR; + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Gclose(group_id); + H5Gclose(container_group); + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test to check that H5Gflush fails when it + * is passed invalid parameters. + */ +static int +test_flush_group_invalid_params(void) +{ + herr_t status; + + TESTING("H5Gflush with invalid parameters"); + + /* Make sure the connector supports the API functions being tested */ + if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FLUSH_REFRESH)) { + SKIPPED(); + HDprintf(" API functions for group flush aren't supported with this connector\n"); + return 0; + } + + H5E_BEGIN_TRY + { + status = H5Gflush(H5I_INVALID_HID); + } + H5E_END_TRY; + + if (status >= 0) { + H5_FAILED(); + HDprintf(" flushed group with invalid ID!\n"); + goto error; + } + + PASSED(); + + return 0; + +error: + return 1; +} + +/* + * A test for H5Grefresh. + */ +static int +test_refresh_group(void) +{ + hid_t file_id = H5I_INVALID_HID; + hid_t container_group = H5I_INVALID_HID; + hid_t group_id = H5I_INVALID_HID; + + TESTING("H5Grefresh"); + + /* 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_FLUSH_REFRESH)) { + SKIPPED(); + HDprintf( + " API functions for basic file, group, or refresh 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 '%s'\n", H5_api_test_filename); + goto error; + } + + if ((container_group = H5Gopen2(file_id, GROUP_TEST_GROUP_NAME, H5P_DEFAULT)) < 0) { + H5_FAILED(); + HDprintf(" couldn't open container group\n"); + goto error; + } + + if ((group_id = H5Gcreate2(container_group, GROUP_REFRESH_GNAME, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT)) < + 0) { + H5_FAILED(); + HDprintf(" couldn't create group '%s'\n", GROUP_REFRESH_GNAME); + goto error; + } + + /* Refresh the group */ + if (H5Grefresh(group_id) < 0) { + H5_FAILED(); + HDprintf(" couldn't refresh the group '%s'\n", GROUP_REFRESH_GNAME); + goto error; + } + + if (H5Gclose(group_id) < 0) + TEST_ERROR; + if (H5Gclose(container_group) < 0) + TEST_ERROR; + if (H5Fclose(file_id) < 0) + TEST_ERROR; + + PASSED(); + + return 0; + +error: + H5E_BEGIN_TRY + { + H5Gclose(group_id); + H5Gclose(container_group); + H5Fclose(file_id); + } + H5E_END_TRY; + + return 1; +} + +/* + * A test to check that H5Grefresh fails when it + * is passed invalid parameters. + */ +static int +test_refresh_group_invalid_params(void) +{ + herr_t status; + + TESTING("H5Grefresh with invalid parameters"); + + /* Make sure the connector supports the API functions being tested */ + if (!(vol_cap_flags_g & H5VL_CAP_FLAG_FLUSH_REFRESH)) { + SKIPPED(); + HDprintf(" API functions for group refresh aren't supported with this connector\n"); + return 0; + } + + H5E_BEGIN_TRY + { + status = H5Grefresh(H5I_INVALID_HID); + } + H5E_END_TRY; + + if (status >= 0) { + H5_FAILED(); + HDprintf(" refreshed group with invalid ID!\n"); + goto error; + } + + PASSED(); + + return 0; + +error: + return 1; +} + +int +H5_api_group_test(void) +{ + size_t i; + int nerrors; + + HDprintf("**********************************************\n"); + HDprintf("* *\n"); + HDprintf("* API Group Tests *\n"); + HDprintf("* *\n"); + HDprintf("**********************************************\n\n"); + + for (i = 0, nerrors = 0; i < ARRAY_LENGTH(group_tests); i++) { + nerrors += (*group_tests[i])() ? 1 : 0; + } + + HDprintf("\n"); + + return nerrors; +} |