Changeset 12781 for trunk/psLib/test/mathtypes

Timestamp:

Apr 10, 2007, 11:09:31 AM (19 years ago)

Author:

gusciora

Message:

This is a fairly large checkin. Most of the files were modified so they have
the same basic structure and format for testing: reporting errors, checking
memory leaks etc. Several bug fixes are included as well.

Location:

trunk/psLib/test/mathtypes

Files:

• tap_psImage.c (modified) (3 diffs)
• tap_psImageInterpolate.c (modified) (1 diff)
• tap_psScalar.c (modified) (2 diffs)
• tap_psVector.c (modified) (29 diffs)
• tap_psVectorSort_01.c (modified) (4 diffs)
• tap_psVectorSort_02.c (modified) (4 diffs)
• tap_psVectorSort_03.c (modified) (2 diffs)
• tap_psVectorSort_04.c (modified) (2 diffs)

trunk/psLib/test/mathtypes/tap_psImage.c

@@ -6 +6 @@
  *  @author Robert DeSonia, MHPCC
  *
- *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
- *  @date $Date: 2007-03-20 03:57:25 $
+ *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
+ *  @date $Date: 2007-04-10 21:09:30 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -16 +16 @@
 #include <string.h>
 #include <stdlib.h>
-
 #include "pslib.h"
 #include "psType.h"
-
 #include "tap.h"
 #include "pstap.h"
 
-
-//static int Okay = 1;
-//static int setOkay( int okay )
-//{
-//    Okay = okay;
-//    return okay;
-//}
 
 #define OK(exp) \
@@ -40 +31 @@
 }
 
