Description:

    Further warning cleanups: from 667 warnings to 503.

12 files changed, 345 insertions, 93 deletions

diff --git a/test/cmpd_dset.c b/test/cmpd_dset.c
index 311b9bb..a7f3902 100644
--- a/test/cmpd_dset.c
+++ b/test/cmpd_dset.c
@@ -154,30 +154,28 @@ static unsigned
 test_compound (char *filename, hid_t fapl)
 {
     /* First dataset */
-    static s1_t		s1[NX*NY];
+    s1_t		*s1 = NULL;
     hid_t		s1_tid;
 
     /* Second dataset */
-    static s2_t		s2[NX*NY];
+    s2_t		*s2 = NULL;
     hid_t		s2_tid;
 
     /* Third dataset */
-    static s3_t		s3[NX*NY];
+    s3_t		*s3 = NULL;
     hid_t		s3_tid;
 
     /* Fourth dataset */
-    static s4_t		s4[NX*NY];
+    s4_t		*s4 = NULL;
     hid_t		s4_tid;
 
     /* Fifth dataset */
-    static s5_t		s5[NX*NY];
+    s5_t		*s5 = NULL;
     hid_t		s5_tid;
 
-    static s6_t		s6[NX*NY];
-    hid_t		s6_tid;
-
-
     /* Sixth dataset */
+    s6_t		*s6 = NULL;
+    hid_t		s6_tid;
 
     /* Seventh dataset */
     hid_t		s7_sid;
@@ -204,6 +202,20 @@ test_compound (char *filename, hid_t fapl)
     hsize_t		memb_size[1] = {4};
     int			ret_code;
 
+    /* Allocate buffers for datasets */
+    if(NULL == (s1 = (s1_t *)HDmalloc(sizeof(s1_t) * NX * NY)))
+        goto error;
+    if(NULL == (s2 = (s2_t *)HDmalloc(sizeof(s2_t) * NX * NY)))
+        goto error;
+    if(NULL == (s3 = (s3_t *)HDmalloc(sizeof(s3_t) * NX * NY)))
+        goto error;
+    if(NULL == (s4 = (s4_t *)HDmalloc(sizeof(s4_t) * NX * NY)))
+        goto error;
+    if(NULL == (s5 = (s5_t *)HDmalloc(sizeof(s5_t) * NX * NY)))
+        goto error;
+    if(NULL == (s6 = (s6_t *)HDmalloc(sizeof(s6_t) * NX * NY)))
+        goto error;
+
     /* Create the file */
     if ((file = H5Fcreate (filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0) {
 	goto error;
@@ -848,11 +860,34 @@ test_compound (char *filename, hid_t fapl)
     H5Dclose (dataset);
     H5Fclose (file);
 
+    /* Release buffers */
+    HDfree(s1);
+    HDfree(s2);
+    HDfree(s3);
+    HDfree(s4);
+    HDfree(s5);
+    HDfree(s6);
+
     PASSED();
     return 0;
 
 error:
     puts("*** DATASET TESTS FAILED ***");
+
+    /* Release resources */
+    if(s1) 
+        HDfree(s1);
+    if(s2) 
+        HDfree(s2);
+    if(s3) 
+        HDfree(s3);
+    if(s4) 
+        HDfree(s4);
+    if(s5) 
+        HDfree(s5);
+    if(s6) 
+        HDfree(s6);
+
     return 1;
 }
 
diff --git a/test/dsets.c b/test/dsets.c
index fe6a0c0..4a52539 100644
--- a/test/dsets.c
+++ b/test/dsets.c
@@ -7942,11 +7942,10 @@ test_big_chunks_bypass_cache(hid_t fapl)
     int         fvalue = BYPASS_FILL_VALUE;	/* Fill value */
     hsize_t     count, stride, offset, block;	/* Setting for hyperslab (1-D) */
     hsize_t     t_count[2], t_stride[2], t_offset[2], t_block[2];  /* Setting for hyperslab (2-D) */
-		/* Buffer for reading and writing data (1-D) */
-    static int  wdata[BYPASS_CHUNK_DIM/2], rdata1[BYPASS_DIM],
-                rdata2[BYPASS_CHUNK_DIM/2];	
+		/* Buffers for reading and writing data (1-D) */
+    int         *wdata = NULL, *rdata1 = NULL, *rdata2 = NULL;	
 		/* Buffer for reading and writing data (2-D) */
-    static int  t_wdata[BYPASS_CHUNK_DIM/2][BYPASS_CHUNK_DIM/2], t_rdata1[BYPASS_DIM][BYPASS_DIM],
+    int         t_wdata[BYPASS_CHUNK_DIM/2][BYPASS_CHUNK_DIM/2], t_rdata1[BYPASS_DIM][BYPASS_DIM],
                 t_rdata2[BYPASS_CHUNK_DIM/2][BYPASS_CHUNK_DIM/2];
     int         i, j;		/* Local index variables */
     H5F_libver_t low;           /* File format low bound */
@@ -8031,6 +8030,14 @@ test_big_chunks_bypass_cache(hid_t fapl)
     if(H5Sselect_hyperslab(t_sid, H5S_SELECT_SET, t_offset, t_stride, t_count, t_block) < 0)
         FAIL_STACK_ERROR
 
+    /* Allocate buffers */
+    if(NULL == (wdata = (int *)HDmalloc(sizeof(int) * (BYPASS_CHUNK_DIM / 2))))
+        TEST_ERROR
+    if(NULL == (rdata1 = (int *)HDmalloc(sizeof(int) * BYPASS_DIM)))
+        TEST_ERROR
+    if(NULL == (rdata2 = (int *)HDmalloc(sizeof(int) * (BYPASS_CHUNK_DIM / 2))))
+        TEST_ERROR
+
     /* Initialize data to write for 1-D dataset */
     for(i = 0; i < BYPASS_CHUNK_DIM / 2; i++)
         wdata[i] = i;
@@ -8165,6 +8172,11 @@ test_big_chunks_bypass_cache(hid_t fapl)
     if(H5Pclose(fapl_local) < 0) FAIL_STACK_ERROR
     if(H5Fclose(fid) < 0) FAIL_STACK_ERROR
 
+    /* Release buffers */
+    HDfree(wdata);
+    HDfree(rdata1);
+    HDfree(rdata2);
+
     PASSED();
     return 0;
 
@@ -8179,6 +8191,12 @@ error:
         H5Sclose(t_sid);
         H5Fclose(fid);
     } H5E_END_TRY;
+    if(wdata)
+        HDfree(wdata);
+    if(rdata1)
+        HDfree(rdata1);
+    if(rdata2)
+        HDfree(rdata2);
     return -1;
 } /* end test_big_chunks_bypass_cache() */
 
@@ -9265,9 +9283,9 @@ test_fixed_array(hid_t fapl)
     hsize_t     msize_big[1] = {POINTS_BIG};    /* Size of memory space for big dataset */
 
     int         wbuf[POINTS];           /* write buffer */
-    int         wbuf_big[POINTS_BIG];  	/* write buffer for big dataset */
+    int         *wbuf_big = NULL;  	/* write buffer for big dataset */
     int         rbuf[POINTS];          	/* read buffer */
-    int         rbuf_big[POINTS_BIG];  	/* read buffer for big dataset */
+    int         *rbuf_big = NULL;  	/* read buffer for big dataset */
 
     hsize_t     chunk_dim2[2] = {4, 3}; /* Chunk dimensions */
     int         chunks[12][6];          /* # of chunks for dataset dimensions */
@@ -9309,6 +9327,12 @@ test_fixed_array(hid_t fapl)
     if((empty_size = h5_get_file_size(filename, fapl)) < 0)
         TEST_ERROR
 
+    /* Allocate the "big" buffers */
+    if(NULL == (wbuf_big = (int *)HDmalloc(sizeof(int) * POINTS_BIG)))
+        TEST_ERROR
+    if(NULL == (rbuf_big = (int *)HDmalloc(sizeof(int) * POINTS_BIG)))
+        TEST_ERROR
+
 #ifdef H5_HAVE_FILTER_DEFLATE
     /* Loop over compressing chunks */
     for(compress = FALSE; compress <= TRUE; compress++) {
@@ -9567,7 +9591,7 @@ test_fixed_array(hid_t fapl)
 
 	    /* Verify that written and read data are the same */
 	    for(i = 0; i < POINTS_BIG; i++)
-		if(rbuf_big[i] != wbuf_big[i]){
+		if(rbuf_big[i] != wbuf_big[i]) {
 		    printf("    Line %d: Incorrect value, wbuf_bif[%u]=%d, rbuf_big[%u]=%d\n",
 			__LINE__,(unsigned)i,wbuf_big[i],(unsigned)i,rbuf_big[i]);
 		    TEST_ERROR;
@@ -9599,6 +9623,10 @@ test_fixed_array(hid_t fapl)
     } /* end for */
 #endif /* H5_HAVE_FILTER_DEFLATE */
 
+    /* Release buffers */
+    HDfree(wbuf_big);
+    HDfree(rbuf_big);
+
     PASSED();
     return 0;
 
@@ -9610,6 +9638,10 @@ error:
         H5Sclose(mem_id);
         H5Fclose(fid);
     } H5E_END_TRY;
+    if(wbuf_big)
+        HDfree(wbuf_big);
+    if(rbuf_big)
+        HDfree(rbuf_big);
     return -1;
 } /* end test_fixed_array() */
 
@@ -9650,11 +9682,11 @@ test_single_chunk(hid_t fapl)
     hid_t       sid = -1, sid_max = -1;       	/* Dataspace ID for dataset with fixed dimensions */
     hid_t       did = -1, did_max = -1;      	/* Dataset ID for dataset with fixed dimensions */
     hsize_t     dim2[2] = {DSET_DIM1, DSET_DIM2};   	/* Dataset dimensions */
-    hsize_t     t_dim2[2] = {50, 100};   	/* Dataset dimensions */
-    int         wbuf[DSET_DIM1*DSET_DIM2];           	/* write buffer */
-    int         t_wbuf[50*100];           	/* write buffer */
-    int         rbuf[DSET_DIM1*DSET_DIM2];          	/* read buffer */
-    int         t_rbuf[50*100];          	/* read buffer */
+    hsize_t     t_dim2[2] = {50, 100};   /* Dataset dimensions */
+    int         *wbuf = NULL;            /* write buffer */
+    int         *t_wbuf = NULL;          /* write buffer */
+    int         *rbuf = NULL;          	 /* read buffer */
+    int         *t_rbuf = NULL;          /* read buffer */
 
     H5D_chunk_index_t idx_type; 	/* Dataset chunk index type */
     H5F_libver_t low, high;     	/* File format bounds */
@@ -9686,6 +9718,16 @@ test_single_chunk(hid_t fapl)
     if((empty_size = h5_get_file_size(filename, fapl)) < 0)
         TEST_ERROR
 
+    /* Allocate the buffers */
+    if(NULL == (wbuf = (int *)HDmalloc(sizeof(int) * (DSET_DIM1 * DSET_DIM2))))
+        TEST_ERROR
+    if(NULL == (rbuf = (int *)HDmalloc(sizeof(int) * (DSET_DIM1 * DSET_DIM2))))
+        TEST_ERROR
+    if(NULL == (t_wbuf = (int *)HDmalloc(sizeof(int) * (50 * 100))))
+        TEST_ERROR
+    if(NULL == (t_rbuf = (int *)HDmalloc(sizeof(int) * (50 * 100))))
+        TEST_ERROR
+
     for(i = n = 0; i < (DSET_DIM1 * DSET_DIM2); i++)
 	wbuf[i] = (int)n++;
 
@@ -9800,7 +9842,7 @@ test_single_chunk(hid_t fapl)
 	    /* Open the second dataset */
 	    if((did = H5Dopen2(fid, DSET_SINGLE_NOMAX, H5P_DEFAULT)) < 0) TEST_ERROR;
 
-	    HDmemset(rbuf, 0, sizeof(rbuf));
+	    HDmemset(rbuf, 0, sizeof(int) * (DSET_DIM1 * DSET_DIM2));
 
 	    /* Read from dataset */
 	    if(H5Dread(did, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, t_rbuf) < 0) TEST_ERROR;
@@ -9836,6 +9878,12 @@ test_single_chunk(hid_t fapl)
     } /* end for */
 #endif /* H5_HAVE_FILTER_DEFLATE */
 
