Index: trunk/psLib/test/types/Makefile.am =================================================================== --- trunk/psLib/test/types/Makefile.am (revision 8775) +++ trunk/psLib/test/types/Makefile.am (revision 8786) @@ -26,6 +26,4 @@ tap_psArray_all -check_PROGRAMS = $(TESTS) - check_DATA = \ test.config \ @@ -44,4 +42,6 @@ tableU8.dat \ mdcfgwrt.verified + +check_PROGRAMS = $(TESTS) EXTRA_DIST = \ Index: trunk/psLib/test/types/execute_tap =================================================================== --- trunk/psLib/test/types/execute_tap (revision 8775) +++ trunk/psLib/test/types/execute_tap (revision 8786) @@ -10,2 +10,3 @@ ./tap_psMetadata_manip ./tap_psMetadata_printing +./tap_psMetadata_polynomials Index: trunk/psLib/test/types/tap_psListIterator.c =================================================================== --- trunk/psLib/test/types/tap_psListIterator.c (revision 8775) +++ trunk/psLib/test/types/tap_psListIterator.c (revision 8786) @@ -71,5 +71,5 @@ int main (void) { - plan_tests(158); + plan_tests(66); diag("psListIterator tests"); Index: trunk/psLib/test/types/tap_psMetadata_creating.c =================================================================== --- trunk/psLib/test/types/tap_psMetadata_creating.c (revision 8775) +++ trunk/psLib/test/types/tap_psMetadata_creating.c (revision 8786) @@ -24,5 +24,5 @@ int main(void) { - plan_tests(35); + plan_tests(42); diag("psMetadata & psMetadataItem Creation Functions"); @@ -37,5 +37,5 @@ void testItemAllocs(void) { - diag(" >>>Test 1: psMetadataItemAlloc & Free Fxns"); + diag(" >>>Test 1: psMetadataItemAlloc Fxns"); psMetadataItem *itemStr = psMetadataItemAllocStr("itemStr", "", "itemStr"); psMetadataItem *itemF32 = psMetadataItemAllocF32("itemF32", "", 6.66); @@ -262,7 +262,6 @@ void testMDAlloc_AddItem(void) { - diag(" >>>Test 2: psMetadataAlloc, psMemCheckMetadata, & psMetadataAdd Fxns"); + diag(" >>>Test 2: psMetadataAlloc & psMetadataAdd Fxns"); psMetadata *md = NULL; - //Attempt to free a null metadata md = psMetadataAlloc(); psMetadata *md1 = psMetadataAlloc(); @@ -271,5 +270,5 @@ { ok( psMemCheckMetadata(md), - "psMemCheckMetadata: return true for valid Metadata."); + "psMemCheckMetadata: return true for valid Metadata."); } //Make sure MemCheck worked. Try primitive type. Expect false. @@ -277,20 +276,19 @@ int j = 2; ok( !psMemCheckMetadata(&j), - "psMemCheckMetadata: return false for non-Metadata input."); + "psMemCheckMetadata: return false for non-Metadata input."); } //Return false for attempt to add a psMetadataItem with no name. { ok( !psMetadataAdd(md1, PS_LIST_HEAD, NULL, PS_DATA_S32, "", 1), - "psMetadataAdd: return false for adding item with no name."); + "psMetadataAdd: return false for adding item with no name."); } psFree(md1); md1 = psMetadataAlloc(); - diag(" >>>Test 3: psMetadataAddItem"); //Return false for NULL metadata input psMetadataItem *item = psMetadataItemAllocBool("item", "", true); { ok( !psMetadataAddItem(NULL, item, PS_LIST_HEAD, PS_META_DEFAULT), - "psMetadataAddItem: return false for NULL metadata input."); + "psMetadataAddItem: return false for NULL metadata input."); } //Return false for metadata with NULL hash @@ -299,5 +297,5 @@ { ok( !psMetadataAddItem(md1, item, PS_LIST_HEAD, PS_META_DEFAULT), - "psMetadataAddItem: return false for metadata with no hash."); + "psMetadataAddItem: return false for metadata with no hash."); } psFree(md1); @@ -307,5 +305,5 @@ { ok( !psMetadataAddItem(md2, item, PS_LIST_HEAD, PS_META_DEFAULT), - "psMetadataAddItem: return false for metadata with no list."); + "psMetadataAddItem: return false for metadata with no list."); } psFree(md2); @@ -313,5 +311,5 @@ { ok( !psMetadataAddItem(md, NULL, PS_LIST_HEAD, PS_META_DEFAULT), - "psMetadataAddItem: return false for NULL item input."); + "psMetadataAddItem: return false for NULL item input."); } //Return false for psMetadataItem with NULL name @@ -320,13 +318,10 @@ { ok( !psMetadataAddItem(md, item, PS_LIST_HEAD, PS_META_DEFAULT), - "psMetadataAddItem: return false for item with no name."); + "psMetadataAddItem: return false for item with no name."); } psFree(item); - //item type=PS_DATA_METADATA_MULTI - // psMetadataAddS32(md, PS_LIST_TAIL, "S32", PS_META_DUPLICATE_OK, "", 1); psMetadata *itemMD = psMetadataAlloc(); psMetadataAddS32(itemMD, PS_LIST_HEAD, "s", PS_META_DUPLICATE_OK, "", 2); - // psMetadataItem *item2 = psMetadataItemAlloc("multi", PS_DATA_METADATA_MULTI, "", itemMD); psMetadataItem *item2 = psMetadataItemAllocS32("s", "", 2); @@ -334,7 +329,6 @@ { ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), - "psMetadataAddItem: return true for addition of PS_DATA_METADATA_MULTI."); - } - // printf("\n >>Memory leakage coming from above test for METADATA_MULTI\n\n"); + "psMetadataAddItem: return true for addition of PS_DATA_METADATA_MULTI."); + } psFree(item2); psFree(itemMD); @@ -343,31 +337,92 @@ psMetadataAddS32(md, PS_LIST_HEAD, "S32", 0, "", 1); item2 = psMetadataItemAllocS32("S32", "", 1); + //FLAG = PS_META_REPLACE + { + ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_REPLACE), + "psMetadataAddItem: return true for PS_META_REPLACE flag."); + } //FLAG = PS_META_DUPLICATE_OK { ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), - "psMetadataAddItem: return true for PS_META_DUPLICATE_OK flag."); - } - //FLAG = PS_META_REPLACE - { - ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_REPLACE), - "psMetadataAddItem: return true for PS_META_REPLACE flag."); - } + "psMetadataAddItem: return true for PS_META_DUPLICATE_OK flag."); + } + /* SEE BELOW. TEST CASE REDONE b/c item2 in md was already a MULTI //FLAG = PS_META_NO_REPLACE { ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_NO_REPLACE), - "psMetadataAddItem: return true for PS_META_NO_REPLACE flag."); - } + "psMetadataAddItem: return true for PS_META_NO_REPLACE flag."); + } + */ //FLAG = PS_META_DEFAULT { ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DEFAULT), - "psMetadataAddItem: return false for PS_META_DEFAULT flag."); - } + "psMetadataAddItem: return false for PS_META_DEFAULT flag."); + } + + //Return false for attempting to add an element twice with flag NO_REPLACE + { + psMetadata *norep = psMetadataAlloc(); + psMetadataAddS32(norep, PS_LIST_HEAD, "S32", 0, "", 1); + psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1); + ok( psMetadataAddItem(norep, item666, PS_LIST_TAIL, PS_META_NO_REPLACE), + "psMetadataAddItem: return true for PS_META_NO_REPLACE flag."); + psFree(item666); + psFree(norep); + } + //Return false for bad list location + { + psMetadata *emptymeta = psMetadataAlloc(); + psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1); + ok( !psMetadataAddItem(emptymeta, item666, -100, PS_META_NO_REPLACE), + "psMetadataAddItem: return false for invalid list location."); + psFree(item666); + psFree(emptymeta); + } + //Return false for trying to add to MULTI with broken list element. + { + psMetadata *broken_list = psMetadataAlloc(); + psMetadataAddS32(broken_list, PS_LIST_HEAD, "S32", 0, "", 1); + psMetadataAddS32(broken_list, PS_LIST_TAIL, "S32", PS_META_DUPLICATE_OK, "", 1); + psMetadataItem *brokenptr = psMetadataLookup(broken_list, "S32"); + if (brokenptr->type != PS_DATA_METADATA_MULTI) + printf("\nError, Error\n"); + else + { + psFree(brokenptr->data.list); + brokenptr->data.list = NULL; + } + psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1); + ok( !psMetadataAddItem(broken_list, item666, PS_LIST_TAIL, PS_META_DUPLICATE_OK), + "psMetadataAddItem: return false for MULTI with NULL list."); + psFree(item666); + psFree(broken_list); + } + + //Attempt to add a MULTI + psFree(item2); + item2 = NULL; + psMetadata *xxx = psMetadataAlloc(); + psMetadataAddS32(xxx, PS_LIST_TAIL, "new S32", 0, "", 1); + item2 = psMetadataItemAllocS32("new S32", "", 1); + psMetadataAddItem(xxx, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK); + psFree(item2); + item2 = psMetadataLookup(xxx, "new S32"); + { + ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), + "psMetadataAddItem: return true for new MULTI item"); + } + //Attempt to add a 2nd reference of a MULTI to the originating metadata container + { + ok( !psMetadataAddItem(xxx, item2, PS_LIST_TAIL, PS_META_NO_REPLACE), + "psMetadataAddItem: return false for attempt to add 2nd reference" + " of a MULTI"); + } + psFree(xxx); //No existing entries or duplicates found - psFree(item2); item2 = psMetadataItemAllocS32("new", "", 2); { ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), - "psMetadataAddItem: return true for new item."); + "psMetadataAddItem: return true for new item."); } @@ -382,5 +437,5 @@ void testIterAlloc(void) { - diag(" >>>Test 4: psMetadataIteratorAlloc"); + diag(" >>>Test 3: psMetadataIteratorAlloc"); psMetadata *md = psMetadataAlloc(); psMetadata *md2 = NULL; @@ -412,5 +467,24 @@ "psMetadataIteratorAlloc: return valid iterator for valid inputs, regex=NULL."); } - + //Return NULL for attempt to allocate an iterator with unfound regex. + psFree(iter); + iter = NULL; + { + iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "IPP.machines.sky"); + ok( iter == NULL, + "psMetadataIteratorAlloc: return NULL for not-found regex input"); + } + //Return NULL for invalid regex input. + { + iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "IPP.machines.sky\\"); + ok( iter == NULL, + "psMetadataIteratorAlloc: return NULL for invalid regex input"); + } + //Return properly allocated iterator for valid non-null regex input. + { + iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "S32_"); + ok( iter != NULL, + "psMetadataIteratorAlloc: return valid iterator for valid regex input"); + } //Check for Memory leaks Index: trunk/psLib/test/types/tap_psMetadata_polynomials.c =================================================================== --- trunk/psLib/test/types/tap_psMetadata_polynomials.c (revision 8775) +++ trunk/psLib/test/types/tap_psMetadata_polynomials.c (revision 8786) @@ -22,5 +22,5 @@ int main(void) { - plan_tests(1); + plan_tests(58); diag("psPolynomial(2D, 3D, & 4D)(to/from)MD tests"); @@ -37,33 +37,140 @@ diag(" >>>Test 1: psPolynomial2DtoMD & psPolynomial2DfromMD functions"); psMetadata *md = psMetadataAlloc(); - psMetadata *out = NULL; psPolynomial2D *p2d = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 1, 1); - psPolynomial2D *polly = NULL; - p2d->coeff[0][0] = 1.1; p2d->coeff[0][1] = 2.2; - p2d->coeff[1][0] = 2.1; - p2d->coeff[1][1] = 1.2; - - if (!psPolynomial2DtoMD(md, p2d, "polyMD") ) - printf("\nnot true\n"); - else - psMetadataPrint(NULL, md, 2); - - - - //Return true for valid case - { - // ok( psPolynomial2DtoMD(md, p2d, "%f", ...); - } - - - + p2d->coeff[1][0] = 3.3; + p2d->coeff[1][1] = 4.4; + p2d->coeffErr[0][0] = 0.1; + p2d->coeffErr[0][1] = 0.2; + p2d->coeffErr[1][0] = 0.3; + p2d->coeffErr[1][1] = 0.4; + + //psPolynomial2DtoMD + //Return a valid metadata containing a polynomial-metadata structure + { + ok( psPolynomial2DtoMD(md, p2d, "polyMD"), + "psPolynomial2DtoMD: return true for valid inputs."); + psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); + skip_start( polyMDtemp == NULL , 1, + "Skipping 1 tests because psPolynomial2DtoMD has errors"); + psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); + skip_start( polyItem == NULL, 2, + "Skipping 2 tests because psPolynomial2DtoMD has errors in order elements"); + ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1, + "psPolynomial2DtoMD: return correct number of x orders."); + polyItem = psMetadataGet(polyMDtemp, 1); + ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1, + "psPolynomial2DtoMD: return correct number of y orders."); + skip_end(); + polyItem = psMetadataGet(polyMDtemp, 2); + skip_start( polyItem == NULL, 2, + "Skipping 2 tests because psPolynomial2DtoMD has errors in coeff elements"); + ok( !strncmp(polyItem->name, "VAL_X00_Y00", 14) && + abs(polyItem->data.F64-1.1) < DBL_EPSILON, + "psPolynomial2DtoMD: return correct first element."); + polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL); + ok( !strncmp(polyItem->name, "ERR_X01_Y01", 14) && + abs(polyItem->data.F64-0.4) < DBL_EPSILON, + "psPolynomial2DtoMD: return correct last element."); + skip_end(); + skip_end(); + } + + //Return false for no-name polynomial + { + ok( !psPolynomial2DtoMD(md, p2d, ""), + "psPolynomial2DtoMD: return false for no-name."); + } + //Return false for NULL-name polynomial + { + ok( !psPolynomial2DtoMD(md, p2d, NULL), + "psPolynomial2DtoMD: return false for NULL name input."); + } + //Return false for NULL metadata input + { + ok( !psPolynomial2DtoMD(NULL, p2d, "polyMD"), + "psPolynomial2DtoMD: return false for NULL metadata input."); + } + //Return false for NULL polynomial input + { + ok( !psPolynomial2DtoMD(md, NULL, "polyMD"), + "psPolynomial2DtoMD: return false for NULL polynomial input."); + } + //Return false for empty polynomial + { + psPolynomial2D *emptyPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0); + ok( !psPolynomial2DtoMD(md, emptyPoly, "polyMD"), + "psPolynomial2DtoMD: return false for empty polynomial input."); + psFree(emptyPoly); + } + //Return true for polynomial with 1 element, a constant + { + psPolynomial2D *constPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0); + constPoly->coeff[0][0] = 6.66; + ok( psPolynomial2DtoMD(md, constPoly, "polyMD"), + "psPolynomial2DtoMD: return true for constant polynomial (1 element != 0)."); + psFree(constPoly); + } + //Return false for non-ordinary polynomial + { + psPolynomial2D *p2d2 = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, 1, 1); + p2d2->coeff[0][0] = 1.1; + ok( !psPolynomial2DtoMD(md, p2d2, "polyMD"), + "psPolynomial2DtoMD: return false for chebyshev polynomial"); + psFree(p2d2); + } + + //psPolynomial2DfromMD Tests + //Return NULL for NULL metadata input. + { + psPolynomial2D *emptyPoly2D = NULL; + emptyPoly2D = psPolynomial2DfromMD(NULL); + ok( emptyPoly2D == NULL, + "psPolynomial2DfromMD: return NULL for NULL metadata input."); + } + //Get a polynomial from Metadata. + psPolynomial2D *outPoly = NULL; + psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); + outPoly = psPolynomial2DfromMD(polyMDtemp); + { + skip_start( outPoly == NULL, 1, + "Skipping 1 tests because psPolynomial2DfromMD has errors."); + ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 && + outPoly->nY == 1 && abs(outPoly->coeff[0][0] - 1.1) < DBL_EPSILON, + "psPolynomial2DfromMD: return correct polynomial from metadata"); + skip_end(); + } + //Set poly->mask[1][1] = 1 for missing [1][1] element in metadata + psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL-1); + psFree(outPoly); + outPoly = NULL; + outPoly = psPolynomial2DfromMD(polyMDtemp); + { + // ok( outPoly->mask[1][1] == 1, + // "psPolynomial2DfromMD: return mask[1][1] == 1 for metadata-polynomial", + // " with missing element"); + ok( outPoly == NULL, + "psPolynomial2DfromMD: return NULL for polynomial with missing coeff"); + } + //Return NULL for polynomial in metadata with no y-order + psMetadataRemoveKey(polyMDtemp, "NORDER_Y"); + outPoly = psPolynomial2DfromMD(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial2DfromMD: return NULL for metadata-polynomial with no y-order"); + } + //Return NULL for polynomial in metadata with no x-order + psMetadataRemoveKey(polyMDtemp, "NORDER_X"); + outPoly = psPolynomial2DfromMD(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial2DfromMD: return NULL for metadata-polynomial with no x-order"); + } //Check for Memory leaks { + psFree(outPoly); psFree(p2d); - psFree(polly); - psFree(out); psFree(md); checkMem(); @@ -75,12 +182,158 @@ diag(" >>>Test 2: psPolynomial3DtoMD & psPolynomial3DfromMD functions"); psMetadata *md = psMetadataAlloc(); - psMetadata *out = NULL; - - - + psPolynomial3D *p3d = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1); + p3d->coeff[0][0][0] = 1.1; + p3d->coeff[1][0][0] = 2.2; + p3d->coeff[0][1][0] = 3.3; + p3d->coeff[0][0][1] = 4.4; + p3d->coeff[1][1][0] = 5.5; + p3d->coeff[1][0][1] = 6.6; + p3d->coeff[0][1][1] = 7.7; + p3d->coeff[1][1][1] = 8.8; + p3d->coeffErr[0][0][0] = 0.1; + p3d->coeffErr[1][0][0] = 0.2; + p3d->coeffErr[0][1][0] = 0.3; + p3d->coeffErr[0][0][1] = 0.4; + p3d->coeffErr[1][1][0] = 0.5; + p3d->coeffErr[1][0][1] = 0.6; + p3d->coeffErr[0][1][1] = 0.7; + p3d->coeffErr[1][1][1] = 0.8; + + //psPolynomial3DtoMD + //Return a valid metadata containing a polynomial-metadata structure + { + ok( psPolynomial3DtoMD(md, p3d, "polyMD"), + "psPolynomial3DtoMD: return true for valid inputs."); + psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); + skip_start( polyMDtemp == NULL , 1, + "Skipping 1 tests because psPolynomial3DtoMD has errors"); + psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); + skip_start( polyItem == NULL, 2, + "Skipping 3 tests because psPolynomial3DtoMD has errors in order elements"); + ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1, + "psPolynomial3DtoMD: return correct number of x orders."); + polyItem = psMetadataGet(polyMDtemp, 1); + ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1, + "psPolynomial3DtoMD: return correct number of y orders."); + polyItem = psMetadataGet(polyMDtemp, 2); + ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1, + "psPolynomial3DtoMD: return correct number of z orders."); + skip_end(); + polyItem = psMetadataGet(polyMDtemp, 3); + skip_start( polyItem == NULL, 2, + "Skipping 2 tests because psPolynomial3DtoMD has errors in coeff elements"); + ok( !strncmp(polyItem->name, "VAL_X00_Y00_Z00", 14) && + abs(polyItem->data.F64-1.1) < DBL_EPSILON, + "psPolynomial3DtoMD: return correct first element."); + polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL); + ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01", 14) && + abs(polyItem->data.F64-0.8) < DBL_EPSILON, + "psPolynomial3DtoMD: return correct last element."); + skip_end(); + skip_end(); + } + //Return false for no-name polynomial + { + ok( !psPolynomial3DtoMD(md, p3d, ""), + "psPolynomial3DtoMD: return false for no-name."); + } + //Return false for NULL-name polynomial + { + ok( !psPolynomial3DtoMD(md, p3d, NULL), + "psPolynomial3DtoMD: return false for NULL name input."); + } + //Return false for NULL metadata input + { + ok( !psPolynomial3DtoMD(NULL, p3d, "polyMD"), + "psPolynomial3DtoMD: return false for NULL metadata input."); + } + //Return false for NULL polynomial input + { + ok( !psPolynomial3DtoMD(md, NULL, "polyMD"), + "psPolynomial3DtoMD: return false for NULL polynomial input."); + } + //Return false for empty polynomial + { + psPolynomial3D *emptyPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0); + ok( !psPolynomial3DtoMD(md, emptyPoly, "polyMD"), + "psPolynomial3DtoMD: return false for empty polynomial input."); + psFree(emptyPoly); + } + //Return true for polynomial with 1 element, a constant + { + psPolynomial3D *constPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0); + constPoly->coeff[0][0][0] = 6.66; + ok( psPolynomial3DtoMD(md, constPoly, "polyMD"), + "psPolynomial3DtoMD: return true for constant polynomial (1 element != 0)."); + psFree(constPoly); + } + //Return false for non-ordinary polynomial + { + psPolynomial3D *p3d2 = psPolynomial3DAlloc(PS_POLYNOMIAL_CHEB, 1, 1, 1); + p3d2->coeff[0][0][0] = 1.1; + ok( !psPolynomial3DtoMD(md, p3d2, "polyMD"), + "psPolynomial3DtoMD: return false for chebyshev polynomial"); + psFree(p3d2); + } + + //psPolynomial3DfromMD Tests + //Return NULL for NULL metadata input. + { + psPolynomial3D *emptyPoly2D = NULL; + emptyPoly2D = psPolynomial3DfromMD(NULL); + ok( emptyPoly2D == NULL, + "psPolynomial3DfromMD: return NULL for NULL metadata input."); + } + //Get a polynomial from Metadata. + psPolynomial3D *outPoly = NULL; + psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); + outPoly = psPolynomial3DfromMD(polyMDtemp); + { + skip_start( outPoly == NULL, 1, + "Skipping 1 tests because psPolynomial3DfromMD has errors."); + ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 && + outPoly->nY == 1 && outPoly->nZ == 1 && + abs(outPoly->coeff[0][0][0] - 1.1) < DBL_EPSILON, + "psPolynomial3DfromMD: return correct polynomial from metadata"); + skip_end(); + } + //Return NULL for polynomial with missing coefficient + psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL-1); + psFree(outPoly); + outPoly = NULL; + outPoly = psPolynomial3DfromMD(polyMDtemp); + { + // ok( outPoly->mask[1][1][1] == 1, + // "psPolynomial3DfromMD: return mask[1][1][1] == 1 for metadata-polynomial" + // " with missing element"); + ok( outPoly == NULL, + "psPolynomial3DfromMD: return NULL for polynomial with missing coeff"); + } + //Return NULL for polynomial in metadata with no z-order + psMetadataRemoveKey(polyMDtemp, "NORDER_Z"); + outPoly = psPolynomial3DfromMD(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial3DfromMD: return NULL for metadata-polynomial with no z-order"); + } + //Return NULL for polynomial in metadata with no y-order + psMetadataRemoveKey(polyMDtemp, "NORDER_Y"); + outPoly = psPolynomial3DfromMD(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial3DfromMD: return NULL for metadata-polynomial with no y-order"); + } + //Return NULL for polynomial in metadata with no x-order + psMetadataRemoveKey(polyMDtemp, "NORDER_X"); + outPoly = psPolynomial3DfromMD(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial3DfromMD: return NULL for metadata-polynomial with no x-order"); + } //Check for Memory leaks { - psFree(out); + psFree(outPoly); + psFree(p3d); psFree(md); checkMem(); @@ -92,12 +345,191 @@ diag(" >>>Test 3: psPolynomial4DtoMD & psPolynomial4DfromMD functions"); psMetadata *md = psMetadataAlloc(); - psMetadata *out = NULL; - - - + psPolynomial4D *p4d = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1, 1); + p4d->coeff[0][0][0][0] = 1.1; + p4d->coeff[0][0][0][1] = 2.2; + p4d->coeff[0][0][1][0] = 3.3; + p4d->coeff[0][1][0][0] = 4.4; + p4d->coeff[1][0][0][0] = 5.5; + + p4d->coeff[0][0][1][1] = 6.6; + p4d->coeff[0][1][0][1] = 7.7; + p4d->coeff[1][0][0][1] = 8.8; + p4d->coeff[0][1][1][0] = 9.9; + p4d->coeff[1][0][1][0] = 10.10; + p4d->coeff[1][1][0][0] = 11.11; + + p4d->coeff[0][1][1][1] = 12.12; + p4d->coeff[1][0][1][1] = 13.13; + p4d->coeff[1][1][0][1] = 14.14; + p4d->coeff[1][1][1][0] = 15.15; + + p4d->coeff[1][1][1][1] = 16.16; + + p4d->coeffErr[0][0][0][0] = 0.1; + p4d->coeffErr[0][0][0][1] = 0.2; + p4d->coeffErr[0][0][1][0] = 0.3; + p4d->coeffErr[0][1][0][0] = 0.4; + p4d->coeffErr[1][0][0][0] = 0.5; + + p4d->coeffErr[0][0][1][1] = 0.6; + p4d->coeffErr[0][1][0][1] = 0.7; + p4d->coeffErr[1][0][0][1] = 0.8; + p4d->coeffErr[0][1][1][0] = 0.9; + p4d->coeffErr[1][0][1][0] = 0.10; + p4d->coeffErr[1][1][0][0] = 0.11; + + p4d->coeffErr[0][1][1][1] = 0.12; + p4d->coeffErr[1][0][1][1] = 0.13; + p4d->coeffErr[1][1][0][1] = 0.14; + p4d->coeffErr[1][1][1][0] = 0.15; + + p4d->coeffErr[1][1][1][1] = 0.16; + + //psPolynomial4DtoMD + //Return a valid metadata containing a polynomial-metadata structure + { + ok( psPolynomial4DtoMD(md, p4d, "polyMD"), + "psPolynomial4DtoMD: return true for valid inputs."); + psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); + skip_start( polyMDtemp == NULL , 1, + "Skipping 1 tests because psPolynomial4DtoMD has errors"); + psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); + skip_start( polyItem == NULL, 2, + "Skipping 4 tests because psPolynomial4DtoMD has errors in order elements"); + ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1, + "psPolynomial4DtoMD: return correct number of x orders."); + polyItem = psMetadataGet(polyMDtemp, 1); + ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1, + "psPolynomial4DtoMD: return correct number of y orders."); + polyItem = psMetadataGet(polyMDtemp, 2); + ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1, + "psPolynomial4DtoMD: return correct number of z orders."); + polyItem = psMetadataGet(polyMDtemp, 3); + ok( !strncmp(polyItem->name, "NORDER_T", 10) && polyItem->data.S32 == 1, + "psPolynomial4DtoMD: return correct number of t orders."); + skip_end(); + polyItem = psMetadataGet(polyMDtemp, 4); + skip_start( polyItem == NULL, 2, + "Skipping 2 tests because psPolynomial4DtoMD has errors in coeff elements"); + ok( !strncmp(polyItem->name, "VAL_X00_Y00_Z00_T00", 14) && + abs(polyItem->data.F64-1.1) < DBL_EPSILON, + "psPolynomial4DtoMD: return correct first element."); + polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL); + ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01_T01", 14) && + abs(polyItem->data.F64-0.16) < DBL_EPSILON, + "psPolynomial4DtoMD: return correct last element."); + skip_end(); + skip_end(); + } + //Return false for no-name polynomial + { + ok( !psPolynomial4DtoMD(md, p4d, ""), + "psPolynomial4DtoMD: return false for no-name."); + } + //Return false for NULL-name polynomial + { + ok( !psPolynomial4DtoMD(md, p4d, NULL), + "psPolynomial4DtoMD: return false for NULL name input."); + } + //Return false for NULL metadata input + { + ok( !psPolynomial4DtoMD(NULL, p4d, "polyMD"), + "psPolynomial4DtoMD: return false for NULL metadata input."); + } + //Return false for NULL polynomial input + { + ok( !psPolynomial4DtoMD(md, NULL, "polyMD"), + "psPolynomial4DtoMD: return false for NULL polynomial input."); + } + //Return false for empty polynomial + { + psPolynomial4D *emptyPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0); + ok( !psPolynomial4DtoMD(md, emptyPoly, "polyMD"), + "psPolynomial4DtoMD: return false for empty polynomial input."); + psFree(emptyPoly); + } + //Return true for polynomial with 1 element, a constant + { + psPolynomial4D *constPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0); + constPoly->coeff[0][0][0][0] = 6.66; + ok( psPolynomial4DtoMD(md, constPoly, "polyMD"), + "psPolynomial4DtoMD: return true for constant polynomial (1 element != 0)."); + psFree(constPoly); + } + //Return false for non-ordinary polynomial + { + psPolynomial4D *p4d2 = psPolynomial4DAlloc(PS_POLYNOMIAL_CHEB, 1, 1, 1, 1); + p4d2->coeff[0][0][0][0] = 1.1; + ok( !psPolynomial4DtoMD(md, p4d2, "polyMD"), + "psPolynomial4DtoMD: return false for chebyshev polynomial"); + psFree(p4d2); + } + + //psPolynomial4DfromMD Tests + //Return NULL for NULL metadata input. + { + psPolynomial4D *emptyPoly2D = NULL; + emptyPoly2D = psPolynomial4DfromMD(NULL); + ok( emptyPoly2D == NULL, + "psPolynomial4DfromMD: return NULL for NULL metadata input."); + } + //Get a polynomial from Metadata. + psPolynomial4D *outPoly = NULL; + psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); + outPoly = psPolynomial4DfromMD(polyMDtemp); + { + skip_start( outPoly == NULL, 1, + "Skipping 1 tests because psPolynomial4DfromMD has errors."); + ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 && + outPoly->nY == 1 && outPoly->nZ == 1 && outPoly->nT == 1 && + abs(outPoly->coeff[0][0][0][0] - 1.1) < DBL_EPSILON, + "psPolynomial4DfromMD: return correct polynomial from metadata"); + skip_end(); + } + //Return NULL for polynomial with missing coefficient + psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL-1); + psFree(outPoly); + outPoly = NULL; + outPoly = psPolynomial4DfromMD(polyMDtemp); + { + // ok( outPoly->mask[1][1][1] == 1, + // "psPolynomial4DfromMD: return mask[1][1][1] == 1 for metadata-polynomial" + // " with missing element"); + ok( outPoly == NULL, + "psPolynomial4DfromMD: return NULL for polynomial with missing coeff"); + } + //Return NULL for polynomial in metadata with no t-order + psMetadataRemoveKey(polyMDtemp, "NORDER_T"); + outPoly = psPolynomial4DfromMD(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial4DfromMD: return NULL for metadata-polynomial with no t-order"); + } + //Return NULL for polynomial in metadata with no z-order + psMetadataRemoveKey(polyMDtemp, "NORDER_Z"); + outPoly = psPolynomial4DfromMD(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial4DfromMD: return NULL for metadata-polynomial with no z-order"); + } + //Return NULL for polynomial in metadata with no y-order + psMetadataRemoveKey(polyMDtemp, "NORDER_Y"); + outPoly = psPolynomial4DfromMD(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial4DfromMD: return NULL for metadata-polynomial with no y-order"); + } + //Return NULL for polynomial in metadata with no x-order + psMetadataRemoveKey(polyMDtemp, "NORDER_X"); + outPoly = psPolynomial4DfromMD(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial4DfromMD: return NULL for metadata-polynomial with no x-order"); + } //Check for Memory leaks { - psFree(out); + psFree(outPoly); + psFree(p4d); psFree(md); checkMem();