-
-
 int main(int argc, char* argv[])
 {
-    plan_tests(383);
-
-    void testImageAlloc(void);
-    testImageAlloc();
-
-    void testRegion(void);
-    testRegion();
-
-    void testRegion2(void);
-    testRegion2();
-
-    void testRegion3(void);
-    testRegion3();
-
-    void testImageInit(void);
-    testImageInit();
-
-    void testImageSet(void);
-    testImageSet();
+    psLogSetFormat("HLNM");
+    psLogSetLevel(PS_LOG_INFO);
+    plan_tests(402);
+
+    // testImageAlloc()
+    {
+        psMemId id = psMemGetId();
+        psImage* image = NULL;
+        psU32 sizes = 6;
+        psU32 numCols[] = {0,1,1,100,100,150};
+        psU32 numRows[] = {0,1,100,1,150,100};
+        psU32 types = 12;
+        psElemType type[] = { PS_TYPE_S8, PS_TYPE_S16, PS_TYPE_S32, PS_TYPE_S64,
+                              PS_TYPE_U8, PS_TYPE_U16, PS_TYPE_U32, PS_TYPE_U64,
+                              PS_TYPE_F32, PS_TYPE_F64 };
+        for (psU32 t=0;t<types;t++) {
+            for (psU32 i=0;i<sizes;i++) {
+                // Following should be an error if numRows[i] == 0 || numCols[i]==0
+                image = psImageAlloc(numCols[i],numRows[i],type[t]);
+                if (image == NULL) {
+                    if (numRows[i] == 0 || numCols[i] == 0) {
+                        continue;
+                    }
+                    ok(0, "psImageAlloc returned NULL for type %x, size %dx%d.",
+                       type[t], numCols[i], numRows[i]);
+                    psFree(image);
+                }
+
+                ok(image->type.dimen==PS_DIMEN_IMAGE && image->type.type==type[t],
+                    "psImageAlloc allocated dimen/type (%d/%d), expecting "
+                    "PS_IMAGE_DIMEN/%d", image->type.dimen,
+                    image->type.type, type[t]);
+                ok(image->numCols == numCols[i] && image->numRows == numRows[i],
+                    "psImageAlloc allocated size %dx%d, expecting be %dx%d "
+                    "(type = %d)", image->numCols, image->numRows, numCols[i],
+                    numRows[i],type[t]);
+                ok(image->col0 == 0 && image->row0 == 0,
+                    "psImageAlloc returned row0/col0 of %d/%d.  Expected 0/0.",
+                    image->row0, image->row0);
+                ok(image->parent == NULL, "psImageAlloc returned NULL parent");
+                ok(image->children == NULL,
+                    "psImageAlloc returned NULL children array");
+
+
+                if (image->children != NULL) {
+                    psFree(image);
+                }
+
+                switch (type[t]) {
+                case PS_TYPE_U16: {
+                        psU32 rows = numRows[i];
+                        psU32 cols = numCols[i];
+    
+                        for (psS32 r=0;r<rows;r++) {
+                            for (psS32 c=0;c<cols;c++) {
+                                image->data.U16[r][c] = 2*c+r;
+                            }
+                        }
+                        bool errorFlag = false;
+                        for (psS32 r=0;r<rows;r++) {
+                            for (psS32 c=0;c<cols;c++) {
+                                if (image->data.U16[r][c] != 2*c+r) {
+                                    errorFlag = true;
+                                }
+                            }
+                        }
+                        ok(!errorFlag, "psImageAlloc() set data correctly (U16)");
+                    }
+                    break;
+                case PS_TYPE_F32: {
+                        psU32 rows = numRows[i];
+                        psU32 cols = numCols[i];
+    
+                        for (psS32 r=0;r<rows;r++) {
+                            for (psS32 c=0;c<cols;c++) {
+                                image->data.F32[r][c] = 2.0f*c+r;
+                            }
+                        }
+                        bool errorFlag = false;
+                        for (psS32 r=0;r<rows;r++) {
+                            for (psS32 c=0;c<cols;c++) {
+                                if (fabsf(image->data.F32[r][c] - (2.0f*c+r)) > FLT_EPSILON) {
+                                    errorFlag = true;
+                                }
+                            }
+                        }
+                        ok(!errorFlag, "psImageAlloc() set data correctly (F32)");
+                    }
+                    break;
+                case PS_TYPE_F64: {
+                        psU32 rows = numRows[i];
+                        psU32 cols = numCols[i];
+    
+                        for (psS32 r=0;r<rows;r++) {
+                            for (psS32 c=0;c<cols;c++) {
+                                image->data.F64[r][c] = 2.0f*c+r;
+                            }
+                        }
+                        bool errorFlag = false;
+                        for (psS32 r=0;r<rows;r++) {
+                            for (psS32 c=0;c<cols;c++) {
+                                if (fabs(image->data.F64[r][c] - (2.0f*c+r)) > DBL_EPSILON) {
+                                    errorFlag = true;
+                                }
+                            }
+                        }
+                        ok(!errorFlag, "psImageAlloc() set data correctly (F64)");
+                    }
+                    break;
+                default: {
+                        // ignore type and just use as byte bucket.
+                        psU32 rows = numRows[i];
+                        psU32 cols = numCols[i]*PSELEMTYPE_SIZEOF(type[t]);
+    
+                        for (psS32 r=0;r<rows;r++) {
+                            for (psS32 c=0;c<cols;c++) {
+                                image->data.U8[r][c] = (uint8_t)(r + c);
+                            }
+                        }
+                        bool errorFlag = false;
+                        for (psS32 r=0;r<rows;r++) {
+                            for (psS32 c=0;c<cols;c++) {
+                                if (image->data.U8[r][c] != (uint8_t)(r + c)) {
+                                    errorFlag = true;
+                                }
+                            }
+                        }
+                        ok(!errorFlag, "psImageAlloc() set data correctly (default)");
+                    }
+                }
+                psFree(image);
+            }
+        }
+
+        // #548: Verify no memory leaks or corruption are detected after a valid psImage structure with multiple
+        // children is freed.
+        image = psImageAlloc(100,100,PS_TYPE_F32);
+        psImageSubset(image,(psRegion) {50,0,70,20});
+        psImageSubset(image,(psRegion) {70,20,90,40});
+        psFree(image);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // testRegion()
+    {
+        psMemId id = psMemGetId();
+        psRegion region = psRegionSet(1,2,3,4);
+        char *tmpStr = psRegionToString(region);
+        ok(!(region.x0 != 1 || region.x1 != 2 || region.y0 != 3 || region.y1 != 4),
+            "The region attributes are set to (%s)", tmpStr);
+        psFree(tmpStr);
+        region = psRegionFromString("[1:2,3:4]");
+        tmpStr = psRegionToString(region);
+        ok(!(region.x0 != 0 || region.x1 != 2 || region.y0 != 2 || region.y1 != 4),
+            "The region attributes are set to (%s)", tmpStr);
+        psFree(tmpStr);
+        region = psRegionFromString("[1:2,3:]");
+        ok(isnan(region.x0),
+            "psRegionFromString returned a NULL pointer given a malformed string.");
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    //psRegionForImage
+    {
+        psMemId id = psMemGetId();
+        psImage *in;
+        psRegion inReg;
+        psRegion out;
+        in = psImageAlloc(1, 1, PS_TYPE_S32);
+        inReg = psRegionSet(1, 2, 1, 2);
+        out = psRegionForImage(in,inReg);
+        psRegion inReg2;
+        psRegion out2;
+        inReg2 = psRegionSet(-1, 0, -2, -1);
+        out2 = psRegionForImage(in, inReg2);
+    
+        ok(!( out.x0 != 1 || out.x1 != 1 || out.y0 != 1 || out.y1 != 1 ),
+           "Region For Image returned correct values");
+    
+        ok(!( out2.x0 != 0 || out2.x1 != 1 || out2.y0 != 0 || out2.y1 != 0 ),
+           "Region For Image returned correct values");
+        psFree(in);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    //psRegionForSquare//
+    {
+        psMemId id = psMemGetId();
+        float X = 1;
+        float Y = 1;
+        float RAD = 1;
+        psRegion out;
+        out = psRegionForSquare(X, Y, RAD);
+        ok(!(out.x0 != 0 || out.x1 != 3 || out.y0 != 0 || out.y1!= 3),
+            "Region For Square returned correct values");
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    //Initialize an image with a given value.//
+    {
+        psMemId id = psMemGetId();
+        psImage *in1 = NULL;
+        psImage *in2 = NULL;
+        psImage *in3 = NULL;
+        psImage *in4 = NULL;
+        int nRow = 1;
+        int nCol = 1;
+        in1 = psImageAlloc(nRow, nCol, PS_TYPE_U8);
+        ok(psImageInit(in1, 5 ),
+             "ImageAlloc.  U8 Case - 1x1");
+        nRow = 5;
+        in2 = psImageAlloc(nRow, nCol, PS_TYPE_F32);
+        ok(psImageInit(in2, 3),
+             "ImageAlloc.  F32 Case - 5x1");
+    
+        nCol = 5;
+        in3 = psImageAlloc(nRow, nCol, PS_TYPE_F64);
+        ok(psImageInit(in3, 3.14),
+             "ImageAlloc.  F64 Case - 5x5");
+    
+        in4 = psImageAlloc(nRow, nCol, PS_TYPE_S32);
+        ok(psImageInit(in4, 3),
+             "ImageAlloc.  S32 Case - 5x5");
+        psFree(in1);
+        psFree(in2);
+        psFree(in3);
+        psFree(in4);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // testImageSet()
+    {
+        psMemId id = psMemGetId();
+        psImage *image = NULL;
+        image = psImageAlloc(5, 4, PS_TYPE_S32);
+
+        //Set the position of the subimage relative to the parent.
+        image->col0 = 10;
+        image->row0 = 10;
+        for (int i = 0; i < 4; i++) {
+            for (int j = 0; j < 5; j++) {
+                image->data.S32[i][j] = i+j;
+            }
+        }
+
+        //Attempt to set a position in a NULL psImage*
+        psImage *none = NULL;
+        ok(! psImageSet(none, 1, 1, 1),
+            "psImageSet returned non-null");
+
+        //Attempt to set a position in a psImage* with negative numCols, numRows
+        none = psImageAlloc(2, 2, PS_TYPE_S32);
+        *(int*)&none->numCols = -1;
+        ok(! psImageSet(none, 1, 1, 1),
+            "psImageSet return false when passed an image with negative numCols");
+
+        *(int*)&none->numCols = 2;
+        *(int*)&none->numRows = -1;
+        ok(!psImageSet(none, 1, 1, 1),
+             "psImageSet failed to return false when passed an image with negative numRows");
+
+        //Attempt to set a position in a psImage* with negative col0, row0
+        *(int*)&none->numRows = 2;
+        none->row0 = -1;
+        ok(!psImageSet(none, 1, 1, 1),
+             "psImageSet failed to return false when passed an image with negative col0");
+
+        none->row0 = 0;
+        none->col0 = -1;
+        ok(!psImageSet(none, 1, 1, 1),
+             "psImageSet failed to return false when passed an image with negative col0");
+        psFree(none);
+
+        //Try to set a position inside of the subimage.
+        ok(psImageSet(image, 14, 12, 666),
+             "psImageSet failed to return true when passed valid parameters");
+
+        ok(image->data.S32[2][4] == 666,
+            "psImageSet set the data value. value=%d", image->data.S32[2][4]);
+
+        //Try to set a position inside of the subimage from the tail.
+        ok(psImageSet(image, -1, -1, 666),
+             "psImageSet return true when passed valid parameters");
+
+        ok(image->data.S32[3][4] == 666,
+            "psImageSet set (from the tail) the data values correctly");
+
+        //Try to set a position outside of the subimage but inside of the parent image.
+        ok(!psImageSet(image, 0, 0, 666),
+             "psImageSet return false when passed an invalid location");
+
+        ok(!psImageSet(image, 9, 10, 666),
+             "psImageSet return false when passed an invalid location");
+
+        //Try to set a position outside of the subimage.
+        ok(!psImageSet(image, 15, 14, 666),
+             "psImageSet return false when passed an invalid location");
+
+        //Try to set a position outside of the subimage, indexing from the tail.
+        ok(!psImageSet(image, -6, -1, 666),
+             "psImageSet return false when passed an invalid location");
+        psFree(image);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // testImageGet()
+    {
+        psMemId id = psMemGetId();
+        psImage *image = NULL;
+        image = psImageAlloc(5, 3, PS_TYPE_S32);
+
+        //Set the position of the subimage relative to the parent.
+        image->col0 = 10;
+        image->row0 = 10;
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 5; j++) {
+                image->data.S32[i][j] = i+j;
+            }
+        }
+    
+        //Attempt to get a position in a NULL psImage*
+        psImage *none = NULL;
+        ok(isnan( psImageGet(none, 1, 1) ),
+             "psImageGet return false when passed a NULL image");
+    
+        //Attempt to get a position in a psImage* with negative numCols, numRows
+        none = psImageAlloc(2, 2, PS_TYPE_S32);
+        *(int*)&none->numCols = -1;
+        ok(isnan( psImageGet(none, 1, 1) ),
+             "psImageGet return false when passed an image with negative numCols");
+    
+        *(int*)&none->numCols = 2;
+        *(int*)&none->numRows = -1;
+        ok(isnan( psImageGet(none, 1, 1) ),
+             "psImageGet return false when passed an image with negative numRows");
+    
+        //Attempt to get a position in a psImage* with negative col0, row0
+        *(int*)&none->numRows = 2;
+        none->row0 = -1;
+        ok(isnan( psImageGet(none, 1, 1) ),
+             "psImageGet return false when passed an image with negative col0");
+    
+        none->row0 = 0;
+        none->col0 = -1;
+        ok(isnan( psImageGet(none, 1, 1) ),
+             "psImageGet return false when passed an image with negative col0");
+    
+        psFree(none);
+    
+    
+        //Try to get a position inside of the subimage.
+        ok(psImageGet(image, 14, 12) == 6,
+             "psImageGet return the correct value");
+    
+        //Try to get a position inside of the subimage from the tail.
+        ok(psImageGet(image, -1, -1) == 6,
+             "psImageGet return the correct value");
+    
+        //Try to get a position outside of the subimage but inside of the parent image.
+        ok(isnan( psImageGet(image, 1, 1) ),
+             "psImageGet return NAN when passed an invalid location");
+    
+        ok(isnan( psImageGet(image, 9, 10) ),
+             "psImageGet return NAN when passed an invalid location");
+    
+        //Try to set a position outside of the subimage.
+        ok(isnan( psImageGet(image, 15, 14) ),
+             "psImageGet return NAN when passed an invalid location");
+    
+        //Try to set a position outside of the subimage, indexing from the tail.
+        ok(isnan( psImageGet(image, -6, -1) ),
+             "psImageGet failed to return NAN when passed an invalid location");
+        psFree(image);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 }
-
-
-void testImageAlloc()
-{
-//    diag("testImageAlloc");
-
-    psImage* image = NULL;
-    psU32 sizes = 6;
-    psU32 numCols[] = {
-                          0,1,1,100,100,150
-                      };
-    psU32 numRows[] = {
-                          0,1,100,1,150,100
-                      };
-    psU32 types = 12;
-    psElemType type[] = { PS_TYPE_S8, PS_TYPE_S16, PS_TYPE_S32, PS_TYPE_S64,
-                          PS_TYPE_U8, PS_TYPE_U16, PS_TYPE_U32, PS_TYPE_U64,
-                          PS_TYPE_F32, PS_TYPE_F64 };
-
-    for (psU32 t=0;t<types;t++) {
-
-        for (psU32 i=0;i<sizes;i++) {
-
-            // Following should be an error if numRows[i] == 0 || numCols[i]==0
-
-            image = psImageAlloc(numCols[i],numRows[i],type[t]);
-
-            if (image == NULL) {
-                if (numRows[i] == 0 || numCols[i] == 0) {
-                    continue;
-                }
-                ok(0, "psImageAlloc returned NULL for type %x, size %dx%d.",
-                   type[t], numCols[i], numRows[i]);
-                psFree(image);
-                return;
-            }
-
-            ok (image->type.dimen==PS_DIMEN_IMAGE && image->type.type==type[t],
-                "psImageAlloc allocated dimen/type (%d/%d), expecting "
-                "PS_IMAGE_DIMEN/%d", image->type.dimen,
-                image->type.type, type[t]);
-            skip_start (!(image->type.dimen==PS_DIMEN_IMAGE && image->type.type==type[t]),
-                        4, "psImageAlloc allocated wrong dimen/type");
-
-            ok (image->numCols == numCols[i] && image->numRows == numRows[i],
-                "psImageAlloc allocated size %dx%d, expecting be %dx%d "
-                "(type = %d)", image->numCols, image->numRows, numCols[i],
-                numRows[i],type[t]);
-            skip_start (!(image->numCols == numCols[i] && image->numRows == numRows[i]),
-                        3, "psImageAlloc allocated wrong size");
-
-            ok (image->col0 == 0 && image->row0 == 0,
-                "psImageAlloc returned row0/col0 of %d/%d.  Expected 0/0.",
-                image->row0, image->row0);
-            skip_start (!(image->col0 == 0 && image->row0 == 0),
-                        2, "psImageAlloc returned wrong row0/col0");
-
-            ok (image->parent == NULL, "psImageAlloc returned NULL parent");
-            skip_start (image->parent != NULL,
-                        1, "psImageAlloc returned NULL parent");
-
-            ok (image->children == NULL,
-                "psImageAlloc returned NULL children array");
-
-            skip_end();
-            skip_end();
-            skip_end();
-            skip_end();
-
-            if (image->children != NULL) {
-                psFree(image);
-                return;
-            }
-
-            switch (type[t]) {
-            case PS_TYPE_U16: {
-                    psU32 rows = numRows[i];
-                    psU32 cols = numCols[i];
-
-                    for (psS32 r=0;r<rows;r++) {
-                        for (psS32 c=0;c<cols;c++) {
-                            image->data.U16[r][c] = 2*c+r;
-                        }
-                    }
-                    bool errorFlag = false;
-                    for (psS32 r=0;r<rows;r++) {
-                        for (psS32 c=0;c<cols;c++) {
-                            if (image->data.U16[r][c] != 2*c+r) {
-//                                diag("ERROR: Could not set all pixels in uint16 image at (%d,%d)",c,r);
-                                errorFlag = true;
-                            }
-                        }
-                    }
-                    ok(!errorFlag, "psImageAlloc() set data correctly (U16)");
-                }
-                break;
-            case PS_TYPE_F32: {
-                    psU32 rows = numRows[i];
-                    psU32 cols = numCols[i];
-
-                    for (psS32 r=0;r<rows;r++) {
-                        for (psS32 c=0;c<cols;c++) {
-                            image->data.F32[r][c] = 2.0f*c+r;
-                        }
-                    }
-                    bool errorFlag = false;
-                    for (psS32 r=0;r<rows;r++) {
-                        for (psS32 c=0;c<cols;c++) {
-                            if (fabsf(image->data.F32[r][c] - (2.0f*c+r)) > FLT_EPSILON) {
-//                                diag("Could not set all pixels in float image at (%d,%d)",c,r);
-                                errorFlag = true;
-                            }
-                        }
-                    }
-                    ok(!errorFlag, "psImageAlloc() set data correctly (F32)");
-                }
-                break;
-            case PS_TYPE_F64: {
-                    psU32 rows = numRows[i];
-                    psU32 cols = numCols[i];
-
-                    for (psS32 r=0;r<rows;r++) {
-                        for (psS32 c=0;c<cols;c++) {
-                            image->data.F64[r][c] = 2.0f*c+r;
-                        }
-                    }
-                    bool errorFlag = false;
-                    for (psS32 r=0;r<rows;r++) {
-                        for (psS32 c=0;c<cols;c++) {
-                            if (fabs(image->data.F64[r][c] - (2.0f*c+r)) > DBL_EPSILON) {
-//                                diag("Set all pixels in double image at (%d,%d)",c,r);
-                                errorFlag = true;
-                            }
-                        }
-                    }
-                    ok(!errorFlag, "psImageAlloc() set data correctly (F64)");
-                }
-                break;
-            default: {
-                    // ignore type and just use as byte bucket.
-                    psU32 rows = numRows[i];
-                    psU32 cols = numCols[i]*PSELEMTYPE_SIZEOF(type[t]);
-
-                    for (psS32 r=0;r<rows;r++) {
-                        for (psS32 c=0;c<cols;c++) {
-                            image->data.U8[r][c] = (uint8_t)(r + c);
-                        }
-                    }
-                    bool errorFlag = false;
-                    for (psS32 r=0;r<rows;r++) {
-                        for (psS32 c=0;c<cols;c++) {
-                            if (image->data.U8[r][c] != (uint8_t)(r + c)) {
-//                                diag("Set all pixels in image (type=%d) at (%d,%d)", type[t],c,r);
-                                errorFlag = true;
-                            }
-                        }
-                    }
-                    ok(!errorFlag, "psImageAlloc() set data correctly (default)");
-                }
-            }
-            psFree(image);
-        }
-    }
-
-    // #548: Verify no memory leaks or corruption are detected after a valid psImage structure with multiple
-    // children is freed.
-    image = psImageAlloc(100,100,PS_TYPE_F32);
-    psImageSubset(image,(psRegion) {
-                      50,0,70,20
-                  }
-                 );
-    psImageSubset(image,(psRegion) {
-                      70,20,90,40
-                  }
-                 );
-
-    psFree(image);
-}
-
-
-
-void testRegion()
-{
-    // Testpoint #790
-
-//    diag("testRegion");
-
-    psRegion region = psRegionSet(1,2,3,4);
-    ok (!(region.x0 != 1 || region.x1 != 2 || region.y0 != 3 || region.y1 != 4),
-        "The region attributes are set to (%s)", psRegionToString(region));
-
-    // Testpoint #791
-
-    region = psRegionFromString("[1:2,3:4]");
-    ok (!(region.x0 != 0 || region.x1 != 2 || region.y0 != 2 || region.y1 != 4),
-        "The region attributes are set to (%s)", psRegionToString(region));
-
-    region = psRegionFromString("[1:2,3:]");
-    ok (isnan(region.x0),
-        "psRegionFromString returned a NULL pointer given a malformed string.");
-}
-
-
-//psRegionForImage//
-void testRegion2()
-{
-//    diag("testRegion2");
-
-    psImage *in;
-    psRegion inReg;
-    psRegion out;
-    in = psImageAlloc(1, 1, PS_TYPE_S32);
-    inReg = psRegionSet(1, 2, 1, 2);
-    out = psRegionForImage(in,inReg);
-    psRegion inReg2;
-    psRegion out2;
-    inReg2 = psRegionSet(-1, 0, -2, -1);
-    out2 = psRegionForImage(in, inReg2);
-
-    ok(!( out.x0 != 1 || out.x1 != 1 || out.y0 != 1 || out.y1 != 1 ),
-       "Region For Image returned correct values.\n");
-
-    ok(!( out2.x0 != 0 || out2.x1 != 1 || out2.y0 != 0 || out2.y1 != 0 ),
-       "Region For Image returned correct values.\n");
-
-    psFree(in);
-}
-
-
-//psRegionForSquare//
-void testRegion3()
-{
-//    diag("testRegion3");
-
-    float X = 1;
-    float Y = 1;
-    float RAD = 1;
-    psRegion out;
-    out = psRegionForSquare(X, Y, RAD);
-    ok (!(out.x0 != 0 || out.x1 != 3 || out.y0 != 0 || out.y1!= 3),
-        "Region For Square returned correct values.\n");
-}
-
-
-//Initialize an image with a given value.//
-void testImageInit()
-{
-//    diag("testImageInit");
-
-    psImage *in1 = NULL;
-    psImage *in2 = NULL;
-    psImage *in3 = NULL;
-    psImage *in4 = NULL;
-    int nRow = 1;
-    int nCol = 1;
-    in1 = psImageAlloc(nRow, nCol, PS_TYPE_U8);
-    ok ( psImageInit(in1, 5 ),
-         "ImageAlloc.  U8 Case - 1x1\n");
-    nRow = 5;
-    in2 = psImageAlloc(nRow, nCol, PS_TYPE_F32);
-    ok ( psImageInit(in2, 3),
-         "ImageAlloc.  F32 Case - 5x1\n");
-
-    nCol = 5;
-    in3 = psImageAlloc(nRow, nCol, PS_TYPE_F64);
-    ok ( psImageInit(in3, 3.14),
-         "ImageAlloc.  F64 Case - 5x5\n");
-
-    in4 = psImageAlloc(nRow, nCol, PS_TYPE_S32);
-    ok ( psImageInit(in4, 3),
-         "ImageAlloc.  S32 Case - 5x5\n");
-
-    psFree(in1);
-    psFree(in2);
-    psFree(in3);
-    psFree(in4);
-}
-
-
-void testImageSet()
-{
-//    diag("testImageSet");
-
-    psImage *image = NULL;
-    image = psImageAlloc(5, 4, PS_TYPE_S32);
-
-    //Set the position of the subimage relative to the parent.
-    image->col0 = 10;
-    image->row0 = 10;
-    for (int i = 0; i < 4; i++) {
-        for (int j = 0; j < 5; j++) {
-            image->data.S32[i][j] = i+j;
-        }
-    }
-
-    //Attempt to set a position in a NULL psImage*
-    psImage *none = NULL;
-    ok (! psImageSet(none, 1, 1, 1),
-        "psImageSet returned non-null.\n");
-    skip_start ( psImageSet(none, 1, 1, 1),
-                 12, "psImageSet failed");
-
-    //Attempt to set a position in a psImage* with negative numCols, numRows
-    none = psImageAlloc(2, 2, PS_TYPE_S32);
-    *(int*)&none->numCols = -1;
-    ok (! psImageSet(none, 1, 1, 1),
-        "psImageSet return false when passed an image with negative numCols");
-    skip_start ( psImageSet(none, 1, 1, 1),
-                 11,"psImageSet return true when passed an image with negative numCols");
-
-    *(int*)&none->numCols = 2;
-    *(int*)&none->numRows = -1;
-    ok ( !psImageSet(none, 1, 1, 1),
-         "psImageSet failed to return false when passed an image with negative numRows.\n");
-    skip_start ( psImageSet(none, 1, 1, 1),
-                 10,"psImageSet return true when passed an image with negative numRows.");
-
-    //Attempt to set a position in a psImage* with negative col0, row0
-    *(int*)&none->numRows = 2;
-    none->row0 = -1;
-    ok ( !psImageSet(none, 1, 1, 1),
-         "psImageSet failed to return false when passed an image with negative col0.\n");
-    skip_start ( psImageSet(none, 1, 1, 1),
-                 9,"psImageSet return true when passed an image with negative col0.\n");
-
-    none->row0 = 0;
-    none->col0 = -1;
-    ok ( !psImageSet(none, 1, 1, 1),
-         "psImageSet failed to return false when passed an image with negative col0.\n");
-    skip_start ( psImageSet(none, 1, 1, 1),
-                 8,"psImageSet return true when passed an image with negative col0.\n");
-
-    psFree(none);
-
-    //Try to set a position inside of the subimage.
-    ok ( psImageSet(image, 14, 12, 666),
-         "psImageSet failed to return true when passed valid parameters.\n");
-    skip_start ( !psImageSet(image, 14, 12, 666),
-                 7,"psImageSet failed to return true when passed valid parameters.\n");
-
-    ok (image->data.S32[2][4] == 666,
-        "psImageSet set the data value. value=%d\n", image->data.S32[2][4]);
-    skip_start (image->data.S32[2][4] != 666,
-                6,"psImageSet set the data value. value=%d\n", image->data.S32[2][4]);
-
-    //Try to set a position inside of the subimage from the tail.
-    ok ( psImageSet(image, -1, -1, 666),
-         "psImageSet return true when passed valid parameters.\n");
-    skip_start ( !psImageSet(image, -1, -1, 666),
-                 5,"psImageSet failed to return true when passed valid parameters.\n");
-
-    ok (image->data.S32[3][4] == 666,
-        "psImageSet set (from the tail) the data values correctly.\n");
-    skip_start (image->data.S32[3][4] != 666,
-                4,"psImageSet set (from the tail) the data values incorrectly.\n");
-
-
-    //Try to set a position outside of the subimage but inside of the parent image.
-    ok ( !psImageSet(image, 0, 0, 666),
-         "psImageSet return false when passed an invalid location.\n");
-    skip_start ( psImageSet(image, 0, 0, 666),
-                 3,"psImageSet failed to return false when passed an invalid location");
-
-    ok ( !psImageSet(image, 9, 10, 666),
-         "psImageSet return false when passed an invalid location.\n");
-    skip_start ( psImageSet(image, 9, 10, 666),
-                 2,"psImageSet return false when passed an invalid location.\n");
-
-    //Try to set a position outside of the subimage.
-    ok ( !psImageSet(image, 15, 14, 666),
-         "psImageSet return false when passed an invalid location.\n");
-    skip_start ( psImageSet(image, 15, 14, 666),
-                 1,"psImageSet failed to return false when passed an invalid location");
-
-    //Try to set a position outside of the subimage, indexing from the tail.
-    ok ( !psImageSet(image, -6, -1, 666),
-         "psImageSet return false when passed an invalid location.\n");
-
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-
-    psFree(image);
-}
-
-
-void testImageGet()
-{
-//    diag("testImageGet");
-
-    psImage *image = NULL;
-    image = psImageAlloc(5, 3, PS_TYPE_S32);
-
-    //Set the position of the subimage relative to the parent.
-    image->col0 = 10;
-    image->row0 = 10;
-    for (int i = 0; i < 3; i++) {
-        for (int j = 0; j < 5; j++) {
-            image->data.S32[i][j] = i+j;
-        }
-    }
-
-    //Attempt to get a position in a NULL psImage*
-    psImage *none = NULL;
-    ok ( isnan( psImageGet(none, 1, 1) ),
-         "psImageGet return false when passed a NULL image.\n");
-    skip_start ( !isnan( psImageGet(none, 1, 1) ),
-                 10,"psImageGet failed to return false when passed a NULL image.\n");
-
-    //Attempt to get a position in a psImage* with negative numCols, numRows
-    none = psImageAlloc(2, 2, PS_TYPE_S32);
-    *(int*)&none->numCols = -1;
-    ok ( isnan( psImageGet(none, 1, 1) ),
-         "psImageGet return false when passed an image with negative numCols");
-    skip_start ( !isnan( psImageGet(none, 1, 1) ),
-                 9,"psImageGet return true when passed an image with negative numCols");
-
-    *(int*)&none->numCols = 2;
-    *(int*)&none->numRows = -1;
-    ok ( isnan( psImageGet(none, 1, 1) ),
-         "psImageGet return false when passed an image with negative numRows");
-    skip_start ( !isnan( psImageGet(none, 1, 1) ),
-                 8,"psImageGet failed to return false when passed an image with negative numRows.\n");
-
-    //Attempt to get a position in a psImage* with negative col0, row0
-    *(int*)&none->numRows = 2;
-    none->row0 = -1;
-    ok ( isnan( psImageGet(none, 1, 1) ),
-         "psImageGet return false when passed an image with negative col0.\n");
-    skip_start ( !isnan( psImageGet(none, 1, 1) ),
-                 7,"psImageGet return false when passed an image with negative col0.\n");
-
-    none->row0 = 0;
-    none->col0 = -1;
-    ok ( isnan( psImageGet(none, 1, 1) ),
-         "psImageGet return false when passed an image with negative col0.\n");
-    skip_start ( !isnan( psImageGet(none, 1, 1) ),
-                 6,"psImageGet failed to return false when passed an image with negative col0.\n");
-
-    psFree(none);
-
-
-    //Try to get a position inside of the subimage.
-    ok ( psImageGet(image, 14, 12) == 6,
-         "psImageGet return the correct value.\n");
-    skip_start ( psImageGet(image, 14, 12) != 6,
-                 5,"psImageGet failed to return the correct value.\n");
-
-    //Try to get a position inside of the subimage from the tail.
-    ok ( psImageGet(image, -1, -1) == 6,
-         "psImageGet return the correct value.\n");
-    skip_start ( psImageGet(image, -1, -1) == 6,
-                 4, "psImageGet failed to return the correct value.\n");
-
-    //Try to get a position outside of the subimage but inside of the parent image.
-    ok ( isnan( psImageGet(image, 1, 1) ),
-         "psImageGet return NAN when passed an invalid location.\n");
-    skip_start ( !isnan( psImageGet(image, 1, 1) ),
-                 3, "psImageGet didn't return NAN when passed an invalid location.\n");
-
-    ok ( isnan( psImageGet(image, 9, 10) ),
-         "psImageGet return NAN when passed an invalid location.\n");
-    skip_start ( ! isnan( psImageGet(image, 9, 10) ),
-                 2,"psImageGet failed to return NAN when passed an invalid location.\n");
-
-    //Try to set a position outside of the subimage.
-    ok ( isnan( psImageGet(image, 15, 14) ),
-         "psImageGet return NAN when passed an invalid location.\n");
-    skip_start ( !isnan( psImageGet(image, 15, 14) ),
-                 1, "psImageGet didn't return NAN when passed an invalid location.\n");
-
-    //Try to set a position outside of the subimage, indexing from the tail.
-    ok ( isnan( psImageGet(image, -6, -1) ),
-         "psImageGet failed to return NAN when passed an invalid location.\n");
-
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-    skip_end();
-
-
-    psFree(image);
-}

trunk/psLib/test/mathtypes/tap_psImageInterpolate.c

@@ -8 +8 @@
 int main (void)
 {
-    plan_tests(88);
-
-//    diag("psImageInterpolate() tests");
+    psLogSetFormat("HLNM");
+    psLogSetLevel(PS_LOG_INFO);
+    plan_tests(47);
 
     // very simple tests: no mask, bilinear mode, xramp image only
     {
         psMemId id = psMemGetId();
-
-//        diag ("interpolate a delta function");
-
-        // generate simple image (x ramp)
-        psImage *image = psImageAlloc(32, 32, PS_TYPE_F64);
-        ok(image != NULL, "psImage successfully allocated");
-        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
-
-        psImageInit(image, 0.0);
-        image->data.F64[10][10] = 1;
-
-        // center of pixels is 0.5, 0.5
-        double value;
-
-        psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BILINEAR,
-                                                                           image, NULL, NULL, 0, 0.0, 0.0,
-                                                                           0, 0, 0.0);
-        ok(interp, "Interpolation options set");
-
-        ok(psImageInterpolate(&value, NULL, NULL, 10.5, 10.5, interp), "Interpolation");
-        is_double (value, 1.0, "pixel center value - %f", value);
-
-//        diag ("why do I need to have tolerances of 4epsilon or so??");
-
-        ok(psImageInterpolate(&value, NULL, NULL, 10.9, 10.5, interp), "Interpolation");
-        is_double_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 10.5, 10.9, interp), "Interpolation");
-        is_double_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 10.1, 10.5, interp), "Interpolation");
-        is_double_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value);
-
-        psFree(interp);
-
-        skip_end();
-
-        psFree(image);
-        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
-    }
+        // generate simple image (x ramp)
+        psImage *image = psImageAlloc(32, 32, PS_TYPE_F32);
+        ok(image != NULL, "psImage successfully allocated");
+        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
+
+        image->data.F32[10][10] = 1;
+
+        // center of pixels is 0.5, 0.5
+        float value;
+
+        value = psImagePixelInterpolate (image, 10.5, 10.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 1.0, "pixel center value - %f", value);
+
+        value = psImagePixelInterpolate (image, 10.9, 10.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value);
+
+        value = psImagePixelInterpolate (image, 10.5, 10.9, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value);
+
+        value = psImagePixelInterpolate (image, 10.1, 10.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value);
+
+        skip_end();
+
+        psFree(image);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     // very simple tests: no mask, bilinear mode, xramp image only
     {
         psMemId id = psMemGetId();
-
-//        diag ("interpolate an x-ramp");
-
-        // generate simple image (x ramp)
-        psImage *image = psImageAlloc(32, 32, PS_TYPE_F64);
-        ok(image != NULL, "psImage successfully allocated");
-        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
-
-        for (int j = 0; j < image->numRows; j++) {
-            for (int i = 0; i < image->numCols; i++) {
-                image->data.F64[j][i] = i + 0.5;
-            }
-        }
-
-        // center of pixels is 0.5, 0.5
-        double value;
-
-        psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BILINEAR,
-                                                                           image, NULL, NULL, 0, 0.0, 0.0,
-                                                                           0, 0, 0.0);
-        ok(interp, "Interpolation options set");
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation");
-        is_double_tol (value, 2.5, 5.0e-8, "pixel center value - %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.5, interp), "Interpolation");
-        is_double_tol (value, 2.2, 5.0e-8, "coord: 2.2, 2.5, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.5, interp), "Interpolation");
-        is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.2, interp), "Interpolation");
-        is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation");
-        is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 0.8, 2.8, interp), "Interpolation");
-        is_double_tol (value, 0.8, 5.0e-8, "coord: 0.8, value: %f", value);
+        // generate simple image (x ramp)
+        psImage *image = psImageAlloc(32, 32, PS_TYPE_F32);
+        ok(image != NULL, "psImage successfully allocated");
+        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
+
+        for (int j = 0; j < image->numRows; j++)
+        {
+            for (int i = 0; i < image->numCols; i++) {
+                image->data.F32[j][i] = i + 0.5;
+            }
+        }
+
+        // center of pixels is 0.5, 0.5
+        float value;
+
+        value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 2.5, "pixel center value - %f", value);
+
+        value = psImagePixelInterpolate (image, 2.2, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.8, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 2.8, "coord: 2.8, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.8, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 2.8, "coord: 2.8, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 2.8, "coord: 2.8, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 0.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 0.8, "coord: 0.8, value: %f", value);
 
         // no extrapolation
-        ok(psImageInterpolate(&value, NULL, NULL, 0.3, 2.8, interp), "Interpolation");
-        is_double (value, 0.0, "coord: 0.3, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, -0.2, 2.8, interp), "Interpolation");
-        is_double (value, 0.0, "coord: -0.2, value: %f", value);
-
-        psFree(interp);
-
-        skip_end();
-
-        psFree(image);
-        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
-    }
+        value = psImagePixelInterpolate (image, 0.3, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 0.5, "coord: 0.3, value: %f", value);
+
+        value = psImagePixelInterpolate (image, -0.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 0.5, "coord: -0.2, value: %f", value);
+
+        skip_end();
+
+        psFree(image);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     // very simple tests: no mask, bilinear mode, yramp image only
     {
         psMemId id = psMemGetId();
-
-//        diag ("interpolate a y-ramp: ");
-
         // generate simple image (y ramp)
-        psImage *image = psImageAlloc(32, 32, PS_TYPE_F64);
-        ok(image != NULL, "psImage successfully allocated");
-        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
-
-        for (int j = 0; j < image->numRows; j++)
-        {
-            for (int i = 0; i < image->numCols; i++) {
-                image->data.F64[j][i] = j + 0.5;
-            }
-        }
-
-        // center of pixels is 0.5, 0.5
-        double value;
-
-        psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BILINEAR,
-                                                                           image, NULL, NULL, 0, 0.0, 0.0,
-                                                                           0, 0, 0.0);
-        ok(interp, "Interpolation options set");
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation");
-        is_double_tol (value, 2.5, 5.0e-8, "pixel center value - %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.2, interp), "Interpolation");
-        is_double_tol (value, 2.2, 5.0e-8, "coord: 2.2, 2.2, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.8, interp), "Interpolation");
-        is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.8, interp), "Interpolation");
-        is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation");
-        is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
-
-        psFree(interp);
-
-        skip_end();
-
-        psFree(image);
-        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
-    }
+        psImage *image = psImageAlloc(32, 32, PS_TYPE_F32);
+        ok(image != NULL, "psImage successfully allocated");
+        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
+
+        for (int j = 0; j < image->numRows; j++)
+        {
+            for (int i = 0; i < image->numCols; i++) {
+                image->data.F32[j][i] = j + 0.5;
+            }
+        }
+
+        // center of pixels is 0.5, 0.5
+        float value;
+
+        value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 2.5, "pixel center value - %f", value);
+
+        value = psImagePixelInterpolate (image, 2.2, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.5, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 2.8, "coord: 2.8, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 2.8, "coord: 2.8, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
+        is_float (value, 2.8, "coord: 2.8, value: %f", value);
+
+        skip_end();
+
+        psFree(image);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     // very simple tests: no mask, bicube mode, xramp image only
     {
         psMemId id = psMemGetId();
-
-//        diag ("interpolate an x-ramp (bicube)");
-
-        // generate simple image (x ramp)
-        psImage *image = psImageAlloc(32, 32, PS_TYPE_F64);
-        ok(image != NULL, "psImage successfully allocated");
-        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
-
-        for (int j = 0; j < image->numRows; j++)
-        {
-            for (int i = 0; i < image->numCols; i++) {
-                image->data.F64[j][i] = i + 0.5;
-            }
-        }
-
-        // center of pixels is 0.5, 0.5
-        double value;
-
-        psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BICUBE,
-                                                                           image, NULL, NULL, 0, 0.0, 0.0,
-                                                                           0, 0, 0.0);
-        ok(interp, "Interpolation options set");
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation");
-        is_double_tol (value, 2.5, 5.0e-8, "coord; 2.5, 2.5, value - %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.5, interp), "Interpolation");
-        is_double_tol (value, 2.2, 5.0e-8, "coord: 2.2, 2.5, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.5, interp), "Interpolation");
-        is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, 2.5, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.2, interp), "Interpolation");
-        is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, 2.2, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation");
-        is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, 2.8, value: %f", value);
-
-//        diag ("coords outside of nominal range (1 < x < Nx - 2) return 'uncover'");
+        // generate simple image (x ramp)
+        psImage *image = psImageAlloc(32, 32, PS_TYPE_F32);
+        ok(image != NULL, "psImage successfully allocated");
+        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
+
+        for (int j = 0; j < image->numRows; j++)
+        {
+            for (int i = 0; i < image->numCols; i++) {
+                image->data.F32[j][i] = i + 0.5;
+            }
+        }
+
+        // center of pixels is 0.5, 0.5
+        float value;
+
+        value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 2.5, "coord; 2.5, 2.5, value - %f", value);
+
+        value = psImagePixelInterpolate (image, 2.2, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.8, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 2.8, "coord: 2.8, 2.5, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.8, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 2.8, "coord: 2.8, 2.2, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 2.8, "coord: 2.8, 2.8, value: %f", value);
 
         // no extrapolation: these return the 'uncover' value
