Changeset 9597

Timestamp:

Oct 16, 2006, 4:35:25 PM (20 years ago)

Author:

drobbin

Message:

Added null check to PS_ASSERT_PTR in psAssert.h
edited formatting of output of psArrayRemoveData tests
Edited PolynomialXDto/fromMetadata to reflect recent changes to mask handling and added 1D cases.

Location:

trunk/psLib

Files:

• src/sys/psAssert.h (modified) (1 diff)
• test/types/tap_psArray_all.c (modified) (1 diff)
• test/types/tap_psMetadata_polynomials.c (modified) (23 diffs)

trunk/psLib/src/sys/psAssert.h

@@ -13 +13 @@
 #define PS_ASSERT_PTR(NAME, RVAL) \
 { \
+    if (NAME == NULL) return(RVAL); \
     psMemBlock *mb = (psMemBlock*)(NAME) - 1; \
     if (mb->startblock != P_PS_MEMMAGIC || mb->endblock != P_PS_MEMMAGIC || \

trunk/psLib/test/types/tap_psArray_all.c

@@ -155 +155 @@
         psArray *temp = NULL;
         ok( !psArrayRemoveData(temp, s2),
-            "psArrayRemoveData:         return false for NULL input psArray.");
+            "psArrayRemoveData:     return false for NULL input psArray.");
     }
     //Return true for successful removal
     {
         ok( psArrayRemoveData(a, s2) && a->n == 2,
-            "psArrayRemoveData:         return true for successful removal.");
+            "psArrayRemoveData:     return true for successful removal.");
     }
 

trunk/psLib/test/types/tap_psMetadata_polynomials.c

@@ -17 +17 @@
 #include "pstap.h"
 
+void test1Dcase(void);
 void test2Dcase(void);
 void test3Dcase(void);
@@ -23 +24 @@
 int main(void)
 {
-    plan_tests(58);
-
-    diag("psPolynomial(2D, 3D, & 4D)(to/from)MD tests");
-
+    plan_tests(89);
+
+    diag("psPolynomial(1D, 2D, 3D, & 4D)(to/from)Metadata tests");
+
+    test1Dcase();
     test2Dcase();
     test3Dcase();
@@ -34 +36 @@
 }
 
