[svn-r13615]

bug fixes
substituted hize_t array index variables for int
stack corruption in the h52gif reading routine, wrote a new routine
shell script for gif tests, added check of program return value

enabled the gif test script

tested: linux pgcc, solaris, linux 64

2 files changed, 766 insertions, 769 deletions

diff --git a/hl/test/test_image.c b/hl/test/test_image.c
index c988160..9645bad 100644
--- a/hl/test/test_image.c
+++ b/hl/test/test_image.c
@@ -20,7 +20,7 @@
 #include "H5IMpublic.h"
 #include "pal_rgb.h"
 
-#define FILE1       "test_image1.h5"
+#define FILE_NAME   "test_image1.h5"
 #define FILE2       "test_image2.h5"
 #define FILE3       "test_image3.h5"
 #define DATA_FILE1  "image8.txt"
@@ -32,15 +32,16 @@
 #define IMAGE1_NAME "image8bit"
 #define IMAGE2_NAME "image24bitpixel"
 #define IMAGE3_NAME "image24bitplane"
+#define PAL_NAME    "palette"
 #define PAL1_NAME   "rainbow"
 #define PAL2_NAME   "sepia"
 #define PAL3_NAME   "earth"
 #define PAL4_NAME   "blue-red"
 
 
-#define WIDTH       (hsize_t)500
-#define HEIGHT      (hsize_t)200
-#define PAL_ENTRIES 9
+#define WIDTH        400
+#define HEIGHT       200
+#define PAL_ENTRIES  256
 
 /* struct to store RGB values read from a .pal file */
 typedef struct rgb_t {
@@ -66,19 +67,19 @@ unsigned char *image_data = NULL;
 
 int main(void)
 {
- int nerrors=0;
-
- nerrors += test_simple()<0  ?1:0;
- nerrors += test_data()<0  ?1:0;
- nerrors += test_generate()<0  ?1:0;
-
- if (nerrors) goto error;
- printf("All image tests passed.\n");
- return 0;
-
+    int nerrors=0;
+    
+    nerrors += test_simple()<0  ?1:0;
+    nerrors += test_data()<0  ?1:0;
+    nerrors += test_generate()<0  ?1:0;
+    
+    if (nerrors) goto error;
+    printf("All image tests passed.\n");
+    return 0;
+    
 error:
- printf("***** %d IMAGE TEST%s FAILED! *****\n",nerrors, 1 == nerrors ? "" : "S");
- return 1;
+    printf("***** %d IMAGE TEST%s FAILED! *****\n",nerrors, 1 == nerrors ? "" : "S");
+    return 1;
 }
 
 /*-------------------------------------------------------------------------
@@ -88,244 +89,214 @@ error:
 
 static int test_simple(void)
 {
- hid_t         fid;
- hsize_t       width;
- hsize_t       height;
- hsize_t       planes;
- hsize_t       pal_dims[] = {PAL_ENTRIES,3};
- hsize_t       pal_dims_out[2];
- char          interlace[20];
- hssize_t      npals;
- size_t       i, j;
- herr_t        is_image;
- herr_t        is_pal;
- unsigned char image_in1 [ WIDTH*HEIGHT ];
- unsigned char image_out1[ WIDTH*HEIGHT ];
- unsigned char image_in2 [ WIDTH*HEIGHT*3 ];
- unsigned char image_out2[ WIDTH*HEIGHT*3 ];
- unsigned char pal_data_out[PAL_ENTRIES*3];
- unsigned char n;
- hsize_t space;
- /* create a PAL_ENTRIES entry palette */
- unsigned char pal_data_in[PAL_ENTRIES*3] = {
- 0,0,168,      /* dark blue */
- 0,0,252,      /* blue */
- 0,168,252,    /* ocean blue */
- 84,252,252,   /* light blue */
- 168,252,168,  /* light green */
- 0,252,168,    /* green */
- 252,252,84,   /* yellow */
- 252,168,0,    /* orange */
- 252,0,0};     /* red */
-
- /* create an image of 9 values divided evenly by the array */
- space = WIDTH*HEIGHT / PAL_ENTRIES;
- for (i=0, j=0, n=0; i < (size_t)(WIDTH*HEIGHT); i++, j++ )
- {
-  image_in1[i] = n;
-  if ( j > (size_t)space )
-  {
-   n++;
-   j=0;
-  }
-  if (n>PAL_ENTRIES-1) n=0;
- }
- /* create an image 3 byte RGB image */
- for (i=0, j=0, n=0; i < (size_t)(WIDTH*HEIGHT*3); i++, j++)
- {
-  image_in2[i] = n;
-  if (j==3)
-  {
-   n++;
-   j=0;
-  }
- }
-
- /* create a file using default properties */
- if ((fid=H5Fcreate(FILE1,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT))<0)
-  goto out;
-
-
- printf("Testing API functions\n");
-
-/*-------------------------------------------------------------------------
- * indexed image test
- *-------------------------------------------------------------------------
- */
-
- TESTING2("indexed images");
-
- /* write image */
- if (H5IMmake_image_8bit(fid,"image1",WIDTH,HEIGHT,image_in1)<0)
-  goto out;
-
- /* make a palette */
- if (H5IMmake_palette(fid,"palette",pal_dims,pal_data_in)<0)
-  goto out;
-
- /* attach the palette to the image dataset */
- if (H5IMlink_palette(fid,"image1","palette")<0)
-  goto out;
-
- /* get info */
- if (H5IMget_image_info(fid,"image1",&width,&height,&planes,interlace,&npals)<0)
-  goto out;
-
- if (width!=WIDTH)
-  goto out;
- if (height!=HEIGHT)
-  goto out;
- if (planes!=1)
-  goto out;
- if (npals!=1)
-  goto out;
-
- /* read image */
- if (H5IMread_image(fid,"image1",image_out1)<0)
-  goto out;
-
- /* check */
- for (i = 0; i < (size_t)(height*width*planes); i++)
- {
-  if ( image_in1[i] != image_out1[i] )
-  {
-   goto out;
-  }
- }
-
-
- PASSED();
-
-/*-------------------------------------------------------------------------
- * true color image test
- *-------------------------------------------------------------------------
- */
-
- TESTING2("true color image");
-
- /* write image */
- if (H5IMmake_image_24bit(fid,"image2",WIDTH,HEIGHT,"INTERLACE_PIXEL",image_in2))
-  goto out;
-
- /* get info */
- if (H5IMget_image_info(fid,"image2",&width,&height,&planes,interlace,&npals)<0)
-  goto out;
-
- if (width!=WIDTH)
-  goto out;
- if (height!=HEIGHT)
-  goto out;
- if (planes!=3)
-  goto out;
-
- /* read image */
- if (H5IMread_image(fid,"image2",image_out2)<0)
-  goto out;
-
- /* check */
- for (i = 0; i < (size_t)(height*width*planes); i++)
- {
-  if ( image_in2[i] != image_out2[i] )
-  {
-    goto out;
-  }
- }
-
- PASSED();
-
-/*-------------------------------------------------------------------------
- * H5IMget_npalettes test
- *-------------------------------------------------------------------------
- */
-
- TESTING2("palette functions");
-
- if (H5IMget_npalettes(fid,"image1",&npals)<0)
-  goto out;
-
- if (npals!=1)
-  goto out;
-
-/*-------------------------------------------------------------------------
- * H5IMget_palette_info test
- *-------------------------------------------------------------------------
- */
-
- if (H5IMget_palette_info(fid,"image1",0,pal_dims_out)<0)
-  goto out;
-
- /* check */
- for (i = 0; i < 2; i++)
- {
-  if ( pal_dims[i] != pal_dims_out[i] )
-  {
-   goto out;
-  }
- }
-
-/*-------------------------------------------------------------------------
- * H5IMget_palette test
- *-------------------------------------------------------------------------
- */
-
- if (H5IMget_palette(fid,"image1",0,pal_data_out)<0)
-  goto out;
-
- /* check */
- for (i = 0; i < PAL_ENTRIES*3; i++)
- {
-  if ( pal_data_in[i] != pal_data_out[i] )
-  {
-   goto out;
-  }
- }
-
-/*-------------------------------------------------------------------------
- * H5IMis_image test
- *-------------------------------------------------------------------------
- */
-
- if ((is_image=H5IMis_image(fid,"image1"))<0)
-  goto out;
-
- if (is_image!=1)
-  goto out;
-
- if ((is_image=H5IMis_image(fid,"image2"))<0)
-  goto out;
-
- if (is_image!=1)
-  goto out;
-
-/*-------------------------------------------------------------------------
- * H5IMis_palette test
- *-------------------------------------------------------------------------
- */
-
- if ((is_pal=H5IMis_palette(fid,"palette"))<0)
-  goto out;
-
- if (is_pal!=1)
-  goto out;
-
- PASSED();
-
-/*-------------------------------------------------------------------------
- * close
- *-------------------------------------------------------------------------
- */
- if (H5Fclose(fid)<0)
-  goto out;
+    hsize_t       width    = WIDTH;
+    hsize_t       height   = HEIGHT;
+    hsize_t       planes;
+    hid_t         fid;
+    int           i, j, n, space;
+    char          interlace[20];
+    hssize_t      npals;
+    
+    /* 8-bit image */
+    unsigned char buf1 [ WIDTH*HEIGHT ];
+    unsigned char pal[ PAL_ENTRIES * 3 ];        /* palette array */
+    hsize_t       pal_dims[2] = {PAL_ENTRIES,3}; /* palette dimensions */
+    
+    /* 24-bit image */
+    unsigned char buf2 [ WIDTH*HEIGHT*3 ];
+    
+    /* read data */
+    unsigned char buf1_out [ WIDTH*HEIGHT ];
+    unsigned char buf2_out [ WIDTH*HEIGHT*3 ];
+    unsigned char pal_out[ PAL_ENTRIES * 3 ];    /* palette array */
+    hsize_t       pal_dims_out[2];               /* palette dimensions */
+    
+    /* create an image */
+    space = WIDTH*HEIGHT / PAL_ENTRIES;
+    for (i=0, j=0, n=0; i < WIDTH*HEIGHT; i++, j++ )
+    {
+        buf1[i] = n;
+        if ( j > space )
+        {
+            n++;
+            j=0;
+        }
+        
+    }
+    
+    
+    /* create an image */
+    space = WIDTH*HEIGHT / 256;
+    for (i=0, j=0, n=0; i < WIDTH*HEIGHT*3; i+=3, j++ )
+    {
+        unsigned char r, g, b;
+
+        r = n; g = 0; b = 255-n;
+        buf2[i]   = r;
+        buf2[i+1] = g;
+        buf2[i+2] = b;
+        if ( j > space )
+        {
+            n++;
+            j=0;
+        }
+    }
+    
+   /*-------------------------------------------------------------------------
+    * define a palette, blue to red tones 
+    *-------------------------------------------------------------------------
+    */
+    for ( i=0, n=0; i<PAL_ENTRIES*3; i+=3, n++)
+    {
+        pal[i]  =n;      /* red */
+        pal[i+1]=0;      /* green */
+        pal[i+2]=255-n;  /* blue */
+    }
+    
+    /* Create a new HDF5 file using default properties. */
+    fid = H5Fcreate(FILE_NAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT );
+    
+   /*-------------------------------------------------------------------------
+    * Indexed image test
+    *-------------------------------------------------------------------------
+    */
+    
+    TESTING("indexed image");
+    
+    /* Write image */
+    if ( H5IMmake_image_8bit( fid, IMAGE1_NAME, width, height, buf1 ) < 0 )
+        goto out;
+    
+    /* Make a palette */
+    if ( H5IMmake_palette( fid, PAL_NAME, pal_dims, pal ) < 0 )
+        goto out;
+    
+    /* Attach a palette to the image dataset */
+    if ( H5IMlink_palette( fid, IMAGE1_NAME, PAL_NAME ) < 0 )
+        goto out;
+    
+    /* Read image */
+    if ( H5IMget_image_info( fid, IMAGE1_NAME, &width, &height, &planes, interlace, &npals ) < 0 )
+        goto out;
+    
+    if ( H5IMread_image( fid, IMAGE1_NAME, buf1_out ) < 0 )
+        goto out;
+    
+    for (i = 0; i < height*width*planes; i++) 
+    {
+        if ( buf1[i] != buf1_out[i] ) 
+            goto out;
+ 
+    }
+    
+    
+    PASSED();
+    
+   /*-------------------------------------------------------------------------
+    * True color image test
+    *-------------------------------------------------------------------------
+    */
+    
+    TESTING("true color image");
+    
+    /* Write image */
+    if ( H5IMmake_image_24bit( fid, IMAGE2_NAME, width, height, "INTERLACE_PIXEL", buf2 ) )
+        goto out;
+    
+    /* Read image */
+    if ( H5IMget_image_info( fid, IMAGE2_NAME, &width, &height, &planes, interlace, &npals ) < 0 )
+        goto out;
+    
+    if ( H5IMread_image( fid, IMAGE2_NAME, buf2_out ) < 0 )
+        goto out;
+    
+    for (i = 0; i < height*width*planes; i++) 
+    {
+        if ( buf2[i] != buf2_out[i] ) 
+            goto out;
+    }
+    
+    
+    PASSED();
+    
+   /*-------------------------------------------------------------------------
+    * H5IMget_npalettes test
+    *-------------------------------------------------------------------------
+    */
+    
+    TESTING("pallete functions");
+    
+    if ( H5IMget_npalettes( fid, IMAGE1_NAME, &npals ) < 0 )
+        goto out;
+    
+   /*-------------------------------------------------------------------------
+    * H5IMget_palette_info test
+    *-------------------------------------------------------------------------
+    */
+    
+    if ( H5IMget_palette_info( fid, IMAGE1_NAME, 0, pal_dims_out ) < 0 )
+        goto out;
+    
+    for (i = 0; i < 2; i++) 
+    {
+        if ( pal_dims[i] != pal_dims_out[i] ) 
+            goto out;
+    }
+    
+   /*-------------------------------------------------------------------------
+    * H5IMget_palette test
+    *-------------------------------------------------------------------------
+    */
+    
+    if ( H5IMget_palette( fid, IMAGE1_NAME, 0, pal_out ) < 0 )
+        goto out;
+    
+    for (i = 0; i < PAL_ENTRIES * 3; i++) 
+    {
+        if ( pal[i] != pal_out[i] ) 
+            goto out;
+    }
+    
+   /*-------------------------------------------------------------------------
+    * H5IMis_image test
+    *-------------------------------------------------------------------------
+    */
+    
+    if ( H5IMis_image( fid, IMAGE1_NAME ) < 0 )
+        goto out;
+    
+    if ( H5IMis_image( fid, IMAGE2_NAME ) < 0 )
+        goto out;
+    
+   /*-------------------------------------------------------------------------
+    * H5IMis_palette test
+    *-------------------------------------------------------------------------
+    */
+    
+    if ( H5IMis_palette( fid, PAL_NAME ) < 0 )
+        goto out;
+    
+   /*-------------------------------------------------------------------------
+    * end tests
+    *-------------------------------------------------------------------------
+    */
+    
+    /* Close the file. */
+    if(H5Fclose( fid ) < 0) 
+        goto out;
+    
+    
+    PASSED();
 
- return 0;
+    return 0;
 
- /* error zone, gracefully close */
+    /* error zone, gracefully close */
 out:
- H5E_BEGIN_TRY {
-  H5Fclose(fid);
- } H5E_END_TRY;
- H5_FAILED();
- return FAIL;
+    H5E_BEGIN_TRY {
+        H5Fclose(fid);
+    } H5E_END_TRY;
+    H5_FAILED();
+    return FAIL;
 }
 
 