-        ok(psImageInterpolate(&value, NULL, NULL, 0.8, 2.8, interp), "Interpolation");
-        is_double (value, 0.0, "coord: 0.8, 2.8, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 0.3, 2.8, interp), "Interpolation");
-        is_double (value, 0.0, "coord: 0.3, 2.8, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, -0.2, 2.8, interp), "Interpolation");
-        is_double (value, 0.0, "coord: -0.2, 2.8, value: %f", value);
-
-        psFree(interp);
-
-        skip_end();
-
-        psFree(image);
-        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
-    }
+        value = psImagePixelInterpolate (image, 0.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 0.0, "coord: 0.8, 2.8, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 0.3, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 0.0, "coord: 0.3, 2.8, value: %f", value);
+
+        value = psImagePixelInterpolate (image, -0.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 0.0, "coord: -0.2, 2.8, value: %f", value);
+
+        skip_end();
+
+        psFree(image);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     // very simple tests: no mask, bilinear mode, yramp image only
     {
         psMemId id = psMemGetId();
-
-//        diag ("interpolate a y-ramp (bicube)");
-
         // generate simple image (y ramp)
-        psImage *image = psImageAlloc(32, 32, PS_TYPE_F64);
-        ok(image != NULL, "psImage successfully allocated");
-        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
-
-        for (int j = 0; j < image->numRows; j++)
-        {
-            for (int i = 0; i < image->numCols; i++) {
-                image->data.F64[j][i] = j + 0.5;
-            }
-        }
-
-        // center of pixels is 0.5, 0.5
-        double value;
-
-        psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BICUBE,
-                                                                           image, NULL, NULL, 0, 0.0, 0.0,
-                                                                           0, 0, 0.0);
-        ok(interp, "Interpolation options set");
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation");
-        is_double_tol (value, 2.5, 5.0e-8, "pixel center value - %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.2, interp), "Interpolation");
-        is_double_tol (value, 2.2, 5.0e-8, "coord: 2.2, 2.5, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.8, interp), "Interpolation");
-        is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.8, interp), "Interpolation");
-        is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation");
-        is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
-
-        psFree(interp);
-
-        skip_end();
-
-        psFree(image);
-        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
-    }
+        psImage *image = psImageAlloc(32, 32, PS_TYPE_F32);
+        ok(image != NULL, "psImage successfully allocated");
+        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
+
+        for (int j = 0; j < image->numRows; j++)
+        {
+            for (int i = 0; i < image->numCols; i++) {
+                image->data.F32[j][i] = j + 0.5;
+            }
+        }
+
+        // center of pixels is 0.5, 0.5
+        float value;
+
+        value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 2.5, "pixel center value - %f", value);
+
+        value = psImagePixelInterpolate (image, 2.2, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.5, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 2.8, "coord: 2.8, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 2.8, "coord: 2.8, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 2.8, "coord: 2.8, value: %f", value);
+
+        skip_end();
+
+        psFree(image);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     // very simple tests: no mask, bilinear mode, x,y 2nd order shape
     {
         psMemId id = psMemGetId();
-
-//        diag ("interpolate a quadratic shape (bicube)");
-
-        // generate simple image (x ramp)
-        psImage *image = psImageAlloc(32, 32, PS_TYPE_F64);
-        ok(image != NULL, "psImage successfully allocated");
-        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
-
-        for (int j = 0; j < image->numRows; j++)
-        {
-            for (int i = 0; i < image->numCols; i++) {
-                image->data.F64[j][i] = 0.25*PS_SQR(i + 0.5) + j + 0.5;
-            }
-        }
-
-        // center of pixels is 0.5, 0.5
-        double value;
-
-        psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BICUBE,
-                                                                           image, NULL, NULL, 0, 0.0, 0.0,
-                                                                           0, 0, 0.0);
-        ok(interp, "Interpolation options set");
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation");
-        is_double_tol (value, 4.0625, 2.0e-7, "pixel center value - %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.2, interp), "Interpolation");
-        is_double_tol (value, 3.41, 2.0e-7, "coord: 2.2, 2.5, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.8, interp), "Interpolation");
-        is_double_tol (value, 4.3625, 2.0e-7, "coord: 2.5, 2.8, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.8, interp), "Interpolation");
-        is_double_tol (value, 4.01, 2.0e-7, "coord: 2.2, 2.8, value: %f", value);
-
-        ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation");
-        is_double_tol (value, 4.76, 2.0e-7, "coord: 2.8, 2.8, value: %f", value);
-
-        psFree(interp);
-
-        skip_end();
-
-        psFree(image);
-        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
-    }
-
-    return exit_status();
+        // generate simple image (x ramp)
+        psImage *image = psImageAlloc(32, 32, PS_TYPE_F32);
+        ok(image != NULL, "psImage successfully allocated");
+        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
+
+        for (int j = 0; j < image->numRows; j++)
+        {
+            for (int i = 0; i < image->numCols; i++) {
+                image->data.F32[j][i] = 0.25*PS_SQR(i + 0.5) + j + 0.5;
+            }
+        }
+
+        // center of pixels is 0.5, 0.5
+        float value;
+
+        value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 4.0625, "pixel center value - %f", value);
+
+        value = psImagePixelInterpolate (image, 2.2, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 3.41, "coord: 2.2, 2.5, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.5, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 4.3625002, "coord: 2.5, 2.8, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 4.010000229, "coord: 2.2, 2.8, value: %f", value);
+
+        value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
+        is_float (value, 4.75999975, "coord: 2.8, 2.8, value: %f", value);
+
+        skip_end();
+
+        psFree(image);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
 }

