From 1acc676fcf1e2451d1935f95731b5644a60a0e0d Mon Sep 17 00:00:00 2001 From: Raymond Lu Date: Tue, 2 May 2006 14:42:41 -0500 Subject: [svn-r12322] Purpose: Test some functions Description: Test some data type functions that are and aren't supposed to work with some data types. Platforms tested: h5committest and fuss. --- test/dtypes.c | 502 +++++++++++++++++++++++++++++++++++++++++++++++++++++++- test/enum.c | 115 ++++++++++++- test/tarray.c | 60 +++++++ test/tvltypes.c | 61 +++++++ 4 files changed, 733 insertions(+), 5 deletions(-) diff --git a/test/dtypes.c b/test/dtypes.c index 5e63a95..acfda55 100644 --- a/test/dtypes.c +++ b/test/dtypes.c @@ -478,8 +478,17 @@ error: static int test_compound_1(void) { - complex_t tmp; - hid_t complex_id; + complex_t tmp; + hid_t complex_id; + hid_t super; + size_t size; + H5T_pad_t lsb, msb; + H5T_cset_t cset; + H5T_str_t strpad; + H5T_order_t order; + H5T_sign_t sign; + char* tag; + int offset; herr_t ret; TESTING("compound data types"); @@ -503,6 +512,116 @@ test_compound_1(void) if (H5Tinsert(complex_id, "imaginary", HOFFSET(complex_t, im), H5T_NATIVE_DOUBLE)<0) goto error; + /* Test some functions that aren't supposed to work for compound type */ + H5E_BEGIN_TRY { + size=H5Tget_precision(complex_id); + } H5E_END_TRY; + if (size>0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + size = 128; + H5E_BEGIN_TRY { + ret = H5Tset_precision(complex_id, size); + } H5E_END_TRY; + if (ret>=0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + ret = H5Tget_pad(complex_id, &lsb, &msb); + } H5E_END_TRY; + if (ret>=0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + size = H5Tget_ebias(complex_id); + } H5E_END_TRY; + if (size>0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + lsb = H5Tget_inpad(complex_id); + } H5E_END_TRY; + if (lsb>=0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + cset = H5Tget_cset(complex_id); + } H5E_END_TRY; + if (cset>-1) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + strpad = H5Tget_strpad(complex_id); + } H5E_END_TRY; + if (strpad>-1) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + offset = H5Tget_offset(complex_id); + } H5E_END_TRY; + if (offset>=0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + order = H5Tget_order(complex_id); + } H5E_END_TRY; + if (order>-1) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + sign = H5Tget_sign(complex_id); + } H5E_END_TRY; + if (sign>-1) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + tag = H5Tget_tag(complex_id); + } H5E_END_TRY; + if (tag) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + super = H5Tget_super(complex_id); + } H5E_END_TRY; + if (super>=0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + if (H5Tclose (complex_id)<0) goto error; PASSED(); return 0; @@ -2986,6 +3105,125 @@ test_conv_str_2(void) /*------------------------------------------------------------------------- + * Function: test_conv_str_3 + * + * Purpose: Tests some functions that are or aren't supposed to work + * for string type. + * + * Return: Success: 0 + * + * Failure: number of errors + * + * Programmer: Raymond Lu + * Tuesday, April 4, 2006 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static int +test_conv_str_3(void) +{ + char *buf=NULL; + hid_t type, super; + const size_t nelmts = NTESTELEM; + size_t i, j, nchars; + int ret_value = 1; + int size; + H5T_pad_t inpad; + H5T_cset_t cset; + H5T_sign_t sign; + char* tag; + herr_t ret; + + TESTING("some type functions for string"); + + /* + * Initialize types and buffer. + */ + type = mkstr(8, H5T_STR_NULLPAD); + buf = (char*)HDcalloc(nelmts, 8); + for (i=0; i=0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + size=H5Tget_ebias(type); + } H5E_END_TRY; + if (size>0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + inpad=H5Tget_inpad(type); + } H5E_END_TRY; + if (inpad>-1) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + sign=H5Tget_sign(type); + } H5E_END_TRY; + if (sign>-1) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + tag = H5Tget_tag(type); + } H5E_END_TRY; + if (tag) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + super = H5Tget_super(type); + } H5E_END_TRY; + if (super>=0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + PASSED(); + ret_value = 0; + + error: + if (buf) HDfree(buf); + reset_hdf5(); + return ret_value; +} + + +/*------------------------------------------------------------------------- * Function: test_conv_enum_1 * * Purpose: Test conversion speed for enum data types @@ -3239,6 +3477,136 @@ test_conv_bitfield(void) /*------------------------------------------------------------------------- + * Function: test_bitfield_funcs + * + * Purpose: Test some data type functions that are and aren't supposed + * work for bitfield type. + * + * Return: Success: 0 + * + * Failure: number of errors + * + * Programmer: Raymond Lu + * Wednesday, April 5, 2006 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static int +test_bitfield_funcs(void) +{ + hid_t type=-1, super=-1; + int size; + char* tag; + H5T_pad_t inpad; + H5T_cset_t cset; + H5T_str_t strpad; + herr_t ret; + + TESTING("some type functions for bitfield"); + + /* + * First create a bitfield type. + */ + if((type = H5Tcopy(H5T_STD_B32LE))<0) goto error; + + /* + * Offset a 12-byte value in the middle of a 16 and 32 byte + * field. Pad unused bits with ones. + * ____ ____ __10 1010 1010 10__ ____ ____ + */ + if(H5Tset_precision(type, 12)<0) goto error; + if(H5Tset_offset(type, 10)<0) goto error; + if(H5Tset_pad(type, H5T_PAD_ONE, H5T_PAD_ONE)) goto error; + if((size=H5Tget_size(type))==0) goto error; + if(H5Tset_order(type, H5T_ORDER_BE)<0) goto error; + + H5E_BEGIN_TRY { + size=H5Tget_ebias(type); + } H5E_END_TRY; + if (size>0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + inpad=H5Tget_inpad(type); + } H5E_END_TRY; + if (inpad>-1) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + cset=H5Tget_cset(type); + } H5E_END_TRY; + if (cset>-1) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + strpad=H5Tget_strpad(type); + } H5E_END_TRY; + if (strpad>-1) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + ret=H5Tset_sign(type, H5T_SGN_2); + } H5E_END_TRY; + if(ret>=0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + tag = H5Tget_tag(type); + } H5E_END_TRY; + if (tag) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + super = H5Tget_super(type); + } H5E_END_TRY; + if (super>=0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + super = H5Tget_native_type(type, H5T_DIR_ASCEND); + } H5E_END_TRY; + if (super>=0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5Tclose(type); + PASSED(); + reset_hdf5(); + return 0; + + error: + H5Tclose(type); + reset_hdf5(); + return 1; +} + + +/*------------------------------------------------------------------------- * Function: convert_opaque * * Purpose: A fake opaque conversion functions @@ -3294,6 +3662,8 @@ test_opaque(void) num_errors += opaque_check(1); /* Test named opaque types with very long tag */ num_errors += opaque_long(); + /* Test some type functions with opaque type */ + num_errors += opaque_funcs(); if(num_errors) goto error; @@ -3302,7 +3672,6 @@ test_opaque(void) return 0; error: - H5_FAILED(); return num_errors; } @@ -3439,6 +3808,130 @@ opaque_long(void) /*------------------------------------------------------------------------- + * Function: opaque_funcs + * + * Purpose: Test some type functions that are and aren't supposed to + * work with opaque type. + * + * Return: Success: 0 + * + * Failure: number of errors + * + * Programmer: Raymond Lu + * Wednesday, April 5, 2006 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static int +opaque_funcs(void) +{ + hid_t type = -1, super=-1; + int size; + H5T_pad_t inpad; + H5T_cset_t cset; + H5T_str_t strpad; + H5T_sign_t sign; + herr_t ret; + + /* Build opaque type */ + if ((type=H5Tcreate(H5T_OPAQUE, 4))<0) TEST_ERROR + if (H5Tset_tag(type, "opaque source type")<0) TEST_ERROR + + if ((size=H5Tget_size(type))==0) goto error; + + H5E_BEGIN_TRY { + ret=H5Tset_precision(type, 32); + } H5E_END_TRY; + if (ret>=0) { + printf("Operation not allowed for this type.\n"); + TEST_ERROR + } /* end if */ + + H5E_BEGIN_TRY { + ret=H5Tset_pad(type, H5T_PAD_ZERO, H5T_PAD_ONE); + } H5E_END_TRY; + if (ret>=0) { + printf("Operation not allowed for this type.\n"); + TEST_ERROR + } /* end if */ + + H5E_BEGIN_TRY { + size=H5Tget_ebias(type); + } H5E_END_TRY; + if (size>0) { + printf("Operation not allowed for this type.\n"); + TEST_ERROR + } /* end if */ + + H5E_BEGIN_TRY { + inpad=H5Tget_inpad(type); + } H5E_END_TRY; + if (inpad>-1) { + printf("Operation not allowed for this type.\n"); + TEST_ERROR + } /* end if */ + + H5E_BEGIN_TRY { + cset=H5Tget_cset(type); + } H5E_END_TRY; + if (cset>-1) { + printf("Operation not allowed for this type.\n"); + TEST_ERROR + } /* end if */ + + H5E_BEGIN_TRY { + strpad=H5Tget_strpad(type); + } H5E_END_TRY; + if (strpad>-1) { + printf("Operation not allowed for this type.\n"); + TEST_ERROR + } /* end if */ + + H5E_BEGIN_TRY { + ret=H5Tset_offset(type, 16); + } H5E_END_TRY; + if (ret>=0) { + printf("Operation not allowed for this type.\n"); + TEST_ERROR + } /* end if */ + + H5E_BEGIN_TRY { + ret=H5Tset_order(type, H5T_ORDER_BE); + } H5E_END_TRY; + if (ret>=0) { + printf("Operation not allowed for this type.\n"); + TEST_ERROR + } /* end if */ + + H5E_BEGIN_TRY { + sign = H5Tget_sign(type); + } H5E_END_TRY; + if (sign>-1) { + printf("Operation not allowed for this type.\n"); + TEST_ERROR + } /* end if */ + + H5E_BEGIN_TRY { + super = H5Tget_super(type); + } H5E_END_TRY; + if (super>=0) { + printf("Operation not allowed for this type.\n"); + TEST_ERROR + } /* end if */ + + /* Close datatype */ + if(H5Tclose(type) < 0) TEST_ERROR + return 0; + + error: + if (type>0) H5Tclose(type); + return 1; +} + + +/*------------------------------------------------------------------------- * Function: test_encode * * Purpose: Tests functions of encoding and decoding data type. @@ -4053,6 +4546,7 @@ main(void) nerrors += test_conv_str_1(); nerrors += test_conv_str_2(); + nerrors += test_conv_str_3(); nerrors += test_compound_2(); nerrors += test_compound_3(); nerrors += test_compound_4(); @@ -4067,6 +4561,7 @@ main(void) nerrors += test_conv_enum_1(); nerrors += test_conv_enum_2(); nerrors += test_conv_bitfield(); + nerrors += test_bitfield_funcs(); nerrors += test_opaque(); if (nerrors) { @@ -4077,4 +4572,3 @@ main(void) printf("All data type tests passed.\n"); return 0; } - diff --git a/test/enum.c b/test/enum.c index 13769b5..4e97a25 100644 --- a/test/enum.c +++ b/test/enum.c @@ -426,6 +426,118 @@ test_value_dsnt_exist(void) /*------------------------------------------------------------------------- + * Function: test_funcs + * + * Purpose: Create an enumeration data type and test some functions + * that are or aren't supposed to work with it. + * + * Return: Success: 0 + * + * Failure: number of errors + * + * Programmer: Raymond Lu + * Tuesday, April 4, 2006 + * + * Modifications: + * + *------------------------------------------------------------------------- + */ +static int +test_funcs(void) +{ + hid_t type=-1, cwg=-1; + c_e1 val; + signed char val8; + int size; + H5T_pad_t inpad; + H5T_cset_t cset; + herr_t ret; + + TESTING("some functions with enumeration types"); + + /* A native integer */ + if ((type = H5Tcreate(H5T_ENUM, sizeof(c_e1)))<0) goto error; + if (H5Tenum_insert(type, "RED", CPTR(val, E1_RED ))<0) goto error; + if (H5Tenum_insert(type, "GREEN", CPTR(val, E1_GREEN))<0) goto error; + if (H5Tenum_insert(type, "BLUE", CPTR(val, E1_BLUE ))<0) goto error; + if (H5Tenum_insert(type, "WHITE", CPTR(val, E1_WHITE))<0) goto error; + if (H5Tenum_insert(type, "BLACK", CPTR(val, E1_BLACK))<0) goto error; + + if ((size=H5Tget_precision(type))==0) goto error; + if ((size=H5Tget_size(type))==0) goto error; + if ((size=H5Tget_offset(type))<0) goto error; + if (H5Tget_sign(type)<0) goto error; + if (H5Tget_super(type)<0) goto error; + + H5E_BEGIN_TRY { + ret=H5Tset_pad(type, H5T_PAD_ZERO, H5T_PAD_ONE); + } H5E_END_TRY; + if (ret>=0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + size=H5Tget_ebias(type); + } H5E_END_TRY; + if (size>0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + inpad=H5Tget_inpad(type); + } H5E_END_TRY; + if (inpad>-1) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + cset=H5Tget_cset(type); + } H5E_END_TRY; + if (cset>-1) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + size = 16; + H5E_BEGIN_TRY { + ret=H5Tset_offset(type, (size_t)size); + } H5E_END_TRY; + if (ret>=0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + H5E_BEGIN_TRY { + ret=H5Tset_order(type, H5T_ORDER_BE); + } H5E_END_TRY; + if (ret>=0) { + H5_FAILED(); + printf("Operation not allowed for this type.\n"); + goto error; + } /* end if */ + + if (H5Tclose(type)<0) goto error; + + PASSED(); + return 0; + + error: + H5E_BEGIN_TRY { + H5Tclose(type); + } H5E_END_TRY; + return 1; +} + + +/*------------------------------------------------------------------------- * Function: main * * Purpose: @@ -461,8 +573,9 @@ main(void) nerrors += test_tr1(file); nerrors += test_tr2(file); nerrors += test_value_dsnt_exist(); + nerrors += test_funcs(); - H5Fclose(file); + H5Fclose(file); if (nerrors) goto error; puts("All enum tests passed."); diff --git a/test/tarray.c b/test/tarray.c index 7c025f6..50fe1a9 100644 --- a/test/tarray.c +++ b/test/tarray.c @@ -177,6 +177,65 @@ test_array_atomic_1d(void) /**************************************************************** ** +** test_array_funcs(): Test some type functions that are and +** aren't supposed to work with array type. +** +****************************************************************/ +static void +test_array_funcs(void) +{ + hid_t type; /* Datatype ID */ + hsize_t tdims1[] = {ARRAY1_DIM1}; + int size; + H5T_pad_t inpad; + H5T_norm_t norm; + H5T_sign_t sign; + H5T_cset_t cset; + H5T_str_t strpad; + herr_t ret; /* Generic return value */ + + /* Create a datatype to refer to */ + type = H5Tarray_create (H5T_IEEE_F32BE,ARRAY1_RANK,tdims1,NULL); + CHECK(type, FAIL, "H5Tarray_create"); + + size=H5Tget_precision(type); + CHECK(size, FAIL, "H5Tget_precision"); + + size=H5Tget_size(type); + CHECK(size, FAIL, "H5Tget_size"); + + size=H5Tget_ebias(type); + CHECK(size, FAIL, "H5Tget_ebias"); + + ret=H5Tset_pad(type, H5T_PAD_ZERO, H5T_PAD_ONE); + CHECK(ret, FAIL, "H5Tset_pad"); + + inpad=H5Tget_inpad(type); + CHECK(inpad, FAIL, "H5Tget_inpad"); + + norm=H5Tget_norm(type); + CHECK(norm, FAIL, "H5Tget_norm"); + + ret=H5Tset_offset(type, 16); + CHECK(ret, FAIL, "H5Tset_offset"); + + H5E_BEGIN_TRY { + cset=H5Tget_cset(type); + } H5E_END_TRY; + VERIFY(cset, FAIL, "H5Tget_cset"); + + H5E_BEGIN_TRY { + strpad=H5Tget_strpad(type); + } H5E_END_TRY; + VERIFY(strpad, FAIL, "H5Tget_strpad"); + + /* Close datatype */ + ret = H5Tclose(type); + CHECK(ret, FAIL, "H5Tclose"); +} /* end test_array_funcs */ + +/**************************************************************** +** ** test_array_atomic_3d(): Test basic array datatype code. ** Tests 3-D array of atomic datatypes ** @@ -2068,6 +2127,7 @@ test_array(void) test_array_compound_array(); /* Test 1-D array of compound datatypes (with array fields) */ test_array_vlen_atomic(); /* Test 1-D array of atomic VL datatypes */ test_array_vlen_array(); /* Test 1-D array of 1-D array VL datatypes */ + test_array_funcs(); /* Test type functions with array types */ test_array_bkg(); /* Read compound datatype with array fields and background fields read */ diff --git a/test/tvltypes.c b/test/tvltypes.c index df72c52..a12de08 100644 --- a/test/tvltypes.c +++ b/test/tvltypes.c @@ -164,6 +164,66 @@ test_vltypes_dataset_create(void) /**************************************************************** ** +** test_vltypes_funcs(): Test some type functions that are and +** aren't supposed to work with VL type. +** +****************************************************************/ +static void +test_vltypes_funcs(void) +{ + hid_t type; /* Datatype ID */ + int size; + H5T_pad_t inpad; + H5T_norm_t norm; + H5T_cset_t cset; + H5T_str_t strpad; + herr_t ret; /* Generic return value */ + + /* Output message about test being performed */ + MESSAGE(5, ("Testing some type functions for VL\n")); + + /* Create a datatype to refer to */ + type = H5Tvlen_create (H5T_IEEE_F32BE); + CHECK(type, FAIL, "H5Tvlen_create"); + + size=H5Tget_precision(type); + CHECK(size, FAIL, "H5Tget_precision"); + + size=H5Tget_size(type); + CHECK(size, FAIL, "H5Tget_size"); + + size=H5Tget_ebias(type); + CHECK(size, FAIL, "H5Tget_ebias"); + + ret=H5Tset_pad(type, H5T_PAD_ZERO, H5T_PAD_ONE); + CHECK(ret, FAIL, "H5Tset_pad"); + + inpad=H5Tget_inpad(type); + CHECK(inpad, FAIL, "H5Tget_inpad"); + + norm=H5Tget_norm(type); + CHECK(norm, FAIL, "H5Tget_norm"); + + ret=H5Tset_offset(type, 16); + CHECK(ret, FAIL, "H5Tset_offset"); + + H5E_BEGIN_TRY { + cset=H5Tget_cset(type); + } H5E_END_TRY; + VERIFY(cset, FAIL, "H5Tget_cset"); + + H5E_BEGIN_TRY { + strpad=H5Tget_strpad(type); + } H5E_END_TRY; + VERIFY(strpad, FAIL, "H5Tget_strpad"); + + /* Close datatype */ + ret = H5Tclose(type); + CHECK(ret, FAIL, "H5Tclose"); +} + +/**************************************************************** +** ** test_vltypes_vlen_atomic(): Test basic VL datatype code. ** Tests VL datatypes of atomic datatypes ** @@ -2042,6 +2102,7 @@ test_vltypes(void) /* These next tests use the same file */ test_vltypes_dataset_create(); /* Check dataset of VL when fill value * won't be rewritten to it.*/ + test_vltypes_funcs(); /* Test functions with VL types */ test_vltypes_vlen_atomic(); /* Test VL atomic datatypes */ rewrite_vltypes_vlen_atomic(); /* Check VL memory leak */ test_vltypes_vlen_compound(); /* Test VL compound datatypes */ -- cgit v0.12