+    /* Release buffers */
+    HDfree(wbuf);
+    HDfree(rbuf);
+    HDfree(t_wbuf);
+    HDfree(t_rbuf);
+
     PASSED();
     return 0;
 
@@ -9849,6 +9897,14 @@ error:
         H5Sclose(sid_max);
         H5Fclose(fid);
     } H5E_END_TRY;
+    if(wbuf)
+        HDfree(wbuf);
+    if(rbuf)
+        HDfree(rbuf);
+    if(t_wbuf)
+        HDfree(t_wbuf);
+    if(t_rbuf)
+        HDfree(t_rbuf);
     return -1;
 } /* end test_single_chunk() */
 
diff --git a/test/dt_arith.c b/test/dt_arith.c
index 064ee69..cdfe182 100644
--- a/test/dt_arith.c
+++ b/test/dt_arith.c
@@ -2673,12 +2673,14 @@ test_conv_int_2(void)
 {
     int		i, j;
     hid_t	src_type, dst_type;
-    char	buf[32*100];
+    char	*buf;
 
     printf("%-70s", "Testing overlap calculations");
     HDfflush(stdout);
 
-    HDmemset(buf, 0, sizeof buf);
+    buf = (char *)HDcalloc(32, 100);
+    HDassert(buf);
+
     for (i=1; i<=32; i++) {
 	for (j=1; j<=32; j++) {
 
@@ -2700,6 +2702,7 @@ test_conv_int_2(void)
 	}
     }
     PASSED();
+    HDfree(buf);
     return 0;
 }
 
