Index: trunk/psLib/test/math/tst_psFunc10.c
===================================================================
--- trunk/psLib/test/math/tst_psFunc10.c	(revision 5090)
+++ trunk/psLib/test/math/tst_psFunc10.c	(revision 5092)
@@ -4,6 +4,6 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.4 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2005-09-22 02:47:16 $
+*  @version  $Revision: 1.5 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2005-09-22 20:45:43 $
 *
 * Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
@@ -22,6 +22,6 @@
 
 testDescription tests[] = {
-                              {testPoly3DEval,583,"psPolynomial3DEval",0,false},
-                              {testPoly3DEvalVector,000,"psPolynomial3DEvalVector",0,false},
+                              {testPoly3DEval,583,"psPolynomial3DEval",true,false},
+                              {testPoly3DEvalVector,000,"psPolynomial3DEvalVector",true,false},
                               {NULL}
                           };
@@ -133,62 +133,9 @@
 
 // This test will verify operation of 1D polynomial evaluation
-/*psS32 testPoly3DEval(void)
-{
-    psF32  result;
-    psF32  resultCheb;
- 
-    // Allocate polynomial structure
-    psPolynomial3D*  polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_ORD);
-    psPolynomial3D*  polyCheb = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1, PS_POLYNOMIAL_CHEB);
-    // Set polynomial members
-    for(psS32 i = 0; i < TERMS; i++) {
-        for(psS32 j = 0; j < TERMS; j++) {
-            for(psS32 k = 0; k < TERMS; k++) {
-                polyOrd->coeff[i][j][k] = poly3DCoeff[i][j][k];
-                polyOrd->mask[i][j][k]  = poly3DMask[i][j][k];
-                polyCheb->coeff[i][j][k] = 1.0;
-                polyCheb->mask[i][j][k]  = poly3DMask[i][j][k];
-            }
-        }
-    }
-    // Evaluate test points and verify results
-    for(psS32 i = 0; i < TESTPOINTS; i++) {
-        result = psPolynomial3DEval(polyOrd,poly3DXYZValue[i][0],poly3DXYZValue[i][1],
-                                    poly3DXYZValue[i][2]);
-        if(fabs(poly3DResult[i]-result) > ERROR_TOL ) {
-            psError(PS_ERR_UNKNOWN,true,"Evaluated value %g not as expected %g",
-                    result, poly3DResult[i]);
-            return i;
-        }
-        resultCheb = psPolynomial3DEval(polyCheb,poly3DXYZChebValue[i][0], poly3DXYZChebValue[i][1],
-                                        poly3DXYZChebValue[i][2]);
-        if(fabs(poly3DChebResult[i]-resultCheb) > ERROR_TOL ) {
-            psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
-                    resultCheb, poly3DChebResult[i]);
-            return 5*i;
-        }
-    }
-    psFree(polyOrd);
-    psFree(polyCheb);
- 
-    // Allocate polynomial with invalid type
-    polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1, 99);
-    // Attempt to evaluation invalid polynomial type
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message invalid type");
-    result = psPolynomial3DEval(polyOrd,0.0, 0.0, 0.0);
-    if ( !isnan(result) ) {
-        psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
-        return 20;
-    }
-    psFree(polyOrd);
- 
-    return 0;
-}
-*/
-// This test will verify operation of 1D polynomial evaluation
 psS32 testPoly3DEval(void)
 {
     psF64  result;
     psF64  resultCheb;
+    psBool testStatus = true;
 
     // Allocate polynomial structure
@@ -211,14 +158,14 @@
                                     Dpoly3DXYZValue[i][2]);
         if(fabs(Dpoly3DResult[i]-result) > ERROR_TOL ) {
-            psError(PS_ERR_UNKNOWN,true,"Evaluated value %lg not as expected %lg",
-                    result, Dpoly3DResult[i]);
-            return i;
+            printf("TEST ERROR: Evaluated value %lg not as expected %lg.\n",
+                   result, Dpoly3DResult[i]);
+            testStatus = false;
         }
         resultCheb = psPolynomial3DEval(polyCheb,Dpoly3DXYZChebValue[i][0],Dpoly3DXYZChebValue[i][1],
                                         Dpoly3DXYZChebValue[i][2]);
         if(fabs(Dpoly3DChebResult[i]-resultCheb) > ERROR_TOL ) {
-            psError(PS_ERR_UNKNOWN,true,"Evaluated Chebyshev value %lg not as expected %lg",
-                    resultCheb, Dpoly3DChebResult[i]);
-            return 5*i;
+            printf("TEST ERROR: Evaluated Chebyshev value %lg not as expected %lg.\n",
+                   resultCheb, Dpoly3DChebResult[i]);
+            testStatus = false;
         }
     }
@@ -232,6 +179,6 @@
     result = psPolynomial3DEval(polyOrd,0.0, 0.0, 0.0);
     if ( !isnan(result) ) {
-        psError(PS_ERR_UNKNOWN,true,"Did not return NAN for invalid polynomial type");
-        return 20;
+        printf("TEST ERROR: Did not return NAN for invalid polynomial type.\n");
+        testStatus = false;
     }
     psFree(polyOrd);