@@ -336,184 +307,184 @@ out:
 
 static int test_data(void)
 {
- hid_t          fid;
- hsize_t        pal_dims[2];
- hsize_t        width;
- hsize_t        height;
- unsigned char  pal[256*3]; /* buffer to hold an HDF5 palette */
- rgb_t          rgb[256];   /* buffer to hold a .pal file palette */
- int            i, n;
-
- /* create a file using default properties */
- if ((fid=H5Fcreate(FILE2,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT))<0)
-  goto out;
-
- printf("Testing read ascii image data and generate images\n");
-
-/*-------------------------------------------------------------------------
- * read 8bit image data
- *-------------------------------------------------------------------------
- */
-
- TESTING2("make indexed image");
-
- /* read first data file */
- if (read_data(DATA_FILE1,&width,&height)<0)
-  goto out;
-
- /* make an image */
- if (H5IMmake_image_8bit(fid,IMAGE1_NAME,width,height,image_data)<0)
-  goto out;
-
- PASSED();
-
-
- TESTING2("attaching palettes");
-
-/*-------------------------------------------------------------------------
- * palette #1. rainbow palette. data is contained in "pal_rgb.h"
- *-------------------------------------------------------------------------
- */
-
- /* initialize the palette data */
- pal_dims[0] = 256;
- pal_dims[1] = 3;
-
- /* make a palette */
- if (H5IMmake_palette(fid,PAL1_NAME,pal_dims,pal_rgb)<0)
-  goto out;
-
- /* attach a palette to the image dataset */
- if (H5IMlink_palette(fid,IMAGE1_NAME,PAL1_NAME)<0)
-  goto out;
-
-/*-------------------------------------------------------------------------
- * palette #2. sepia palette.
- * read a PAL file and attach the palette to the HDF5 file
- *-------------------------------------------------------------------------
- */
-
- /* read a PAL file */
- if (read_palette(PAL2_FILE, rgb, sizeof(rgb))<0)
-  goto out;
-
- /* transfer to the HDF5 buffer */
- for ( i=0, n=0; i<256*3; i+=3, n++)
- {
-  pal[i]  =rgb[n].r;
-  pal[i+1]=rgb[n].g;
-  pal[i+2]=rgb[n].b;
- }
-
- /* make a palette */
- if (H5IMmake_palette(fid,PAL2_NAME,pal_dims,pal)<0)
-  goto out;
-
- /* attach the palette to the image dataset */
- if (H5IMlink_palette(fid,IMAGE1_NAME,PAL2_NAME)<0)
-  goto out;
-
-/*-------------------------------------------------------------------------
- * palette #3. earth palette.
- * read a PAL file and attach the palette to the HDF5 file
- *-------------------------------------------------------------------------
- */
-
- /* read a PAL file */
- if (read_palette(PAL3_FILE, rgb, sizeof(rgb))<0)
-  goto out;
-
- /* transfer to the HDF5 buffer */
- for ( i=0, n=0; i<256*3; i+=3, n++)
- {
-  pal[i]  =rgb[n].r;
-  pal[i+1]=rgb[n].g;
-  pal[i+2]=rgb[n].b;
- }
-
- /* make a palette */
- if (H5IMmake_palette(fid,PAL3_NAME,pal_dims,pal)<0)
-  goto out;
-
- /* attach the palette to the image dataset */
- if (H5IMlink_palette(fid,IMAGE1_NAME,PAL3_NAME)<0)
-  goto out;
-
- PASSED();
-
-
-/*-------------------------------------------------------------------------
- * palette #4. blue-red
- * make a palette whith blue to red colors
- *-------------------------------------------------------------------------
- */
- for ( i=0, n=0; i<256*3; i+=3, n++)
- {
-  pal[i]  =n;
-  pal[i+1]=0;
-  pal[i+2]=255-n;
- }
-
- /* make a palette */
- if (H5IMmake_palette(fid,PAL4_NAME,pal_dims,pal)<0)
-  goto out;
-
- /* attach the palette to the image dataset */
- if (H5IMlink_palette(fid,IMAGE1_NAME,PAL4_NAME)<0)
-  goto out;
-
-
-/*-------------------------------------------------------------------------
- * true color image example with pixel interlace
- *-------------------------------------------------------------------------
- */
-
- TESTING2("make true color image with pixel interlace");
-
- /* read second data file */
- if ((read_data(DATA_FILE2,&width,&height))<0)
-  goto out;
-
- /* make image */
- if ((H5IMmake_image_24bit(fid,IMAGE2_NAME,width,height,"INTERLACE_PIXEL",image_data))<0)
-  goto out;
-
- PASSED();
-
-/*-------------------------------------------------------------------------
- * True color image example with plane interlace
- *-------------------------------------------------------------------------
- */
-
- TESTING2("make true color image with plane interlace");
-
- /* read third data file */
- if ((read_data(DATA_FILE3,&width,&height))<0)
-  goto out;
-
- /* make image */
- if ((H5IMmake_image_24bit(fid,IMAGE3_NAME,width,height,"INTERLACE_PLANE",image_data))<0)
-  goto out;
-
- PASSED();
-
-
-/*-------------------------------------------------------------------------
- * close
- *-------------------------------------------------------------------------
- */
- if (H5Fclose(fid)<0)
-  goto out;
-
- return 0;
-
- /* error zone, gracefully close */
+    hid_t          fid;
+    hsize_t        pal_dims[2];
+    hsize_t        width;
+    hsize_t        height;
+    unsigned char  pal[256*3]; /* buffer to hold an HDF5 palette */
+    rgb_t          rgb[256];   /* buffer to hold a .pal file palette */
+    int            i, n;
+    
+    /* create a file using default properties */
+    if ((fid=H5Fcreate(FILE2,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT))<0)
+        goto out;
+    
+    printf("Testing read ascii image data and generate images\n");
+    
+   /*-------------------------------------------------------------------------
+    * read 8bit image data
+    *-------------------------------------------------------------------------
+    */
+    
+    TESTING2("make indexed image");
+    
+    /* read first data file */
+    if (read_data(DATA_FILE1,&width,&height)<0)
+        goto out;
+    
+    /* make an image */
+    if (H5IMmake_image_8bit(fid,IMAGE1_NAME,width,height,image_data)<0)
+        goto out;
+    
+    PASSED();
+    
+    
+    TESTING2("attaching palettes");
+    
+   /*-------------------------------------------------------------------------
+    * palette #1. rainbow palette. data is contained in "pal_rgb.h"
+    *-------------------------------------------------------------------------
+    */
+    
+    /* initialize the palette data */
+    pal_dims[0] = 256;
+    pal_dims[1] = 3;
+    
+    /* make a palette */
+    if (H5IMmake_palette(fid,PAL1_NAME,pal_dims,pal_rgb)<0)
+        goto out;
+    
+    /* attach a palette to the image dataset */
+    if (H5IMlink_palette(fid,IMAGE1_NAME,PAL1_NAME)<0)
+        goto out;
+    
+   /*-------------------------------------------------------------------------
+    * palette #2. sepia palette.
+    * read a PAL file and attach the palette to the HDF5 file
+    *-------------------------------------------------------------------------
+    */
+    
+    /* read a PAL file */
+    if (read_palette(PAL2_FILE, rgb, sizeof(rgb))<0)
+        goto out;
+    
+    /* transfer to the HDF5 buffer */
+    for ( i=0, n=0; i<256*3; i+=3, n++)
+    {
+        pal[i]  =rgb[n].r;
+        pal[i+1]=rgb[n].g;
+        pal[i+2]=rgb[n].b;
+    }
+    
+    /* make a palette */
+    if (H5IMmake_palette(fid,PAL2_NAME,pal_dims,pal)<0)
+        goto out;
+    
+    /* attach the palette to the image dataset */
+    if (H5IMlink_palette(fid,IMAGE1_NAME,PAL2_NAME)<0)
+        goto out;
+    
+   /*-------------------------------------------------------------------------
+    * palette #3. earth palette.
+    * read a PAL file and attach the palette to the HDF5 file
+    *-------------------------------------------------------------------------
+    */
+    
+    /* read a PAL file */
+    if (read_palette(PAL3_FILE, rgb, sizeof(rgb))<0)
+        goto out;
+    
+    /* transfer to the HDF5 buffer */
+    for ( i=0, n=0; i<256*3; i+=3, n++)
+    {
+        pal[i]  =rgb[n].r;
+        pal[i+1]=rgb[n].g;
+        pal[i+2]=rgb[n].b;
+    }
+    
+    /* make a palette */
+    if (H5IMmake_palette(fid,PAL3_NAME,pal_dims,pal)<0)
+        goto out;
+    
+    /* attach the palette to the image dataset */
+    if (H5IMlink_palette(fid,IMAGE1_NAME,PAL3_NAME)<0)
+        goto out;
+    
+    PASSED();
+    
+    
+   /*-------------------------------------------------------------------------
+    * palette #4. blue-red
+    * make a palette whith blue to red colors
+    *-------------------------------------------------------------------------
+    */
+    for ( i=0, n=0; i<256*3; i+=3, n++)
+    {
+        pal[i]  =n;
+        pal[i+1]=0;
+        pal[i+2]=255-n;
+    }
+    
+    /* make a palette */
+    if (H5IMmake_palette(fid,PAL4_NAME,pal_dims,pal)<0)
+        goto out;
+    
+    /* attach the palette to the image dataset */
+    if (H5IMlink_palette(fid,IMAGE1_NAME,PAL4_NAME)<0)
+        goto out;
+    
+    
+   /*-------------------------------------------------------------------------
+    * true color image example with pixel interlace
+    *-------------------------------------------------------------------------
+    */
+    
+    TESTING2("make true color image with pixel interlace");
+    
+    /* read second data file */
+    if ((read_data(DATA_FILE2,&width,&height))<0)
+        goto out;
+    
+    /* make image */
+    if ((H5IMmake_image_24bit(fid,IMAGE2_NAME,width,height,"INTERLACE_PIXEL",image_data))<0)
+        goto out;
+    
+    PASSED();
+    
+    /*-------------------------------------------------------------------------
+    * True color image example with plane interlace
+    *-------------------------------------------------------------------------
+    */
+    
+    TESTING2("make true color image with plane interlace");
+    
+    /* read third data file */
+    if ((read_data(DATA_FILE3,&width,&height))<0)
+        goto out;
+    
+    /* make image */
+    if ((H5IMmake_image_24bit(fid,IMAGE3_NAME,width,height,"INTERLACE_PLANE",image_data))<0)
+        goto out;
+    
+    PASSED();
+    
+    
+   /*-------------------------------------------------------------------------
+    * close
+    *-------------------------------------------------------------------------
+    */
+    if (H5Fclose(fid)<0)
+        goto out;
+    
+    return 0;
+    
+    /* error zone, gracefully close */
 out:
- H5E_BEGIN_TRY {
-  H5Fclose(fid);
- } H5E_END_TRY;
- H5_FAILED();
- return FAIL;
+    H5E_BEGIN_TRY {
+        H5Fclose(fid);
+    } H5E_END_TRY;
+    H5_FAILED();
+    return FAIL;
 }
 
 
