diff options
Diffstat (limited to 'test/tattr.c')
-rw-r--r-- | test/tattr.c | 869 |
1 files changed, 434 insertions, 435 deletions
diff --git a/test/tattr.c b/test/tattr.c index 91cba51..2e391c5 100644 --- a/test/tattr.c +++ b/test/tattr.c @@ -164,7 +164,7 @@ typedef struct { int stop; /* # of iterations to stop after */ hsize_t curr; /* Current creation order value */ size_t max_visit; /* Size of "visited attribute" flag array */ - hbool_t *visited; /* Pointer to array of "visited attribute" flags */ + bool *visited; /* Pointer to array of "visited attribute" flags */ } attr_iter_info_t; static herr_t attr_op1(hid_t loc_id, const char *name, const H5A_info_t *ainfo, void *op_data); @@ -308,8 +308,8 @@ test_attr_basic_write(hid_t fapl) if (attr_name) { ret = (herr_t)H5Aget_name(attr, (size_t)(attr_name_size + 1), attr_name); CHECK(ret, FAIL, "H5Aget_name"); - ret = HDstrcmp(attr_name, ATTR_TMP_NAME); - VERIFY(ret, 0, "HDstrcmp"); + ret = strcmp(attr_name, ATTR_TMP_NAME); + VERIFY(ret, 0, "strcmp"); free(attr_name); attr_name = NULL; @@ -345,8 +345,8 @@ test_attr_basic_write(hid_t fapl) if (attr_name) { ret = (herr_t)H5Aget_name(attr2, (size_t)(attr_name_size + 1), attr_name); CHECK(ret, FAIL, "H5Aget_name"); - ret = HDstrcmp(attr_name, ATTR1A_NAME); - VERIFY(ret, 0, "HDstrcmp"); + ret = strcmp(attr_name, ATTR1A_NAME); + VERIFY(ret, 0, "strcmp"); free(attr_name); attr_name = NULL; @@ -870,8 +870,8 @@ test_attr_compound_read(hid_t fapl) VERIFY(fields, 3, "H5Tget_nmembers"); for (i = 0; i < fields; i++) { fieldname = H5Tget_member_name(type, (unsigned)i); - if (!(HDstrcmp(fieldname, ATTR4_FIELDNAME1) != 0 || HDstrcmp(fieldname, ATTR4_FIELDNAME2) != 0 || - HDstrcmp(fieldname, ATTR4_FIELDNAME3) != 0)) + if (!(strcmp(fieldname, ATTR4_FIELDNAME1) != 0 || strcmp(fieldname, ATTR4_FIELDNAME2) != 0 || + strcmp(fieldname, ATTR4_FIELDNAME3) != 0)) TestErrPrintf("invalid field name for field #%d: %s\n", i, fieldname); H5free_memory(fieldname); } /* end for */ @@ -930,8 +930,8 @@ test_attr_compound_read(hid_t fapl) /* Verify Name */ name_len = H5Aget_name(attr, (size_t)ATTR_NAME_LEN, attr_name); - VERIFY(name_len, HDstrlen(ATTR4_NAME), "H5Aget_name"); - if (HDstrcmp(attr_name, ATTR4_NAME) != 0) + VERIFY(name_len, strlen(ATTR4_NAME), "H5Aget_name"); + if (strcmp(attr_name, ATTR4_NAME) != 0) TestErrPrintf("attribute name different: attr_name=%s, should be %s\n", attr_name, ATTR4_NAME); /* Close attribute datatype */ @@ -1305,16 +1305,16 @@ test_attr_mult_read(hid_t fapl) /* Verify Name */ name_len = H5Aget_name(attr, (size_t)ATTR_NAME_LEN, attr_name); - VERIFY(name_len, HDstrlen(ATTR1_NAME), "H5Aget_name"); - if (HDstrcmp(attr_name, ATTR1_NAME) != 0) + VERIFY(name_len, strlen(ATTR1_NAME), "H5Aget_name"); + if (strcmp(attr_name, ATTR1_NAME) != 0) TestErrPrintf("attribute name different: attr_name=%s, should be %s\n", attr_name, ATTR1_NAME); /* Verify Name with too small of a buffer */ - name_len = H5Aget_name(attr, HDstrlen(ATTR1_NAME), attr_name); - VERIFY(name_len, HDstrlen(ATTR1_NAME), "H5Aget_name"); - HDstrcpy(temp_name, ATTR1_NAME); /* make a copy of the name */ - temp_name[HDstrlen(ATTR1_NAME) - 1] = '\0'; /* truncate it to match the one retrieved */ - if (HDstrcmp(attr_name, temp_name) != 0) + name_len = H5Aget_name(attr, strlen(ATTR1_NAME), attr_name); + VERIFY(name_len, strlen(ATTR1_NAME), "H5Aget_name"); + strcpy(temp_name, ATTR1_NAME); /* make a copy of the name */ + temp_name[strlen(ATTR1_NAME) - 1] = '\0'; /* truncate it to match the one retrieved */ + if (strcmp(attr_name, temp_name) != 0) TestErrPrintf("attribute name different: attr_name=%s, should be %s\n", attr_name, temp_name); /* Close attribute */ @@ -1363,16 +1363,16 @@ test_attr_mult_read(hid_t fapl) /* Verify Name */ name_len = H5Aget_name(attr, (size_t)ATTR_NAME_LEN, attr_name); - VERIFY(name_len, HDstrlen(ATTR2_NAME), "H5Aget_name"); - if (HDstrcmp(attr_name, ATTR2_NAME) != 0) + VERIFY(name_len, strlen(ATTR2_NAME), "H5Aget_name"); + if (strcmp(attr_name, ATTR2_NAME) != 0) TestErrPrintf("attribute name different: attr_name=%s, should be %s\n", attr_name, ATTR2_NAME); /* Verify Name with too small of a buffer */ - name_len = H5Aget_name(attr, HDstrlen(ATTR2_NAME), attr_name); - VERIFY(name_len, HDstrlen(ATTR2_NAME), "H5Aget_name"); - HDstrcpy(temp_name, ATTR2_NAME); /* make a copy of the name */ - temp_name[HDstrlen(ATTR2_NAME) - 1] = '\0'; /* truncate it to match the one retrieved */ - if (HDstrcmp(attr_name, temp_name) != 0) + name_len = H5Aget_name(attr, strlen(ATTR2_NAME), attr_name); + VERIFY(name_len, strlen(ATTR2_NAME), "H5Aget_name"); + strcpy(temp_name, ATTR2_NAME); /* make a copy of the name */ + temp_name[strlen(ATTR2_NAME) - 1] = '\0'; /* truncate it to match the one retrieved */ + if (strcmp(attr_name, temp_name) != 0) TestErrPrintf("attribute name different: attr_name=%s, should be %s\n", attr_name, temp_name); /* Close attribute */ @@ -1425,16 +1425,16 @@ test_attr_mult_read(hid_t fapl) /* Verify Name */ name_len = H5Aget_name(attr, (size_t)ATTR_NAME_LEN, attr_name); - VERIFY(name_len, HDstrlen(ATTR3_NAME), "H5Aget_name"); - if (HDstrcmp(attr_name, ATTR3_NAME) != 0) + VERIFY(name_len, strlen(ATTR3_NAME), "H5Aget_name"); + if (strcmp(attr_name, ATTR3_NAME) != 0) TestErrPrintf("attribute name different: attr_name=%s, should be %s\n", attr_name, ATTR3_NAME); /* Verify Name with too small of a buffer */ - name_len = H5Aget_name(attr, HDstrlen(ATTR3_NAME), attr_name); - VERIFY(name_len, HDstrlen(ATTR3_NAME), "H5Aget_name"); - HDstrcpy(temp_name, ATTR3_NAME); /* make a copy of the name */ - temp_name[HDstrlen(ATTR3_NAME) - 1] = '\0'; /* truncate it to match the one retrieved */ - if (HDstrcmp(attr_name, temp_name) != 0) + name_len = H5Aget_name(attr, strlen(ATTR3_NAME), attr_name); + VERIFY(name_len, strlen(ATTR3_NAME), "H5Aget_name"); + strcpy(temp_name, ATTR3_NAME); /* make a copy of the name */ + temp_name[strlen(ATTR3_NAME) - 1] = '\0'; /* truncate it to match the one retrieved */ + if (strcmp(attr_name, temp_name) != 0) TestErrPrintf("attribute name different: attr_name=%s, should be %s\n", attr_name, temp_name); /* Close attribute */ @@ -1463,19 +1463,19 @@ attr_op1(hid_t H5_ATTR_UNUSED loc_id, const char *name, const H5A_info_t H5_ATTR switch (*count) { case 0: - if (HDstrcmp(name, ATTR1_NAME) != 0) + if (strcmp(name, ATTR1_NAME) != 0) TestErrPrintf("attribute name different: name=%s, should be %s\n", name, ATTR1_NAME); (*count)++; break; case 1: - if (HDstrcmp(name, ATTR2_NAME) != 0) + if (strcmp(name, ATTR2_NAME) != 0) TestErrPrintf("attribute name different: name=%s, should be %s\n", name, ATTR2_NAME); (*count)++; break; case 2: - if (HDstrcmp(name, ATTR3_NAME) != 0) + if (strcmp(name, ATTR3_NAME) != 0) TestErrPrintf("attribute name different: name=%s, should be %s\n", name, ATTR3_NAME); (*count)++; break; @@ -1620,8 +1620,8 @@ test_attr_delete(hid_t fapl) /* Verify Name */ name_len = H5Aget_name(attr, (size_t)ATTR_NAME_LEN, attr_name); - VERIFY(name_len, HDstrlen(ATTR1_NAME), "H5Aget_name"); - if (HDstrcmp(attr_name, ATTR1_NAME) != 0) + VERIFY(name_len, strlen(ATTR1_NAME), "H5Aget_name"); + if (strcmp(attr_name, ATTR1_NAME) != 0) TestErrPrintf("attribute name different: attr_name=%s, should be %s\n", attr_name, ATTR1_NAME); /* Close attribute */ @@ -1635,8 +1635,8 @@ test_attr_delete(hid_t fapl) /* Verify Name */ name_len = H5Aget_name(attr, (size_t)ATTR_NAME_LEN, attr_name); - VERIFY(name_len, HDstrlen(ATTR3_NAME), "H5Aget_name"); - if (HDstrcmp(attr_name, ATTR3_NAME) != 0) + VERIFY(name_len, strlen(ATTR3_NAME), "H5Aget_name"); + if (strcmp(attr_name, ATTR3_NAME) != 0) TestErrPrintf("attribute name different: attr_name=%s, should be %s\n", attr_name, ATTR3_NAME); /* Close attribute */ @@ -1659,8 +1659,8 @@ test_attr_delete(hid_t fapl) /* Verify Name */ name_len = H5Aget_name(attr, (size_t)ATTR_NAME_LEN, attr_name); - VERIFY(name_len, HDstrlen(ATTR3_NAME), "H5Aget_name"); - if (HDstrcmp(attr_name, ATTR3_NAME) != 0) + VERIFY(name_len, strlen(ATTR3_NAME), "H5Aget_name"); + if (strcmp(attr_name, ATTR3_NAME) != 0) TestErrPrintf("attribute name different: attr_name=%s, should be %s\n", attr_name, ATTR3_NAME); /* Close attribute */ @@ -2126,7 +2126,7 @@ test_attr_dense_verify(hid_t loc_id, unsigned max_attr) /* Re-open all the attributes by name and verify the data */ for (u = 0; u < max_attr; u++) { /* Open attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Aopen(loc_id, attrname, H5P_DEFAULT); CHECK(attr, FAIL, "H5Aopen"); @@ -2151,10 +2151,10 @@ test_attr_dense_verify(hid_t loc_id, unsigned max_attr) CHECK(attr, FAIL, "H5Aopen_by_idx"); /* Verify Name */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); name_len = H5Aget_name(attr, (size_t)ATTR_NAME_LEN, check_name); - VERIFY(name_len, HDstrlen(attrname), "H5Aget_name"); - if (HDstrcmp(check_name, attrname) != 0) + VERIFY(name_len, strlen(attrname), "H5Aget_name"); + if (strcmp(check_name, attrname) != 0) TestErrPrintf("attribute name different: attrname = '%s', should be '%s'\n", check_name, attrname); @@ -2246,12 +2246,12 @@ test_attr_dense_create(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add attributes, until just before converting to dense storage */ for (u = 0; u < max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -2266,17 +2266,17 @@ test_attr_dense_create(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add one more attribute, to push into "dense" storage */ /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Write data into the attribute */ ret = H5Awrite(attr, H5T_NATIVE_UINT, &u); @@ -2392,12 +2392,12 @@ test_attr_dense_open(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add attributes, until just before converting to dense storage */ for (u = 0; u < max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -2416,17 +2416,17 @@ test_attr_dense_open(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add one more attribute, to push into "dense" storage */ /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Write data into the attribute */ ret = H5Awrite(attr, H5T_NATIVE_UINT, &u); @@ -2501,7 +2501,7 @@ test_attr_dense_delete(hid_t fcpl, hid_t fapl) */ fcpl = H5Pcopy(fcpl); CHECK(fcpl, FAIL, "H5Pcopy"); - ret = H5Pset_file_space_strategy(fcpl, H5F_FSPACE_STRATEGY_FSM_AGGR, TRUE, 1); + ret = H5Pset_file_space_strategy(fcpl, H5F_FSPACE_STRATEGY_FSM_AGGR, true, 1); CHECK(ret, FAIL, "H5Pset_file_space_strategy"); } fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl, fapl); @@ -2554,12 +2554,12 @@ test_attr_dense_delete(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add attributes, until well into dense storage */ for (u = 0; u < (max_compact * 2); u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -2579,7 +2579,7 @@ test_attr_dense_delete(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Close dataspace */ ret = H5Sclose(sid); @@ -2604,7 +2604,7 @@ test_attr_dense_delete(hid_t fcpl, hid_t fapl) /* Delete attributes until the attributes revert to compact storage again */ for (u--; u >= min_dense; u--) { /* Delete attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); ret = H5Adelete(dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); @@ -2615,29 +2615,29 @@ test_attr_dense_delete(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Delete one more attribute, which should cause reversion to compact storage */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); ret = H5Adelete(dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Verify attributes still left */ ret = test_attr_dense_verify(dataset, (u - 1)); CHECK(ret, FAIL, "test_attr_dense_verify"); /* Delete another attribute, to verify deletion in compact storage */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", (u - 1)); + snprintf(attrname, sizeof(attrname), "attr %02u", (u - 1)); ret = H5Adelete(dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Verify attributes still left */ ret = test_attr_dense_verify(dataset, (u - 2)); @@ -2702,7 +2702,7 @@ test_attr_dense_rename(hid_t fcpl, hid_t fapl) */ fcpl = H5Pcopy(fcpl); CHECK(fcpl, FAIL, "H5Pcopy"); - ret = H5Pset_file_space_strategy(fcpl, H5F_FSPACE_STRATEGY_FSM_AGGR, TRUE, 1); + ret = H5Pset_file_space_strategy(fcpl, H5F_FSPACE_STRATEGY_FSM_AGGR, true, 1); CHECK(ret, FAIL, "H5Pset_file_space_strategy"); } fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl, fapl); @@ -2742,7 +2742,7 @@ test_attr_dense_rename(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5Pget_attr_phase_change"); /* Using creation order or not */ - for (use_corder = FALSE; use_corder <= TRUE; use_corder++) { + for (use_corder = false; use_corder <= true; use_corder++) { if (use_corder) { ret = H5Pset_attr_creation_order(dcpl, H5P_CRT_ORDER_TRACKED | H5P_CRT_ORDER_INDEXED); @@ -2755,12 +2755,12 @@ test_attr_dense_rename(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add attributes, until well into dense storage */ for (u = 0; u < (max_compact * 2); u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, H5I_INVALID_HID, "H5Acreate2"); @@ -2773,7 +2773,7 @@ test_attr_dense_rename(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5Aclose"); /* Rename attribute */ - HDsnprintf(new_attrname, sizeof(new_attrname), "new attr %02u", u); + snprintf(new_attrname, sizeof(new_attrname), "new attr %02u", u); /* Rename attribute */ ret = H5Arename_by_name(fid, DSET1_NAME, attrname, new_attrname, H5P_DEFAULT); @@ -2787,7 +2787,7 @@ test_attr_dense_rename(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Close Dataset */ ret = H5Dclose(dataset); @@ -2826,7 +2826,7 @@ test_attr_dense_rename(hid_t fcpl, hid_t fapl) unsigned value; /* Attribute value */ /* Open attribute */ - HDsnprintf(attrname, sizeof(attrname), "new attr %02u", u); + snprintf(attrname, sizeof(attrname), "new attr %02u", u); attr = H5Aopen(dataset, attrname, H5P_DEFAULT); CHECK(attr, H5I_INVALID_HID, "H5Aopen"); @@ -2898,7 +2898,7 @@ test_attr_dense_unlink(hid_t fcpl, hid_t fapl) */ fcpl = H5Pcopy(fcpl); CHECK(fcpl, FAIL, "H5Pcopy"); - ret = H5Pset_file_space_strategy(fcpl, H5F_FSPACE_STRATEGY_FSM_AGGR, TRUE, 1); + ret = H5Pset_file_space_strategy(fcpl, H5F_FSPACE_STRATEGY_FSM_AGGR, true, 1); CHECK(ret, FAIL, "H5Pset_file_space_strategy"); } fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl, fapl); @@ -2945,12 +2945,12 @@ test_attr_dense_unlink(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add attributes, until well into dense storage */ for (u = 0; u < (max_compact * 2); u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -2970,7 +2970,7 @@ test_attr_dense_unlink(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Close dataspace */ ret = H5Sclose(sid); @@ -3087,13 +3087,13 @@ test_attr_dense_limits(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add first attribute, which should be immediately in dense storage */ /* Create attribute */ u = 0; - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -3107,13 +3107,13 @@ test_attr_dense_limits(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Add second attribute, to allow deletions to be checked easily */ /* Create attribute */ u = 1; - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -3127,7 +3127,7 @@ test_attr_dense_limits(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Delete second attribute, attributes should still be stored densely */ @@ -3137,19 +3137,19 @@ test_attr_dense_limits(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Delete first attribute, attributes should not be stored densely */ /* Delete attribute */ u = 0; - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); ret = H5Adelete(dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Close dataspace */ ret = H5Sclose(sid); @@ -3247,12 +3247,12 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add attributes, until just before converting to dense storage */ for (u = 0; u < max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -3267,7 +3267,7 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add one more attribute, to push into "dense" storage */ /* Create dataspace for attribute */ @@ -3275,13 +3275,13 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl) CHECK(sid2, FAIL, "H5Screate_simple"); /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_INT, sid2, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Open the attribute just created and get a second ID */ attr2 = H5Aopen(dataset, attrname, H5P_DEFAULT); @@ -3316,7 +3316,7 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Open first attribute for the dataset */ attr = H5Aopen(dataset, attrname, H5P_DEFAULT); @@ -3368,7 +3368,7 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Open first attribute for the dataset */ attr = H5Aopen(dataset, attrname, H5P_DEFAULT); @@ -3431,7 +3431,7 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Open first attribute for the dataset */ attr = H5Aopen_by_idx(dataset, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)4, H5P_DEFAULT, H5P_DEFAULT); @@ -3485,7 +3485,7 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Open attribute of the dataset for the first time */ attr = H5Aopen_by_idx(dataset, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)2, H5P_DEFAULT, H5P_DEFAULT); @@ -3499,7 +3499,7 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Open attribute for the second time */ attr2 = H5Aopen_by_idx(dataset, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)2, H5P_DEFAULT, H5P_DEFAULT); @@ -3549,7 +3549,7 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Open attribute of the dataset for the first time */ attr = H5Aopen_by_idx(dataset, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)3, H5P_DEFAULT, H5P_DEFAULT); @@ -3558,7 +3558,7 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl) /* Delete a few attributes until the storage switches to compact */ for (u = min_dense - 1; u <= max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); add_attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(add_attr, FAIL, "H5Acreate2"); @@ -3573,7 +3573,7 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Open attribute for the second time */ attr2 = H5Aopen_by_idx(dataset, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)3, H5P_DEFAULT, H5P_DEFAULT); @@ -3626,7 +3626,7 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl) /* Add attributes, until just before converting to dense storage */ for (u = 0; u < max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(gid1, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -3645,7 +3645,7 @@ test_attr_dense_dup_ids(hid_t fcpl, hid_t fapl) /* Check on group's attribute storage status */ is_dense = H5O__is_attr_dense_test(gid1); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Open the hard link just created */ gid2 = H5Gopen2(fid, GROUP2_NAME, H5P_DEFAULT); @@ -3784,15 +3784,15 @@ test_attr_big(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add first "small" attribute, which should be in compact storage */ /* Create attribute */ u = 0; - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -3802,15 +3802,15 @@ test_attr_big(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add second "small" attribute, which should stay in compact storage */ /* Create attribute */ u = 1; - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -3820,15 +3820,15 @@ test_attr_big(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add first "big" attribute, which should push storage into dense form */ /* Create attribute */ u = 2; - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, big_sid, H5P_DEFAULT, H5P_DEFAULT); if (low == H5F_LIBVER_LATEST) { CHECK(attr, FAIL, "H5Acreate2"); @@ -3843,15 +3843,15 @@ test_attr_big(hid_t fcpl, hid_t fapl) * form - QAK) */ is_empty = H5O__is_attr_empty_test(dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, (nshared_indices ? FALSE : TRUE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (nshared_indices ? false : true), "H5O__is_attr_dense_test"); /* Add second "big" attribute, which should leave storage in dense form */ /* Create attribute */ u = 3; - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, big_sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -3865,63 +3865,63 @@ test_attr_big(hid_t fcpl, hid_t fapl) * form - QAK) */ is_empty = H5O__is_attr_empty_test(dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, (nshared_indices ? FALSE : TRUE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (nshared_indices ? false : true), "H5O__is_attr_dense_test"); /* Delete second "small" attribute, attributes should still be stored densely */ /* Delete attribute */ u = 1; - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); ret = H5Adelete(dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, (nshared_indices ? FALSE : TRUE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (nshared_indices ? false : true), "H5O__is_attr_dense_test"); /* Delete second "big" attribute, attributes should still be stored densely */ /* Delete attribute */ u = 3; - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); ret = H5Adelete(dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, (nshared_indices ? FALSE : TRUE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (nshared_indices ? false : true), "H5O__is_attr_dense_test"); /* Delete first "big" attribute, attributes should _not_ be stored densely */ /* Delete attribute */ u = 2; - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); ret = H5Adelete(dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Delete first "small" attribute, should be no attributes now */ /* Delete attribute */ u = 0; - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); ret = H5Adelete(dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); } /* end if */ else { /* Shouldn't be able to create "big" attributes with older version of format */ @@ -3933,9 +3933,9 @@ test_attr_big(hid_t fcpl, hid_t fapl) * form - QAK) */ is_empty = H5O__is_attr_empty_test(dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); } /* end else */ /* Close dataspaces */ @@ -4022,7 +4022,7 @@ test_attr_null_space(hid_t fcpl, hid_t fapl) /* Add attribute with 'null' dataspace */ /* Create attribute */ - HDstrcpy(attrname, "null attr"); + strcpy(attrname, "null attr"); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, null_sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -4040,7 +4040,7 @@ test_attr_null_space(hid_t fcpl, hid_t fapl) /* Compare the dataspaces */ cmp = H5Sextent_equal(attr_sid, null_sid); CHECK(cmp, FAIL, "H5Sextent_equal"); - VERIFY(cmp, TRUE, "H5Sextent_equal"); + VERIFY(cmp, true, "H5Sextent_equal"); /* Close dataspace */ ret = H5Sclose(attr_sid); @@ -4062,7 +4062,7 @@ test_attr_null_space(hid_t fcpl, hid_t fapl) /* Add another attribute with 'null' dataspace */ /* Create attribute */ - HDstrcpy(attrname, "null attr #2"); + strcpy(attrname, "null attr #2"); attr = H5Acreate2(dataset, attrname, H5T_NATIVE_UINT, null_sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -4096,7 +4096,7 @@ test_attr_null_space(hid_t fcpl, hid_t fapl) CHECK(dataset, FAIL, "H5Dopen2"); /* Open first attribute */ - HDstrcpy(attrname, "null attr #2"); + strcpy(attrname, "null attr #2"); attr = H5Aopen(dataset, attrname, H5P_DEFAULT); CHECK(attr, FAIL, "H5Aopen"); @@ -4114,7 +4114,7 @@ test_attr_null_space(hid_t fcpl, hid_t fapl) /* Compare the dataspaces */ cmp = H5Sextent_equal(attr_sid, null_sid); CHECK(cmp, FAIL, "H5Sextent_equal"); - VERIFY(cmp, TRUE, "H5Sextent_equal"); + VERIFY(cmp, true, "H5Sextent_equal"); /* Close dataspace */ ret = H5Sclose(attr_sid); @@ -4134,7 +4134,7 @@ test_attr_null_space(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5Aclose"); /* Open second attribute */ - HDstrcpy(attrname, "null attr"); + strcpy(attrname, "null attr"); attr = H5Aopen(dataset, attrname, H5P_DEFAULT); CHECK(attr, FAIL, "H5Aopen"); @@ -4239,7 +4239,7 @@ test_attr_deprec(hid_t fcpl, hid_t fapl) /* Get number of attributes with bad ID */ H5E_BEGIN_TRY { - ret = H5Aget_num_attrs((hid_t)-1); + ret = H5Aget_num_attrs((hid_t)H5I_INVALID_HID); } H5E_END_TRY VERIFY(ret, FAIL, "H5Aget_num_attrs"); @@ -4289,7 +4289,7 @@ test_attr_deprec(hid_t fcpl, hid_t fapl) ** ****************************************************************/ static void -test_attr_many(hbool_t new_format, hid_t fcpl, hid_t fapl) +test_attr_many(bool new_format, hid_t fcpl, hid_t fapl) { hid_t fid; /* HDF5 File ID */ hid_t gid; /* Group ID */ @@ -4318,22 +4318,22 @@ test_attr_many(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Create many attributes */ for (u = 0; u < nattr; u++) { - HDsnprintf(attrname, sizeof(attrname), "a-%06u", u); + snprintf(attrname, sizeof(attrname), "a-%06u", u); exists = H5Aexists(gid, attrname); - VERIFY(exists, FALSE, "H5Aexists"); + VERIFY(exists, false, "H5Aexists"); exists = H5Aexists_by_name(fid, GROUP1_NAME, attrname, H5P_DEFAULT); - VERIFY(exists, FALSE, "H5Aexists_by_name"); + VERIFY(exists, false, "H5Aexists_by_name"); aid = H5Acreate2(gid, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(aid, FAIL, "H5Acreate2"); exists = H5Aexists(gid, attrname); - VERIFY(exists, TRUE, "H5Aexists"); + VERIFY(exists, true, "H5Aexists"); exists = H5Aexists_by_name(fid, GROUP1_NAME, attrname, H5P_DEFAULT); - VERIFY(exists, TRUE, "H5Aexists_by_name"); + VERIFY(exists, true, "H5Aexists_by_name"); ret = H5Awrite(aid, H5T_NATIVE_UINT, &u); CHECK(ret, FAIL, "H5Awrite"); @@ -4342,10 +4342,10 @@ test_attr_many(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5Aclose"); exists = H5Aexists(gid, attrname); - VERIFY(exists, TRUE, "H5Aexists"); + VERIFY(exists, true, "H5Aexists"); exists = H5Aexists_by_name(fid, GROUP1_NAME, attrname, H5P_DEFAULT); - VERIFY(exists, TRUE, "H5Aexists_by_name"); + VERIFY(exists, true, "H5Aexists_by_name"); } /* end for */ /* Close group */ @@ -4370,22 +4370,22 @@ test_attr_many(hbool_t new_format, hid_t fcpl, hid_t fapl) for (u = 0; u < nattr; u++) { unsigned value; /* Attribute value */ - HDsnprintf(attrname, sizeof(attrname), "a-%06u", u); + snprintf(attrname, sizeof(attrname), "a-%06u", u); exists = H5Aexists(gid, attrname); - VERIFY(exists, TRUE, "H5Aexists"); + VERIFY(exists, true, "H5Aexists"); exists = H5Aexists_by_name(fid, GROUP1_NAME, attrname, H5P_DEFAULT); - VERIFY(exists, TRUE, "H5Aexists_by_name"); + VERIFY(exists, true, "H5Aexists_by_name"); aid = H5Aopen(gid, attrname, H5P_DEFAULT); CHECK(aid, FAIL, "H5Aopen"); exists = H5Aexists(gid, attrname); - VERIFY(exists, TRUE, "H5Aexists"); + VERIFY(exists, true, "H5Aexists"); exists = H5Aexists_by_name(fid, GROUP1_NAME, attrname, H5P_DEFAULT); - VERIFY(exists, TRUE, "H5Aexists_by_name"); + VERIFY(exists, true, "H5Aexists_by_name"); ret = H5Aread(aid, H5T_NATIVE_UINT, &value); CHECK(ret, FAIL, "H5Aread"); @@ -4480,9 +4480,9 @@ test_attr_corder_create_basic(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Close Dataset */ ret = H5Dclose(dataset); @@ -4506,9 +4506,9 @@ test_attr_corder_create_basic(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Retrieve dataset creation property list for group */ dcpl = H5Dget_create_plist(dataset); @@ -4615,14 +4615,14 @@ test_attr_corder_create_compact(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Create several attributes, but keep storage in compact form */ for (u = 0; u < max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -4639,9 +4639,9 @@ test_attr_corder_create_compact(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (u + 1), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); } /* end for */ } /* end for */ @@ -4701,9 +4701,9 @@ test_attr_corder_create_compact(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, max_compact, "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Loop through attributes, checking their creation order values */ /* (the name index is used, but the creation order value is in the same order) */ @@ -4711,12 +4711,12 @@ test_attr_corder_create_compact(hid_t fcpl, hid_t fapl) H5A_info_t ainfo; /* Attribute information */ /* Retrieve information for attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); ret = H5Aget_info_by_name(my_dataset, ".", attrname, &ainfo, H5P_DEFAULT); CHECK(ret, FAIL, "H5Aget_info_by_name"); /* Verify creation order of attribute */ - VERIFY(ainfo.corder_valid, TRUE, "H5Aget_info_by_name"); + VERIFY(ainfo.corder_valid, true, "H5Aget_info_by_name"); VERIFY(ainfo.corder, u, "H5Aget_info_by_name"); } /* end for */ } /* end for */ @@ -4819,14 +4819,14 @@ test_attr_corder_create_dense(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Create several attributes, but keep storage in compact form */ for (u = 0; u < max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -4843,13 +4843,13 @@ test_attr_corder_create_dense(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (u + 1), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); } /* end for */ /* Create another attribute, to push into dense storage */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", max_compact); + snprintf(attrname, sizeof(attrname), "attr %02u", max_compact); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -4866,9 +4866,9 @@ test_attr_corder_create_dense(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (max_compact + 1), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Retrieve & verify # of records in the name & creation order indices */ ret = H5O__attr_dense_info_test(my_dataset, &name_count, &corder_count); @@ -4932,9 +4932,9 @@ test_attr_corder_create_dense(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (max_compact + 1), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Loop through attributes, checking their creation order values */ /* (the name index is used, but the creation order value is in the same order) */ @@ -4942,12 +4942,12 @@ test_attr_corder_create_dense(hid_t fcpl, hid_t fapl) H5A_info_t ainfo; /* Attribute information */ /* Retrieve information for attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); ret = H5Aget_info_by_name(my_dataset, ".", attrname, &ainfo, H5P_DEFAULT); CHECK(ret, FAIL, "H5Aget_info_by_name"); /* Verify creation order of attribute */ - VERIFY(ainfo.corder_valid, TRUE, "H5Aget_info_by_name"); + VERIFY(ainfo.corder_valid, true, "H5Aget_info_by_name"); VERIFY(ainfo.corder, u, "H5Aget_info_by_name"); } /* end for */ } /* end for */ @@ -4975,13 +4975,13 @@ test_attr_corder_create_dense(hid_t fcpl, hid_t fapl) static void test_attr_corder_create_reopen(hid_t fcpl, hid_t fapl) { - hid_t fid = -1; /* File ID */ - hid_t gcpl_id = -1; /* Group creation property list ID */ - hid_t gid = -1; /* Group ID */ - hid_t sid = -1; /* Dataspace ID */ - hid_t aid = -1; /* Attribute ID */ - int buf; /* Attribute data */ - herr_t ret; /* Generic return value */ + hid_t fid = H5I_INVALID_HID; /* File ID */ + hid_t gcpl_id = H5I_INVALID_HID; /* Group creation property list ID */ + hid_t gid = H5I_INVALID_HID; /* Group ID */ + hid_t sid = H5I_INVALID_HID; /* Dataspace ID */ + hid_t aid = H5I_INVALID_HID; /* Attribute ID */ + int buf; /* Attribute data */ + herr_t ret; /* Generic return value */ /* Output message about test being performed */ MESSAGE(5, ("Testing Creating Attributes w/New & Old Format\n")); @@ -5160,9 +5160,9 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); } /* end for */ /* Close Datasets */ @@ -5215,7 +5215,7 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) /* Create several attributes, but keep storage in compact form */ for (u = 0; u < max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -5232,13 +5232,13 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (u + 1), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); } /* end for */ /* Create another attribute, to push into dense storage */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", max_compact); + snprintf(attrname, sizeof(attrname), "attr %02u", max_compact); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -5255,9 +5255,9 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (max_compact + 1), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Retrieve & verify # of records in the name & creation order indices */ ret = H5O__attr_dense_info_test(my_dataset, &name_count, &corder_count); @@ -5266,7 +5266,7 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) /* Delete several attributes from object, until attribute storage resumes compact form */ for (u = max_compact; u >= min_dense; u--) { - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); ret = H5Adelete(my_dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); @@ -5275,9 +5275,9 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, u, "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Retrieve & verify # of records in the name & creation order indices */ ret = H5O__attr_dense_info_test(my_dataset, &name_count, &corder_count); @@ -5286,7 +5286,7 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) } /* end for */ /* Delete another attribute, to push attribute storage into compact form */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", (min_dense - 1)); + snprintf(attrname, sizeof(attrname), "attr %02u", (min_dense - 1)); ret = H5Adelete(my_dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); @@ -5295,14 +5295,14 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (min_dense - 1), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Re-add attributes to get back into dense form */ for (u = (min_dense - 1); u < (max_compact + 1); u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -5320,9 +5320,9 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (max_compact + 1), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Retrieve & verify # of records in the name & creation order indices */ ret = H5O__attr_dense_info_test(my_dataset, &name_count, &corder_count); @@ -5378,9 +5378,9 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (max_compact + 1), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Retrieve & verify # of records in the name & creation order indices */ ret = H5O__attr_dense_info_test(my_dataset, &name_count, &corder_count); @@ -5389,7 +5389,7 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) /* Delete several attributes from object, until attribute storage resumes compact form */ for (u = max_compact; u >= min_dense; u--) { - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); ret = H5Adelete(my_dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); @@ -5398,9 +5398,9 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, u, "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Retrieve & verify # of records in the name & creation order indices */ ret = H5O__attr_dense_info_test(my_dataset, &name_count, &corder_count); @@ -5409,7 +5409,7 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) } /* end for */ /* Delete another attribute, to push attribute storage into compact form */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", (min_dense - 1)); + snprintf(attrname, sizeof(attrname), "attr %02u", (min_dense - 1)); ret = H5Adelete(my_dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); @@ -5418,14 +5418,14 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (min_dense - 1), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Re-add attributes to get back into dense form */ for (u = (min_dense - 1); u < (max_compact + 1); u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -5443,9 +5443,9 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (max_compact + 1), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Retrieve & verify # of records in the name & creation order indices */ ret = H5O__attr_dense_info_test(my_dataset, &name_count, &corder_count); @@ -5454,11 +5454,11 @@ test_attr_corder_transition(hid_t fcpl, hid_t fapl) /* Delete all attributes */ for (u = max_compact; u > 0; u--) { - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); ret = H5Adelete(my_dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); } /* end for */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", 0); + snprintf(attrname, sizeof(attrname), "attr %02u", 0); ret = H5Adelete(my_dataset, attrname); CHECK(ret, FAIL, "H5Adelete"); } /* end for */ @@ -5535,7 +5535,7 @@ test_attr_corder_delete(hid_t fcpl, hid_t fapl) /* Loop to leave file open when deleting dataset, or to close & re-open file * before deleting dataset */ - for (reopen_file = FALSE; reopen_file <= TRUE; reopen_file++) { + for (reopen_file = false; reopen_file <= true; reopen_file++) { /* Create test file */ fid = H5Fcreate(FILENAME, H5F_ACC_TRUNC, fcpl, fapl); CHECK(fid, FAIL, "H5Fopen"); @@ -5569,14 +5569,14 @@ test_attr_corder_delete(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Create attributes, until attribute storage is in dense form */ for (u = 0; u < max_compact * 2; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -5594,9 +5594,9 @@ test_attr_corder_delete(hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (max_compact * 2), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Retrieve & verify # of records in the name & creation order indices */ ret = H5O__attr_dense_info_test(my_dataset, &name_count, &corder_count); @@ -5671,7 +5671,7 @@ test_attr_corder_delete(hid_t fcpl, hid_t fapl) *------------------------------------------------------------------------- */ static int -attr_info_by_idx_check(hid_t obj_id, const char *attrname, hsize_t n, hbool_t use_index) +attr_info_by_idx_check(hid_t obj_id, const char *attrname, hsize_t n, bool use_index) { char tmpname[NAME_BUF_SIZE]; /* Temporary attribute name */ H5A_info_t ainfo; /* Attribute info struct */ @@ -5698,7 +5698,7 @@ attr_info_by_idx_check(hid_t obj_id, const char *attrname, hsize_t n, hbool_t us ret = (herr_t)H5Aget_name_by_idx(obj_id, ".", H5_INDEX_CRT_ORDER, H5_ITER_INC, n, tmpname, (size_t)NAME_BUF_SIZE, H5P_DEFAULT); CHECK(ret, FAIL, "H5Aget_name_by_idx"); - if (HDstrcmp(attrname, tmpname) != 0) + if (strcmp(attrname, tmpname) != 0) TestErrPrintf("Line %d: attribute name size wrong!\n", __LINE__); /* Don't test "native" order if there is no creation order index, since @@ -5724,7 +5724,7 @@ attr_info_by_idx_check(hid_t obj_id, const char *attrname, hsize_t n, hbool_t us ret = (herr_t)H5Aget_name_by_idx(obj_id, ".", H5_INDEX_CRT_ORDER, H5_ITER_NATIVE, n, tmpname, (size_t)NAME_BUF_SIZE, H5P_DEFAULT); CHECK(ret, FAIL, "H5Aget_name_by_idx"); - if (HDstrcmp(attrname, tmpname) != 0) + if (strcmp(attrname, tmpname) != 0) TestErrPrintf("Line %d: attribute name size wrong!\n", __LINE__); } /* end if */ @@ -5745,7 +5745,7 @@ attr_info_by_idx_check(hid_t obj_id, const char *attrname, hsize_t n, hbool_t us ret = (herr_t)H5Aget_name_by_idx(obj_id, ".", H5_INDEX_CRT_ORDER, H5_ITER_DEC, (hsize_t)0, tmpname, (size_t)NAME_BUF_SIZE, H5P_DEFAULT); CHECK(ret, FAIL, "H5Aget_name_by_idx"); - if (HDstrcmp(attrname, tmpname) != 0) + if (strcmp(attrname, tmpname) != 0) TestErrPrintf("Line %d: attribute name size wrong!\n", __LINE__); /* Verify the information for first attribute, in increasing name order */ @@ -5765,7 +5765,7 @@ attr_info_by_idx_check(hid_t obj_id, const char *attrname, hsize_t n, hbool_t us ret = (herr_t)H5Aget_name_by_idx(obj_id, ".", H5_INDEX_NAME, H5_ITER_INC, n, tmpname, (size_t)NAME_BUF_SIZE, H5P_DEFAULT); CHECK(ret, FAIL, "H5Aget_name_by_idx"); - if (HDstrcmp(attrname, tmpname) != 0) + if (strcmp(attrname, tmpname) != 0) TestErrPrintf("Line %d: attribute name size wrong!\n", __LINE__); /* Don't test "native" order queries on link name order, since there's not @@ -5789,7 +5789,7 @@ attr_info_by_idx_check(hid_t obj_id, const char *attrname, hsize_t n, hbool_t us ret = (herr_t)H5Aget_name_by_idx(obj_id, ".", H5_INDEX_NAME, H5_ITER_DEC, (hsize_t)0, tmpname, (size_t)NAME_BUF_SIZE, H5P_DEFAULT); CHECK(ret, FAIL, "H5Aget_name_by_idx"); - if (HDstrcmp(attrname, tmpname) != 0) + if (strcmp(attrname, tmpname) != 0) TestErrPrintf("Line %d: attribute name size wrong!\n", __LINE__); /* Retrieve current # of errors */ @@ -5806,7 +5806,7 @@ attr_info_by_idx_check(hid_t obj_id, const char *attrname, hsize_t n, hbool_t us ** ****************************************************************/ static void -test_attr_info_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) +test_attr_info_by_idx(bool new_format, hid_t fcpl, hid_t fapl) { hid_t fid; /* HDF5 File ID */ hid_t dset1, dset2, dset3; /* Dataset IDs */ @@ -5848,7 +5848,7 @@ test_attr_info_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5Pget_attr_phase_change"); /* Loop over using index for creation order value */ - for (use_index = FALSE; use_index <= TRUE; use_index++) { + for (use_index = false; use_index <= true; use_index++) { /* Output message about test being performed */ if (use_index) MESSAGE(5, ("Testing Querying Attribute Info By Index w/Creation Order Index\n")); @@ -5860,7 +5860,7 @@ test_attr_info_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(fid, FAIL, "H5Fcreate"); /* Set attribute creation order tracking & indexing for object */ - if (new_format == TRUE) { + if (new_format == true) { ret = H5Pset_attr_creation_order( dcpl, (H5P_CRT_ORDER_TRACKED | (use_index ? H5P_CRT_ORDER_INDEXED : (unsigned)0))); CHECK(ret, FAIL, "H5Pset_attr_creation_order"); @@ -5895,9 +5895,9 @@ test_attr_info_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Check for query on non-existent attribute */ H5E_BEGIN_TRY @@ -5918,7 +5918,7 @@ test_attr_info_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Create attributes, up to limit of compact form */ for (u = 0; u < max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -5940,9 +5940,9 @@ test_attr_info_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, max_compact, "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Check for out of bound offset queries */ H5E_BEGIN_TRY @@ -5970,7 +5970,7 @@ test_attr_info_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Create more attributes, to push into dense form */ for (; u < (max_compact * 2); u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -5984,7 +5984,7 @@ test_attr_info_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Verify state of object */ is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, (new_format ? TRUE : FALSE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (new_format ? true : false), "H5O__is_attr_dense_test"); /* Verify information for new attribute */ ret = attr_info_by_idx_check(my_dataset, attrname, (hsize_t)u, use_index); @@ -5996,9 +5996,9 @@ test_attr_info_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (max_compact * 2), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, (new_format ? TRUE : FALSE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (new_format ? true : false), "H5O__is_attr_dense_test"); if (new_format) { /* Retrieve & verify # of records in the name & creation order indices */ @@ -6288,7 +6288,7 @@ test_attr_get_name_invalid_buf(hid_t fcpl, hid_t fapl) ** ****************************************************************/ static void -test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) +test_attr_delete_by_idx(bool new_format, hid_t fcpl, hid_t fapl) { hid_t fid; /* HDF5 File ID */ hid_t dset1, dset2, dset3; /* Dataset IDs */ @@ -6338,7 +6338,7 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Loop over operating in different orders */ for (order = H5_ITER_INC; order <= H5_ITER_DEC; order++) { /* Loop over using index for creation order value */ - for (use_index = FALSE; use_index <= TRUE; use_index++) { + for (use_index = false; use_index <= true; use_index++) { /* Print appropriate test message */ if (idx_type == H5_INDEX_CRT_ORDER) { if (order == H5_ITER_INC) { @@ -6382,7 +6382,7 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(fid, FAIL, "H5Fcreate"); /* Set attribute creation order tracking & indexing for object */ - if (new_format == TRUE) { + if (new_format == true) { ret = H5Pset_attr_creation_order( dcpl, (H5P_CRT_ORDER_TRACKED | (use_index ? H5P_CRT_ORDER_INDEXED : (unsigned)0))); CHECK(ret, FAIL, "H5Pset_attr_creation_order"); @@ -6417,9 +6417,9 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Check for deleting non-existent attribute */ H5E_BEGIN_TRY @@ -6432,7 +6432,7 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Create attributes, up to limit of compact form */ for (u = 0; u < max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -6455,9 +6455,9 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, max_compact, "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Check for out of bound deletions */ H5E_BEGIN_TRY @@ -6511,10 +6511,10 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) ret = (herr_t)H5Aget_name_by_idx(my_dataset, ".", idx_type, order, (hsize_t)0, tmpname, (size_t)NAME_BUF_SIZE, H5P_DEFAULT); if (order == H5_ITER_INC) - HDsnprintf(attrname, sizeof(attrname), "attr %02u", (u + 1)); + snprintf(attrname, sizeof(attrname), "attr %02u", (u + 1)); else - HDsnprintf(attrname, sizeof(attrname), "attr %02u", (max_compact - (u + 2))); - ret = HDstrcmp(attrname, tmpname); + snprintf(attrname, sizeof(attrname), "attr %02u", (max_compact - (u + 2))); + ret = strcmp(attrname, tmpname); VERIFY(ret, 0, "H5Aget_name_by_idx"); } /* end for */ @@ -6524,7 +6524,7 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Verify state of attribute storage (empty) */ is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); } /* end for */ /* Work on all the datasets */ @@ -6549,7 +6549,7 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Create more attributes, to push into dense form */ for (u = 0; u < (max_compact * 2); u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -6565,7 +6565,7 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Verify state of object */ if (u >= max_compact) { is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, (new_format ? TRUE : FALSE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (new_format ? true : false), "H5O__is_attr_dense_test"); } /* end if */ /* Verify information for new attribute */ @@ -6578,9 +6578,9 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (max_compact * 2), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, (new_format ? TRUE : FALSE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (new_format ? true : false), "H5O__is_attr_dense_test"); if (new_format) { /* Retrieve & verify # of records in the name & creation order indices */ @@ -6643,11 +6643,10 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) ret = (herr_t)H5Aget_name_by_idx(my_dataset, ".", idx_type, order, (hsize_t)0, tmpname, (size_t)NAME_BUF_SIZE, H5P_DEFAULT); if (order == H5_ITER_INC) - HDsnprintf(attrname, sizeof(attrname), "attr %02u", (u + 1)); + snprintf(attrname, sizeof(attrname), "attr %02u", (u + 1)); else - HDsnprintf(attrname, sizeof(attrname), "attr %02u", - ((max_compact * 2) - (u + 2))); - ret = HDstrcmp(attrname, tmpname); + snprintf(attrname, sizeof(attrname), "attr %02u", ((max_compact * 2) - (u + 2))); + ret = strcmp(attrname, tmpname); VERIFY(ret, 0, "H5Aget_name_by_idx"); } /* end for */ @@ -6657,7 +6656,7 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Verify state of attribute storage (empty) */ is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); /* Check for deletion on empty attribute storage again */ H5E_BEGIN_TRY @@ -6692,7 +6691,7 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Create attributes, to push into dense form */ for (u = 0; u < (max_compact * 2); u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -6708,7 +6707,7 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Verify state of object */ if (u >= max_compact) { is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, (new_format ? TRUE : FALSE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (new_format ? true : false), "H5O__is_attr_dense_test"); } /* end if */ /* Verify information for new attribute */ @@ -6761,11 +6760,11 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) ret = (herr_t)H5Aget_name_by_idx(my_dataset, ".", idx_type, order, (hsize_t)u, tmpname, (size_t)NAME_BUF_SIZE, H5P_DEFAULT); if (order == H5_ITER_INC) - HDsnprintf(attrname, sizeof(attrname), "attr %02u", ((u * 2) + 1)); + snprintf(attrname, sizeof(attrname), "attr %02u", ((u * 2) + 1)); else - HDsnprintf(attrname, sizeof(attrname), "attr %02u", - ((max_compact * 2) - ((u * 2) + 2))); - ret = HDstrcmp(attrname, tmpname); + snprintf(attrname, sizeof(attrname), "attr %02u", + ((max_compact * 2) - ((u * 2) + 2))); + ret = strcmp(attrname, tmpname); VERIFY(ret, 0, "H5Aget_name_by_idx"); } /* end for */ } /* end for */ @@ -6814,11 +6813,11 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) ret = (herr_t)H5Aget_name_by_idx(my_dataset, ".", idx_type, order, (hsize_t)0, tmpname, (size_t)NAME_BUF_SIZE, H5P_DEFAULT); if (order == H5_ITER_INC) - HDsnprintf(attrname, sizeof(attrname), "attr %02u", ((u * 2) + 3)); + snprintf(attrname, sizeof(attrname), "attr %02u", ((u * 2) + 3)); else - HDsnprintf(attrname, sizeof(attrname), "attr %02u", - ((max_compact * 2) - ((u * 2) + 4))); - ret = HDstrcmp(attrname, tmpname); + snprintf(attrname, sizeof(attrname), "attr %02u", + ((max_compact * 2) - ((u * 2) + 4))); + ret = strcmp(attrname, tmpname); VERIFY(ret, 0, "H5Aget_name_by_idx"); } /* end for */ @@ -6828,7 +6827,7 @@ test_attr_delete_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Verify state of attribute storage (empty) */ is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); /* Check for deletion on empty attribute storage again */ H5E_BEGIN_TRY @@ -6902,8 +6901,8 @@ attr_iterate2_cb(hid_t loc_id, const char *attr_name, const H5A_info_t *info, vo } /* end if */ /* Verify name of link */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", (unsigned)my_info.corder); - if (HDstrcmp(attr_name, attrname) != 0) + snprintf(attrname, sizeof(attrname), "attr %02u", (unsigned)my_info.corder); + if (strcmp(attr_name, attrname) != 0) return (H5_ITER_ERROR); /* Check if we've visited this link before */ @@ -6911,7 +6910,7 @@ attr_iterate2_cb(hid_t loc_id, const char *attr_name, const H5A_info_t *info, vo return (H5_ITER_ERROR); if (op_data->visited[op_data->curr]) return (H5_ITER_ERROR); - op_data->visited[op_data->curr] = TRUE; + op_data->visited[op_data->curr] = true; /* Advance to next value, in correct direction */ if (op_data->order != H5_ITER_DEC) @@ -6990,14 +6989,14 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx iter_info->stop = -1; iter_info->ncalled = 0; iter_info->curr = order != H5_ITER_DEC ? 0 : (max_attrs - 1); - memset(iter_info->visited, 0, sizeof(hbool_t) * iter_info->max_visit); + memset(iter_info->visited, 0, sizeof(bool) * iter_info->max_visit); ret = H5Aiterate2(obj_id, idx_type, order, &skip, attr_iterate2_cb, iter_info); CHECK(ret, FAIL, "H5Aiterate2"); /* Verify that we visited all the attributes */ VERIFY(skip, max_attrs, "H5Aiterate2"); for (v = 0; v < max_attrs; v++) - VERIFY(iter_info->visited[v], TRUE, "H5Aiterate2"); + VERIFY(iter_info->visited[v], true, "H5Aiterate2"); /* Iterate over attributes on object */ iter_info->nskipped = (unsigned)(skip = 0); @@ -7005,14 +7004,14 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx iter_info->stop = -1; iter_info->ncalled = 0; iter_info->curr = order != H5_ITER_DEC ? 0 : (max_attrs - 1); - memset(iter_info->visited, 0, sizeof(hbool_t) * iter_info->max_visit); + memset(iter_info->visited, 0, sizeof(bool) * iter_info->max_visit); ret = H5Aiterate_by_name(fid, dsetname, idx_type, order, &skip, attr_iterate2_cb, iter_info, H5P_DEFAULT); CHECK(ret, FAIL, "H5Aiterate_by_name"); /* Verify that we visited all the attributes */ VERIFY(skip, max_attrs, "H5Aiterate_by_name"); for (v = 0; v < max_attrs; v++) - VERIFY(iter_info->visited[v], TRUE, "H5Aiterate_by_name"); + VERIFY(iter_info->visited[v], true, "H5Aiterate_by_name"); /* Iterate over attributes on object */ iter_info->nskipped = (unsigned)(skip = 0); @@ -7020,14 +7019,14 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx iter_info->stop = -1; iter_info->ncalled = 0; iter_info->curr = order != H5_ITER_DEC ? 0 : (max_attrs - 1); - memset(iter_info->visited, 0, sizeof(hbool_t) * iter_info->max_visit); + memset(iter_info->visited, 0, sizeof(bool) * iter_info->max_visit); ret = H5Aiterate_by_name(obj_id, ".", idx_type, order, &skip, attr_iterate2_cb, iter_info, H5P_DEFAULT); CHECK(ret, FAIL, "H5Aiterate_by_name"); /* Verify that we visited all the attributes */ VERIFY(skip, max_attrs, "H5Aiterate_by_name"); for (v = 0; v < max_attrs; v++) - VERIFY(iter_info->visited[v], TRUE, "H5Aiterate_by_name"); + VERIFY(iter_info->visited[v], true, "H5Aiterate_by_name"); #ifndef H5_NO_DEPRECATED_SYMBOLS /* Iterate over attributes on object, with H5Aiterate1 */ @@ -7036,14 +7035,14 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx iter_info->stop = -1; iter_info->ncalled = 0; iter_info->curr = order != H5_ITER_DEC ? 0 : (max_attrs - 1); - memset(iter_info->visited, 0, sizeof(hbool_t) * iter_info->max_visit); + memset(iter_info->visited, 0, sizeof(bool) * iter_info->max_visit); ret = H5Aiterate1(obj_id, &oskip, attr_iterate1_cb, iter_info); CHECK(ret, FAIL, "H5Aiterate1"); /* Verify that we visited all the attributes */ VERIFY(skip, max_attrs, "H5Aiterate1"); for (v = 0; v < max_attrs; v++) - VERIFY(iter_info->visited[v], TRUE, "H5Aiterate1"); + VERIFY(iter_info->visited[v], true, "H5Aiterate1"); #endif /* H5_NO_DEPRECATED_SYMBOLS */ /* Skip over some attributes on object */ @@ -7052,7 +7051,7 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx iter_info->stop = -1; iter_info->ncalled = 0; iter_info->curr = order != H5_ITER_DEC ? skip : ((max_attrs - 1) - skip); - memset(iter_info->visited, 0, sizeof(hbool_t) * iter_info->max_visit); + memset(iter_info->visited, 0, sizeof(bool) * iter_info->max_visit); ret = H5Aiterate2(obj_id, idx_type, order, &skip, attr_iterate2_cb, iter_info); CHECK(ret, FAIL, "H5Aiterate2"); @@ -7060,18 +7059,18 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx VERIFY(skip, max_attrs, "H5Aiterate2"); if (order == H5_ITER_INC) { for (v = 0; v < (max_attrs / 2); v++) - VERIFY(iter_info->visited[v + (max_attrs / 2)], TRUE, "H5Aiterate2"); + VERIFY(iter_info->visited[v + (max_attrs / 2)], true, "H5Aiterate2"); } /* end if */ else if (order == H5_ITER_DEC) { for (v = 0; v < (max_attrs / 2); v++) - VERIFY(iter_info->visited[v], TRUE, "H5Aiterate2"); + VERIFY(iter_info->visited[v], true, "H5Aiterate2"); } /* end if */ else { unsigned nvisit = 0; /* # of links visited */ assert(order == H5_ITER_NATIVE); for (v = 0; v < max_attrs; v++) - if (iter_info->visited[v] == TRUE) + if (iter_info->visited[v] == true) nvisit++; VERIFY(nvisit, max_attrs, "H5Aiterate2"); @@ -7083,7 +7082,7 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx iter_info->stop = -1; iter_info->ncalled = 0; iter_info->curr = order != H5_ITER_DEC ? skip : ((max_attrs - 1) - skip); - memset(iter_info->visited, 0, sizeof(hbool_t) * iter_info->max_visit); + memset(iter_info->visited, 0, sizeof(bool) * iter_info->max_visit); ret = H5Aiterate_by_name(fid, dsetname, idx_type, order, &skip, attr_iterate2_cb, iter_info, H5P_DEFAULT); CHECK(ret, FAIL, "H5Aiterate_by_name"); @@ -7091,18 +7090,18 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx VERIFY(skip, max_attrs, "H5Aiterate_by_name"); if (order == H5_ITER_INC) { for (v = 0; v < (max_attrs / 2); v++) - VERIFY(iter_info->visited[v + (max_attrs / 2)], TRUE, "H5Aiterate_by_name"); + VERIFY(iter_info->visited[v + (max_attrs / 2)], true, "H5Aiterate_by_name"); } /* end if */ else if (order == H5_ITER_DEC) { for (v = 0; v < (max_attrs / 2); v++) - VERIFY(iter_info->visited[v], TRUE, "H5Aiterate_by_name"); + VERIFY(iter_info->visited[v], true, "H5Aiterate_by_name"); } /* end if */ else { unsigned nvisit = 0; /* # of links visited */ assert(order == H5_ITER_NATIVE); for (v = 0; v < max_attrs; v++) - if (iter_info->visited[v] == TRUE) + if (iter_info->visited[v] == true) nvisit++; VERIFY(nvisit, max_attrs, "H5Aiterate_by_name"); @@ -7114,7 +7113,7 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx iter_info->stop = -1; iter_info->ncalled = 0; iter_info->curr = order != H5_ITER_DEC ? skip : ((max_attrs - 1) - skip); - memset(iter_info->visited, 0, sizeof(hbool_t) * iter_info->max_visit); + memset(iter_info->visited, 0, sizeof(bool) * iter_info->max_visit); ret = H5Aiterate_by_name(obj_id, ".", idx_type, order, &skip, attr_iterate2_cb, iter_info, H5P_DEFAULT); CHECK(ret, FAIL, "H5Aiterate_by_name"); @@ -7122,18 +7121,18 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx VERIFY(skip, max_attrs, "H5Aiterate_by_name"); if (order == H5_ITER_INC) { for (v = 0; v < (max_attrs / 2); v++) - VERIFY(iter_info->visited[v + (max_attrs / 2)], TRUE, "H5Aiterate_by_name"); + VERIFY(iter_info->visited[v + (max_attrs / 2)], true, "H5Aiterate_by_name"); } /* end if */ else if (order == H5_ITER_DEC) { for (v = 0; v < (max_attrs / 2); v++) - VERIFY(iter_info->visited[v], TRUE, "H5Aiterate_by_name"); + VERIFY(iter_info->visited[v], true, "H5Aiterate_by_name"); } /* end if */ else { unsigned nvisit = 0; /* # of links visited */ assert(order == H5_ITER_NATIVE); for (v = 0; v < max_attrs; v++) - if (iter_info->visited[v] == TRUE) + if (iter_info->visited[v] == true) nvisit++; VERIFY(nvisit, max_attrs, "H5Aiterate_by_name"); @@ -7146,7 +7145,7 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx iter_info->stop = -1; iter_info->ncalled = 0; iter_info->curr = order != H5_ITER_DEC ? (unsigned)oskip : ((max_attrs - 1) - oskip); - memset(iter_info->visited, 0, sizeof(hbool_t) * iter_info->max_visit); + memset(iter_info->visited, 0, sizeof(bool) * iter_info->max_visit); ret = H5Aiterate1(obj_id, &oskip, attr_iterate1_cb, iter_info); CHECK(ret, FAIL, "H5Aiterate1"); @@ -7154,18 +7153,18 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx VERIFY(oskip, max_attrs, "H5Aiterate1"); if (order == H5_ITER_INC) { for (v = 0; v < (max_attrs / 2); v++) - VERIFY(iter_info->visited[v + (max_attrs / 2)], TRUE, "H5Aiterate1"); + VERIFY(iter_info->visited[v + (max_attrs / 2)], true, "H5Aiterate1"); } /* end if */ else if (order == H5_ITER_DEC) { for (v = 0; v < (max_attrs / 2); v++) - VERIFY(iter_info->visited[v], TRUE, "H5Aiterate1"); + VERIFY(iter_info->visited[v], true, "H5Aiterate1"); } /* end if */ else { unsigned nvisit = 0; /* # of links visited */ assert(order == H5_ITER_NATIVE); for (v = 0; v < max_attrs; v++) - if (iter_info->visited[v] == TRUE) + if (iter_info->visited[v] == true) nvisit++; VERIFY(nvisit, max_attrs, "H5Aiterate1"); @@ -7178,7 +7177,7 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx iter_info->stop = 3; iter_info->ncalled = 0; iter_info->curr = order != H5_ITER_DEC ? 0 : (max_attrs - 1); - memset(iter_info->visited, 0, sizeof(hbool_t) * iter_info->max_visit); + memset(iter_info->visited, 0, sizeof(bool) * iter_info->max_visit); ret = H5Aiterate2(obj_id, idx_type, order, &skip, attr_iterate2_cb, iter_info); CHECK(ret, FAIL, "H5Aiterate2"); VERIFY(ret, CORDER_ITER_STOP, "H5Aiterate2"); @@ -7190,7 +7189,7 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx iter_info->stop = 3; iter_info->ncalled = 0; iter_info->curr = order != H5_ITER_DEC ? 0 : (max_attrs - 1); - memset(iter_info->visited, 0, sizeof(hbool_t) * iter_info->max_visit); + memset(iter_info->visited, 0, sizeof(bool) * iter_info->max_visit); ret = H5Aiterate_by_name(fid, dsetname, idx_type, order, &skip, attr_iterate2_cb, iter_info, H5P_DEFAULT); CHECK(ret, FAIL, "H5Aiterate_by_name"); VERIFY(ret, CORDER_ITER_STOP, "H5Aiterate_by_name"); @@ -7202,7 +7201,7 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx iter_info->stop = 3; iter_info->ncalled = 0; iter_info->curr = order != H5_ITER_DEC ? 0 : (max_attrs - 1); - memset(iter_info->visited, 0, sizeof(hbool_t) * iter_info->max_visit); + memset(iter_info->visited, 0, sizeof(bool) * iter_info->max_visit); ret = H5Aiterate_by_name(obj_id, ".", idx_type, order, &skip, attr_iterate2_cb, iter_info, H5P_DEFAULT); CHECK(ret, FAIL, "H5Aiterate_by_name"); VERIFY(ret, CORDER_ITER_STOP, "H5Aiterate_by_name"); @@ -7215,7 +7214,7 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx iter_info->stop = 3; iter_info->ncalled = 0; iter_info->curr = order != H5_ITER_DEC ? 0 : (max_attrs - 1); - memset(iter_info->visited, 0, sizeof(hbool_t) * iter_info->max_visit); + memset(iter_info->visited, 0, sizeof(bool) * iter_info->max_visit); ret = H5Aiterate1(obj_id, &oskip, attr_iterate1_cb, iter_info); CHECK(ret, FAIL, "H5Aiterate1"); VERIFY(ret, CORDER_ITER_STOP, "H5Aiterate1"); @@ -7263,7 +7262,7 @@ attr_iterate_check(hid_t fid, const char *dsetname, hid_t obj_id, H5_index_t idx ** ****************************************************************/ static void -test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl) +test_attr_iterate2(bool new_format, hid_t fcpl, hid_t fapl) { hid_t fid; /* HDF5 File ID */ hid_t dset1, dset2, dset3; /* Dataset IDs */ @@ -7281,7 +7280,7 @@ test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl) H5_index_t idx_type; /* Type of index to operate on */ H5_iter_order_t order; /* Order within in the index */ attr_iter_info_t iter_info; /* Iterator info */ - hbool_t *visited = NULL; /* Array of flags for visiting links */ + bool *visited = NULL; /* Array of flags for visiting links */ hsize_t idx; /* Start index for iteration */ unsigned use_index; /* Use index on creation order values */ const char *dsetname; /* Name of dataset for attributes */ @@ -7310,7 +7309,7 @@ test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Allocate the "visited link" array */ iter_info.max_visit = max_compact * 2; - visited = (hbool_t *)malloc(sizeof(hbool_t) * iter_info.max_visit); + visited = (bool *)malloc(sizeof(bool) * iter_info.max_visit); CHECK_PTR(visited, "malloc"); iter_info.visited = visited; @@ -7319,7 +7318,7 @@ test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Loop over operating in different orders */ for (order = H5_ITER_INC; order <= H5_ITER_DEC; order++) { /* Loop over using index for creation order value */ - for (use_index = FALSE; use_index <= TRUE; use_index++) { + for (use_index = false; use_index <= true; use_index++) { /* Print appropriate test message */ if (idx_type == H5_INDEX_CRT_ORDER) { if (order == H5_ITER_INC) { @@ -7363,7 +7362,7 @@ test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(fid, FAIL, "H5Fcreate"); /* Set attribute creation order tracking & indexing for object */ - if (new_format == TRUE) { + if (new_format == true) { ret = H5Pset_attr_creation_order( dcpl, (H5P_CRT_ORDER_TRACKED | (use_index ? H5P_CRT_ORDER_INDEXED : (unsigned)0))); CHECK(ret, FAIL, "H5Pset_attr_creation_order"); @@ -7401,9 +7400,9 @@ test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Check for iterating over object with no attributes (should be OK) */ ret = H5Aiterate2(my_dataset, idx_type, order, NULL, attr_iterate2_cb, NULL); @@ -7420,7 +7419,7 @@ test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Create attributes, up to limit of compact form */ for (u = 0; u < max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -7443,9 +7442,9 @@ test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, max_compact, "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Check for out of bound iteration */ idx = u; @@ -7504,7 +7503,7 @@ test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Create more attributes, to push into dense form */ for (u = max_compact; u < (max_compact * 2); u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -7520,7 +7519,7 @@ test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Verify state of object */ if (u >= max_compact) { is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, (new_format ? TRUE : FALSE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (new_format ? true : false), "H5O__is_attr_dense_test"); } /* end if */ /* Verify information for new attribute */ @@ -7533,9 +7532,9 @@ test_attr_iterate2(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (max_compact * 2), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, (new_format ? TRUE : FALSE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (new_format ? true : false), "H5O__is_attr_dense_test"); if (new_format) { /* Retrieve & verify # of records in the name & creation order indices */ @@ -7667,7 +7666,7 @@ attr_open_by_idx_check(hid_t obj_id, H5_index_t idx_type, H5_iter_order_t order, ** ****************************************************************/ static void -test_attr_open_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) +test_attr_open_by_idx(bool new_format, hid_t fcpl, hid_t fapl) { hid_t fid; /* HDF5 File ID */ hid_t dset1, dset2, dset3; /* Dataset IDs */ @@ -7714,7 +7713,7 @@ test_attr_open_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Loop over operating in different orders */ for (order = H5_ITER_INC; order <= H5_ITER_DEC; order++) { /* Loop over using index for creation order value */ - for (use_index = FALSE; use_index <= TRUE; use_index++) { + for (use_index = false; use_index <= true; use_index++) { /* Print appropriate test message */ if (idx_type == H5_INDEX_CRT_ORDER) { if (order == H5_ITER_INC) { @@ -7758,7 +7757,7 @@ test_attr_open_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(fid, FAIL, "H5Fcreate"); /* Set attribute creation order tracking & indexing for object */ - if (new_format == TRUE) { + if (new_format == true) { ret = H5Pset_attr_creation_order( dcpl, (H5P_CRT_ORDER_TRACKED | (use_index ? H5P_CRT_ORDER_INDEXED : (unsigned)0))); CHECK(ret, FAIL, "H5Pset_attr_creation_order"); @@ -7793,9 +7792,9 @@ test_attr_open_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Check for opening an attribute on an object with no attributes */ H5E_BEGIN_TRY @@ -7809,7 +7808,7 @@ test_attr_open_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Create attributes, up to limit of compact form */ for (u = 0; u < max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -7832,9 +7831,9 @@ test_attr_open_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, max_compact, "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Check for out of bound opening an attribute on an object */ H5E_BEGIN_TRY @@ -7872,7 +7871,7 @@ test_attr_open_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Create more attributes, to push into dense form */ for (u = max_compact; u < (max_compact * 2); u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -7888,7 +7887,7 @@ test_attr_open_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Verify state of object */ if (u >= max_compact) { is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, (new_format ? TRUE : FALSE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (new_format ? true : false), "H5O__is_attr_dense_test"); } /* end if */ /* Verify information for new attribute */ @@ -7901,9 +7900,9 @@ test_attr_open_by_idx(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (max_compact * 2), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, (new_format ? TRUE : FALSE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (new_format ? true : false), "H5O__is_attr_dense_test"); if (new_format) { /* Retrieve & verify # of records in the name & creation order indices */ @@ -7978,7 +7977,7 @@ attr_open_check(hid_t fid, const char *dsetname, hid_t obj_id, unsigned max_attr /* Open each attribute on object by index and check that it's the correct one */ for (u = 0; u < max_attrs; u++) { /* Open the attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr_id = H5Aopen(obj_id, attrname, H5P_DEFAULT); CHECK(attr_id, FAIL, "H5Aopen"); @@ -8038,7 +8037,7 @@ attr_open_check(hid_t fid, const char *dsetname, hid_t obj_id, unsigned max_attr ** ****************************************************************/ static void -test_attr_open_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) +test_attr_open_by_name(bool new_format, hid_t fcpl, hid_t fapl) { hid_t fid; /* HDF5 File ID */ hid_t dset1, dset2, dset3; /* Dataset IDs */ @@ -8080,7 +8079,7 @@ test_attr_open_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5Pget_attr_phase_change"); /* Loop over using index for creation order value */ - for (use_index = FALSE; use_index <= TRUE; use_index++) { + for (use_index = false; use_index <= true; use_index++) { /* Print appropriate test message */ if (use_index) MESSAGE(5, ("Testing Opening Attributes By Name w/Creation Order Index\n")); @@ -8092,7 +8091,7 @@ test_attr_open_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(fid, FAIL, "H5Fcreate"); /* Set attribute creation order tracking & indexing for object */ - if (new_format == TRUE) { + if (new_format == true) { ret = H5Pset_attr_creation_order( dcpl, (H5P_CRT_ORDER_TRACKED | (use_index ? H5P_CRT_ORDER_INDEXED : (unsigned)0))); CHECK(ret, FAIL, "H5Pset_attr_creation_order"); @@ -8130,9 +8129,9 @@ test_attr_open_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Check for opening a non-existent attribute on an object with no attributes */ H5E_BEGIN_TRY @@ -8159,7 +8158,7 @@ test_attr_open_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Create attributes, up to limit of compact form */ for (u = 0; u < max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -8181,9 +8180,9 @@ test_attr_open_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, max_compact, "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Check for opening a non-existent attribute on an object with compact attribute storage */ H5E_BEGIN_TRY @@ -8237,7 +8236,7 @@ test_attr_open_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Create more attributes, to push into dense form */ for (u = max_compact; u < (max_compact * 2); u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate2(my_dataset, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate2"); @@ -8252,7 +8251,7 @@ test_attr_open_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Verify state of object */ if (u >= max_compact) { is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, (new_format ? TRUE : FALSE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (new_format ? true : false), "H5O__is_attr_dense_test"); } /* end if */ /* Verify information for new attribute */ @@ -8265,9 +8264,9 @@ test_attr_open_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (max_compact * 2), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, (new_format ? TRUE : FALSE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (new_format ? true : false), "H5O__is_attr_dense_test"); if (new_format) { /* Retrieve & verify # of records in the name & creation order indices */ @@ -8334,7 +8333,7 @@ test_attr_open_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) ** ****************************************************************/ static void -test_attr_create_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) +test_attr_create_by_name(bool new_format, hid_t fcpl, hid_t fapl) { hid_t fid; /* HDF5 File ID */ hid_t dset1, dset2, dset3; /* Dataset IDs */ @@ -8375,7 +8374,7 @@ test_attr_create_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5Pget_attr_phase_change"); /* Loop over using index for creation order value */ - for (use_index = FALSE; use_index <= TRUE; use_index++) { + for (use_index = false; use_index <= true; use_index++) { /* Print appropriate test message */ if (use_index) MESSAGE(5, ("Testing Creating Attributes By Name w/Creation Order Index\n")); @@ -8387,7 +8386,7 @@ test_attr_create_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(fid, FAIL, "H5Fcreate"); /* Set attribute creation order tracking & indexing for object */ - if (new_format == TRUE) { + if (new_format == true) { ret = H5Pset_attr_creation_order( dcpl, (H5P_CRT_ORDER_TRACKED | (use_index ? H5P_CRT_ORDER_INDEXED : (unsigned)0))); CHECK(ret, FAIL, "H5Pset_attr_creation_order"); @@ -8425,14 +8424,14 @@ test_attr_create_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, TRUE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, true, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Create attributes, up to limit of compact form */ for (u = 0; u < max_compact; u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate_by_name(fid, dsetname, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate_by_name"); @@ -8455,9 +8454,9 @@ test_attr_create_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, max_compact, "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Test opening attributes stored compactly */ ret = attr_open_check(fid, dsetname, my_dataset, u); @@ -8489,7 +8488,7 @@ test_attr_create_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Create more attributes, to push into dense form */ for (u = max_compact; u < (max_compact * 2); u++) { /* Create attribute */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); attr = H5Acreate_by_name(fid, dsetname, attrname, H5T_NATIVE_UINT, sid, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT); CHECK(attr, FAIL, "H5Acreate_by_name"); @@ -8505,7 +8504,7 @@ test_attr_create_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) /* Verify state of object */ if (u >= max_compact) { is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, (new_format ? TRUE : FALSE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (new_format ? true : false), "H5O__is_attr_dense_test"); } /* end if */ /* Verify information for new attribute */ @@ -8518,9 +8517,9 @@ test_attr_create_by_name(hbool_t new_format, hid_t fcpl, hid_t fapl) CHECK(ret, FAIL, "H5O__num_attrs_test"); VERIFY(nattrs, (max_compact * 2), "H5O__num_attrs_test"); is_empty = H5O__is_attr_empty_test(my_dataset); - VERIFY(is_empty, FALSE, "H5O__is_attr_empty_test"); + VERIFY(is_empty, false, "H5O__is_attr_empty_test"); is_dense = H5O__is_attr_dense_test(my_dataset); - VERIFY(is_dense, (new_format ? TRUE : FALSE), "H5O__is_attr_dense_test"); + VERIFY(is_dense, (new_format ? true : false), "H5O__is_attr_dense_test"); if (new_format) { /* Retrieve & verify # of records in the name & creation order indices */ @@ -8707,14 +8706,14 @@ test_attr_shared_write(hid_t fcpl, hid_t fapl) /* Check on datasets' attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); is_dense = H5O__is_attr_dense_test(dataset2); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add attributes to each dataset, until after converting to dense storage */ for (u = 0; u < max_compact * 2; u++) { /* Create attribute name */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); /* Alternate between creating "small" & "big" attributes */ if (u % 2) { @@ -8724,7 +8723,7 @@ test_attr_shared_write(hid_t fcpl, hid_t fapl) /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); /* Write data into the attribute */ attr_value = u + 1; @@ -8738,7 +8737,7 @@ test_attr_shared_write(hid_t fcpl, hid_t fapl) /* Check that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -8763,9 +8762,9 @@ test_attr_shared_write(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); if (u < max_compact) - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); else - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Alternate between creating "small" & "big" attributes */ if (u % 2) { @@ -8775,7 +8774,7 @@ test_attr_shared_write(hid_t fcpl, hid_t fapl) /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); /* Write data into the attribute */ attr_value = u + 1; @@ -8789,7 +8788,7 @@ test_attr_shared_write(hid_t fcpl, hid_t fapl) /* Check that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -8814,9 +8813,9 @@ test_attr_shared_write(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset2); if (u < max_compact) - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); else - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); } /* end for */ /* Close attribute's datatype */ @@ -9044,14 +9043,14 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl) /* Check on datasets' attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); is_dense = H5O__is_attr_dense_test(dataset2); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add attributes to each dataset, until after converting to dense storage */ for (u = 0; u < max_compact * 2; u++) { /* Create attribute name */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); /* Alternate between creating "small" & "big" attributes */ if (u % 2) { @@ -9061,7 +9060,7 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl) /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); /* Write data into the attribute */ attr_value = u + 1; @@ -9075,7 +9074,7 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl) /* Check that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -9100,9 +9099,9 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); if (u < max_compact) - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); else - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Alternate between creating "small" & "big" attributes */ if (u % 2) { @@ -9112,7 +9111,7 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl) /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); /* Write data into the attribute */ attr_value = u + 1; @@ -9126,7 +9125,7 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl) /* Check that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -9151,12 +9150,12 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset2); if (u < max_compact) - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); else - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Create new attribute name */ - HDsnprintf(attrname2, sizeof(attrname2), "new attr %02u", u); + snprintf(attrname2, sizeof(attrname2), "new attr %02u", u); /* Change second dataset's attribute's name */ ret = H5Arename_by_name(fid, DSET2_NAME, attrname, attrname2, H5P_DEFAULT); @@ -9171,12 +9170,12 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl) if (u % 2) { /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); } /* end if */ else { /* Check that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -9195,12 +9194,12 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl) if (u % 2) { /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); } /* end if */ else { /* Check that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -9225,12 +9224,12 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl) if (u % 2) { /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); } /* end if */ else { /* Check that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -9249,12 +9248,12 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl) if (u % 2) { /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); } /* end if */ else { /* Check that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -9491,14 +9490,14 @@ test_attr_shared_delete(hid_t fcpl, hid_t fapl) /* Check on datasets' attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); is_dense = H5O__is_attr_dense_test(dataset2); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add attributes to each dataset, until after converting to dense storage */ for (u = 0; u < max_compact * 2; u++) { /* Create attribute name */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); /* Alternate between creating "small" & "big" attributes */ if (u % 2) { @@ -9508,7 +9507,7 @@ test_attr_shared_delete(hid_t fcpl, hid_t fapl) /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); /* Write data into the attribute */ attr_value = u + 1; @@ -9522,7 +9521,7 @@ test_attr_shared_delete(hid_t fcpl, hid_t fapl) /* Check that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -9547,9 +9546,9 @@ test_attr_shared_delete(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); if (u < max_compact) - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); else - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Alternate between creating "small" & "big" attributes */ if (u % 2) { @@ -9559,7 +9558,7 @@ test_attr_shared_delete(hid_t fcpl, hid_t fapl) /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); /* Write data into the attribute */ attr_value = u + 1; @@ -9573,7 +9572,7 @@ test_attr_shared_delete(hid_t fcpl, hid_t fapl) /* Check that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -9598,15 +9597,15 @@ test_attr_shared_delete(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset2); if (u < max_compact) - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); else - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); } /* end for */ /* Delete attributes from second dataset */ for (u = 0; u < max_compact * 2; u++) { /* Create attribute name */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); /* Delete second dataset's attribute */ ret = H5Adelete_by_name(fid, DSET2_NAME, attrname, H5P_DEFAULT); @@ -9621,12 +9620,12 @@ test_attr_shared_delete(hid_t fcpl, hid_t fapl) if (u % 2) { /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); } /* end if */ else { /* Check that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -9863,14 +9862,14 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl) /* Check on datasets' attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); is_dense = H5O__is_attr_dense_test(dataset2); - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); /* Add attributes to each dataset, until after converting to dense storage */ for (u = 0; u < max_compact * 2; u++) { /* Create attribute name */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); /* Alternate between creating "small" & "big" attributes */ if (u % 2) { @@ -9880,7 +9879,7 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl) /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); /* Write data into the attribute */ attr_value = u + 1; @@ -9894,7 +9893,7 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl) /* ChecFk that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -9919,9 +9918,9 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); if (u < max_compact) - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); else - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Alternate between creating "small" & "big" attributes */ if (u % 2) { @@ -9931,7 +9930,7 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl) /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); /* Write data into the attribute */ attr_value = u + 1; @@ -9945,7 +9944,7 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl) /* Check that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -9970,9 +9969,9 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl) /* Check on dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset2); if (u < max_compact) - VERIFY(is_dense, FALSE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, false, "H5O__is_attr_dense_test"); else - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); } /* end for */ /* Close attribute's datatype */ @@ -9989,12 +9988,12 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl) /* Check on first dataset's attribute storage status */ is_dense = H5O__is_attr_dense_test(dataset); - VERIFY(is_dense, TRUE, "H5O__is_attr_dense_test"); + VERIFY(is_dense, true, "H5O__is_attr_dense_test"); /* Check ref count on attributes of first dataset */ for (u = 0; u < max_compact * 2; u++) { /* Create attribute name */ - HDsnprintf(attrname, sizeof(attrname), "attr %02u", u); + snprintf(attrname, sizeof(attrname), "attr %02u", u); /* Open attribute on first dataset */ attr = H5Aopen(dataset, attrname, H5P_DEFAULT); @@ -10003,12 +10002,12 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl) if (u % 2) { /* Check that attribute is not shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, FALSE, "H5A__is_shared_test"); + VERIFY(is_shared, false, "H5A__is_shared_test"); } /* end if */ else { /* Check that attribute is shared */ is_shared = H5A__is_shared_test(attr); - VERIFY(is_shared, TRUE, "H5A__is_shared_test"); + VERIFY(is_shared, true, "H5A__is_shared_test"); /* Check refcount for attribute */ ret = H5A__get_shared_rc_test(attr, &shared_refcount); @@ -10267,7 +10266,7 @@ test_attr_bug2(hid_t fcpl, hid_t fapl) /* Create attributes on group */ for (i = 0; i < BUG2_NATTR; i++) { - HDsnprintf(aname, sizeof(aname), "%03u", i); + snprintf(aname, sizeof(aname), "%03u", i); aid = H5Acreate2(gid, aname, H5T_STD_I32LE, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(aid, FAIL, "H5Acreate2"); @@ -10277,7 +10276,7 @@ test_attr_bug2(hid_t fcpl, hid_t fapl) /* Delete every other attribute */ for (i = 1; i < BUG2_NATTR; i += 2) { - HDsnprintf(aname, sizeof(aname), "%03u", i); + snprintf(aname, sizeof(aname), "%03u", i); ret = H5Adelete(gid, aname); CHECK(ret, FAIL, "H5Adelete"); } @@ -10301,7 +10300,7 @@ test_attr_bug2(hid_t fcpl, hid_t fapl) /* Open an attribute in the middle */ i = (BUG2_NATTR / 4) * 2; - HDsnprintf(aname, sizeof(aname), "%03u", i); + snprintf(aname, sizeof(aname), "%03u", i); aid = H5Aopen(gid, aname, H5P_DEFAULT); CHECK(aid, FAIL, "H5Aopen"); @@ -10310,7 +10309,7 @@ test_attr_bug2(hid_t fcpl, hid_t fapl) CHECK(tid, FAIL, "H5Aget_type"); tri_ret = H5Tequal(tid, H5T_STD_I32LE); - VERIFY(tri_ret, TRUE, "H5Tequal"); + VERIFY(tri_ret, true, "H5Tequal"); /* Close IDs */ ret = H5Tclose(tid); @@ -10344,7 +10343,7 @@ test_attr_bug2(hid_t fcpl, hid_t fapl) /* Create attributes on group */ for (i = 0; i < BUG2_NATTR2; i++) { - HDsnprintf(aname, sizeof(aname), "%03u", i); + snprintf(aname, sizeof(aname), "%03u", i); aid = H5Acreate2(gid, aname, H5T_STD_I32LE, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(aid, FAIL, "H5Acreate2"); @@ -10354,7 +10353,7 @@ test_attr_bug2(hid_t fcpl, hid_t fapl) /* Delete every other attribute */ for (i = 0; i < BUG2_NATTR2; i++) { - HDsnprintf(aname, sizeof(aname), "%03u", i); + snprintf(aname, sizeof(aname), "%03u", i); ret = H5Adelete(gid, aname); CHECK(ret, FAIL, "H5Adelete"); } @@ -11168,17 +11167,17 @@ test_attr_bug8(hid_t fcpl, hid_t fapl) static void test_attr_bug9(hid_t fcpl, hid_t fapl) { - hid_t fid = -1; /* File ID */ - hid_t gid = -1; /* Group ID */ - hid_t aid = -1; /* Attribute ID */ - hid_t sid = -1; /* Dataspace ID */ - hsize_t dims[1] = {32768}; /* Attribute dimensions */ - int create_link; /* Whether to create a soft link */ - unsigned max_compact; /* Setting from fcpl */ - unsigned min_dense; /* Setting from fcpl */ - char aname[11]; /* Attribute name */ - unsigned i; /* Local index variable */ - herr_t ret; /* Generic return status */ + hid_t fid = H5I_INVALID_HID; /* File ID */ + hid_t gid = H5I_INVALID_HID; /* Group ID */ + hid_t aid = H5I_INVALID_HID; /* Attribute ID */ + hid_t sid = H5I_INVALID_HID; /* Dataspace ID */ + hsize_t dims[1] = {32768}; /* Attribute dimensions */ + int create_link; /* Whether to create a soft link */ + unsigned max_compact; /* Setting from fcpl */ + unsigned min_dense; /* Setting from fcpl */ + char aname[11]; /* Attribute name */ + unsigned i; /* Local index variable */ + herr_t ret; /* Generic return status */ /* Output message about test being performed */ MESSAGE(5, ("Testing that attributes can always be added to named datatypes\n")); @@ -11212,7 +11211,7 @@ test_attr_bug9(hid_t fcpl, hid_t fapl) /* Create enough attributes to cause a change to dense storage */ for (i = 0; i < max_compact + 1; i++) { /* Create attribute */ - HDsnprintf(aname, sizeof(aname), "%u", i); + snprintf(aname, sizeof(aname), "%u", i); aid = H5Acreate2(gid, aname, H5T_NATIVE_CHAR, sid, H5P_DEFAULT, H5P_DEFAULT); CHECK(aid, FAIL, "H5Acreate2"); @@ -11414,13 +11413,13 @@ test_attr_delete_last_dense(hid_t fcpl, hid_t fapl) void test_attr(void) { - hid_t fapl = (-1), fapl2 = (-1); /* File access property lists */ - hid_t fcpl = (-1), fcpl2 = (-1); /* File creation property lists */ - hid_t dcpl = -1; /* Dataset creation property list */ - unsigned new_format; /* Whether to use the new format or not */ - unsigned use_shared; /* Whether to use shared attributes or not */ - unsigned minimize_dset_oh; /* Whether to use minimized dataset object headers */ - herr_t ret; /* Generic return value */ + hid_t fapl = (H5I_INVALID_HID), fapl2 = (H5I_INVALID_HID); /* File access property lists */ + hid_t fcpl = (H5I_INVALID_HID), fcpl2 = (H5I_INVALID_HID); /* File creation property lists */ + hid_t dcpl = H5I_INVALID_HID; /* Dataset creation property list */ + unsigned new_format; /* Whether to use the new format or not */ + unsigned use_shared; /* Whether to use shared attributes or not */ + unsigned minimize_dset_oh; /* Whether to use minimized dataset object headers */ + herr_t ret; /* Generic return value */ MESSAGE(5, ("Testing Attributes\n")); @@ -11454,12 +11453,12 @@ test_attr(void) MESSAGE(7, ("testing with minimzied dataset object headers\n")); dcpl = H5Pcreate(H5P_DATASET_CREATE); CHECK(dcpl, FAIL, "H5Pcreate"); - ret = H5Pset_dset_no_attrs_hint(dcpl, TRUE); + ret = H5Pset_dset_no_attrs_hint(dcpl, true); CHECK_I(ret, "H5Pset_dset_no_attrs_hint"); dcpl_g = dcpl; } - for (new_format = FALSE; new_format <= TRUE; new_format++) { + for (new_format = false; new_format <= true; new_format++) { hid_t my_fapl; /* Set the FAPL for the type of format */ @@ -11500,10 +11499,10 @@ test_attr(void) /* This next test uses its own file information */ test_attr_duplicate_ids(my_fapl); - for (use_shared = FALSE; use_shared <= TRUE; use_shared++) { + for (use_shared = false; use_shared <= true; use_shared++) { hid_t my_fcpl; - if (new_format == TRUE && use_shared) { + if (new_format == true && use_shared) { MESSAGE(7, ("testing with shared attributes\n")); my_fcpl = fcpl2; } @@ -11553,7 +11552,7 @@ test_attr(void) through a different file handle */ /* tests specific to the "new format" */ - if (new_format == TRUE) { + if (new_format == true) { /* General attribute tests */ test_attr_dense_create(my_fcpl, my_fapl); /* Test dense attribute storage creation */ test_attr_dense_open(my_fcpl, my_fapl); /* Test opening attributes in dense storage */ @@ -11584,7 +11583,7 @@ test_attr(void) w/attribute creation order info */ /* More complex tests with exclusively both "new format" and "shared" attributes */ - if (use_shared == TRUE) { + if (use_shared == true) { test_attr_shared_write( my_fcpl, my_fapl); /* Test writing to shared attributes in compact & dense storage */ |