trunk/psLib/test/mathtypes/tap_psScalar.c

@@ -5 +5 @@
  *  @author Eric Van Alst, MHPCC
  *
- *  @version $Revision: 1.4 $
+ *  @version $Revision: 1.5 $
  *           $Name: not supported by cvs2svn $
- *  @date $Date: 2007-03-20 03:57:25 $
+ *  @date $Date: 2007-04-10 21:09:30 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
  */
-
 #include <pslib.h>
-
 #include "tap.h"
 #include "pstap.h"
@@ -49 +47 @@
 int main(void)
 {
-    plan_tests(43);
+    psLogSetFormat("HLNM");
+    psLogSetLevel(PS_LOG_INFO);
+    plan_tests(47);
 
-    void testScalarAlloc();
-    testScalarAlloc();
-    void testBadScalarAlloc();
-    testBadScalarAlloc();
 
-    void testScalarCopy();
-    testScalarCopy();
-    void testBadScalarCopy();
-    testBadScalarCopy();
-}
+    // Verify return is null for invalid scalar type
+    {
+        psMemId id = psMemGetId();
+        psScalar* scalar = psScalarAlloc(true,PS_TYPE_BOOL);
+        ok(scalar == NULL, "psScalarAlloc returns null for invalid type");
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 
-void testScalarAlloc(void)
-{
-//    diag("psTestScalarAlloc");
 
     //Verify the proper allocation/deallocation of scalar objects of valid types
-    tstScalarAllocByType(S8,10);
-    tstScalarAllocByType(U8,12);
-    tstScalarAllocByType(S16,14);
-    tstScalarAllocByType(U16,16);
-    tstScalarAllocByType(S32,18);
-    tstScalarAllocByType(U32,20);
-    tstScalarAllocByType(S64,22);
-    tstScalarAllocByType(U64,24);
-    tstScalarAllocByType(F32,26);
-    tstScalarAllocByType(F64,28);
-}
+    {
+        psMemId id = psMemGetId();
+        tstScalarAllocByType(S8,10);
+        tstScalarAllocByType(U8,12);
+        tstScalarAllocByType(S16,14);
+        tstScalarAllocByType(U16,16);
+        tstScalarAllocByType(S32,18);
+        tstScalarAllocByType(U32,20);
+        tstScalarAllocByType(S64,22);
+        tstScalarAllocByType(U64,24);
+        tstScalarAllocByType(F32,26);
+        tstScalarAllocByType(F64,28);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 
 
-void testBadScalarAlloc(void)
-{
-//    diag("psTestBadScalarAlloc");
-
-    // Verify return is null for invalid scalar type
-    psScalar* scalar = psScalarAlloc(true,PS_TYPE_BOOL);
-    ok(scalar == NULL, "psScalarAlloc returns null for invalid type");
-}
+    // Verify the return is null for invalid scalar type in the original
+    {
+        psMemId id = psMemGetId();
+        psScalar* scalarOrig = psScalarAlloc(0,PS_TYPE_S8);
+        scalarOrig->type.type = PS_TYPE_BOOL;
+        psScalar* scalarCopy = psScalarCopy(scalarOrig);
+        ok(scalarCopy == NULL, "psScalarCopy returns NULL for invalid type");
+        scalarCopy = psScalarCopy(NULL);
+        ok(scalarCopy == NULL, "psScalarCopy returns NULL for NULL argument");
+        psFree(scalarOrig);
+        psFree(scalarCopy);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 
 
-void testScalarCopy(void)
-{
-//    diag("psTestScalarCopy");
-
     // Verify the proper copying of scalar objects for all valid types
-    tstScalarCopyByType(S8,100);
-    tstScalarCopyByType(U8,110);
-    tstScalarCopyByType(S16,120);
-    tstScalarCopyByType(U16,130);
-    tstScalarCopyByType(S32,140);
-    tstScalarCopyByType(U32,150);
-    tstScalarCopyByType(S64,160);
-    tstScalarCopyByType(U64,170);
-    tstScalarCopyByType(F32,180);
-    tstScalarCopyByType(F64,190);
+    {
+        psMemId id = psMemGetId();
+        tstScalarCopyByType(S8,100);
+        tstScalarCopyByType(U8,110);
+        tstScalarCopyByType(S16,120);
+        tstScalarCopyByType(U16,130);
+        tstScalarCopyByType(S32,140);
+        tstScalarCopyByType(U32,150);
+        tstScalarCopyByType(S64,160);
+        tstScalarCopyByType(U64,170);
+        tstScalarCopyByType(F32,180);
+        tstScalarCopyByType(F64,190);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 }
-
-
-void testBadScalarCopy(void)
-{
-//    diag("psTestBadScalarCopy");
-
-    // Verify the return is null for invalid scalar type in the original
-    psScalar* scalarOrig = psScalarAlloc(0,PS_TYPE_S8);
-    scalarOrig->type.type = PS_TYPE_BOOL;
-    psScalar* scalarCopy = psScalarCopy(scalarOrig);
-    ok(scalarCopy == NULL, "psScalarCopy returns NULL for invalid type");
-
-    scalarCopy = psScalarCopy(NULL);
-    ok(scalarCopy == NULL, "psScalarCopy returns NULL for NULL argument");
-}

trunk/psLib/test/mathtypes/tap_psVector.c

@@ -8 +8 @@
 int main (void)
 {
-    plan_tests(209);
-
-//    diag("psVectorAlloc() tests");
+    plan_tests(285);
+
 
     {
         psMemId id = psMemGetId();
         psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
-
         ok(psVec != NULL, "psVector successfully allocated");
         skip_start(psVec == NULL, 4, "Skipping 4 tests because psVectorAlloc() failed");
@@ -23 +21 @@
         ok(psVec->type.dimen == PS_DIMEN_VECTOR, "Vector dimen = %d", psVec->type.dimen);
         skip_end();
-
         psFree(psVec);
         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     }
 
-    {
+
+    {
+        psMemId id = psMemGetId();
         psVector* vecZero = psVectorAlloc(0, PS_TYPE_S32);
-
         ok(vecZero != NULL, "zero-length vector allocated");
         skip_start(vecZero == NULL, 2, "Skipping 2 tests because psVectorAlloc() failed");
@@ -36 +34 @@
         ok(vecZero->n == 0, "Vector population = %ld", vecZero->n);
         skip_end();
-
         psFree(vecZero);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector* vecBogus = psVectorAlloc(10, 0);
-
         ok(vecBogus == NULL, "psVectorAlloc() doesn't not accept bogus type");
         psErr *err = psErrorLast();
-
         skip_start(err == NULL, 2, "Skipping 2 tests because psVectorAlloc() didn't fail as expect");
         ok(strstr(err->name, "vectorAlloc"), "alloc failure - got error name %s", err->name);
         ok(err->code == PS_ERR_BAD_PARAMETER_TYPE, "alloc failure - got error code %d", err->code);
         skip_end();
-
         psFree(vecBogus);
-    }
-
-
-//    diag("psVectorRealloc() tests");
-
-    {
-        // create new psVector
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // psVectorRealloc() tests
+    {
+        psMemId id = psMemGetId();
         psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
         ok(psVec->n == 5, "Vector population = %ld", psVec->n);
-//        for(psS32 i = 0; i < 5; i++) {
-//            printf ("Elem %d = %d\n", i, psVec->data.S32[i]);
-//        }
 
         // generate first part of vector
@@ -93 +87 @@
         }
         skip_end();
-
         psFree(psVec);
-    }
-
-    {
-        // Test D - Reallocate S32 vector smaller
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // Test D - Reallocate S32 vector smaller
+    {
+        psMemId id = psMemGetId();
         psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
-        psVec->n = 5;
-
         // generate test data values
         for(psS32 i = 0; i < 5; i++) {
@@ -107 +101 @@
             psVec->n++;
         }
-
         psVec = psVectorRealloc(psVec, 3);
-
         ok(psVec != NULL, "test vector reallocated to smaller size");
         skip_start(psVec == NULL, 5, "Skipping 6 tests because psVectorRealloc() failed");
@@ -120 +112 @@
         }
         skip_end();
-    }
-
-    {
-        // reallocate to 0 length
+        psFree(psVec);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // reallocate to 0 length
+    {
+        psMemId id = psMemGetId();
         psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
         psVec = psVectorRealloc(psVec,0);
@@ -136 +132 @@
         // XXX not really a test...
         psFree(psVec);
-    }
-
-    {
-        psVector *vecBogus = psVectorAlloc(5, PS_TYPE_S32);
-        vecBogus = psVectorRealloc(NULL, 6);
-
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
+        psVector *vecBogus = psVectorRealloc(NULL, 6);
         ok(vecBogus == NULL, "psVectorRealloc() doesn't not accept bogus type");
         psErr *err = psErrorLast();
-
         skip_start(err == NULL, 2, "Skipping 2 tests because psVectorRealloc() didn't fail as expect");
         ok(strstr(err->name, "psVectorRealloc"), "alloc failure - got error name %s", err->name);
         ok(err->code == PS_ERR_BAD_PARAMETER_NULL, "alloc failure - got error code %d", err->code);
         skip_end();
-
         psFree(vecBogus);
-    }
-
-//    diag("psVectorExtend() tests");
-    {
-        // create new psVector
+        psFree(err);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // psVectorExtend() tests
+    {
+        psMemId id = psMemGetId();
         psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
         psVec = psVectorExtend(psVec, 0, 2);
@@ -164 +162 @@
         ok(psVec->n == 7, "Vector population = %ld", psVec->n);
         skip_end();
-
         psFree(psVec);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
         psVec = psVectorExtend(psVec, 0, 2);
         psVec = psVectorExtend(psVec, 0, 2);
-
         ok(psVec != NULL, "test vector extended");
         skip_start(psVec == NULL, 2, "Skipping 2 tests because psVectorExtend() failed");
@@ -179 +178 @@
         ok(psVec->n == 9,"Vector population = %ld", psVec->n);
         skip_end();
-
         psFree(psVec);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
         psVec = psVectorExtend(psVec, 0, 2);
         psVec = psVectorExtend(psVec, 0, 2);
         psVec = psVectorExtend(psVec, 0, -2);
-
         ok(psVec != NULL, "test vector extended");
         skip_start(psVec == NULL, 2, "Skipping 2 tests because psVectorExtend() failed");
@@ -195 +195 @@
         ok(psVec->n == 7, "Vector population = %ld", psVec->n);
         skip_end();
-
         psFree(psVec);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
         psVec = psVectorExtend(psVec, 0, 2);
@@ -205 +207 @@
         psVec = psVectorExtend(psVec, 0, -2);
         psVec = psVectorExtend(psVec, 0, -20);
-
         ok(psVec != NULL, "test vector extended");
         skip_start(psVec == NULL, 2, "Skipping 2 tests because psVectorExtend() failed");
@@ -212 +213 @@
         ok(psVec->n == 0, "Vector population = %ld", psVec->n);
         skip_end();
-
         psFree(psVec);
-    }
-
-
-//    diag("psVectorInit() tests");
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // psVectorInit() tests
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(1, PS_TYPE_U8);
         ok(psVectorInit(vec, 1 ), "U8 Case");
         psFree(vec);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(1, PS_TYPE_U16);
         ok(!psVectorInit(vec, PS_MAX_U64), "VectorInit failed.  U16 Case");
         psFree(vec);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(1, PS_TYPE_U32);
         ok(psVectorInit(vec, 10), "U32 Case");
         psFree(vec);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(1, PS_TYPE_U64);
         ok(psVectorInit(vec, PS_MIN_U64), "U64 Case");
         psFree(vec);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(1, PS_TYPE_S8);
         ok(!psVectorInit(vec, PS_MAX_S16), "VectorInit failed.  S8 Case");
         psFree(vec);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(1, PS_TYPE_S16);
         ok(psVectorInit(vec, -100), "S16 Case");
         psFree(vec);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(1, PS_TYPE_S32);
         ok(psVectorInit(vec, 1), "S32 Case");
         psFree(vec);
-    }
-
-    {
-        // XXX is this test ok?
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // XXX is this test ok?
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(1, PS_TYPE_S64);
         ok(psVectorInit(vec, PS_MAX_S64), "S64 Case");
         psFree(vec);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(1, PS_TYPE_F32);
         ok(psVectorInit(vec, 1.1), "F32 Case");
         psFree(vec);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(1, PS_TYPE_F64);
         ok(psVectorInit(vec, 1.4 ), "F64 Case");
         psFree(vec);
-    }
-
-
-//    diag("psVectorCreate() tests");
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // psVectorCreate() tests
+    {
+        psMemId id = psMemGetId();
         psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S8);
         for (int i = 0; i < 10; i++) {
@@ -290 +319 @@
         }
         psFree(test);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U8);
         for (int i = 0; i < 10; i++) {
@@ -299 +331 @@
         }
         psFree(test);
-    }
-
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U32);
         for (int i = 0; i < 10; i++) {
@@ -309 +343 @@
         }
         psFree(test);
-    }
-
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S32);
         for (int i = 0; i < 10; i++) {
@@ -319 +355 @@
         }
         psFree(test);
-    }
-
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *input = psVectorAlloc(5, PS_TYPE_F32);
         psVector *test = psVectorCreate(input, 0.0, 5.0, 0.5, PS_TYPE_F32);
@@ -330 +368 @@
                "Vector data matches. i = %d, data=%f", i, test->data.F32[i]);
         }