+
+void test1Dcase(void)
+{
+    diag("  >>>Test 1:  psPolynomial1DtoMetadata & psPolynomial1DfromMetadata functions");
+    psMetadata *md = psMetadataAlloc();
+    psPolynomial1D *p1d = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 1);
+    p1d->coeff[0] = 1.1;
+    p1d->coeff[1] = 2.2;
+    p1d->coeffErr[0] = 0.1;
+    p1d->coeffErr[1] = 0.2;
+
+    //psPolynomial1DtoMetadata
+    //Return a valid metadata containing a polynomial-metadata structure
+    {
+        diag ("example of 1DtoMD using the names not the sequence");
+
+        ok( psPolynomial1DtoMetadata(md, p1d, "polyMD"),
+            "psPolynomial1DtoMetadata:      return true for valid inputs.");
+        psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
+        skip_start( polyMDtemp == NULL , 1,
+                    "Skipping 1 tests because psPolynomial1DtoMetadata has errors");
+
+        bool status;
+        int nX = psMetadataLookupS32(&status, polyMDtemp, "NORDER_X");
+        ok(status,
+           "psPolynomial1DtoMetadata:      found NORDER_X");
+        ok(nX == 1,
+           "psPolynomial1DtoMetadata:      NORDER_X is 1");
+
+        double val;
+        val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X00");
+        ok(status,
+           "psPolynomial1DtoMetadata:      found VAL_X00");
+        ok_double(val, 1.1,
+                  "psPolynomial1DtoMetadata:      VAL_X00 is %lf", val);
+
+        val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X01");
+        ok(status,
+           "psPolynomial1DtoMetadata:      found VAL_X01");
+        ok_double(val, 2.2,
+                  "psPolynomial1DtoMetadata:      VAL_X01 is %lf", val);
+        skip_end();
+    }
+
+    //Return false for no-name polynomial
+    {
+        ok( !psPolynomial1DtoMetadata(md, p1d, ""),
+            "psPolynomial1DtoMetadata:      return false for no-name.");
+    }
+    //Return false for NULL-name polynomial
+    {
+        ok( !psPolynomial1DtoMetadata(md, p1d, NULL),
+            "psPolynomial1DtoMetadata:      return false for NULL name input.");
+    }
+    //Return false for NULL metadata input
+    {
+        ok( !psPolynomial1DtoMetadata(NULL, p1d, "polyMD"),
+            "psPolynomial1DtoMetadata:     return false for NULL metadata input.");
+    }
+    //Return false for NULL polynomial input
+    {
+        ok( !psPolynomial1DtoMetadata(md, NULL, "polyMD"),
+            "psPolynomial1DtoMetadata:     return false for NULL polynomial input.");
+    }
+    //Return true for polynomial with 1 element, a constant
+    {
+        psPolynomial1D *constPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 0);
+        constPoly->coeff[0] = 6.66;
+        ok( psPolynomial1DtoMetadata(md, constPoly, "polyMD"),
+            "psPolynomial1DtoMetadata:     return true for constant polynomial (1 element != 0).");
+        psFree(constPoly);
+    }
+    //Return false for non-ordinary polynomial
+    {
+        psPolynomial1D *p1d1 = psPolynomial1DAlloc(PS_POLYNOMIAL_CHEB, 1);
+        p1d1->coeff[0] = 1.1;
+        ok( !psPolynomial1DtoMetadata(md, p1d1, "polyMD"),
+            "psPolynomial1DtoMetadata:     return false for chebyshev polynomial");
+        psFree(p1d1);
+    }
+
+    //psPolynomial1DfromMetadata Tests
+    //Return NULL for NULL metadata input.
+    {
+        psPolynomial1D *emptyPoly1D = NULL;
+        emptyPoly1D = psPolynomial1DfromMetadata(NULL);
+        ok( emptyPoly1D == NULL,
+            "psPolynomial1DfromMetadata:   return NULL for NULL metadata input.");
+    }
+    //Get a polynomial from Metadata.
+    psPolynomial1D *outPoly = NULL;
+    psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
+    outPoly = psPolynomial1DfromMetadata(polyMDtemp);
+    {
+        skip_start( outPoly == NULL, 1,
+                    "Skipping 1 tests because psPolynomial1DfromMetadata has errors.");
+        ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
+            abs(outPoly->coeff[0] - 1.1) < DBL_EPSILON,
+            "psPolynomial1DfromMetadata:   return correct polynomial from metadata");
+        skip_end();
+    }
+    //Get a polynomial from Metadata with mask[0] == 1.
+    psFree(outPoly);
+    outPoly = NULL;
+    psPolynomial1D *maskPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 0);
+    maskPoly->coeff[0] = 6.66;
+    maskPoly->mask[0] = 1;
+    psMetadata *newmd = psMetadataAlloc();
+    psPolynomial1DtoMetadata(newmd, maskPoly, "polyMD");
+    psMetadata *polyMask = psMetadataLookupMetadata(NULL, newmd, "polyMD");
+    outPoly = psPolynomial1DfromMetadata(polyMask);
+    {
+        ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 0 &&
+            outPoly->mask[0] == 1,
+            "psPolynomial1DfromMetadata:   return correct polynomial (w/mask) from metadata");
+    }
+    psFree(maskPoly);
+    psFree(newmd);
+    //Return NULL for wrong NELEMENTS
+    psMetadataItem *nElementItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
+    nElementItem->data.S32 -= 1;
+    psFree(outPoly);
+    outPoly = NULL;
+    outPoly = psPolynomial1DfromMetadata(polyMDtemp);
+    {
+        ok( outPoly == NULL,
+            "psPolynomial1DfromMetadata:   "
+            "return NULL for metadata-polynomial with wrong NELEMENTS");
+    }
+    //Return NULL for missing NELEMENTS
+    psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL);
+    psFree(outPoly);
+    outPoly = NULL;
+    outPoly = psPolynomial1DfromMetadata(polyMDtemp);
+    {
+        ok( outPoly == NULL,
+            "psPolynomial1DfromMetadata:   "
+            "return NULL for metadata-polynomial with no NELEMENTS");
+    }
+
+    //Return NULL for polynomial in metadata with no x-order
+    psMetadataRemoveKey(polyMDtemp, "NORDER_X");
+    psFree(outPoly);
+    outPoly = NULL;
+    outPoly = psPolynomial1DfromMetadata(polyMDtemp);
+    {
+        ok( outPoly == NULL,
+            "psPolynomial1DfromMetadata:   "
+            "return NULL for metadata-polynomial with no x-order");
+    }
+
+    //Check for Memory leaks
+    {
+        psFree(outPoly);
+        psFree(p1d);
+        psFree(md);
+        checkMem();
+    }
+}
+
 void test2Dcase(void)
 {
-    diag("  >>>Test 1:  psPolynomial2DtoMetadata & psPolynomial2DfromMetadata functions");
+    diag("  >>>Test 2:  psPolynomial2DtoMetadata & psPolynomial2DfromMetadata functions");
     psMetadata *md = psMetadataAlloc();
     psPolynomial2D *p2d = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 1, 1);