diff --git a/test/gheap.c b/test/gheap.c
index 317e306..3e88ca6 100644
--- a/test/gheap.c
+++ b/test/gheap.c
@@ -78,7 +78,7 @@ test_1 (hid_t fapl)
 {
     hid_t	file = -1;
     H5F_t 	*f = NULL;
-    H5HG_t	obj[1024];
+    H5HG_t	*obj = NULL;
     uint8_t	out[1024];
     uint8_t	in[1024];
     size_t	u;
@@ -89,6 +89,10 @@ test_1 (hid_t fapl)
 
     TESTING("monotonically increasing lengths");
 
+    /* Allocate buffer for H5HG_t */
+    if(NULL == (obj = (H5HG_t *)HDmalloc(sizeof(H5HG_t) * 1024)))
+        goto error;
+
     /* Open a clean file */
     h5_fixname(FILENAME[0], fapl, filename, sizeof filename);
     if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
@@ -138,6 +142,10 @@ test_1 (hid_t fapl)
 	}
     }
 
+    /* Release buffer */
+    HDfree(obj);
+    obj = NULL;
+
     if(H5Fclose(file) < 0) goto error;
     if(nerrors) goto error;
 
@@ -148,6 +156,8 @@ error:
     H5E_BEGIN_TRY {
 	H5Fclose(file);
     } H5E_END_TRY;
+    if(obj)
+        HDfree(obj);
     return MAX(1, nerrors);
 }
 
@@ -174,7 +184,7 @@ test_2 (hid_t fapl)
 {
     hid_t	file = -1;
     H5F_t 	*f = NULL;
-    H5HG_t	obj[1024];
+    H5HG_t	*obj = NULL;
     uint8_t	out[1024];
     uint8_t	in[1024];
     size_t	u;
@@ -184,6 +194,10 @@ test_2 (hid_t fapl)
 
     TESTING("monotonically decreasing lengths");
 
+    /* Allocate buffer for H5HG_t */
+    if(NULL == (obj = (H5HG_t *)HDmalloc(sizeof(H5HG_t) * 1024)))
+        goto error;
+
     /* Open a clean file */
     h5_fixname(FILENAME[1], fapl, filename, sizeof filename);
     if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
@@ -226,8 +240,13 @@ test_2 (hid_t fapl)
 	}
     }
 
+    /* Release buffer */
+    HDfree(obj);
+    obj = NULL;
+
     if (H5Fclose(file)<0) goto error;
     if (nerrors) goto error;
+
     PASSED();
     return 0;
 
@@ -235,6 +254,8 @@ test_2 (hid_t fapl)
     H5E_BEGIN_TRY {
 	H5Fclose(file);
     } H5E_END_TRY;
+    if(obj)
+        HDfree(obj);
     return MAX(1, nerrors);
 }
 
@@ -261,7 +282,7 @@ test_3 (hid_t fapl)
 {
     hid_t	file = -1;
     H5F_t 	*f = NULL;
-    H5HG_t	obj[1024];
+    H5HG_t	*obj = NULL;
     uint8_t	out[1024];
     size_t	u;
     size_t	size;
@@ -271,6 +292,10 @@ test_3 (hid_t fapl)
 
     TESTING("complete object removal");
 
+    /* Allocate buffer for H5HG_t */
+    if(NULL == (obj = (H5HG_t *)HDmalloc(sizeof(H5HG_t) * 1024)))
+        goto error;
+
     /* Open a clean file */
     h5_fixname(FILENAME[2], fapl, filename, sizeof filename);
     if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
@@ -304,8 +329,13 @@ test_3 (hid_t fapl)
 	}
     }
 
+    /* Release buffer */
+    HDfree(obj);
+    obj = NULL;
+
     if (H5Fclose(file)<0) goto error;
     if (nerrors) goto error;
+
     PASSED();
     return 0;
 
@@ -313,6 +343,8 @@ test_3 (hid_t fapl)
     H5E_BEGIN_TRY {
 	H5Fclose(file);
     } H5E_END_TRY;
+    if(obj)
+        HDfree(obj);
     return MAX(1, nerrors);
 }
 