@@ -240,141 +187,7 @@
 }
 
-/*psS32 testPoly3DEvalVector(void)
-{
-    // Allocate polynomial
-    psPolynomial3D* polyOrd  = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_ORD);
-    psPolynomial3D* polyCheb = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_CHEB);
- 
-    // Set polynomial members
-    for(psS32 i = 0; i < TERMS; i++) {
-        for(psS32 j = 0; j < TERMS; j++) {
-            for(psS32 k = 0; k < TERMS; k++) {
-                polyOrd->coeff[i][j][k] = poly3DCoeff[i][j][k];
-                polyOrd->mask[i][j][k]  = poly3DMask[i][j][k];
-                polyCheb->coeff[i][j][k] = 1.0;
-                polyCheb->mask[i][j][k]  = poly3DMask[i][j][k];
-            }
-        }
-    }
- 
-    // Create input vectors
-    psVector* inputOrdX  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
-    psVector* inputOrdY  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
-    psVector* inputOrdZ  = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
-    psVector* inputChebX = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
-    psVector* inputChebY = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
-    psVector* inputChebZ = psVectorAlloc(TESTPOINTS, PS_TYPE_F32);
-    for(psS32 i = 0; i < TESTPOINTS; i++) {
-        inputOrdX->data.F32[i] = poly3DXYZValue[i][0];
-        inputOrdY->data.F32[i] = poly3DXYZValue[i][1];
-        inputOrdZ->data.F32[i] = poly3DXYZValue[i][2];
-        inputChebX->data.F32[i] = poly3DXYZChebValue[i][0];
-        inputChebY->data.F32[i] = poly3DXYZChebValue[i][1];
-        inputChebZ->data.F32[i] = poly3DXYZChebValue[i][2];
-    }
- 
-    // Evaluate the vectors
-    psVector* outputOrd = psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ);
-    if(outputOrd == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
-        return 1;
-    }
-    if(outputOrd->type.type != PS_TYPE_F32) {
-        psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
-                outputOrd->type.type, PS_TYPE_F32);
-        return 2;
-    }
-    psVector* outputCheb = psPolynomial3DEvalVector(polyCheb,inputChebX,inputChebY,inputChebZ);
-    if(outputCheb == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
-        return 1;
-    }
-    if(outputCheb->type.type != PS_TYPE_F32) {
-        psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
-                outputCheb->type.type, PS_TYPE_F32);
-        return 2;
-    }
- 
-    // Verify the results
-    for(psS32 i = 0; i < TESTPOINTS; i++) {
-        if(fabs(poly3DResult[i]-outputOrd->data.F32[i]) > ERROR_TOL) {
-            psError(PS_ERR_UNKNOWN,true,"Result[%d] %g not equal to expected %g",
-                    i, outputOrd->data.F32[i], poly3DResult[i]);
-            return i*5;
-        }
-        if(fabs(poly3DChebResult[i]-outputCheb->data.F32[i]) > ERROR_TOL) {
-            psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %g not equal to expected %g",
-                    i, outputCheb->data.F32[i], poly3DChebResult[i]);
-            return i*10;
-        }
-    }
- 
-    // Attempt to invoke function with null polynomial
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
-    if(psPolynomial3DEvalVector(NULL, inputOrdX, inputOrdY, inputOrdZ) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
-        return 60;
-    }
- 
-    // Attempt to invoke function with null input vector
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psPolynomial3DEvalVector(polyOrd,NULL, inputOrdY,inputOrdZ) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
-        return 61;
-    }
-    // Attempt to invoke function with null input vector
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psPolynomial3DEvalVector(polyOrd, inputOrdX, NULL,inputOrdZ) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
-        return 62;
-    }
-    // Attempt to invoke function with null input vector
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
-    if(psPolynomial3DEvalVector(polyOrd, inputOrdX,inputOrdY,NULL) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
-        return 63;
-    }
- 
-    // Attempt to invoke function with a non F32 type input vector
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
-    inputOrdX->type.type = PS_TYPE_U8;
-    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector");
-        return 65;
-    }
-    inputOrdX->type.type = PS_TYPE_F32;
-    // Attempt to invoke function with a non F32 type input vector
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
-    inputOrdY->type.type = PS_TYPE_U8;
-    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector");
-        return 66;
-    }
-    inputOrdY->type.type = PS_TYPE_F32;
-    // Attempt to invoke function with a non F32 type input vector
-    psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for invalid input type");
-    inputOrdZ->type.type = PS_TYPE_U8;
-    if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F32 input vector");
-        return 67;
-    }
-    inputOrdZ->type.type = PS_TYPE_F32;
- 
-    psFree(inputOrdX);
-    psFree(inputOrdY);
-    psFree(inputOrdZ);
-    psFree(inputChebX);
-    psFree(inputChebY);
-    psFree(inputChebZ);
-    psFree(outputOrd);
-    psFree(outputCheb);
-    psFree(polyOrd);
-    psFree(polyCheb);
- 
-    return 0;
-}
-*/
 psS32 testPoly3DEvalVector(void)
 {
+    psBool testStatus = true;
     // Allocate polynomial
     psPolynomial3D* polyOrd = psPolynomial3DAlloc(TERMS-1, TERMS-1, TERMS-1,PS_POLYNOMIAL_ORD);
@@ -412,21 +225,21 @@
     psVector* outputOrd = psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ);
     if(outputOrd == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
-        return 1;
+        printf("TEST ERROR: Unexpected return of NULL.\n");
+        testStatus = false;
     }
     if(outputOrd->type.type != PS_TYPE_F64) {
-        psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
-                outputOrd->type.type, PS_TYPE_F64);
-        return 2;
+        printf("TEST ERROR: Output vector of type %d expected %d.\n",
+               outputOrd->type.type, PS_TYPE_F64);
+        testStatus = false;
     }
     psVector* outputCheb = psPolynomial3DEvalVector(polyCheb,inputChebX,inputChebY,inputChebZ);
     if(outputCheb == NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Unexpected return of NULL.");
-        return 1;
+        printf("TEST ERROR: Unexpected return of NULL.\n");
+        testStatus = false;
     }
     if(outputCheb->type.type != PS_TYPE_F64) {
-        psError(PS_ERR_UNKNOWN,true,"Output vector of type %d expected %d",
-                outputCheb->type.type, PS_TYPE_F64);
-        return 2;
+        printf("TEST ERROR: Output vector of type %d expected %d.\n",
+               outputCheb->type.type, PS_TYPE_F64);
+        testStatus = false;
     }
 