@@ -52 +214 @@
     {
         ok( psPolynomial2DtoMetadata(md, p2d, "polyMD"),
-            "psPolynomial2DtoMetadata:      return true for valid inputs.");
+            "psPolynomial2DtoMetadata:     return true for valid inputs.");
 
         psMetadataConfigWrite (md, "test.md");
 
-        ok (0, "these tests are relying on the ORDER of the MD components not the NAMES");
-        ok (0, "these seem like irrelevant tests");
+        //XXX        ok (0, "these tests are relying on the ORDER of the MD components not the NAMES");
+        //XXX        ok (0, "these seem like irrelevant tests");
         psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
         skip_start( polyMDtemp == NULL , 1,
@@ -65 +227 @@
                     "Skipping 2 tests because psPolynomial2DtoMetadata has errors in order elements");
         ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1,
-            "psPolynomial2DtoMetadata:      return correct number of x orders.");
+            "psPolynomial2DtoMetadata:     return correct number of x orders.");
         polyItem = psMetadataGet(polyMDtemp, 1);
         ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1,
-            "psPolynomial2DtoMetadata:      return correct number of y orders.");
+            "psPolynomial2DtoMetadata:     return correct number of y orders.");
         skip_end();
         polyItem = psMetadataGet(polyMDtemp, 2);
@@ -75 +237 @@
         ok( !strncmp(polyItem->name, "VAL_X00_Y00", 14) &&
             abs(polyItem->data.F64-1.1) < DBL_EPSILON,
-            "psPolynomial2DtoMetadata:      return correct first element.");
-        polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
+            "psPolynomial2DtoMetadata:     return correct first element.");
+        polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL-1);
         ok( !strncmp(polyItem->name, "ERR_X01_Y01", 14) &&
             abs(polyItem->data.F64-0.4) < DBL_EPSILON,
-            "psPolynomial2DtoMetadata:      return correct last element.");
+            "psPolynomial2DtoMetadata:     return correct last element.");
         skip_end();
         skip_end();
@@ -90 +252 @@
 
         ok( psPolynomial2DtoMetadata(md, p2d, "polyMD"),
-            "psPolynomial2DtoMetadata:      return true for valid inputs.");
+            "psPolynomial2DtoMetadata:     return true for valid inputs.");
 
         psMetadataConfigWrite (md, "test.md");
@@ -101 +263 @@
         bool status;
         int nX = psMetadataLookupS32(&status, polyMDtemp, "NORDER_X");