@@ -340,7 +372,7 @@ test_4 (hid_t fapl)
 {
     hid_t	file = -1;
     H5F_t 	*f = NULL;
-    H5HG_t	obj[1024];
+    H5HG_t	*obj = NULL;
     uint8_t	out[1024];
     size_t	u;
     size_t	size;
@@ -350,6 +382,10 @@ test_4 (hid_t fapl)
 
     TESTING("partial object removal");
 
+    /* Allocate buffer for H5HG_t */
+    if(NULL == (obj = (H5HG_t *)HDmalloc(sizeof(H5HG_t) * 1024)))
+        goto error;
+
     /* Open a clean file */
     h5_fixname(FILENAME[3], fapl, filename, sizeof filename);
     if((file = H5Fcreate(filename, H5F_ACC_TRUNC, H5P_DEFAULT, fapl)) < 0)
@@ -389,8 +425,13 @@ test_4 (hid_t fapl)
 	}
     }
 
+    /* Release buffer */
+    HDfree(obj);
+    obj = NULL;
+
     if (H5Fclose(file)<0) goto error;
     if (nerrors) goto error;
+
     PASSED();
     return 0;
 
@@ -398,6 +439,8 @@ test_4 (hid_t fapl)
     H5E_BEGIN_TRY {
 	H5Fclose(file);
     } H5E_END_TRY;
+    if(obj)
+        HDfree(obj);
     return MAX(1, nerrors);
 }
 
diff --git a/test/h5test.c b/test/h5test.c
index aea5dc7..974f2e7 100644
--- a/test/h5test.c
+++ b/test/h5test.c
@@ -74,7 +74,7 @@ char  *paraprefix = NULL;  /* for command line option para-prefix */
 MPI_Info    h5_io_info_g=MPI_INFO_NULL;/* MPI INFO object for IO */
 #endif
 
-#define READ_BUF_SIZE           4096
+#define READ_BUF_SIZE           65536
 
 /*
  * These are the letters that are appended to the file name when generating
@@ -855,7 +855,7 @@ h5_fileaccess(void)
         H5FD_mem_t memb_map[H5FD_MEM_NTYPES];
         hid_t memb_fapl[H5FD_MEM_NTYPES];
         const char *memb_name[H5FD_MEM_NTYPES];
-        char sv[H5FD_MEM_NTYPES][1024];
+        char *sv[H5FD_MEM_NTYPES];
         haddr_t memb_addr[H5FD_MEM_NTYPES];
         H5FD_mem_t  mt;
 
@@ -867,6 +867,8 @@ h5_fileaccess(void)
         HDassert(HDstrlen(multi_letters)==H5FD_MEM_NTYPES);
         for(mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t, mt)) {
             memb_fapl[mt] = H5P_DEFAULT;
+            sv[mt] = (char *)HDmalloc(1024);
+            HDassert(sv[mt]);
             HDsprintf(sv[mt], "%%s-%c.h5", multi_letters[mt]);
             memb_name[mt] = sv[mt];
             memb_addr[mt] = (haddr_t)MAX(mt - 1, 0) * (HADDR_MAX / 10);
@@ -874,6 +876,9 @@ h5_fileaccess(void)
 
         if(H5Pset_fapl_multi(fapl, memb_map, memb_fapl, memb_name, memb_addr, FALSE) < 0)
             return -1;
+
+        for(mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t, mt))
+            HDfree(sv[mt]);
     }
     else if(!HDstrcmp(name, "family")) {
         hsize_t fam_size = 100*1024*1024; /*100 MB*/
@@ -989,7 +994,7 @@ h5_get_vfd_fapl(void)
         H5FD_mem_t  memb_map[H5FD_MEM_NTYPES];
         hid_t       memb_fapl[H5FD_MEM_NTYPES];
         const char  *memb_name[H5FD_MEM_NTYPES];
-        char        sv[H5FD_MEM_NTYPES][1024];
+        char        *sv[H5FD_MEM_NTYPES];
         haddr_t     memb_addr[H5FD_MEM_NTYPES];
         H5FD_mem_t  mt;
 
@@ -1001,15 +1006,18 @@ h5_get_vfd_fapl(void)
         HDassert(HDstrlen(multi_letters) == H5FD_MEM_NTYPES);
         for(mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t, mt)) {
             memb_fapl[mt] = H5P_DEFAULT;
+            sv[mt] = (char *)HDmalloc(1024);
+            HDassert(sv[mt]);
             HDsprintf(sv[mt], "%%s-%c.h5", multi_letters[mt]);
             memb_name[mt] = sv[mt];
             memb_addr[mt] = (haddr_t)MAX(mt - 1, 0) * (HADDR_MAX / 10);
         } /* end for */
 