@@ -532,45 +503,45 @@ out:
 
 static int test_generate(void)
 {
- hid_t    fid;
- hsize_t  pal_dims[2] = { 256, 3 };
- float    *data;
- int      imax, jmax, kmax;
- float    valex, xmin, xmax, value;
- FILE     *f;
- char     *srcdir = getenv("srcdir"); /* the source directory */
- char     data_file[512]="";          /* buffer to hold name of existing data file */
- int      i;
-
- /* create a file using default properties */
- if ((fid=H5Fcreate(FILE3,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT))<0)
-  goto out;
-
- printf("Testing read and process data and make indexed images\n");
-
-/*-------------------------------------------------------------------------
- * compose the name of the file to open, using the srcdir, if appropriate
- *-------------------------------------------------------------------------
- */
- if ( srcdir )
- {
-  strcpy(data_file, srcdir);
-  strcat(data_file, "/");
- }
- strcat(data_file,DATA_FILE4);
-
-/*-------------------------------------------------------------------------
- * read data; the file data format is described below
- *-------------------------------------------------------------------------
- */
-
- f  = fopen( data_file, "r" ) ;
- if ( f == NULL )
- {
-  printf( "Could not find file %s. Try set $srcdir \n", data_file );
-  H5Fclose(fid);
-  return -1;
- }
+    hid_t    fid;
+    hsize_t  pal_dims[2] = { 256, 3 };
+    float    *data;
+    int      imax, jmax, kmax;
+    float    valex, xmin, xmax, value;
+    FILE     *f;
+    char     *srcdir = getenv("srcdir"); /* the source directory */
+    char     data_file[512]="";          /* buffer to hold name of existing data file */
+    int      i;
+    
+    /* create a file using default properties */
+    if ((fid=H5Fcreate(FILE3,H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT))<0)
+        goto out;
+    
+    printf("Testing read and process data and make indexed images\n");
+    
+   /*-------------------------------------------------------------------------
+    * compose the name of the file to open, using the srcdir, if appropriate
+    *-------------------------------------------------------------------------
+    */
+    if ( srcdir )
+    {
+        strcpy(data_file, srcdir);
+        strcat(data_file, "/");
+    }
+    strcat(data_file,DATA_FILE4);
+    
+    /*-------------------------------------------------------------------------
+    * read data; the file data format is described below
+    *-------------------------------------------------------------------------
+    */
+    
+    f  = fopen( data_file, "r" ) ;
+    if ( f == NULL )
+    {
+        printf( "Could not find file %s. Try set $srcdir \n", data_file );
+        H5Fclose(fid);
+        return -1;
+    }
 
 /*
 !The first line of the ASCII file contains the dimension of the array :
@@ -608,120 +579,120 @@ static int test_generate(void)
 */
 
 
- fscanf( f, "%d %d %d", &imax, &jmax, &kmax );
- fscanf( f, "%f %f %f", &valex, &xmin, &xmax );
-
- data = (float*) malloc ( imax * jmax * kmax * sizeof( float ));
- image_data = (unsigned char*) malloc ( imax * jmax * kmax * sizeof( unsigned char ));
-
- for ( i = 0; i < imax * jmax * kmax; i++ )
- {
-  fscanf( f, "%f ", &value );
-  data[i] = value;
- }
- fclose( f );
-
-/*-------------------------------------------------------------------------
- * transform the data from floating point to unsigend char
- * we are processing all the data here
- *-------------------------------------------------------------------------
- */
-
- TESTING2("make indexed image from all the data");
-
- for ( i = 0; i < imax * jmax * kmax; i++ )
- {
-  image_data[i] = (unsigned char)(( 255 * (data[i] - xmin ) ) / (xmax - xmin ));
- }
-
- /* Make the image */
- if ((H5IMmake_image_8bit(fid,"All data",(hsize_t)imax,(hsize_t)jmax,image_data))<0)
-  goto out;
-
- PASSED();
-
-/*-------------------------------------------------------------------------
- * transform the data from floating point to unsigend char
- * here we just process the land data
- *-------------------------------------------------------------------------
- */
-
- TESTING2("make indexed image from land data");
-
- for ( i = 0; i < imax * jmax * kmax; i++ )
- {
-  if ( data[i] < 0 )
-   image_data[i] = 0;
-  else
-   image_data[i] = (unsigned char)(( 255 * (data[i] ) ) / xmax );
- }
-
- /* make the image */
- if ((H5IMmake_image_8bit(fid,"Land data",(hsize_t)imax,(hsize_t)jmax,image_data))<0)
-  goto out;
-
- PASSED();
-
-/*-------------------------------------------------------------------------
- * transform the data from floating point to unsigend char
- * here we just process the sea data
- *-------------------------------------------------------------------------
- */
-
- TESTING2("make indexed image from sea data");
-
- for ( i = 0; i < imax * jmax * kmax; i++ )
- {
-  if ( data[i] > 0 )
-   image_data[i] = 0;
-  else
-   image_data[i] = (unsigned char)(( 255 * (data[i] - xmin ) ) / xmin );
- }
-
- /* make the image */
- if ((H5IMmake_image_8bit(fid,"Sea data",(hsize_t)imax,(hsize_t)jmax,image_data))<0)
-  goto out;
-
- PASSED();
-
-/*-------------------------------------------------------------------------
- * make a palette and attach it to the datasets
- *-------------------------------------------------------------------------
- */
-
- TESTING2("attaching palettes");
-
- /* make a palette */
- if ((H5IMmake_palette(fid,PAL1_NAME,pal_dims,pal_rgb))<0)
-  goto out;
-
- /* attach the palette to the image datasets */
- if ((H5IMlink_palette(fid,"All data",PAL1_NAME))<0)
-  goto out;
- if ((H5IMlink_palette(fid,"Land data",PAL1_NAME))<0)
-  goto out;
- if ((H5IMlink_palette(fid,"Sea data",PAL1_NAME))<0)
-  goto out;
-
- PASSED();
-
-
-/*-------------------------------------------------------------------------
- * close
- *-------------------------------------------------------------------------
- */
- if (H5Fclose(fid)<0)
-  goto out;
-
- return 0;
-
- /* error zone, gracefully close */
+    fscanf( f, "%d %d %d", &imax, &jmax, &kmax );
+    fscanf( f, "%f %f %f", &valex, &xmin, &xmax );
+    
+    data = (float*) malloc ( imax * jmax * kmax * sizeof( float ));
+    image_data = (unsigned char*) malloc ( imax * jmax * kmax * sizeof( unsigned char ));
+    
+    for ( i = 0; i < imax * jmax * kmax; i++ )
+    {
+        fscanf( f, "%f ", &value );
+        data[i] = value;
+    }
+    fclose( f );
+    
+   /*-------------------------------------------------------------------------
+    * transform the data from floating point to unsigned char
+    * we are processing all the data here
+    *-------------------------------------------------------------------------
+    */
+    
+    TESTING2("make indexed image from all the data");
+    
+    for ( i = 0; i < imax * jmax * kmax; i++ )
+    {
+        image_data[i] = (unsigned char)(( 255 * (data[i] - xmin ) ) / (xmax - xmin ));
+    }
+    
+    /* Make the image */
+    if ((H5IMmake_image_8bit(fid,"All data",(hsize_t)imax,(hsize_t)jmax,image_data))<0)
+        goto out;
+    
+    PASSED();
+    
+   /*-------------------------------------------------------------------------
+    * transform the data from floating point to unsigned char
+    * here we just process the land data
+    *-------------------------------------------------------------------------
+    */
+    
+    TESTING2("make indexed image from land data");
+    
+    for ( i = 0; i < imax * jmax * kmax; i++ )
+    {
+        if ( data[i] < 0 )
+            image_data[i] = 0;
+        else
+            image_data[i] = (unsigned char)(( 255 * (data[i] ) ) / xmax );
+    }
+    
+    /* make the image */
+    if ((H5IMmake_image_8bit(fid,"Land data",(hsize_t)imax,(hsize_t)jmax,image_data))<0)
+        goto out;
+    
+    PASSED();
+    
+   /*-------------------------------------------------------------------------
+    * transform the data from floating point to unsigned char
+    * here we just process the sea data
+    *-------------------------------------------------------------------------
+    */
+    
+    TESTING2("make indexed image from sea data");
+    
+    for ( i = 0; i < imax * jmax * kmax; i++ )
+    {
+        if ( data[i] > 0 )
+            image_data[i] = 0;
+        else
+            image_data[i] = (unsigned char)(( 255 * (data[i] - xmin ) ) / xmin );
+    }
+    
+    /* make the image */
+    if ((H5IMmake_image_8bit(fid,"Sea data",(hsize_t)imax,(hsize_t)jmax,image_data))<0)
+        goto out;
+    
+    PASSED();
+    
+   /*-------------------------------------------------------------------------
+    * make a palette and attach it to the datasets
+    *-------------------------------------------------------------------------
+    */
+    
+    TESTING2("attaching palettes");
+    
+    /* make a palette */
+    if ((H5IMmake_palette(fid,PAL1_NAME,pal_dims,pal_rgb))<0)
+        goto out;
+    
+    /* attach the palette to the image datasets */
+    if ((H5IMlink_palette(fid,"All data",PAL1_NAME))<0)
+        goto out;
+    if ((H5IMlink_palette(fid,"Land data",PAL1_NAME))<0)
+        goto out;
+    if ((H5IMlink_palette(fid,"Sea data",PAL1_NAME))<0)
+        goto out;
+    
+    PASSED();
+    
+    
+   /*-------------------------------------------------------------------------
+    * close
+    *-------------------------------------------------------------------------
+    */
+    if (H5Fclose(fid)<0)
+        goto out;
+    
+    return 0;
+    
+    /* error zone, gracefully close */
 out:
- H5E_BEGIN_TRY {
-  H5Fclose(fid);
- } H5E_END_TRY;
- H5_FAILED();
- return FAIL;
+    H5E_BEGIN_TRY {
+        H5Fclose(fid);
+    } H5E_END_TRY;
+    H5_FAILED();
+    return FAIL;
 }
 
 