-
         psFree(input);
-    }
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     //  Test PS_TYPE_F64
     //       PS_TYPE_S64
     //       PS_TYPE_U64
-
-    {
+    {
+        psMemId id = psMemGetId();
         psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S64);
         for (int i = 0; i < 10; i++)
@@ -347 +386 @@
         }
         psFree(test);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U64);
         for (int i = 0; i < 10; i++)
@@ -358 +400 @@
         }
         psFree(test);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *input = psVectorAlloc(5, PS_TYPE_F64);
         psVector *test = psVectorCreate(input, 0.0, 5.0, 0.5, PS_TYPE_F64);
-
         for (int i = 0; i < 10; i++)
         {
@@ -371 +415 @@
         }
         psFree(input);
-    }
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     //  Test PS_TYPE_U16
     //       PS_TYPE_S16
     {
+        psMemId id = psMemGetId();
         psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S16);
         for (int i = 0; i < 10; i++)
@@ -383 +430 @@
         }
         psFree(test);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *input = psVectorAlloc(5, PS_TYPE_U16);
         psVector *test = psVectorCreate(input, 0.0, 20.0, 2.0, PS_TYPE_U16);
-
         for (int i = 0; i < 10; i++)
         {
@@ -395 +444 @@
         }
         psFree(input);