-        if(H5Pset_fapl_multi(fapl, memb_map, memb_fapl, memb_name,
-          memb_addr, FALSE) < 0) {
+        if(H5Pset_fapl_multi(fapl, memb_map, memb_fapl, memb_name, memb_addr, FALSE) < 0)
             return -1;
-        } /* end if */
+
+        for(mt = H5FD_MEM_DEFAULT; mt < H5FD_MEM_NTYPES; H5_INC_ENUM(H5FD_mem_t, mt))
+            HDfree(sv[mt]);
     } else if(!HDstrcmp(tok, "family")) {
         /* Family of files, each 1MB and using the default driver */
         hsize_t fam_size = 100*1024*1024; /*100 MB*/
@@ -1573,9 +1581,13 @@ h5_make_local_copy(const char *origfilename, const char *local_copy_name)
 {
     int fd_old = (-1), fd_new = (-1);   /* File descriptors for copying data */
     ssize_t nread;                      /* Number of bytes read in */
-    char  buf[READ_BUF_SIZE];           /* Buffer for copying data */
+    void  *buf;                         /* Buffer for copying data */
     const char *filename = H5_get_srcdir_filename(origfilename);;       /* Get the test file name to copy */
 
+    /* Allocate copy buffer */
+    if(NULL == (buf = HDmalloc(READ_BUF_SIZE)))
+        return -1;
+
     /* Copy old file into temporary file */
     if((fd_old = HDopen(filename, O_RDONLY, 0666)) < 0)
         return -1;
@@ -1586,6 +1598,9 @@ h5_make_local_copy(const char *origfilename, const char *local_copy_name)
     while((nread = HDread(fd_old, buf, (size_t)READ_BUF_SIZE)) > 0)
         if(HDwrite(fd_new, buf, (size_t)nread) < 0)
             return -1;
+ 
+    /* Release memory */
+    HDfree(buf);
 
     /* Close files */
     if(HDclose(fd_old) < 0) return -1;
diff --git a/test/tattr.c b/test/tattr.c
index e7b3ece..6f55081 100644
--- a/test/tattr.c
+++ b/test/tattr.c
@@ -8029,7 +8029,7 @@ test_attr_shared_write(hid_t fcpl, hid_t fapl)
     htri_t	is_shared;	/* Is attributes shared? */
     hsize_t     shared_refcount;        /* Reference count of shared attribute */
     unsigned    attr_value;     /* Attribute value */
-    unsigned	big_value[SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3];   /* Data for "big" attribute */
+    unsigned	*big_value;     /* Data for "big" attribute */
     size_t      mesg_count;     /* # of shared messages */
     unsigned    test_shared;    /* Index over shared component type */
     unsigned    u;              /* Local index variable */
@@ -8040,8 +8040,10 @@ test_attr_shared_write(hid_t fcpl, hid_t fapl)
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Writing Shared & Unshared Attributes in Compact & Dense Storage\n"));
 
-    /* Initialize "big" attribute data */
-    HDmemset(big_value, 1, sizeof(big_value));
+    /* Allocate & initialize "big" attribute data */
+    big_value = (unsigned *)HDmalloc((size_t)(SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3) * sizeof(unsigned));
+    CHECK(big_value, NULL, "HDmalloc");
+    HDmemset(big_value, 1, sizeof(unsigned) * (size_t)(SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3));
 
     /* Create dataspace for dataset */
     sid = H5Screate(H5S_SCALAR);
@@ -8328,6 +8330,9 @@ test_attr_shared_write(hid_t fcpl, hid_t fapl)
     CHECK(ret, FAIL, "H5Sclose");
     ret = H5Sclose(big_sid);
     CHECK(ret, FAIL, "H5Sclose");
+
+    /* Release memory */
+    HDfree(big_value);
 }   /* test_attr_shared_write() */
 
 /****************************************************************
@@ -8355,7 +8360,7 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl)
     htri_t	is_shared;	/* Is attributes shared? */
     hsize_t     shared_refcount;        /* Reference count of shared attribute */
     unsigned    attr_value;     /* Attribute value */
-    unsigned	big_value[SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3];   /* Data for "big" attribute */
+    unsigned	*big_value;     /* Data for "big" attribute */
     size_t      mesg_count;     /* # of shared messages */
     unsigned    test_shared;    /* Index over shared component type */
     unsigned    u;              /* Local index variable */
@@ -8366,8 +8371,10 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl)
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Renaming Shared & Unshared Attributes in Compact & Dense Storage\n"));
 
-    /* Initialize "big" attribute data */
-    HDmemset(big_value, 1, sizeof(big_value));
+    /* Allocate & initialize "big" attribute data */
+    big_value = (unsigned *)HDmalloc((size_t)(SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3) * sizeof(unsigned));
+    CHECK(big_value, NULL, "HDmalloc");
+    HDmemset(big_value, 1, sizeof(unsigned) * (size_t)(SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3));
 
     /* Create dataspace for dataset */
     sid = H5Screate(H5S_SCALAR);
@@ -8770,6 +8777,9 @@ test_attr_shared_rename(hid_t fcpl, hid_t fapl)
     CHECK(ret, FAIL, "H5Sclose");
     ret = H5Sclose(big_sid);
     CHECK(ret, FAIL, "H5Sclose");
+
+    /* Release memory */
+    HDfree(big_value);
 }   /* test_attr_shared_rename() */
 
 /****************************************************************
@@ -8796,7 +8806,7 @@ test_attr_shared_delete(hid_t fcpl, hid_t fapl)
     htri_t	is_shared;	/* Is attributes shared? */
     hsize_t     shared_refcount;        /* Reference count of shared attribute */
     unsigned    attr_value;     /* Attribute value */
-    unsigned	big_value[SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3];   /* Data for "big" attribute */
+    unsigned	*big_value;     /* Data for "big" attribute */
     size_t      mesg_count;     /* # of shared messages */
     unsigned    test_shared;    /* Index over shared component type */
     unsigned    u;              /* Local index variable */
@@ -8807,8 +8817,10 @@ test_attr_shared_delete(hid_t fcpl, hid_t fapl)
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Deleting Shared & Unshared Attributes in Compact & Dense Storage\n"));
 
-    /* Initialize "big" attribute data */
-    HDmemset(big_value, 1, sizeof(big_value));
+    /* Allocate & initialize "big" attribute data */
+    big_value = (unsigned *)HDmalloc((size_t)(SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3) * sizeof(unsigned));
+    CHECK(big_value, NULL, "HDmalloc");
+    HDmemset(big_value, 1, sizeof(unsigned) * (size_t)(SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3));
 
     /* Create dataspace for dataset */
     sid = H5Screate(H5S_SCALAR);
@@ -9134,6 +9146,9 @@ test_attr_shared_delete(hid_t fcpl, hid_t fapl)
     CHECK(ret, FAIL, "H5Sclose");
     ret = H5Sclose(big_sid);
     CHECK(ret, FAIL, "H5Sclose");
+
+    /* Release memory */
+    HDfree(big_value);
 }   /* test_attr_shared_delete() */
 
 /****************************************************************
@@ -9160,7 +9175,7 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl)
     htri_t	is_shared;	/* Is attributes shared? */
     hsize_t     shared_refcount;        /* Reference count of shared attribute */
     unsigned    attr_value;     /* Attribute value */
-    unsigned	big_value[SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3];   /* Data for "big" attribute */
+    unsigned	*big_value;     /* Data for "big" attribute */
     size_t      mesg_count;     /* # of shared messages */
     unsigned    test_shared;    /* Index over shared component type */
     unsigned    u;              /* Local index variable */
@@ -9171,8 +9186,10 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl)
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Unlinking Object with Shared Attributes in Compact & Dense Storage\n"));
 