-        ok(status, "psPolynomial2DtoMetadata: found NORDER_X");
-        ok(nX == 1, "psPolynomial2DtoMetadata: NORDER_X is 1");
+        ok(status,
+           "psPolynomial2DtoMetadata:     found NORDER_X");
+        ok(nX == 1,
+           "psPolynomial2DtoMetadata:     NORDER_X is 1");
 
         int nY = psMetadataLookupS32(&status, polyMDtemp, "NORDER_Y");
-        ok(status, "psPolynomial2DtoMetadata: found NORDER_Y");
-        ok(nY == 1, "psPolynomial2DtoMetadata: NORDER_Y is 1");
+        ok(status,
+           "psPolynomial2DtoMetadata:     found NORDER_Y");
+        ok(nY == 1,
+           "psPolynomial2DtoMetadata:     NORDER_Y is 1");
 
         double val;
         val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X00_Y00");
-        ok(status, "psPolynomial2DtoMetadata: found VAL_X00_Y00");
-        ok_double(val, 1.1, "psPolynomial2DtoMetadata: VAL_X00_Y00 is %lf", val);
+        ok(status,
+           "psPolynomial2DtoMetadata:     found VAL_X00_Y00");
+        ok_double(val, 1.1,
+                  "psPolynomial2DtoMetadata:     VAL_X00_Y00 is %lf", val);
 
         val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X01_Y01");
-        ok(status, "psPolynomial2DtoMetadata: found VAL_X01_Y01");
-        ok_double(val, 4.4, "psPolynomial2DtoMetadata: VAL_X01_Y01 is %lf", val);
+        ok(status,
+           "psPolynomial2DtoMetadata:     found VAL_X01_Y01");
+        ok_double(val, 4.4,
+                  "psPolynomial2DtoMetadata:     VAL_X01_Y01 is %lf", val);
 
         skip_end();
@@ -123 +293 @@
     {
         ok( !psPolynomial2DtoMetadata(md, p2d, ""),
-            "psPolynomial2DtoMetadata:      return false for no-name.");
+            "psPolynomial2DtoMetadata:     return false for no-name.");
     }
     //Return false for NULL-name polynomial
     {
         ok( !psPolynomial2DtoMetadata(md, p2d, NULL),
-            "psPolynomial2DtoMetadata:      return false for NULL name input.");
+            "psPolynomial2DtoMetadata:     return false for NULL name input.");
     }
     //Return false for NULL metadata input
     {
         ok( !psPolynomial2DtoMetadata(NULL, p2d, "polyMD"),
-            "psPolynomial2DtoMetadata:      return false for NULL metadata input.");
+            "psPolynomial2DtoMetadata:     return false for NULL metadata input.");
     }
     //Return false for NULL polynomial input
     {
         ok( !psPolynomial2DtoMetadata(md, NULL, "polyMD"),
-            "psPolynomial2DtoMetadata:      return false for NULL polynomial input.");
-    }
-    //Return false for empty polynomial
-    {
-        psPolynomial2D *emptyPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0);
-        ok( !psPolynomial2DtoMetadata(md, emptyPoly, "polyMD"),
-            "psPolynomial2DtoMetadata:     return false for empty polynomial input.");
-        psFree(emptyPoly);
+            "psPolynomial2DtoMetadata:     return false for NULL polynomial input.");
     }
     //Return true for polynomial with 1 element, a constant
@@ -184 +347 @@
         skip_end();
     }