@@ -746,65 +717,65 @@ static int read_data( const char* fname, /*IN*/
                       hsize_t *width, /*OUT*/
                       hsize_t *height /*OUT*/ )
 {
- int    i, n;
- int    color_planes;
- char   str[20];
- FILE   *f;
- int    w, h;
- char   *srcdir = getenv("srcdir"); /* the source directory */
- char   data_file[512]="";          /* buffer to hold name of existing data file */
-
-/*-------------------------------------------------------------------------
- * compose the name of the file to open, using "srcdir", if appropriate
- *-------------------------------------------------------------------------
- */
- strcpy(data_file, "");
- if (srcdir)
- {
-  strcpy(data_file, srcdir);
-  strcat(data_file, "/");
- }
- strcat(data_file,fname);
-
-/*-------------------------------------------------------------------------
- * read
- *-------------------------------------------------------------------------
- */
-
- f = fopen(data_file, "r");
- if ( f == NULL )
- {
-  printf( "Could not open file %s. Try set $srcdir \n", data_file );
-  return -1;
- }
-
- fscanf( f, "%s", str );
- fscanf( f, "%d", &color_planes );
- fscanf( f, "%s", str );
- fscanf( f, "%d", &h);
- fscanf( f, "%s", str );
- fscanf( f, "%d", &w);
-
- *width = (hsize_t)w;
- *height = (hsize_t)h;
-
- if ( image_data )
- {
-  free( image_data );
-  image_data=NULL;
- }
-
- image_data = (unsigned char*) malloc (w * h * color_planes * sizeof( unsigned char ));
-
- for (i = 0; i < h * w * color_planes ; i++)
- {
-  fscanf( f, "%d",&n );
-  image_data[i] = (unsigned char)n;
- }
- fclose(f);
-
- return 1;
-
+    int    i, n;
+    int    color_planes;
+    char   str[20];
+    FILE   *f;
+    int    w, h;
+    char   *srcdir = getenv("srcdir"); /* the source directory */
+    char   data_file[512]="";          /* buffer to hold name of existing data file */
+    
+   /*-------------------------------------------------------------------------
+    * compose the name of the file to open, using "srcdir", if appropriate
+    *-------------------------------------------------------------------------
+    */
+    strcpy(data_file, "");
+    if (srcdir)
+    {
+        strcpy(data_file, srcdir);
+        strcat(data_file, "/");
+    }
+    strcat(data_file,fname);
+    
+   /*-------------------------------------------------------------------------
+    * read
+    *-------------------------------------------------------------------------
+    */
+    
+    f = fopen(data_file, "r");
+    if ( f == NULL )
+    {
+        printf( "Could not open file %s. Try set $srcdir \n", data_file );
+        return -1;
+    }
+    
+    fscanf( f, "%s", str );
+    fscanf( f, "%d", &color_planes );
+    fscanf( f, "%s", str );
+    fscanf( f, "%d", &h);
+    fscanf( f, "%s", str );
+    fscanf( f, "%d", &w);
+    
+    *width = (hsize_t)w;
+    *height = (hsize_t)h;
+    
+    if ( image_data )
+    {
+        free( image_data );
+        image_data=NULL;
+    }
+    
+    image_data = (unsigned char*) malloc (w * h * color_planes * sizeof( unsigned char ));
+    
+    for (i = 0; i < h * w * color_planes ; i++)
+    {
+        fscanf( f, "%d",&n );
+        image_data[i] = (unsigned char)n;
+    }
+    fclose(f);
+    
+    return 1;
+    
 }
 
 