-    /* Initialize "big" attribute data */
-    HDmemset(big_value, 1, sizeof(big_value));
+    /* Allocate & initialize "big" attribute data */
+    big_value = (unsigned *)HDmalloc((size_t)(SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3) * sizeof(unsigned));
+    CHECK(big_value, NULL, "HDmalloc");
+    HDmemset(big_value, 1, sizeof(unsigned) * (size_t)(SPACE1_DIM1 * SPACE1_DIM2 * SPACE1_DIM3));
 
     /* Create dataspace for dataset */
     sid = H5Screate(H5S_SCALAR);
@@ -9484,6 +9501,9 @@ test_attr_shared_unlink(hid_t fcpl, hid_t fapl)
     CHECK(ret, FAIL, "H5Sclose");
     ret = H5Sclose(big_sid);
     CHECK(ret, FAIL, "H5Sclose");
+
+    /* Release memory */
+    HDfree(big_value);
 }   /* test_attr_shared_unlink() */
 
 /****************************************************************
diff --git a/test/tchecksum.c b/test/tchecksum.c
index ca6c227..cf519c0 100644
--- a/test/tchecksum.c
+++ b/test/tchecksum.c
@@ -37,7 +37,6 @@
 /*******************/
 /* Local variables */
 /*******************/
-uint8_t large_buf[BUF_LEN];
 
 
 /****************************************************************
@@ -184,33 +183,41 @@ test_chksum_size_four(void)
 static void
 test_chksum_large(void)
 {
+    uint8_t *large_buf;         /* Buffer for checksum calculations */
     uint32_t chksum;            /* Checksum value */
     size_t u;                   /* Local index variable */
 
+    /* Allocate the buffer */
+    large_buf = (uint8_t *)HDmalloc((size_t)BUF_LEN);
+    CHECK(large_buf, NULL, "HDmalloc");
+
     /* Initialize buffer w/known data */
     for(u = 0; u < BUF_LEN; u++)
         large_buf[u] = (uint8_t)(u * 3);
 
     /* Buffer w/real data */
-    chksum = H5_checksum_fletcher32(large_buf, sizeof(large_buf));
+    chksum = H5_checksum_fletcher32(large_buf, (size_t)BUF_LEN);
     VERIFY(chksum, 0x85b4e2a, "H5_checksum_fletcher32");
 
-    chksum = H5_checksum_crc(large_buf, sizeof(large_buf));
+    chksum = H5_checksum_crc(large_buf, (size_t)BUF_LEN);
     VERIFY(chksum, 0xfbd0f7c0, "H5_checksum_crc");
 
-    chksum = H5_checksum_lookup3(large_buf, sizeof(large_buf), 0);
+    chksum = H5_checksum_lookup3(large_buf, (size_t)BUF_LEN, 0);
     VERIFY(chksum, 0x1bd2ee7b, "H5_checksum_lookup3");
 
     /* Buffer w/zero(s) for data */
-    HDmemset(large_buf, 0, sizeof(large_buf));
-    chksum = H5_checksum_fletcher32(large_buf, sizeof(large_buf));
+    HDmemset(large_buf, 0, (size_t)BUF_LEN);
+    chksum = H5_checksum_fletcher32(large_buf, (size_t)BUF_LEN);
     VERIFY(chksum, 0, "H5_checksum_fletcher32");
 
-    chksum = H5_checksum_crc(large_buf, sizeof(large_buf));
+    chksum = H5_checksum_crc(large_buf, (size_t)BUF_LEN);
     VERIFY(chksum, 0xfac8b4c4, "H5_checksum_crc");
 
-    chksum = H5_checksum_lookup3(large_buf, sizeof(large_buf), 0);
+    chksum = H5_checksum_lookup3(large_buf, (size_t)BUF_LEN, 0);
     VERIFY(chksum, 0x930c7afc, "H5_checksum_lookup3");
+
+    /* Release memory for buffer */
+    HDfree(large_buf);
 } /* test_chksum_large() */
 
 
diff --git a/test/th5o.c b/test/th5o.c
index 125e11b..c2c4034 100644
--- a/test/th5o.c
+++ b/test/th5o.c
@@ -777,15 +777,21 @@ test_h5o_link(void)
     hsize_t dims[2] = {TEST6_DIM1, TEST6_DIM2};
     htri_t committed;           /* Whether the named datatype is committed */
     unsigned new_format;        /* Whether to use the new format or not */
-    int wdata[TEST6_DIM1][TEST6_DIM2];
-    int rdata[TEST6_DIM1][TEST6_DIM2];
-    int i, n, j;
+    int *wdata;
+    int *rdata;
+    int i, n;
     herr_t ret;                 /* Value returned from API calls */
 
+    /* Allocate memory buffers */
+    /* (These are treated as 2-D buffers) */
+    wdata = (int *)HDmalloc((size_t)(TEST6_DIM1 * TEST6_DIM2) * sizeof(int));
+    CHECK(wdata, NULL, "HDmalloc");
+    rdata = (int *)HDmalloc((size_t)(TEST6_DIM1 * TEST6_DIM2) * sizeof(int));
+    CHECK(rdata, NULL, "HDmalloc");
+
     /* Initialize the raw data */
-    for(i = n = 0; i < TEST6_DIM1; i++)
-        for(j = 0; j < TEST6_DIM2; j++)
-          wdata[i][j] = n++;
+    for(i = n = 0; i < (TEST6_DIM1 * TEST6_DIM2); i++)
+      wdata[i] = n++;
 
     /* Create the dataspace */
     space_id = H5Screate_simple(2 ,dims, NULL);
@@ -840,9 +846,8 @@ test_h5o_link(void)
         CHECK(ret, FAIL, "H5Dread");
 
         /* Verify the data */
-        for(i = 0; i < TEST6_DIM1; i++)
-            for(j = 0; j < TEST6_DIM2; j++)
-                VERIFY(wdata[i][j], rdata[i][j], "H5Dread");
+        for(i = 0; i < (TEST6_DIM1 * TEST6_DIM2); i++)
+            VERIFY(wdata[i], rdata[i], "H5Dread");
 
         /* Create a group with no name*/
         group_id = H5Gcreate_anon(file_id, H5P_DEFAULT, H5P_DEFAULT);
