diff options
Diffstat (limited to 'c++/test')
| -rw-r--r-- | c++/test/titerate.cpp | 77 | ||||
| -rw-r--r-- | c++/test/ttypes.cpp | 528 |
2 files changed, 533 insertions, 72 deletions
diff --git a/c++/test/titerate.cpp b/c++/test/titerate.cpp index f75d92e..5c760f3 100644 --- a/c++/test/titerate.cpp +++ b/c++/test/titerate.cpp @@ -12,8 +12,8 @@ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /***************************************************************************** - FILE - titerate.cpp - HDF5 C++ testing iterate related functionality + FILE + titerate.cpp - HDF5 C++ testing iterate related functionality ***************************************************************************/ #ifdef OLD_HEADER_FILENAME @@ -94,8 +94,7 @@ int iter_strcmp(const void *s1, const void *s2) ** ****************************************************************/ static herr_t -liter_cb(hid_t H5_ATTR_UNUSED group, const char *name, const H5L_info_t H5_ATTR_UNUSED *link_info, - void *op_data) +liter_cb(hid_t H5_ATTR_UNUSED group, const char *name, const H5L_info_t H5_ATTR_UNUSED *link_info, void *op_data) { iter_info *info = (iter_info *)op_data; static int count = 0; @@ -208,7 +207,7 @@ static void test_iter_group(FileAccPropList& fapl) H5std_string obj_name; for (i = 0; i < nobjs; i++) { - //H5O_info_t oinfo; /* Object info */ + //H5O_info_t oinfo; /* Object info */ obj_name = root_group.getObjnameByIdx(i); //ret = (herr_t)H5Lget_name_by_idx(root_group, ".", H5_INDEX_NAME, H5_ITER_INC, (hsize_t)i, dataset_name, (size_t)NAMELEN, H5P_DEFAULT); @@ -380,23 +379,11 @@ void printelems(const Group& group, const H5std_string& dsname, const H5std_stri a1.close(); } - // catch failure caused by the DataSpace operations - catch( DataSpaceIException error ) - { - error.printError(); - } - - // catch failure caused by the Group operations - catch( GroupIException error ) - { - error.printError(); - } - - // catch failure caused by the DataSet operations - catch( DataSetIException error ) - { - error.printError(); - } + // Catch all exceptions and rethrow so caller can handle + catch (Exception& E) + { + throw; + } } /*------------------------------------------------------------------------- @@ -413,11 +400,11 @@ void printelems(const Group& group, const H5std_string& dsname, const H5std_stri */ static void test_HDFFV_9920() { - int attr_data[2] = { 100, 200}; - hsize_t dims[1] = { DIM1 }; - - try - { + int attr_data[2] = { 100, 200}; + hsize_t dims[1] = { DIM1 }; + + try + { // Create a new file and a group in it H5File file( FILE_NAME, H5F_ACC_TRUNC ); @@ -448,31 +435,13 @@ static void test_HDFFV_9920() printelems(file, FDATASET_NAME, FATTR_NAME); printelems(gr1, GDATASET_NAME, GATTR_NAME); - } // end of try block - - // catch failure caused by the H5File operations - catch( DataSpaceIException error ) - { - error.printError(); - } - - // catch failure caused by the H5File operations - catch( AttributeIException error ) - { - error.printError(); - } - - // catch failure caused by the H5File operations - catch( FileIException error ) - { - error.printError(); - } - - // catch failure caused by the DataSet operations - catch( DataSetIException error ) - { - error.printError(); - } + } // end of try block + + // Catch all failures for handling in the same way + catch (Exception& E) + { + issue_fail_msg("test_HDFFV_9920()", __LINE__, __FILE__, E.getCDetailMsg()); + } } @@ -503,9 +472,9 @@ void test_iterate() test_iter_group(fapl); // Test iterating groups test_HDFFV_9920(); // Test the fix of HDFFV-9920 - //test_iter_attr(fapl); // Test iterating attributes + //test_iter_attr(fapl); // Test iterating attributes -} // test_iterate +} // test_iterate /*------------------------------------------------------------------------- * Function: cleanup_iterate diff --git a/c++/test/ttypes.cpp b/c++/test/ttypes.cpp index f76f780..3cf0920 100644 --- a/c++/test/ttypes.cpp +++ b/c++/test/ttypes.cpp @@ -60,6 +60,7 @@ const char *FILENAME[] = { "dtypes1.h5", "dtypes2.h5", "dtypes3.h5", + "dtypes4.h5", NULL }; @@ -80,6 +81,12 @@ typedef enum int_t { INT_LONG, INT_ULONG, INT_LLONG, INT_ULLONG, INT_OTHER } int_t; +typedef struct { + int a; + float b; + long c; + double d; +} src_typ_t; /*------------------------------------------------------------------------- * Function: test_classes @@ -125,9 +132,7 @@ static void test_classes() * * Purpose Test datatype copy functionality * - * Return Success: 0 - * - * Failure: number of errors + * Return None * * Programmer Binh-Minh Ribler (using C version) * January, 2007 @@ -179,13 +184,284 @@ static void test_copy() /*------------------------------------------------------------------------- + * Function: test_detect_type_class + * + * Purpose Test DataType::detectClass() + * + * Return None + * + * Programmer Binh-Minh Ribler (using C version) + * August, 2017 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +typedef struct { /* Struct with atomic fields */ + int i; + float f; + char c; + double d; + short s; +} atomic_typ_t; + +typedef struct { /* Struct with complex fields */ + hobj_ref_t arr_r[3][3]; + int i; + hvl_t vl_f; + hvl_t vl_s; + char c; + short s; +} complex_typ_t; + +static void test_detect_type_class() +{ + + SUBTEST("DataType::detectClass()"); + try { + bool in_class = false; // indicates whether a datatype is in a class + + /* + * Test class of some atomic types. + */ + + // Native integers should be in the integer class + in_class = DataType::detectClass(PredType::NATIVE_INT, H5T_INTEGER); + verify_val(in_class, true, "DataType::detectClass() with H5T_INTEGER", __LINE__, __FILE__); + + // Native integers should _not_ be in other classes + in_class = DataType::detectClass(PredType::NATIVE_INT, H5T_FLOAT); + verify_val(in_class, false, "DataType::detectClass() with H5T_FLOAT", __LINE__, __FILE__); + in_class = DataType::detectClass(PredType::NATIVE_INT, H5T_ARRAY); + verify_val(in_class, false, "DataType::detectClass() with H5T_ARRAY", __LINE__, __FILE__); + in_class = DataType::detectClass(PredType::NATIVE_INT, H5T_ENUM); + verify_val(in_class, false, "DataType::detectClass() with H5T_ENUM", __LINE__, __FILE__); + + /* + * Test class of a compound type with some atomic types as fields. + */ + + // Create a compound datatype and insert some atomic types + CompType atom_cmpd(sizeof(atomic_typ_t)); + atom_cmpd.insertMember("i", HOFFSET(atomic_typ_t, i), PredType::NATIVE_INT); + atom_cmpd.insertMember("f", HOFFSET(atomic_typ_t, f), PredType::NATIVE_FLOAT); + atom_cmpd.insertMember("c", HOFFSET(atomic_typ_t, c), PredType::NATIVE_CHAR); + atom_cmpd.insertMember("d", HOFFSET(atomic_typ_t, d), PredType::NATIVE_DOUBLE); + atom_cmpd.insertMember("s", HOFFSET(atomic_typ_t, s), PredType::NATIVE_SHORT); + + // Make certain that atom_cmpd is a compound type, + in_class = atom_cmpd.detectClass(H5T_COMPOUND); + verify_val(in_class, true, "CompType::detectClass() with H5T_COMPOUND", __LINE__, __FILE__); + // and that it contains a field of type integer + in_class = atom_cmpd.detectClass(H5T_INTEGER); + verify_val(in_class, true, "CompType::detectClass() with H5T_INTEGER", __LINE__, __FILE__); + // and a field of type float, + in_class = atom_cmpd.detectClass(H5T_FLOAT); + verify_val(in_class, true, "CompType::detectClass() with H5T_FLOAT", __LINE__, __FILE__); + // and that it doesn't contain any field of variable-length + in_class = atom_cmpd.detectClass(H5T_VLEN); + verify_val(in_class, false, "CompType::detectClass() with H5T_VLEN", __LINE__, __FILE__); + + /* + * Test class of array datatype + */ + + // Create an array datatype with an atomic base type + unsigned rank = 2; // Rank for array datatype + hsize_t dims[2] = {3,3}; // Dimensions for array datatype + ArrayType atom_arr(PredType::STD_REF_OBJ, rank, dims); + + // Make certain that the correct classes can be detected + in_class = atom_arr.detectClass(H5T_ARRAY); + verify_val(in_class, true, "CompType::detectClass() with H5T_ARRAY", __LINE__, __FILE__); + in_class = atom_arr.detectClass(H5T_REFERENCE); + verify_val(in_class, true, "CompType::detectClass() with H5T_REFERENCE", __LINE__, __FILE__); + + // Make certain that an incorrect class is not detected + in_class = atom_arr.detectClass(H5T_VLEN); + verify_val(in_class, false, "CompType::detectClass() with H5T_VLEN", __LINE__, __FILE__); + in_class = atom_arr.detectClass(H5T_FLOAT); + verify_val(in_class, false, "CompType::detectClass() with H5T_FLOAT", __LINE__, __FILE__); + in_class = atom_arr.detectClass(H5T_INTEGER); + verify_val(in_class, false, "CompType::detectClass() with H5T_INTEGER", __LINE__, __FILE__); + + /* + * Test class of VL datatype + */ + + // Create a VL datatype with an atomic base type of float + VarLenType atom_vlf(PredType::NATIVE_FLOAT); + + // Make certain that the correct classes can be detected + in_class = atom_vlf.detectClass(H5T_VLEN); + verify_val(in_class, true, "CompType::detectClass() with H5T_VLEN", __LINE__, __FILE__); + in_class = atom_vlf.detectClass(H5T_FLOAT); + verify_val(in_class, true, "CompType::detectClass() with H5T_FLOAT", __LINE__, __FILE__); + + // Make certain that an incorrect class is not detected + in_class = atom_vlf.detectClass(H5T_COMPOUND); + verify_val(in_class, false, "CompType::detectClass() with H5T_COMPOUND", __LINE__, __FILE__); + in_class = atom_vlf.detectClass(H5T_INTEGER); + verify_val(in_class, false, "CompType::detectClass() with H5T_INTEGER", __LINE__, __FILE__); + + /* + * Test class of VL datatype + */ + + // Create a VL datatype with an atomic base type of char. It should be a VL + // but not a string class. + VarLenType atom_vlc(PredType::NATIVE_CHAR); + + // Make certain that the correct classes can be detected + in_class = atom_vlc.detectClass(H5T_VLEN); + verify_val(in_class, true, "CompType::detectClass() with H5T_VLEN", __LINE__, __FILE__); + in_class = atom_vlc.detectClass(H5T_INTEGER); + verify_val(in_class, true, "CompType::detectClass() with H5T_INTEGER", __LINE__, __FILE__); + + // Make certain that an incorrect class is not detected + in_class = atom_vlc.detectClass(H5T_STRING); + verify_val(in_class, false, "CompType::detectClass() with H5T_STRING", __LINE__, __FILE__); + + /* + * Test class of VL string datatype + */ + + // Create a VL string. It should be a string, not a VL class. + StrType atom_vls(0, H5T_VARIABLE); + + // Make certain that the correct classes can be detected + in_class = atom_vls.detectClass(H5T_STRING); + verify_val(in_class, true, "CompType::detectClass() with H5T_STRING", __LINE__, __FILE__); + + // Make certain that an incorrect class is not detected + in_class = atom_vls.detectClass(H5T_VLEN); + verify_val(in_class, false, "CompType::detectClass() with H5T_VLEN", __LINE__, __FILE__); + + /* + * Test class of a compound type with some complex types as fields. + */ + + // Create a compound datatype with complex type fields + CompType cplx_cmpd(sizeof(complex_typ_t)); + cplx_cmpd.insertMember("arr_r", HOFFSET(complex_typ_t, arr_r), atom_arr); + cplx_cmpd.insertMember("i", HOFFSET(complex_typ_t, i), PredType::NATIVE_INT); + cplx_cmpd.insertMember("vl_f", HOFFSET(complex_typ_t, vl_f), atom_vlf); + cplx_cmpd.insertMember("vl_s", HOFFSET(complex_typ_t, vl_s), atom_vls); + cplx_cmpd.insertMember("c", HOFFSET(complex_typ_t, c), PredType::NATIVE_CHAR); + cplx_cmpd.insertMember("s", HOFFSET(complex_typ_t, s), PredType::NATIVE_SHORT); + + // Make certain that the correct classes can be detected + in_class = cplx_cmpd.detectClass(H5T_COMPOUND); + verify_val(in_class, true, "CompType::detectClass() with H5T_COMPOUND", __LINE__, __FILE__); + in_class = cplx_cmpd.detectClass(H5T_ARRAY); + verify_val(in_class, true, "CompType::detectClass() with H5T_ARRAY", __LINE__, __FILE__); + in_class = cplx_cmpd.detectClass(H5T_REFERENCE); + verify_val(in_class, true, "CompType::detectClass() with H5T_REFERENCE", __LINE__, __FILE__); + in_class = cplx_cmpd.detectClass(H5T_INTEGER); + verify_val(in_class, true, "CompType::detectClass() with H5T_INTEGER", __LINE__, __FILE__); + in_class = cplx_cmpd.detectClass(H5T_FLOAT); + verify_val(in_class, true, "CompType::detectClass() with H5T_FLOAT", __LINE__, __FILE__); + in_class = cplx_cmpd.detectClass(H5T_STRING); + verify_val(in_class, true, "CompType::detectClass() with H5T_STRING", __LINE__, __FILE__); + in_class = cplx_cmpd.detectClass(H5T_VLEN); + verify_val(in_class, true, "CompType::detectClass() with H5T_VLEN", __LINE__, __FILE__); + + // Make certain that an incorrect class is not detected + in_class = cplx_cmpd.detectClass(H5T_TIME); + verify_val(in_class, false, "CompType::detectClass() with H5T_TIME", __LINE__, __FILE__); + in_class = cplx_cmpd.detectClass(H5T_ENUM); + verify_val(in_class, false, "CompType::detectClass() with H5T_ENUM", __LINE__, __FILE__); + + PASSED(); + } + catch (Exception& E) + { + issue_fail_msg("test_detect_type_class", __LINE__, __FILE__, E.getCDetailMsg()); + } +} + + +/*------------------------------------------------------------------------- + * Function: test_vltype + * + * Purpose Tests VarLenType class + * + * Return None + * + * Programmer Binh-Minh Ribler (use C version) + * August, 2017 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static void test_vltype() +{ + // Output message about test being performed + SUBTEST("VarLenType functions"); + try + { + VarLenType vltype(PredType::NATIVE_INT); + + bool in_class = vltype.detectClass(H5T_VLEN); + verify_val(in_class, true, "VarLenType::detectClass() with H5T_VLEN", __LINE__, __FILE__); + in_class = vltype.detectClass(H5T_INTEGER); + verify_val(in_class, true, "VarLenType::detectClass() with H5T_INTEGER", __LINE__, __FILE__); + + // Test copy constructor + VarLenType vltype2(vltype); + + // Verify that the copied type has a valid id + bool is_valid = IdComponent::isValid(vltype2.getId()); + verify_val(in_class, true, "isValid on vltype2", __LINE__, __FILE__); + + in_class = vltype2.detectClass(H5T_VLEN); + verify_val(in_class, true, "VarLenType::detectClass() with H5T_VLEN for vltype2", __LINE__, __FILE__); + in_class = vltype2.detectClass(H5T_INTEGER); + verify_val(in_class, true, "VarLenType::detectClass() with H5T_INTEGER for vltype2", __LINE__, __FILE__); + in_class = vltype2.detectClass(H5T_FLOAT); + verify_val(in_class, false, "VarLenType::detectClass() with H5T_FLOAT for vltype2", __LINE__, __FILE__); + + // Create a new file to use in this test + H5File file(FILENAME[3], H5F_ACC_TRUNC); + + // Create a group in the file, to hold some varlentype + Group top_group(file.createGroup("top group")); + + // Create a variable-length type + VarLenType first_vlt(PredType::NATIVE_FLOAT); + + // Commit the type to the group + first_vlt.commit(top_group, "first variable-length type"); + + // Close it + first_vlt.close(); + + // Reopen it + VarLenType first_vlt_again(top_group, "first variable-length type"); + + // Trying to detect H5T_VLEN and H5T_FLOAT classes on this type, + // should both be true + in_class = vltype2.detectClass(H5T_VLEN); + verify_val(in_class, true, "VarLenType::detectClass() with H5T_VLEN for vltype2", __LINE__, __FILE__); + in_class = first_vlt_again.detectClass(H5T_FLOAT); + verify_val(in_class, true, "VarLenType::detectClass() with H5T_FLOAT for first_vlt_again", __LINE__, __FILE__); + + PASSED(); + } // end of try block + catch (Exception& E) + { + issue_fail_msg("test_vltype", __LINE__, __FILE__, E.getCDetailMsg()); + } +} // test_vltype + + +/*------------------------------------------------------------------------- * Function: test_query * * Purpose Tests query functions of compound and enumeration types. * - * Return Success: 0 - * - * Failure: number of errors + * Return None * * Programmer Binh-Minh Ribler (use C version) * January, 2007 @@ -200,12 +476,6 @@ const H5std_string EnumT_NAME("Enum_type"); static void test_query() { - typedef struct { - int a; - float b; - long c; - double d; - } src_typ_t; short enum_val; // Output message about test being performed @@ -317,9 +587,7 @@ static void test_query() * * Purpose Tests transient datatypes. * - * Return Success: 0 - * - * Failure: number of errors + * Return None * * Programmer Binh-Minh Ribler (use C version) * January, 2007 @@ -396,9 +664,7 @@ static void test_transient () * * Purpose Tests named datatypes. * - * Return Success: 0 - * - * Failure: number of errors + * Return None * * Programmer Binh-Minh Ribler (use C version) * January, 2007 @@ -556,6 +822,229 @@ static void test_named () } // test_named +/*------------------------------------------------------------------------- + * Function: test_encode_decode + * + * Purpose Test datatype encode/decode functionality. + * + * Return None + * + * Programmer Binh-Minh Ribler (using C version) + * August, 2017 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +const H5std_string filename3("encode_decode.h5"); +const int ARRAY1_RANK = 1; +const int ARRAY1_DIM = 10; +static void test_encode_decode() +{ + short enum_val; + + SUBTEST("DataType::encode() and DataType::decode()"); + try { + // Create the file. + H5File file(filename3, H5F_ACC_TRUNC); + + // + // Test with CompType + // + + // Create a compound datatype + CompType cmptyp(sizeof(src_typ_t)); + + cmptyp.insertMember("a", HOFFSET(src_typ_t, a), PredType::NATIVE_INT); + cmptyp.insertMember("b", HOFFSET(src_typ_t, b), PredType::NATIVE_FLOAT); + cmptyp.insertMember("c", HOFFSET(src_typ_t, c), PredType::NATIVE_LONG); + cmptyp.insertMember("d", HOFFSET(src_typ_t, d), PredType::NATIVE_DOUBLE); + + // Encode compound type in its buffer + cmptyp.encode(); + + // Verify that encoding had been done + verify_val(cmptyp.hasBinaryDesc(), true, "DataType::encode", __LINE__, __FILE__); + + // Decode compound type's buffer to a new CompType + CompType* decoded_cmp_ptr(static_cast<CompType *>(cmptyp.decode())); + + // Verify that the datatype was copied exactly via encoding/decoding + verify_val(cmptyp == *decoded_cmp_ptr, true, "DataType::decode", __LINE__, __FILE__); + + // Verify again via querying member number and member index by name. + verify_val(decoded_cmp_ptr->getNmembers(), 4, "DataType::decode", __LINE__, __FILE__); + verify_val(decoded_cmp_ptr->getMemberIndex("c"), 2, "DataType::decode", __LINE__, __FILE__); + + // Create a CompType instance from the pointer and verify it + CompType cmptyp_clone(*decoded_cmp_ptr); + verify_val(cmptyp == cmptyp_clone, true, "DataType::decode", __LINE__, __FILE__); + verify_val(cmptyp_clone.getNmembers(), 4, "DataType::decode", __LINE__, __FILE__); + verify_val(cmptyp_clone.getMemberIndex("c"), 2, "DataType::decode", __LINE__, __FILE__); + + delete decoded_cmp_ptr; + + // + // Test with EnumType + // + + // Create a enumerate datatype + EnumType enumtyp(sizeof(short)); + + enumtyp.insert("RED", (enum_val=0,&enum_val)); + enumtyp.insert("GREEN", (enum_val=1,&enum_val)); + enumtyp.insert("BLUE", (enum_val=2,&enum_val)); + enumtyp.insert("ORANGE", (enum_val=3,&enum_val)); + enumtyp.insert("YELLOW", (enum_val=4,&enum_val)); + + // Encode compound type in a buffer + enumtyp.encode(); + + // Verify that encoding had been done + verify_val(enumtyp.hasBinaryDesc(), true, "DataType::encode", __LINE__, __FILE__); + + // Decode enumeration type's buffer to a new EnumType + EnumType* decoded_enum_ptr(static_cast<EnumType *>(enumtyp.decode())); + + // Verify that the datatype was copied exactly via encoding/decoding + verify_val(enumtyp == *decoded_enum_ptr, true, "DataType::decode", __LINE__, __FILE__); + + // Verify again via querying member number and member index by name. + verify_val(decoded_enum_ptr->getNmembers(), 5, "DataType::decode", __LINE__, __FILE__); + verify_val(decoded_enum_ptr->getMemberIndex("GREEN"), 1, "DataType::decode", __LINE__, __FILE__); + + // Create a EnumType instance from the pointer and verify it + EnumType enumtyp_clone(*decoded_enum_ptr); + verify_val(enumtyp == enumtyp_clone, true, "DataType::decode", __LINE__, __FILE__); + verify_val(enumtyp_clone.getNmembers(), 5, "DataType::decode", __LINE__, __FILE__); + verify_val(enumtyp_clone.getMemberIndex("GREEN"), 1, "DataType::decode", __LINE__, __FILE__); + + delete decoded_enum_ptr; + + // + // Test with variable-length string + // + + // Create a variable-length string type + StrType vlsttyp(PredType::C_S1); + vlsttyp.setSize(H5T_VARIABLE); + + // Encode the variable-length type in its buffer + vlsttyp.encode(); + + // Verify that encoding had been done + verify_val(vlsttyp.hasBinaryDesc(), true, "DataType::encode", __LINE__, __FILE__); + + // Decode the variable-length type's buffer to a new StrType + StrType* decoded_str_ptr(static_cast<StrType *>(vlsttyp.decode())); + + verify_val(vlsttyp == *decoded_str_ptr, true, "DataType::decode", __LINE__, __FILE__); + verify_val(decoded_str_ptr->isVariableStr(), true, "DataType::decode", __LINE__, __FILE__); + + delete decoded_str_ptr; + + // Test decoding the type by way of DataType* + + // Decode variable-length string type to a new DataType + DataType* decoded_vlstr_ptr(vlsttyp.decode()); + + // Create a StrType instance from the DataType object and verify it + StrType decoded_vlsttyp(decoded_vlstr_ptr->getId()); + verify_val(vlsttyp == decoded_vlsttyp, true, "DataType::decode", __LINE__, __FILE__); + verify_val(decoded_vlsttyp.isVariableStr(), true, "DataType::decode", __LINE__, __FILE__); + + delete decoded_vlstr_ptr; + + // + // Test with ArrayType + // + + hsize_t tdims1[] = {ARRAY1_DIM}; + + // Create an array datatype of the compound datatype + ArrayType arrtyp(cmptyp, ARRAY1_RANK, tdims1); + + // Encode the array type in its buffer + arrtyp.encode(); + + // Verify that encoding had been done + verify_val(arrtyp.hasBinaryDesc(), true, "DataType::encode", __LINE__, __FILE__); + + // Create an ArrayType instance from the decoded pointer and verify it + ArrayType* decoded_arr_ptr(static_cast<ArrayType *>(arrtyp.decode())); + + verify_val(arrtyp == *decoded_arr_ptr, true, "DataType::decode", __LINE__, __FILE__); + + delete decoded_arr_ptr; + + // Test decoding the type by way of DataType* + + // Decode the array type's buffer + DataType *decoded_dt_ptr = arrtyp.decode(); + + // Create a ArrayType instance from the decoded pointer and verify it + ArrayType decoded_arrtyp(decoded_dt_ptr->getId()); + verify_val(arrtyp == decoded_arrtyp, true, "DataType::decode", __LINE__, __FILE__); + verify_val(decoded_arrtyp.getArrayNDims(), ARRAY1_RANK, "DataType::decode", __LINE__, __FILE__); + + delete decoded_dt_ptr; + + // + // Test with IntType + // + + // Create an int datatype + IntType inttyp(PredType::NATIVE_UINT); + + // Encode the array type in its buffer + inttyp.encode(); + + // Verify that encoding had been done + verify_val(inttyp.hasBinaryDesc(), true, "DataType::encode", __LINE__, __FILE__); + + // Create an IntType instance from the decoded pointer and verify it + IntType* decoded_int_ptr(static_cast<IntType *>(inttyp.decode())); + H5T_sign_t int_sign = decoded_int_ptr->getSign(); + verify_val(int_sign, H5T_SGN_NONE, "DataType::decode", __LINE__, __FILE__); + verify_val(inttyp == *decoded_int_ptr, true, "DataType::decode", __LINE__, __FILE__); + + delete decoded_int_ptr; + + // + // Test decoding FloatType by way of DataType* + // + + // Create a float datatype + FloatType flttyp(PredType::NATIVE_FLOAT); + + // Encode the float type in its buffer + flttyp.encode(); + + // Verify that encoding had been done + verify_val(flttyp.hasBinaryDesc(), true, "DataType::encode", __LINE__, __FILE__); + + // Decode the array type's buffer + DataType* decoded_flt_ptr(flttyp.decode()); + + // Create a IntType instance from the decoded pointer and verify it + FloatType decoded_flttyp(decoded_flt_ptr->getId()); + verify_val(flttyp == decoded_flttyp, true, "DataType::decode", __LINE__, __FILE__); + + H5std_string norm_string; + H5T_norm_t mant_norm = decoded_flttyp.getNorm(norm_string); + //verify_val(decoded_flttyp.isVariableStr(), true, "DataType::decode", __LINE__, __FILE__); + + delete decoded_flt_ptr; + + PASSED(); + } + catch (Exception& E) + { + issue_fail_msg("test_encode_decode", __LINE__, __FILE__, E.getCDetailMsg()); + } +} + + /**************************************************************** ** ** test_types(): Main datatypes testing routine. @@ -570,9 +1059,12 @@ void test_types() // Test basic datatypes test_classes(); test_copy(); + test_detect_type_class(); + test_vltype(); test_query(); test_transient(); test_named(); + test_encode_decode(); } // test_types() |