diff --git a/hl/test/test_table.c b/hl/test/test_table.c
index fcc8a7b..f5b73f9 100644
--- a/hl/test/test_table.c
+++ b/hl/test/test_table.c
@@ -48,10 +48,11 @@
  */
 
 #define TITLE           "Title"
-#define NFIELDS         (hsize_t)5
-#define NRECORDS        (hsize_t)8
-#define NRECORDS_ADD    (hsize_t)3
+#define NFIELDS          5
+#define NRECORDS         8
+#define NRECORDS_ADD     3
 
+#define TESTING2(WHAT) {printf("%-70s", "Testing     " WHAT); fflush(stdout);}
 
 /*-------------------------------------------------------------------------
  * structure used for all tests, a particle with properties
@@ -128,8 +129,7 @@ static int compare_deleted(hsize_t rrecords, hsize_t dstart, hsize_t drecords,
  *-------------------------------------------------------------------------
  */
 
-static int
-test_table(hid_t fid, int do_write)
+int test_table(hid_t fid, int write)
 {
  /* identifiers */
  hid_t       fid1;
@@ -142,7 +142,12 @@ test_table(hid_t fid, int do_write)
  hsize_t     position;
  char        tname[20];
 
+ /* indices */
+ int i, j;
+
  /* write, read, append, delete, insert some records and fields */
+ hsize_t FIELDS   = NFIELDS;
+ hsize_t RECORDS  = NRECORDS;
  hsize_t start;
  hsize_t wstart;
  hsize_t rstart;
@@ -156,8 +161,6 @@ test_table(hid_t fid, int do_write)
  hsize_t drecords;
  hsize_t nfields;
  hsize_t rfields;
- hsize_t i, j;
- size_t u;
  hsize_t start1;      /* record to start reading from 1st table */
  hsize_t start2;      /* record to start writing in 2nd table */
 
@@ -324,7 +327,7 @@ test_table(hid_t fid, int do_write)
   { "Name","Longitude","Pressure","Temperature","Latitude" };
  hid_t field_type[NFIELDS];
  hid_t string_type = H5Tcopy( H5T_C_S1 );
- H5Tset_size( string_type, (size_t)16 );
+ H5Tset_size( string_type, 16 );
  field_type[0] = string_type;
  field_type[1] = H5T_NATIVE_LONG;
  field_type[2] = H5T_NATIVE_FLOAT;
@@ -340,11 +343,11 @@ test_table(hid_t fid, int do_write)
  *
  *-------------------------------------------------------------------------
  */
- if (do_write)
+ if (write)
  {
  TESTING2("making table");
 
- if (H5TBmake_table(TITLE,fid,"table1",NFIELDS,NRECORDS,type_size_mem,
+ if (H5TBmake_table(TITLE,fid,"table1",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill,compress,wbuf)<0)
                     goto out;
@@ -380,12 +383,12 @@ test_table(hid_t fid, int do_write)
  *
  *-------------------------------------------------------------------------
  */
- if (do_write)
+ if (write)
  {
  TESTING2("writing records");
 
  /* create an empty table */
- if (H5TBmake_table(TITLE,fid,"table2",NFIELDS,NRECORDS,type_size_mem,
+ if (H5TBmake_table(TITLE,fid,"table2",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill,compress,0)<0)
                     goto out;
@@ -438,7 +441,7 @@ test_table(hid_t fid, int do_write)
  * we use the original "table1" instead
  *-------------------------------------------------------------------------
  */
- if(do_write)
+ if(write)
   strcpy(tname,"table2");
  else
   strcpy(tname,"table1");
@@ -449,7 +452,7 @@ test_table(hid_t fid, int do_write)
   goto out;
 
  /* compare */
- for( i=rstart; i<rrecords; i++)
+ for( i=(int)rstart; i<(int)rrecords; i++)
  {
   if (cmp_par(i,i,rbuf,wbuf)<0)
    goto out;
@@ -465,7 +468,7 @@ test_table(hid_t fid, int do_write)
  *
  *-------------------------------------------------------------------------
  */
- if (do_write)
+ if (write)
  {
  TESTING2("appending records");
 
@@ -489,12 +492,12 @@ test_table(hid_t fid, int do_write)
 
  /* compare */
  wrecords=8;
- for( i=rstart; i<wrecords; i++)
+ for( i=(int)rstart; i<(int)wrecords; i++)
  {
   if (cmp_par(i,i,rbuf,wbuf)<0)
    goto out;
  }
- for( i=wrecords, j=0; i<rrecords; i++,j++)
+ for( i=(int)wrecords, j=0; i<(int)rrecords; i++,j++)
  {
   if (cmp_par(i,j,rbuf,abuf)<0)
    goto out;
@@ -511,7 +514,7 @@ test_table(hid_t fid, int do_write)
  *
  *-------------------------------------------------------------------------
  */
- if (do_write)
+ if (write)
  {
  TESTING2("inserting records");
 
@@ -540,15 +543,15 @@ test_table(hid_t fid, int do_write)
    if (cmp_par(i,i,rbuf,wbuf)<0)
     goto out;
   }
-  else if (i>=istart && i<istart+irecords)
+  else if (i>=(int)istart && i<(int)istart+(int)irecords)
   {
-   j=i-istart;
+   j=i-(int)istart;
    if (cmp_par(i,j,rbuf,ibuf)<0)
     goto out;
   }
-  else if (i>=istart+irecords && i<10)
+  else if (i>=(int)istart+(int)irecords && i<10)
   {
-   j=i-irecords;
+   j=i-(int)irecords;
    if (cmp_par(i,j,rbuf,wbuf)<0)
     goto out;
   }
@@ -571,7 +574,7 @@ test_table(hid_t fid, int do_write)
  *
  *-------------------------------------------------------------------------
  */
- if (do_write)
+ if (write)
  {
  TESTING2("deleting records");
 
@@ -581,10 +584,19 @@ test_table(hid_t fid, int do_write)
  * data= 0 1 2 3 4 5 6 7
  *-------------------------------------------------------------------------
  */
- for( u=0; u<(size_t)NRECORDS; u++)
-  wbufd[u] = wbuf[u];
 
- if (H5TBmake_table(TITLE,fid,"table3",NFIELDS,NRECORDS,type_size_mem,
+ for( i=0; i<NRECORDS; i++)
+ {
+  wbufd[i].lati = wbuf[i].lati;
+  wbufd[i].longi = wbuf[i].longi;
+  wbufd[i].pressure = wbuf[i].pressure;
+  wbufd[i].temperature = wbuf[i].temperature;
+  strcpy(wbufd[i].name, wbuf[i].name );
+  
+ }
+
+
+ if (H5TBmake_table(TITLE,fid,"table3",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill,compress,wbufd)<0)
                     goto out;
@@ -618,8 +630,8 @@ test_table(hid_t fid, int do_write)
  *-------------------------------------------------------------------------
  */
  nrecords=rrecords;
- for( u=0; u<(size_t)nrecords; u++)
-  wbufd[u] = rbuf[u];
+ for( i=0; i<nrecords; i++)
+  wbufd[i] = rbuf[i];
 
 /*-------------------------------------------------------------------------
  * Delete records, start at 0, delete 2
@@ -649,8 +661,8 @@ test_table(hid_t fid, int do_write)
  *-------------------------------------------------------------------------
  */
  nrecords=rrecords;
- for( u=0; u<(size_t)nrecords; u++)
-  wbufd[u] = rbuf[u];
+ for( i=0; i<nrecords; i++)
+  wbufd[i] = rbuf[i];
 
 /*-------------------------------------------------------------------------
  * Delete records, start at 1, delete 1
@@ -680,8 +692,8 @@ test_table(hid_t fid, int do_write)
  *-------------------------------------------------------------------------
  */
  nrecords=rrecords;
- for( u=0; u<(size_t)nrecords; u++)
-  wbufd[u] = rbuf[u];
+ for( i=0; i<nrecords; i++)
+  wbufd[i] = rbuf[i];
 
 /*-------------------------------------------------------------------------
  * Delete records, start at 0, delete 1
@@ -711,8 +723,8 @@ test_table(hid_t fid, int do_write)
  *-------------------------------------------------------------------------
  */
  nrecords=rrecords;
- for( u=0; u<(size_t)nrecords; u++)
-  wbufd[u] = rbuf[u];
+ for( i=0; i<nrecords; i++)
+  wbufd[i] = rbuf[i];
 
  /* Read complete table */
  if (H5TBread_table(fid,"table3",type_size_mem,field_offset,field_size,rbuf)<0)
@@ -738,16 +750,16 @@ test_table(hid_t fid, int do_write)
  *-------------------------------------------------------------------------
  */
 
- if (do_write)
+ if (write)
  {
  TESTING2("adding records");
 
  /* create 2 tables */
- if (H5TBmake_table(TITLE,fid,"table4",NFIELDS,NRECORDS,type_size_mem,
+ if (H5TBmake_table(TITLE,fid,"table4",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill,compress,wbuf)<0)
                     goto out;
- if (H5TBmake_table(TITLE,fid,"table5",NFIELDS,NRECORDS,type_size_mem,
+ if (H5TBmake_table(TITLE,fid,"table5",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill,compress,wbuf)<0)
                     goto out;
@@ -771,15 +783,15 @@ test_table(hid_t fid, int do_write)
    if (cmp_par(i,i,rbuf,wbuf)<0)
     goto out;
   }
-  else if ( i < start2+nrecords )
+  else if ( i < (int)start2+(int)nrecords )
   {
-   j = i-start1;
+   j = i-(int)start1;
    if (cmp_par(i,j,rbuf,wbuf)<0)
     goto out;
   }
   else
   {
-   j = i-nrecords;
+   j = i-(int)nrecords;
    if (cmp_par(i,j,rbuf,wbuf)<0)
     goto out;
   }
@@ -798,16 +810,16 @@ test_table(hid_t fid, int do_write)
  *-------------------------------------------------------------------------
  */
 
- if (do_write)
+ if (write)
  {
  TESTING2("combining tables");
 
  /* create 2 tables */
- if (H5TBmake_table(TITLE,fid,"table6",NFIELDS,NRECORDS,type_size_mem,
+ if (H5TBmake_table(TITLE,fid,"table6",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill,compress,wbuf)<0)
                     goto out;
- if (H5TBmake_table(TITLE,fid,"table7",NFIELDS,NRECORDS,type_size_mem,
+ if (H5TBmake_table(TITLE,fid,"table7",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill,compress,wbuf)<0)
                     goto out;
@@ -845,11 +857,11 @@ test_table(hid_t fid, int do_write)
  fid2 = H5Fcreate("combine_tables2.h5",H5F_ACC_TRUNC,H5P_DEFAULT,H5P_DEFAULT);
 
  /* create 2 tables, one in each file */
- if (H5TBmake_table(TITLE,fid1,"table1",NFIELDS,NRECORDS,type_size_mem,
+ if (H5TBmake_table(TITLE,fid1,"table1",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill,compress,wbuf)<0)
                     goto out;
- if (H5TBmake_table(TITLE,fid2,"table2",NFIELDS,NRECORDS,type_size_mem,
+ if (H5TBmake_table(TITLE,fid2,"table2",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill,compress,wbuf)<0)
                     goto out;
@@ -893,12 +905,12 @@ test_table(hid_t fid, int do_write)
  *
  *-------------------------------------------------------------------------
  */
- if (do_write)
+ if (write)
  {
  TESTING2("writing fields by name");
 
  /* make an empty table with fill values */
- if (H5TBmake_table(TITLE,fid,"table9",NFIELDS,NRECORDS,type_size_mem,
+ if (H5TBmake_table(TITLE,fid,"table9",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill1,compress,0)<0)
                     goto out;
@@ -912,7 +924,7 @@ test_table(hid_t fid, int do_write)
 
  /* write the new longitude and latitude information starting at record 2 */
  start    = 2;
- nrecords = NRECORDS_ADD;
+ nrecords = 3;
  if (H5TBwrite_fields_name(fid,"table9","Latitude,Longitude",start,nrecords,sizeof(position_t),
   field_offset_pos,field_sizes_pos,position_in)<0)
   goto out;
@@ -923,23 +935,29 @@ test_table(hid_t fid, int do_write)
  if (H5TBread_table(fid,"table9",type_size_mem,field_offset,field_size,rbuf)<0)
   goto out;
 
- /* compare the read values with the initial values */
- for( u = 0; u < (size_t)NRECORDS; u++ )
- {
-  if ( u >= 2 && u <= 4 )
   {
-    if ( rbuf[u].lati        != position_in[u-(size_t)NRECORDS_ADD+1].lati ||
-         rbuf[u].longi       != position_in[u-(size_t)NRECORDS_ADD+1].longi ||
-         rbuf[u].pressure    != pressure_in[u-(size_t)NRECORDS_ADD+1] )
+   
+   
+   /* compare the read values with the initial values */
+   for( i = 0; i < NRECORDS; i++ )
+   {
+    if ( i >= 2 && i <= 4 )
     {
-     fprintf(stderr,"%ld %f %d\n",
-      rbuf[u].longi,rbuf[u].pressure,rbuf[u].lati);
-     fprintf(stderr,"%ld %f %d\n",
-      position_in[u].longi,pressure_in[u],position_in[u].lati);
+     if ( rbuf[i].lati        != position_in[i-NRECORDS_ADD+1].lati ||
+      rbuf[i].longi       != position_in[i-NRECORDS_ADD+1].longi ||
+      rbuf[i].pressure    != pressure_in[i-NRECORDS_ADD+1] )
+     {
+      fprintf(stderr,"%ld %f %d\n",
+       rbuf[i].longi,rbuf[i].pressure,rbuf[i].lati);
+      fprintf(stderr,"%ld %f %d\n",
+       position_in[i].longi,pressure_in[i],position_in[i].lati);
       goto out;
+     }
     }
+   }
   }
- }
+
+
 
  PASSED();
  } /*write*/
@@ -958,16 +976,16 @@ test_table(hid_t fid, int do_write)
  * write and read the "Pressure" field
  *-------------------------------------------------------------------------
  */
- if (do_write)
+ if (write)
  {
-  if (H5TBmake_table(TITLE,fid,"table10",NFIELDS,NRECORDS,type_size_mem,
+  if (H5TBmake_table(TITLE,fid,"table10",FIELDS,RECORDS,type_size_mem,
    field_names,field_offset,field_type,
    chunk_size,fill1,compress,0)<0)
    goto out;
 
   /* write the pressure field to all the records */
   start    = 0;
-  nrecords = NRECORDS_ADD;
+  nrecords = NRECORDS;
   if ( H5TBwrite_fields_name(fid,"table10","Pressure",start,nrecords,
    sizeof( float ),0,field_sizes_pre,pressure_in)<0)
    goto out;
@@ -975,15 +993,16 @@ test_table(hid_t fid, int do_write)
 
  /* read the "Pressure" field */
  start    = 0;
- nrecords = NRECORDS_ADD;
+ nrecords = NRECORDS;
  if ( H5TBread_fields_name(fid,"table10","Pressure",start,nrecords,
   sizeof(float),0,field_sizes_pre,pressure_out)<0)
   goto out;
 
+
  /* Compare the extracted table with the initial values */
- for( u = 0; u < (size_t)NRECORDS_ADD; u++ )
+ for( i = 0; i < NRECORDS; i++ )
  {
-  if ( pressure_out[u] != pressure_in[u] ) {
+  if ( pressure_out[i] != pressure_in[i] ) {
    goto out;
   }
  }
@@ -992,7 +1011,7 @@ test_table(hid_t fid, int do_write)
  * Write and read the "Latitude,Longitude" fields
  *-------------------------------------------------------------------------
  */
- if (do_write)
+ if (write)
  {
   /* Write the new longitude and latitude information to all the records */
   start    = 0;
@@ -1009,11 +1028,12 @@ test_table(hid_t fid, int do_write)
   start, nrecords, sizeof(position_t), field_offset_pos, field_sizes_pos, position_out ) < 0 )
   goto out;
 
+
  /* Compare the extracted table with the initial values */
- for( u = 0; u < (size_t)NRECORDS_ADD; u++ )
+ for( i = 0; i < NRECORDS_ADD; i++ )
  {
-  if ( position_out[u].lati  != position_in[u].lati ||
-   position_out[u].longi != position_in[u].longi )
+  if ( position_out[i].lati  != position_in[i].lati ||
+   position_out[i].longi != position_in[i].longi )
    goto out;
  }
 
@@ -1022,7 +1042,7 @@ test_table(hid_t fid, int do_write)
  * Write and read the "Name,Pressure" fields
  *-------------------------------------------------------------------------
  */
- if (do_write)
+ if (write)
  {
  /* Write the new name and pressure information to all the records */
  start    = 0;
@@ -1040,19 +1060,21 @@ test_table(hid_t fid, int do_write)
    namepre_out ) < 0 )
   goto out;
 
+
  /* Compare the extracted table with the initial values */
- for( u = 0; u < (size_t)NRECORDS; u++ )
+ for( i = 0; i < NRECORDS; i++ )
  {
-  if ( ( strcmp( namepre_out[u].name,  namepre_in[u].name ) != 0 ) ||
-         namepre_out[u].pressure != namepre_in[u].pressure ) {
+  if ( ( strcmp( namepre_out[i].name,  namepre_in[i].name ) != 0 ) ||
+         namepre_out[i].pressure != namepre_in[i].pressure ) {
    goto out;
   }
  }
+
  /* reset buffer */
- for( u = 0; u < (size_t)NRECORDS; u++ )
+ for( i = 0; i < NRECORDS; i++ )
  {
-  strcpy( namepre_out[u].name,  "\0" );
-  namepre_out[u].pressure = -1;
+  strcpy( namepre_out[i].name,  "\0" );
+  namepre_out[i].pressure = -1;
  }
 
 /*-------------------------------------------------------------------------
@@ -1066,14 +1088,19 @@ test_table(hid_t fid, int do_write)
    field_sizes_namepre, namepre_out ) < 0 )
   goto out;
 
+
  /* Compare the extracted table with the initial values */
- for( u = 0; u < 3; u++ )
+ for( i = 0; i < 3; i++ )
  {
-  if ( ( strcmp( namepre_out[u].name,  namepre_in[(size_t)start+u].name ) != 0 ) ||
-         namepre_out[u].pressure != namepre_in[(size_t)start+u].pressure ) {
+  int iistart = (int) start;
+  if ( ( strcmp( namepre_out[i].name,  namepre_in[iistart+i].name ) != 0 ) ||
+         namepre_out[i].pressure != namepre_in[iistart+i].pressure ) {
    goto out;
   }
  }
+
+ 
+
  PASSED();
 
 /*-------------------------------------------------------------------------
@@ -1084,12 +1111,12 @@ test_table(hid_t fid, int do_write)
  *
  *-------------------------------------------------------------------------
  */
- if (do_write)
+ if (write)
  {
  TESTING2("writing fields by index");
 
  /* make an empty table */
- if (H5TBmake_table(TITLE,fid,"table11",NFIELDS,NRECORDS,type_size_mem,
+ if (H5TBmake_table(TITLE,fid,"table11",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill,compress,NULL)<0)
                     goto out;
@@ -1120,13 +1147,13 @@ test_table(hid_t fid, int do_write)
   goto out;
 
  /* Compare the extracted table with the initial values */
- for( u = 0; u < (size_t)NRECORDS; u++ )
+ for( i = 0; i < NRECORDS; i++ )
  {
-  if ( u >= 2 && u <= 4 )
+  if ( i >= 2 && i <= 4 )
   {
-    if ( rbuf[u].lati        != position_in[u-(size_t)NRECORDS_ADD+1].lati ||
-         rbuf[u].longi       != position_in[u-(size_t)NRECORDS_ADD+1].longi ||
-         rbuf[u].pressure    != pressure_in[u-(size_t)NRECORDS_ADD+1] )
+    if ( rbuf[i].lati        != position_in[i-NRECORDS_ADD+1].lati ||
+         rbuf[i].longi       != position_in[i-NRECORDS_ADD+1].longi ||
+         rbuf[i].pressure    != pressure_in[i-NRECORDS_ADD+1] )
    goto out;
   }
  }
@@ -1146,10 +1173,10 @@ test_table(hid_t fid, int do_write)
 
  TESTING2("reading fields by index");
 
- if (do_write)
+ if (write)
  {
  /* make an empty table */
- if (H5TBmake_table(TITLE,fid,"table12",NFIELDS,NRECORDS,type_size_mem,
+ if (H5TBmake_table(TITLE,fid,"table12",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill,compress,NULL)<0)
                     goto out;
@@ -1177,9 +1204,9 @@ test_table(hid_t fid, int do_write)
   goto out;
 
  /* compare the extracted table with the initial values */
- for( u = 0; u < (size_t)NRECORDS; u++ )
+ for( i = 0; i < NRECORDS; i++ )
  {
-  if ( pressure_out[u] != pressure_in[u] ) {
+  if ( pressure_out[i] != pressure_in[i] ) {
    goto out;
   }
  }
@@ -1188,7 +1215,7 @@ test_table(hid_t fid, int do_write)
  * write and read the "Latitude,Longitude" fields
  *-------------------------------------------------------------------------
  */
- if (do_write)
+ if (write)
  {
  /* write the new longitude and latitude information to all the records */
  nfields = 2;
@@ -1208,10 +1235,10 @@ test_table(hid_t fid, int do_write)
   goto out;
 
  /* compare the extracted table with the initial values */
- for( u = 0; u < (size_t)NRECORDS_ADD; u++ )
+ for( i = 0; i < NRECORDS_ADD; i++ )
  {
-  if ( position_out[u].lati  != position_in[u].lati ||
-       position_out[u].longi != position_in[u].longi ) {
+  if ( position_out[i].lati  != position_in[i].lati ||
+       position_out[i].longi != position_in[i].longi ) {
    goto out;
   }
  }
@@ -1221,7 +1248,7 @@ test_table(hid_t fid, int do_write)
  *-------------------------------------------------------------------------
  */
 
- if (do_write)
+ if (write)
  {
  /* write the new name and pressure information to all the records */
  nfields = 2;
@@ -1242,19 +1269,19 @@ test_table(hid_t fid, int do_write)
   goto out;
 
  /* compare the extracted table with the initial values */
- for( u = 0; u < (size_t)NRECORDS; u++ )
+ for( i = 0; i < NRECORDS; i++ )
  {
-  if ( ( strcmp( namepre_out[u].name,  namepre_in[u].name ) != 0 ) ||
-         namepre_out[u].pressure != namepre_in[u].pressure ) {
+  if ( ( strcmp( namepre_out[i].name,  namepre_in[i].name ) != 0 ) ||
+         namepre_out[i].pressure != namepre_in[i].pressure ) {
    goto out;
   }
  }
 
  /* reset buffer */
- for( u = 0; u < (size_t)NRECORDS; u++ )
+ for( i = 0; i < NRECORDS; i++ )
  {
-  strcpy( namepre_out[u].name,  "\0" );
-  namepre_out[u].pressure = -1;
+  strcpy( namepre_out[i].name,  "\0" );
+  namepre_out[i].pressure = -1;
  }
 
 /*-------------------------------------------------------------------------
@@ -1272,10 +1299,11 @@ test_table(hid_t fid, int do_write)
   goto out;
 
  /* compare the extracted table with the initial values */
- for( u = 0; u < 3; u++ )
+ for( i = 0; i < 3; i++ )
  {
-  if ( ( strcmp( namepre_out[u].name,  wbuf[(size_t)start+u].name ) != 0 ) ||
-   namepre_out[u].pressure != wbuf[(size_t)start+u].pressure ) {
+  int iistart = (int) start;
+  if ( ( strcmp( namepre_out[i].name,  wbuf[iistart+i].name ) != 0 ) ||
+   namepre_out[i].pressure != wbuf[iistart+i].pressure ) {
    goto out;
   }
  }
@@ -1292,12 +1320,12 @@ test_table(hid_t fid, int do_write)
  *-------------------------------------------------------------------------
  */
 
- if (do_write)
+ if (write)
  {
  TESTING2("inserting fields");
 
  /* make a table */
- if (H5TBmake_table(TITLE,fid,"table13",NFIELDS,NRECORDS,type_size_mem,
+ if (H5TBmake_table(TITLE,fid,"table13",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill1,compress,wbuf)<0)
                     goto out;
@@ -1313,14 +1341,14 @@ test_table(hid_t fid, int do_write)
   goto out;
 
  /* compare the extracted table with the original array */
- for( u = 0; u < (size_t)NRECORDS; u++ )
+ for( i = 0; i < NRECORDS; i++ )
  {
-  if ( ( strcmp( rbuf2[u].name,  wbuf[u].name ) != 0 ) ||
-   rbuf2[u].lati          != wbuf[u].lati ||
-   rbuf2[u].longi         != wbuf[u].longi ||
-   rbuf2[u].pressure      != wbuf[u].pressure ||
-   rbuf2[u].temperature   != wbuf[u].temperature ||
-   rbuf2[u].new_field     != buf_new[u] ) {
+  if ( ( strcmp( rbuf2[i].name,  wbuf[i].name ) != 0 ) ||
+   rbuf2[i].lati          != wbuf[i].lati ||
+   rbuf2[i].longi         != wbuf[i].longi ||
+   rbuf2[i].pressure      != wbuf[i].pressure ||
+   rbuf2[i].temperature   != wbuf[i].temperature ||
+   rbuf2[i].new_field     != buf_new[i] ) {
    goto out;
   }
  }
@@ -1336,12 +1364,12 @@ test_table(hid_t fid, int do_write)
  *
  *-------------------------------------------------------------------------
  */
- if (do_write)
+ if (write)
  {
  TESTING2("deleting fields");
 
   /* make a table */
- if (H5TBmake_table(TITLE,fid,"table14",NFIELDS,NRECORDS,type_size_mem,
+ if (H5TBmake_table(TITLE,fid,"table14",FIELDS,RECORDS,type_size_mem,
                     field_names,field_offset,field_type,
                     chunk_size,fill,compress,wbuf)<0)
                     goto out;
@@ -1356,12 +1384,12 @@ test_table(hid_t fid, int do_write)
   goto out;
 
  /* compare the extracted table with the original array */
- for( u = 0; u < (size_t)NRECORDS; u++ )
+ for( i = 0; i < NRECORDS; i++ )
  {
-  if ( ( strcmp( rbuf3[u].name, wbuf[u].name ) != 0 ) ||
-         rbuf3[u].lati != wbuf[u].lati ||
-         rbuf3[u].longi != wbuf[u].longi ||
-         rbuf3[u].temperature != wbuf[u].temperature ) {
+  if ( ( strcmp( rbuf3[i].name, wbuf[i].name ) != 0 ) ||
+         rbuf3[i].lati != wbuf[i].lati ||
+         rbuf3[i].longi != wbuf[i].longi ||
+         rbuf3[i].temperature != wbuf[i].temperature ) {
    goto out;
   }
  }
@@ -1404,26 +1432,26 @@ test_table(hid_t fid, int do_write)
 
  /* alocate */
  names_out = malloc( sizeof(char*) * (size_t)NFIELDS );
- for ( u = 0; u < (size_t)NFIELDS; u++)
+ for ( i = 0; i < NFIELDS; i++)
  {
-  names_out[u] = malloc( sizeof(char) * 255 );
+  names_out[i] = malloc( sizeof(char) * 255 );
  }
 
  /* Get field info */
  if ( H5TBget_field_info(fid, "table1", names_out, sizes_out, offset_out, &size_out ) < 0 )
   goto out;
 
- for ( u = 0; u < (size_t)NFIELDS; u++)
+ for ( i = 0; i < NFIELDS; i++)
  {
-  if ( (strcmp( field_names[u], names_out[u] ) != 0)) {
+  if ( (strcmp( field_names[i], names_out[i] ) != 0)) {
    goto out;
   }
  }
 
  /* release */
- for ( u = 0; u < (size_t)NFIELDS; u++)
+ for ( i = 0; i < NFIELDS; i++)
  {
-  free ( names_out[u] );
+  free ( names_out[i] );
  }
  free ( names_out );
 
@@ -1550,9 +1578,8 @@ static hid_t h5file_open(const char *fname, unsigned flags)
  * function that compares one particle
  *-------------------------------------------------------------------------
  */
-static int cmp_par(hsize_t _i, hsize_t _j, particle_t *rbuf, particle_t *wbuf )
+static int cmp_par(hsize_t i, hsize_t j, particle_t *rbuf, particle_t *wbuf )
 {
-    size_t i = (size_t)_i, j = (size_t)_j;
  if ( ( strcmp( rbuf[i].name, wbuf[j].name ) != 0 ) ||
   rbuf[i].lati != wbuf[j].lati ||
   rbuf[i].longi != wbuf[j].longi ||
@@ -1593,4 +1620,3 @@ static int compare_deleted(hsize_t rrecords, hsize_t dstart, hsize_t drecords,
  return 0;
 }
 
-