@@ -879,9 +884,8 @@ test_h5o_link(void)
         /* Read data from dataset */
         ret = H5Dread(dset_id, H5T_NATIVE_INT, H5S_ALL, H5S_ALL, H5P_DEFAULT, rdata);
         CHECK(ret, FAIL, "H5Dread");
-        for(i = 0; i < TEST6_DIM1; i++)
-            for(j = 0; j < TEST6_DIM2; j++)
-                VERIFY(wdata[i][j], rdata[i][j], "H5Dread");
+        for(i = 0; i < (TEST6_DIM1 * TEST6_DIM2); i++)
+            VERIFY(wdata[i], rdata[i], "H5Dread");
 
         /* Close open IDs */
         ret = H5Dclose(dset_id);
@@ -897,6 +901,10 @@ test_h5o_link(void)
     CHECK(ret, FAIL, "H5Sclose");
     ret = H5Pclose(lcpl_id);
     CHECK(ret, FAIL, "H5Pclose");
+
+    /* Release buffers */
+    HDfree(wdata);
+    HDfree(rdata);
 } /* end test_h5o_link() */
 
 
diff --git a/test/theap.c b/test/theap.c
index 2d509bf..b19e08f 100644
--- a/test/theap.c
+++ b/test/theap.c
@@ -44,13 +44,13 @@ typedef struct test_obj {
 } test_obj;
 
 /* Array of random element values */
-static test_obj rand_num[NUM_ELEMS];
+static test_obj *rand_num;
 
 /* Array of random elements values, sorted in increasing order */
-static test_obj inc_sort_num[NUM_ELEMS];
+static test_obj *inc_sort_num;
 
 /* Array of random elements values, sorted in decreasing order */
-static test_obj dec_sort_num[NUM_ELEMS];
+static test_obj *dec_sort_num;
 
 static int tst_dec_sort(const void *_i1, const void *_i2)
 {
@@ -88,21 +88,29 @@ test_heap_init(void)
     time_t curr_time;   /* Current time, for seeding random number generator */
     size_t u;           /* Local index variables */
 
+    /* Allocate arrays */
+    rand_num = (test_obj *)HDmalloc(sizeof(test_obj) * NUM_ELEMS);
+    HDassert(rand_num);
+    inc_sort_num = (test_obj *)HDmalloc(sizeof(test_obj) * NUM_ELEMS);
+    HDassert(inc_sort_num);
+    dec_sort_num = (test_obj *)HDmalloc(sizeof(test_obj) * NUM_ELEMS);
+    HDassert(dec_sort_num);
+
     /* Create randomized set of numbers */
-    curr_time=time(NULL);
+    curr_time = HDtime(NULL);
     HDsrandom((unsigned)curr_time);
-    for(u=0; u<NUM_ELEMS; u++)
+    for(u = 0; u < NUM_ELEMS; u++)
         /* Generate random numbers from -1000 to 1000 */
-        rand_num[u].val=(int)(HDrandom()%2001)-1001;
+        rand_num[u].val = (int)(HDrandom() % 2001) - 1001;
 
     /* Sort random numbers into increasing order */
-    HDmemcpy(inc_sort_num,rand_num,sizeof(test_obj)*NUM_ELEMS);
+    HDmemcpy(inc_sort_num, rand_num, sizeof(test_obj) * NUM_ELEMS);
     HDqsort(inc_sort_num, (size_t)NUM_ELEMS, sizeof(test_obj), tst_inc_sort);
 
     /* Sort random numbers into decreasing order */
-    HDmemcpy(dec_sort_num,rand_num,sizeof(test_obj)*NUM_ELEMS);
+    HDmemcpy(dec_sort_num, rand_num, sizeof(test_obj) * NUM_ELEMS);
     HDqsort(dec_sort_num, (size_t)NUM_ELEMS, sizeof(test_obj), tst_dec_sort);
-} /* end test_tst_init() */
+} /* end test_heap_init() */
 
 /****************************************************************
 **
@@ -1023,6 +1031,21 @@ test_heap_incdec(void)
 
 /****************************************************************
 **
+**  test_heap_term(): Test H5HP (heap) code.
+**      Release data for Heap testing
+**
+****************************************************************/
+static void
+test_heap_term(void)
+{
+    /* Release arrays */
+    HDfree(rand_num);
+    HDfree(inc_sort_num);
+    HDfree(dec_sort_num);
+} /* end test_tst_term() */
+
+/****************************************************************
+**
 **  test_heap(): Main H5HP testing routine.
 **
 ****************************************************************/
@@ -1044,5 +1067,8 @@ test_heap(void)
     test_heap_change();          /* Test changing priority of objects on Heap */
     test_heap_incdec();          /* Test incrementing & decrementing priority of objects on Heap */
 
+    /* Release Heap testing data */
+    test_heap_term();
+
 }   /* end test_heap() */
 
diff --git a/test/titerate.c b/test/titerate.c
index 9f0b900..3004d62 100644
--- a/test/titerate.c
+++ b/test/titerate.c
@@ -584,9 +584,9 @@ test_iter_group_large(hid_t fapl)
     hid_t		tid;       /* Datatype ID			*/
     hsize_t		dims[] = {SPACE1_DIM1};
     herr_t		ret;		/* Generic return value		*/
-    char gname[20];         /* Temporary group name */
-    iter_info names[ITER_NGROUPS+2]; /* Names of objects in the root group */
-    iter_info *curr_name;        /* Pointer to the current name in the root group */
+    char gname[20];             /* Temporary group name */
+    iter_info *names;           /* Names of objects in the root group */
+    iter_info *curr_name;       /* Pointer to the current name in the root group */
     int                 i;
 
     /* Compound datatype */
@@ -596,7 +596,9 @@ test_iter_group_large(hid_t fapl)
         float c;
     } s1_t;
 
-    HDmemset(names, 0, sizeof names);
+    /* Allocate & initialize array */
+    names = (iter_info *)HDcalloc(sizeof(iter_info), (ITER_NGROUPS + 2));
+    CHECK(names, NULL, "HDcalloc");
 
     /* Output message about test being performed */
     MESSAGE(5, ("Testing Large Group Iteration Functionality\n"));