-    }
-
-
-
-//    diag("psVectorToString() tests");
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
 
     #define TEST_VECTOR_TO_STRING(TYPE, SIZE, START, INC, EXPECTED)         \
     {                                                                       \
+        psMemId id = psMemGetId(); \
         const int asize = SIZE;  /* alloc size */                           \
         const int osize = 100;   /* output size (max) */                    \
@@ -416 +465 @@
         \
         psFree(input);                                                      \
-    }
-
-
+        psFree(result);                                                      \
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); \
+    }
+//HERE
+    // psVectorToString() tests
     TEST_VECTOR_TO_STRING(PS_TYPE_U8,  5, 1, 1, "[1,2,3,4,5]");
-
     TEST_VECTOR_TO_STRING(PS_TYPE_U16, 5, 1, 1, "[1,2,3,4,5]");
-
     TEST_VECTOR_TO_STRING(PS_TYPE_U32, 5, 1, 1, "[1,2,3,4,5]");
-
     TEST_VECTOR_TO_STRING(PS_TYPE_U64, 5, 1, 1, "[1,2,3,4,5]");
-
     TEST_VECTOR_TO_STRING(PS_TYPE_S8,  5, -100, 10,"[-100,-90,-80,-70,-60]");
-
     TEST_VECTOR_TO_STRING(PS_TYPE_S16, 5, 0, -100, "[0,-100,-200,-300,-400]");
-
     TEST_VECTOR_TO_STRING(PS_TYPE_S32, 5, 0, -100, "[0,-100,-200,-300,-400]");
-
     TEST_VECTOR_TO_STRING(PS_TYPE_S64, 5, 0, -100, "[0,-100,-200,-300,-400]");
-
     TEST_VECTOR_TO_STRING(PS_TYPE_F32,5,.123,1,"[0.123,1.123,2.123,3.123,4.123]");
     TEST_VECTOR_TO_STRING(PS_TYPE_F64,5,.123,1,"[0.123,1.123,2.123,3.123,4.123]");
 
-
-//    diag("p_psVectorGetElementF64() tests");
 
     #define TEST_VECTOR_GET_ELEMENT_F64(ELEM_TYPE, SIZE, VALUE_TYPE,        \
                                         INIT_VALUE )                                                        \
     {                                                                       \
+        psMemId id = psMemGetId(); \
         psVector *vec = psVectorAlloc(SIZE, ELEM_TYPE);                     \
         vec->n = SIZE;                                                      \
@@ -454 +496 @@
         \
         psFree(vec);                                                        \
-    }
-
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); \
+    }
+    // p_psVectorGetElementF64() tests
     TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U8, 1, psU8, 1);
-
     TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U16, 2, psU16, 2);
-
     TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U32, 3, psU32, 3);
-
     TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U64, 100, psU64, 999999);
-
     TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S8,  1, psS8, -1);
-
     TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S16, 2, psS16, -2);
-
     TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S32, 3, psS32, -3);
-
     TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S64, 100, psS64, -999999);
-
     TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_F32,1, psF32, .123);
-
     TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_F64,2, psF64, -123.123);
 
 
-//    diag("p_psVectorPrint() tests");
     // XXX: Why are we testing private functions?
     #define TEST_VECTOR_PRINT(ELEM_TYPE, SIZE, VALUE_TYPE, INIT_VALUE, FD,  \
                               OUT_NAME, EXPECTED_RC )                                             \
     {                                                                       \
+        psMemId id = psMemGetId(); \
         psVector *vec = psVectorAlloc(SIZE, ELEM_TYPE);                     \
         vec->n = SIZE;                                                      \
@@ -491 +525 @@
         \
         psFree(vec);                                                        \
-    }
-
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); \
+    }
+    // p_psVectorPrint() tests
     TEST_VECTOR_PRINT(PS_TYPE_U8, 1, psU8, 1, 1, "PS_TYPE_U8", TRUE);
-
     TEST_VECTOR_PRINT(PS_TYPE_U16, 2, psU16, 2, 1, "PS_TYPE_U16", TRUE);
-
     TEST_VECTOR_PRINT(PS_TYPE_U32, 3, psU32, 3, 1, "PS_TYPE_U32", TRUE);
-
     TEST_VECTOR_PRINT(PS_TYPE_U64, 4, psU64, 999999, 1, "PS_TYPE_U64", TRUE);
-
     TEST_VECTOR_PRINT(PS_TYPE_S8,  1, psS8, -1, 1, "PS_TYPE_S8", TRUE);
-
     TEST_VECTOR_PRINT(PS_TYPE_S16, 2, psS16, -2, 1, "PS_TYPE_S16", TRUE);
-
     TEST_VECTOR_PRINT(PS_TYPE_S32, 3, psS32, -3, 1, "PS_TYPE_S32", TRUE);
-
     TEST_VECTOR_PRINT(PS_TYPE_S64, 4, psS64, -999999, 1, "PS_TYPE_S64", TRUE);
-
     TEST_VECTOR_PRINT(PS_TYPE_F32,1, psF32, .123, 1, "PS_TYPE_F32", TRUE);
-
     TEST_VECTOR_PRINT(PS_TYPE_F64,2, psF64, -123.123, 1, "PS_TYPE_F64", TRUE);
 