-    //Set poly->mask[1][1] = 1 for missing [1][1] element in metadata
-    psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL-1);
+    //Get a polynomial from Metadata with mask[0][0] == 1.
+    psFree(outPoly);
+    outPoly = NULL;
+    psPolynomial2D *maskPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0);
+    maskPoly->coeff[0][0] = 6.66;
+    maskPoly->mask[0][0] = 1;
+    psMetadata *newmd = psMetadataAlloc();
+    psPolynomial2DtoMetadata(newmd, maskPoly, "polyMD");
+    psMetadata *polyMask = psMetadataLookupMetadata(NULL, newmd, "polyMD");
+    outPoly = psPolynomial2DfromMetadata(polyMask);
+    {
+        ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 0 &&
+            outPoly->nY == 0 && outPoly->mask[0][0] == 1,
+            "psPolynomial2DfromMetadata:   return correct polynomial (w/mask) from metadata");
+    }
+    psFree(maskPoly);
+    psFree(newmd);
+    //Return NULL for wrong NELEMENTS
+    psMetadataItem *nElementItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
+    nElementItem->data.S32 -= 1;
     psFree(outPoly);
     outPoly = NULL;
     outPoly = psPolynomial2DfromMetadata(polyMDtemp);
     {
-        //        ok( outPoly->mask[1][1] == 1,
-        //            "psPolynomial2DfromMetadata:   return mask[1][1] == 1 for metadata-polynomial",
-        //            " with missing element");
-        ok( outPoly == NULL,
-            "psPolynomial2DfromMetadata:   return NULL for polynomial with missing coeff");
-    }
+        ok( outPoly == NULL,
+            "psPolynomial2DfromMetadata:   "
+            "return NULL for metadata-polynomial with wrong NELEMENTS");
+    }
+    //Return NULL for missing NELEMENTS
+    psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL);
+    psFree(outPoly);
+    outPoly = NULL;
+    outPoly = psPolynomial2DfromMetadata(polyMDtemp);
+    {
+        ok( outPoly == NULL,
+            "psPolynomial2DfromMetadata:   "
+            "return NULL for metadata-polynomial with no NELEMENTS");
+    }
+
     //Return NULL for polynomial in metadata with no y-order
     psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
+    psFree(outPoly);
+    outPoly = NULL;
     outPoly = psPolynomial2DfromMetadata(polyMDtemp);
     {
         ok( outPoly == NULL,
-            "psPolynomial2DfromMetadata:   return NULL for metadata-polynomial with no y-order");
+            "psPolynomial2DfromMetadata:   "
+            "return NULL for metadata-polynomial with no y-order");
     }
     //Return NULL for polynomial in metadata with no x-order
     psMetadataRemoveKey(polyMDtemp, "NORDER_X");
+    psFree(outPoly);
+    outPoly = NULL;
     outPoly = psPolynomial2DfromMetadata(polyMDtemp);
     {
         ok( outPoly == NULL,
-            "psPolynomial2DfromMetadata:   return NULL for metadata-polynomial with no x-order");
+            "psPolynomial2DfromMetadata:   "
+            "return NULL for metadata-polynomial with no x-order");
     }
 
@@ -222 +418 @@
 void test3Dcase(void)
 {
-    diag("  >>>Test 2:  psPolynomial3DtoMetadata & psPolynomial3DfromMetadata functions");
+    diag("  >>>Test 3:  psPolynomial3DtoMetadata & psPolynomial3DfromMetadata functions");
     psMetadata *md = psMetadataAlloc();
     psPolynomial3D *p3d = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1);
@@ -268 +464 @@
             abs(polyItem->data.F64-1.1) < DBL_EPSILON,
             "psPolynomial3DtoMetadata:     return correct first element.");
-        polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
+        polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL-1);
         ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01", 14) &&
             abs(polyItem->data.F64-0.8) < DBL_EPSILON,
@@ -295 +491 @@
             "psPolynomial3DtoMetadata:     return false for NULL polynomial input.");
     }
-    //Return false for empty polynomial
-    {
-        psPolynomial3D *emptyPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0);
-        ok( !psPolynomial3DtoMetadata(md, emptyPoly, "polyMD"),
-            "psPolynomial3DtoMetadata:     return false for empty polynomial input.");
-        psFree(emptyPoly);
-    }
+    /*    //Return false for empty polynomial
+        {
+            psPolynomial3D *emptyPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0);
+            ok( !psPolynomial3DtoMetadata(md, emptyPoly, "polyMD"),
+                "psPolynomial3DtoMetadata:     return false for empty polynomial input.");
+            psFree(emptyPoly);
+        }
+    */
     //Return true for polynomial with 1 element, a constant
     {
@@ -340 +537 @@
         skip_end();
     }