@@ -686,6 +688,9 @@ test_iter_group_large(hid_t fapl)
     /* Close file */
     ret = H5Fclose(file);
     CHECK(ret, FAIL, "H5Fclose");
+
+    /* Release memory */
+    HDfree(names);
 } /* test_iterate_group_large() */
 
 /****************************************************************
diff --git a/test/tskiplist.c b/test/tskiplist.c
index f413674..5738aad 100644
--- a/test/tskiplist.c
+++ b/test/tskiplist.c
@@ -38,9 +38,9 @@
 #define NUM_ELEMS       1000
 
 /* Random numbers */
-static int rand_num[NUM_ELEMS];
-static int sort_rand_num[NUM_ELEMS];
-static int rev_sort_rand_num[NUM_ELEMS];
+static int *rand_num;
+static int *sort_rand_num;
+static int *rev_sort_rand_num;
 
 static int tst_sort(const void *i1, const void *i2)
 {
@@ -66,23 +66,31 @@ test_skiplist_init(void)
     unsigned found;     /* Flag to indicate value was inserted already */
     size_t u,v;         /* Local index variables */
 
+    /* Allocate arrays */
+    rand_num = (int *)HDmalloc(sizeof(int) * NUM_ELEMS);
+    HDassert(rand_num);
+    sort_rand_num = (int *)HDmalloc(sizeof(int) * NUM_ELEMS);
+    HDassert(sort_rand_num);
+    rev_sort_rand_num = (int *)HDmalloc(sizeof(int) * NUM_ELEMS);
+    HDassert(rev_sort_rand_num);
+
     /* Initialize random number seed */
     curr_time = HDtime(NULL);
     HDsrandom((unsigned)curr_time);
 
     /* Create randomized set of numbers */
-    for(u=0; u<NUM_ELEMS; u++) {
+    for(u = 0; u < NUM_ELEMS; u++) {
         do {
             /* Reset flag */
-            found=0;
+            found = 0;
 
             /* Generate random numbers from -5000 to 5000 */
-            new_val=(int)(HDrandom()%10001)-5001;
+            new_val = (int)(HDrandom() % 10001) - 5001;
 
             /* Check if the value is already in the array */
-            for(v=0; v<u; v++)
-                if(rand_num[v]==new_val)
-                    found=1;
+            for(v = 0; v < u; v++)
+                if(rand_num[v] == new_val)
+                    found = 1;
         } while(found);
 
         /* Set unique value in array */
@@ -90,7 +98,7 @@ test_skiplist_init(void)
     } /* end for */
 
     /* Copy random values to sorted array */
-    HDmemcpy(sort_rand_num,rand_num,sizeof(int)*NUM_ELEMS);
+    HDmemcpy(sort_rand_num, rand_num, sizeof(int) * NUM_ELEMS);
 
     /* Sort random numbers */
     HDqsort(sort_rand_num, (size_t)NUM_ELEMS, sizeof(int), tst_sort);
@@ -100,7 +108,7 @@ test_skiplist_init(void)
 
     /* Sort random numbers */
     HDqsort(rev_sort_rand_num, (size_t)NUM_ELEMS, sizeof(int), tst_rev_sort);
-} /* end test_tst_init() */
+} /* end test_skiplist_init() */
 
 /****************************************************************
 **
@@ -1746,6 +1754,21 @@ test_skiplist_remove_first_many(void)
 
 /****************************************************************
 **
+**  test_skiplist_term(): Test H5SL (skiplist) code.
+**      Release data for skip list testing
+**
+****************************************************************/
+static void
+test_skiplist_term(void)
+{
+    /* Release arrays */
+    HDfree(rand_num);
+    HDfree(sort_rand_num);
+    HDfree(rev_sort_rand_num);
+} /* end test_skiplist_term() */
+
+/****************************************************************
+**
 **  test_skiplist(): Main H5SL testing routine.
 **
 ****************************************************************/
@@ -1784,5 +1807,8 @@ test_skiplist(void)
     test_skiplist_remove_first();   /* Test 'remove first' operation */
     test_skiplist_remove_first_many();  /* Test 'remove first' operation on large skip lists */
 
+    /* Release skip list testing data */
+    test_skiplist_term();
+
 }   /* end test_skiplist() */
 
diff --git a/test/tvltypes.c b/test/tvltypes.c
index f8a6a91..d00519d 100644
--- a/test/tvltypes.c
+++ b/test/tvltypes.c
@@ -1001,8 +1001,8 @@ test_vltypes_compound_vlen_vlen(void)
         float f;
         hvl_t v;
     } s1;
-    s1 wdata[SPACE3_DIM1];              /* data to write */
-    s1 rdata[SPACE3_DIM1];              /* data to read */
+    s1          *wdata;                 /* data to write */
+    s1          *rdata;                 /* data to read */
     hid_t	fid1;		        /* HDF5 File IDs		*/
     hid_t	dataset;	        /* Dataset ID			*/
     hid_t	sid1;                   /* Dataspace ID			*/
@@ -1016,6 +1016,10 @@ test_vltypes_compound_vlen_vlen(void)
     MESSAGE(5, ("Testing Compound Datatypes with VL Atomic Datatype Component Functionality\n"));
 
     /* Allocate and initialize VL data to write */
+    wdata = (s1 *)HDmalloc(sizeof(s1) * SPACE3_DIM1);
+    CHECK(wdata, NULL, "HDmalloc");
+    rdata = (s1 *)HDmalloc(sizeof(s1) * SPACE3_DIM1);
+    CHECK(rdata, NULL, "HDmalloc");
     for(i = 0; i < SPACE3_DIM1; i++) {
         wdata[i].i = (int)(i * 10);
         wdata[i].f = (float)(i * 20) / 3.0F;
@@ -1147,6 +1151,10 @@ test_vltypes_compound_vlen_vlen(void)
     /* Close file */
     ret = H5Fclose(fid1);
     CHECK(ret, FAIL, "H5Fclose");
+
+    /* Release buffers */
+    HDfree(wdata);
+    HDfree(rdata);
 } /* end test_vltypes_compound_vlen_vlen() */
 
 /****************************************************************