-//    diag("psVectorSet() tests");
-
-    {
+    // psVectorSet() tests
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(5, PS_TYPE_S32);
-
         ok(psVectorSet(vec, 0, 10),
            "VectorSet set S32 at position 0");
-
-        psFree(vec);
-    }
-
-    {
+        psFree(vec);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(5, PS_TYPE_S32);
-
         ok(!psVectorSet(vec, 10, 10),
            "VectorSet failes to set S32 at out of range position");
-
-        psFree(vec);
-    }
-
-    {
+        psFree(vec);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(5, PS_TYPE_S32);
-
         ok(psVectorSet(vec, 1, 4) == true,
            "VectorSet set S32 at position 1");
-
-        psFree(vec);
-    }
-
-
-//    diag("psVectorGet() tests");
-
-    {
+        psFree(vec);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // psVectorGet() tests
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(10, PS_TYPE_S32);
         psVectorSet(vec, 0, 10);
-
         ok((psS32)psVectorGet(vec, 0) == 10,
            "VectorGet returned the correct S32 from position 0");
-
-        psFree(vec);
-    }
-
-    {
+        psFree(vec);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(5, PS_TYPE_S32);
         psVectorSet(vec, -1, 4);
-
         ok((psS32)psVectorGet(vec, -1) == 4,
            "VectorGet returned the correct S32 from tail using -1");
-
-        psFree(vec);
-    }
-
-
-//    diag("psVectorCountPixelMask() tests");
-
-    {
+        psFree(vec);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // psVectorCountPixelMask() tests
+    {
+        psMemId id = psMemGetId();
         ok(psVectorCountPixelMask(NULL, 1) == -1,
            "psVectorCountPixelMask returned -1 for NULL Vector input");
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(5, PS_TYPE_S32);
         vec->data.S32[0] = 0;
@@ -580 +610 @@
         vec->data.S32[3] = 1;
         vec->data.S32[4] = 0;
-        vec->n = 5;
-
         ok(psVectorCountPixelMask(vec, 1) == -1,
            "returned -1 for wrong type of Vector input");
-
-        psFree(vec);
-    }
-
-    {
+        psFree(vec);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vec = psVectorAlloc(5, PS_TYPE_U8);
         vec->data.U8[0] = 0;
@@ -595 +625 @@
         vec->data.U8[3] = 1;
         vec->data.U8[4] = 0;
-        vec->n = 5;
         long numPix = psVectorCountPixelMask(vec, 1);
-
         ok(numPix != -1, "returned -1 for correct Vector input");
         ok(numPix == 2, "returned pixel count %d", numPix);
-
-        psFree(vec);
-    }
-
-
-//    diag("psVectorLength() tests");
-    {
+        psFree(vec);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // psVectorLength() tests
+    {
+        psMemId id = psMemGetId();
         psVector *vector = psVectorAlloc(5, PS_TYPE_F32);
         ok(psVectorLength(vector) == 5,
            "returned the correct length of vector (was %d, should be 5)", psVectorLength(vector));
         psFree(vector);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vector = psVectorAlloc(5, PS_TYPE_F32);
-        vector->n = 5;
-
         ok(psVectorLength(vector) == 5,
            "returned the correct length of vector");
-
         psFree(vector);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *vector = psVectorAlloc(6, PS_TYPE_F32);
-        vector->n = 6;
-
         ok(psVectorLength(vector) == 6,
            "returned the correct length of vector");
-
         psFree(vector);
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         ok(psVectorLength(NULL) == -1, "returned -1 for a NULL input vector");
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psArray *array = psArrayAlloc(5);
-
         ok(psVectorLength((psVector*)array) == -1,
            "returned -1 for an invalid input vector");
-
         psFree(array);
-    }
-
-
-//    diag("psVectorCopy() tests");
-
-    {
-
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // psVectorCopy() tests
+    {
+        psMemId id = psMemGetId();
         ok(psVectorCopy(NULL, NULL, PS_TYPE_F32) == NULL,
            "returned a NULL vector for NULL input");
-    }
-
-    {
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    {
+        psMemId id = psMemGetId();
         psVector *in = psVectorAlloc(5, PS_TYPE_F32);
-        in->n = 5;
-
         for (int i = 0; i < 5; i++) {
             in->data.F32[i] = i;
         }
-
         //Try copy of different type
         psVector *copy = psVectorCopy(NULL, in, PS_TYPE_F64);
@@ -671 +704 @@
            copy->data.F64[2], in->data.F32[2]);
         skip_end();
-
         psFree(in);
         psFree(copy);
-    }
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     // XXX psVectorRecycle needs it's own tests
     // copy = psVectorRecycle(copy, in->n + 2, PS_TYPE_F64);
-
-    {
+    {
+        psMemId id = psMemGetId();
         // Try copy of same type and non-NULL outVector of different type and
         // size.
@@ -700 +734 @@
         psFree(in);
         psFree(copy);
-    }
-
-    return exit_status();
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
 }

trunk/psLib/test/mathtypes/tap_psVectorSort_01.c

@@ -12 +12 @@
  *  @author  Ross Harman, MHPCC
  *
- *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
- *  @date  $Date: 2007-03-20 03:57:25 $
+ *  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
+ *  @date  $Date: 2007-04-10 21:09:31 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
  *
  */
-
 #include <pslib.h>
-
 #include "tap.h"
 #include "pstap.h"
 
-
 #define tstVectorSortByType(datatype,value)   \
 in = psVectorAlloc(7,PS_TYPE_##datatype); \
-in->n = 7;  \
 out = psVectorAlloc(7,PS_TYPE_##datatype); \
-out->n = 7;  \
 in->data.datatype[0] = 7+value; \
 in->data.datatype[1] = 9+value; \
@@ -45 +40 @@
 ok(out->data.datatype[0] == in->data.datatype[6], \
    "sort out[0] type %s",#datatype); \
-skip_start(out->data.datatype[0] != in->data.datatype[6], \
-           6,"sort out[0] type %s",#datatype); \
 ok(out->data.datatype[1] == in->data.datatype[3], \
    "sort out[1] type %s",#datatype); \
-skip_start(out->data.datatype[1] != in->data.datatype[3], \
-           5,"Improper sort out[1] type %s",#datatype); \
 ok(out->data.datatype[2] == in->data.datatype[2], \
    "sort out[2] type %s",#datatype); \
-skip_start(out->data.datatype[2] != in->data.datatype[2], \
-           4,"Improper sort out[2] type %s",#datatype); \
 ok(out->data.datatype[3] == in->data.datatype[4], \
    "sort out[3] type %s",#datatype); \
-skip_start(out->data.datatype[3] != in->data.datatype[4], \
-           3,"Improper sort out[3] type %s",#datatype); \
 ok(out->data.datatype[4] == in->data.datatype[5], \
    "sort out[4] %s",#datatype); \
-skip_start(out->data.datatype[4] != in->data.datatype[5], \
-           2,"Improper sort out[4] %s",#datatype); \
 ok(out->data.datatype[5] == in->data.datatype[0], \
    "sort out[5] %s",#datatype); \
-skip_start(out->data.datatype[5] != in->data.datatype[0], \
-           1,"Improper sort out[5] %s",#datatype); \
 ok(out->data.datatype[6] == in->data.datatype[1], \
    "sort out[6] %s",#datatype); \
-skip_end(); \
-skip_end(); \
-skip_end(); \
-skip_end(); \
-skip_end(); \
-skip_end(); \
 skip_end(); \
 psFree(in); \
@@ -84 +61 @@
            char* argv[])
 {
-    plan_tests(92);
+    psLogSetFormat("HLNM");
+    psLogSetLevel(PS_LOG_INFO);
+    plan_tests(97);
 
     psVector *in = NULL;
@@ -91 +70 @@
 
     // Test A - Verify the sort for all supported types
-
-    tstVectorSortByType(S8,0);
-    tstVectorSortByType(S16,1);
-    tstVectorSortByType(S32,2);
-    tstVectorSortByType(S64,3);
-    tstVectorSortByType(U8,4);
-    tstVectorSortByType(U16,5);
-    tstVectorSortByType(U32,6);
-    tstVectorSortByType(U64,7);
-    tstVectorSortByType(F32,8);
-    tstVectorSortByType(F64,9);
+    {
+        psMemId id = psMemGetId();
+        tstVectorSortByType(S8,0);
+        tstVectorSortByType(S16,1);
+        tstVectorSortByType(S32,2);
+        tstVectorSortByType(S64,3);
+        tstVectorSortByType(U8,4);
+        tstVectorSortByType(U16,5);
+        tstVectorSortByType(U32,6);
+        tstVectorSortByType(U64,7);
+        tstVectorSortByType(F32,8);
+        tstVectorSortByType(F64,9);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 
 
     // Test B - Sort input vector into itself
+    {
+        psMemId id = psMemGetId();
+        psVector *in = psVectorAlloc(7, PS_TYPE_F32);
+        in->data.F32[0] = 0.7f;
+        in->data.F32[1] = 0.9f;
+        in->data.F32[2] = 0.3f;
+        in->data.F32[3] = 0.1f;
+        in->data.F32[4] = 0.5f;
+        in->data.F32[5] = 0.5f;
+        in->data.F32[6] = -2.0f;
+        in = psVectorSort(in, in);
+        ok(in->data.F32[0] == -2.0f,"self sort in[0]");
+        ok(in->data.F32[1] == 0.1f,"self sort in[1]");
+        ok(in->data.F32[2] == 0.3f, "self sort in[2]");
+        ok(in->data.F32[3] == 0.5f, "self sort in[3]");
+        ok(in->data.F32[4] == 0.5f, "self sort in[4]");
+        ok(in->data.F32[5] == 0.7f, "self sort in[5]");
+        ok(in->data.F32[6] == 0.9f, "self sort in[6]");
+        psFree(in);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 
-    in = psVectorAlloc(7, PS_TYPE_F32);
-    in->n = 7;
-    in->data.F32[0] = 0.7f;
-    in->data.F32[1] = 0.9f;
-    in->data.F32[2] = 0.3f;
-    in->data.F32[3] = 0.1f;
-    in->data.F32[4] = 0.5f;
-    in->data.F32[5] = 0.5f;
-    in->data.F32[6] = -2.0f;
-    in = psVectorSort(in, in);
-    ok(in->data.F32[0] == -2.0f,"self sort in[0]");
-    ok(in->data.F32[1] == 0.1f,"self sort in[1]");
-    ok(in->data.F32[2] == 0.3f, "self sort in[2]");
-    ok(in->data.F32[3] == 0.5f, "self sort in[3]");
-    ok(in->data.F32[4] == 0.5f, "self sort in[4]");
-    ok(in->data.F32[5] == 0.7f, "self sort in[5]");
-    ok(in->data.F32[6] == 0.9f, "self sort in[6]");
 
     // Test C - Attempt to sort vector with invalid type
-    in->type.type = PS_TYPE_BOOL;
-    out = psVectorAlloc(7,PS_TYPE_F32);
-    tempVec = psVectorSort(out,in);
-    ok(tempVec == NULL, "Did return NULL on error");
+    {
+        psMemId id = psMemGetId();
+        psVector *in = psVectorAlloc(7, PS_TYPE_F32);
+        in->type.type = PS_TYPE_BOOL;
+        out = psVectorAlloc(7,PS_TYPE_F32);
+        tempVec = psVectorSort(out,in);
+        ok(tempVec == NULL, "Did return NULL on error");
+        psFree(out);
+        psFree(in);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     // Test D - Sort vector with zero elements
-    out = psVectorAlloc(7,PS_TYPE_F32);
-    in->n = 0;
-    out = psVectorSort(out,in);
-    ok (out != NULL, "psVectorSort returned a non-NULL vector" );
-    skip_start (out == NULL, 1, "psVectorSort returned a NULL vector" );
-    ok (out->n == 0, "psVectorSort correctly return a 0-length vector.\n");
-    skip_end();
-
-    psFree(out);
+    {
+        psMemId id = psMemGetId();
+        out = psVectorAlloc(7,PS_TYPE_F32);
+        in->n = 0;
+        out = psVectorSort(out,in);
+        ok(out != NULL, "psVectorSort returned a non-NULL vector" );
+        skip_start (out == NULL, 1, "psVectorSort returned a NULL vector" );
+        ok(out->n == 0, "psVectorSort correctly return a 0-length vector");
+        skip_end();
+        psFree(out);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 
 
     // Test D - Free float vectors
-    psFree(in);
-    ok ( ! psMemCheckLeaks(0, NULL, stdout, false),"Memory leaks not detected");
-
-    psS32 nBad = psMemCheckCorruption(stderr, false);
-    ok(!nBad, "Found %d bad memory blocks\n", nBad);
+    {
+        psMemId id = psMemGetId();
+        psVector *in = psVectorAlloc(7, PS_TYPE_F32);
+        psFree(in);
+        ok( ! psMemCheckLeaks(0, NULL, stdout, false),"Memory leaks not detected");
+        psS32 nBad = psMemCheckCorruption(stderr, false);
+        ok(!nBad, "Found %d bad memory blocks", nBad);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 }

trunk/psLib/test/mathtypes/tap_psVectorSort_02.c

@@ -14 +14 @@
  *  @author  Ross Harman, MHPCC
  *
- *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
- *  @date  $Date: 2007-03-20 03:57:25 $
+ *  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
+ *  @date  $Date: 2007-04-10 21:09:31 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -28 +28 @@
 #define tstVectorSortIndexByType(datatype,value) \
 in = psVectorAlloc( 5, PS_TYPE_##datatype ); \
-in->n = 5; \
 in->data.datatype[0] = 7+value; \
 in->data.datatype[1] = 9+value; \
@@ -52 +51 @@
 psS32 main(psS32 argc, char* argv[])
 {
-    plan_tests(71);
+    psLogSetFormat("HLNM");
+    psLogSetLevel(PS_LOG_INFO);
+    plan_tests(77);
 
     psVector *in = NULL;
@@ -59 +60 @@
 
     // Test A - Sort vectors by index for all types
-    tstVectorSortIndexByType(S8,0)
-    tstVectorSortIndexByType(U8,1)
-    tstVectorSortIndexByType(S16,2)
-    tstVectorSortIndexByType(U16,3)
-    tstVectorSortIndexByType(S32,4)
-    tstVectorSortIndexByType(U32,5)
-    tstVectorSortIndexByType(S64,6)
-    tstVectorSortIndexByType(U64,7)
-    tstVectorSortIndexByType(F32,8)
-    tstVectorSortIndexByType(F64,9)
-    psFree(out);
+    {
+        psMemId id = psMemGetId();
+        tstVectorSortIndexByType(S8,0)
+        tstVectorSortIndexByType(U8,1)
+        tstVectorSortIndexByType(S16,2)
+        tstVectorSortIndexByType(U16,3)
+        tstVectorSortIndexByType(S32,4)
+        tstVectorSortIndexByType(U32,5)
+        tstVectorSortIndexByType(S64,6)
+        tstVectorSortIndexByType(U64,7)
+        tstVectorSortIndexByType(F32,8)
+        tstVectorSortIndexByType(F64,9)
+        psFree(out);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     // Test  C  Attempt to sort with null input vector
-    in = NULL;
-    out = psVectorAlloc(5,PS_TYPE_U32);
-    out = psVectorSortIndex(out,in);
-    ok(out == NULL, "Did return NULL with NULL input specified");
+    {
+        psMemId id = psMemGetId();
+        in = NULL;
+        out = psVectorAlloc(5,PS_TYPE_U32);
+        out = psVectorSortIndex(out,in);
+        ok(out == NULL, "Did return NULL with NULL input specified");
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     // Test  D  Sort with output vector which needs to be resized
-    in = psVectorAlloc(5,PS_TYPE_U8);
-    in->n=5;
-    for(psS32 m=0; m<5; m++) {
-        in->data.U8[m]= 20-m;
+    {
+        psMemId id = psMemGetId();
+        in = psVectorAlloc(5,PS_TYPE_U8);
+        in->n=5;
+        for(psS32 m=0; m<5; m++) {
+            in->data.U8[m]= 20-m;
+        }
+        out = psVectorAlloc(5,PS_TYPE_U32);
+        out->n = 5;
+        out = psVectorSortIndex(out,in);
+        ok(out->n == 5, "Did properly resize output vector...out->n=%d, in->n=%d", out->n, in->n);
+        ok(out->data.U32[0] == 4,
+           "Did properly sort index out[0] = %d",out->data.U32[0]);
+        ok(out->data.U32[1] == 3,
+           "Did properly sort index out[1] = %d",out->data.U32[1]);
+        ok(out->data.U32[2] == 2,
+           "Did properly sort index out[2] = %d",out->data.U32[2]);
+        ok(out->data.U32[3] == 1,
+           "Did properly sort index out[3] = %d",out->data.U32[3]);
+        ok(out->data.U32[4] == 0,
+           "Did properly sort index out[4] = %d",out->data.U32[4]);
+        psFree(in);
+        psFree(out);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     }
-    out = psVectorAlloc(5,PS_TYPE_U32);
-    out->n = 5;
-    out = psVectorSortIndex(out,in);
-    ok(out->n == 5, "Did properly resize output vector...out->n=%d, in->n=%d", out->n, in->n);
-    ok(out->data.U32[0] == 4,
-       "Did properly sort index out[0] = %d",out->data.U32[0]);
-    ok(out->data.U32[1] == 3,
-       "Did properly sort index out[1] = %d",out->data.U32[1]);
-    ok(out->data.U32[2] == 2,
-       "Did properly sort index out[2] = %d",out->data.U32[2]);
-    ok(out->data.U32[3] == 1,
-       "Did properly sort index out[3] = %d",out->data.U32[3]);
-    ok(out->data.U32[4] == 0,
-       "Did properly sort index out[4] = %d",out->data.U32[4]);
 
-    psFree(in);
-    psFree(out);
 
     // Test E - Sort input vector with zero elements
-    in = psVectorAlloc(5,PS_TYPE_U8);
-    out = psVectorAlloc(5,PS_TYPE_U32);
-    in->n = 0;
-    out->n = 0;
-    tempVect = out;
-    out = psVectorSortIndex(out,in);
-    ok ( out == tempVect, "Did not return the same output vector");
-    in->n=5;
-    out->n=5;
-    psFree(out);
-    psFree(in);
+    {
+        psMemId id = psMemGetId();
+        in = psVectorAlloc(5,PS_TYPE_U8);
+        out = psVectorAlloc(5,PS_TYPE_U32);
+        in->n = 0;
+        out->n = 0;
+        tempVect = out;
+        out = psVectorSortIndex(out,in);
+        ok ( out == tempVect, "Did not return the same output vector");
+        in->n=5;
+        out->n=5;
+        psFree(out);
+        psFree(in);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     // Test F - Attempt to sort input vector with invalid type
-    in = psVectorAlloc(5,PS_TYPE_U8);
-    out = psVectorAlloc(5,PS_TYPE_U32);
-    in->n = 5;
-    out->n = 5;
-    tempVect = out;
-    in->type.type = PS_TYPE_BOOL;
-    out = psVectorSortIndex(out,in);
-    ok( out == NULL, "Did return NULL");
-    in->type.type = PS_TYPE_U8;
-    psFree(in);
+    {
+        psMemId id = psMemGetId();
+        in = psVectorAlloc(5,PS_TYPE_U8);
+        out = psVectorAlloc(5,PS_TYPE_U32);
+        in->n = 5;
+        out->n = 5;
+        tempVect = out;
+        in->type.type = PS_TYPE_BOOL;
+        out = psVectorSortIndex(out,in);
+        ok( out == NULL, "Did return NULL");
+        in->type.type = PS_TYPE_U8;
+        psFree(in);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     // Test G - Free vectors
-    psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false);
-    ok(!nLeaks, "Found %d memory leaks\n", nLeaks);
-    psS32 nBad = psMemCheckCorruption(stderr, false);
-    ok(!nBad, "Found %d bad memory blocks\n", nBad);
+    {
+        psMemId id = psMemGetId();
+        psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false);
+        ok(!nLeaks, "Found %d memory leaks", nLeaks);
+        psS32 nBad = psMemCheckCorruption(stderr, false);
+        ok(!nBad, "Found %d bad memory blocks", nBad);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 }

trunk/psLib/test/mathtypes/tap_psVectorSort_03.c

@@ -3 +3 @@
  *  @brief Test driver for psVectorSort functions
  *
- *  This test driver contains the following tests for psVectorSort test point 3:
- *     A)  Create float vectors of different sizes
- *     B)  Attempt to sort vectors...should get errors
- *     C)  Create float vector and double vector
- *     D)  Attempt to sort vectors...should get errors
- *     E)  Free float, double vectors
- *
  *  @author  Ross Harman, MHPCC
  *
- *  @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
- *  @date  $Date: 2007-01-24 22:14:48 $
+ *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
+ *  @date  $Date: 2007-04-10 21:09:31 $
+ *
+ *  XXX: These tests are obsolete.  psVectorSOrt no longer returns error
+ *  with incorrect input vector types or sizes
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
@@ -28 +24 @@
            char* argv[])
 {
-    plan_tests(2);
+    psLogSetFormat("HLNM");
+    psLogSetLevel(PS_LOG_INFO);
+    plan_tests(1);
+    ok(true, "cake");
 
-    psVector *in = NULL;
-    psVector *out = NULL;
-    psVector *in2 = NULL;
-    psVector *out2 = NULL;
-
-    // Test A - Create float vectors
-    in = psVectorAlloc(5, PS_TYPE_F32);
-    in->n = 5;
-    out = psVectorAlloc(6, PS_TYPE_F32);
-    out->n = 6;
-    in->n = 5;
-    for(psS32 i=0; i<5; i++) {
-        //printf("arr[%d] = %f\n", i, in->data.F32[i]);
+    // Create float vectors with incorrect sizes
+    if (0) {
+        psMemId id = psMemGetId();
+        psVector *in = psVectorAlloc(5, PS_TYPE_F32);
+        psVector *out = psVectorAlloc(6, PS_TYPE_F32);
+        psVector *out2 = psVectorSort(out, in);
+        ok(out2 == NULL, "psVectorSort() returned() NULL with non-uniform verctor input sizes");
+        psFree(in);
+        psFree(out);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     }
 
 
-    // Test B - Sort input float vector and put results into output float vector
-    out = psVectorSort(out, in);
-
-    // Test C - Create float vector and double vector
-    in2 = psVectorAlloc(5, PS_TYPE_F32);
-    in2->n = 5;
-    out2 = psVectorAlloc(5, PS_TYPE_F64);
-    out2->n = 5;
-    for(psS32 j=0; j<5; j++) {
-        //printf("vec[%d] = %f\n", j, in2->data.F32[j]);
+    // Create float vector and double vector
+    if (0) {
+        psMemId id = psMemGetId();
+        psVector *in2 = psVectorAlloc(5, PS_TYPE_F32);
+        psVector *out2 = psVectorAlloc(5, PS_TYPE_F64);
+        psVector *out3 = psVectorSort(out2, in2);
+        ok(out3 == NULL, "psVectorSort() returned() NULL with non-uniform verctor input types");
+        psFree(in2);
+        psFree(out2);
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     }
-
-    // Test D - Attempt to sort vectors with output of different type should create error
-    out2 = psVectorSort(out2, in2);
-
-    // Test C - Free float vectors
-    psFree(in);
-    psFree(in2);
-    psFree(out);
-    psFree(out2);
-    psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false);
-    ok(!nLeaks, "Found %d memory leaks\n", nLeaks);
-    psS32 nBad = psMemCheckCorruption(stderr, false);
-    ok(!nBad, "Found %d bad memory blocks\n", nBad);
 }

trunk/psLib/test/mathtypes/tap_psVectorSort_04.c

@@ -3 +3 @@
  *  @brief Test driver for psVectorSort functions
  *
- *  This test driver contains the following tests for psVectorSort test point 4:
- *     A)  Attempt to sort with null input vector
- *     B)  Free vectors
- *
  *  @author  Ross Harman, MHPCC
  *
- *  @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
- *  @date  $Date: 2007-01-24 22:14:48 $
+ *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
+ *  @date  $Date: 2007-04-10 21:09:31 $
  *
  *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
  *
  */
-
 #include <pslib.h>
-
 #include "tap.h"
 #include "pstap.h"
@@ -25 +19 @@
            char* argv[])
 {
+    psLogSetFormat("HLNM");
+    psLogSetLevel(PS_LOG_INFO);
     plan_tests(2);
 
-    psVector *badIn = NULL;
-    psVector *goodOut = psVectorAlloc(5, PS_TYPE_F32);
 
-    // Test A - Attempt to sort with null input vector
-    goodOut = psVectorSort(goodOut, badIn);
-
-    // Test B - Free vectors
-    psFree(goodOut);
-    psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false);
-    ok(!nLeaks, "Found %d memory blocks\n", nLeaks);
-    psS32 nBad = psMemCheckCorruption(stderr, false);
-    ok(!nBad, "Found %d bad memory blocks\n", nBad);
+    // Attempt to sort with null input vector
+    {
+        psMemId id = psMemGetId();
+        psVector *goodOut = psVectorAlloc(5, PS_TYPE_F32);
+        goodOut = psVectorSort(goodOut, NULL);
+        ok(goodOut == NULL, "psVectorSort() returned NULL with NULL input vector");
+        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
+    }
 }