-    //Return NULL for polynomial with missing coefficient
-    psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL-1);
+
+    //Get a polynomial from Metadata with mask[0][0][0] == 1.
+    psFree(outPoly);
+    outPoly = NULL;
+    psPolynomial3D *maskPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0);
+    maskPoly->coeff[0][0][0] = 6.66;
+    maskPoly->mask[0][0][0] = 1;
+    psMetadata *newmd = psMetadataAlloc();
+    psPolynomial3DtoMetadata(newmd, maskPoly, "polyMD");
+    psMetadata *polyMask = psMetadataLookupMetadata(NULL, newmd, "polyMD");
+    outPoly = psPolynomial3DfromMetadata(polyMask);
+    {
+        ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 0 && outPoly->nY == 0
+            && outPoly->nZ == 0 && outPoly->mask[0][0][0] == 1,
+            "psPolynomial3DfromMetadata:   return correct polynomial (w/mask) from metadata");
+    }
+    psFree(maskPoly);
+    psFree(newmd);
+    //Return NULL for wrong NELEMENTS
+    psMetadataItem *nElementItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
+    nElementItem->data.S32 -= 1;
     psFree(outPoly);
     outPoly = NULL;
     outPoly = psPolynomial3DfromMetadata(polyMDtemp);
     {
-        //        ok( outPoly->mask[1][1][1] == 1,
-        //            "psPolynomial3DfromMetadata:   return mask[1][1][1] == 1 for metadata-polynomial"
-        //            " with missing element");
-        ok( outPoly == NULL,
-            "psPolynomial3DfromMetadata:   return NULL for polynomial with missing coeff");
-    }
+        ok( outPoly == NULL,
+            "psPolynomial3DfromMetadata:   "
+            "return NULL for metadata-polynomial with wrong NELEMENTS");
+    }
+    //Return NULL for missing NELEMENTS
+    psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL);
+    psFree(outPoly);
+    outPoly = NULL;
+    outPoly = psPolynomial3DfromMetadata(polyMDtemp);
+    {
+        ok( outPoly == NULL,
+            "psPolynomial3DfromMetadata:   "
+            "return NULL for metadata-polynomial with no NELEMENTS");
+    }
+
     //Return NULL for polynomial in metadata with no z-order
     psMetadataRemoveKey(polyMDtemp, "NORDER_Z");
+    psFree(outPoly);
+    outPoly = NULL;
     outPoly = psPolynomial3DfromMetadata(polyMDtemp);
     {
@@ -361 +588 @@
     //Return NULL for polynomial in metadata with no y-order
     psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
+    psFree(outPoly);
+    outPoly = NULL;
     outPoly = psPolynomial3DfromMetadata(polyMDtemp);
     {
@@ -368 +597 @@
     //Return NULL for polynomial in metadata with no x-order
     psMetadataRemoveKey(polyMDtemp, "NORDER_X");
+    psFree(outPoly);
+    outPoly = NULL;
     outPoly = psPolynomial3DfromMetadata(polyMDtemp);
     {
@@ -385 +616 @@
 void test4Dcase(void)
 {
-    diag("  >>>Test 3:  psPolynomial4DtoMetadata & psPolynomial4DfromMetadata functions");
+    diag("  >>>Test 4:  psPolynomial4DtoMetadata & psPolynomial4DfromMetadata functions");
     psMetadata *md = psMetadataAlloc();
     psPolynomial4D *p4d = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1, 1);
@@ -457 +688 @@
             abs(polyItem->data.F64-1.1) < DBL_EPSILON,
             "psPolynomial4DtoMetadata:     return correct first element.");
-        polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
+        polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL-1);
         ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01_T01", 14) &&
             abs(polyItem->data.F64-0.16) < DBL_EPSILON,
@@ -484 +715 @@
             "psPolynomial4DtoMetadata:     return false for NULL polynomial input.");
     }