@@ -434,12 +247,12 @@
     for(psS32 i = 0; i < TESTPOINTS; i++) {
         if(fabs(Dpoly3DResult[i]-outputOrd->data.F64[i]) > ERROR_TOL) {
-            psError(PS_ERR_UNKNOWN,true,"Result[%d] %lg not equal to expected %lg",
-                    i, outputOrd->data.F64[i], Dpoly3DResult[i]);
-            return i*5;
+            printf("TEST ERROR: Result[%d] %lg not equal to expected %lg.\n",
+                   i, outputOrd->data.F64[i], Dpoly3DResult[i]);
+            testStatus = false;
         }
         if(fabs(Dpoly3DChebResult[i]-outputCheb->data.F64[i]) > ERROR_TOL) {
-            psError(PS_ERR_UNKNOWN,true,"ResultCheb[%d] %lg not equal to expected %lg",
-                    i, outputCheb->data.F64[i], Dpoly3DChebResult[i]);
-            return i*10;
+            printf("TEST ERROR: ResultCheb[%d] %lg not equal to expected %lg.\n",
+                   i, outputCheb->data.F64[i], Dpoly3DChebResult[i]);
+            testStatus = false;
         }
     }
@@ -448,6 +261,6 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL polynomial");
     if(psPolynomial3DEvalVector(NULL,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL polynomial");
-        return 60;
+        printf("TEST ERROR: Return of NULL expected for NULL polynomial.\n");
+        testStatus = false;
     }
 
@@ -455,18 +268,18 @@
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
     if(psPolynomial3DEvalVector(polyOrd,NULL,inputOrdY,inputOrdZ) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
-        return 61;
+        printf("TEST ERROR: Return of NULL expected for NULL input vector.\n");
+        testStatus = false;
     }
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
     if(psPolynomial3DEvalVector(polyOrd,inputOrdX,NULL,inputOrdZ) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
-        return 62;
+        printf("TEST ERROR: Return of NULL expected for NULL input vector.\n");
+        testStatus = false;
     }
     // Attempt to invoke function with null input vector
     psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error message for NULL input vector");
     if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,NULL) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return of NULL expected for NULL input vector");
-        return 63;
+        printf("TEST ERROR: Return of NULL expected for NULL input vector.\n");
+        testStatus = false;
     }
 
@@ -475,6 +288,6 @@
     inputOrdX->type.type = PS_TYPE_U8;
     if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
-        return 64;
+        printf("TEST ERROR: Return NULL expected for non-F64 input vector.\n");
+        testStatus = false;
     }
     inputOrdX->type.type = PS_TYPE_F64;
@@ -483,6 +296,6 @@
     inputOrdY->type.type = PS_TYPE_U8;
     if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
-        return 65;
+        printf("TEST ERROR: Return NULL expected for non-F64 input vector.\n");
+        testStatus = false;
     }
     inputOrdY->type.type = PS_TYPE_F64;
@@ -491,6 +304,6 @@
     inputOrdZ->type.type = PS_TYPE_U8;
     if(psPolynomial3DEvalVector(polyOrd,inputOrdX,inputOrdY,inputOrdZ) != NULL) {
-        psError(PS_ERR_UNKNOWN,true,"Return NULL expected for non-F64 input vector");
-        return 66;
+        printf("TEST ERROR: Return NULL expected for non-F64 input vector.\n");
+        testStatus = false;
     }
     inputOrdZ->type.type = PS_TYPE_F64;