[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.

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<nelmts; i++) {
+	nchars = HDrand() % 8;
+	for (j=0; j<nchars; j++)
+	    buf[i*8+j] = 'a' + HDrand()%26;
+	while (j<nchars)
+            buf[i*8+j++] = '\0';
+    }
+
+    if ((size=H5Tget_precision(type))==0) goto error;
+    if ((size=H5Tget_size(type))==0) goto error;
+    if (H5Tset_pad(type, H5T_PAD_ZERO, H5T_PAD_ONE)<0) goto error;
+    if ((cset=H5Tget_cset(type))<0) goto error;
+    if (H5Tget_strpad(type)<0) goto error;
+    if (H5Tset_offset(type, 0)<0) goto error;
+    if (H5Tget_order(type)<0) goto error;
+    
+    H5E_BEGIN_TRY {
+        ret=H5Tset_precision(type, nelmts);
+    } 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 {
+        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 */