Index: /trunk/psLib/src/sys/psAssert.h =================================================================== --- /trunk/psLib/src/sys/psAssert.h (revision 9596) +++ /trunk/psLib/src/sys/psAssert.h (revision 9597) @@ -13,4 +13,5 @@ #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 || \ Index: /trunk/psLib/test/types/tap_psArray_all.c =================================================================== --- /trunk/psLib/test/types/tap_psArray_all.c (revision 9596) +++ /trunk/psLib/test/types/tap_psArray_all.c (revision 9597) @@ -155,10 +155,10 @@ 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."); } Index: /trunk/psLib/test/types/tap_psMetadata_polynomials.c =================================================================== --- /trunk/psLib/test/types/tap_psMetadata_polynomials.c (revision 9596) +++ /trunk/psLib/test/types/tap_psMetadata_polynomials.c (revision 9597) @@ -17,4 +17,5 @@ #include "pstap.h" +void test1Dcase(void); void test2Dcase(void); void test3Dcase(void); @@ -23,8 +24,9 @@ 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,7 +36,167 @@ } + +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,10 +214,10 @@ { 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,8 +227,8 @@ "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,9 +237,9 @@ 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,5 +252,5 @@ ok( psPolynomial2DtoMetadata(md, p2d, "polyMD"), - "psPolynomial2DtoMetadata: return true for valid inputs."); + "psPolynomial2DtoMetadata: return true for valid inputs."); psMetadataConfigWrite (md, "test.md"); @@ -101,19 +263,27 @@ 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,27 +293,20 @@ { 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,29 +347,62 @@ 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,5 +418,5 @@ 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,5 +464,5 @@ 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,11 +491,12 @@ "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,18 +537,48 @@ 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,4 +588,6 @@ //Return NULL for polynomial in metadata with no y-order psMetadataRemoveKey(polyMDtemp, "NORDER_Y"); + psFree(outPoly); + outPoly = NULL; outPoly = psPolynomial3DfromMetadata(polyMDtemp); { @@ -368,4 +597,6 @@ //Return NULL for polynomial in metadata with no x-order psMetadataRemoveKey(polyMDtemp, "NORDER_X"); + psFree(outPoly); + outPoly = NULL; outPoly = psPolynomial3DfromMetadata(polyMDtemp); { @@ -385,5 +616,5 @@ 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,5 +688,5 @@ 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,11 +715,12 @@ "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,18 +761,47 @@ 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,4 +811,6 @@ //Return NULL for polynomial in metadata with no z-order psMetadataRemoveKey(polyMDtemp, "NORDER_Z"); + psFree(outPoly); + outPoly = NULL; outPoly = psPolynomial4DfromMetadata(polyMDtemp); { @@ -557,4 +820,6 @@ //Return NULL for polynomial in metadata with no y-order psMetadataRemoveKey(polyMDtemp, "NORDER_Y"); + psFree(outPoly); + outPoly = NULL; outPoly = psPolynomial4DfromMetadata(polyMDtemp); { @@ -564,4 +829,6 @@ //Return NULL for polynomial in metadata with no x-order psMetadataRemoveKey(polyMDtemp, "NORDER_X"); + psFree(outPoly); + outPoly = NULL; outPoly = psPolynomial4DfromMetadata(polyMDtemp); {