Index: /trunk/psLib/test/types/tap_psArguments_all.c =================================================================== --- /trunk/psLib/test/types/tap_psArguments_all.c (revision 9581) +++ /trunk/psLib/test/types/tap_psArguments_all.c (revision 9582) @@ -19,5 +19,5 @@ void testArgumentGetParse(void); void testArgumentVerbosity(void); -void testLogTraceArguments(void); +//void testLogTraceArguments(void); int main(void) @@ -29,5 +29,5 @@ testArgumentGetParse(); testArgumentVerbosity(); - testLogTraceArguments(); + // testLogTraceArguments(); done(); @@ -314,8 +314,9 @@ } +/* void testLogTraceArguments(void) { diag(" >>>Test 3: psLogArguments & psTraceArguments Fxns"); - + //Return 2 (default) for NULL arguments input { @@ -377,6 +378,6 @@ "psLogArguments: return 2 for '-logfmt H' argument inputs."); } - - + + //psTraceArguments Tests //Return 0 (default) for NULL arguments input @@ -422,5 +423,5 @@ "psTraceArguments: return 2 for '-trace-levels' argument input."); } - + //Check for Memory leaks { @@ -428,2 +429,3 @@ } } +*/ Index: /trunk/psLib/test/types/tap_psArray_all.c =================================================================== --- /trunk/psLib/test/types/tap_psArray_all.c (revision 9581) +++ /trunk/psLib/test/types/tap_psArray_all.c (revision 9582) @@ -149,33 +149,33 @@ } - //Tests for psArrayRemove + //Tests for psArrayRemoveData //Setup array with 3 elements to test remove function //Return false for attempting to remove from a NULL array { psArray *temp = NULL; - ok( !psArrayRemove(temp, s2), - "psArrayRemove: return false for NULL input psArray."); + ok( !psArrayRemoveData(temp, s2), + "psArrayRemoveData: return false for NULL input psArray."); } //Return true for successful removal { - ok( psArrayRemove(a, s2) && a->n == 2, - "psArrayRemove: return true for successful removal."); - } - - //Tests for psArrayRemoveByPos + ok( psArrayRemoveData(a, s2) && a->n == 2, + "psArrayRemoveData: return true for successful removal."); + } + + //Tests for psArrayRemoveIndex //Return false for NULL array input { - ok( !psArrayRemoveByPos(NULL, 0), - "psArrayRemoveByPos: return false for NULL input psArray."); + ok( !psArrayRemoveIndex(NULL, 0), + "psArrayRemoveIndex: return false for NULL input psArray."); } //Return false for out-of-range index { - ok( !psArrayRemoveByPos(a, 5), - "psArrayRemoveByPos: return false for out-of-range location."); + ok( !psArrayRemoveIndex(a, 5), + "psArrayRemoveIndex: return false for out-of-range location."); } //Return true for successful removal { - ok( psArrayRemoveByPos(a, 1) && a->n == 1, - "psArrayRemoveByPos: return true for successful removal."); + ok( psArrayRemoveIndex(a, 1) && a->n == 1, + "psArrayRemoveIndex: return true for successful removal."); } Index: /trunk/psLib/test/types/tap_psMetadata_manip.c =================================================================== --- /trunk/psLib/test/types/tap_psMetadata_manip.c (revision 9581) +++ /trunk/psLib/test/types/tap_psMetadata_manip.c (revision 9582) @@ -182,5 +182,5 @@ bool status = false; psMetadata *mdtemp = NULL; - mdtemp = psMetadataLookupMD(&status, md, "metadata7"); + mdtemp = psMetadataLookupMetadata(&status, md, "metadata7"); psMetadataItem *itemtemp = psMetadataGet(mdtemp, PS_LIST_HEAD); ok( status && itemtemp->type == PS_DATA_S32 && itemtemp->data.S32 == 666, @@ -256,9 +256,9 @@ bool status = false; psMetadata *met = NULL; - met = psMetadataLookupMD(&status, md, "item"); + met = psMetadataLookupMetadata(&status, md, "item"); ok( !status && met == NULL, "psMetadataLookupMD: return NULL for incorrect key."); met = NULL; - met = psMetadataLookupMD(NULL, md, "item"); + met = psMetadataLookupMetadata(NULL, md, "item"); ok( met == NULL, "psMetadataLookupMD: return NULL for incorrect key (& NULL status)."); @@ -268,9 +268,9 @@ bool status = false; psMetadata *met = NULL; - met = psMetadataLookupMD(&status, md, "itemS8"); + met = psMetadataLookupMetadata(&status, md, "itemS8"); ok( !status && met == NULL, "psMetadataLookupMD: return NULL for incorrect key (& NULL status)."); met = NULL; - met = psMetadataLookupMD(NULL, md, "itemS8"); + met = psMetadataLookupMetadata(NULL, md, "itemS8"); ok( met == NULL, "psMetadataLookupMD: return NULL for incorrect key."); Index: /trunk/psLib/test/types/tap_psMetadata_polynomials.c =================================================================== --- /trunk/psLib/test/types/tap_psMetadata_polynomials.c (revision 9581) +++ /trunk/psLib/test/types/tap_psMetadata_polynomials.c (revision 9582) @@ -36,5 +36,5 @@ void test2Dcase(void) { - diag(" >>>Test 1: psPolynomial2DtoMD & psPolynomial2DfromMD functions"); + diag(" >>>Test 1: psPolynomial2DtoMetadata & psPolynomial2DfromMetadata functions"); psMetadata *md = psMetadataAlloc(); psPolynomial2D *p2d = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 1, 1); @@ -48,9 +48,9 @@ p2d->coeffErr[1][1] = 0.4; - //psPolynomial2DtoMD + //psPolynomial2DtoMetadata //Return a valid metadata containing a polynomial-metadata structure { - ok( psPolynomial2DtoMD(md, p2d, "polyMD"), - "psPolynomial2DtoMD: return true for valid inputs."); + ok( psPolynomial2DtoMetadata(md, p2d, "polyMD"), + "psPolynomial2DtoMetadata: return true for valid inputs."); psMetadataConfigWrite (md, "test.md"); @@ -58,62 +58,62 @@ ok (0, "these tests are relying on the ORDER of the MD components not the NAMES"); ok (0, "these seem like irrelevant tests"); - psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); + psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD"); skip_start( polyMDtemp == NULL , 1, - "Skipping 1 tests because psPolynomial2DtoMD has errors"); + "Skipping 1 tests because psPolynomial2DtoMetadata has errors"); psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); skip_start( polyItem == NULL, 2, - "Skipping 2 tests because psPolynomial2DtoMD has errors in order elements"); + "Skipping 2 tests because psPolynomial2DtoMetadata has errors in order elements"); ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1, - "psPolynomial2DtoMD: 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, - "psPolynomial2DtoMD: return correct number of y orders."); + "psPolynomial2DtoMetadata: 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"); + "Skipping 2 tests because psPolynomial2DtoMetadata 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."); + "psPolynomial2DtoMetadata: 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(); - } - - //psPolynomial2DtoMD + "psPolynomial2DtoMetadata: return correct last element."); + skip_end(); + skip_end(); + } + + //psPolynomial2DtoMetadata //Return a valid metadata containing a polynomial-metadata structure { diag ("example of 2DtoMD using the names not the sequence"); - ok( psPolynomial2DtoMD(md, p2d, "polyMD"), - "psPolynomial2DtoMD: return true for valid inputs."); + ok( psPolynomial2DtoMetadata(md, p2d, "polyMD"), + "psPolynomial2DtoMetadata: return true for valid inputs."); psMetadataConfigWrite (md, "test.md"); // of the components. these seem like irrelevant tests. - psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); + psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD"); skip_start( polyMDtemp == NULL , 1, - "Skipping 1 tests because psPolynomial2DtoMD has errors"); + "Skipping 1 tests because psPolynomial2DtoMetadata has errors"); bool status; int nX = psMetadataLookupS32(&status, polyMDtemp, "NORDER_X"); - ok(status, "psPolynomial2DtoMD: found NORDER_X"); - ok(nX == 1, "psPolynomial2DtoMD: 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, "psPolynomial2DtoMD: found NORDER_Y"); - ok(nY == 1, "psPolynomial2DtoMD: 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, "psPolynomial2DtoMD: found VAL_X00_Y00"); - ok_double(val, 1.1, "psPolynomial2DtoMD: 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, "psPolynomial2DtoMD: found VAL_X01_Y01"); - ok_double(val, 4.4, "psPolynomial2DtoMD: 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(); @@ -122,27 +122,27 @@ //Return false for no-name polynomial { - ok( !psPolynomial2DtoMD(md, p2d, ""), - "psPolynomial2DtoMD: return false for no-name."); + ok( !psPolynomial2DtoMetadata(md, p2d, ""), + "psPolynomial2DtoMetadata: return false for no-name."); } //Return false for NULL-name polynomial { - ok( !psPolynomial2DtoMD(md, p2d, NULL), - "psPolynomial2DtoMD: return false for NULL name input."); + ok( !psPolynomial2DtoMetadata(md, p2d, NULL), + "psPolynomial2DtoMetadata: return false for NULL name input."); } //Return false for NULL metadata input { - ok( !psPolynomial2DtoMD(NULL, p2d, "polyMD"), - "psPolynomial2DtoMD: return false for NULL metadata input."); + ok( !psPolynomial2DtoMetadata(NULL, p2d, "polyMD"), + "psPolynomial2DtoMetadata: return false for NULL metadata input."); } //Return false for NULL polynomial input { - ok( !psPolynomial2DtoMD(md, NULL, "polyMD"), - "psPolynomial2DtoMD: 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( !psPolynomial2DtoMD(md, emptyPoly, "polyMD"), - "psPolynomial2DtoMD: return false for empty polynomial input."); + ok( !psPolynomial2DtoMetadata(md, emptyPoly, "polyMD"), + "psPolynomial2DtoMetadata: return false for empty polynomial input."); psFree(emptyPoly); } @@ -151,6 +151,6 @@ 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)."); + ok( psPolynomial2DtoMetadata(md, constPoly, "polyMD"), + "psPolynomial2DtoMetadata: return true for constant polynomial (1 element != 0)."); psFree(constPoly); } @@ -159,27 +159,27 @@ 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"); + ok( !psPolynomial2DtoMetadata(md, p2d2, "polyMD"), + "psPolynomial2DtoMetadata: return false for chebyshev polynomial"); psFree(p2d2); } - //psPolynomial2DfromMD Tests + //psPolynomial2DfromMetadata Tests //Return NULL for NULL metadata input. { psPolynomial2D *emptyPoly2D = NULL; - emptyPoly2D = psPolynomial2DfromMD(NULL); + emptyPoly2D = psPolynomial2DfromMetadata(NULL); ok( emptyPoly2D == NULL, - "psPolynomial2DfromMD: return NULL for NULL metadata input."); + "psPolynomial2DfromMetadata: return NULL for NULL metadata input."); } //Get a polynomial from Metadata. psPolynomial2D *outPoly = NULL; - psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); - outPoly = psPolynomial2DfromMD(polyMDtemp); + psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD"); + outPoly = psPolynomial2DfromMetadata(polyMDtemp); { skip_start( outPoly == NULL, 1, - "Skipping 1 tests because psPolynomial2DfromMD has errors."); + "Skipping 1 tests because psPolynomial2DfromMetadata 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"); + "psPolynomial2DfromMetadata: return correct polynomial from metadata"); skip_end(); } @@ -188,25 +188,25 @@ psFree(outPoly); outPoly = NULL; - outPoly = psPolynomial2DfromMD(polyMDtemp); + outPoly = psPolynomial2DfromMetadata(polyMDtemp); { // ok( outPoly->mask[1][1] == 1, - // "psPolynomial2DfromMD: return mask[1][1] == 1 for metadata-polynomial", + // "psPolynomial2DfromMetadata: return mask[1][1] == 1 for metadata-polynomial", // " with missing element"); ok( outPoly == NULL, - "psPolynomial2DfromMD: return NULL for polynomial with missing coeff"); + "psPolynomial2DfromMetadata: 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"); + outPoly = psPolynomial2DfromMetadata(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial2DfromMetadata: 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"); + outPoly = psPolynomial2DfromMetadata(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial2DfromMetadata: return NULL for metadata-polynomial with no x-order"); } @@ -222,5 +222,5 @@ void test3Dcase(void) { - diag(" >>>Test 2: psPolynomial3DtoMD & psPolynomial3DfromMD functions"); + diag(" >>>Test 2: psPolynomial3DtoMetadata & psPolynomial3DfromMetadata functions"); psMetadata *md = psMetadataAlloc(); psPolynomial3D *p3d = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1); @@ -242,34 +242,34 @@ p3d->coeffErr[1][1][1] = 0.8; - //psPolynomial3DtoMD + //psPolynomial3DtoMetadata //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"); + ok( psPolynomial3DtoMetadata(md, p3d, "polyMD"), + "psPolynomial3DtoMetadata: return true for valid inputs."); + psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD"); skip_start( polyMDtemp == NULL , 1, - "Skipping 1 tests because psPolynomial3DtoMD has errors"); + "Skipping 1 tests because psPolynomial3DtoMetadata has errors"); psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); skip_start( polyItem == NULL, 2, - "Skipping 3 tests because psPolynomial3DtoMD has errors in order elements"); + "Skipping 3 tests because psPolynomial3DtoMetadata has errors in order elements"); ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1, - "psPolynomial3DtoMD: return correct number of x orders."); + "psPolynomial3DtoMetadata: 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."); + "psPolynomial3DtoMetadata: 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."); + "psPolynomial3DtoMetadata: 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"); + "Skipping 2 tests because psPolynomial3DtoMetadata 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."); + "psPolynomial3DtoMetadata: 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."); + "psPolynomial3DtoMetadata: return correct last element."); skip_end(); skip_end(); @@ -277,27 +277,27 @@ //Return false for no-name polynomial { - ok( !psPolynomial3DtoMD(md, p3d, ""), - "psPolynomial3DtoMD: return false for no-name."); + ok( !psPolynomial3DtoMetadata(md, p3d, ""), + "psPolynomial3DtoMetadata: return false for no-name."); } //Return false for NULL-name polynomial { - ok( !psPolynomial3DtoMD(md, p3d, NULL), - "psPolynomial3DtoMD: return false for NULL name input."); + ok( !psPolynomial3DtoMetadata(md, p3d, NULL), + "psPolynomial3DtoMetadata: return false for NULL name input."); } //Return false for NULL metadata input { - ok( !psPolynomial3DtoMD(NULL, p3d, "polyMD"), - "psPolynomial3DtoMD: return false for NULL metadata input."); + ok( !psPolynomial3DtoMetadata(NULL, p3d, "polyMD"), + "psPolynomial3DtoMetadata: return false for NULL metadata input."); } //Return false for NULL polynomial input { - ok( !psPolynomial3DtoMD(md, NULL, "polyMD"), - "psPolynomial3DtoMD: return false for NULL polynomial input."); + ok( !psPolynomial3DtoMetadata(md, NULL, "polyMD"), + "psPolynomial3DtoMetadata: 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."); + ok( !psPolynomial3DtoMetadata(md, emptyPoly, "polyMD"), + "psPolynomial3DtoMetadata: return false for empty polynomial input."); psFree(emptyPoly); } @@ -306,6 +306,6 @@ 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)."); + ok( psPolynomial3DtoMetadata(md, constPoly, "polyMD"), + "psPolynomial3DtoMetadata: return true for constant polynomial (1 element != 0)."); psFree(constPoly); } @@ -314,28 +314,28 @@ 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"); + ok( !psPolynomial3DtoMetadata(md, p3d2, "polyMD"), + "psPolynomial3DtoMetadata: return false for chebyshev polynomial"); psFree(p3d2); } - //psPolynomial3DfromMD Tests + //psPolynomial3DfromMetadata Tests //Return NULL for NULL metadata input. { psPolynomial3D *emptyPoly2D = NULL; - emptyPoly2D = psPolynomial3DfromMD(NULL); + emptyPoly2D = psPolynomial3DfromMetadata(NULL); ok( emptyPoly2D == NULL, - "psPolynomial3DfromMD: return NULL for NULL metadata input."); + "psPolynomial3DfromMetadata: return NULL for NULL metadata input."); } //Get a polynomial from Metadata. psPolynomial3D *outPoly = NULL; - psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); - outPoly = psPolynomial3DfromMD(polyMDtemp); + psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD"); + outPoly = psPolynomial3DfromMetadata(polyMDtemp); { skip_start( outPoly == NULL, 1, - "Skipping 1 tests because psPolynomial3DfromMD has errors."); + "Skipping 1 tests because psPolynomial3DfromMetadata 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"); + "psPolynomial3DfromMetadata: return correct polynomial from metadata"); skip_end(); } @@ -344,32 +344,32 @@ psFree(outPoly); outPoly = NULL; - outPoly = psPolynomial3DfromMD(polyMDtemp); + outPoly = psPolynomial3DfromMetadata(polyMDtemp); { // ok( outPoly->mask[1][1][1] == 1, - // "psPolynomial3DfromMD: return mask[1][1][1] == 1 for metadata-polynomial" + // "psPolynomial3DfromMetadata: return mask[1][1][1] == 1 for metadata-polynomial" // " with missing element"); ok( outPoly == NULL, - "psPolynomial3DfromMD: return NULL for polynomial with missing coeff"); + "psPolynomial3DfromMetadata: 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"); + outPoly = psPolynomial3DfromMetadata(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial3DfromMetadata: 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"); + outPoly = psPolynomial3DfromMetadata(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial3DfromMetadata: 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"); + outPoly = psPolynomial3DfromMetadata(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial3DfromMetadata: return NULL for metadata-polynomial with no x-order"); } @@ -385,5 +385,5 @@ void test4Dcase(void) { - diag(" >>>Test 3: psPolynomial4DtoMD & psPolynomial4DfromMD functions"); + diag(" >>>Test 3: psPolynomial4DtoMetadata & psPolynomial4DfromMetadata functions"); psMetadata *md = psMetadataAlloc(); psPolynomial4D *p4d = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1, 1); @@ -428,37 +428,37 @@ p4d->coeffErr[1][1][1][1] = 0.16; - //psPolynomial4DtoMD + //psPolynomial4DtoMetadata //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"); + ok( psPolynomial4DtoMetadata(md, p4d, "polyMD"), + "psPolynomial4DtoMetadata: return true for valid inputs."); + psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD"); skip_start( polyMDtemp == NULL , 1, - "Skipping 1 tests because psPolynomial4DtoMD has errors"); + "Skipping 1 tests because psPolynomial4DtoMetadata has errors"); psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); skip_start( polyItem == NULL, 2, - "Skipping 4 tests because psPolynomial4DtoMD has errors in order elements"); + "Skipping 4 tests because psPolynomial4DtoMetadata has errors in order elements"); ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1, - "psPolynomial4DtoMD: return correct number of x orders."); + "psPolynomial4DtoMetadata: 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."); + "psPolynomial4DtoMetadata: 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."); + "psPolynomial4DtoMetadata: 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."); + "psPolynomial4DtoMetadata: 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"); + "Skipping 2 tests because psPolynomial4DtoMetadata 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."); + "psPolynomial4DtoMetadata: 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."); + "psPolynomial4DtoMetadata: return correct last element."); skip_end(); skip_end(); @@ -466,27 +466,27 @@ //Return false for no-name polynomial { - ok( !psPolynomial4DtoMD(md, p4d, ""), - "psPolynomial4DtoMD: return false for no-name."); + ok( !psPolynomial4DtoMetadata(md, p4d, ""), + "psPolynomial4DtoMetadata: return false for no-name."); } //Return false for NULL-name polynomial { - ok( !psPolynomial4DtoMD(md, p4d, NULL), - "psPolynomial4DtoMD: return false for NULL name input."); + ok( !psPolynomial4DtoMetadata(md, p4d, NULL), + "psPolynomial4DtoMetadata: return false for NULL name input."); } //Return false for NULL metadata input { - ok( !psPolynomial4DtoMD(NULL, p4d, "polyMD"), - "psPolynomial4DtoMD: return false for NULL metadata input."); + ok( !psPolynomial4DtoMetadata(NULL, p4d, "polyMD"), + "psPolynomial4DtoMetadata: return false for NULL metadata input."); } //Return false for NULL polynomial input { - ok( !psPolynomial4DtoMD(md, NULL, "polyMD"), - "psPolynomial4DtoMD: return false for NULL polynomial input."); + ok( !psPolynomial4DtoMetadata(md, NULL, "polyMD"), + "psPolynomial4DtoMetadata: 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."); + ok( !psPolynomial4DtoMetadata(md, emptyPoly, "polyMD"), + "psPolynomial4DtoMetadata: return false for empty polynomial input."); psFree(emptyPoly); } @@ -495,6 +495,6 @@ 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)."); + ok( psPolynomial4DtoMetadata(md, constPoly, "polyMD"), + "psPolynomial4DtoMetadata: return true for constant polynomial (1 element != 0)."); psFree(constPoly); } @@ -503,28 +503,28 @@ 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"); + ok( !psPolynomial4DtoMetadata(md, p4d2, "polyMD"), + "psPolynomial4DtoMetadata: return false for chebyshev polynomial"); psFree(p4d2); } - //psPolynomial4DfromMD Tests + //psPolynomial4DfromMetadata Tests //Return NULL for NULL metadata input. { psPolynomial4D *emptyPoly2D = NULL; - emptyPoly2D = psPolynomial4DfromMD(NULL); + emptyPoly2D = psPolynomial4DfromMetadata(NULL); ok( emptyPoly2D == NULL, - "psPolynomial4DfromMD: return NULL for NULL metadata input."); + "psPolynomial4DfromMetadata: return NULL for NULL metadata input."); } //Get a polynomial from Metadata. psPolynomial4D *outPoly = NULL; - psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD"); - outPoly = psPolynomial4DfromMD(polyMDtemp); + psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD"); + outPoly = psPolynomial4DfromMetadata(polyMDtemp); { skip_start( outPoly == NULL, 1, - "Skipping 1 tests because psPolynomial4DfromMD has errors."); + "Skipping 1 tests because psPolynomial4DfromMetadata 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"); + "psPolynomial4DfromMetadata: return correct polynomial from metadata"); skip_end(); } @@ -533,39 +533,39 @@ psFree(outPoly); outPoly = NULL; - outPoly = psPolynomial4DfromMD(polyMDtemp); + outPoly = psPolynomial4DfromMetadata(polyMDtemp); { // ok( outPoly->mask[1][1][1] == 1, - // "psPolynomial4DfromMD: return mask[1][1][1] == 1 for metadata-polynomial" + // "psPolynomial4DfromMetadata: return mask[1][1][1] == 1 for metadata-polynomial" // " with missing element"); ok( outPoly == NULL, - "psPolynomial4DfromMD: return NULL for polynomial with missing coeff"); + "psPolynomial4DfromMetadata: 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"); + outPoly = psPolynomial4DfromMetadata(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial4DfromMetadata: 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"); + outPoly = psPolynomial4DfromMetadata(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial4DfromMetadata: 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"); + outPoly = psPolynomial4DfromMetadata(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial4DfromMetadata: 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"); + outPoly = psPolynomial4DfromMetadata(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial4DfromMetadata: return NULL for metadata-polynomial with no x-order"); }