Index: trunk/psLib/test/math/tap_psPolynomialEval4D.c
===================================================================
--- trunk/psLib/test/math/tap_psPolynomialEval4D.c	(revision 11422)
+++ trunk/psLib/test/math/tap_psPolynomialEval4D.c	(revision 13124)
@@ -4,6 +4,6 @@
 *  ORD and CHEB type polynomials.
 *
-*  @version  $Revision: 1.4 $  $Name: not supported by cvs2svn $
-*  @date  $Date: 2007-01-30 04:49:52 $
+*  @version  $Revision: 1.5 $  $Name: not supported by cvs2svn $
+*  @date  $Date: 2007-05-02 04:20:06 $
 *
 * Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
@@ -363,5 +363,25 @@
     psLogSetFormat("HLNM");
     psLogSetLevel(PS_LOG_INFO);
-    plan_tests(37);
+    plan_tests(56);
+
+
+    // Allocate polynomial with unallowed type
+    {
+        psMemId id = psMemGetId();
+        psPolynomial4D* polyOrd = psPolynomial4DAlloc(99, TERMS-1, TERMS-1, TERMS-1, TERMS-1);
+        ok(polyOrd == NULL, "psPolynomial4DAlloc() returned NULL with unallowed type");
+        psFree(polyOrd);
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
+
+    // Evaluate NULL polynomial
+    {
+        psMemId id = psMemGetId();
+        psF64 result = psPolynomial4DEval(NULL, 0.0, 0.0, 0.0, 0.0);
+        ok(isnan(result), "psPolynomial4DEval() returned NAN with unallowed type");
+        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+    }
+
 
     // Allocate and evaluate an ordinary polynomial structure
@@ -444,20 +464,4 @@
 
 
-    // XXX: This is wierd: why the skip()?
-    // Allocate polynomial with unallowed type
-    {
-        psMemId id = psMemGetId();
-        psPolynomial4D* polyOrd = psPolynomial4DAlloc(99, TERMS-1, TERMS-1, TERMS-1, TERMS-1);
-        ok(polyOrd == NULL, "Ordinary polynomial allocation successful");
-        skip_start(polyOrd == NULL, 1, "Skipping tests because psPolynomial4DAlloc() failed");
-
-        // Attempt to evaluation invalid polynomial type
-        psF64 result = psPolynomial4DEval(polyOrd,0.0, 0.0, 0.0, 0.0);
-        ok(isnan(result), "psPolynomial3DEval() did not return NAN, as expected");
-        skip_end();
-        psFree(polyOrd);
-        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
-    }
-
     // Allocate polynomial, test the psPolynomial4DEvalVector() routines
     {
@@ -514,37 +518,82 @@
         ok(!errorFlag, "psPolynomial4DEvalVector() produced the correct answers");
 
-        // Attempt to invoke function with null polynomial
-        ok(psPolynomial4DEvalVector(NULL,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL polynomial");
-
-        // Attempt to invoke function with null input vector
-        ok(psPolynomial4DEvalVector(polyOrd,NULL,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
-
-        // Attempt to invoke function with null input vector
-        ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,NULL,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
-
-        // Attempt to invoke function with null input vector
-        ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,NULL,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
-
-        // Attempt to invoke function with null input vector
-        ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,NULL) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
+
+        // Attempt to invoke function with NULL polynomial
+        {
+            psMemId id = psMemGetId();
+            ok(psPolynomial4DEvalVector(NULL,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL polynomial");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
+
+
+        // Attempt to invoke function with NULL input vector
+        {
+            psMemId id = psMemGetId();
+            ok(psPolynomial4DEvalVector(polyOrd,NULL,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
+
+
+        // Attempt to invoke function with NULL input vector
+        {
+            psMemId id = psMemGetId();
+            ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,NULL,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
+
+
+        // Attempt to invoke function with NULL input vector
+        {
+            psMemId id = psMemGetId();
+            ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,NULL,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
+
+
+        // Attempt to invoke function with NULL input vector
+        {
+            psMemId id = psMemGetId();
+            ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,NULL) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
+
 
         // Attempt to invoke function with a non F64 type input vector
-        inputOrdX->type.type = PS_TYPE_U8;
-        ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+        {
+            psMemId id = psMemGetId();
+            inputOrdX->type.type = PS_TYPE_U8;
+            ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
         inputOrdX->type.type = PS_TYPE_F64;
 
+
         // Attempt to invoke function with a non F64 type input vector
-        inputOrdY->type.type = PS_TYPE_U8;
-        ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+        {
+            psMemId id = psMemGetId();
+            inputOrdY->type.type = PS_TYPE_U8;
+            ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
         inputOrdY->type.type = PS_TYPE_F64;
 
+
         // Attempt to invoke function with a non F64 type input vector
-        inputOrdZ->type.type = PS_TYPE_U8;
-        ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+        {
+            psMemId id = psMemGetId();
+            inputOrdZ->type.type = PS_TYPE_U8;
+            ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
         inputOrdZ->type.type = PS_TYPE_F64;
 
+
         // Attempt to invoke function with a non F64 type input vector
-        inputOrdW->type.type = PS_TYPE_U8;
-        ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+        {
+            psMemId id = psMemGetId();
+            inputOrdW->type.type = PS_TYPE_U8;
+            ok(psPolynomial4DEvalVector(polyOrd,inputOrdW,inputOrdX,inputOrdY,inputOrdZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
         inputOrdW->type.type = PS_TYPE_F64;
         psFree(outputOrd);
@@ -613,37 +662,82 @@
         ok(!errorFlag, "psPolynomial4DEvalVector() produced the correct answers");
 
-        // Attempt to invoke function with null polynomial
-        ok(psPolynomial4DEvalVector(NULL,inputChebW,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL polynomial");
-
-        // Attempt to invoke function with null input vector
-        ok(psPolynomial4DEvalVector(polyCheb,NULL,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
-
-        // Attempt to invoke function with null input vector
-        ok(psPolynomial4DEvalVector(polyCheb,inputChebW,NULL,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
-
-        // Attempt to invoke function with null input vector
-        ok(psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,NULL,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
-
-        // Attempt to invoke function with null input vector
-        ok(psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,NULL) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
+
+        // Attempt to invoke function with NULL polynomial
+        {
+            psMemId id = psMemGetId();
+            ok(psPolynomial4DEvalVector(NULL,inputChebW,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL polynomial");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
+
+
+        // Attempt to invoke function with NULL input vector
+        {
+            psMemId id = psMemGetId();
+            ok(psPolynomial4DEvalVector(polyCheb,NULL,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
+
+
+        // Attempt to invoke function with NULL input vector
+        {
+            psMemId id = psMemGetId();
+            ok(psPolynomial4DEvalVector(polyCheb,inputChebW,NULL,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
+
+
+        // Attempt to invoke function with NULL input vector
+        {
+            psMemId id = psMemGetId();
+            ok(psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,NULL,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
+
+
+        // Attempt to invoke function with NULL input vector
+        {
+            psMemId id = psMemGetId();
+            ok(psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,NULL) == NULL, "psPolynomial4DEvalVector() produced NULL when called with NULL input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
+
 
         // Attempt to invoke function with a non F64 type input vector
-        inputChebX->type.type = PS_TYPE_U8;
-        ok(psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+        {
+            psMemId id = psMemGetId();
+            inputChebX->type.type = PS_TYPE_U8;
+            ok(psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
         inputChebX->type.type = PS_TYPE_F64;
 
+
         // Attempt to invoke function with a non F64 type input vector
-        inputChebY->type.type = PS_TYPE_U8;
-        ok(psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+        {
+            psMemId id = psMemGetId();
+            inputChebY->type.type = PS_TYPE_U8;
+            ok(psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
         inputChebY->type.type = PS_TYPE_F64;
 
+
         // Attempt to invoke function with a non F64 type input vector
-        inputChebZ->type.type = PS_TYPE_U8;
-        ok(psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+        {
+            psMemId id = psMemGetId();
+            inputChebZ->type.type = PS_TYPE_U8;
+            ok(psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
         inputChebZ->type.type = PS_TYPE_F64;
 
+
         // Attempt to invoke function with a non F64 type input vector
-        inputChebW->type.type = PS_TYPE_U8;
-        ok(psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+        {
+            psMemId id = psMemGetId();
+            inputChebW->type.type = PS_TYPE_U8;
+            ok(psPolynomial4DEvalVector(polyCheb,inputChebW,inputChebX,inputChebY,inputChebZ) == NULL, "psPolynomial4DEvalVector() produced NULL when called with non F64 input vector");
+            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
+        }
         inputChebW->type.type = PS_TYPE_F64;
         psFree(outputCheb);