-    //Return false for empty polynomial
-    {
-        psPolynomial4D *emptyPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0);
-        ok( !psPolynomial4DtoMetadata(md, emptyPoly, "polyMD"),
-            "psPolynomial4DtoMetadata:     return false for empty polynomial input.");
-        psFree(emptyPoly);
-    }
+    /*    //Return false for empty polynomial
+        {
+            psPolynomial4D *emptyPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0);
+            ok( !psPolynomial4DtoMetadata(md, emptyPoly, "polyMD"),
+                "psPolynomial4DtoMetadata:     return false for empty polynomial input.");
+            psFree(emptyPoly);
+        }
+    */
     //Return true for polynomial with 1 element, a constant
     {
@@ -529 +761 @@
         skip_end();
     }
-    //Return NULL for polynomial with missing coefficient
-    psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL-1);
+    //Get a polynomial from Metadata with mask[0][0][0][0] == 1.
+    psFree(outPoly);
+    outPoly = NULL;
+    psPolynomial4D *maskPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0);
+    maskPoly->coeff[0][0][0][0] = 6.66;
+    maskPoly->mask[0][0][0][0] = 1;
+    psMetadata *newmd = psMetadataAlloc();
+    psPolynomial4DtoMetadata(newmd, maskPoly, "polyMD");
+    psMetadata *polyMask = psMetadataLookupMetadata(NULL, newmd, "polyMD");
+    outPoly = psPolynomial4DfromMetadata(polyMask);
+    {
+        ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 0 && outPoly->nY == 0
+            && outPoly->nZ == 0 && outPoly->nT == 0 && outPoly->mask[0][0][0][0] == 1,
+            "psPolynomial4DfromMetadata:   return correct polynomial (w/mask) from metadata");
+    }
+    psFree(maskPoly);
+    psFree(newmd);
+    //Return NULL for wrong NELEMENTS
+    psMetadataItem *nElementItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
+    nElementItem->data.S32 -= 1;
     psFree(outPoly);
     outPoly = NULL;
     outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     {
-        //        ok( outPoly->mask[1][1][1] == 1,
-        //            "psPolynomial4DfromMetadata:   return mask[1][1][1] == 1 for metadata-polynomial"
-        //            " with missing element");
-        ok( outPoly == NULL,
-            "psPolynomial4DfromMetadata:   return NULL for polynomial with missing coeff");
-    }
+        ok( outPoly == NULL,
+            "psPolynomial4DfromMetadata:   "
+            "return NULL for metadata-polynomial with wrong NELEMENTS");
+    }
+    //Return NULL for missing NELEMENTS
+    psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL);
+    psFree(outPoly);
+    outPoly = NULL;
+    outPoly = psPolynomial4DfromMetadata(polyMDtemp);
+    {
+        ok( outPoly == NULL,
+            "psPolynomial4DfromMetadata:   "
+            "return NULL for metadata-polynomial with no NELEMENTS");
+    }
+
     //Return NULL for polynomial in metadata with no t-order
     psMetadataRemoveKey(polyMDtemp, "NORDER_T");
+    psFree(outPoly);
+    outPoly = NULL;
     outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     {
@@ -550 +811 @@
     //Return NULL for polynomial in metadata with no z-order
     psMetadataRemoveKey(polyMDtemp, "NORDER_Z");
+    psFree(outPoly);
+    outPoly = NULL;
     outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     {
@@ -557 +820 @@
     //Return NULL for polynomial in metadata with no y-order
     psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
+    psFree(outPoly);
+    outPoly = NULL;
     outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     {
@@ -564 +829 @@
     //Return NULL for polynomial in metadata with no x-order
     psMetadataRemoveKey(polyMDtemp, "NORDER_X");
+    psFree(outPoly);
+    outPoly = NULL;
     outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     {