Index: trunk/psLib/test/math/tap_psPolynomialEval1D.c =================================================================== --- trunk/psLib/test/math/tap_psPolynomialEval1D.c (revision 12777) +++ trunk/psLib/test/math/tap_psPolynomialEval1D.c (revision 12781) @@ -4,6 +4,6 @@ * ORD and CHEB type polynomials. * -* @version $Revision: 1.5 $ $Name: not supported by cvs2svn $ -* @date $Date: 2007-01-30 04:49:52 $ +* @version $Revision: 1.6 $ $Name: not supported by cvs2svn $ +* @date $Date: 2007-04-10 21:09:30 $ * * XXX: Probably should test single- and multi-dimensional polynomials in @@ -75,5 +75,5 @@ skip_end(); psFree(polyOrd); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } Index: trunk/psLib/test/math/tap_psStats00.c =================================================================== --- trunk/psLib/test/math/tap_psStats00.c (revision 12777) +++ trunk/psLib/test/math/tap_psStats00.c (revision 12781) @@ -9,6 +9,6 @@ * @author GLG, MHPCC * - * @version $Revision: 1.5 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-03-27 22:52:03 $ + * @version $Revision: 1.6 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-04-10 21:09:30 $ * * Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii @@ -242,5 +242,5 @@ } bool result = psVectorStats(myStats, myVector, NULL, maskVector, 1); - ok(result == false, "psVectorStats suceeded (All values masked)"); + ok(result == true, "psVectorStats() returned TRUE (All values masked)"); ok(isnan(myStats->sampleMean), "psVectorStats() returned NAN"); ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); Index: trunk/psLib/test/math/tap_psStats09.c =================================================================== --- trunk/psLib/test/math/tap_psStats09.c (revision 12777) +++ trunk/psLib/test/math/tap_psStats09.c (revision 12781) @@ -115,5 +115,4 @@ for (psS32 i=0;idata.F32[i] = ERRORS; - errors->n++; } } @@ -125,5 +124,4 @@ for (psS32 i=0;idata.F64[i] = ERRORS; - errors->n++; } } @@ -135,5 +133,4 @@ for (psS32 i=0;idata.S8[i] = (psS8) ERRORS; - errors->n++; } } @@ -145,5 +142,4 @@ for (psS32 i=0;idata.U16[i] = (psU16) ERRORS; - errors->n++; } } @@ -155,5 +151,4 @@ for (psS32 i=0;idata.S32[i] = (psS32) ERRORS; - errors->n++; } } @@ -171,5 +166,4 @@ for (psS32 i=0;idata.U8[i] = (psU8) 0; - mask->n++; } } @@ -181,5 +175,4 @@ for (psS32 i=0;idata.S32[i] = (psS32) 0; - mask->n++; } } @@ -282,5 +275,5 @@ bool rc = psVectorStats(myStats, in, errors, outliers, 1); if (rc == false) { - diag("TEST ERROR: the psVectorStats() function returned NULL.\n"); + diag("TEST ERROR: the psVectorStats() function returned NULL (a).\n"); testStatus = false; } else { @@ -301,5 +294,5 @@ if (rc == false) { if (expectedRC == true) { - diag("TEST ERROR: the psVectorStats() function returned NULL.\n"); + diag("TEST ERROR: the psVectorStats() function returned NULL (b).\n"); testStatus = false; } Index: trunk/psLib/test/mathtypes/tap_psImage.c =================================================================== --- trunk/psLib/test/mathtypes/tap_psImage.c (revision 12777) +++ trunk/psLib/test/mathtypes/tap_psImage.c (revision 12781) @@ -6,6 +6,6 @@ * @author Robert DeSonia, MHPCC * - * @version $Revision: 1.5 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-03-20 03:57:25 $ + * @version $Revision: 1.6 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-04-10 21:09:30 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -16,18 +16,9 @@ #include #include - #include "pslib.h" #include "psType.h" - #include "tap.h" #include "pstap.h" - -//static int Okay = 1; -//static int setOkay( int okay ) -//{ -// Okay = okay; -// return okay; -//} #define OK(exp) \ @@ -40,524 +31,387 @@ } - - int main(int argc, char* argv[]) { - plan_tests(383); - - void testImageAlloc(void); - testImageAlloc(); - - void testRegion(void); - testRegion(); - - void testRegion2(void); - testRegion2(); - - void testRegion3(void); - testRegion3(); - - void testImageInit(void); - testImageInit(); - - void testImageSet(void); - testImageSet(); + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(402); + + // testImageAlloc() + { + psMemId id = psMemGetId(); + psImage* image = NULL; + psU32 sizes = 6; + psU32 numCols[] = {0,1,1,100,100,150}; + psU32 numRows[] = {0,1,100,1,150,100}; + psU32 types = 12; + psElemType type[] = { PS_TYPE_S8, PS_TYPE_S16, PS_TYPE_S32, PS_TYPE_S64, + PS_TYPE_U8, PS_TYPE_U16, PS_TYPE_U32, PS_TYPE_U64, + PS_TYPE_F32, PS_TYPE_F64 }; + for (psU32 t=0;ttype.dimen==PS_DIMEN_IMAGE && image->type.type==type[t], + "psImageAlloc allocated dimen/type (%d/%d), expecting " + "PS_IMAGE_DIMEN/%d", image->type.dimen, + image->type.type, type[t]); + ok(image->numCols == numCols[i] && image->numRows == numRows[i], + "psImageAlloc allocated size %dx%d, expecting be %dx%d " + "(type = %d)", image->numCols, image->numRows, numCols[i], + numRows[i],type[t]); + ok(image->col0 == 0 && image->row0 == 0, + "psImageAlloc returned row0/col0 of %d/%d. Expected 0/0.", + image->row0, image->row0); + ok(image->parent == NULL, "psImageAlloc returned NULL parent"); + ok(image->children == NULL, + "psImageAlloc returned NULL children array"); + + + if (image->children != NULL) { + psFree(image); + } + + switch (type[t]) { + case PS_TYPE_U16: { + psU32 rows = numRows[i]; + psU32 cols = numCols[i]; + + for (psS32 r=0;rdata.U16[r][c] = 2*c+r; + } + } + bool errorFlag = false; + for (psS32 r=0;rdata.U16[r][c] != 2*c+r) { + errorFlag = true; + } + } + } + ok(!errorFlag, "psImageAlloc() set data correctly (U16)"); + } + break; + case PS_TYPE_F32: { + psU32 rows = numRows[i]; + psU32 cols = numCols[i]; + + for (psS32 r=0;rdata.F32[r][c] = 2.0f*c+r; + } + } + bool errorFlag = false; + for (psS32 r=0;rdata.F32[r][c] - (2.0f*c+r)) > FLT_EPSILON) { + errorFlag = true; + } + } + } + ok(!errorFlag, "psImageAlloc() set data correctly (F32)"); + } + break; + case PS_TYPE_F64: { + psU32 rows = numRows[i]; + psU32 cols = numCols[i]; + + for (psS32 r=0;rdata.F64[r][c] = 2.0f*c+r; + } + } + bool errorFlag = false; + for (psS32 r=0;rdata.F64[r][c] - (2.0f*c+r)) > DBL_EPSILON) { + errorFlag = true; + } + } + } + ok(!errorFlag, "psImageAlloc() set data correctly (F64)"); + } + break; + default: { + // ignore type and just use as byte bucket. + psU32 rows = numRows[i]; + psU32 cols = numCols[i]*PSELEMTYPE_SIZEOF(type[t]); + + for (psS32 r=0;rdata.U8[r][c] = (uint8_t)(r + c); + } + } + bool errorFlag = false; + for (psS32 r=0;rdata.U8[r][c] != (uint8_t)(r + c)) { + errorFlag = true; + } + } + } + ok(!errorFlag, "psImageAlloc() set data correctly (default)"); + } + } + psFree(image); + } + } + + // #548: Verify no memory leaks or corruption are detected after a valid psImage structure with multiple + // children is freed. + image = psImageAlloc(100,100,PS_TYPE_F32); + psImageSubset(image,(psRegion) {50,0,70,20}); + psImageSubset(image,(psRegion) {70,20,90,40}); + psFree(image); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // testRegion() + { + psMemId id = psMemGetId(); + psRegion region = psRegionSet(1,2,3,4); + char *tmpStr = psRegionToString(region); + ok(!(region.x0 != 1 || region.x1 != 2 || region.y0 != 3 || region.y1 != 4), + "The region attributes are set to (%s)", tmpStr); + psFree(tmpStr); + region = psRegionFromString("[1:2,3:4]"); + tmpStr = psRegionToString(region); + ok(!(region.x0 != 0 || region.x1 != 2 || region.y0 != 2 || region.y1 != 4), + "The region attributes are set to (%s)", tmpStr); + psFree(tmpStr); + region = psRegionFromString("[1:2,3:]"); + ok(isnan(region.x0), + "psRegionFromString returned a NULL pointer given a malformed string."); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + //psRegionForImage + { + psMemId id = psMemGetId(); + psImage *in; + psRegion inReg; + psRegion out; + in = psImageAlloc(1, 1, PS_TYPE_S32); + inReg = psRegionSet(1, 2, 1, 2); + out = psRegionForImage(in,inReg); + psRegion inReg2; + psRegion out2; + inReg2 = psRegionSet(-1, 0, -2, -1); + out2 = psRegionForImage(in, inReg2); + + ok(!( out.x0 != 1 || out.x1 != 1 || out.y0 != 1 || out.y1 != 1 ), + "Region For Image returned correct values"); + + ok(!( out2.x0 != 0 || out2.x1 != 1 || out2.y0 != 0 || out2.y1 != 0 ), + "Region For Image returned correct values"); + psFree(in); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + //psRegionForSquare// + { + psMemId id = psMemGetId(); + float X = 1; + float Y = 1; + float RAD = 1; + psRegion out; + out = psRegionForSquare(X, Y, RAD); + ok(!(out.x0 != 0 || out.x1 != 3 || out.y0 != 0 || out.y1!= 3), + "Region For Square returned correct values"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + //Initialize an image with a given value.// + { + psMemId id = psMemGetId(); + psImage *in1 = NULL; + psImage *in2 = NULL; + psImage *in3 = NULL; + psImage *in4 = NULL; + int nRow = 1; + int nCol = 1; + in1 = psImageAlloc(nRow, nCol, PS_TYPE_U8); + ok(psImageInit(in1, 5 ), + "ImageAlloc. U8 Case - 1x1"); + nRow = 5; + in2 = psImageAlloc(nRow, nCol, PS_TYPE_F32); + ok(psImageInit(in2, 3), + "ImageAlloc. F32 Case - 5x1"); + + nCol = 5; + in3 = psImageAlloc(nRow, nCol, PS_TYPE_F64); + ok(psImageInit(in3, 3.14), + "ImageAlloc. F64 Case - 5x5"); + + in4 = psImageAlloc(nRow, nCol, PS_TYPE_S32); + ok(psImageInit(in4, 3), + "ImageAlloc. S32 Case - 5x5"); + psFree(in1); + psFree(in2); + psFree(in3); + psFree(in4); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // testImageSet() + { + psMemId id = psMemGetId(); + psImage *image = NULL; + image = psImageAlloc(5, 4, PS_TYPE_S32); + + //Set the position of the subimage relative to the parent. + image->col0 = 10; + image->row0 = 10; + for (int i = 0; i < 4; i++) { + for (int j = 0; j < 5; j++) { + image->data.S32[i][j] = i+j; + } + } + + //Attempt to set a position in a NULL psImage* + psImage *none = NULL; + ok(! psImageSet(none, 1, 1, 1), + "psImageSet returned non-null"); + + //Attempt to set a position in a psImage* with negative numCols, numRows + none = psImageAlloc(2, 2, PS_TYPE_S32); + *(int*)&none->numCols = -1; + ok(! psImageSet(none, 1, 1, 1), + "psImageSet return false when passed an image with negative numCols"); + + *(int*)&none->numCols = 2; + *(int*)&none->numRows = -1; + ok(!psImageSet(none, 1, 1, 1), + "psImageSet failed to return false when passed an image with negative numRows"); + + //Attempt to set a position in a psImage* with negative col0, row0 + *(int*)&none->numRows = 2; + none->row0 = -1; + ok(!psImageSet(none, 1, 1, 1), + "psImageSet failed to return false when passed an image with negative col0"); + + none->row0 = 0; + none->col0 = -1; + ok(!psImageSet(none, 1, 1, 1), + "psImageSet failed to return false when passed an image with negative col0"); + psFree(none); + + //Try to set a position inside of the subimage. + ok(psImageSet(image, 14, 12, 666), + "psImageSet failed to return true when passed valid parameters"); + + ok(image->data.S32[2][4] == 666, + "psImageSet set the data value. value=%d", image->data.S32[2][4]); + + //Try to set a position inside of the subimage from the tail. + ok(psImageSet(image, -1, -1, 666), + "psImageSet return true when passed valid parameters"); + + ok(image->data.S32[3][4] == 666, + "psImageSet set (from the tail) the data values correctly"); + + //Try to set a position outside of the subimage but inside of the parent image. + ok(!psImageSet(image, 0, 0, 666), + "psImageSet return false when passed an invalid location"); + + ok(!psImageSet(image, 9, 10, 666), + "psImageSet return false when passed an invalid location"); + + //Try to set a position outside of the subimage. + ok(!psImageSet(image, 15, 14, 666), + "psImageSet return false when passed an invalid location"); + + //Try to set a position outside of the subimage, indexing from the tail. + ok(!psImageSet(image, -6, -1, 666), + "psImageSet return false when passed an invalid location"); + psFree(image); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // testImageGet() + { + psMemId id = psMemGetId(); + psImage *image = NULL; + image = psImageAlloc(5, 3, PS_TYPE_S32); + + //Set the position of the subimage relative to the parent. + image->col0 = 10; + image->row0 = 10; + for (int i = 0; i < 3; i++) { + for (int j = 0; j < 5; j++) { + image->data.S32[i][j] = i+j; + } + } + + //Attempt to get a position in a NULL psImage* + psImage *none = NULL; + ok(isnan( psImageGet(none, 1, 1) ), + "psImageGet return false when passed a NULL image"); + + //Attempt to get a position in a psImage* with negative numCols, numRows + none = psImageAlloc(2, 2, PS_TYPE_S32); + *(int*)&none->numCols = -1; + ok(isnan( psImageGet(none, 1, 1) ), + "psImageGet return false when passed an image with negative numCols"); + + *(int*)&none->numCols = 2; + *(int*)&none->numRows = -1; + ok(isnan( psImageGet(none, 1, 1) ), + "psImageGet return false when passed an image with negative numRows"); + + //Attempt to get a position in a psImage* with negative col0, row0 + *(int*)&none->numRows = 2; + none->row0 = -1; + ok(isnan( psImageGet(none, 1, 1) ), + "psImageGet return false when passed an image with negative col0"); + + none->row0 = 0; + none->col0 = -1; + ok(isnan( psImageGet(none, 1, 1) ), + "psImageGet return false when passed an image with negative col0"); + + psFree(none); + + + //Try to get a position inside of the subimage. + ok(psImageGet(image, 14, 12) == 6, + "psImageGet return the correct value"); + + //Try to get a position inside of the subimage from the tail. + ok(psImageGet(image, -1, -1) == 6, + "psImageGet return the correct value"); + + //Try to get a position outside of the subimage but inside of the parent image. + ok(isnan( psImageGet(image, 1, 1) ), + "psImageGet return NAN when passed an invalid location"); + + ok(isnan( psImageGet(image, 9, 10) ), + "psImageGet return NAN when passed an invalid location"); + + //Try to set a position outside of the subimage. + ok(isnan( psImageGet(image, 15, 14) ), + "psImageGet return NAN when passed an invalid location"); + + //Try to set a position outside of the subimage, indexing from the tail. + ok(isnan( psImageGet(image, -6, -1) ), + "psImageGet failed to return NAN when passed an invalid location"); + psFree(image); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } } - - -void testImageAlloc() -{ -// diag("testImageAlloc"); - - psImage* image = NULL; - psU32 sizes = 6; - psU32 numCols[] = { - 0,1,1,100,100,150 - }; - psU32 numRows[] = { - 0,1,100,1,150,100 - }; - psU32 types = 12; - psElemType type[] = { PS_TYPE_S8, PS_TYPE_S16, PS_TYPE_S32, PS_TYPE_S64, - PS_TYPE_U8, PS_TYPE_U16, PS_TYPE_U32, PS_TYPE_U64, - PS_TYPE_F32, PS_TYPE_F64 }; - - for (psU32 t=0;ttype.dimen==PS_DIMEN_IMAGE && image->type.type==type[t], - "psImageAlloc allocated dimen/type (%d/%d), expecting " - "PS_IMAGE_DIMEN/%d", image->type.dimen, - image->type.type, type[t]); - skip_start (!(image->type.dimen==PS_DIMEN_IMAGE && image->type.type==type[t]), - 4, "psImageAlloc allocated wrong dimen/type"); - - ok (image->numCols == numCols[i] && image->numRows == numRows[i], - "psImageAlloc allocated size %dx%d, expecting be %dx%d " - "(type = %d)", image->numCols, image->numRows, numCols[i], - numRows[i],type[t]); - skip_start (!(image->numCols == numCols[i] && image->numRows == numRows[i]), - 3, "psImageAlloc allocated wrong size"); - - ok (image->col0 == 0 && image->row0 == 0, - "psImageAlloc returned row0/col0 of %d/%d. Expected 0/0.", - image->row0, image->row0); - skip_start (!(image->col0 == 0 && image->row0 == 0), - 2, "psImageAlloc returned wrong row0/col0"); - - ok (image->parent == NULL, "psImageAlloc returned NULL parent"); - skip_start (image->parent != NULL, - 1, "psImageAlloc returned NULL parent"); - - ok (image->children == NULL, - "psImageAlloc returned NULL children array"); - - skip_end(); - skip_end(); - skip_end(); - skip_end(); - - if (image->children != NULL) { - psFree(image); - return; - } - - switch (type[t]) { - case PS_TYPE_U16: { - psU32 rows = numRows[i]; - psU32 cols = numCols[i]; - - for (psS32 r=0;rdata.U16[r][c] = 2*c+r; - } - } - bool errorFlag = false; - for (psS32 r=0;rdata.U16[r][c] != 2*c+r) { -// diag("ERROR: Could not set all pixels in uint16 image at (%d,%d)",c,r); - errorFlag = true; - } - } - } - ok(!errorFlag, "psImageAlloc() set data correctly (U16)"); - } - break; - case PS_TYPE_F32: { - psU32 rows = numRows[i]; - psU32 cols = numCols[i]; - - for (psS32 r=0;rdata.F32[r][c] = 2.0f*c+r; - } - } - bool errorFlag = false; - for (psS32 r=0;rdata.F32[r][c] - (2.0f*c+r)) > FLT_EPSILON) { -// diag("Could not set all pixels in float image at (%d,%d)",c,r); - errorFlag = true; - } - } - } - ok(!errorFlag, "psImageAlloc() set data correctly (F32)"); - } - break; - case PS_TYPE_F64: { - psU32 rows = numRows[i]; - psU32 cols = numCols[i]; - - for (psS32 r=0;rdata.F64[r][c] = 2.0f*c+r; - } - } - bool errorFlag = false; - for (psS32 r=0;rdata.F64[r][c] - (2.0f*c+r)) > DBL_EPSILON) { -// diag("Set all pixels in double image at (%d,%d)",c,r); - errorFlag = true; - } - } - } - ok(!errorFlag, "psImageAlloc() set data correctly (F64)"); - } - break; - default: { - // ignore type and just use as byte bucket. - psU32 rows = numRows[i]; - psU32 cols = numCols[i]*PSELEMTYPE_SIZEOF(type[t]); - - for (psS32 r=0;rdata.U8[r][c] = (uint8_t)(r + c); - } - } - bool errorFlag = false; - for (psS32 r=0;rdata.U8[r][c] != (uint8_t)(r + c)) { -// diag("Set all pixels in image (type=%d) at (%d,%d)", type[t],c,r); - errorFlag = true; - } - } - } - ok(!errorFlag, "psImageAlloc() set data correctly (default)"); - } - } - psFree(image); - } - } - - // #548: Verify no memory leaks or corruption are detected after a valid psImage structure with multiple - // children is freed. - image = psImageAlloc(100,100,PS_TYPE_F32); - psImageSubset(image,(psRegion) { - 50,0,70,20 - } - ); - psImageSubset(image,(psRegion) { - 70,20,90,40 - } - ); - - psFree(image); -} - - - -void testRegion() -{ - // Testpoint #790 - -// diag("testRegion"); - - psRegion region = psRegionSet(1,2,3,4); - ok (!(region.x0 != 1 || region.x1 != 2 || region.y0 != 3 || region.y1 != 4), - "The region attributes are set to (%s)", psRegionToString(region)); - - // Testpoint #791 - - region = psRegionFromString("[1:2,3:4]"); - ok (!(region.x0 != 0 || region.x1 != 2 || region.y0 != 2 || region.y1 != 4), - "The region attributes are set to (%s)", psRegionToString(region)); - - region = psRegionFromString("[1:2,3:]"); - ok (isnan(region.x0), - "psRegionFromString returned a NULL pointer given a malformed string."); -} - - -//psRegionForImage// -void testRegion2() -{ -// diag("testRegion2"); - - psImage *in; - psRegion inReg; - psRegion out; - in = psImageAlloc(1, 1, PS_TYPE_S32); - inReg = psRegionSet(1, 2, 1, 2); - out = psRegionForImage(in,inReg); - psRegion inReg2; - psRegion out2; - inReg2 = psRegionSet(-1, 0, -2, -1); - out2 = psRegionForImage(in, inReg2); - - ok(!( out.x0 != 1 || out.x1 != 1 || out.y0 != 1 || out.y1 != 1 ), - "Region For Image returned correct values.\n"); - - ok(!( out2.x0 != 0 || out2.x1 != 1 || out2.y0 != 0 || out2.y1 != 0 ), - "Region For Image returned correct values.\n"); - - psFree(in); -} - - -//psRegionForSquare// -void testRegion3() -{ -// diag("testRegion3"); - - float X = 1; - float Y = 1; - float RAD = 1; - psRegion out; - out = psRegionForSquare(X, Y, RAD); - ok (!(out.x0 != 0 || out.x1 != 3 || out.y0 != 0 || out.y1!= 3), - "Region For Square returned correct values.\n"); -} - - -//Initialize an image with a given value.// -void testImageInit() -{ -// diag("testImageInit"); - - psImage *in1 = NULL; - psImage *in2 = NULL; - psImage *in3 = NULL; - psImage *in4 = NULL; - int nRow = 1; - int nCol = 1; - in1 = psImageAlloc(nRow, nCol, PS_TYPE_U8); - ok ( psImageInit(in1, 5 ), - "ImageAlloc. U8 Case - 1x1\n"); - nRow = 5; - in2 = psImageAlloc(nRow, nCol, PS_TYPE_F32); - ok ( psImageInit(in2, 3), - "ImageAlloc. F32 Case - 5x1\n"); - - nCol = 5; - in3 = psImageAlloc(nRow, nCol, PS_TYPE_F64); - ok ( psImageInit(in3, 3.14), - "ImageAlloc. F64 Case - 5x5\n"); - - in4 = psImageAlloc(nRow, nCol, PS_TYPE_S32); - ok ( psImageInit(in4, 3), - "ImageAlloc. S32 Case - 5x5\n"); - - psFree(in1); - psFree(in2); - psFree(in3); - psFree(in4); -} - - -void testImageSet() -{ -// diag("testImageSet"); - - psImage *image = NULL; - image = psImageAlloc(5, 4, PS_TYPE_S32); - - //Set the position of the subimage relative to the parent. - image->col0 = 10; - image->row0 = 10; - for (int i = 0; i < 4; i++) { - for (int j = 0; j < 5; j++) { - image->data.S32[i][j] = i+j; - } - } - - //Attempt to set a position in a NULL psImage* - psImage *none = NULL; - ok (! psImageSet(none, 1, 1, 1), - "psImageSet returned non-null.\n"); - skip_start ( psImageSet(none, 1, 1, 1), - 12, "psImageSet failed"); - - //Attempt to set a position in a psImage* with negative numCols, numRows - none = psImageAlloc(2, 2, PS_TYPE_S32); - *(int*)&none->numCols = -1; - ok (! psImageSet(none, 1, 1, 1), - "psImageSet return false when passed an image with negative numCols"); - skip_start ( psImageSet(none, 1, 1, 1), - 11,"psImageSet return true when passed an image with negative numCols"); - - *(int*)&none->numCols = 2; - *(int*)&none->numRows = -1; - ok ( !psImageSet(none, 1, 1, 1), - "psImageSet failed to return false when passed an image with negative numRows.\n"); - skip_start ( psImageSet(none, 1, 1, 1), - 10,"psImageSet return true when passed an image with negative numRows."); - - //Attempt to set a position in a psImage* with negative col0, row0 - *(int*)&none->numRows = 2; - none->row0 = -1; - ok ( !psImageSet(none, 1, 1, 1), - "psImageSet failed to return false when passed an image with negative col0.\n"); - skip_start ( psImageSet(none, 1, 1, 1), - 9,"psImageSet return true when passed an image with negative col0.\n"); - - none->row0 = 0; - none->col0 = -1; - ok ( !psImageSet(none, 1, 1, 1), - "psImageSet failed to return false when passed an image with negative col0.\n"); - skip_start ( psImageSet(none, 1, 1, 1), - 8,"psImageSet return true when passed an image with negative col0.\n"); - - psFree(none); - - //Try to set a position inside of the subimage. - ok ( psImageSet(image, 14, 12, 666), - "psImageSet failed to return true when passed valid parameters.\n"); - skip_start ( !psImageSet(image, 14, 12, 666), - 7,"psImageSet failed to return true when passed valid parameters.\n"); - - ok (image->data.S32[2][4] == 666, - "psImageSet set the data value. value=%d\n", image->data.S32[2][4]); - skip_start (image->data.S32[2][4] != 666, - 6,"psImageSet set the data value. value=%d\n", image->data.S32[2][4]); - - //Try to set a position inside of the subimage from the tail. - ok ( psImageSet(image, -1, -1, 666), - "psImageSet return true when passed valid parameters.\n"); - skip_start ( !psImageSet(image, -1, -1, 666), - 5,"psImageSet failed to return true when passed valid parameters.\n"); - - ok (image->data.S32[3][4] == 666, - "psImageSet set (from the tail) the data values correctly.\n"); - skip_start (image->data.S32[3][4] != 666, - 4,"psImageSet set (from the tail) the data values incorrectly.\n"); - - - //Try to set a position outside of the subimage but inside of the parent image. - ok ( !psImageSet(image, 0, 0, 666), - "psImageSet return false when passed an invalid location.\n"); - skip_start ( psImageSet(image, 0, 0, 666), - 3,"psImageSet failed to return false when passed an invalid location"); - - ok ( !psImageSet(image, 9, 10, 666), - "psImageSet return false when passed an invalid location.\n"); - skip_start ( psImageSet(image, 9, 10, 666), - 2,"psImageSet return false when passed an invalid location.\n"); - - //Try to set a position outside of the subimage. - ok ( !psImageSet(image, 15, 14, 666), - "psImageSet return false when passed an invalid location.\n"); - skip_start ( psImageSet(image, 15, 14, 666), - 1,"psImageSet failed to return false when passed an invalid location"); - - //Try to set a position outside of the subimage, indexing from the tail. - ok ( !psImageSet(image, -6, -1, 666), - "psImageSet return false when passed an invalid location.\n"); - - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - - psFree(image); -} - - -void testImageGet() -{ -// diag("testImageGet"); - - psImage *image = NULL; - image = psImageAlloc(5, 3, PS_TYPE_S32); - - //Set the position of the subimage relative to the parent. - image->col0 = 10; - image->row0 = 10; - for (int i = 0; i < 3; i++) { - for (int j = 0; j < 5; j++) { - image->data.S32[i][j] = i+j; - } - } - - //Attempt to get a position in a NULL psImage* - psImage *none = NULL; - ok ( isnan( psImageGet(none, 1, 1) ), - "psImageGet return false when passed a NULL image.\n"); - skip_start ( !isnan( psImageGet(none, 1, 1) ), - 10,"psImageGet failed to return false when passed a NULL image.\n"); - - //Attempt to get a position in a psImage* with negative numCols, numRows - none = psImageAlloc(2, 2, PS_TYPE_S32); - *(int*)&none->numCols = -1; - ok ( isnan( psImageGet(none, 1, 1) ), - "psImageGet return false when passed an image with negative numCols"); - skip_start ( !isnan( psImageGet(none, 1, 1) ), - 9,"psImageGet return true when passed an image with negative numCols"); - - *(int*)&none->numCols = 2; - *(int*)&none->numRows = -1; - ok ( isnan( psImageGet(none, 1, 1) ), - "psImageGet return false when passed an image with negative numRows"); - skip_start ( !isnan( psImageGet(none, 1, 1) ), - 8,"psImageGet failed to return false when passed an image with negative numRows.\n"); - - //Attempt to get a position in a psImage* with negative col0, row0 - *(int*)&none->numRows = 2; - none->row0 = -1; - ok ( isnan( psImageGet(none, 1, 1) ), - "psImageGet return false when passed an image with negative col0.\n"); - skip_start ( !isnan( psImageGet(none, 1, 1) ), - 7,"psImageGet return false when passed an image with negative col0.\n"); - - none->row0 = 0; - none->col0 = -1; - ok ( isnan( psImageGet(none, 1, 1) ), - "psImageGet return false when passed an image with negative col0.\n"); - skip_start ( !isnan( psImageGet(none, 1, 1) ), - 6,"psImageGet failed to return false when passed an image with negative col0.\n"); - - psFree(none); - - - //Try to get a position inside of the subimage. - ok ( psImageGet(image, 14, 12) == 6, - "psImageGet return the correct value.\n"); - skip_start ( psImageGet(image, 14, 12) != 6, - 5,"psImageGet failed to return the correct value.\n"); - - //Try to get a position inside of the subimage from the tail. - ok ( psImageGet(image, -1, -1) == 6, - "psImageGet return the correct value.\n"); - skip_start ( psImageGet(image, -1, -1) == 6, - 4, "psImageGet failed to return the correct value.\n"); - - //Try to get a position outside of the subimage but inside of the parent image. - ok ( isnan( psImageGet(image, 1, 1) ), - "psImageGet return NAN when passed an invalid location.\n"); - skip_start ( !isnan( psImageGet(image, 1, 1) ), - 3, "psImageGet didn't return NAN when passed an invalid location.\n"); - - ok ( isnan( psImageGet(image, 9, 10) ), - "psImageGet return NAN when passed an invalid location.\n"); - skip_start ( ! isnan( psImageGet(image, 9, 10) ), - 2,"psImageGet failed to return NAN when passed an invalid location.\n"); - - //Try to set a position outside of the subimage. - ok ( isnan( psImageGet(image, 15, 14) ), - "psImageGet return NAN when passed an invalid location.\n"); - skip_start ( !isnan( psImageGet(image, 15, 14) ), - 1, "psImageGet didn't return NAN when passed an invalid location.\n"); - - //Try to set a position outside of the subimage, indexing from the tail. - ok ( isnan( psImageGet(image, -6, -1) ), - "psImageGet failed to return NAN when passed an invalid location.\n"); - - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - - - psFree(image); -} Index: trunk/psLib/test/mathtypes/tap_psImageInterpolate.c =================================================================== --- trunk/psLib/test/mathtypes/tap_psImageInterpolate.c (revision 12777) +++ trunk/psLib/test/mathtypes/tap_psImageInterpolate.c (revision 12781) @@ -8,318 +8,257 @@ int main (void) { - plan_tests(88); - -// diag("psImageInterpolate() tests"); + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(47); // very simple tests: no mask, bilinear mode, xramp image only { psMemId id = psMemGetId(); - -// diag ("interpolate a delta function"); - - // generate simple image (x ramp) - psImage *image = psImageAlloc(32, 32, PS_TYPE_F64); - ok(image != NULL, "psImage successfully allocated"); - skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); - - psImageInit(image, 0.0); - image->data.F64[10][10] = 1; - - // center of pixels is 0.5, 0.5 - double value; - - psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BILINEAR, - image, NULL, NULL, 0, 0.0, 0.0, - 0, 0, 0.0); - ok(interp, "Interpolation options set"); - - ok(psImageInterpolate(&value, NULL, NULL, 10.5, 10.5, interp), "Interpolation"); - is_double (value, 1.0, "pixel center value - %f", value); - -// diag ("why do I need to have tolerances of 4epsilon or so??"); - - ok(psImageInterpolate(&value, NULL, NULL, 10.9, 10.5, interp), "Interpolation"); - is_double_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 10.5, 10.9, interp), "Interpolation"); - is_double_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 10.1, 10.5, interp), "Interpolation"); - is_double_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value); - - psFree(interp); - - skip_end(); - - psFree(image); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } + // generate simple image (x ramp) + psImage *image = psImageAlloc(32, 32, PS_TYPE_F32); + ok(image != NULL, "psImage successfully allocated"); + skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); + + image->data.F32[10][10] = 1; + + // center of pixels is 0.5, 0.5 + float value; + + value = psImagePixelInterpolate (image, 10.5, 10.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 1.0, "pixel center value - %f", value); + + value = psImagePixelInterpolate (image, 10.9, 10.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value); + + value = psImagePixelInterpolate (image, 10.5, 10.9, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value); + + value = psImagePixelInterpolate (image, 10.1, 10.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value); + + skip_end(); + + psFree(image); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + // very simple tests: no mask, bilinear mode, xramp image only { psMemId id = psMemGetId(); - -// diag ("interpolate an x-ramp"); - - // generate simple image (x ramp) - psImage *image = psImageAlloc(32, 32, PS_TYPE_F64); - ok(image != NULL, "psImage successfully allocated"); - skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); - - for (int j = 0; j < image->numRows; j++) { - for (int i = 0; i < image->numCols; i++) { - image->data.F64[j][i] = i + 0.5; - } - } - - // center of pixels is 0.5, 0.5 - double value; - - psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BILINEAR, - image, NULL, NULL, 0, 0.0, 0.0, - 0, 0, 0.0); - ok(interp, "Interpolation options set"); - - ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation"); - is_double_tol (value, 2.5, 5.0e-8, "pixel center value - %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.5, interp), "Interpolation"); - is_double_tol (value, 2.2, 5.0e-8, "coord: 2.2, 2.5, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.5, interp), "Interpolation"); - is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.2, interp), "Interpolation"); - is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation"); - is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 0.8, 2.8, interp), "Interpolation"); - is_double_tol (value, 0.8, 5.0e-8, "coord: 0.8, value: %f", value); + // generate simple image (x ramp) + psImage *image = psImageAlloc(32, 32, PS_TYPE_F32); + ok(image != NULL, "psImage successfully allocated"); + skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); + + for (int j = 0; j < image->numRows; j++) + { + for (int i = 0; i < image->numCols; i++) { + image->data.F32[j][i] = i + 0.5; + } + } + + // center of pixels is 0.5, 0.5 + float value; + + value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 2.5, "pixel center value - %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 0.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 0.8, "coord: 0.8, value: %f", value); // no extrapolation - ok(psImageInterpolate(&value, NULL, NULL, 0.3, 2.8, interp), "Interpolation"); - is_double (value, 0.0, "coord: 0.3, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, -0.2, 2.8, interp), "Interpolation"); - is_double (value, 0.0, "coord: -0.2, value: %f", value); - - psFree(interp); - - skip_end(); - - psFree(image); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } + value = psImagePixelInterpolate (image, 0.3, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 0.5, "coord: 0.3, value: %f", value); + + value = psImagePixelInterpolate (image, -0.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 0.5, "coord: -0.2, value: %f", value); + + skip_end(); + + psFree(image); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + // very simple tests: no mask, bilinear mode, yramp image only { psMemId id = psMemGetId(); - -// diag ("interpolate a y-ramp: "); - // generate simple image (y ramp) - psImage *image = psImageAlloc(32, 32, PS_TYPE_F64); - ok(image != NULL, "psImage successfully allocated"); - skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); - - for (int j = 0; j < image->numRows; j++) - { - for (int i = 0; i < image->numCols; i++) { - image->data.F64[j][i] = j + 0.5; - } - } - - // center of pixels is 0.5, 0.5 - double value; - - psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BILINEAR, - image, NULL, NULL, 0, 0.0, 0.0, - 0, 0, 0.0); - ok(interp, "Interpolation options set"); - - ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation"); - is_double_tol (value, 2.5, 5.0e-8, "pixel center value - %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.2, interp), "Interpolation"); - is_double_tol (value, 2.2, 5.0e-8, "coord: 2.2, 2.2, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.8, interp), "Interpolation"); - is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.8, interp), "Interpolation"); - is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation"); - is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value); - - psFree(interp); - - skip_end(); - - psFree(image); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } + psImage *image = psImageAlloc(32, 32, PS_TYPE_F32); + ok(image != NULL, "psImage successfully allocated"); + skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); + + for (int j = 0; j < image->numRows; j++) + { + for (int i = 0; i < image->numCols; i++) { + image->data.F32[j][i] = j + 0.5; + } + } + + // center of pixels is 0.5, 0.5 + float value; + + value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 2.5, "pixel center value - %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value); + + value = psImagePixelInterpolate (image, 2.5, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR); + is_float (value, 2.8, "coord: 2.8, value: %f", value); + + skip_end(); + + psFree(image); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + // very simple tests: no mask, bicube mode, xramp image only { psMemId id = psMemGetId(); - -// diag ("interpolate an x-ramp (bicube)"); - - // generate simple image (x ramp) - psImage *image = psImageAlloc(32, 32, PS_TYPE_F64); - ok(image != NULL, "psImage successfully allocated"); - skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); - - for (int j = 0; j < image->numRows; j++) - { - for (int i = 0; i < image->numCols; i++) { - image->data.F64[j][i] = i + 0.5; - } - } - - // center of pixels is 0.5, 0.5 - double value; - - psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BICUBE, - image, NULL, NULL, 0, 0.0, 0.0, - 0, 0, 0.0); - ok(interp, "Interpolation options set"); - - ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation"); - is_double_tol (value, 2.5, 5.0e-8, "coord; 2.5, 2.5, value - %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.5, interp), "Interpolation"); - is_double_tol (value, 2.2, 5.0e-8, "coord: 2.2, 2.5, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.5, interp), "Interpolation"); - is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, 2.5, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.2, interp), "Interpolation"); - is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, 2.2, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation"); - is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, 2.8, value: %f", value); - -// diag ("coords outside of nominal range (1 < x < Nx - 2) return 'uncover'"); + // generate simple image (x ramp) + psImage *image = psImageAlloc(32, 32, PS_TYPE_F32); + ok(image != NULL, "psImage successfully allocated"); + skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); + + for (int j = 0; j < image->numRows; j++) + { + for (int i = 0; i < image->numCols; i++) { + image->data.F32[j][i] = i + 0.5; + } + } + + // center of pixels is 0.5, 0.5 + float value; + + value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 2.5, "coord; 2.5, 2.5, value - %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 2.8, "coord: 2.8, 2.5, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 2.8, "coord: 2.8, 2.2, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 2.8, "coord: 2.8, 2.8, value: %f", value); // no extrapolation: these return the 'uncover' value - ok(psImageInterpolate(&value, NULL, NULL, 0.8, 2.8, interp), "Interpolation"); - is_double (value, 0.0, "coord: 0.8, 2.8, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 0.3, 2.8, interp), "Interpolation"); - is_double (value, 0.0, "coord: 0.3, 2.8, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, -0.2, 2.8, interp), "Interpolation"); - is_double (value, 0.0, "coord: -0.2, 2.8, value: %f", value); - - psFree(interp); - - skip_end(); - - psFree(image); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } + value = psImagePixelInterpolate (image, 0.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 0.0, "coord: 0.8, 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 0.3, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 0.0, "coord: 0.3, 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, -0.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 0.0, "coord: -0.2, 2.8, value: %f", value); + + skip_end(); + + psFree(image); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + // very simple tests: no mask, bilinear mode, yramp image only { psMemId id = psMemGetId(); - -// diag ("interpolate a y-ramp (bicube)"); - // generate simple image (y ramp) - psImage *image = psImageAlloc(32, 32, PS_TYPE_F64); - ok(image != NULL, "psImage successfully allocated"); - skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); - - for (int j = 0; j < image->numRows; j++) - { - for (int i = 0; i < image->numCols; i++) { - image->data.F64[j][i] = j + 0.5; - } - } - - // center of pixels is 0.5, 0.5 - double value; - - psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BICUBE, - image, NULL, NULL, 0, 0.0, 0.0, - 0, 0, 0.0); - ok(interp, "Interpolation options set"); - - ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation"); - is_double_tol (value, 2.5, 5.0e-8, "pixel center value - %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.2, interp), "Interpolation"); - is_double_tol (value, 2.2, 5.0e-8, "coord: 2.2, 2.5, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.8, interp), "Interpolation"); - is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.8, interp), "Interpolation"); - is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation"); - is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value); - - psFree(interp); - - skip_end(); - - psFree(image); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } + psImage *image = psImageAlloc(32, 32, PS_TYPE_F32); + ok(image != NULL, "psImage successfully allocated"); + skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); + + for (int j = 0; j < image->numRows; j++) + { + for (int i = 0; i < image->numCols; i++) { + image->data.F32[j][i] = j + 0.5; + } + } + + // center of pixels is 0.5, 0.5 + float value; + + value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 2.5, "pixel center value - %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value); + + value = psImagePixelInterpolate (image, 2.5, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 2.8, "coord: 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 2.8, "coord: 2.8, value: %f", value); + + skip_end(); + + psFree(image); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + // very simple tests: no mask, bilinear mode, x,y 2nd order shape { psMemId id = psMemGetId(); - -// diag ("interpolate a quadratic shape (bicube)"); - - // generate simple image (x ramp) - psImage *image = psImageAlloc(32, 32, PS_TYPE_F64); - ok(image != NULL, "psImage successfully allocated"); - skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); - - for (int j = 0; j < image->numRows; j++) - { - for (int i = 0; i < image->numCols; i++) { - image->data.F64[j][i] = 0.25*PS_SQR(i + 0.5) + j + 0.5; - } - } - - // center of pixels is 0.5, 0.5 - double value; - - psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BICUBE, - image, NULL, NULL, 0, 0.0, 0.0, - 0, 0, 0.0); - ok(interp, "Interpolation options set"); - - ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation"); - is_double_tol (value, 4.0625, 2.0e-7, "pixel center value - %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.2, interp), "Interpolation"); - is_double_tol (value, 3.41, 2.0e-7, "coord: 2.2, 2.5, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.8, interp), "Interpolation"); - is_double_tol (value, 4.3625, 2.0e-7, "coord: 2.5, 2.8, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.8, interp), "Interpolation"); - is_double_tol (value, 4.01, 2.0e-7, "coord: 2.2, 2.8, value: %f", value); - - ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation"); - is_double_tol (value, 4.76, 2.0e-7, "coord: 2.8, 2.8, value: %f", value); - - psFree(interp); - - skip_end(); - - psFree(image); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - return exit_status(); + // generate simple image (x ramp) + psImage *image = psImageAlloc(32, 32, PS_TYPE_F32); + ok(image != NULL, "psImage successfully allocated"); + skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed"); + + for (int j = 0; j < image->numRows; j++) + { + for (int i = 0; i < image->numCols; i++) { + image->data.F32[j][i] = 0.25*PS_SQR(i + 0.5) + j + 0.5; + } + } + + // center of pixels is 0.5, 0.5 + float value; + + value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 4.0625, "pixel center value - %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 3.41, "coord: 2.2, 2.5, value: %f", value); + + value = psImagePixelInterpolate (image, 2.5, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 4.3625002, "coord: 2.5, 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 4.010000229, "coord: 2.2, 2.8, value: %f", value); + + value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE); + is_float (value, 4.75999975, "coord: 2.8, 2.8, value: %f", value); + + skip_end(); + + psFree(image); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } } Index: trunk/psLib/test/mathtypes/tap_psScalar.c =================================================================== --- trunk/psLib/test/mathtypes/tap_psScalar.c (revision 12777) +++ trunk/psLib/test/mathtypes/tap_psScalar.c (revision 12781) @@ -5,13 +5,11 @@ * @author Eric Van Alst, MHPCC * - * @version $Revision: 1.4 $ + * @version $Revision: 1.5 $ * $Name: not supported by cvs2svn $ - * @date $Date: 2007-03-20 03:57:25 $ + * @date $Date: 2007-04-10 21:09:30 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii */ - #include - #include "tap.h" #include "pstap.h" @@ -49,74 +47,64 @@ int main(void) { - plan_tests(43); + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(47); - void testScalarAlloc(); - testScalarAlloc(); - void testBadScalarAlloc(); - testBadScalarAlloc(); - void testScalarCopy(); - testScalarCopy(); - void testBadScalarCopy(); - testBadScalarCopy(); -} + // Verify return is null for invalid scalar type + { + psMemId id = psMemGetId(); + psScalar* scalar = psScalarAlloc(true,PS_TYPE_BOOL); + ok(scalar == NULL, "psScalarAlloc returns null for invalid type"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } -void testScalarAlloc(void) -{ -// diag("psTestScalarAlloc"); //Verify the proper allocation/deallocation of scalar objects of valid types - tstScalarAllocByType(S8,10); - tstScalarAllocByType(U8,12); - tstScalarAllocByType(S16,14); - tstScalarAllocByType(U16,16); - tstScalarAllocByType(S32,18); - tstScalarAllocByType(U32,20); - tstScalarAllocByType(S64,22); - tstScalarAllocByType(U64,24); - tstScalarAllocByType(F32,26); - tstScalarAllocByType(F64,28); -} + { + psMemId id = psMemGetId(); + tstScalarAllocByType(S8,10); + tstScalarAllocByType(U8,12); + tstScalarAllocByType(S16,14); + tstScalarAllocByType(U16,16); + tstScalarAllocByType(S32,18); + tstScalarAllocByType(U32,20); + tstScalarAllocByType(S64,22); + tstScalarAllocByType(U64,24); + tstScalarAllocByType(F32,26); + tstScalarAllocByType(F64,28); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } -void testBadScalarAlloc(void) -{ -// diag("psTestBadScalarAlloc"); - - // Verify return is null for invalid scalar type - psScalar* scalar = psScalarAlloc(true,PS_TYPE_BOOL); - ok(scalar == NULL, "psScalarAlloc returns null for invalid type"); -} + // Verify the return is null for invalid scalar type in the original + { + psMemId id = psMemGetId(); + psScalar* scalarOrig = psScalarAlloc(0,PS_TYPE_S8); + scalarOrig->type.type = PS_TYPE_BOOL; + psScalar* scalarCopy = psScalarCopy(scalarOrig); + ok(scalarCopy == NULL, "psScalarCopy returns NULL for invalid type"); + scalarCopy = psScalarCopy(NULL); + ok(scalarCopy == NULL, "psScalarCopy returns NULL for NULL argument"); + psFree(scalarOrig); + psFree(scalarCopy); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } -void testScalarCopy(void) -{ -// diag("psTestScalarCopy"); - // Verify the proper copying of scalar objects for all valid types - tstScalarCopyByType(S8,100); - tstScalarCopyByType(U8,110); - tstScalarCopyByType(S16,120); - tstScalarCopyByType(U16,130); - tstScalarCopyByType(S32,140); - tstScalarCopyByType(U32,150); - tstScalarCopyByType(S64,160); - tstScalarCopyByType(U64,170); - tstScalarCopyByType(F32,180); - tstScalarCopyByType(F64,190); + { + psMemId id = psMemGetId(); + tstScalarCopyByType(S8,100); + tstScalarCopyByType(U8,110); + tstScalarCopyByType(S16,120); + tstScalarCopyByType(U16,130); + tstScalarCopyByType(S32,140); + tstScalarCopyByType(U32,150); + tstScalarCopyByType(S64,160); + tstScalarCopyByType(U64,170); + tstScalarCopyByType(F32,180); + tstScalarCopyByType(F64,190); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } } - - -void testBadScalarCopy(void) -{ -// diag("psTestBadScalarCopy"); - - // Verify the return is null for invalid scalar type in the original - psScalar* scalarOrig = psScalarAlloc(0,PS_TYPE_S8); - scalarOrig->type.type = PS_TYPE_BOOL; - psScalar* scalarCopy = psScalarCopy(scalarOrig); - ok(scalarCopy == NULL, "psScalarCopy returns NULL for invalid type"); - - scalarCopy = psScalarCopy(NULL); - ok(scalarCopy == NULL, "psScalarCopy returns NULL for NULL argument"); -} Index: trunk/psLib/test/mathtypes/tap_psVector.c =================================================================== --- trunk/psLib/test/mathtypes/tap_psVector.c (revision 12777) +++ trunk/psLib/test/mathtypes/tap_psVector.c (revision 12781) @@ -8,12 +8,10 @@ int main (void) { - plan_tests(209); - -// diag("psVectorAlloc() tests"); + plan_tests(285); + { psMemId id = psMemGetId(); psVector *psVec = psVectorAlloc(5, PS_TYPE_S32); - ok(psVec != NULL, "psVector successfully allocated"); skip_start(psVec == NULL, 4, "Skipping 4 tests because psVectorAlloc() failed"); @@ -23,12 +21,12 @@ ok(psVec->type.dimen == PS_DIMEN_VECTOR, "Vector dimen = %d", psVec->type.dimen); skip_end(); - psFree(psVec); ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); } - { + + { + psMemId id = psMemGetId(); psVector* vecZero = psVectorAlloc(0, PS_TYPE_S32); - ok(vecZero != NULL, "zero-length vector allocated"); skip_start(vecZero == NULL, 2, "Skipping 2 tests because psVectorAlloc() failed"); @@ -36,32 +34,28 @@ ok(vecZero->n == 0, "Vector population = %ld", vecZero->n); skip_end(); - psFree(vecZero); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector* vecBogus = psVectorAlloc(10, 0); - ok(vecBogus == NULL, "psVectorAlloc() doesn't not accept bogus type"); psErr *err = psErrorLast(); - skip_start(err == NULL, 2, "Skipping 2 tests because psVectorAlloc() didn't fail as expect"); ok(strstr(err->name, "vectorAlloc"), "alloc failure - got error name %s", err->name); ok(err->code == PS_ERR_BAD_PARAMETER_TYPE, "alloc failure - got error code %d", err->code); skip_end(); - psFree(vecBogus); - } - - -// diag("psVectorRealloc() tests"); - - { - // create new psVector + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // psVectorRealloc() tests + { + psMemId id = psMemGetId(); psVector *psVec = psVectorAlloc(5, PS_TYPE_S32); ok(psVec->n == 5, "Vector population = %ld", psVec->n); -// for(psS32 i = 0; i < 5; i++) { -// printf ("Elem %d = %d\n", i, psVec->data.S32[i]); -// } // generate first part of vector @@ -93,13 +87,13 @@ } skip_end(); - psFree(psVec); - } - - { - // Test D - Reallocate S32 vector smaller + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // Test D - Reallocate S32 vector smaller + { + psMemId id = psMemGetId(); psVector *psVec = psVectorAlloc(5, PS_TYPE_S32); - psVec->n = 5; - // generate test data values for(psS32 i = 0; i < 5; i++) { @@ -107,7 +101,5 @@ psVec->n++; } - psVec = psVectorRealloc(psVec, 3); - ok(psVec != NULL, "test vector reallocated to smaller size"); skip_start(psVec == NULL, 5, "Skipping 6 tests because psVectorRealloc() failed"); @@ -120,8 +112,12 @@ } skip_end(); - } - - { - // reallocate to 0 length + psFree(psVec); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // reallocate to 0 length + { + psMemId id = psMemGetId(); psVector *psVec = psVectorAlloc(5, PS_TYPE_S32); psVec = psVectorRealloc(psVec,0); @@ -136,24 +132,26 @@ // XXX not really a test... psFree(psVec); - } - - { - psVector *vecBogus = psVectorAlloc(5, PS_TYPE_S32); - vecBogus = psVectorRealloc(NULL, 6); - + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); + psVector *vecBogus = psVectorRealloc(NULL, 6); ok(vecBogus == NULL, "psVectorRealloc() doesn't not accept bogus type"); psErr *err = psErrorLast(); - skip_start(err == NULL, 2, "Skipping 2 tests because psVectorRealloc() didn't fail as expect"); ok(strstr(err->name, "psVectorRealloc"), "alloc failure - got error name %s", err->name); ok(err->code == PS_ERR_BAD_PARAMETER_NULL, "alloc failure - got error code %d", err->code); skip_end(); - psFree(vecBogus); - } - -// diag("psVectorExtend() tests"); - { - // create new psVector + psFree(err); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // psVectorExtend() tests + { + psMemId id = psMemGetId(); psVector *psVec = psVectorAlloc(5, PS_TYPE_S32); psVec = psVectorExtend(psVec, 0, 2); @@ -164,13 +162,14 @@ ok(psVec->n == 7, "Vector population = %ld", psVec->n); skip_end(); - psFree(psVec); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *psVec = psVectorAlloc(5, PS_TYPE_S32); psVec = psVectorExtend(psVec, 0, 2); psVec = psVectorExtend(psVec, 0, 2); - ok(psVec != NULL, "test vector extended"); skip_start(psVec == NULL, 2, "Skipping 2 tests because psVectorExtend() failed"); @@ -179,14 +178,15 @@ ok(psVec->n == 9,"Vector population = %ld", psVec->n); skip_end(); - psFree(psVec); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *psVec = psVectorAlloc(5, PS_TYPE_S32); psVec = psVectorExtend(psVec, 0, 2); psVec = psVectorExtend(psVec, 0, 2); psVec = psVectorExtend(psVec, 0, -2); - ok(psVec != NULL, "test vector extended"); skip_start(psVec == NULL, 2, "Skipping 2 tests because psVectorExtend() failed"); @@ -195,9 +195,11 @@ ok(psVec->n == 7, "Vector population = %ld", psVec->n); skip_end(); - psFree(psVec); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *psVec = psVectorAlloc(5, PS_TYPE_S32); psVec = psVectorExtend(psVec, 0, 2); @@ -205,5 +207,4 @@ psVec = psVectorExtend(psVec, 0, -2); psVec = psVectorExtend(psVec, 0, -20); - ok(psVec != NULL, "test vector extended"); skip_start(psVec == NULL, 2, "Skipping 2 tests because psVectorExtend() failed"); @@ -212,76 +213,104 @@ ok(psVec->n == 0, "Vector population = %ld", psVec->n); skip_end(); - psFree(psVec); - } - - -// diag("psVectorInit() tests"); - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // psVectorInit() tests + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(1, PS_TYPE_U8); ok(psVectorInit(vec, 1 ), "U8 Case"); psFree(vec); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(1, PS_TYPE_U16); ok(!psVectorInit(vec, PS_MAX_U64), "VectorInit failed. U16 Case"); psFree(vec); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(1, PS_TYPE_U32); ok(psVectorInit(vec, 10), "U32 Case"); psFree(vec); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(1, PS_TYPE_U64); ok(psVectorInit(vec, PS_MIN_U64), "U64 Case"); psFree(vec); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(1, PS_TYPE_S8); ok(!psVectorInit(vec, PS_MAX_S16), "VectorInit failed. S8 Case"); psFree(vec); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(1, PS_TYPE_S16); ok(psVectorInit(vec, -100), "S16 Case"); psFree(vec); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(1, PS_TYPE_S32); ok(psVectorInit(vec, 1), "S32 Case"); psFree(vec); - } - - { - // XXX is this test ok? + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // XXX is this test ok? + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(1, PS_TYPE_S64); ok(psVectorInit(vec, PS_MAX_S64), "S64 Case"); psFree(vec); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(1, PS_TYPE_F32); ok(psVectorInit(vec, 1.1), "F32 Case"); psFree(vec); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(1, PS_TYPE_F64); ok(psVectorInit(vec, 1.4 ), "F64 Case"); psFree(vec); - } - - -// diag("psVectorCreate() tests"); - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // psVectorCreate() tests + { + psMemId id = psMemGetId(); psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S8); for (int i = 0; i < 10; i++) { @@ -290,7 +319,10 @@ } psFree(test); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U8); for (int i = 0; i < 10; i++) { @@ -299,8 +331,10 @@ } psFree(test); - } - - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U32); for (int i = 0; i < 10; i++) { @@ -309,8 +343,10 @@ } psFree(test); - } - - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S32); for (int i = 0; i < 10; i++) { @@ -319,8 +355,10 @@ } psFree(test); - } - - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *input = psVectorAlloc(5, PS_TYPE_F32); psVector *test = psVectorCreate(input, 0.0, 5.0, 0.5, PS_TYPE_F32); @@ -330,13 +368,14 @@ "Vector data matches. i = %d, data=%f", i, test->data.F32[i]); } - psFree(input); - } + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + // Test PS_TYPE_F64 // PS_TYPE_S64 // PS_TYPE_U64 - - { + { + psMemId id = psMemGetId(); psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S64); for (int i = 0; i < 10; i++) @@ -347,7 +386,10 @@ } psFree(test); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U64); for (int i = 0; i < 10; i++) @@ -358,10 +400,12 @@ } psFree(test); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *input = psVectorAlloc(5, PS_TYPE_F64); psVector *test = psVectorCreate(input, 0.0, 5.0, 0.5, PS_TYPE_F64); - for (int i = 0; i < 10; i++) { @@ -371,9 +415,12 @@ } psFree(input); - } + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + // Test PS_TYPE_U16 // PS_TYPE_S16 { + psMemId id = psMemGetId(); psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S16); for (int i = 0; i < 10; i++) @@ -383,10 +430,12 @@ } psFree(test); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *input = psVectorAlloc(5, PS_TYPE_U16); psVector *test = psVectorCreate(input, 0.0, 20.0, 2.0, PS_TYPE_U16); - for (int i = 0; i < 10; i++) { @@ -395,12 +444,12 @@ } psFree(input); - } - - - -// diag("psVectorToString() tests"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + #define TEST_VECTOR_TO_STRING(TYPE, SIZE, START, INC, EXPECTED) \ { \ + psMemId id = psMemGetId(); \ const int asize = SIZE; /* alloc size */ \ const int osize = 100; /* output size (max) */ \ @@ -416,32 +465,25 @@ \ psFree(input); \ - } - - + psFree(result); \ + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); \ + } +//HERE + // psVectorToString() tests TEST_VECTOR_TO_STRING(PS_TYPE_U8, 5, 1, 1, "[1,2,3,4,5]"); - TEST_VECTOR_TO_STRING(PS_TYPE_U16, 5, 1, 1, "[1,2,3,4,5]"); - TEST_VECTOR_TO_STRING(PS_TYPE_U32, 5, 1, 1, "[1,2,3,4,5]"); - TEST_VECTOR_TO_STRING(PS_TYPE_U64, 5, 1, 1, "[1,2,3,4,5]"); - TEST_VECTOR_TO_STRING(PS_TYPE_S8, 5, -100, 10,"[-100,-90,-80,-70,-60]"); - TEST_VECTOR_TO_STRING(PS_TYPE_S16, 5, 0, -100, "[0,-100,-200,-300,-400]"); - TEST_VECTOR_TO_STRING(PS_TYPE_S32, 5, 0, -100, "[0,-100,-200,-300,-400]"); - TEST_VECTOR_TO_STRING(PS_TYPE_S64, 5, 0, -100, "[0,-100,-200,-300,-400]"); - TEST_VECTOR_TO_STRING(PS_TYPE_F32,5,.123,1,"[0.123,1.123,2.123,3.123,4.123]"); TEST_VECTOR_TO_STRING(PS_TYPE_F64,5,.123,1,"[0.123,1.123,2.123,3.123,4.123]"); - -// diag("p_psVectorGetElementF64() tests"); #define TEST_VECTOR_GET_ELEMENT_F64(ELEM_TYPE, SIZE, VALUE_TYPE, \ INIT_VALUE ) \ { \ + psMemId id = psMemGetId(); \ psVector *vec = psVectorAlloc(SIZE, ELEM_TYPE); \ vec->n = SIZE; \ @@ -454,32 +496,24 @@ \ psFree(vec); \ - } - + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); \ + } + // p_psVectorGetElementF64() tests TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U8, 1, psU8, 1); - TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U16, 2, psU16, 2); - TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U32, 3, psU32, 3); - TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U64, 100, psU64, 999999); - TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S8, 1, psS8, -1); - TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S16, 2, psS16, -2); - TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S32, 3, psS32, -3); - TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S64, 100, psS64, -999999); - TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_F32,1, psF32, .123); - TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_F64,2, psF64, -123.123); -// diag("p_psVectorPrint() tests"); // XXX: Why are we testing private functions? #define TEST_VECTOR_PRINT(ELEM_TYPE, SIZE, VALUE_TYPE, INIT_VALUE, FD, \ OUT_NAME, EXPECTED_RC ) \ { \ + psMemId id = psMemGetId(); \ psVector *vec = psVectorAlloc(SIZE, ELEM_TYPE); \ vec->n = SIZE; \ @@ -491,87 +525,83 @@ \ psFree(vec); \ - } - + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); \ + } + // p_psVectorPrint() tests TEST_VECTOR_PRINT(PS_TYPE_U8, 1, psU8, 1, 1, "PS_TYPE_U8", TRUE); - TEST_VECTOR_PRINT(PS_TYPE_U16, 2, psU16, 2, 1, "PS_TYPE_U16", TRUE); - TEST_VECTOR_PRINT(PS_TYPE_U32, 3, psU32, 3, 1, "PS_TYPE_U32", TRUE); - TEST_VECTOR_PRINT(PS_TYPE_U64, 4, psU64, 999999, 1, "PS_TYPE_U64", TRUE); - TEST_VECTOR_PRINT(PS_TYPE_S8, 1, psS8, -1, 1, "PS_TYPE_S8", TRUE); - TEST_VECTOR_PRINT(PS_TYPE_S16, 2, psS16, -2, 1, "PS_TYPE_S16", TRUE); - TEST_VECTOR_PRINT(PS_TYPE_S32, 3, psS32, -3, 1, "PS_TYPE_S32", TRUE); - TEST_VECTOR_PRINT(PS_TYPE_S64, 4, psS64, -999999, 1, "PS_TYPE_S64", TRUE); - TEST_VECTOR_PRINT(PS_TYPE_F32,1, psF32, .123, 1, "PS_TYPE_F32", TRUE); - TEST_VECTOR_PRINT(PS_TYPE_F64,2, psF64, -123.123, 1, "PS_TYPE_F64", TRUE); -// diag("psVectorSet() tests"); - - { + // psVectorSet() tests + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(5, PS_TYPE_S32); - ok(psVectorSet(vec, 0, 10), "VectorSet set S32 at position 0"); - - psFree(vec); - } - - { + psFree(vec); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(5, PS_TYPE_S32); - ok(!psVectorSet(vec, 10, 10), "VectorSet failes to set S32 at out of range position"); - - psFree(vec); - } - - { + psFree(vec); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(5, PS_TYPE_S32); - ok(psVectorSet(vec, 1, 4) == true, "VectorSet set S32 at position 1"); - - psFree(vec); - } - - -// diag("psVectorGet() tests"); - - { + psFree(vec); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // psVectorGet() tests + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(10, PS_TYPE_S32); psVectorSet(vec, 0, 10); - ok((psS32)psVectorGet(vec, 0) == 10, "VectorGet returned the correct S32 from position 0"); - - psFree(vec); - } - - { + psFree(vec); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(5, PS_TYPE_S32); psVectorSet(vec, -1, 4); - ok((psS32)psVectorGet(vec, -1) == 4, "VectorGet returned the correct S32 from tail using -1"); - - psFree(vec); - } - - -// diag("psVectorCountPixelMask() tests"); - - { + psFree(vec); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // psVectorCountPixelMask() tests + { + psMemId id = psMemGetId(); ok(psVectorCountPixelMask(NULL, 1) == -1, "psVectorCountPixelMask returned -1 for NULL Vector input"); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(5, PS_TYPE_S32); vec->data.S32[0] = 0; @@ -580,13 +610,13 @@ vec->data.S32[3] = 1; vec->data.S32[4] = 0; - vec->n = 5; - ok(psVectorCountPixelMask(vec, 1) == -1, "returned -1 for wrong type of Vector input"); - - psFree(vec); - } - - { + psFree(vec); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vec = psVectorAlloc(5, PS_TYPE_U8); vec->data.U8[0] = 0; @@ -595,72 +625,75 @@ vec->data.U8[3] = 1; vec->data.U8[4] = 0; - vec->n = 5; long numPix = psVectorCountPixelMask(vec, 1); - ok(numPix != -1, "returned -1 for correct Vector input"); ok(numPix == 2, "returned pixel count %d", numPix); - - psFree(vec); - } - - -// diag("psVectorLength() tests"); - { + psFree(vec); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // psVectorLength() tests + { + psMemId id = psMemGetId(); psVector *vector = psVectorAlloc(5, PS_TYPE_F32); ok(psVectorLength(vector) == 5, "returned the correct length of vector (was %d, should be 5)", psVectorLength(vector)); psFree(vector); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vector = psVectorAlloc(5, PS_TYPE_F32); - vector->n = 5; - ok(psVectorLength(vector) == 5, "returned the correct length of vector"); - psFree(vector); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *vector = psVectorAlloc(6, PS_TYPE_F32); - vector->n = 6; - ok(psVectorLength(vector) == 6, "returned the correct length of vector"); - psFree(vector); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); ok(psVectorLength(NULL) == -1, "returned -1 for a NULL input vector"); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psArray *array = psArrayAlloc(5); - ok(psVectorLength((psVector*)array) == -1, "returned -1 for an invalid input vector"); - psFree(array); - } - - -// diag("psVectorCopy() tests"); - - { - + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // psVectorCopy() tests + { + psMemId id = psMemGetId(); ok(psVectorCopy(NULL, NULL, PS_TYPE_F32) == NULL, "returned a NULL vector for NULL input"); - } - - { + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + { + psMemId id = psMemGetId(); psVector *in = psVectorAlloc(5, PS_TYPE_F32); - in->n = 5; - for (int i = 0; i < 5; i++) { in->data.F32[i] = i; } - //Try copy of different type psVector *copy = psVectorCopy(NULL, in, PS_TYPE_F64); @@ -671,13 +704,14 @@ copy->data.F64[2], in->data.F32[2]); skip_end(); - psFree(in); psFree(copy); - } + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + // XXX psVectorRecycle needs it's own tests // copy = psVectorRecycle(copy, in->n + 2, PS_TYPE_F64); - - { + { + psMemId id = psMemGetId(); // Try copy of same type and non-NULL outVector of different type and // size. @@ -700,6 +734,5 @@ psFree(in); psFree(copy); - } - - return exit_status(); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } } Index: trunk/psLib/test/mathtypes/tap_psVectorSort_01.c =================================================================== --- trunk/psLib/test/mathtypes/tap_psVectorSort_01.c (revision 12777) +++ trunk/psLib/test/mathtypes/tap_psVectorSort_01.c (revision 12781) @@ -12,22 +12,17 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-03-20 03:57:25 $ + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-04-10 21:09:31 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii * */ - #include - #include "tap.h" #include "pstap.h" - #define tstVectorSortByType(datatype,value) \ in = psVectorAlloc(7,PS_TYPE_##datatype); \ -in->n = 7; \ out = psVectorAlloc(7,PS_TYPE_##datatype); \ -out->n = 7; \ in->data.datatype[0] = 7+value; \ in->data.datatype[1] = 9+value; \ @@ -45,34 +40,16 @@ ok(out->data.datatype[0] == in->data.datatype[6], \ "sort out[0] type %s",#datatype); \ -skip_start(out->data.datatype[0] != in->data.datatype[6], \ - 6,"sort out[0] type %s",#datatype); \ ok(out->data.datatype[1] == in->data.datatype[3], \ "sort out[1] type %s",#datatype); \ -skip_start(out->data.datatype[1] != in->data.datatype[3], \ - 5,"Improper sort out[1] type %s",#datatype); \ ok(out->data.datatype[2] == in->data.datatype[2], \ "sort out[2] type %s",#datatype); \ -skip_start(out->data.datatype[2] != in->data.datatype[2], \ - 4,"Improper sort out[2] type %s",#datatype); \ ok(out->data.datatype[3] == in->data.datatype[4], \ "sort out[3] type %s",#datatype); \ -skip_start(out->data.datatype[3] != in->data.datatype[4], \ - 3,"Improper sort out[3] type %s",#datatype); \ ok(out->data.datatype[4] == in->data.datatype[5], \ "sort out[4] %s",#datatype); \ -skip_start(out->data.datatype[4] != in->data.datatype[5], \ - 2,"Improper sort out[4] %s",#datatype); \ ok(out->data.datatype[5] == in->data.datatype[0], \ "sort out[5] %s",#datatype); \ -skip_start(out->data.datatype[5] != in->data.datatype[0], \ - 1,"Improper sort out[5] %s",#datatype); \ ok(out->data.datatype[6] == in->data.datatype[1], \ "sort out[6] %s",#datatype); \ -skip_end(); \ -skip_end(); \ -skip_end(); \ -skip_end(); \ -skip_end(); \ -skip_end(); \ skip_end(); \ psFree(in); \ @@ -84,5 +61,7 @@ char* argv[]) { - plan_tests(92); + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(97); psVector *in = NULL; @@ -91,60 +70,82 @@ // Test A - Verify the sort for all supported types - - tstVectorSortByType(S8,0); - tstVectorSortByType(S16,1); - tstVectorSortByType(S32,2); - tstVectorSortByType(S64,3); - tstVectorSortByType(U8,4); - tstVectorSortByType(U16,5); - tstVectorSortByType(U32,6); - tstVectorSortByType(U64,7); - tstVectorSortByType(F32,8); - tstVectorSortByType(F64,9); + { + psMemId id = psMemGetId(); + tstVectorSortByType(S8,0); + tstVectorSortByType(S16,1); + tstVectorSortByType(S32,2); + tstVectorSortByType(S64,3); + tstVectorSortByType(U8,4); + tstVectorSortByType(U16,5); + tstVectorSortByType(U32,6); + tstVectorSortByType(U64,7); + tstVectorSortByType(F32,8); + tstVectorSortByType(F64,9); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } // Test B - Sort input vector into itself + { + psMemId id = psMemGetId(); + psVector *in = psVectorAlloc(7, PS_TYPE_F32); + in->data.F32[0] = 0.7f; + in->data.F32[1] = 0.9f; + in->data.F32[2] = 0.3f; + in->data.F32[3] = 0.1f; + in->data.F32[4] = 0.5f; + in->data.F32[5] = 0.5f; + in->data.F32[6] = -2.0f; + in = psVectorSort(in, in); + ok(in->data.F32[0] == -2.0f,"self sort in[0]"); + ok(in->data.F32[1] == 0.1f,"self sort in[1]"); + ok(in->data.F32[2] == 0.3f, "self sort in[2]"); + ok(in->data.F32[3] == 0.5f, "self sort in[3]"); + ok(in->data.F32[4] == 0.5f, "self sort in[4]"); + ok(in->data.F32[5] == 0.7f, "self sort in[5]"); + ok(in->data.F32[6] == 0.9f, "self sort in[6]"); + psFree(in); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } - in = psVectorAlloc(7, PS_TYPE_F32); - in->n = 7; - in->data.F32[0] = 0.7f; - in->data.F32[1] = 0.9f; - in->data.F32[2] = 0.3f; - in->data.F32[3] = 0.1f; - in->data.F32[4] = 0.5f; - in->data.F32[5] = 0.5f; - in->data.F32[6] = -2.0f; - in = psVectorSort(in, in); - ok(in->data.F32[0] == -2.0f,"self sort in[0]"); - ok(in->data.F32[1] == 0.1f,"self sort in[1]"); - ok(in->data.F32[2] == 0.3f, "self sort in[2]"); - ok(in->data.F32[3] == 0.5f, "self sort in[3]"); - ok(in->data.F32[4] == 0.5f, "self sort in[4]"); - ok(in->data.F32[5] == 0.7f, "self sort in[5]"); - ok(in->data.F32[6] == 0.9f, "self sort in[6]"); // Test C - Attempt to sort vector with invalid type - in->type.type = PS_TYPE_BOOL; - out = psVectorAlloc(7,PS_TYPE_F32); - tempVec = psVectorSort(out,in); - ok(tempVec == NULL, "Did return NULL on error"); + { + psMemId id = psMemGetId(); + psVector *in = psVectorAlloc(7, PS_TYPE_F32); + in->type.type = PS_TYPE_BOOL; + out = psVectorAlloc(7,PS_TYPE_F32); + tempVec = psVectorSort(out,in); + ok(tempVec == NULL, "Did return NULL on error"); + psFree(out); + psFree(in); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + // Test D - Sort vector with zero elements - out = psVectorAlloc(7,PS_TYPE_F32); - in->n = 0; - out = psVectorSort(out,in); - ok (out != NULL, "psVectorSort returned a non-NULL vector" ); - skip_start (out == NULL, 1, "psVectorSort returned a NULL vector" ); - ok (out->n == 0, "psVectorSort correctly return a 0-length vector.\n"); - skip_end(); - - psFree(out); + { + psMemId id = psMemGetId(); + out = psVectorAlloc(7,PS_TYPE_F32); + in->n = 0; + out = psVectorSort(out,in); + ok(out != NULL, "psVectorSort returned a non-NULL vector" ); + skip_start (out == NULL, 1, "psVectorSort returned a NULL vector" ); + ok(out->n == 0, "psVectorSort correctly return a 0-length vector"); + skip_end(); + psFree(out); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } // Test D - Free float vectors - psFree(in); - ok ( ! psMemCheckLeaks(0, NULL, stdout, false),"Memory leaks not detected"); - - psS32 nBad = psMemCheckCorruption(stderr, false); - ok(!nBad, "Found %d bad memory blocks\n", nBad); + { + psMemId id = psMemGetId(); + psVector *in = psVectorAlloc(7, PS_TYPE_F32); + psFree(in); + ok( ! psMemCheckLeaks(0, NULL, stdout, false),"Memory leaks not detected"); + psS32 nBad = psMemCheckCorruption(stderr, false); + ok(!nBad, "Found %d bad memory blocks", nBad); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } } Index: trunk/psLib/test/mathtypes/tap_psVectorSort_02.c =================================================================== --- trunk/psLib/test/mathtypes/tap_psVectorSort_02.c (revision 12777) +++ trunk/psLib/test/mathtypes/tap_psVectorSort_02.c (revision 12781) @@ -14,6 +14,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-03-20 03:57:25 $ + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-04-10 21:09:31 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -28,5 +28,4 @@ #define tstVectorSortIndexByType(datatype,value) \ in = psVectorAlloc( 5, PS_TYPE_##datatype ); \ -in->n = 5; \ in->data.datatype[0] = 7+value; \ in->data.datatype[1] = 9+value; \ @@ -52,5 +51,7 @@ psS32 main(psS32 argc, char* argv[]) { - plan_tests(71); + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(77); psVector *in = NULL; @@ -59,75 +60,103 @@ // Test A - Sort vectors by index for all types - tstVectorSortIndexByType(S8,0) - tstVectorSortIndexByType(U8,1) - tstVectorSortIndexByType(S16,2) - tstVectorSortIndexByType(U16,3) - tstVectorSortIndexByType(S32,4) - tstVectorSortIndexByType(U32,5) - tstVectorSortIndexByType(S64,6) - tstVectorSortIndexByType(U64,7) - tstVectorSortIndexByType(F32,8) - tstVectorSortIndexByType(F64,9) - psFree(out); + { + psMemId id = psMemGetId(); + tstVectorSortIndexByType(S8,0) + tstVectorSortIndexByType(U8,1) + tstVectorSortIndexByType(S16,2) + tstVectorSortIndexByType(U16,3) + tstVectorSortIndexByType(S32,4) + tstVectorSortIndexByType(U32,5) + tstVectorSortIndexByType(S64,6) + tstVectorSortIndexByType(U64,7) + tstVectorSortIndexByType(F32,8) + tstVectorSortIndexByType(F64,9) + psFree(out); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + // Test C Attempt to sort with null input vector - in = NULL; - out = psVectorAlloc(5,PS_TYPE_U32); - out = psVectorSortIndex(out,in); - ok(out == NULL, "Did return NULL with NULL input specified"); + { + psMemId id = psMemGetId(); + in = NULL; + out = psVectorAlloc(5,PS_TYPE_U32); + out = psVectorSortIndex(out,in); + ok(out == NULL, "Did return NULL with NULL input specified"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + // Test D Sort with output vector which needs to be resized - in = psVectorAlloc(5,PS_TYPE_U8); - in->n=5; - for(psS32 m=0; m<5; m++) { - in->data.U8[m]= 20-m; + { + psMemId id = psMemGetId(); + in = psVectorAlloc(5,PS_TYPE_U8); + in->n=5; + for(psS32 m=0; m<5; m++) { + in->data.U8[m]= 20-m; + } + out = psVectorAlloc(5,PS_TYPE_U32); + out->n = 5; + out = psVectorSortIndex(out,in); + ok(out->n == 5, "Did properly resize output vector...out->n=%d, in->n=%d", out->n, in->n); + ok(out->data.U32[0] == 4, + "Did properly sort index out[0] = %d",out->data.U32[0]); + ok(out->data.U32[1] == 3, + "Did properly sort index out[1] = %d",out->data.U32[1]); + ok(out->data.U32[2] == 2, + "Did properly sort index out[2] = %d",out->data.U32[2]); + ok(out->data.U32[3] == 1, + "Did properly sort index out[3] = %d",out->data.U32[3]); + ok(out->data.U32[4] == 0, + "Did properly sort index out[4] = %d",out->data.U32[4]); + psFree(in); + psFree(out); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - out = psVectorAlloc(5,PS_TYPE_U32); - out->n = 5; - out = psVectorSortIndex(out,in); - ok(out->n == 5, "Did properly resize output vector...out->n=%d, in->n=%d", out->n, in->n); - ok(out->data.U32[0] == 4, - "Did properly sort index out[0] = %d",out->data.U32[0]); - ok(out->data.U32[1] == 3, - "Did properly sort index out[1] = %d",out->data.U32[1]); - ok(out->data.U32[2] == 2, - "Did properly sort index out[2] = %d",out->data.U32[2]); - ok(out->data.U32[3] == 1, - "Did properly sort index out[3] = %d",out->data.U32[3]); - ok(out->data.U32[4] == 0, - "Did properly sort index out[4] = %d",out->data.U32[4]); - psFree(in); - psFree(out); // Test E - Sort input vector with zero elements - in = psVectorAlloc(5,PS_TYPE_U8); - out = psVectorAlloc(5,PS_TYPE_U32); - in->n = 0; - out->n = 0; - tempVect = out; - out = psVectorSortIndex(out,in); - ok ( out == tempVect, "Did not return the same output vector"); - in->n=5; - out->n=5; - psFree(out); - psFree(in); + { + psMemId id = psMemGetId(); + in = psVectorAlloc(5,PS_TYPE_U8); + out = psVectorAlloc(5,PS_TYPE_U32); + in->n = 0; + out->n = 0; + tempVect = out; + out = psVectorSortIndex(out,in); + ok ( out == tempVect, "Did not return the same output vector"); + in->n=5; + out->n=5; + psFree(out); + psFree(in); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + // Test F - Attempt to sort input vector with invalid type - in = psVectorAlloc(5,PS_TYPE_U8); - out = psVectorAlloc(5,PS_TYPE_U32); - in->n = 5; - out->n = 5; - tempVect = out; - in->type.type = PS_TYPE_BOOL; - out = psVectorSortIndex(out,in); - ok( out == NULL, "Did return NULL"); - in->type.type = PS_TYPE_U8; - psFree(in); + { + psMemId id = psMemGetId(); + in = psVectorAlloc(5,PS_TYPE_U8); + out = psVectorAlloc(5,PS_TYPE_U32); + in->n = 5; + out->n = 5; + tempVect = out; + in->type.type = PS_TYPE_BOOL; + out = psVectorSortIndex(out,in); + ok( out == NULL, "Did return NULL"); + in->type.type = PS_TYPE_U8; + psFree(in); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + // Test G - Free vectors - psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false); - ok(!nLeaks, "Found %d memory leaks\n", nLeaks); - psS32 nBad = psMemCheckCorruption(stderr, false); - ok(!nBad, "Found %d bad memory blocks\n", nBad); + { + psMemId id = psMemGetId(); + psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false); + ok(!nLeaks, "Found %d memory leaks", nLeaks); + psS32 nBad = psMemCheckCorruption(stderr, false); + ok(!nBad, "Found %d bad memory blocks", nBad); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } } Index: trunk/psLib/test/mathtypes/tap_psVectorSort_03.c =================================================================== --- trunk/psLib/test/mathtypes/tap_psVectorSort_03.c (revision 12777) +++ trunk/psLib/test/mathtypes/tap_psVectorSort_03.c (revision 12781) @@ -3,15 +3,11 @@ * @brief Test driver for psVectorSort functions * - * This test driver contains the following tests for psVectorSort test point 3: - * A) Create float vectors of different sizes - * B) Attempt to sort vectors...should get errors - * C) Create float vector and double vector - * D) Attempt to sort vectors...should get errors - * E) Free float, double vectors - * * @author Ross Harman, MHPCC * - * @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-01-24 22:14:48 $ + * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-04-10 21:09:31 $ + * + * XXX: These tests are obsolete. psVectorSOrt no longer returns error + * with incorrect input vector types or sizes * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -28,45 +24,32 @@ char* argv[]) { - plan_tests(2); + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(1); + ok(true, "cake"); - psVector *in = NULL; - psVector *out = NULL; - psVector *in2 = NULL; - psVector *out2 = NULL; - - // Test A - Create float vectors - in = psVectorAlloc(5, PS_TYPE_F32); - in->n = 5; - out = psVectorAlloc(6, PS_TYPE_F32); - out->n = 6; - in->n = 5; - for(psS32 i=0; i<5; i++) { - //printf("arr[%d] = %f\n", i, in->data.F32[i]); + // Create float vectors with incorrect sizes + if (0) { + psMemId id = psMemGetId(); + psVector *in = psVectorAlloc(5, PS_TYPE_F32); + psVector *out = psVectorAlloc(6, PS_TYPE_F32); + psVector *out2 = psVectorSort(out, in); + ok(out2 == NULL, "psVectorSort() returned() NULL with non-uniform verctor input sizes"); + psFree(in); + psFree(out); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - // Test B - Sort input float vector and put results into output float vector - out = psVectorSort(out, in); - - // Test C - Create float vector and double vector - in2 = psVectorAlloc(5, PS_TYPE_F32); - in2->n = 5; - out2 = psVectorAlloc(5, PS_TYPE_F64); - out2->n = 5; - for(psS32 j=0; j<5; j++) { - //printf("vec[%d] = %f\n", j, in2->data.F32[j]); + // Create float vector and double vector + if (0) { + psMemId id = psMemGetId(); + psVector *in2 = psVectorAlloc(5, PS_TYPE_F32); + psVector *out2 = psVectorAlloc(5, PS_TYPE_F64); + psVector *out3 = psVectorSort(out2, in2); + ok(out3 == NULL, "psVectorSort() returned() NULL with non-uniform verctor input types"); + psFree(in2); + psFree(out2); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - - // Test D - Attempt to sort vectors with output of different type should create error - out2 = psVectorSort(out2, in2); - - // Test C - Free float vectors - psFree(in); - psFree(in2); - psFree(out); - psFree(out2); - psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false); - ok(!nLeaks, "Found %d memory leaks\n", nLeaks); - psS32 nBad = psMemCheckCorruption(stderr, false); - ok(!nBad, "Found %d bad memory blocks\n", nBad); } Index: trunk/psLib/test/mathtypes/tap_psVectorSort_04.c =================================================================== --- trunk/psLib/test/mathtypes/tap_psVectorSort_04.c (revision 12777) +++ trunk/psLib/test/mathtypes/tap_psVectorSort_04.c (revision 12781) @@ -3,19 +3,13 @@ * @brief Test driver for psVectorSort functions * - * This test driver contains the following tests for psVectorSort test point 4: - * A) Attempt to sort with null input vector - * B) Free vectors - * * @author Ross Harman, MHPCC * - * @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-01-24 22:14:48 $ + * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-04-10 21:09:31 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii * */ - #include - #include "tap.h" #include "pstap.h" @@ -25,17 +19,16 @@ char* argv[]) { + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); plan_tests(2); - psVector *badIn = NULL; - psVector *goodOut = psVectorAlloc(5, PS_TYPE_F32); - // Test A - Attempt to sort with null input vector - goodOut = psVectorSort(goodOut, badIn); - - // Test B - Free vectors - psFree(goodOut); - psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false); - ok(!nLeaks, "Found %d memory blocks\n", nLeaks); - psS32 nBad = psMemCheckCorruption(stderr, false); - ok(!nBad, "Found %d bad memory blocks\n", nBad); + // Attempt to sort with null input vector + { + psMemId id = psMemGetId(); + psVector *goodOut = psVectorAlloc(5, PS_TYPE_F32); + goodOut = psVectorSort(goodOut, NULL); + ok(goodOut == NULL, "psVectorSort() returned NULL with NULL input vector"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } } Index: trunk/psLib/test/sys/tap_psConfigure.c =================================================================== --- trunk/psLib/test/sys/tap_psConfigure.c (revision 12777) +++ trunk/psLib/test/sys/tap_psConfigure.c (revision 12781) @@ -11,6 +11,6 @@ * @author Ross Harman, MHPCC * - * @version $Revision: 1.2 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-02-07 22:50:18 $ + * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-04-10 21:09:31 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -24,25 +24,18 @@ -static psS32 psLibVersion00(void); - - psS32 main(psS32 argc, char* argv[]) { - plan_tests(1); + plan_tests(2); - psLibVersion00(); + // Simple test of psLibVersion() + // XX: Must somehow verify the output is correct. + { + psMemId id = psMemGetId(); + char *stringVal = NULL; + stringVal = psLibVersion(); + ok(stringVal != NULL && strlen(stringVal), "Version is cool"); + psFree(stringVal); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } } - -static psS32 psLibVersion00(void) -{ - diag("psLibVersion00"); - - char *stringVal = NULL; - stringVal = psLibVersion(); - ok( stringVal != NULL && strlen(stringVal), "Version is cool"); - psFree(stringVal); - - return 0; -} - Index: trunk/psLib/test/sys/tap_psError.c =================================================================== --- trunk/psLib/test/sys/tap_psError.c (revision 12777) +++ trunk/psLib/test/sys/tap_psError.c (revision 12781) @@ -3,16 +3,8 @@ * @brief Test driver for psError function * - * This test driver contains the following test points for psError - * testError00 - psError() (Testpoint #486) - * testError01 - psErrorMsg(), psErrorStackPrint() (Testpoint #725) - * testError02 - psErrorStackPrintV() (Testpoint #726) - * testError03 - psErrorGet(), psErrorLast() (Testpoint #727) - * testError04 - psErrorClear() (Testpoint #728) - * testError05 - psErrorCodeString() (Testpoint #729) - * * @author Eric Van Alst, MHPCC * - * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-03-20 03:57:25 $ + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-04-10 21:09:31 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -28,7 +20,8 @@ // Function used in testError02 to verify the psErrorStackPrintV function -static void myErrorStackPrint(FILE *fd, - const char *fmt, - ...) +static void myErrorStackPrint( + FILE *fd, + const char *fmt, + ...) { va_list ap; @@ -41,362 +34,346 @@ -static psS32 testError00(void) -{ -// diag("testError00"); - - psS32 intval=1; - psS64 longval = 2; - float floatval = 3.01; - char charval = 'E'; - char *stringval = "E R R O R"; - - // Test point #1 Multiple type values placed in the error string - psError(PS_ERR_UNKNOWN, true, - "ALL TYPES intval = %d longval = %lld floatval = %f charval = %c strval = %s", - intval,longval,floatval,charval,stringval); - - // Test point #2 String values in error message - psError(PS_ERR_UNKNOWN, true, "NO VALUES"); - - // Test point #3 Empty strings in error message - psError(PS_ERR_UNKNOWN, true, " "); - - return 0; -} - - -static psS32 testError01(void) -{ -// diag("testError01"); - - psErrorCode code=PS_ERR_BAD_PARAMETER_VALUE; - - // Verify the return value of psErrorMsg is the psErrorCode passed - ok ( psError(code, true, "Error code = %d", code) == code, - "Failed return value verify."); - skip_start ( psError(code, true, "Error code = %d", code) != code, - 4, "Failed return value verify."); - - psErrorStackPrint(stderr,"ERROR STACK PRINT Test1A"); - - // test1B empty string in for name argument - ok ( psError(code+1, true, "Error code = %d", code+1) == code+1, - "Failed return with empty string."); - skip_start ( psError(code+1, true, "Error code = %d", code+1) != code+1, - 3, "Failed return with empty string."); - - psErrorStackPrint(stderr,"ERROR STACK PRINT Test1B"); - - // test1D undefined code - ok ( psError(-1, true, "Error code = %d", -1) == -1, - "Failed return with undefined code."); - skip_start ( psError(-1, true, "Error code = %d", -1) != -1, - 2, "Failed return with undefined code."); - - psErrorStackPrint(stderr,"ERROR STACK PRINT Test1D"); - - // test1E set psErrorMsg argument to false - ok( psError(code, false, "Error code = %d", code) == code, - "Failed return with false new arg."); - skip_start( psError(code, false, "Error code = %d", code) != code, - 1, "Failed return with false new arg."); - - psErrorStackPrint(stderr,"ERROR STACK PRINT Test1E"); - - // test1F psErrorMsg with a error code less then PS_ERR_BASE(256) - ok( psError(9, true, "Errno code = %d", 9) == 9, "Error Code" ); - - psErrorStackPrint(stderr,"ERROR STACK PRINT Test1F"); - - skip_end(); - skip_end(); - skip_end(); - skip_end(); - - return 0; -} - - -static psS32 testError02(void) -{ -// diag("testError02"); - - psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE; - - // Generate error message and verify return value - ok (psError(code, true, "Error code = %d", code) == code, - "Failed return value verify."); - - myErrorStackPrint(stderr,"ERROR STACK PRINT Test%dA",2); - - return 0; -} - - -static psS32 testError03(void) -{ -// diag("testError03"); - - psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE; - psErr *last = NULL; - psErr *getErr = NULL; - - // Attempt to get last error message with an empty stack verify psErr with code PS_ERR_NONE - last = psErrorLast(); - ok(last->code == PS_ERR_NONE, - "psErrorLast did return PS_ERR_NONE for empty stack (%d)", last->code); - skip_start(last->code == PS_ERR_NONE, - 9, "psErrorLast did return PS_ERR_NONE for empty stack"); - - psFree(last); - - // HEY - // Attempt to get specific error message with empty stack verify psErr with code PS_ERR_NONE - getErr= psErrorGet(2); - ok(getErr->code == PS_ERR_NONE, - "psErrorGet did not return PS_ERR_NONE for empty stack (%d)", getErr->code); - skip_start(getErr->code == PS_ERR_NONE, - 8, "psErrorGet did not return PS_ERR_NONE for empty stack"); - - psFree(getErr); - - // Attempt to get error message with invalid index and an empty stack - getErr= psErrorGet(-1); - ok(getErr->code == PS_ERR_NONE, - "psErrorGet with invalid index/empty stack"); - skip_start(getErr->code != PS_ERR_NONE, - 7, "psErrorGet with invalid index/empty stack"); - - psFree(getErr); - - // Generate three error messages - ok (psError(code, true, "Error code = %d", code) == code, - "return value verify-1."); - skip_start (psError(code, true, "Error code = %d", code != code), - 6, "return value verify-2."); - - ok (psError((code+1), false, "Error code = %d", (code+1)) == (code+1), - "Failed return value verify-3."); - skip_start (psError((code+1), false, "Error code = %d", (code+1))!=(code+1), - 5, "Failed return value verify-4."); - - ok (psError((code+2), false, "Error code = %d", (code+2)) == (code+2), - "Failed return value verify-5."); - skip_start (psError((code+2), false, "Error code = %d", (code+2))!=(code+2), - 4, "Failed return value verify-6."); - - last = psErrorLast(); - getErr= psErrorGet(0); - - // Check that last and get with 0 index are equal - ok(last == getErr, "psErrorGet(0) equal to psErrorLast"); - skip_start(last != getErr, 3, "psErrorGet(0) equal to psErrorLast"); - - psFree(last); - - // Verify the last error message was returned - ok ( getErr->code == (code+2), - "psErrorLast() did not retrieve last error"); - skip_start ( getErr->code != (code+2), - 2, "psErrorLast() did not retrieve last error"); - - psFree(getErr); - - // Verify the middle error message can be retrieved - getErr= psErrorGet(1); - ok ( getErr->code == (code+1), - "psErrorGet() did not retrieve proper error"); - skip_start ( getErr->code != (code+1), - 1, "psErrorGet() did not retrieve proper error"); - - psFree(getErr); - - // Verify the psErrorGet returns NULL if an invalid index is given - getErr= psErrorGet(-1); - ok ( getErr->code == PS_ERR_NONE, - "psErrorGet() did not return PS_ERR_NONE w/ invalid arg"); - - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - - psFree(getErr); - - return 0; -} - - -static psS32 testError04(void) -{ - //diag("testError04"); - - psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE; - psErr *last = NULL; - psErr *lastAfterClear = NULL; - - // With an attemp error stack call psErrorClear - psErrorClear(); - - // Get the last error message and verify PS_ERR_NONE (empty stack) - lastAfterClear = psErrorLast(); - ok(lastAfterClear->code == PS_ERR_NONE, "psErrorLast return expected."); - skip_start(lastAfterClear->code != PS_ERR_NONE, - 5, "psErrorLast return expected."); - - psFree(lastAfterClear); - - // Generate three error messages to have messages on error stack - ok (psError(code, true, "Error code = %d", code) == code, - "Failed return value verify."); - skip_start (psError(code, true, "Error code = %d", code) != code, - 4, "Failed return value verify."); - - ok (psError((code+1), false, "Error code = %d", (code+1)) == (code+1), - "Failed return value verify."); - skip_start (psError((code+1), false, "Error code = %d", (code+1))!=(code+1), - 3, "Failed return value verify."); - - ok (psError((code+2), false, "Error code = %d", (code+2)) == (code+2), - "Failed return value verify."); - skip_start (psError((code+2), false, "Error code = %d", (code+2))!=(code+2), - 2, "Failed return value verify."); - - // Get the last error message and verify it has the expected code - last = psErrorLast(); - ok(last->code == (code+2), "psErrorLast return expected."); - skip_start(last->code != (code+2), 1, "psErrorLast return expected."); - - psFree(last); - - // Clear the error stack - psErrorClear(); - - // Get the last error message after clear and verify is has PS_ERR_NONE code - lastAfterClear = psErrorLast(); - ok(lastAfterClear->code == PS_ERR_NONE, "psErrorLast return expected."); - - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - - psFree(lastAfterClear); - - return 0; -} - - -static psS32 testError05(void) -{ - //diag("testError05"); - - // Verify the return value of psErrorCodeString - // psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE; - // psLogMsg("tst_psError05", PS_LOG_INFO, psErrorCodeString(code)); - - // Verify the return value of psErrorCodeString if code is negative - ok( psErrorCodeString(-1) == NULL, "error string with neg. code"); - - return 0; -} - - -static psS32 testErrorRegister(void) -{ - //diag("testErrorRegister"); - - psS32 numErr = 4; - psErrorDescription errDesc[] = { {PS_ERR_N_ERR_CLASSES+1,"first"}, - {PS_ERR_N_ERR_CLASSES+2,"second"}, - {PS_ERR_N_ERR_CLASSES+3,"third"}, - {PS_ERR_N_ERR_CLASSES+4,"fourth"} }; - /* - 1. invoke psErrorRegister with a n>1 array of psErrorDescriptions. Verify that: - a. Each error description given is retrievable with psErrorCodeString. - */ - psErrorRegister(errDesc,numErr); - - for (psS32 i = 0; i < numErr; i++) { - const char* desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES+1+i); - ok (desc != NULL, - "psErrorCode didn't find registered error code."); - - ok (strcmp(desc,errDesc[i].description) == 0, - "psErrorCode didn't return the proper description. Got '%s', expected '%s'.", desc,errDesc[i].description); - } - - /* - 2. invoke psErrorCodeString with a static/builtin psLib error code. Verify: - a. the result is correct. - */ - const char* desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES); - ok (desc != NULL, "psErrorCode didn't find static error code."); - ok (strcmp(desc,"error classes end marker") == 0, - "psErrorCode didn't return the proper description. Got '%s', expected '%s'.", - desc,"error classes end marker"); - - desc = psErrorCodeString(PS_ERR_NONE); - ok (desc != NULL, - "psErrorCode didn't find static error code."); - ok (strcmp(desc,"not an error") == 0, - "psErrorCode didn't return the proper description. Got '%s', expected '%s'.", - desc,"not an error"); - - /* - 3. invoke psErrorCodeString with an invalid code. Verify a NULL is returned. - */ - desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES+numErr+1); - ok (desc == NULL, - "psErrorCode didn't return a NULL with a bogus input code."); - - /* - 4. invoke psErrorRegister with a NULL psErrorDescription. Verify that: - a. the execution does not cease. - b. an appropriate error is generated. - */ - psLogMsg(__func__,PS_LOG_INFO,"Following should be an error."); - psErrorClear(); - psErrorRegister(NULL,1); - psErr* err = psErrorLast(); - ok (err->code == PS_ERR_BAD_PARAMETER_NULL, - "psErrorCode didn't generate proper error code for NULL input."); - - psFree(err); - - /* - 5. invoke psErrorRegister with nerror=0. Verify that no error occurs. - */ - psErrorClear(); - psErrorRegister(errDesc,0); - err = psErrorLast(); - ok (err->code == PS_ERR_NONE, - "psErrorCode generated an error for nErrors = 0."); - - psFree(err); - return 0; -} - - psS32 main( psS32 argc, char* argv[] ) { psLogSetFormat("HLNM"); - plan_tests(38); - - // XXX: testError03() fails if we put it in sequence with the others. - testError03(); - testError00(); - testError01(); - testError02(); - testError04(); - testError05(); - testErrorRegister(); + plan_tests(60); + + + //psError() tests + { + psS32 intval=1; + psS64 longval = 2; + float floatval = 3.01; + char charval = 'E'; + char *stringval = "E R R O R"; + + // Multiple type values placed in the error string + // XX: The output is never verified + { + psMemId id = psMemGetId(); + psError(PS_ERR_UNKNOWN, true, + "ALL TYPES intval = %d longval = %lld floatval = %f charval = %c strval = %s", + intval,longval,floatval,charval,stringval); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // String values in error message + // XX: The output is never verified + { + psMemId id = psMemGetId(); + psError(PS_ERR_UNKNOWN, true, "NO VALUES"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // Empty strings in error message + // XX: The output is never verified + { + psMemId id = psMemGetId(); + psError(PS_ERR_UNKNOWN, true, " "); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // Verify the return value of psErrorMsg is the psErrorCode passed + { + psMemId id = psMemGetId(); + psErrorCode code=PS_ERR_BAD_PARAMETER_VALUE; + ok(psError(code, true, "Error code = %d", code) == code, "Failed return value verify."); + psErrorStackPrint(stderr,"ERROR STACK PRINT Test1A"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // test1B empty string in for name argument + { + psMemId id = psMemGetId(); + psErrorCode code=PS_ERR_BAD_PARAMETER_VALUE; + ok(psError(code+1, true, "Error code = %d", code+1) == code+1, + "Failed return with empty string."); + psErrorStackPrint(stderr,"ERROR STACK PRINT Test1B"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // test1D undefined code + { + psMemId id = psMemGetId(); + ok(psError(-1, true, "Error code = %d", -1) == -1, + "Failed return with undefined code."); + psErrorStackPrint(stderr,"ERROR STACK PRINT Test1D"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // test1E set psErrorMsg argument to false + { + psMemId id = psMemGetId(); + psErrorCode code=PS_ERR_BAD_PARAMETER_VALUE; + ok(psError(code, false, "Error code = %d", code) == code, + "Failed return with false new arg."); + psErrorStackPrint(stderr,"ERROR STACK PRINT Test1E"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // test1F psErrorMsg with a error code less then PS_ERR_BASE(256) + { + psMemId id = psMemGetId(); + ok(psError(9, true, "Errno code = %d", 9) == 9, "Error Code" ); + psErrorStackPrint(stderr,"ERROR STACK PRINT Test1F"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + } + + + //testError02() + { + // Generate error message and verify return value + { + psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE; + psMemId id = psMemGetId(); + ok(psError(code, true, "Error code = %d", code) == code, + "Failed return value verify."); + myErrorStackPrint(stderr,"ERROR STACK PRINT Test%dA",2); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + } + + + //psErrorGet(), psErrorLast() + { + // Attempt to get last error message with an empty stack verify + // psErr with code PS_ERR_NONE + { + psMemId id = psMemGetId(); + psErrorClear(); + psErr *last = psErrorLast(); + ok(last != NULL, "psErrorLast() returned non-NULL"); + skip_start(last == NULL, 1, "Skipping tests because psErrorLast() returned NULL"); + ok(last->code == PS_ERR_NONE, + "psErrorLast did return PS_ERR_NONE for empty stack(%d)", last->code); + skip_end(); + psFree(last); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + // Attempt to get specific error message with empty stack verify + // psErr with code PS_ERR_NONE + { + psMemId id = psMemGetId(); + psErr *getErr= psErrorGet(2); + ok(getErr != NULL, "psErrorGet(2) returned non-NULL"); + skip_start(getErr == NULL, 1, "Skipping tests because psErrorGet() returned NULL"); + ok(getErr->code == PS_ERR_NONE, + "psErrorGet(2) did return PS_ERR_NONE for empty stack(%d)", getErr->code); + skip_end(); + psFree(getErr); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // Attempt to get error message with invalid index and an empty stack + { + psMemId id = psMemGetId(); + psErr *getErr= psErrorGet(-1); + ok(getErr != NULL, "psErrorGet(-1) returned non-NULL"); + skip_start(getErr == NULL, 1, "Skipping tests because psErrorGet(-1) returned NULL"); + ok(getErr->code == PS_ERR_NONE, "psErrorGet with invalid index/empty stack"); + skip_end(); + psFree(getErr); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // Generate three error messages, ensure they are correctly returned by psError() + { + psMemId id = psMemGetId(); + psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE; + ok(psError(code, true, "Error code = %d", code) == code, + "psError() returned correct error code (example 1)"); + ok(psError((code+1), false, "Error code = %d", (code+1)) == (code+1), + "psError() returned correct error code (example 2)"); + ok(psError((code+2), false, "Error code = %d", (code+2)) == (code+2), + "psError() returned correct error code (example 3)"); + + psErr *last = psErrorLast(); + psErr *getErr= psErrorGet(0); + + // Check that last and get with 0 index are equal + ok(last == getErr, "psErrorGet(0) equal to psErrorLast()"); + psFree(last); + + // Verify the last error message was returned + ok(getErr->code == (code+2), "psErrorLast() did retrieve last error"); + psFree(getErr); + psErrorClear(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // Verify the middle error message can be retrieved + { + psMemId id = psMemGetId(); + psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE; + psError(code, true, "Error code = %d", code); + psError((code+1), false, "Error code = %d", (code+1)); + psError((code+2), false, "Error code = %d", (code+2)); + psErr *getErr= psErrorGet(1); + ok(getErr->code == (code+1), "psErrorGet() did not retrieve proper error"); + psFree(getErr); + psErrorClear(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + // Verify the psErrorGet returns non-NULL PS_ERR_NONE if an invalid index + // is given with non-empty error stack + { + psMemId id = psMemGetId(); + psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE; + psError(code, true, "Error code = %d", code); + psError((code+1), false, "Error code = %d", (code+1)); + psError((code+2), false, "Error code = %d", (code+2)); + psErr *getErr= psErrorGet(-1); + ok(getErr->code == PS_ERR_NONE, "psErrorGet() did not return PS_ERR_NONE w/ invalid arg"); + psFree(getErr); + psErrorClear(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + } + + + // psErrorClear() + { + // With an attemp error stack call psErrorClear + { + psMemId id = psMemGetId(); + psErrorClear(); + // Get the last error message and verify PS_ERR_NONE (empty stack) + psErr *lastAfterClear = psErrorLast(); + ok(lastAfterClear->code == PS_ERR_NONE, "psErrorLast return expected."); + psFree(lastAfterClear); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // Generate three error messages to have messages on error stack + { + psMemId id = psMemGetId(); + psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE; + ok(psError(code, true, "Error code = %d", code) == code, + "Failed return value verify."); + ok(psError((code+1), false, "Error code = %d", (code+1)) == (code+1), + "Failed return value verify."); + ok(psError((code+2), false, "Error code = %d", (code+2)) == (code+2), + "Failed return value verify."); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + // Get the last error message and verify it has the expected code + { + psMemId id = psMemGetId(); + psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE; + psErr *last = psErrorLast(); + ok(last->code == (code+2), "psErrorLast return expected."); + psFree(last); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + // Clear the error stack + { + psMemId id = psMemGetId(); + psErrorClear(); + // Get the last error message after clear and verify is has PS_ERR_NONE code + psErr *lastAfterClear = psErrorLast(); + ok(lastAfterClear->code == PS_ERR_NONE, "psErrorLast return expected."); + psFree(lastAfterClear); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + } + + + // psErrorCodeString() + { + // Verify the return value of psErrorCodeString + // psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE; + // psLogMsg("tst_psError05", PS_LOG_INFO, psErrorCodeString(code)); + + // Verify the return value of psErrorCodeString if code is negative + ok( psErrorCodeString(-1) == NULL, "error string with neg. code"); + } + + + //testErrorRegister() + { + psS32 numErr = 4; + psErrorDescription errDesc[] = { {PS_ERR_N_ERR_CLASSES+1,"first"}, + {PS_ERR_N_ERR_CLASSES+2,"second"}, + {PS_ERR_N_ERR_CLASSES+3,"third"}, + {PS_ERR_N_ERR_CLASSES+4,"fourth"} }; + /* + 1. invoke psErrorRegister with a n>1 array of psErrorDescriptions. Verify that: + a. Each error description given is retrievable with psErrorCodeString. + */ + psErrorRegister(errDesc,numErr); + + for (psS32 i = 0; i < numErr; i++) { + const char* desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES+1+i); + ok(desc != NULL, + "psErrorCode didn't find registered error code."); + + ok(strcmp(desc,errDesc[i].description) == 0, + "psErrorCode didn't return the proper description. Got '%s', expected '%s'.", desc,errDesc[i].description); + } + + /* + 2. invoke psErrorCodeString with a static/builtin psLib error code. Verify: + a. the result is correct. + */ + const char* desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES); + ok(desc != NULL, "psErrorCode didn't find static error code."); + ok(strcmp(desc,"error classes end marker") == 0, + "psErrorCode didn't return the proper description. Got '%s', expected '%s'.", + desc,"error classes end marker"); + + desc = psErrorCodeString(PS_ERR_NONE); + ok(desc != NULL, + "psErrorCode didn't find static error code."); + ok(strcmp(desc,"not an error") == 0, + "psErrorCode didn't return the proper description. Got '%s', expected '%s'.", + desc,"not an error"); + + /* + 3. invoke psErrorCodeString with an invalid code. Verify a NULL is returned. + */ + desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES+numErr+1); + ok(desc == NULL, + "psErrorCode didn't return a NULL with a bogus input code."); + + /* + 4. invoke psErrorRegister with a NULL psErrorDescription. Verify that: + a. the execution does not cease. + b. an appropriate error is generated. + */ + psLogMsg(__func__,PS_LOG_INFO,"Following should be an error."); + psErrorClear(); + psErrorRegister(NULL,1); + psErr* err = psErrorLast(); + ok(err->code == PS_ERR_BAD_PARAMETER_NULL, + "psErrorCode didn't generate proper error code for NULL input."); + + psFree(err); + + /* + 5. invoke psErrorRegister with nerror=0. Verify that no error occurs. + */ + psErrorClear(); + psErrorRegister(errDesc,0); + err = psErrorLast(); + ok(err->code == PS_ERR_NONE, + "psErrorCode generated an error for nErrors = 0."); + psFree(err); + } } - - +//HERE Index: trunk/psLib/test/sys/tap_psLine.c =================================================================== --- trunk/psLib/test/sys/tap_psLine.c (revision 12777) +++ trunk/psLib/test/sys/tap_psLine.c (revision 12781) @@ -5,6 +5,6 @@ * @author dRob, MHPCC * - * @version $Revision: 1.3 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-03-22 22:47:07 $ + * @version $Revision: 1.4 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-04-10 21:09:31 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -17,129 +17,73 @@ #include "string.h" -static psS32 testLineAlloc(void); -static psS32 testLineInit(void); -static psS32 testLineAdd(void); -static psS32 testLineChk(void); +psS32 main( psS32 argc, char* argv[] ) +{ + plan_tests(16); + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + + //testLineAlloc() + { + psMemId id = psMemGetId(); + psLine *lineline = NULL; + lineline = psLineAlloc(20); + ok(lineline->NLINE==20, "psLine set NLINE parameter during Allocation"); + ok(lineline->Nline == 0, "psLine set Nline parameter during Allocation"); + strncpy(lineline->line, "Hello World", 20); + ok(!strncmp(lineline->line, "Hello World", 20), + "psLine was stored a simple string!"); + psFree(lineline); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // testLineInit() + { + psMemId id = psMemGetId(); + psLine *line = NULL; + //Return false for NULL input + int okay = !psLineInit(line); + ok(okay, "psLineInit. Expected false for NULL psLine input"); + //Allocate a line and return true on Init + line = psLineAlloc(1); + okay = psLineInit(line); + ok(okay, "psLineInit. Expected true for valid psLine input"); + ok(line->NLINE == 1 && line->Nline == 0, "psLineInit returned line parameters."); + psFree(line); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } -psS32 main( psS32 argc, char* argv[] ) -{ - plan_tests(12); - - testLineAlloc(); - testLineInit(); - testLineAdd(); - testLineChk(); -} - -psS32 testLineAlloc(void) -{ -// diag("testLineAlloc"); - - psLine *lineline = NULL; - lineline = psLineAlloc(20); - - ok (lineline->NLINE==20, "psLine set NLINE parameter during Allocation"); - skip_start (lineline->NLINE != 20, - 2, "psLine set NLINE parameter during Allocation"); - - ok (lineline->Nline == 0, - "psLine set Nline parameter during Allocation\n"); - skip_start (lineline->Nline == 0, - 1, "psLine set Nline parameter during Allocation\n"); - - strncpy(lineline->line, "Hello World", 20); - ok (!strncmp(lineline->line, "Hello World", 20), - "psLine was stored a simple string!\n"); - - skip_end(); - skip_end(); - - psFree(lineline); - - return 0; -} - -psS32 testLineInit(void) -{ -// diag("testLineInit"); - - psLine *line = NULL; - //Return false for NULL input - int okay = !psLineInit(line); - ok (okay, "psLineInit. Expected false for NULL psLine input.\n"); - skip_start (!okay, 2, "psLineInit. Expected NULL psLine input.\n"); - - //Allocate a line and return true on Init - line = psLineAlloc(1); - okay = psLineInit(line); - ok( okay, "psLineInit. Expected true for valid psLine input.\n"); - skip_start( !okay, 1, "psLineInit. Expected true for valid psLine input."); - - ok (line->NLINE == 1 && line->Nline == 0, - "psLineInit returned line parameters."); - - skip_end(); - skip_end(); - - psFree(line); - - return 0; -} + // testLineAdd() + { + psMemId id = psMemGetId(); + psLine *line = NULL; + //Return false for NULL input + ok(!psLineAdd(line, "Hello World"), + "psLineAdd. Expected false for NULL psLine input."); + //Allocate and return true for valid input. + line = psLineAlloc(20); + int okay = psLineAdd(line, "Hello %s", "World"); + ok( okay, "psLineAdd. Expected true for valid psLine input"); + ok(line->NLINE == 20 && line->Nline == 11, + "psLineAdd failed to return the correct line parameters"); + ok(!strncmp(line->line, "Hello World", 20), + "psLineAdd failed to store the correct line string."); + psFree(line); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } -psS32 testLineAdd(void) -{ -// diag("testLineAdd"); - - psLine *line = NULL; - //Return false for NULL input - ok (!psLineAdd(line, "Hello World"), - "psLineAdd. Expected false for NULL psLine input."); - skip_start(psLineAdd(line, "Hello World"), - 3, "psLineAdd. Expected false for NULL psLine input."); - - //Allocate and return true for valid input. - line = psLineAlloc(20); - int okay = psLineAdd(line, "Hello %s", "World"); - ok( okay, "psLineAdd. Expected true for valid psLine input.\n"); - skip_start( !okay, 2, "psLineAdd.Expected true for valid psLine input.\n"); - - ok (line->NLINE == 20 && line->Nline == 11, - "psLineAdd failed to return the correct line parameters.\n"); - skip_start (line->NLINE != 20 || line->Nline != 11, - 1,"psLineAdd failed to return the correct line parameters.\n"); - - ok (!strncmp(line->line, "Hello World", 20), - "psLineAdd failed to store the correct line string."); - - skip_end(); - skip_end(); - skip_end(); - - psFree(line); - - return 0; + // testLineChk() + { + psMemId id = psMemGetId(); + psLine *line = NULL; + //Return false for Null input line + ok(!psMemCheckLine(line), + "psMemCheckLine return false for NULL line input"); + line = psLineAlloc(1); + ok(psMemCheckLine(line), + "psMemCheckLine return true for valid line input"); + psFree(line); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } } - -psS32 testLineChk(void) -{ -// diag("testLineChk"); - - psLine *line = NULL; - //Return false for Null input line - ok (!psMemCheckLine(line), - "psMemCheckLine return false for NULL line input.\n"); - skip_start (psMemCheckLine(line), - 1, "psMemCheckLine return false for NULL line input.\n"); - - line = psLineAlloc(1); - ok (psMemCheckLine(line), - "psMemCheckLine return true for valid line input.\n"); - - psFree(line); - - skip_end(); - - return 0; -} Index: trunk/psLib/test/sys/tap_psMemory.c =================================================================== --- trunk/psLib/test/sys/tap_psMemory.c (revision 12777) +++ trunk/psLib/test/sys/tap_psMemory.c (revision 12781) @@ -3,9 +3,8 @@ * @brief Contains the tests for psMemory.[ch] * -* * @author Robert DeSonia, MHPCC * -* @version $Revision: 1.6 $ $Name: not supported by cvs2svn $ -* @date $Date: 2007-03-20 03:57:25 $ +* @version $Revision: 1.7 $ $Name: not supported by cvs2svn $ +* @date $Date: 2007-04-10 21:09:31 $ * * XXXX: Several tests fail with an Abort and are commented out. @@ -42,43 +41,252 @@ psLogSetFormat("HLNM"); psLogSetLevel(PS_LOG_INFO); - plan_tests(10); - - void TPFreeReferencedMemory( void ); - if (1) { - TPFreeReferencedMemory(); - } - - void TPOutOfMemory( void ); + plan_tests(46); + + // TPFreeReferencedMemory() + { + psMemId id = psMemGetId(); + psS32 *mem = ( psS32* ) psAlloc( 100 * sizeof( psS32 ) ); + psS32 ref = psMemGetRefCounter( mem ); + ok(ref == 1, "buffer reference count %d.", ref ); + skip_start ( ref != 1, 3, "buffer reference count %d.", ref ); + psMemIncrRefCounter(mem); + psMemIncrRefCounter(mem); + psMemIncrRefCounter(mem); + + ref = psMemGetRefCounter( mem ); + ok(ref == 4, "buffer reference count was %d.", ref ); + skip_start ( ref != 4, 2, "buffer reference count was %d.", ref ); + + psMemDecrRefCounter( mem ); + psMemDecrRefCounter( mem ); + + ref = psMemGetRefCounter( mem ); + ok(ref == 2, "Found buffer reference count to be %d.", ref ); + skip_start ( ref != 2, 1, "Found buffer reference count to be %d.", ref ); + + psMemDecrRefCounter( mem ); + ref = psMemGetRefCounter( mem ); + ok(ref == 1, "Found buffer reference count to be %d.", ref ); + skip_end(); + skip_end(); + skip_end(); + psFree(mem); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // Upon requesting more memory than is available, psalloc shall call + // the psMemExhaustedCallback. // XXXX: Skipping TPOutOfMemory() because of test abort failure if (0) { - TPOutOfMemory(); - } - - void TPReallocOutOfMemory( void ); + psMemId id = psMemGetId(); + psS32 *mem[ 100 ]; + psMemExhaustedCallback cb; + for ( psS32 lcv = 0; lcv < 100; lcv++ ) { + mem[ lcv ] = NULL; + } + exhaustedCallbackCalled = 0; + cb = psMemExhaustedCallbackSet( TPOutOfMemoryExhaustedCallback ); + #ifdef COMMENTED_OUT + // Don't include since intentionally aborts + for ( psS32 lcv = 0; lcv < 100; lcv++ ) { + mem[ lcv ] = ( psS32* ) psAlloc( SIZE_MAX/2 - 1000 ); + } + psMemExhaustedCallbackSet( cb ); + ok(exhaustedCallbackCalled != 0, + "Called psAlloc with HUGE memory requirement and survived!"); + for ( psS32 lcv = 0; lcv < 100; lcv++ ) { + psFree( mem[ lcv ] ); + } + #endif + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + + // Bug/Task #562 regression test. Upon requesting more memory than is available, + // psRealloc shall call the psMemExhaustedCallback. // XXXX: Skipping TPReallocOutOfMemory() because of test abort failure if (0) { - TPReallocOutOfMemory(); - } - - void TPCheckBufferPositive( void ); - if (1) { - TPCheckBufferPositive(); - } - - void TPrealloc( void ); - if (1) { - TPrealloc(); - } - - void TPallocCallback( void ); - if (1) { - TPallocCallback(); - } - - void TPcheckLeaks( void ); + psMemId id = psMemGetId(); + psS32 *mem[ 100 ]; + psMemExhaustedCallback cb; + for ( psS32 lcv = 0; lcv < 100; lcv++ ) { + mem[ lcv ] = NULL; + } + exhaustedCallbackCalled = 0; + cb = psMemExhaustedCallbackSet( TPOutOfMemoryExhaustedCallback ); + for ( psS32 lcv = 0; lcv < 100; lcv++ ) { + mem[ lcv ] = ( psS32* ) psAlloc( 10 ); + } + for ( psS32 lcv = 0; lcv < 100; lcv++ ) { + mem[ lcv ] = ( psS32* ) psRealloc( mem[ lcv ], SIZE_MAX/2 - 1000 ); + } + psMemExhaustedCallbackSet( cb ); + ok(exhaustedCallbackCalled != 0, + "Called psRealloc with HUGE memory requirement and survived in %s!", __func__ ); + for ( psS32 lcv = 0; lcv < 100; lcv++ ) { + psFree( mem[ lcv ] ); + } + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // psAlloc shall allocate memory blocks writeable by caller. + { + psMemId id = psMemGetId(); + const psS32 size = 100; + psS32 *mem = ( psS32* ) psAlloc( size * sizeof( psS32 ) ); + ok(mem != NULL, "psAlloc returned non-NULL value" ); + for ( psS32 index = 0;index < size;index++ ) { + mem[ index ] = index; + } + psS32 failed = 0; + for ( psS32 index = 0;index < size;index++ ) { + if ( mem[ index ] != index ) { + failed++; + } + } + ok(failed == 0, "mem legit" ); + psFree( mem ); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // psRealloc shall increase/decrease memory buffer while preserving contents + { + psMemId id = psMemGetId(); + const psS32 initialSize = 100; + // allocate buffer with known values. + psS32 *mem1 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); + psS32 *mem2 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); + psS32 *mem3 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); + for ( psS32 lcv = 0;lcv < initialSize;lcv++ ) { + mem1[lcv] = mem2[lcv] = mem3[lcv] = lcv; + } + psMemCheckCorruption(stderr, false); + // realloc to 2x + mem1 = ( psS32* ) psRealloc( mem1, 2 * initialSize * sizeof( psS32 ) ); + mem2 = ( psS32* ) psRealloc( mem2, 2 * initialSize * sizeof( psS32 ) ); + mem3 = ( psS32* ) psRealloc( mem3, 2 * initialSize * sizeof( psS32 ) ); + // check values of initial block + int error = 0; + for ( psS32 i = 0;i < initialSize;i++ ) { + if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) { + error = 1; + break; + } + } + ok(error==0, "Realloc preserve the contents with expanding buffer"); + psMemCheckCorruption(stderr, false); + // realloc to 1/2 initial value. + mem1 = ( psS32* ) psRealloc( mem1, ( initialSize / 2 ) * sizeof( psS32 ) ); + mem2 = ( psS32* ) psRealloc( mem2, ( initialSize / 2 ) * sizeof( psS32 ) ); + mem3 = ( psS32* ) psRealloc( mem3, ( initialSize / 2 ) * sizeof( psS32 ) ); + // check values of initial block + error = 0; + for ( psS32 i = 0;i < initialSize / 2;i++ ) { + if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) { + error = 1; + break; + } + } + ok(error==0, "Realloc preserved the contents with shrinking buffer"); + psFree( mem1 ); + psFree( mem2 ); + psFree( mem3 ); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // TPallocCallback() + { + psMemId id = psMemGetId(); + psS32 currentId = psMemGetId(); + const psS32 initialSize = 100; + psS32 mark; + allocCallbackCalled = 0; + freeCallbackCalled = 0; + psMemAllocCallbackSet( memAllocCallback ); + psMemFreeCallbackSet( memFreeCallback ); + psMemAllocCallbackSetID( currentId + 1 ); + psMemFreeCallbackSetID( currentId + 1 ); + // allocate buffer with known values. + psS32 *mem1 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); + psS32 *mem2 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); + psS32 *mem3 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); + psFree(mem1); + psFree(mem2); + psFree(mem3); + ok(allocCallbackCalled == 2 && freeCallbackCalled == 2, + "alloc/free callbacks called the proper number of times" ); + allocCallbackCalled = 0; + freeCallbackCalled = 0; + mark = psMemGetId(); + mem1 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); + psMemAllocCallbackSetID( mark ); + mem1 = ( psS32* ) psRealloc( mem1, initialSize * 2 * sizeof( psS32 ) ); + psFree( mem1 ); + ok(allocCallbackCalled == 2, + "realloc callbacks were called the proper number of times" ); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // TPcheckLeaks() // XXXX: Skipping TPcheckLeaks() because of test abort failure if (0) { - TPcheckLeaks(); - } + const psS32 numBuffers = 5; + psS32* buffers[ 5 ]; + psS32 lcv; + psS32 currentId = psMemGetId(); + psMemBlock** blks; + psS32 nLeaks = 0; + psS32 lineMark = 0; + + for ( lcv = 0;lcv < numBuffers;lcv++ ) { + lineMark = __LINE__ + 1; + buffers[ lcv ] = psAlloc( sizeof( psS32 ) ); + } + for ( lcv = 1;lcv < numBuffers;lcv++ ) { + psFree( buffers[ lcv ] ); + } + nLeaks = psMemCheckLeaks( currentId, &blks, stderr, false ); + ok(nLeaks == 1, "psMemCheckLeaks found %d leaks", nLeaks ); + ok(blks[ 0 ] ->lineno == lineMark, + "psMemCheckLeaks found a leak other than the expected one (line %d vs %d)", lineMark, blks[ 0 ] ->lineno ); + psFree( buffers[ 0 ] ); + psFree( blks ); + psMemCheckLeaks(currentId,NULL,stderr, false); + for ( lcv = 0;lcv < numBuffers;lcv++ ) { + lineMark = __LINE__ + 1; + buffers[ lcv ] = psAlloc( sizeof( psS32 ) ); + } + for ( lcv = 0;lcv < numBuffers - 1;lcv++ ) { + psFree( buffers[ lcv ] ); + } + nLeaks = psMemCheckLeaks( currentId, &blks, stderr, false ); + ok(nLeaks == 1, "psMemCheckLeaks found %d leaks.", nLeaks ); + ok(blks[ 0 ] ->lineno == lineMark, "psMemCheckLeaks found leaks"); + psFree( buffers[ 4 ] ); + psFree( blks ); + for ( lcv = 0;lcv < numBuffers;lcv++ ) { + lineMark = __LINE__ + 1; + buffers[ lcv ] = psAlloc( sizeof( psS32 ) ); + } + for ( lcv = 0;lcv < numBuffers;lcv++ ) { + if ( lcv % 2 == 0 ) { + psFree( buffers[ lcv ] ); + } + } + nLeaks = psMemCheckLeaks( currentId, &blks, stderr, false ); + ok(nLeaks == 2, "psMemCheckLeaks found %d leaks.", nLeaks); + ok(blks[ 0 ] ->lineno == lineMark, + "psMemCheckLeaks found a leak other than the expected." ); + psFree(blks); + psFree(buffers[1]); + psFree(buffers[3]); + } + void TPmultipleFree( void ); @@ -87,337 +295,254 @@ TPmultipleFree(); } -} - -// Testpoint #449, psAlloc shall allocate memory blocks writeable by caller. -void TPCheckBufferPositive( void ) -{ -// diag("TPCheckBufferPositive"); - - psS32 * mem; - const psS32 size = 100; - psS32 failed = 0; - - mem = ( psS32* ) psAlloc( size * sizeof( psS32 ) ); - ok ( mem != NULL, "psAlloc returned non-NULL value" ); - - for ( psS32 index = 0;index < size;index++ ) { - mem[ index ] = index; - } - - for ( psS32 index = 0;index < size;index++ ) { - if ( mem[ index ] != index ) { - failed++; - } - } - ok( failed == 0, "mem legit" ); - - psFree( mem ); -} - -void TPFreeReferencedMemory( void ) -{ - // diag("TPFreeReferencedMemory"); - - // create memory - psS32 * mem; - psS32 ref = 0; - - mem = ( psS32* ) psAlloc( 100 * sizeof( psS32 ) ); - - ref = psMemGetRefCounter( mem ); - ok ( ref == 1, "buffer reference count %d.", ref ); - skip_start ( ref != 1, 3, "buffer reference count %d.", ref ); - - psMemIncrRefCounter( mem ); - psMemIncrRefCounter( mem ); - psMemIncrRefCounter( mem ); - - ref = psMemGetRefCounter( mem ); - ok ( ref == 4, "buffer reference count was %d.", ref ); - skip_start ( ref != 4, 2, "buffer reference count was %d.", ref ); - - psMemDecrRefCounter( mem ); - psMemDecrRefCounter( mem ); - - ref = psMemGetRefCounter( mem ); - ok ( ref == 2, "Found buffer reference count to be %d.", ref ); - skip_start ( ref != 2, 1, "Found buffer reference count to be %d.", ref ); - - psMemDecrRefCounter( mem ); - - ref = psMemGetRefCounter( mem ); - ok ( ref == 1, "Found buffer reference count to be %d.", ref ); - - skip_end(); - skip_end(); - skip_end(); - - psFree( mem ); -} - -// Bug/Task #562 regression test. Upon requesting more memory than is available, psRealloc shall call -// the psMemExhaustedCallback. -void TPReallocOutOfMemory( void ) -{ - // diag("TPReallocOutOfMemory"); - - psS32 * mem[ 100 ]; - psMemExhaustedCallback cb; - - for ( psS32 lcv = 0; lcv < 100; lcv++ ) { - mem[ lcv ] = NULL; - } - - exhaustedCallbackCalled = 0; - - cb = psMemExhaustedCallbackSet( TPOutOfMemoryExhaustedCallback ); - - for ( psS32 lcv = 0; lcv < 100; lcv++ ) { - mem[ lcv ] = ( psS32* ) psAlloc( 10 ); - } - - for ( psS32 lcv = 0; lcv < 100; lcv++ ) { - mem[ lcv ] = ( psS32* ) psRealloc( mem[ lcv ], SIZE_MAX/2 - 1000 ); - } - - psMemExhaustedCallbackSet( cb ); - - ok ( exhaustedCallbackCalled != 0, - "Called psRealloc with HUGE memory requirement and survived in %s!", __func__ ); - - for ( psS32 lcv = 0; lcv < 100; lcv++ ) { - psFree( mem[ lcv ] ); - } -} - - -// Testpoint #450, Upon requesting more memory than is available, psalloc shall call -// the psMemExhaustedCallback. -void TPOutOfMemory( void ) -{ - // diag("TPOutOfMemory"); - - psS32 * mem[ 100 ]; - psMemExhaustedCallback cb; - - for ( psS32 lcv = 0; lcv < 100; lcv++ ) { - mem[ lcv ] = NULL; - } - - exhaustedCallbackCalled = 0; - cb = psMemExhaustedCallbackSet( TPOutOfMemoryExhaustedCallback ); - - #ifdef COMMENTED_OUT - // Don't include since intentionally aborts - - for ( psS32 lcv = 0; lcv < 100; lcv++ ) { - mem[ lcv ] = ( psS32* ) psAlloc( SIZE_MAX/2 - 1000 ); - } - - psMemExhaustedCallbackSet( cb ); - - ok ( exhaustedCallbackCalled != 0, - "Called psAlloc with HUGE memory requirement and survived!"); - - for ( psS32 lcv = 0; lcv < 100; lcv++ ) { - psFree( mem[ lcv ] ); - } - #endif -} - - -// Testpoint #451, psRealloc shall increase/decrease memory buffer while preserving contents -void TPrealloc( void ) -{ - // diag("TPrealloc"); - - psS32 * mem1; - psS32* mem2; - psS32* mem3; - const psS32 initialSize = 100; - - // allocate buffer with known values. - mem1 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); - mem2 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); - mem3 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); - for ( psS32 lcv = 0;lcv < initialSize;lcv++ ) { - mem1[ lcv ] = mem2[ lcv ] = mem3[ lcv ] = lcv; - } - - psMemCheckCorruption(stderr, false); - - // realloc to 2x - mem1 = ( psS32* ) psRealloc( mem1, 2 * initialSize * sizeof( psS32 ) ); - mem2 = ( psS32* ) psRealloc( mem2, 2 * initialSize * sizeof( psS32 ) ); - mem3 = ( psS32* ) psRealloc( mem3, 2 * initialSize * sizeof( psS32 ) ); - - // check values of initial block - int error = 0; - for ( psS32 i = 0;i < initialSize;i++ ) { - if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) { - error = 1; - break; - } - } - ok(error==0, "Realloc preserve the contents with expanding buffer"); - - psMemCheckCorruption(stderr, false); - - // realloc to 1/2 initial value. - mem1 = ( psS32* ) psRealloc( mem1, ( initialSize / 2 ) * sizeof( psS32 ) ); - mem2 = ( psS32* ) psRealloc( mem2, ( initialSize / 2 ) * sizeof( psS32 ) ); - mem3 = ( psS32* ) psRealloc( mem3, ( initialSize / 2 ) * sizeof( psS32 ) ); - - // check values of initial block - error = 0; - for ( psS32 i = 0;i < initialSize / 2;i++ ) { - if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) { - error = 1; - break; - } - } - ok(error==0, "Realloc preserved the contents with shrinking buffer"); - - psFree( mem1 ); - psFree( mem2 ); - psFree( mem3 ); -} - - -void TPallocCallback( void ) -{ - // diag("TPallocCallback"); - - psS32 * mem1; - psS32* mem2; - psS32* mem3; - psS32 currentId = psMemGetId(); - const psS32 initialSize = 100; - psS32 mark; - - allocCallbackCalled = 0; - freeCallbackCalled = 0; - psMemAllocCallbackSet( memAllocCallback ); - psMemFreeCallbackSet( memFreeCallback ); - - psMemAllocCallbackSetID( currentId + 1 ); - psMemFreeCallbackSetID( currentId + 1 ); - - // allocate buffer with known values. - mem1 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); - mem2 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); - mem3 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); - - psFree( mem1 ); - psFree( mem2 ); - psFree( mem3 ); - - ok( allocCallbackCalled == 2 && freeCallbackCalled == 2, - "alloc/free callbacks called the proper number of times" ); - skip_start( allocCallbackCalled != 2 || freeCallbackCalled != 2, - 1, "alloc/free callbacks called the proper number of times" ); - - allocCallbackCalled = 0; - freeCallbackCalled = 0; - - mark = psMemGetId(); - - mem1 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) ); - - psMemAllocCallbackSetID( mark ); - - mem1 = ( psS32* ) psRealloc( mem1, initialSize * 2 * sizeof( psS32 ) ); - - psFree( mem1 ); - - ok ( allocCallbackCalled == 2, - "realloc callbacks were called the proper number of times" ); - - skip_end(); -} - - -void TPcheckLeaks( void ) -{ - const psS32 numBuffers = 5; - psS32* buffers[ 5 ]; - psS32 lcv; - psS32 currentId = psMemGetId(); - psMemBlock** blks; - psS32 nLeaks = 0; - psS32 lineMark = 0; - - for ( lcv = 0;lcv < numBuffers;lcv++ ) { - lineMark = __LINE__ + 1; - buffers[ lcv ] = psAlloc( sizeof( psS32 ) ); - } - - for ( lcv = 1;lcv < numBuffers;lcv++ ) { - psFree( buffers[ lcv ] ); - } - - nLeaks = psMemCheckLeaks( currentId, &blks, stderr, false ); - - ok ( nLeaks == 1, "psMemCheckLeaks found %d leaks", nLeaks ); - skip_start ( nLeaks != 1, 5, "psMemCheckLeaks found %d leaks", nLeaks ); - - ok ( blks[ 0 ] ->lineno == lineMark, - "psMemCheckLeaks found a leak other than the expected one (line %d vs %d)", lineMark, blks[ 0 ] ->lineno ); - skip_start ( blks[ 0 ] ->lineno != lineMark, - 4,"psMemCheckLeaks found a leak other than the expected one (line %d vs %d)", lineMark, blks[ 0 ] ->lineno ); - - psFree( buffers[ 0 ] ); - psFree( blks ); - - psMemCheckLeaks(currentId,NULL,stderr, false); - - for ( lcv = 0;lcv < numBuffers;lcv++ ) { - lineMark = __LINE__ + 1; - buffers[ lcv ] = psAlloc( sizeof( psS32 ) ); - } - - for ( lcv = 0;lcv < numBuffers - 1;lcv++ ) { - psFree( buffers[ lcv ] ); - } - - nLeaks = psMemCheckLeaks( currentId, &blks, stderr, false ); - - ok ( nLeaks == 1, "psMemCheckLeaks found %d leaks.", nLeaks ); - skip_start ( nLeaks != 1, 3, "psMemCheckLeaks found %d leaks.", nLeaks ); - - ok ( blks[ 0 ] ->lineno == lineMark, "psMemCheckLeaks found leaks"); - skip_start ( blks[ 0 ] ->lineno==lineMark,2,"psMemCheckLeaks found leaks"); - - psFree( buffers[ 4 ] ); - psFree( blks ); - - for ( lcv = 0;lcv < numBuffers;lcv++ ) { - lineMark = __LINE__ + 1; - buffers[ lcv ] = psAlloc( sizeof( psS32 ) ); - } - - for ( lcv = 0;lcv < numBuffers;lcv++ ) { - if ( lcv % 2 == 0 ) { - psFree( buffers[ lcv ] ); - } - } - - nLeaks = psMemCheckLeaks( currentId, &blks, stderr, false ); - - ok ( nLeaks == 2, "psMemCheckLeaks found %d leaks.", nLeaks); - skip_start ( nLeaks != 2, 1, "psMemCheckLeaks found %d leaks.", nLeaks); - - ok ( blks[ 0 ] ->lineno == lineMark, - "psMemCheckLeaks found a leak other than the expected." ); - - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - - psFree( blks ); - psFree( buffers[ 1 ] ); - psFree( buffers[ 3 ] ); + +//HERE + // memCheckTypes() + if (1) { + psMemId id = psMemGetId(); + psArray *negative = psArrayAlloc(2); + psMetadata *neg = psMetadataAlloc(); + + psArray *array = psArrayAlloc(100); + int okay = psMemCheckType(PS_DATA_ARRAY,array); + if (!okay) { + psFree(array); + } + ok(okay, "psMemCheckArray in memCheckType"); + + ok(!psMemCheckType(PS_DATA_ARRAY, neg), "psMemCheckType with metadata input"); + psFree(array); + + psBitSet *bits; + bits = psBitSetAlloc(100); + okay = psMemCheckType(PS_DATA_BITSET, bits); + if (!okay ) + psFree(bits); + ok(okay, "psMemCheckBitSet in memCheckType"); + ok(!psMemCheckType(PS_DATA_BITSET, negative), "psMemCheckType on psArray"); + psFree(bits); + + psCube *cube; + cube = psCubeAlloc(); + okay = psMemCheckType(PS_DATA_CUBE, cube); + if (!okay ) + psFree(cube); + ok(okay, "psMemCheckCube in memCheckType"); + psFree(cube); + + psFits *fits; + fits = psFitsOpen("test.fits","w"); + psImage* img = psImageAlloc(16,16,PS_TYPE_F32); + psFitsWriteImage(fits,NULL,img,1,NULL); + psFree(img); + okay = psMemCheckType(PS_DATA_FITS, fits); + if (!okay ) + psFree(fits); + ok(okay, "psMemCheckFits in memCheckType"); + psFitsClose(fits); + + psHash *hash; + hash = psHashAlloc(100); + okay = psMemCheckType(PS_DATA_HASH, hash); + if (!okay ) + psFree(hash); + ok(okay, "psMemCheckHash in memCheckType"); + psFree(hash); + + psHistogram *histogram; + histogram = psHistogramAlloc(1.1, 2.2, 2); + okay = psMemCheckType(PS_DATA_HISTOGRAM, histogram); + if (!okay ) + psFree(histogram); + ok(okay, "psMemCheckHistogram in memCheckType"); + psFree(histogram); + + psImage *image; + image = psImageAlloc(5, 5, PS_TYPE_F32); + okay = psMemCheckType(PS_DATA_IMAGE, image); + if (!okay ) + psFree(image); + ok(okay, "psMemCheckImage in memCheckType"); + psFree(image); + + psKernel *kernel; + kernel = psKernelAlloc(0, 1, 0, 1); + okay = psMemCheckType(PS_DATA_KERNEL, kernel); + if (!okay ) + psFree(kernel); + ok(okay, "psMemCheckKernel in memCheckType"); + psFree(kernel); + + psList *list; + list = psListAlloc(NULL); + okay = psMemCheckType(PS_DATA_LIST, list); + if (!okay ) + psFree(list); + ok(okay, "psMemCheckList in memCheckType"); + psFree(list); + + psLookupTable *lookup; + char *file = "tableF32.dat"; + char *format = "\%f \%lf \%d \%ld"; + lookup = psLookupTableAlloc(file, format, 10); + okay = psMemCheckType(PS_DATA_LOOKUPTABLE, lookup); + if (!okay ) + psFree(lookup); + ok(okay, "psMemCheckLookupTable in memCheckType"); + psFree(lookup); + + psMetadata *metadata; + metadata = psMetadataAlloc(); + okay = psMemCheckType(PS_DATA_METADATA, metadata); + if (!okay ) + psFree(metadata); + ok(okay, "psMemCheckMetadata in memCheckType"); + psFree(metadata); + + psMetadataItem *metaItem; + metaItem = psMetadataItemAlloc("name", PS_DATA_S32, "COMMENT", 1); + okay = psMemCheckType(PS_DATA_METADATAITEM, metaItem); + if (!okay ) + psFree(metaItem); + ok(okay, "psMemCheckMetadataItem in memCheckType"); + psFree(metaItem); + + psMinimization *min; + min = psMinimizationAlloc(3, 0.1); + okay = psMemCheckType(PS_DATA_MINIMIZATION, min); + if (!okay ) + psFree(min); + ok(okay, "psMemCheckMinimization in memCheckType"); + psFree(min); + + psPixels *pixels; + pixels = psPixelsAlloc(100); + okay = psMemCheckType(PS_DATA_PIXELS, pixels); + if (!okay ) + psFree(pixels); + ok(okay, "psMemCheckPixels in memCheckType"); + psFree(pixels); + + psPlane *plane; + plane = psPlaneAlloc(); + okay = psMemCheckType(PS_DATA_PLANE, plane); + if (!okay ) + psFree(plane); + ok(okay, "psMemCheckPlane in memCheckType."); + psFree(plane); + + psPlaneDistort *planeDistort; + planeDistort = psPlaneDistortAlloc(1, 1, 1, 1); + okay = psMemCheckType(PS_DATA_PLANEDISTORT, planeDistort); + if (!okay ) + psFree(planeDistort); + ok(okay, "psMemCheckPlaneDistort in memCheckType."); + psFree(planeDistort); + + psPlaneTransform *planeTransform; + planeTransform = psPlaneTransformAlloc(1, 1); + okay = psMemCheckType(PS_DATA_PLANETRANSFORM, planeTransform); + if (!okay ) + psFree(planeTransform); + ok(okay, "psMemCheckPlaneTransform in memCheckType"); + psFree(planeTransform); + + psPolynomial1D *poly1; + poly1 = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 2); + okay = psMemCheckType(PS_DATA_POLYNOMIAL1D, poly1); + if (!okay ) + psFree(poly1); + ok(okay, "psMemCheckPolynomial1D in memCheckType"); + psFree(poly1); + + psPolynomial2D *poly2; + poly2 = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 2, 1); + okay = psMemCheckType(PS_DATA_POLYNOMIAL2D, poly2); + if (!okay ) + psFree(poly2); + ok(okay, "psMemCheckPolynomial2D in memCheckType"); + psFree(poly2); + + psPolynomial3D *poly3; + poly3 = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 2, 1, 1); + okay = psMemCheckType(PS_DATA_POLYNOMIAL3D, poly3); + if (!okay ) + psFree(poly3); + ok(okay, "psMemCheckPolynomial3D in memCheckType"); + psFree(poly3); + + psPolynomial4D *poly4; + poly4 = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 2, 1, 2, 1); + okay = psMemCheckType(PS_DATA_POLYNOMIAL4D, poly4); + if (!okay ) + psFree(poly4); + ok(okay, "psMemCheckPolynomial4D in memCheckType"); + psFree(poly4); + + psProjection *proj; + proj = psProjectionAlloc(1, 1, 2.1, 2.1, PS_PROJ_TAN); + okay = psMemCheckType(PS_DATA_PROJECTION, proj); + if (!okay ) + psFree(proj); + ok(okay, "psMemCheckProjection in memCheckType."); + psFree(proj); + + psScalar *scalar; + psF64 f64 = 1.1; + scalar = psScalarAlloc(f64, PS_TYPE_F64); + okay = psMemCheckType(PS_DATA_SCALAR, scalar); + if (!okay ) + psFree(scalar); + ok(okay, "psMemCheckScalar in memCheckType"); + psFree(scalar); + + psSphere *sphere; + sphere = psSphereAlloc(); + okay = psMemCheckType(PS_DATA_SPHERE, sphere); + if (!okay ) + psFree(sphere); + ok(okay, "psMemCheckSphere in memCheckType"); + psFree(sphere); + + psSphereRot *sphereRot; + sphereRot = psSphereRotAlloc(0, 0, 20); + okay = psMemCheckType(PS_DATA_SPHEREROT, sphereRot); + if (!okay ) + psFree(sphereRot); + ok(okay, "psMemCheckSphereRot in memCheckType"); + psFree(sphereRot); + + psSpline1D *spline; + spline = psSpline1DAlloc(2, 1, 0, 2); + okay = psMemCheckType(PS_DATA_SPLINE1D, spline); + if (!okay ) + psFree(spline); + ok(okay, "psMemCheckSpline1D in memCheckType"); + psFree(spline); + + psStats *stats; + stats = psStatsAlloc(PS_STAT_MAX); + okay = psMemCheckType(PS_DATA_STATS, stats); + if (!okay ) + psFree(stats); + ok(okay, "psMemCheckStats in memCheckType"); + psFree(stats); + + psTime *time; + time = psTimeAlloc(PS_TIME_UT1); + okay = psMemCheckType(PS_DATA_TIME, time); + if (!okay ) + psFree(time); + ok(okay, "psMemCheckTime in memCheckType"); + psFree(time); + + psVector *vector; + vector = psVectorAlloc(100, PS_TYPE_F32); + okay = psMemCheckType(PS_DATA_VECTOR, vector); + ok(okay, "psMemCheckVector in memCheckType"); + psFree(vector); + psFree(negative); + psFree(neg); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } } @@ -455,12 +580,7 @@ psFree( buffer ); - ok ( corruptions == 1, + ok(corruptions == 1, "Expected one memory corruption but found %d", corruptions ); - skip_start ( corruptions != 1, - 1, "Expected one memory corruption but found %d", corruptions ); - - ok ( problemCallbackCalled == 1, "The memProblemCallback was invoked" ); - - skip_end(); + ok(problemCallbackCalled == 1, "The memProblemCallback was invoked" ); } #endif @@ -500,312 +620,3 @@ } -psS32 memCheckTypes( void ) -{ - psArray *negative; - negative = psArrayAlloc(2); - psMetadata *neg; - neg = psMetadataAlloc(); - - psArray *array; - array = psArrayAlloc(100); - int okay = psMemCheckType(PS_DATA_ARRAY,array); - if ( ! okay ) - psFree(array); - ok ( okay, "psMemCheckArray in memCheckType"); - skip_start( ! okay, 28, "psMemCheckArray in memCheckType"); - - ok ( psMemCheckType(PS_DATA_ARRAY, neg), "psMemCheckArray in memCheckType"); - psFree(array); - - psBitSet *bits; - bits = psBitSetAlloc(100); - okay = psMemCheckType(PS_DATA_BITSET, bits); - if ( ! okay ) - psFree(bits); - ok ( okay, "psMemCheckBitSet in memCheckType"); - skip_start ( !okay, 27, "psMemCheckBitSet in memCheckType"); - - ok ( psMemCheckType(PS_DATA_BITSET, negative), - "psMemCheckBitSet in memCheckType"); - psFree(bits); - - psCube *cube; - cube = psCubeAlloc(); - okay = psMemCheckType(PS_DATA_CUBE, cube); - if ( ! okay ) - psFree(cube); - ok ( okay, "psMemCheckCube in memCheckType"); - skip_start ( !okay, 26, "psMemCheckCube in memCheckType"); - psFree(cube); - - psFits *fits; - fits = psFitsOpen("test.fits","w"); - psImage* img = psImageAlloc(16,16,PS_TYPE_F32); - psFitsWriteImage(fits,NULL,img,1,NULL); - psFree(img); - okay = psMemCheckType(PS_DATA_FITS, fits); - if ( ! okay ) - psFree(fits); - ok ( okay, "psMemCheckFits in memCheckType"); - skip_start ( !okay, 25,"psMemCheckFits in memCheckType"); - psFitsClose(fits); - - psHash *hash; - hash = psHashAlloc(100); - okay = psMemCheckType(PS_DATA_HASH, hash); - if ( ! okay ) - psFree(hash); - ok ( okay, "psMemCheckHash in memCheckType"); - skip_start ( !okay, 24, "psMemCheckHash in memCheckType"); - psFree(hash); - - psHistogram *histogram; - histogram = psHistogramAlloc(1.1, 2.2, 2); - okay = psMemCheckType(PS_DATA_HISTOGRAM, histogram); - if ( ! okay ) - psFree(histogram); - ok ( okay, "psMemCheckHistogram in memCheckType"); - skip_start ( !okay, 23, "psMemCheckHistogram in memCheckType"); - psFree(histogram); - - psImage *image; - image = psImageAlloc(5, 5, PS_TYPE_F32); - okay = psMemCheckType(PS_DATA_IMAGE, image); - if ( ! okay ) - psFree(image); - ok ( okay, "psMemCheckImage in memCheckType"); - skip_start ( !okay, 22, "psMemCheckImage in memCheckType"); - psFree(image); - - psKernel *kernel; - kernel = psKernelAlloc(0, 1, 0, 1); - okay = psMemCheckType(PS_DATA_KERNEL, kernel); - if ( ! okay ) - psFree(kernel); - ok ( okay, "psMemCheckKernel in memCheckType"); - skip_start ( !okay, 21, "psMemCheckKernel in memCheckType"); - psFree(kernel); - - psList *list; - list = psListAlloc(NULL); - okay = psMemCheckType(PS_DATA_LIST, list); - if ( ! okay ) - psFree(list); - ok ( okay, "psMemCheckList in memCheckType"); - skip_start ( !okay, 20, "psMemCheckList in memCheckType"); - psFree(list); - - psLookupTable *lookup; - char *file = "tableF32.dat"; - char *format = "\%f \%lf \%d \%ld"; - lookup = psLookupTableAlloc(file, format, 10); - okay = psMemCheckType(PS_DATA_LOOKUPTABLE, lookup); - if ( ! okay ) - psFree(lookup); - ok ( okay, "psMemCheckLookupTable in memCheckType"); - skip_start ( !okay, 19, "psMemCheckLookupTable in memCheckType"); - psFree(lookup); - - psMetadata *metadata; - metadata = psMetadataAlloc(); - okay = psMemCheckType(PS_DATA_METADATA, metadata); - if ( ! okay ) - psFree(metadata); - ok ( okay, "psMemCheckMetadata in memCheckType"); - skip_start ( !okay, 18, "psMemCheckMetadata in memCheckType"); - psFree(metadata); - - psMetadataItem *metaItem; - metaItem = psMetadataItemAlloc("name", PS_DATA_S32, "COMMENT", 1); - okay = psMemCheckType(PS_DATA_METADATAITEM, metaItem); - if ( ! okay ) - psFree(metaItem); - ok ( okay, "psMemCheckMetadataItem in memCheckType"); - skip_start ( !okay, 17, "psMemCheckMetadataItem in memCheckType"); - psFree(metaItem); - - psMinimization *min; - min = psMinimizationAlloc(3, 0.1); - okay = psMemCheckType(PS_DATA_MINIMIZATION, min); - if ( ! okay ) - psFree(min); - ok ( okay, "psMemCheckMinimization in memCheckType"); - skip_start ( !okay, 16, "psMemCheckMinimization in memCheckType"); - psFree(min); - - psPixels *pixels; - pixels = psPixelsAlloc(100); - okay = psMemCheckType(PS_DATA_PIXELS, pixels); - if ( ! okay ) - psFree(pixels); - ok ( okay, "psMemCheckPixels in memCheckType"); - skip_start ( !okay, 15, "psMemCheckPixels in memCheckType"); - psFree(pixels); - - psPlane *plane; - plane = psPlaneAlloc(); - okay = psMemCheckType(PS_DATA_PLANE, plane); - if ( ! okay ) - psFree(plane); - ok ( okay, "psMemCheckPlane in memCheckType."); - skip_start ( !okay, 14, "psMemCheckPlane in memCheckType."); - psFree(plane); - - psPlaneDistort *planeDistort; - planeDistort = psPlaneDistortAlloc(1, 1, 1, 1); - okay = psMemCheckType(PS_DATA_PLANEDISTORT, planeDistort); - if ( ! okay ) - psFree(planeDistort); - ok ( okay, "psMemCheckPlaneDistort in memCheckType."); - skip_start ( !okay, 13, "psMemCheckPlaneDistort in memCheckType."); - psFree(planeDistort); - - psPlaneTransform *planeTransform; - planeTransform = psPlaneTransformAlloc(1, 1); - okay = psMemCheckType(PS_DATA_PLANETRANSFORM, planeTransform); - if ( ! okay ) - psFree(planeTransform); - ok ( okay, "psMemCheckPlaneTransform in memCheckType"); - skip_start ( !okay, 12, "psMemCheckPlaneTransform in memCheckType"); - psFree(planeTransform); - - psPolynomial1D *poly1; - poly1 = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 2); - okay = psMemCheckType(PS_DATA_POLYNOMIAL1D, poly1); - if ( ! okay ) - psFree(poly1); - ok ( okay, "psMemCheckPolynomial1D in memCheckType"); - skip_start ( !okay, 11, "psMemCheckPolynomial1D in memCheckType"); - psFree(poly1); - - psPolynomial2D *poly2; - poly2 = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 2, 1); - okay = psMemCheckType(PS_DATA_POLYNOMIAL2D, poly2); - if ( ! okay ) - psFree(poly2); - ok ( okay, "psMemCheckPolynomial2D in memCheckType"); - skip_start ( !okay, 10, "psMemCheckPolynomial2D in memCheckType"); - psFree(poly2); - - psPolynomial3D *poly3; - poly3 = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 2, 1, 1); - okay = psMemCheckType(PS_DATA_POLYNOMIAL3D, poly3); - if ( ! okay ) - psFree(poly3); - ok ( okay, "psMemCheckPolynomial3D in memCheckType"); - skip_start ( !okay, 9, "psMemCheckPolynomial3D in memCheckType"); - psFree(poly3); - - psPolynomial4D *poly4; - poly4 = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 2, 1, 2, 1); - okay = psMemCheckType(PS_DATA_POLYNOMIAL4D, poly4); - if ( ! okay ) - psFree(poly4); - ok ( okay, "psMemCheckPolynomial4D in memCheckType"); - skip_start ( !okay, 8, "psMemCheckPolynomial4D in memCheckType"); - psFree(poly4); - - psProjection *proj; - proj = psProjectionAlloc(1, 1, 2.1, 2.1, PS_PROJ_TAN); - okay = psMemCheckType(PS_DATA_PROJECTION, proj); - if ( ! okay ) - psFree(proj); - ok ( okay, "psMemCheckProjection in memCheckType."); - skip_start ( !okay, 7, "psMemCheckProjection in memCheckType."); - psFree(proj); - - psScalar *scalar; - psF64 f64 = 1.1; - scalar = psScalarAlloc(f64, PS_TYPE_F64); - okay = psMemCheckType(PS_DATA_SCALAR, scalar); - if ( ! okay ) - psFree(scalar); - ok ( okay, "psMemCheckScalar in memCheckType"); - skip_start ( !okay, 6, "psMemCheckScalar in memCheckType"); - psFree(scalar); - - psSphere *sphere; - sphere = psSphereAlloc(); - okay = psMemCheckType(PS_DATA_SPHERE, sphere); - if ( ! okay ) - psFree(sphere); - ok ( okay, "psMemCheckSphere in memCheckType"); - skip_start ( !okay, 5, "psMemCheckSphere in memCheckType"); - psFree(sphere); - - psSphereRot *sphereRot; - sphereRot = psSphereRotAlloc(0, 0, 20); - okay = psMemCheckType(PS_DATA_SPHEREROT, sphereRot); - if ( ! okay ) - psFree(sphereRot); - ok( okay, "psMemCheckSphereRot in memCheckType"); - skip_start( !okay, 4, "psMemCheckSphereRot in memCheckType"); - psFree(sphereRot); - - psSpline1D *spline; - spline = psSpline1DAlloc(2, 1, 0, 2); - okay = psMemCheckType(PS_DATA_SPLINE1D, spline); - if ( ! okay ) - psFree(spline); - ok( okay, "psMemCheckSpline1D in memCheckType"); - skip_start( !okay, 3, "psMemCheckSpline1D in memCheckType"); - psFree(spline); - - psStats *stats; - stats = psStatsAlloc(PS_STAT_MAX); - okay = psMemCheckType(PS_DATA_STATS, stats); - if ( ! okay ) - psFree(stats); - ok( okay, "psMemCheckStats in memCheckType"); - skip_start( !okay, 2, "psMemCheckStats in memCheckType"); - psFree(stats); - - psTime *time; - time = psTimeAlloc(PS_TIME_UT1); - okay = psMemCheckType(PS_DATA_TIME, time); - if ( ! okay ) - psFree(time); - ok( okay, "psMemCheckTime in memCheckType"); - skip_start( !okay, 1, "psMemCheckTime in memCheckType"); - psFree(time); - - psVector *vector; - vector = psVectorAlloc(100, PS_TYPE_F32); - okay = psMemCheckType(PS_DATA_VECTOR, vector); - ok( okay, "psMemCheckVector in memCheckType"); - psFree(vector); - - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - skip_end(); - - psFree(negative); - psFree(neg); - - return 0; -} + Index: trunk/psLib/test/sys/tap_psString.c =================================================================== --- trunk/psLib/test/sys/tap_psString.c (revision 12777) +++ trunk/psLib/test/sys/tap_psString.c (revision 12781) @@ -20,6 +20,6 @@ * @author Eric Van Alst, MHPCC * - * @version $Revision: 1.7 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-03-27 22:52:03 $ + * @version $Revision: 1.8 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-04-10 21:09:31 $ * * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii @@ -35,182 +35,124 @@ #define STR_0 "binky had a leeeetle lamb" -psS32 testStringCopy00(void); -psS32 testStringCopy01(void); -psS32 testStringCopy02(void); -psS32 testStringCopy03(void); -psS32 testStringCopy04(void); -//psS32 testStringCopy05(void); -psS32 testStringCopy06(void); - -psS32 testStrAppend00(void); -psS32 testStrAppend01(void); -psS32 testStrAppend02(void); -psS32 testStrAppend03(void); - -psS32 testStrPrepend00(void); -psS32 testStrPrepend01(void); -psS32 testStrPrepend02(void); -psS32 testStrPrepend03(void); - -psS32 testStrSplit00(void); -psS32 testNULLStrings(void); -psS32 testStrCheck(void); - psS32 main( psS32 argc, char* argv[] ) { - plan_tests(55); - - testStringCopy00(); - testStringCopy01(); - testStringCopy02(); - testStringCopy03(); - testStringCopy04(); - testStringCopy06(); - - testStrAppend00(); - testStrAppend01(); - testStrAppend02(); - testStrAppend03(); - - testStrPrepend00(); - testStrPrepend01(); - testStrPrepend02(); - testStrPrepend03(); - - testStrSplit00(); - testNULLStrings(); - testStrCheck(); -} - - -psS32 testStringCopy00(void) -{ -// diag("testStringCopy00"); - - char stringval[20] = "E R R O R"; - psS32 result = 0; - psS32 result1 = 0; - char *strResult; - - // Test point #1 Verify string copy - psStringCopy - strResult = psStringCopy(stringval); - // Perform string compare - result = strcmp(strResult, stringval); - // Modify original string - stringval[0]='G'; - result1 = strcmp(strResult, stringval); - stringval[0]='E'; - ok ( ( result == 0 ) && ( result1 != 0), - "Failed test point #1 strcmp result = %d expected 0\n",result); - - // Free memory allocated - psFree(strResult); - - return 0; -} - - -psS32 testStringCopy01(void) -{ -// diag("testStringCopy01"); - - char *emptyval = ""; - psS32 result = 0; - char *strResult; - - // Test point #2 Verify empty string copy - psStringCopy - strResult = psStringCopy(emptyval); - // Perform string compare - result = strcmp(strResult, emptyval); - ok ( result == 0, - "test point #2 strcmp result = %d expected 0\n",result); - - // Free memory allocated - psFree(strResult); - - return 0; -} - - -psS32 testStringCopy02(void) -{ -// diag("testStringCopy02"); - - psS32 result = 0; - psS32 result1 = 0; - char *strResult; - char stringval1[20] = "e r r o r"; - psS32 substringlen = 5; - char *substringval = "e r r"; - - // Test point #3 Verify string copy with length - psStringNCopy - strResult = psStringNCopy(stringval1, substringlen); - // Perform string compare and get string length - result = strncmp(strResult, substringval, substringlen); - // Change original string - stringval1[0] = 'g'; - result1 = strncmp(strResult, substringval, substringlen); - ok ( ( result == 0 ) && ( result1 == 0 ), - "Failed test point #3 strcmp result = %d expected 0\n",result); - - // Free memory allocated - psFree(strResult); - - return 0; -} - -psS32 testStringCopy03(void) -{ -// diag("testStringCopy03"); - - psS32 result = 0; - psS32 result1 = 0; - char *strResult; - char *stringvalnocopy = "F A I L"; - - // Test point #4 Verify empty string copy with length - psStringNCopy - strResult = psStringNCopy(stringvalnocopy, 0); - // Perform string compare and get sting length - result = strcmp(strResult, stringvalnocopy); - result1 = strlen(strResult); - ok ( result != 0, - "test point #4 strcmp result = %d didn't expected %d\n",result,0); - - // Free memory - psFree(strResult); - - return 0; -} - -psS32 testStringCopy04(void) -{ -// diag("testStringCopy04"); - - psS32 result = 0; - psS32 result1 = 0; - char *strResult; - char stringval[20] = "E R R O R"; - psS32 increaseSize = 5; - - // Test point #5 Copy string to larger string - psStringNCopy - strResult = psStringNCopy(stringval, (strlen(stringval) + increaseSize)); - // Perform string compare and get string length - result = strcmp(strResult, stringval); - result1 = strlen(strResult); - // The strings should still compare - ok ( result == 0 && result1 == strlen(stringval), - "test point #5 strcmp result = %d expected %d\n",result,0); - - // Free memory - psFree(strResult); - - return 0; -} + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(72); + + + //testStringCopy00() + { + psMemId id = psMemGetId(); + char stringval[20] = "E R R O R"; + psS32 result = 0; + psS32 result1 = 0; + char *strResult; + + // Test point #1 Verify string copy - psStringCopy + strResult = psStringCopy(stringval); + // Perform string compare + result = strcmp(strResult, stringval); + // Modify original string + stringval[0]='G'; + result1 = strcmp(strResult, stringval); + stringval[0]='E'; + ok(( result == 0 ) && ( result1 != 0), + "Failed test point #1 strcmp result = %d expected 0",result); + // Free memory allocated + psFree(strResult); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStringCopy01() + { + psMemId id = psMemGetId(); + char *emptyval = ""; + psS32 result = 0; + char *strResult; + + // Test point #2 Verify empty string copy - psStringCopy + strResult = psStringCopy(emptyval); + // Perform string compare + result = strcmp(strResult, emptyval); + ok(result == 0, + "test point #2 strcmp result = %d expected 0",result); + // Free memory allocated + psFree(strResult); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStringCopy02() + { + psMemId id = psMemGetId(); + psS32 result = 0; + psS32 result1 = 0; + char *strResult; + char stringval1[20] = "e r r o r"; + psS32 substringlen = 5; + char *substringval = "e r r"; + + // Test point #3 Verify string copy with length - psStringNCopy + strResult = psStringNCopy(stringval1, substringlen); + // Perform string compare and get string length + result = strncmp(strResult, substringval, substringlen); + // Change original string + stringval1[0] = 'g'; + result1 = strncmp(strResult, substringval, substringlen); + ok(( result == 0 ) && ( result1 == 0 ), + "Failed test point #3 strcmp result = %d expected 0",result); + psFree(strResult); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStringCopy03() + { + psMemId id = psMemGetId(); + psS32 result = 0; + psS32 result1 = 0; + char *strResult; + char *stringvalnocopy = "F A I L"; + + // Test point #4 Verify empty string copy with length - psStringNCopy + strResult = psStringNCopy(stringvalnocopy, 0); + // Perform string compare and get sting length + result = strcmp(strResult, stringvalnocopy); + result1 = strlen(strResult); + ok(result != 0, + "test point #4 strcmp result = %d didn't expected %d",result,0); + psFree(strResult); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStringCopy04() + { + psMemId id = psMemGetId(); + psS32 result = 0; + psS32 result1 = 0; + char *strResult; + char stringval[20] = "E R R O R"; + psS32 increaseSize = 5; + + // Test point #5 Copy string to larger string - psStringNCopy + strResult = psStringNCopy(stringval, (strlen(stringval) + increaseSize)); + // Perform string compare and get string length + result = strcmp(strResult, stringval); + result1 = strlen(strResult); + // The strings should still compare + ok(result == 0 && result1 == strlen(stringval), + "test point #5 strcmp result = %d expected %d",result,0); + psFree(strResult); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } // XXX This test needs to be modified to check for maximum size // This will require a mod to psStringNCopy source to check for maximum size // -//psS32 testStringCopy05(void) +//psS32 testStringCopy05() //{ // char *strResult; @@ -231,369 +173,293 @@ -psS32 testStringCopy06(void) -{ -// diag("testStringCopy06"); - - char *strResult; - char stringval[20] = "E R R O R"; - psS32 result = 0; - - // Test point #7 Verify creation of string literal - PS_STRING - strResult = PS_STRING(E R R O R); - result = strcmp(strResult, stringval); - ok ( result == 0, - "test point #7 strcmp result = %d expected %d",result,0); - - // Memory should not have been allocated - return 0; + // testStringCopy06() + { + psMemId id = psMemGetId(); + char *strResult; + char stringval[20] = "E R R O R"; + psS32 result = 0; + + // Test point #7 Verify creation of string literal - PS_STRING + strResult = PS_STRING(E R R O R); + result = strcmp(strResult, stringval); + ok(result == 0, + "test point #7 strcmp result = %d expected %d",result,0); + // Memory should not have been allocated + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStrAppend00() + { + psMemId id = psMemGetId(); + char *str = psStringCopy("3.14159"); + psStringAppend(&str, "%d%s", 2653589, "79323846"); + // Test point: Verify string append + int result = strcmp(str, "3.14159265358979323846"); + ok(result == 0, "Failed test point"); + psFree(str); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStrAppend01() + { + psMemId id = psMemGetId(); + char *str=NULL; + // test nonsensical invocations ... + ssize_t sz = psStringAppend(NULL, NULL); + ok(sz == 0, "Failed test point"); + sz = psStringAppend(&str, NULL); + ok(sz == 0, "Failed test point"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStrAppend02() + { + psMemId id = psMemGetId(); + char *str=NULL; + // test string creation + psStringAppend(&str, "%s", "fubar"); + int result = strcmp(str, "fubar"); + ok(result == 0, "Failed test point"); + psFree(str); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStrAppend03() + { + psMemId id = psMemGetId(); + char *str =psStringCopy(STR_0); + // test null-op + psStringAppend(&str, "%s", ""); + is_str(str, STR_0, "Failed test point"); + psFree(str); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStrPrepend00() + { + psMemId id = psMemGetId(); + char *str = psStringCopy("79323846"); + psStringPrepend(&str, "%s%d","3.14159", 2653589 ); + // Test point: Verify string append + int result = strcmp(str, "3.14159265358979323846"); + ok(result == 0, "Failed test point"); + psFree(str); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStrPrepend01() + { + psMemId id = psMemGetId(); + char *str=NULL; + // test nonsensical invocations ... + ssize_t sz = psStringPrepend(NULL, NULL); + ok(sz == 0, "Failed test point"); + sz = psStringPrepend(&str, NULL); + ok(sz == 0, "Failed test point"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStrPrepend02() + { + psMemId id = psMemGetId(); + char *str=NULL; + // test string creation + psStringPrepend(&str, "%s", "fubar"); + int result = strcmp(str, "fubar"); + ok(result == 0, "Failed test point"); + psFree(str); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStrPrepend03() + { + // test null-op + psMemId id = psMemGetId(); + char *str = psStringCopy(STR_0); + psStringPrepend(&str, "%s", ""); + int result = strcmp(str, STR_0); + ok(result == 0, "test point str=[%s]", str); + psFree(str); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStrSplit00() + { + psMemId id = psMemGetId(); + psList *strList = NULL; + char str[35]; + char split[5]; + strncpy(str, "This is, a, test case, to check", 35); + strncpy(split, ",", 2); + psString psStr; + psString psSplit; + psStr = psStringCopy(str); + psSplit = psStringCopy(split); + + //Return NULL for NULL inputs + strList = psStringSplit(NULL, NULL, true); + ok(!strList, "psStringSplit" ); + psFree(strList); + + strList = NULL; + //Return empty list for NULL string input + strList = psStringSplit(NULL, split, true); + ok(!psListLength(strList), "psListLength()" ); + psFree(strList); + + strList = NULL; + //Return NULL for NULL splitter input + strList = psStringSplit(str, NULL, true); + ok(!strList, "psStringSplit" ); + psFree(strList); + + strList = NULL; + //Return a psList* of psStrings + strList = psStringSplit(str, split, true); + ok(strList->n == 4, + "psStringSplit to return the correct number of strings"); + ok(!strncmp((psString)(strList->head->data), "This is", 10), + "psStringSplit to return expected strings"); + ok(!strncmp((psString)(strList->head->next->data), " a", 10), + "psStringSplit to return expected strings"); + ok(!strncmp((psString)(strList->head->next->next->data), " test case",10), + "psStringSplit to return expected strings"); + ok(!strncmp((psString)(strList->head->next->next->next->data), " to check", 10), + "psStringSplit failed to return expected strings"); + + psFree(strList); + //Return correct psList when using (psString, char*) + strList = psStringSplit(psStr, split, true); + ok(strList->n == 4, + "psStringSplit to return the correct number of strings"); + ok(!strncmp((psString)(strList->head->data), "This is", 10), + "psStringSplit to return expected strings"); + ok(!strncmp((psString)(strList->head->next->data), " a", 10), + "psStringSplit failed to return expected strings"); + ok(!strncmp((psString)(strList->head->next->next->data), " test case",10), + "psStringSplit failed to return expected strings"); + ok(!strncmp((psString)(strList->head->next->next->next->data), " to check", 10), + "psStringSplit to return expected strings"); + + psFree(strList); + //Return correct psList when using (char*, psString) + strList = psStringSplit(str, psSplit, true); + ok(strList->n == 4, + "psStringSplit to return the correct number of strings"); + ok(!strncmp((psString)(strList->head->data), "This is", 10), + "psStringSplit to return expected strings"); + ok(!strncmp((psString)(strList->head->next->data), " a", 10), + "psStringSplit to return expected strings"); + ok(!strncmp((psString)(strList->head->next->next->data), " test case",10), + "psStringSplit to return expected strings"); + ok(!strncmp((psString)(strList->head->next->next->next->data), " to check", 10), + "psStringSplit to return expected strings"); + + psFree(strList); + //Return correct psList when using (psString, psString) + strList = psStringSplit(psStr, psSplit, true); + ok(strList->n == 4, + "psStringSplit to return the correct number of strings"); + ok(!strncmp((psString)(strList->head->data), "This is", 10), + "psStringSplit to return expected strings"); + ok(!strncmp((psString)(strList->head->next->data), " a", 10), + "psStringSplit to return expected strings"); + ok(!strncmp((psString)(strList->head->next->next->data), " test case",10), + "psStringSplit to return expected strings"); + ok(!strncmp((psString)(strList->head->next->next->next->data), " to check", 10), + "psStringSplit to return expected strings"); + + psFree(strList); + //Return correct psList output for string of zero length case + strncpy(str, "This is,, a,, test case,, to check", 35); + strList = psStringSplit(str, split, false); + ok(strList->n == 4, + "psStringSplit to return the correct number of strings"); + ok(!strncmp((psString)(strList->head->data), "This is", 10), + "psStringSplit to return expected strings"); + ok(!strncmp((psString)(strList->head->next->data), " a", 10), + "psStringSplit to return expected strings"); + ok(!strncmp((psString)(strList->head->next->next->data), " test case",10), + "psStringSplit to return expected strings"); + ok(!strncmp((psString)(strList->head->next->next->next->data), " to check", 10), + "psStringSplit to return expected strings"); + psFree(strList); + psFree(psStr); + psFree(psSplit); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testNULLStrings() + { + psMemId id = psMemGetId(); + psString nullTest = NULL; + psString output = NULL; + ssize_t outSize = 0; + char** nullDest = NULL; + char** test = NULL; + //psStringCopy should return NULL for NULL input string + // psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message"); + output = psStringCopy(nullTest); + ok(output == NULL, "psStringCopy to return NULL for NULL input string"); + + //psStringNCopy should return NULL for NULL input string + output = psStringNCopy(nullTest, 100); + ok(output == NULL, "psStringNCopy to return NULL for NULL input string"); + + //psStringAppend should return 0 for NULL input destination + outSize = psStringAppend(nullDest, "%s", ""); + ok(outSize == 0, "psStringAppend to return 0 for NULL input destination"); + + //psStringAppend should return 0 for NULL input format + outSize = psStringAppend(test, nullTest); + ok(outSize == 0, "psStringAppend to return 0 for NULL input format"); + + //psStringPrepend should return 0 for NULL input destination + outSize = psStringPrepend(nullDest, " "); + ok(outSize == 0, "psStringPrepend to return 0 for NULL input destination"); + + //psStringPrepend should return 0 for NULL input format + outSize = psStringPrepend(test, nullTest); + ok(outSize == 0, "psStringPrepend to return 0 for NULL input format"); + + //psStringSplit should return empty list for NULL input string + psList *nullList = NULL; + nullList = psStringSplit(nullTest, ",", true); + ok(!psListLength(nullList), "psStringSplit to return NULL for NULL input string"); + psFree(nullList); + + nullList = NULL; + //psStringSplit should return NULL for NULL input splitter + nullList = psStringSplit("Hello World", nullTest, true); + ok(!nullList, "psStringSplit to return NULL for NULL input splitter"); + psFree(nullList); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testStrCheck() + { + psMemId id = psMemGetId(); + psString str = psStringAlloc(10); + strcpy(str, "Hello"); + ok(psMemCheckString(str), "psString allocated!"); + ok(psMemCheckType(PS_DATA_STRING, str), "psString allocated"); + psFree(str); + + char charStr[10]; + ok(!psMemCheckType(PS_DATA_STRING, charStr), + "Input string is a psDataType"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } } - - -psS32 testStrAppend00(void) -{ -// diag("testStrAppend00"); - - char *str=NULL; - int result = 0; - - str = psStringCopy("3.14159"); - - psStringAppend(&str, "%d%s", 2653589, "79323846"); - - // Test point: Verify string append - result = strcmp(str, "3.14159265358979323846"); - ok ( result == 0, "Failed test point\n"); - - psFree(str); - - return 0; -} - -psS32 testStrAppend01(void) -{ -// diag("testStrAppend01"); - - ssize_t sz; - char *str=NULL; - - // test nonsensical invocations ... - sz = psStringAppend(NULL, NULL); - ok ( sz == 0, "Failed test point\n"); - - sz = psStringAppend(&str, NULL); - ok ( sz == 0, "Failed test point\n"); - - return 0; -} - - -psS32 testStrAppend02(void) -{ -// diag("testStrAppend02"); - - char *str=NULL; - int result; - - // test string creation - psStringAppend(&str, "%s", "fubar"); - result = strcmp(str, "fubar"); - ok ( result == 0, "Failed test point\n"); - - psFree(str); - - return 0; -} - -psS32 testStrAppend03(void) -{ -// diag("testStrAppend03"); - - char *str =psStringCopy(STR_0); - - // test null-op - psStringAppend(&str, "%s", ""); - is_str(str, STR_0, "Failed test point"); - psFree(str); - - return 0; -} - - -psS32 testStrPrepend00(void) -{ -// diag("testStrPrepend00"); - - char *str=NULL; - int result = 0; - - str = psStringCopy("79323846"); - - psStringPrepend(&str, "%s%d","3.14159", 2653589 ); - - // Test point: Verify string append - result = strcmp(str, "3.14159265358979323846"); - ok ( result == 0, "Failed test point\n"); - - psFree(str); - - return 0; -} - - -psS32 testStrPrepend01(void) -{ -// diag("testStrPrepend01"); - - ssize_t sz; - char *str=NULL; - - // test nonsensical invocations ... - sz = psStringPrepend(NULL, NULL); - ok ( sz == 0, "Failed test point\n"); - - sz = psStringPrepend(&str, NULL); - ok ( sz == 0, "Failed test point\n"); - - return 0; -} - -psS32 testStrPrepend02(void) -{ -// diag("testStrPrepend02"); - - char *str=NULL; - int result; - - // test string creation - psStringPrepend(&str, "%s", "fubar"); - result = strcmp(str, "fubar"); - ok ( result == 0, "Failed test point\n"); - - psFree(str); - - return 0; -} - -psS32 testStrPrepend03(void) -{ -// diag("testStrPrepend03"); - - char *str=NULL; - int result; - - str = psStringCopy(STR_0); - - // test null-op - psStringPrepend(&str, "%s", ""); - result = strcmp(str, STR_0); - ok ( result == 0, "test point str=[%s]\n", str); - - psFree(str); - - return 0; -} - - -psS32 testStrSplit00(void) -{ -// diag("testStrSplit00"); - - psList *strList = NULL; - char str[35]; - char split[5]; - strncpy(str, "This is, a, test case, to check.", 35); - strncpy(split, ",", 2); - psString psStr; - psString psSplit; - psStr = psStringCopy(str); - psSplit = psStringCopy(split); - - //Return NULL for NULL inputs - strList = psStringSplit(NULL, NULL, true); - ok (!strList, "psStringSplit" ); - psFree(strList); - - strList = NULL; - //Return empty list for NULL string input - strList = psStringSplit(NULL, split, true); - ok ( !psListLength(strList), "psListLength()" ); - psFree(strList); - - strList = NULL; - //Return NULL for NULL splitter input - strList = psStringSplit(str, NULL, true); - ok ( !strList, "psStringSplit" ); - psFree(strList); - - strList = NULL; - //Return a psList* of psStrings - strList = psStringSplit(str, split, true); - ok (strList->n == 4, - "psStringSplit to return the correct number of strings.\n"); - - ok ( !strncmp((psString)(strList->head->data), "This is", 10), - "psStringSplit to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->data), " a", 10), - "psStringSplit to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->next->data), " test case",10), - "psStringSplit to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->next->next->data), " to check.", 10), - "psStringSplit failed to return expected strings."); - - psFree(strList); - //Return correct psList when using (psString, char*) - strList = psStringSplit(psStr, split, true); - ok (strList->n == 4, - "psStringSplit to return the correct number of strings.\n"); - - ok ( !strncmp((psString)(strList->head->data), "This is", 10), - "psStringSplit to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->data), " a", 10), - "psStringSplit failed to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->next->data), " test case",10), - "psStringSplit failed to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->next->next->data), " to check.", 10), - "psStringSplit to return expected strings."); - - psFree(strList); - //Return correct psList when using (char*, psString) - strList = psStringSplit(str, psSplit, true); - ok (strList->n == 4, - "psStringSplit to return the correct number of strings.\n"); - - ok ( !strncmp((psString)(strList->head->data), "This is", 10), - "psStringSplit to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->data), " a", 10), - "psStringSplit to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->next->data), " test case",10), - "psStringSplit to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->next->next->data), " to check.", 10), - "psStringSplit to return expected strings."); - - psFree(strList); - //Return correct psList when using (psString, psString) - strList = psStringSplit(psStr, psSplit, true); - ok (strList->n == 4, - "psStringSplit to return the correct number of strings.\n"); - - ok ( !strncmp((psString)(strList->head->data), "This is", 10), - "psStringSplit to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->data), " a", 10), - "psStringSplit to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->next->data), " test case",10), - "psStringSplit to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->next->next->data), " to check.", 10), - "psStringSplit to return expected strings."); - - psFree(strList); - //Return correct psList output for string of zero length case - strncpy(str, "This is,, a,, test case,, to check.", 35); - strList = psStringSplit(str, split, false); - ok (strList->n == 4, - "psStringSplit to return the correct number of strings.\n"); - - ok ( !strncmp((psString)(strList->head->data), "This is", 10), - "psStringSplit to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->data), " a", 10), - "psStringSplit to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->next->data), " test case",10), - "psStringSplit to return expected strings."); - - ok ( !strncmp((psString)(strList->head->next->next->next->data), " to check.", 10), - "psStringSplit to return expected strings."); - - psFree(strList); - psFree(psStr); - psFree(psSplit); - return 0; -} - -psS32 testNULLStrings(void) -{ -// diag("test""s"); - - psString nullTest = NULL; - psString output = NULL; - ssize_t outSize = 0; - char** nullDest = NULL; - char** test = NULL; - //psStringCopy should return NULL for NULL input string - // psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message"); - output = psStringCopy(nullTest); - ok (output == NULL, - "psStringCopy to return NULL for NULL input string.\n"); - - //psStringNCopy should return NULL for NULL input string - output = psStringNCopy(nullTest, 100); - ok (output == NULL, - "psStringNCopy to return NULL for NULL input string.\n"); - - //psStringAppend should return 0 for NULL input destination - outSize = psStringAppend(nullDest, "%s", ""); - ok (outSize == 0, - "psStringAppend to return 0 for NULL input destination.\n"); - - //psStringAppend should return 0 for NULL input format - outSize = psStringAppend(test, nullTest); - ok (outSize == 0, - "psStringAppend to return 0 for NULL input format.\n"); - - //psStringPrepend should return 0 for NULL input destination - outSize = psStringPrepend(nullDest, " "); - ok (outSize == 0, - "psStringPrepend to return 0 for NULL input destination.\n"); - - //psStringPrepend should return 0 for NULL input format - outSize = psStringPrepend(test, nullTest); - ok (outSize == 0, - "psStringPrepend to return 0 for NULL input format.\n"); - - //psStringSplit should return empty list for NULL input string - psList *nullList = NULL; - nullList = psStringSplit(nullTest, ",", true); - ok ( !psListLength(nullList), - "psStringSplit to return NULL for NULL input string.\n"); - psFree(nullList); - - nullList = NULL; - //psStringSplit should return NULL for NULL input splitter - nullList = psStringSplit("Hello World", nullTest, true); - ok ( !nullList, - "psStringSplit to return NULL for NULL input splitter.\n"); - psFree(nullList); - - return 0; -} - -psS32 testStrCheck(void) -{ -// diag("testStrCheck"); - - psString str = NULL; - str = psStringAlloc(10); - strcpy(str, "Hello"); - ok (psMemCheckString(str), "psString allocated!\n"); - - ok (psMemCheckType(PS_DATA_STRING, str), "psString allocated!\n"); - psFree(str); - - char charStr[10]; - ok (!psMemCheckType(PS_DATA_STRING, charStr), - "Input string is a psDataType"); - - return 0; -} +// HERE Index: trunk/psLib/test/sys/tap_psStringSubstitute.c =================================================================== --- trunk/psLib/test/sys/tap_psStringSubstitute.c (revision 12777) +++ trunk/psLib/test/sys/tap_psStringSubstitute.c (revision 12781) @@ -11,73 +11,87 @@ int main (void) { + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); plan_tests(16); - diag("psStringSubstitute() tests"); // Return input for NULL key { + psMemId id = psMemGetId(); psString input = psStringCopy(ORIGINAL); psStringSubstitute(&input, ",", NULL); ok(input && strcmp(input, ORIGINAL) == 0, "output = %s", input); psFree(input); - // ok(psMemCheckLeaks(0, NULL, stdout, false) == 0, "Memory Leaks"); - mem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return input for empty key { + psMemId id = psMemGetId(); psString input = psStringCopy(ORIGINAL); psStringSubstitute(&input, "XXX", ""); ok(input && strcmp(input, ORIGINAL) == 0, "output = %s", input); psFree(input); - // ok(psMemCheckLeaks(0, NULL, stdout, false) == 0, "Memory Leaks"); - mem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return corrected version for NULL replace { + psMemId id = psMemGetId(); psString input = psStringCopy(ORIGINAL); psStringSubstitute(&input, NULL, ","); ok(input && strcmp(input, CORRECTED) == 0, "output = %s", input); psFree(input); - mem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return corrected version for empty replace { + psMemId id = psMemGetId(); psString input = psStringCopy(ORIGINAL); psStringSubstitute(&input, "", ","); ok(input && strcmp(input, CORRECTED) == 0, "output = %s", input); psFree(input); - mem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return NULL for NULL input { + psMemId id = psMemGetId(); int status = psStringSubstitute(NULL, "XXX", ","); ok(status == 0, "status = %d", status); - mem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return emptry string for empty input { + psMemId id = psMemGetId(); psString input = psStringCopy(""); psStringSubstitute(&input, "XXX", ","); ok(input && strcmp(input, "") == 0, "output = %s", input); psFree(input); - mem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Change commas to bangs { + psMemId id = psMemGetId(); psString input = psStringCopy(ORIGINAL); psStringSubstitute(&input, "!", ","); ok(input && strcmp(input, "This is! a! test case! to check.") == 0, "output = %s", input); psFree(input); - mem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Long replacement text --- should allocate new space { + psMemId id = psMemGetId(); psString input = psStringCopy(ORIGINAL); psStringSubstitute(&input, "; This string is too long to fit in input(35 chars)", "."); @@ -86,8 +100,5 @@ "output = %s", input); psFree(input); - mem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - - - return exit_status(); } Index: trunk/psLib/test/sys/tap_psTrace.c =================================================================== --- trunk/psLib/test/sys/tap_psTrace.c (revision 12777) +++ trunk/psLib/test/sys/tap_psTrace.c (revision 12781) @@ -8,5 +8,4 @@ #include #include - #include "pslib.h" #include "tap.h" @@ -14,288 +13,219 @@ -static psS32 testTrace00(void); -static psS32 testTrace01(void); -static psS32 testTrace02(void); -static psS32 testTrace03(void); -static psS32 testTrace04(void); -static psS32 testTrace05(void); -static psS32 testTrace05a(void); -static psS32 testTrace06(void); -static psS32 testTrace08(void); - - psS32 main( psS32 argc, char* argv[] ) { - plan_tests(45); - - testTrace00(); - testTrace01(); - testTrace02(); - testTrace03(); - testTrace04(); - testTrace05(); - testTrace05a(); - testTrace06(); - testTrace08(); -} - - -static psS32 testTrace00(void) -{ -// diag("testTrace00"); - - psS32 i; - psS32 lev = 0; - - // psTraceSetDestination(stderr); - (void)psTraceSetDestination(2); - - for (i=0;i<10;i++) { - (void)psTraceSetLevel(".", i); - lev = psTraceGetLevel("."); - ok(lev == i, "trace level was %d, actual was %d\n", i, lev); - } - - (void)psTraceSetLevel(".", 3); - - for (i=5;i<10;i++) { - (void)psTraceSetLevel(".NODE00", i); - lev = psTraceGetLevel(".NODE00"); - ok (lev == i,"(.NODE00) expected trace level was %d, actual was %d\n", - i, lev); - - lev = psTraceGetLevel("."); - ok (lev == 3, - "expected trace level was %d, actual was %d\n", i, 3); - } - - - (void)psTraceSetLevel(".NODE00.NODE01", 4); - for (i=0;i<10;i++) { - (void)psTraceSetLevel(".NODE00.NODE01", i); - lev = psTraceGetLevel(".NODE00.NODE01"); - ok (lev == i, - "(.NODE00.NODE01) expected trace level was %d, actual was %d\n", - i, lev); - } - - return 0; -} - - -static psS32 testTrace01(void) -{ -// diag("testTrace01"); - - // psTraceSetDestination(stderr); - (void)psTraceSetDestination(2); - (void)psTraceSetLevel(".A.B.C.D.E", 5); - - psTrace(".A.C.D.C",1,"You should not see this.\n"); - psTrace(".A.B.C.D.E",2,"You should see this.\n"); - psTrace(".A.B.C.D.E.F",3,"You should see this too.\n"); - - psTracePrintLevels(); - - return 0; -} - -static psS32 testTrace02(void) -{ -// diag("testTrace02"); - - psTraceReset(); - // psTraceSetDestination(stderr); - (void)psTraceSetDestination(2); - (void)psTraceSetLevel(".A.B", 2); - (void)psTraceSetLevel(".A.B.C.D.E", 5); - psTracePrintLevels(); - (void)psTraceSetLevel(".A.B", 10); - psTracePrintLevels(); - - ok (10 == psTraceGetLevel(".A.B.C"), - ".A.B.C did not dynamically inherit a trace level (%d)\n", - psTraceGetLevel(".A.B.C")); - - ok (10 == psTraceGetLevel(".A.B.C.D"), - ".A.B.C.D did not dynamically inherit a trace level (%d)\n", - psTraceGetLevel(".A.B.C.D")); - - ok (5 == psTraceGetLevel(".A.B.C.D.E"), - ".A.B.C.D.E did dynamically inherit a trace level (%d)\n", - psTraceGetLevel(".A.B.C.D.E")); - - return 0; -} - -static psS32 testTrace03(void) -{ -// diag("testTrace03"); - - psS32 i = 0; - psS32 lev = 0; - - // psTraceSetDestination(stderr); - (void)psTraceSetDestination(2); - - for (i=0;i<10;i++) { - (void)psTraceSetLevel(".", i); - psTraceReset(); - - lev = psTraceGetLevel("."); - ok (lev == PS_UNKNOWN_TRACE_LEVEL, - "expected trace level was %d, actual was %d\n", - PS_UNKNOWN_TRACE_LEVEL, lev); - } - - (void)psTraceSetLevel(".", 5); - (void)psTraceSetLevel(".a", 4); - (void)psTraceSetLevel(".a.b", 3); - (void)psTraceSetLevel(".a.b.c", 2); - ok (!((5 != psTraceGetLevel(".")) || - (4 != psTraceGetLevel(".a")) || - (3 != psTraceGetLevel(".a.b")) || - (2 != psTraceGetLevel(".a.b.c"))), - "trace successFlag = false;levels were not settable?\n"); - - psTraceReset(); - ok (!((PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".")) || - (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a")) || - (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a.b")) || - (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a.b.c"))), - "trace levels were not reset properly\n"); - - return 0; -} - - -static psS32 testTrace04(void) -{ -// diag("testTrace04"); - - int FD; - psS32 nb = 0; - FD = creat("tst_psTrace02_OUT", 0666); - // printf("\nFD = %d\n", FD); - // fp = fopen("tst_psTrace02_OUT", "w"); - for (nb = 0 ; nb<4;nb++) { - if (nb == 0) - // psTraceSetDestination(stdout); - (void)psTraceSetDestination(1); - if (nb == 1) - // psTraceSetDestination(stderr); - (void)psTraceSetDestination(2); - if (nb == 2) - (void)psTraceSetDestination(0); //NULL - if (nb == 3) - (void)psTraceSetDestination(FD); - - (void)psTraceSetLevel(".", 4); - psTrace(".", 5, "(0) This message should not be displayed (%x)\n", - 0xbeefface); - (void)psTraceSetLevel(".", 7); - psTrace(".", 5, "(0) This message should be displayed (%x)\n", - 0xbeefface); - + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(54); + + // testTrace00() + { + psMemId id = psMemGetId(); + psS32 lev = 0; + (void)psTraceSetDestination(2); + for (int i=0;i<10;i++) { + (void)psTraceSetLevel(".", i); + lev = psTraceGetLevel("."); + ok(lev == i, "trace level was %d, actual was %d", i, lev); + } + + (void)psTraceSetLevel(".", 3); + for (int i=5;i<10;i++) { + (void)psTraceSetLevel(".NODE00", i); + lev = psTraceGetLevel(".NODE00"); + ok (lev == i,"(.NODE00) expected trace level was %d, actual was %d", + i, lev); + + lev = psTraceGetLevel("."); + ok (lev == 3, + "expected trace level was %d, actual was %d", i, 3); + } + + (void)psTraceSetLevel(".NODE00.NODE01", 4); + for (int i=0;i<10;i++) { + (void)psTraceSetLevel(".NODE00.NODE01", i); + lev = psTraceGetLevel(".NODE00.NODE01"); + ok (lev == i, + "(.NODE00.NODE01) expected trace level was %d, actual was %d", + i, lev); + } + + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // testTrace01() + { + psMemId id = psMemGetId(); + (void)psTraceSetDestination(2); + (void)psTraceSetLevel(".A.B.C.D.E", 5); + psTrace(".A.C.D.C",1,"You should not see this"); + psTrace(".A.B.C.D.E",2,"You should see this"); + psTrace(".A.B.C.D.E.F",3,"You should see this too"); + psTracePrintLevels(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // testTrace02() + { + psMemId id = psMemGetId(); + psTraceReset(); + (void)psTraceSetDestination(2); + (void)psTraceSetLevel(".A.B", 2); + (void)psTraceSetLevel(".A.B.C.D.E", 5); + psTracePrintLevels(); + (void)psTraceSetLevel(".A.B", 10); + psTracePrintLevels(); + + ok (10 == psTraceGetLevel(".A.B.C"), + ".A.B.C did not dynamically inherit a trace level (%d)", + psTraceGetLevel(".A.B.C")); + + ok (10 == psTraceGetLevel(".A.B.C.D"), + ".A.B.C.D did not dynamically inherit a trace level (%d)", + psTraceGetLevel(".A.B.C.D")); + + ok (5 == psTraceGetLevel(".A.B.C.D.E"), + ".A.B.C.D.E did dynamically inherit a trace level (%d)", + psTraceGetLevel(".A.B.C.D.E")); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // testTrace03() + { + psMemId id = psMemGetId(); + (void)psTraceSetDestination(2); + + for (int i=0;i<10;i++) { + (void)psTraceSetLevel(".", i); + psTraceReset(); + int lev = psTraceGetLevel("."); + ok (lev == PS_UNKNOWN_TRACE_LEVEL, + "expected trace level was %d, actual was %d", + PS_UNKNOWN_TRACE_LEVEL, lev); + } + + (void)psTraceSetLevel(".", 5); (void)psTraceSetLevel(".a", 4); - psTrace(".a", 5, "(1) This message should not be displayed (%x)\n", - 0xbeefface); - (void)psTraceSetLevel(".a", 7); - psTrace(".a", 5, "(1) This message should be displayed (%x)\n", - 0xbeefface); - - - (void)psTraceSetLevel(".a.b", 4); - psTrace(".a.b", 5, "(2) This message should not be displayed (%x)\n", - 0xbeefface); - (void)psTraceSetLevel(".a.b", 7); - psTrace(".a.b", 5, "(2) This message should be displayed (%x)\n", - 0xbeefface); - (void)psTraceSetLevel(".a.b.c", 12); - psTrace(".a.b.c", 11, "(3) This message should be displayed (%x)\n", - 0xbeefface); - - } - - close(FD); - - return(0); -} - -static psS32 testTrace05(void) -{ - // psTraceSetDestination(stderr); - (void)psTraceSetDestination(2); - - (void)psTraceSetLevel(".", 9); - - (void)psTraceSetLevel(".a", 8); - (void)psTraceSetLevel(".b", 7); - (void)psTraceSetLevel(".c", 5); - - (void)psTraceSetLevel(".a.a", 4); - (void)psTraceSetLevel(".a.b", 3); - - (void)psTraceSetLevel(".b.a", 2); - (void)psTraceSetLevel(".b.b", 1); - - (void)psTraceSetLevel(".c.a", 0); - (void)psTraceSetLevel(".c.b", 3); - (void)psTraceSetLevel(".c.c", 5); - - psTracePrintLevels(); - - return 0; - -} - -static psS32 testTrace05a(void) -{ - (void)psTraceSetLevel(".", 9); - - (void)psTraceSetLevel("a", 8); - (void)psTraceSetLevel("b", 7); - (void)psTraceSetLevel("c", 5); - - (void)psTraceSetLevel("a.a", 4); - (void)psTraceSetLevel("a.b", 3); - - (void)psTraceSetLevel("b.a", 2); - (void)psTraceSetLevel("b.b", 1); - - (void)psTraceSetLevel("c.a", 0); - (void)psTraceSetLevel("c.b", 3); - (void)psTraceSetLevel("c.c", 5); - - psTracePrintLevels(); - - return 0; - -} - -static psS32 testTrace06(void) -{ - // psTraceSetDestination(stderr); - (void)psTraceSetDestination(2); - - (void)psTraceSetLevel(".", 9); - - (void)psTraceSetLevel(".a", 8); - (void)psTraceSetLevel(".b", 7); - (void)psTraceSetLevel(".c", 5); - - (void)psTraceSetLevel(".a.a", 4); - (void)psTraceSetLevel(".a.b", 3); - - (void)psTraceSetLevel(".b.a", 2); - (void)psTraceSetLevel(".b.b", 1); - - (void)psTraceSetLevel(".c.a", 0); - (void)psTraceSetLevel(".c.b", 3); - (void)psTraceSetLevel(".c.c", 5); - - psTraceReset(); - - if ((psTraceGetLevel(".")!=PS_UNKNOWN_TRACE_LEVEL) || + (void)psTraceSetLevel(".a.b", 3); + (void)psTraceSetLevel(".a.b.c", 2); + ok (!((5 != psTraceGetLevel(".")) || + (4 != psTraceGetLevel(".a")) || + (3 != psTraceGetLevel(".a.b")) || + (2 != psTraceGetLevel(".a.b.c"))), + "trace successFlag = false;levels were not settable?"); + + psTraceReset(); + ok (!((PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".")) || + (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a")) || + (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a.b")) || + (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a.b.c"))), + "trace levels were not reset properly"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // testTrace04() + { + psMemId id = psMemGetId(); + int FD = creat("tst_psTrace02_OUT", 0666); + for (int nb = 0 ; nb<4;nb++) { + if (nb == 0) + (void)psTraceSetDestination(1); + if (nb == 1) + (void)psTraceSetDestination(2); + if (nb == 2) + (void)psTraceSetDestination(0); + if (nb == 3) + (void)psTraceSetDestination(FD); + + (void)psTraceSetLevel(".", 4); + psTrace(".", 5, "(0) This message should not be displayed (%x)", + 0xbeefface); + (void)psTraceSetLevel(".", 7); + psTrace(".", 5, "(0) This message should be displayed (%x)", + 0xbeefface); + + (void)psTraceSetLevel(".a", 4); + psTrace(".a", 5, "(1) This message should not be displayed (%x)", + 0xbeefface); + (void)psTraceSetLevel(".a", 7); + psTrace(".a", 5, "(1) This message should be displayed (%x)", + 0xbeefface); + + (void)psTraceSetLevel(".a.b", 4); + psTrace(".a.b", 5, "(2) This message should not be displayed (%x)", + 0xbeefface); + (void)psTraceSetLevel(".a.b", 7); + psTrace(".a.b", 5, "(2) This message should be displayed (%x)", + 0xbeefface); + (void)psTraceSetLevel(".a.b.c", 12); + psTrace(".a.b.c", 11, "(3) This message should be displayed (%x)", + 0xbeefface); + } + close(FD); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // testTrace05() + { + psMemId id = psMemGetId(); + (void)psTraceSetDestination(2); + (void)psTraceSetLevel(".", 9); + (void)psTraceSetLevel(".a", 8); + (void)psTraceSetLevel(".b", 7); + (void)psTraceSetLevel(".c", 5); + (void)psTraceSetLevel(".a.a", 4); + (void)psTraceSetLevel(".a.b", 3); + (void)psTraceSetLevel(".b.a", 2); + (void)psTraceSetLevel(".b.b", 1); + (void)psTraceSetLevel(".c.a", 0); + (void)psTraceSetLevel(".c.b", 3); + (void)psTraceSetLevel(".c.c", 5); + psTracePrintLevels(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // testTrace05a() + { + psMemId id = psMemGetId(); + (void)psTraceSetLevel(".", 9); + (void)psTraceSetLevel("a", 8); + (void)psTraceSetLevel("b", 7); + (void)psTraceSetLevel("c", 5); + (void)psTraceSetLevel("a.a", 4); + (void)psTraceSetLevel("a.b", 3); + (void)psTraceSetLevel("b.a", 2); + (void)psTraceSetLevel("b.b", 1); + (void)psTraceSetLevel("c.a", 0); + (void)psTraceSetLevel("c.b", 3); + (void)psTraceSetLevel("c.c", 5); + psTracePrintLevels(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // testTrace06() + { + psMemId id = psMemGetId(); + (void)psTraceSetDestination(2); + (void)psTraceSetLevel(".", 9); + (void)psTraceSetLevel(".a", 8); + (void)psTraceSetLevel(".b", 7); + (void)psTraceSetLevel(".c", 5); + (void)psTraceSetLevel(".a.a", 4); + (void)psTraceSetLevel(".a.b", 3); + (void)psTraceSetLevel(".b.a", 2); + (void)psTraceSetLevel(".b.b", 1); + (void)psTraceSetLevel(".c.a", 0); + (void)psTraceSetLevel(".c.b", 3); + (void)psTraceSetLevel(".c.c", 5); + psTraceReset(); + + if ((psTraceGetLevel(".")!=PS_UNKNOWN_TRACE_LEVEL) || (psTraceGetLevel(".a")!=PS_UNKNOWN_TRACE_LEVEL) || (psTraceGetLevel(".b")!=PS_UNKNOWN_TRACE_LEVEL) || @@ -308,33 +238,28 @@ (psTraceGetLevel(".c.b")!=PS_UNKNOWN_TRACE_LEVEL) || (psTraceGetLevel(".c.c")!=PS_UNKNOWN_TRACE_LEVEL)) { - return 1; - } - - return 0; -} - -// Ensure that the leading dot in the component names are optional. -static psS32 testTrace08(void) -{ - psTraceReset(); - (void)psTraceSetLevel(".", 9); - - (void)psTraceSetLevel(".a", 8); - (void)psTraceSetLevel(".b", 7); - (void)psTraceSetLevel(".c", 5); - - (void)psTraceSetLevel(".a.a", 4); - (void)psTraceSetLevel(".a.b", 3); - - (void)psTraceSetLevel(".b.a", 2); - (void)psTraceSetLevel(".b.b", 1); - - (void)psTraceSetLevel(".c.a", 0); - (void)psTraceSetLevel(".c.b", 3); - (void)psTraceSetLevel(".c.c", 5); - - psTracePrintLevels(); - - if ((psTraceGetLevel(".")!=9) || + return 1; + } + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // Ensure that the leading dot in the component names are optional. + // testTrace08() + { + psMemId id = psMemGetId(); + psTraceReset(); + (void)psTraceSetLevel(".", 9); + (void)psTraceSetLevel(".a", 8); + (void)psTraceSetLevel(".b", 7); + (void)psTraceSetLevel(".c", 5); + (void)psTraceSetLevel(".a.a", 4); + (void)psTraceSetLevel(".a.b", 3); + (void)psTraceSetLevel(".b.a", 2); + (void)psTraceSetLevel(".b.b", 1); + (void)psTraceSetLevel(".c.a", 0); + (void)psTraceSetLevel(".c.b", 3); + (void)psTraceSetLevel(".c.c", 5); + psTracePrintLevels(); + if ((psTraceGetLevel(".")!=9) || (psTraceGetLevel("a")!=8) || (psTraceGetLevel("b")!=7) || @@ -347,19 +272,18 @@ (psTraceGetLevel("c.b")!=3) || (psTraceGetLevel("c.c")!=5)) { - printf("psTraceGetLevel(.) is %d\n", psTraceGetLevel(".")); - printf("psTraceGetLevel(a) is %d\n", psTraceGetLevel("a")); - printf("psTraceGetLevel(b) is %d\n", psTraceGetLevel("b")); - printf("psTraceGetLevel(c) is %d\n", psTraceGetLevel("c")); - printf("psTraceGetLevel(a.a) is %d\n", psTraceGetLevel("a.a")); - printf("psTraceGetLevel(a.b) is %d\n", psTraceGetLevel("a.b")); - printf("psTraceGetLevel(b.a) is %d\n", psTraceGetLevel("b.a")); - printf("psTraceGetLevel(b.b) is %d\n", psTraceGetLevel("b.b")); - printf("psTraceGetLevel(c.a) is %d\n", psTraceGetLevel("c.a")); - printf("psTraceGetLevel(c.b) is %d\n", psTraceGetLevel("c.b")); - printf("psTraceGetLevel(c.c) is %d\n", psTraceGetLevel("c.c")); - - return 1; - } - - return 0; + printf("psTraceGetLevel(.) is %d", psTraceGetLevel(".")); + printf("psTraceGetLevel(a) is %d", psTraceGetLevel("a")); + printf("psTraceGetLevel(b) is %d", psTraceGetLevel("b")); + printf("psTraceGetLevel(c) is %d", psTraceGetLevel("c")); + printf("psTraceGetLevel(a.a) is %d", psTraceGetLevel("a.a")); + printf("psTraceGetLevel(a.b) is %d", psTraceGetLevel("a.b")); + printf("psTraceGetLevel(b.a) is %d", psTraceGetLevel("b.a")); + printf("psTraceGetLevel(b.b) is %d", psTraceGetLevel("b.b")); + printf("psTraceGetLevel(c.a) is %d", psTraceGetLevel("c.a")); + printf("psTraceGetLevel(c.b) is %d", psTraceGetLevel("c.b")); + printf("psTraceGetLevel(c.c) is %d", psTraceGetLevel("c.c")); + return 1; + } + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } } Index: trunk/psLib/test/types/tap_psArguments_all.c =================================================================== --- trunk/psLib/test/types/tap_psArguments_all.c (revision 12777) +++ trunk/psLib/test/types/tap_psArguments_all.c (revision 12781) @@ -11,13 +11,7 @@ * */ - #include - #include "tap.h" #include "pstap.h" - -void testArgumentGetParse(void); -void testArgumentVerbosity(void); -//void testLogTraceArguments(void); int main(void) @@ -25,303 +19,310 @@ psLogSetFormat("HLNM"); psLogSetLevel(PS_LOG_INFO); - plan_tests(27); - - note("Tests for psArguments Functions"); - - testArgumentGetParse(); - testArgumentVerbosity(); - // testLogTraceArguments(); - - done(); + plan_tests(28); + + // testArgumentGetParse() + { + psMemId id = psMemGetId(); + psMetadata *arg = NULL; + char *argv[25]; + argv[0] = "./program"; + argv[1] = "-string"; + argv[2] = "new"; + argv[3] = "-float"; + argv[4] = "6.66"; + argv[5] = "-double"; + argv[6] = "0.666"; + argv[7] = "-int"; + argv[8] = "8"; + argv[9] = "-int"; + argv[10] = "16"; + argv[11] = "-int"; + argv[12] = "32"; + argv[13] = "-int"; + argv[14] = "64"; + argv[15] = "-U8"; + argv[16] = "1"; + argv[17] = "-U16"; + argv[18] = "666"; + argv[19] = "-U32"; + argv[20] = "666"; + argv[21] = "-Bool"; + argv[22] = "true"; + argv[23] = "-int"; + // argv[24] = "32"; + argv[24] = "-vvv"; + int argc = 25; + + //Try to get an argument's position + int i = psArgumentGet(argc, argv, "-float"); + { + ok( i == 3, + "psArgumentGet: return correct location of input argument."); + } + + //Return 0 for attempting to get from a NULL input argument. + { + ok( psArgumentGet(argc, NULL, "-float") == 0, + "psArgumentGet: return 0 for a NULL input argument."); + } + + //Return 0 for attempting to find a NULL string + { + ok( psArgumentGet(argc, argv, NULL) == 0, + "psArgumentGet: return 0 for a NULL input string."); + } + + //Return 0 for attempting to find an empty string + { + ok( psArgumentGet(argc, argv, "") == 0, + "psArgumentGet: return 0 for an empty input string."); + } + + //Return 0 for attempting to get an argument that doesn't match + { + ok( psArgumentGet(argc, argv, "-xxx") == 0, + "psArgumentGet: return 0 for an empty input string."); + } + + //Return false for attempting to remove argnum = 0 + { + ok( !psArgumentRemove(0, &argc, argv), + "psArgumentRemove: return false for argnum = 0."); + } + + //Return false for attempting to remove NULL argc + { + ok( !psArgumentRemove(0, NULL, argv), + "psArgumentRemove: return false for NULL argc."); + } + + //Setup the argument list for comparison + psMetadata *args = psMetadataAlloc(); + psMetadataAdd(args, PS_LIST_TAIL, "-string", PS_DATA_STRING, "Test String", "SomeString"); + psMetadataAdd(args, PS_LIST_TAIL, "-float", PS_DATA_F32, "Test Float", 0.666); + psMetadataAdd(args, PS_LIST_TAIL, "-double", PS_DATA_F64, "Test Double", 0.666); + psMetadata *ints = psMetadataAlloc(); + psMetadataAdd(ints, PS_LIST_TAIL, "int1", PS_DATA_S8, "Int1", 8); + psMetadataAdd(ints, PS_LIST_TAIL, "int2", PS_DATA_S16, "Int2", 16); + psMetadataAdd(ints, PS_LIST_TAIL, "int3", PS_DATA_S32, "Int3", 32); + psMetadataAdd(ints, PS_LIST_TAIL, "int4", PS_DATA_S64, "Int4", 64); + psMetadataAdd(args, PS_LIST_TAIL, "-int", PS_DATA_METADATA, "Integers", ints); + psFree(ints); // Drop reference + psMetadataAddS32(args, PS_LIST_TAIL, "-multi", 0, "666", 2); + psMetadataAddS32(args, PS_LIST_TAIL, "-multi", PS_META_DUPLICATE_OK, "hello kitty", 1); + + psMetadataAddU8(args, PS_LIST_TAIL, "-U8", 0, "U8", 1); + psMetadataAddU16(args, PS_LIST_TAIL, "-U16", 0, "U16", 666); + psMetadataAddU32(args, PS_LIST_TAIL, "-U32", 0, "U32", 666); + psMetadataAddU64(args, PS_LIST_TAIL, "-U64", 0, "U64", 666); + psMetadataAddBool(args, PS_LIST_TAIL, "-Bool", 0, "boolean", true); + psMetadataAddBool(args, PS_LIST_TAIL, "-Bool2", 0, "boolean", false); + psSphere *sphere = psSphereAlloc(); + sphere->r = 6.66; + sphere->d = 666.666; + psMetadataAddPtr(args, PS_LIST_TAIL, "ptr", PS_DATA_SPHERE, "", sphere); + psFree(sphere); + + //psArgumentHelp test + //Do nothing for NULL input (exit gracefully) + psArgumentHelp(NULL); + //Print the Argument help for valid metadata + psArgumentHelp(args); + + //psArgumentParse tests + //Return false for NULL input arguments + { + ok( !psArgumentParse(NULL, &argc, argv), + "psArgumentParse: return false for NULL argument metadata input."); + } + + //Return false for NULL input argc + { + ok( !psArgumentParse(args, NULL, argv), + "psArgumentParse: return false for NULL argc input."); + } + + //Return false for NULL input argv + { + ok( !psArgumentParse(args, &argc, NULL), + "psArgumentParse: return false for NULL argv input."); + } + + //Return false for argc = 0 + { + int tempc = 0; + ok( !psArgumentParse(args, &tempc, argv), + "psArgumentParse: return false for argc = 1 input."); + } + + //Return false for string not found in metadata arguments + { + ok( !psArgumentParse(args, &argc, argv), + "psArgumentParse: return false for argv containing unspecified input."); + } + + //Return true for valid case + { + psArgumentRemove(25, &argc, argv); + ok( psArgumentParse(args, &argc, argv), + "psArgumentParse: return true for valid inputs."); + } + + //Return false for inconsistent argc in metadata + { + psMetadata *tempArg = psMetadataAlloc(); + psMetadata *mdtemp = psMetadataAlloc(); + psMetadataAdd(mdtemp, PS_LIST_TAIL, "int1", PS_DATA_S8, "Int1", 8); + psMetadataAdd(mdtemp, PS_LIST_TAIL, "int2", PS_DATA_S16, "Int2", 16); + psMetadataAdd(mdtemp, PS_LIST_TAIL, "int3", PS_DATA_S32, "Int3", 32); + psMetadataAdd(tempArg, PS_LIST_TAIL, "-int", PS_DATA_METADATA, "Integers", mdtemp); + psFree(mdtemp); + int argcc = 2; + char *argvv[2]; + argvv[0] = "./program"; + argvv[1] = "-string"; + ok( !psArgumentParse(tempArg, &argcc, argvv), + "psArgumentParse: return false for inconsistent argc."); + psFree(tempArg); + } + + //Return false for argc = 1 + { + int argcc = 2; + char *argvv[2]; + argvv[0] = "./program"; + argvv[1] = "-string"; + ok( !psArgumentParse(args, &argcc, argvv), + "psArgumentParse: return false for incomplete string syntax."); + } + + //Return true for an unfound MULTI match + { + int argcc = 3; + char *argvv[3]; + argvv[0] = "./program"; + argvv[1] = "-multi"; + argvv[2] = "2"; + ok( psArgumentParse(args, &argcc, argvv), + "psArgumentParse: return true for MULTI."); + } + + //Check for Memory leaks + { + psFree(args); + psFree(arg); + checkMem(); + } + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // testArgumentVerbosity() + { + psMemId id = psMemGetId(); + //Return 2 (default) for NULL input argument + { + int argc = 1; + ok( psArgumentVerbosity(&argc, NULL) == 2, + "psArgumentVerbosity: return 2 for NULL argument input."); + } + + //Return 2 for NULL argc input + { + char *argv[1]; + argv[0] = "./program"; + ok( psArgumentVerbosity(NULL, argv) == 2, + "psArgumentVerbosity: return 2 for NULL argument input."); + } + + //Return 3 for "-v" option + { + int argc = 2; + char *argv[2]; + argv[0] = "./program"; + argv[1] = "-v"; + ok( psArgumentVerbosity(&argc, argv) == 3, + "psArgumentVerbosity: return 3 for '-v' argument input."); + } + + //Return 4 for "-vv" option + { + int argc = 2; + char *argv[2]; + argv[0] = "./program"; + argv[1] = "-vv"; + ok( psArgumentVerbosity(&argc, argv) == 4, + "psArgumentVerbosity: return 4 for '-vv' argument input."); + } + + //Return 5 for "-vvv" option + { + int argc = 2; + char *argv[2]; + argv[0] = "./program"; + argv[1] = "-vvv"; + ok( psArgumentVerbosity(&argc, argv) == 5, + "psArgumentVerbosity: return 5 for '-vvv' argument input."); + } + + //These routines should return 5 since that was the last level set above with -vvv + //Return 5 for "-logfmt" option + { + int argc = 2; + char *argv[2]; + argv[0] = "./program"; + argv[1] = "-logfmt"; + int rc = psArgumentVerbosity(&argc, argv); + ok(rc == 5, "psArgumentVerbosity: return 5 for '-logfmt' argument input (was %d)", rc); + } + + //Return 5 for "-logfmt" option with "H" + { + int argc = 3; + char *argv[3]; + argv[0] = "./program"; + argv[1] = "-logfmt"; + argv[2] = "H"; + int rc = psArgumentVerbosity(&argc, argv); + ok(rc == 5, "psArgumentVerbosity: return 5 for '-logfmt H' argument inputs (was %d)", rc); + } + + //Return 5 for "-trace" option + { + int argc = 2; + char *argv[2]; + argv[0] = "./program"; + argv[1] = "-trace"; + int rc = psArgumentVerbosity(&argc, argv); + ok(rc == 5, "psArgumentVerbosity: return 5 for '-trace' argument input (was %d)", rc); + } + + //Return 5 for "-trace 1 2" option + { + int argc = 4; + char *argv[4]; + argv[0] = "./program"; + argv[1] = "-trace"; + argv[2] = "1"; + argv[3] = "2"; + int rc = psArgumentVerbosity(&argc, argv); + ok(rc == 5, "psArgumentVerbosity: return 5 for '-trace 1 2' argument inputs (was %d", rc); + } + + //Return 5 for "-trace-levels" option + { + int argc = 2; + char *argv[2]; + argv[0] = "./program"; + argv[1] = "-trace-levels"; + int rc = psArgumentVerbosity(&argc, argv); + ok(rc == 5, "psArgumentVerbosity: return 5 for '-trace-levels' argument input (was %d)", rc); + } + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } } -void testArgumentGetParse(void) -{ - note(" >>>Test 1: psArgument Get, Remove, Parse, and Help Fxns"); - psMetadata *arg = NULL; - char *argv[25]; - argv[0] = "./program"; - argv[1] = "-string"; - argv[2] = "new"; - argv[3] = "-float"; - argv[4] = "6.66"; - argv[5] = "-double"; - argv[6] = "0.666"; - argv[7] = "-int"; - argv[8] = "8"; - argv[9] = "-int"; - argv[10] = "16"; - argv[11] = "-int"; - argv[12] = "32"; - argv[13] = "-int"; - argv[14] = "64"; - argv[15] = "-U8"; - argv[16] = "1"; - argv[17] = "-U16"; - argv[18] = "666"; - argv[19] = "-U32"; - argv[20] = "666"; - argv[21] = "-Bool"; - argv[22] = "true"; - argv[23] = "-int"; - // argv[24] = "32"; - argv[24] = "-vvv"; - int argc = 25; - - //Try to get an argument's position - int i = psArgumentGet(argc, argv, "-float"); - { - ok( i == 3, - "psArgumentGet: return correct location of input argument."); - } - //Return 0 for attempting to get from a NULL input argument. - { - ok( psArgumentGet(argc, NULL, "-float") == 0, - "psArgumentGet: return 0 for a NULL input argument."); - } - //Return 0 for attempting to find a NULL string - { - ok( psArgumentGet(argc, argv, NULL) == 0, - "psArgumentGet: return 0 for a NULL input string."); - } - //Return 0 for attempting to find an empty string - { - ok( psArgumentGet(argc, argv, "") == 0, - "psArgumentGet: return 0 for an empty input string."); - } - //Return 0 for attempting to get an argument that doesn't match - { - ok( psArgumentGet(argc, argv, "-xxx") == 0, - "psArgumentGet: return 0 for an empty input string."); - } - //Return false for attempting to remove argnum = 0 - { - ok( !psArgumentRemove(0, &argc, argv), - "psArgumentRemove: return false for argnum = 0."); - } - //Return false for attempting to remove NULL argc - { - ok( !psArgumentRemove(0, NULL, argv), - "psArgumentRemove: return false for NULL argc."); - } - - //Setup the argument list for comparison - psMetadata *args = psMetadataAlloc(); - psMetadataAdd(args, PS_LIST_TAIL, "-string", PS_DATA_STRING, "Test String", "SomeString"); - psMetadataAdd(args, PS_LIST_TAIL, "-float", PS_DATA_F32, "Test Float", 0.666); - psMetadataAdd(args, PS_LIST_TAIL, "-double", PS_DATA_F64, "Test Double", 0.666); - psMetadata *ints = psMetadataAlloc(); - psMetadataAdd(ints, PS_LIST_TAIL, "int1", PS_DATA_S8, "Int1", 8); - psMetadataAdd(ints, PS_LIST_TAIL, "int2", PS_DATA_S16, "Int2", 16); - psMetadataAdd(ints, PS_LIST_TAIL, "int3", PS_DATA_S32, "Int3", 32); - psMetadataAdd(ints, PS_LIST_TAIL, "int4", PS_DATA_S64, "Int4", 64); - psMetadataAdd(args, PS_LIST_TAIL, "-int", PS_DATA_METADATA, "Integers", ints); - psFree(ints); // Drop reference - psMetadataAddS32(args, PS_LIST_TAIL, "-multi", 0, "666", 2); - psMetadataAddS32(args, PS_LIST_TAIL, "-multi", PS_META_DUPLICATE_OK, "hello kitty", 1); - - psMetadataAddU8(args, PS_LIST_TAIL, "-U8", 0, "U8", 1); - psMetadataAddU16(args, PS_LIST_TAIL, "-U16", 0, "U16", 666); - psMetadataAddU32(args, PS_LIST_TAIL, "-U32", 0, "U32", 666); - psMetadataAddU64(args, PS_LIST_TAIL, "-U64", 0, "U64", 666); - psMetadataAddBool(args, PS_LIST_TAIL, "-Bool", 0, "boolean", true); - psMetadataAddBool(args, PS_LIST_TAIL, "-Bool2", 0, "boolean", false); - psSphere *sphere = psSphereAlloc(); - sphere->r = 6.66; - sphere->d = 666.666; - psMetadataAddPtr(args, PS_LIST_TAIL, "ptr", PS_DATA_SPHERE, "", sphere); - psFree(sphere); - - //psArgumentHelp test - //Do nothing for NULL input (exit gracefully) - psArgumentHelp(NULL); - //Print the Argument help for valid metadata - psArgumentHelp(args); - - //psArgumentParse tests - //Return false for NULL input arguments - { - ok( !psArgumentParse(NULL, &argc, argv), - "psArgumentParse: return false for NULL argument metadata input."); - } - //Return false for NULL input argc - { - ok( !psArgumentParse(args, NULL, argv), - "psArgumentParse: return false for NULL argc input."); - } - //Return false for NULL input argv - { - ok( !psArgumentParse(args, &argc, NULL), - "psArgumentParse: return false for NULL argv input."); - } - //Return false for argc = 0 - { - int tempc = 0; - ok( !psArgumentParse(args, &tempc, argv), - "psArgumentParse: return false for argc = 1 input."); - } - //Return false for string not found in metadata arguments - { - ok( !psArgumentParse(args, &argc, argv), - "psArgumentParse: return false for argv containing unspecified input."); - } - //Return true for valid case - { - psArgumentRemove(25, &argc, argv); - ok( psArgumentParse(args, &argc, argv), - "psArgumentParse: return true for valid inputs."); - } - //Return false for inconsistent argc in metadata - { - psMetadata *tempArg = psMetadataAlloc(); - psMetadata *mdtemp = psMetadataAlloc(); - psMetadataAdd(mdtemp, PS_LIST_TAIL, "int1", PS_DATA_S8, "Int1", 8); - psMetadataAdd(mdtemp, PS_LIST_TAIL, "int2", PS_DATA_S16, "Int2", 16); - psMetadataAdd(mdtemp, PS_LIST_TAIL, "int3", PS_DATA_S32, "Int3", 32); - psMetadataAdd(tempArg, PS_LIST_TAIL, "-int", PS_DATA_METADATA, "Integers", mdtemp); - psFree(mdtemp); - int argcc = 2; - char *argvv[2]; - argvv[0] = "./program"; - argvv[1] = "-string"; - ok( !psArgumentParse(tempArg, &argcc, argvv), - "psArgumentParse: return false for inconsistent argc."); - psFree(tempArg); - } - //Return false for argc = 1 - { - int argcc = 2; - char *argvv[2]; - argvv[0] = "./program"; - argvv[1] = "-string"; - ok( !psArgumentParse(args, &argcc, argvv), - "psArgumentParse: return false for incomplete string syntax."); - } - //Return true for an unfound MULTI match - { - int argcc = 3; - char *argvv[3]; - argvv[0] = "./program"; - argvv[1] = "-multi"; - argvv[2] = "2"; - ok( psArgumentParse(args, &argcc, argvv), - "psArgumentParse: return true for MULTI."); - } - - //Check for Memory leaks - { - psFree(args); - psFree(arg); - checkMem(); - } -} - - - - - - - -void testArgumentVerbosity(void) -{ - note(" >>>Test 2: psArgumentRemove & psArgumentVerbosity Fxns"); - - //Return 2 (default) for NULL input argument - { - int argc = 1; - ok( psArgumentVerbosity(&argc, NULL) == 2, - "psArgumentVerbosity: return 2 for NULL argument input."); - } - //Return 2 for NULL argc input - { - char *argv[1]; - argv[0] = "./program"; - ok( psArgumentVerbosity(NULL, argv) == 2, - "psArgumentVerbosity: return 2 for NULL argument input."); - } - //Return 3 for "-v" option - { - int argc = 2; - char *argv[2]; - argv[0] = "./program"; - argv[1] = "-v"; - ok( psArgumentVerbosity(&argc, argv) == 3, - "psArgumentVerbosity: return 3 for '-v' argument input."); - } - //Return 4 for "-vv" option - { - int argc = 2; - char *argv[2]; - argv[0] = "./program"; - argv[1] = "-vv"; - ok( psArgumentVerbosity(&argc, argv) == 4, - "psArgumentVerbosity: return 4 for '-vv' argument input."); - } - //Return 5 for "-vvv" option - { - int argc = 2; - char *argv[2]; - argv[0] = "./program"; - argv[1] = "-vvv"; - ok( psArgumentVerbosity(&argc, argv) == 5, - "psArgumentVerbosity: return 5 for '-vvv' argument input."); - } - //These routines should return 5 since that was the last level set above with -vvv - //Return 5 for "-logfmt" option - { - int argc = 2; - char *argv[2]; - argv[0] = "./program"; - argv[1] = "-logfmt"; - int rc = psArgumentVerbosity(&argc, argv); - ok(rc == 5, "psArgumentVerbosity: return 5 for '-logfmt' argument input (was %d)", rc); - } - //Return 5 for "-logfmt" option with "H" - { - int argc = 3; - char *argv[3]; - argv[0] = "./program"; - argv[1] = "-logfmt"; - argv[2] = "H"; - int rc = psArgumentVerbosity(&argc, argv); - ok(rc == 5, "psArgumentVerbosity: return 5 for '-logfmt H' argument inputs (was %d)", rc); - } - //Return 5 for "-trace" option - { - int argc = 2; - char *argv[2]; - argv[0] = "./program"; - argv[1] = "-trace"; - int rc = psArgumentVerbosity(&argc, argv); - ok(rc == 5, "psArgumentVerbosity: return 5 for '-trace' argument input (was %d)", rc); - } - //Return 5 for "-trace 1 2" option - { - int argc = 4; - char *argv[4]; - argv[0] = "./program"; - argv[1] = "-trace"; - argv[2] = "1"; - argv[3] = "2"; - int rc = psArgumentVerbosity(&argc, argv); - ok(rc == 5, "psArgumentVerbosity: return 5 for '-trace 1 2' argument inputs (was %d", rc); - } - //Return 5 for "-trace-levels" option - { - int argc = 2; - char *argv[2]; - argv[0] = "./program"; - argv[1] = "-trace-levels"; - int rc = psArgumentVerbosity(&argc, argv); - ok(rc == 5, "psArgumentVerbosity: return 5 for '-trace-levels' argument input (was %d)", rc); - } - - //Check for Memory leaks - { - checkMem(); - } -} - -/* + +/* XXX: Why is this commented out? void testLogTraceArguments(void) { Index: trunk/psLib/test/types/tap_psArray_all.c =================================================================== --- trunk/psLib/test/types/tap_psArray_all.c (revision 12777) +++ trunk/psLib/test/types/tap_psArray_all.c (revision 12781) @@ -11,315 +11,291 @@ * */ - #include - #include "tap.h" #include "pstap.h" -void testArrayAllocs(void); -void testArrayAddRemove(void); -void testArraySetGet(void); -void testArraySort(void); int main(void) { - plan_tests(29); - - note("Tests for psArray Functions"); - - testArrayAllocs(); - testArrayAddRemove( ); - testArraySetGet( ); - testArraySort(); - - done(); -} - -void testArrayAllocs(void) -{ - note(" >>>Test 1: psArrayAlloc, Realloc, & Free Fxns"); - psArray *a = NULL; - - //Tests for psArrayAlloc - //Return NULL on attempting to allocate a negative size array + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(32); + + // testArrayAllocs() { - a = psArrayAlloc(-2); - ok( a == NULL, - "psArrayAlloc: return NULL for negative array-size input."); + psMemId id = psMemGetId(); + psArray *a = NULL; + + //Tests for psArrayAlloc + //Return NULL on attempting to allocate a negative size array + { + a = psArrayAlloc(-2); + ok( a == NULL, + "psArrayAlloc: return NULL for negative array-size input."); + } + //Return NULL for negative array size - psArrayAllocEmpty + { + a = psArrayAllocEmpty(-2); + ok( a == NULL, + "psArrayAllocEmpty: return NULL for negative array-size input."); + } + //Return properly allocated psArray + { + a = psArrayAlloc(0); + ok( a != NULL && psMemCheckArray(a), + "psArrayAlloc: return properly allocated psArray."); + } + + //Tests for psMemCheckArray + //Make sure psMemCheckArray works correctly - return false + { + int j = 2; + ok( !psMemCheckArray(&j), + "psMemCheckArray: return false for non-Array input."); + } + //Tests for psArrayRealloc + //Now try to reallocate the psArray - bigger + { + a = psArrayRealloc(a, 2); + ok ( psArrayLength(a) == 0 && a->nalloc == 2, + "psArrayRealloc: return properly reallocated psArray."); + } + //Return NULL when trying to reallocate a NULL psArray + { + psArray *temp = NULL; + temp = psArrayRealloc(temp, 1); + ok( temp == NULL, + "psArrayRealloc: return NULL for NULL input psArray."); + } + //Attempt to reallocate the psArray - smaller + { + psS32 *s32 = (psS32*)psAlloc(sizeof(psS32)); + *s32 = 1; + psS32 *s32_2 = (psS32*)psAlloc(sizeof(psS32)); + *s32_2 = 2; + skip_start( !psArraySet(a, 0, s32) || !psArraySet(a, 1, s32), 1, + "Skipping 1 tests because psArraySet failed"); + a = psArrayRealloc(a, 1); + *s32_2 = *((psS32*)(a->data[0])); + ok( a->n == 1 && a->nalloc == 1 && *s32_2 == 1, + "psArrayRealloc: return properly reallocated psArray."); + skip_end(); + psFree(s32); + psFree(s32_2); + } + //Attempt to reallocate the psArray to negative size + { + a = psArrayRealloc(a, -1); + psS32 *s32 = (psS32*)psAlloc(sizeof(psS32)); + *s32 = 2; + *s32 = *((psS32*)(a->data[0])); + ok( a->n == 1 && a->nalloc == 1 && *s32 == 1, + "psArrayRealloc: return same psArray for negative-size input."); + psFree(s32); + } + + //Attempt to free a NULL psArray + psArrayElementsFree(NULL); + //Check the length of a NULL array + { + psArray *emptyArray = NULL; + ok( psArrayLength(emptyArray) == -1, + "psArrayLength: return -1 for NULL input psArray."); + } + psFree(a); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - //Return NULL for negative array size - psArrayAllocEmpty + + + // testArrayAddRemove() { - a = psArrayAllocEmpty(-2); - ok( a == NULL, - "psArrayAllocEmpty: return NULL for negative array-size input."); - } - //Return properly allocated psArray - { - a = psArrayAlloc(0); - ok( a != NULL && psMemCheckArray(a), - "psArrayAlloc: return properly allocated psArray."); - } - - //Tests for psMemCheckArray - //Make sure psMemCheckArray works correctly - return false - { - int j = 2; - ok( !psMemCheckArray(&j), - "psMemCheckArray: return false for non-Array input."); - } - //Tests for psArrayRealloc - //Now try to reallocate the psArray - bigger - { - a = psArrayRealloc(a, 2); - ok ( psArrayLength(a) == 0 && a->nalloc == 2, - "psArrayRealloc: return properly reallocated psArray."); - } - //Return NULL when trying to reallocate a NULL psArray - { - psArray *temp = NULL; - temp = psArrayRealloc(temp, 1); - ok( temp == NULL, - "psArrayRealloc: return NULL for NULL input psArray."); - } - //Attempt to reallocate the psArray - smaller - { - psS32 *s32 = (psS32*)psAlloc(sizeof(psS32)); - *s32 = 1; - psS32 *s32_2 = (psS32*)psAlloc(sizeof(psS32)); - *s32_2 = 2; - skip_start( !psArraySet(a, 0, s32) || !psArraySet(a, 1, s32), 1, - "Skipping 1 tests because psArraySet failed"); - a = psArrayRealloc(a, 1); - *s32_2 = *((psS32*)(a->data[0])); - ok( a->n == 1 && a->nalloc == 1 && *s32_2 == 1, - "psArrayRealloc: return properly reallocated psArray."); - skip_end(); - psFree(s32); - psFree(s32_2); - } - //Attempt to reallocate the psArray to negative size - { - a = psArrayRealloc(a, -1); - psS32 *s32 = (psS32*)psAlloc(sizeof(psS32)); - *s32 = 2; - *s32 = *((psS32*)(a->data[0])); - ok( a->n == 1 && a->nalloc == 1 && *s32 == 1, - "psArrayRealloc: return same psArray for negative-size input."); - psFree(s32); - } - - //Attempt to free a NULL psArray - psArrayElementsFree(NULL); - //Check the length of a NULL array - { - psArray *emptyArray = NULL; - ok( psArrayLength(emptyArray) == -1, - "psArrayLength: return -1 for NULL input psArray."); - } - - //Check for Memory leaks - { - psFree(a); - checkMem(); - } -} - -void testArrayAddRemove(void) -{ - note(" >>>Test 2: psArrayAdd & psArrayRemove Fxns"); - psArray *a = psArrayAlloc(0); - psS32 *s1 = (psS32*)psAlloc(sizeof(psS32)); - *s1 = 2; - psS32 *s2 = (psS32*)psAlloc(sizeof(psS32)); - psS32 *s3 = (psS32*)psAlloc(sizeof(psS32)); - - //Tests for psArrayAdd - //Attempt to add element to NULL psArray. - { - psArray *temp = NULL; - temp = psArrayAdd(temp, 1, (psPtr)s1); - *s3 = *((psS32*)(temp->data[0])); - ok( temp->n == 1 && temp->nalloc == 1 && *s3 == 2, - "psArrayAdd: return array with newly added data."); - psFree(temp); - } - //Attempt to add an element to empty array. - { - a = psArrayAdd(a, 1, (psPtr)s1); - *s2 = 666; - *s3 = 212; - a = psArrayAdd(a, 1, s2); - a = psArrayAdd(a, 1, s3); - *s2 = *((psS32*)(a->data[0])); - ok ( a->n == 3 && a->nalloc == 3 && *s2 == 2, - "psArrayAdd: return array with newly added data."); - } - - //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( !psArrayRemoveData(temp, s2), - "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."); - } - - //Tests for psArrayRemoveIndex - //Return false for NULL array input - { - ok( !psArrayRemoveIndex(NULL, 0), - "psArrayRemoveIndex: return false for NULL input psArray."); - } - //Return false for out-of-range index - { - ok( !psArrayRemoveIndex(a, 5), - "psArrayRemoveIndex: return false for out-of-range location."); - } - //Return true for successful removal - { - ok( psArrayRemoveIndex(a, 1) && a->n == 1, - "psArrayRemoveIndex: return true for successful removal."); - } - - //Check for Memory leaks - { + psMemId id = psMemGetId(); + psArray *a = psArrayAlloc(0); + psS32 *s1 = (psS32*)psAlloc(sizeof(psS32)); + *s1 = 2; + psS32 *s2 = (psS32*)psAlloc(sizeof(psS32)); + psS32 *s3 = (psS32*)psAlloc(sizeof(psS32)); + + //Tests for psArrayAdd + //Attempt to add element to NULL psArray. + { + psArray *temp = NULL; + temp = psArrayAdd(temp, 1, (psPtr)s1); + *s3 = *((psS32*)(temp->data[0])); + ok( temp->n == 1 && temp->nalloc == 1 && *s3 == 2, + "psArrayAdd: return array with newly added data."); + psFree(temp); + } + //Attempt to add an element to empty array. + { + a = psArrayAdd(a, 1, (psPtr)s1); + *s2 = 666; + *s3 = 212; + a = psArrayAdd(a, 1, s2); + a = psArrayAdd(a, 1, s3); + *s2 = *((psS32*)(a->data[0])); + ok ( a->n == 3 && a->nalloc == 3 && *s2 == 2, + "psArrayAdd: return array with newly added data."); + } + + //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( !psArrayRemoveData(temp, s2), + "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."); + } + + //Tests for psArrayRemoveIndex + //Return false for NULL array input + { + ok( !psArrayRemoveIndex(NULL, 0), + "psArrayRemoveIndex: return false for NULL input psArray."); + } + //Return false for out-of-range index + { + ok( !psArrayRemoveIndex(a, 5), + "psArrayRemoveIndex: return false for out-of-range location."); + } + //Return true for successful removal + { + ok( psArrayRemoveIndex(a, 1) && a->n == 1, + "psArrayRemoveIndex: return true for successful removal."); + } + psFree(s1); psFree(s2); psFree(s3); psFree(a); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } -} - -void testArraySetGet(void) -{ - note(" >>>Test 3: psArraySet & psArrayGet Fxns"); - psArray *a = NULL; - psArray *b = NULL; - psS32 *s1 = (psS32*)psAlloc(sizeof(psS32)); - *s1 = 2; - psS32 *s2 = (psS32*)psAlloc(sizeof(psS32)); - *s2 = 1; - psS32 *s3 = (psS32*)psAlloc(sizeof(psS32)); - *s3 = 3; - - //Tests for psArraySet - //Return false for trying to set a NULL psArray + + // testArraySetGet() { - ok( !psArraySet(a, 0, (psPtr)s1), - "psArraySet: return false for NULL input psArray."); - } - //Return false for trying to set an invalid position - a = psArrayAlloc(1); - { - ok( !psArraySet(a, 2, (psPtr)s1), - "psArraySet: return false for invalid input position."); - } - //Return false for trying to set nalloc position - psArraySet(a, 0, (psPtr)s1); - { - ok( !psArraySet(a, a->nalloc, (psPtr)s2), - "psArraySet: return false for out-of-range position."); - } - //Return false for an invalid position (-2 = out-of-range neg. index) - { - ok( !psArraySet(a, -2, (psPtr)s2), - "psArraySet: return false for out-of-range negative position."); - } - //Return true for set to a->n position (< nalloc) - a = psArrayRealloc(a, 10); - { - ok( psArraySet(a, a->n, (psPtr)s2) && a->n == 2, - "psArraySet: return true for valid input position."); - } - //Return true for a negative index input - { - ok( psArraySet(a, -2, (psPtr)s3) && a->n == 2 && - *((psS32*)(a->data[0])) == 3, - "psArraySet: return true for valid negative input position."); - } - - //Tests for psArrayGet - //Return NULL for NULL array input - psS32 *s4 = NULL; - { - s4 = (psS32*)psArrayGet(b, 0); - ok( s4 == NULL, - "psArrayGet: return NULL for NULL input psArray."); - } - //Return NULL for an out-of-range index - { - s4 = (psS32*)psArrayGet(a, a->n); - ok( s4 == NULL, - "psArrayGet: return NULL for out-of-range position."); - } - //Return NULL for an out-of-range negative index - { - s4 = (psS32*)psArrayGet(a, -1-a->n); - ok( s4 == NULL, - "psArrayGet: return NULL for out-of-range negative position."); - } - //Return valid case - { - s4 = (psS32*)psArrayGet(a, 1); - ok( *s4 == 1, - "psArrayGet: return correct value for valid position."); - } - - //Check for Memory leaks - { + psMemId id = psMemGetId(); + psArray *a = NULL; + psArray *b = NULL; + psS32 *s1 = (psS32*)psAlloc(sizeof(psS32)); + *s1 = 2; + psS32 *s2 = (psS32*)psAlloc(sizeof(psS32)); + *s2 = 1; + psS32 *s3 = (psS32*)psAlloc(sizeof(psS32)); + *s3 = 3; + + //Tests for psArraySet + //Return false for trying to set a NULL psArray + { + ok( !psArraySet(a, 0, (psPtr)s1), + "psArraySet: return false for NULL input psArray."); + } + //Return false for trying to set an invalid position + a = psArrayAlloc(1); + { + ok( !psArraySet(a, 2, (psPtr)s1), + "psArraySet: return false for invalid input position."); + } + //Return false for trying to set nalloc position + psArraySet(a, 0, (psPtr)s1); + { + ok( !psArraySet(a, a->nalloc, (psPtr)s2), + "psArraySet: return false for out-of-range position."); + } + //Return false for an invalid position (-2 = out-of-range neg. index) + { + ok( !psArraySet(a, -2, (psPtr)s2), + "psArraySet: return false for out-of-range negative position."); + } + //Return true for set to a->n position (< nalloc) + a = psArrayRealloc(a, 10); + { + ok( psArraySet(a, a->n, (psPtr)s2) && a->n == 2, + "psArraySet: return true for valid input position."); + } + //Return true for a negative index input + { + ok( psArraySet(a, -2, (psPtr)s3) && a->n == 2 && + *((psS32*)(a->data[0])) == 3, + "psArraySet: return true for valid negative input position."); + } + + //Tests for psArrayGet + //Return NULL for NULL array input + psS32 *s4 = NULL; + { + s4 = (psS32*)psArrayGet(b, 0); + ok( s4 == NULL, + "psArrayGet: return NULL for NULL input psArray."); + } + //Return NULL for an out-of-range index + { + s4 = (psS32*)psArrayGet(a, a->n); + ok( s4 == NULL, + "psArrayGet: return NULL for out-of-range position."); + } + //Return NULL for an out-of-range negative index + { + s4 = (psS32*)psArrayGet(a, -1-a->n); + ok( s4 == NULL, + "psArrayGet: return NULL for out-of-range negative position."); + } + //Return valid case + { + s4 = (psS32*)psArrayGet(a, 1); + ok( *s4 == 1, + "psArrayGet: return correct value for valid position."); + } + psFree(a); psFree(s1); psFree(s2); psFree(s3); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } -} - -void testArraySort(void) -{ - note(" >>>Test 4: psArray Sort Function"); - psArray *a = NULL; - a = psArrayAlloc(3); - a->n = 0; - psS32 *s1 = (psS32*)psAlloc(sizeof(psS32)); - *s1 = 2; - psS32 *s2 = (psS32*)psAlloc(sizeof(psS32)); - *s2 = 1; - psS32 *s3 = (psS32*)psAlloc(sizeof(psS32)); - *s3 = 3; - psArraySet(a, a->n, (psPtr)s1); - psArraySet(a, a->n, (psPtr)s2); - psArraySet(a, a->n, (psPtr)s3); - psS32 *s4 = (psS32*)psAlloc(sizeof(psS32)); - psS32 *s5 = (psS32*)psAlloc(sizeof(psS32)); - psS32 *s6 = (psS32*)psAlloc(sizeof(psS32)); - - //Tests for psArraySort - //Return NULL for attempt to sort NULL psArray input. + + + // testArraySort() { - psArray *temp = NULL; - temp = psArraySort(temp, (psComparePtrFunc)psCompareDescendingS32Ptr); - ok( temp == NULL, - "psArraySort: return NULL for NULL input psArray."); - } - //Return properly sorted psArray with descending psS32 elements - 3,2,1 - { - a = psArraySort(a, (psComparePtrFunc)psCompareDescendingS32Ptr); - *s4 = *((psS32*)(a->data[0])); - *s5 = *((psS32*)(a->data[1])); - *s6 = *((psS32*)(a->data[2])); - ok( *s4 == 3 && *s5 == 2 && *s6 == 1, - "psArraySort: return properly sorted psArray."); - } - - //Check for Memory leaks - { + psMemId id = psMemGetId(); + psArray *a = NULL; + a = psArrayAlloc(3); + a->n = 0; + psS32 *s1 = (psS32*)psAlloc(sizeof(psS32)); + *s1 = 2; + psS32 *s2 = (psS32*)psAlloc(sizeof(psS32)); + *s2 = 1; + psS32 *s3 = (psS32*)psAlloc(sizeof(psS32)); + *s3 = 3; + psArraySet(a, a->n, (psPtr)s1); + psArraySet(a, a->n, (psPtr)s2); + psArraySet(a, a->n, (psPtr)s3); + psS32 *s4 = (psS32*)psAlloc(sizeof(psS32)); + psS32 *s5 = (psS32*)psAlloc(sizeof(psS32)); + psS32 *s6 = (psS32*)psAlloc(sizeof(psS32)); + + //Tests for psArraySort + //Return NULL for attempt to sort NULL psArray input. + { + psArray *temp = NULL; + temp = psArraySort(temp, (psComparePtrFunc)psCompareDescendingS32Ptr); + ok( temp == NULL, + "psArraySort: return NULL for NULL input psArray."); + } + //Return properly sorted psArray with descending psS32 elements - 3,2,1 + { + a = psArraySort(a, (psComparePtrFunc)psCompareDescendingS32Ptr); + *s4 = *((psS32*)(a->data[0])); + *s5 = *((psS32*)(a->data[1])); + *s6 = *((psS32*)(a->data[2])); + ok( *s4 == 3 && *s5 == 2 && *s6 == 1, + "psArraySort: return properly sorted psArray."); + } + psFree(s1); psFree(s2); @@ -329,7 +305,6 @@ psFree(s6); psFree(a); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - } Index: trunk/psLib/test/types/tap_psBitSet_all.c =================================================================== --- trunk/psLib/test/types/tap_psBitSet_all.c (revision 12777) +++ trunk/psLib/test/types/tap_psBitSet_all.c (revision 12781) @@ -10,286 +10,270 @@ * */ - #include #include - #include "tap.h" #include "pstap.h" -void testBitSetBasics(void); -void testBitSetOps(void); int main(void) { - plan_tests(31); - - note("Tests for psBitSet Functions"); - - testBitSetBasics(); - testBitSetOps(); - - done(); -} - -void testBitSetBasics(void) -{ - note(" >>>Test 1: psBitSet Basic Fxns"); - - psBitSet *noBits = NULL; - psBitSet *bs = NULL; - - //Return NULL for attempt to Allocate BitSet of negative size. + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(32); + + + // testBitSetBasics() { - noBits = psBitSetAlloc(-1); - ok( noBits == NULL, - "psBitSetAlloc: return NULL for negative BitSet-size input."); + psMemId id = psMemGetId(); + psBitSet *noBits = NULL; + psBitSet *bs = NULL; + + //Return NULL for attempt to Allocate BitSet of negative size. + { + noBits = psBitSetAlloc(-1); + ok( noBits == NULL, + "psBitSetAlloc: return NULL for negative BitSet-size input."); + } + //Return properly allocated 0-size psBitSet + { + bs = psBitSetAlloc(0); + ok( bs != NULL && psMemCheckBitSet(bs) && bs->n == 0, + "psBitSetAlloc: return properly allocated psBitSet."); + } + //Return properly allocated psBitSet + { + psFree(bs); + bs = psBitSetAlloc(8); + ok( bs != NULL && psMemCheckBitSet(bs) && bs->n == 1, + "psBitSetAlloc: return properly allocated psBitSet."); + } + //Make sure psMemCheckBitSet works correctly - return false + { + int j = 2; + ok( !psMemCheckBitSet(&j), + "psMemCheckBitSet: return false for non-BitSet input."); + } + + //BitSetSet Tests + //Return FALSE for NULL input psBitSet + { + bool rc = psBitSetSet(NULL, 0); + ok(rc == false, + "psBitSetSet: return FALSE for NULL BitSet input."); + } + //Return FALSE for negative bit input + { + bool rc = psBitSetSet(bs, -1); + ok( rc == false, + "psBitSetSet: return TRUE for negative bits input."); + noBits = NULL; + } + //Return FALSE for out-of-range bits + { + psFree(bs); + bs = psBitSetAlloc(8); + bool rc = psBitSetSet(bs, 8); + ok( rc == false, + "psBitSetSet: return TRUE for out-of-range bits input."); + noBits = NULL; + } + + //Return set BitSet for valid inputs + { + psBitSetSet(bs, 2); + ok( bs->bits[0] == 4, + "psBitSetSet: return properly set BitSet for valid inputs."); + } + + //BitSetClear Tests + //Return FALSE for NULL input psBitSet + { + bool rc = psBitSetClear(noBits, 0); + ok( rc == false, + "psBitSetClear: return FALSE for NULL BitSet input."); + } + //Return FALSE for negative bit input + { + bool rc = psBitSetClear(bs, -1); + ok( rc == false, + "psBitSetClear: return TRUE for negative bits input."); + noBits = NULL; + } + //Return FALSE for out-of-range bits + { + bool rc = psBitSetClear(bs, 8); + ok( rc == false, + "psBitSetClear: return FALSE for out-of-range bits input."); + noBits = NULL; + } + + //Return cleared BitSet for valid inputs + { + psBitSetClear(bs, 2); + ok( bs->bits[0] == 0, + "psBitSetClear: return properly cleared BitSet for valid inputs."); + } + + //BitSetTest Tests + //Return false for NULL input psBitSet + { + ok( !psBitSetTest(noBits, 0), + "psBitSetTest: return false for NULL BitSet input."); + } + //Return false for negative bit input + { + ok( !psBitSetTest(bs, -1), + "psBitSetTest: return false for negative bits input."); + } + //Return false for out-of-range bits + { + ok( !psBitSetTest(bs, 8), + "psBitSetTest: return false for out-of-range bits input."); + } + //Return false for non-matching bit in BitSet + { + ok( !psBitSetTest(bs, 2), + "psBitSetTest: return false for non-matching bit in BitSet."); + } + //Return false for non-matching bit in BitSet + { + psBitSetSet(bs, 2); + ok( psBitSetTest(bs, 2), + "psBitSetTest: return true for matching bit in BitSet."); + } + + psFree(bs); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - //Return properly allocated 0-size psBitSet + + + // testBitSetOps() { - bs = psBitSetAlloc(0); - ok( bs != NULL && psMemCheckBitSet(bs) && bs->n == 0, - "psBitSetAlloc: return properly allocated psBitSet."); - } - //Return properly allocated psBitSet - { - psFree(bs); - bs = psBitSetAlloc(8); - ok( bs != NULL && psMemCheckBitSet(bs) && bs->n == 1, - "psBitSetAlloc: return properly allocated psBitSet."); - } - //Make sure psMemCheckBitSet works correctly - return false - { - int j = 2; - ok( !psMemCheckBitSet(&j), - "psMemCheckBitSet: return false for non-BitSet input."); - } - - //BitSetSet Tests - //Return FALSE for NULL input psBitSet - { - bool rc = psBitSetSet(NULL, 0); - ok(rc == false, - "psBitSetSet: return FALSE for NULL BitSet input."); - } - //Return FALSE for negative bit input - { - bool rc = psBitSetSet(bs, -1); - ok( rc == false, - "psBitSetSet: return TRUE for negative bits input."); - noBits = NULL; - } - //Return FALSE for out-of-range bits - { - psFree(bs); - bs = psBitSetAlloc(8); - bool rc = psBitSetSet(bs, 8); - ok( rc == false, - "psBitSetSet: return TRUE for out-of-range bits input."); - noBits = NULL; - } - - //Return set BitSet for valid inputs - { - psBitSetSet(bs, 2); - ok( bs->bits[0] == 4, - "psBitSetSet: return properly set BitSet for valid inputs."); - } - - //BitSetClear Tests - //Return FALSE for NULL input psBitSet - { - bool rc = psBitSetClear(noBits, 0); - ok( rc == false, - "psBitSetClear: return FALSE for NULL BitSet input."); - } - //Return FALSE for negative bit input - { - bool rc = psBitSetClear(bs, -1); - ok( rc == false, - "psBitSetClear: return TRUE for negative bits input."); - noBits = NULL; - } - //Return FALSE for out-of-range bits - { - bool rc = psBitSetClear(bs, 8); - ok( rc == false, - "psBitSetClear: return FALSE for out-of-range bits input."); - noBits = NULL; - } - - //Return cleared BitSet for valid inputs - { - psBitSetClear(bs, 2); - ok( bs->bits[0] == 0, - "psBitSetClear: return properly cleared BitSet for valid inputs."); - } - - //BitSetTest Tests - //Return false for NULL input psBitSet - { - ok( !psBitSetTest(noBits, 0), - "psBitSetTest: return false for NULL BitSet input."); - } - //Return false for negative bit input - { - ok( !psBitSetTest(bs, -1), - "psBitSetTest: return false for negative bits input."); - } - //Return false for out-of-range bits - { - ok( !psBitSetTest(bs, 8), - "psBitSetTest: return false for out-of-range bits input."); - } - //Return false for non-matching bit in BitSet - { - ok( !psBitSetTest(bs, 2), - "psBitSetTest: return false for non-matching bit in BitSet."); - } - //Return false for non-matching bit in BitSet - { - psBitSetSet(bs, 2); - ok( psBitSetTest(bs, 2), - "psBitSetTest: return true for matching bit in BitSet."); - } - - - //Check for Memory leaks - { - psFree(bs); - checkMem(); - } -} - -void testBitSetOps(void) -{ - note(" >>>Test 2: psBitSet Operation Fxns"); - psBitSet *noBits = NULL; - psBitSet *bs = NULL; - bs = psBitSetAlloc(8); - psBitSetSet(bs, 2); // 0000 0100 == 4 - psBitSetSet(bs, 3); // 0000 1100 == 12 - psBitSetSet(bs, 4); // 0001 1100 == 28 - psBitSetSet(bs, 5); // 0011 1100 == 60 - psBitSetSet(bs, 6); // 0111 1100 == 124 - psBitSetSet(bs, 7); // 1111 1100 == 252 - psBitSet *out = NULL; - - //psBitSetNot Tests - //Return NULL for NULL BitSet input - { - out = psBitSetNot(out, noBits); - ok( out == NULL, - "psBitSetNot: return NULL for NULL BitSet input."); - } - //Return correct BitSet for valid BitSet input - { - out = psBitSetNot(out, bs); //bs = 1111 1100 so out should = 0000 0011 = 3 - ok( out->bits[0] == 3, - "psBitSetNot: return correct BitSet for valid BitSet input."); - } - - //psBitSetOp Tests out = psBitSetOp(out, bs1, "op", bs2); - //Return NULL for NULL BitSet input - { - psFree(out); - out = NULL; - out = psBitSetOp(out, noBits, "op", noBits); - ok( out == NULL, - "psBitSetOp: return NULL for NULL BitSet input."); - } - //Return NULL for NULL operator input - { - out = psBitSetOp(out, bs, NULL, noBits); - ok( out == NULL, - "psBitSetOp: return NULL for NULL operator input."); - } - //Return NULL for invalid operator input - { - out = psBitSetOp(out, bs, "XAND", noBits); - ok( out == NULL, - "psBitSetOp: return NULL for invalid operator input."); - } - //Return NULL for AND operator with NULL second BitSet input - { - out = psBitSetOp(out, bs, "AND", noBits); - ok( out == NULL, - "psBitSetOp: return NULL for AND operator with NULL second BitSet input."); - } - //Return NULL for AND operator with BitSet inputs of differing size. - psBitSet *bs2 = psBitSetAlloc(16); - { - out = psBitSetOp(out, bs, "AND", bs2); - ok( out == NULL, - "psBitSetOp: return NULL for AND operator with BitSet inputs of" - " differing size."); - } - psFree(bs); - bs = psBitSetAlloc(16); - psBitSetSet(bs, 1); // 0000 0010 == 2 - psBitSetSet(bs2, 2); // 0000 0100 == 4 - //Return correct psBitSet output for valid inputs with AND operator - { - out = psBitSetOp(out, bs, "AND", bs2); - ok( out->bits[0] == 0, - "psBitSetOp: return correct psBitSet output for valid inputs" - " with AND operator."); - } - //Return correct psBitSet output for valid inputs with OR operator - { - out = psBitSetOp(out, bs, "OR", bs2); - ok( out->bits[0] == 6, - "psBitSetOp: return correct psBitSet output for valid inputs" - " with OR operator."); - } - //Return correct psBitSet output for valid inputs with XOR operator - psBitSetSet(bs2, 1); // 0000 0110 == 6 - { - out = psBitSetOp(out, bs, "XOR", bs2); - ok( out->bits[0] == 4, - "psBitSetOp: return correct psBitSet output for valid inputs" - " with XOR operator."); - } - //Return correct psBitSet output for valid inputs with NOT operator - { - psFree(out); - out = psBitSetAlloc(0); - psBitSetSet(bs, 2); // 0000 0110 == 4 - psBitSetSet(bs, 3); // 0000 1110 == 12 - psBitSetSet(bs, 4); // 0001 1110 == 28 - psBitSetSet(bs, 5); // 0011 1110 == 60 - psBitSetSet(bs, 6); // 0111 1110 == 124 - psBitSetSet(bs, 7); // 1111 1110 == 252 - out = psBitSetOp(out, bs, "NOT", bs2); - ok( out->bits[0] == 1, - "psBitSetOp: return correct psBitSet output for valid inputs" - " with NOT operator."); - } - - //psBitSetToString Tests - //Return NULL for NULL BitSet input - psString bitStr = NULL; - { - bitStr = psBitSetToString(noBits); - ok( bitStr == NULL, - "psBitSetToString: return NULL for NULL BitSet input."); - } - //Return correct string for valid BitSet input - { - psFree(bs); + psMemId id = psMemGetId(); + psBitSet *noBits = NULL; + psBitSet *bs = NULL; bs = psBitSetAlloc(8); psBitSetSet(bs, 2); // 0000 0100 == 4 - bitStr = psBitSetToString(bs); - ok( !strncmp(bitStr, "00000100", 10), - "psBitSetToString: return correct string for valid BitSet input."); - } - - - //Check for Memory leaks - { + psBitSetSet(bs, 3); // 0000 1100 == 12 + psBitSetSet(bs, 4); // 0001 1100 == 28 + psBitSetSet(bs, 5); // 0011 1100 == 60 + psBitSetSet(bs, 6); // 0111 1100 == 124 + psBitSetSet(bs, 7); // 1111 1100 == 252 + psBitSet *out = NULL; + + //psBitSetNot Tests + //Return NULL for NULL BitSet input + { + out = psBitSetNot(out, noBits); + ok( out == NULL, + "psBitSetNot: return NULL for NULL BitSet input."); + } + //Return correct BitSet for valid BitSet input + { + out = psBitSetNot(out, bs); //bs = 1111 1100 so out should = 0000 0011 = 3 + ok( out->bits[0] == 3, + "psBitSetNot: return correct BitSet for valid BitSet input."); + } + + //psBitSetOp Tests out = psBitSetOp(out, bs1, "op", bs2); + //Return NULL for NULL BitSet input + { + psFree(out); + out = NULL; + out = psBitSetOp(out, noBits, "op", noBits); + ok( out == NULL, + "psBitSetOp: return NULL for NULL BitSet input."); + } + //Return NULL for NULL operator input + { + out = psBitSetOp(out, bs, NULL, noBits); + ok( out == NULL, + "psBitSetOp: return NULL for NULL operator input."); + } + //Return NULL for invalid operator input + { + out = psBitSetOp(out, bs, "XAND", noBits); + ok( out == NULL, + "psBitSetOp: return NULL for invalid operator input."); + } + //Return NULL for AND operator with NULL second BitSet input + { + out = psBitSetOp(out, bs, "AND", noBits); + ok( out == NULL, + "psBitSetOp: return NULL for AND operator with NULL second BitSet input."); + } + //Return NULL for AND operator with BitSet inputs of differing size. + psBitSet *bs2 = psBitSetAlloc(16); + { + out = psBitSetOp(out, bs, "AND", bs2); + ok( out == NULL, + "psBitSetOp: return NULL for AND operator with BitSet inputs of" + " differing size."); + } + psFree(bs); + bs = psBitSetAlloc(16); + psBitSetSet(bs, 1); // 0000 0010 == 2 + psBitSetSet(bs2, 2); // 0000 0100 == 4 + //Return correct psBitSet output for valid inputs with AND operator + { + out = psBitSetOp(out, bs, "AND", bs2); + ok( out->bits[0] == 0, + "psBitSetOp: return correct psBitSet output for valid inputs" + " with AND operator."); + } + //Return correct psBitSet output for valid inputs with OR operator + { + out = psBitSetOp(out, bs, "OR", bs2); + ok( out->bits[0] == 6, + "psBitSetOp: return correct psBitSet output for valid inputs" + " with OR operator."); + } + //Return correct psBitSet output for valid inputs with XOR operator + psBitSetSet(bs2, 1); // 0000 0110 == 6 + { + out = psBitSetOp(out, bs, "XOR", bs2); + ok( out->bits[0] == 4, + "psBitSetOp: return correct psBitSet output for valid inputs" + " with XOR operator."); + } + //Return correct psBitSet output for valid inputs with NOT operator + { + psFree(out); + out = psBitSetAlloc(0); + psBitSetSet(bs, 2); // 0000 0110 == 4 + psBitSetSet(bs, 3); // 0000 1110 == 12 + psBitSetSet(bs, 4); // 0001 1110 == 28 + psBitSetSet(bs, 5); // 0011 1110 == 60 + psBitSetSet(bs, 6); // 0111 1110 == 124 + psBitSetSet(bs, 7); // 1111 1110 == 252 + out = psBitSetOp(out, bs, "NOT", bs2); + ok( out->bits[0] == 1, + "psBitSetOp: return correct psBitSet output for valid inputs" + " with NOT operator."); + } + + //psBitSetToString Tests + //Return NULL for NULL BitSet input + psString bitStr = NULL; + { + bitStr = psBitSetToString(noBits); + ok( bitStr == NULL, + "psBitSetToString: return NULL for NULL BitSet input."); + } + //Return correct string for valid BitSet input + { + psFree(bs); + bs = psBitSetAlloc(8); + psBitSetSet(bs, 2); // 0000 0100 == 4 + bitStr = psBitSetToString(bs); + ok( !strncmp(bitStr, "00000100", 10), + "psBitSetToString: return correct string for valid BitSet input."); + } + psFree(bitStr); psFree(out); psFree(bs); psFree(bs2); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } } Index: trunk/psLib/test/types/tap_psHash_845.c =================================================================== --- trunk/psLib/test/types/tap_psHash_845.c (revision 12777) +++ trunk/psLib/test/types/tap_psHash_845.c (revision 12781) @@ -2,32 +2,33 @@ #include "pslib.h" #include "pstap.h" - #define SIZE 128 - int main(int argc, char *argv[]) { + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); plan_tests(5); - char *stuff1 = psAlloc(SIZE); // Stuff to put on hash - char *stuff2 = psAlloc(SIZE); // Stuff to put on hash + // Very basic test: create a psHash, then add data to it. + // XXX: Remove this test, or mearge it with another file. + { + psMemId id = psMemGetId(); + char *stuff1 = psAlloc(SIZE); // Stuff to put on hash + char *stuff2 = psAlloc(SIZE); // Stuff to put on hash - psHash *hash = psHashAlloc(16); // Hash to test - ok(hash, "Hash allocated"); + psHash *hash = psHashAlloc(16); // Hash to test + ok(hash, "Hash allocated"); + bool status1 = psHashAdd(hash, "stuff", stuff1); + ok(status1, "Added 1 to hash"); + psFree(stuff1); // Drop reference + psMemId last = psMemGetId(); // Last memory I.D. + bool status2 = psHashAdd(hash, "stuff", stuff2); + ok(status2, "Added 2 to hash"); + psFree(stuff2); // Drop reference + int numLeaks = psMemCheckLeaks(last, NULL, NULL, false); // Number of leaks + ok(numLeaks == 0, "No leaks."); + psFree(hash); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } - bool status1 = psHashAdd(hash, "stuff", stuff1); - ok(status1, "Added 1 to hash"); - psFree(stuff1); // Drop reference - - psMemId last = psMemGetId(); // Last memory I.D. - bool status2 = psHashAdd(hash, "stuff", stuff2); - ok(status2, "Added 2 to hash"); - psFree(stuff2); // Drop reference - - int numLeaks = psMemCheckLeaks(last, NULL, NULL, false); // Number of leaks - ok(numLeaks == 0, "No leaks."); - - psFree(hash); - - done(); } Index: trunk/psLib/test/types/tap_psListIterator.c =================================================================== --- trunk/psLib/test/types/tap_psListIterator.c (revision 12777) +++ trunk/psLib/test/types/tap_psListIterator.c (revision 12781) @@ -2,5 +2,4 @@ #include #include - #include "tap.h" #include "pstap.h" @@ -72,10 +71,12 @@ int main (void) { - plan_tests(66); + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(72); note("psListIterator tests"); - - { - note("Forwards"); + // Forwards + { + psMemId id = psMemGetId(); psList *list = listGenerate(); psListIterator *iter = psListIteratorAlloc(list, PS_LIST_HEAD, false); @@ -94,8 +95,11 @@ psFree(iter); psFree(list); - } - - { - note("Backwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // Backwards + { + psMemId id = psMemGetId(); psList *list = listGenerate(); psListIterator *iter = psListIteratorAlloc(list, PS_LIST_TAIL, NULL); @@ -114,8 +118,11 @@ psFree(iter); psFree(list); - } - - { - note("Jumping in halfway through (using allocator), forwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // Jumping in halfway through (using allocator), forwards + { + psMemId id = psMemGetId(); psList *list = listGenerate(); psListIterator *iter = psListIteratorAlloc(list, 3, NULL); @@ -131,8 +138,11 @@ psFree(iter); psFree(list); - } - - { - note("Jumping in halfway through (using allocator), backwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // Jumping in halfway through (using allocator), backwards + { + psMemId id = psMemGetId(); psList *list = listGenerate(); psListIterator *iter = psListIteratorAlloc(list, -4, NULL); @@ -148,8 +158,11 @@ psFree(iter); psFree(list); - } - - { - note("Jumping in halfway through (using set), forwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // Jumping in halfway through (using set), forwards + { + psMemId id = psMemGetId(); psList *list = listGenerate(); psListIterator *iter = psListIteratorAlloc(list, PS_LIST_HEAD, NULL); @@ -166,8 +179,11 @@ psFree(iter); psFree(list); - } - - { - note("Jumping in halfway through (using set), backwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // Jumping in halfway through (using set), backwards + { + psMemId id = psMemGetId(); psList *list = listGenerate(); psListIterator *iter = psListIteratorAlloc(list, PS_LIST_HEAD, NULL); @@ -184,6 +200,5 @@ psFree(iter); psFree(list); - } - - return exit_status(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } } Index: trunk/psLib/test/types/tap_psList_all.c =================================================================== --- trunk/psLib/test/types/tap_psList_all.c (revision 12777) +++ trunk/psLib/test/types/tap_psList_all.c (revision 12781) @@ -13,222 +13,207 @@ * */ - #include #include - #include "tap.h" #include "pstap.h" -void testListCreate(void); -void testListManip(void); -void testListConvertSort(void); - int main(void) { - plan_tests(60); - - note("Tests for psList Functions"); - - testListCreate(); - testListManip(); - testListConvertSort(); - - done(); -} - -void testListCreate(void) -{ - note(" >>>Test 1: psList Creation Fxns"); - psList *noList = NULL; - psListIterator *noIter = NULL; - psList *list = psListAlloc(NULL); - psMetadata *md = psMetadataAlloc(); - psListIterator *iter1 = NULL; - psListIterator *iter2 = NULL; - - //Tests for psListAlloc & psMemCheckList - //Return empty list for NULL data input. + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(62); + + // Test 1: psList Creation Fxns"); + // testListCreate(void) { - noList = psListAlloc(NULL); - ok( psListLength(noList) == 0 && psMemCheckList(noList), - "psListAlloc: return empty list for NULL data input."); - } - //Return allocated list for non-NULL data input. - psFree(noList); - { - - noList = psListAlloc(md); - ok( psListLength(noList) == 1, + psMemId id = psMemGetId(); + psList *noList = NULL; + psListIterator *noIter = NULL; + psList *list = psListAlloc(NULL); + psMetadata *md = psMetadataAlloc(); + psListIterator *iter1 = NULL; + psListIterator *iter2 = NULL; + + //Tests for psListAlloc & psMemCheckList + //Return empty list for NULL data input. + { + noList = psListAlloc(NULL); + ok( psListLength(noList) == 0 && psMemCheckList(noList), + "psListAlloc: return empty list for NULL data input."); + } + //Return allocated list for non-NULL data input. + psFree(noList); + { + noList = psListAlloc(md); + ok( psListLength(noList) == 1, "psListAlloc: return correct list for non-NULL data input."); - } - //Make sure psMemCheckList works correctly - return false - { - int j = 2; - ok( !psMemCheckList(&j), - "psMemCheckList: return false for non-List input."); - } - - //Tests for ListIteratorAlloc - //Return NULL for attempt to allocate iterator with NULL list input - { - noIter = psListIteratorAlloc(NULL, 0, true); - ok( noIter == NULL, - "psListIteratorAlloc: return false for NULL data input."); - } - //Attempt to Allocate a psListIterator with out-of-range location - { - iter1 = psListIteratorAlloc(noList, 10, false); - ok( iter1 == NULL, - "psListIteratorAlloc: return NULL for out-of-range location."); - } - //Return valid iterator for valid inputs - { - iter1 = psListIteratorAlloc(noList, 0, true); - ok( iter1 != NULL, - "psListIteratorAlloc: return valid iterator for valid inputs."); - } - - //Tests For ListAdd Fxns - //Return false for NULL list input - { - ok( !psListAdd(NULL, 0, md), - "psListAdd: return false for NULL list input."); - } - //Return false for NULL data input - { - ok( !psListAdd(list, 0, NULL), - "psListAdd: return false for NULL data input."); - } - //Return false for list with NULL data - { - psFree(list->iterators->data[0]); - list->iterators->data[0] = NULL; - ok( !psListAdd(list, 0, md), - "psListAdd: return false for list with NULL iterators."); - psFree(list); - list = psListAlloc(md); - } - //Return true for valid inputs - tail location - { - ok( psListAdd(list, 2, md), - "psListAdd: return true for valid inputs - Tail Location."); - } - //Return true for valid inputs - head location - { - ok( psListAdd(list, 0, md), - "psListAdd: return true for valid inputs - head Location."); - } - - //psListAddAfter Tests - //psListAddAfter - Return false for NULL data input - { - ok( !psListAddAfter(iter1, NULL), - "psListAddAfter: return false for NULL data input."); - } - //psListAddAfter - Return false for NULL iterator input - { - ok( !psListAddAfter(NULL, md), - "psListAddAfter: return false for NULL iterator input."); - } - //psListAddAfter - Return false for non-mutable iterator input - { - iter1->mutable = false; - ok( !psListAddAfter(iter1, md), - "psListAddAfter: return false for non-mutable iterator input."); - iter1->mutable = true; - psFree(iter1); - } - //psListAddAfter - Return false for iterator with NULL cursor - psList *newList = psListAlloc(md); - iter1 = psListIteratorAlloc(newList, 0, true); - psListElem *cursor = iter1->cursor; - { - iter1->cursor = NULL; - ok( !psListAddAfter(iter1, md), - "psListAddAfter: return false for iterator with headptr but no cursor."); - iter1->cursor = cursor; - } - //Set the iterator to a middle element, then add after - { - iter2 = psListIteratorAlloc(list, 1, true); - ok( psListAddAfter(iter2, md), - "psListAddAfter: return true for adding a list element to the middle."); - } - //Set the iterator to the head element, then add after a wrong index. return true - { - if (!psListIteratorSet(iter2, PS_LIST_HEAD) ) - printf("\nerror in set\n\n"); - ((psListIterator*)(iter2->list->iterators->data[0]))->index = 10; - ok( psListAddAfter(iter2, md), - "psListAddAfter: return true for adding a list element to the head."); - } - //Return true for adding to an empty list - psFree(noList); - noList = psListAlloc(NULL); - psListIterator *iter3 = psListIteratorAlloc(noList, 0, true); - { - ok( psListAddAfter(iter3, md), - "psListAddAfter: return true for adding to an empty list."); - } - - //psListAddBefore Tests - //psListAddBefore - Return false for NULL data input - { - ok( !psListAddBefore(iter1, NULL), - "psListAddBefore: return false for NULL data input."); - } - //psListAddBefore - Return false for NULL iterator input - { - ok( !psListAddBefore(NULL, md), - "psListAddBefore: return false for NULL iterator input."); - } - //psListAddBefore - Return false for non-mutable iterator input - { - iter1->mutable = false; - ok( !psListAddBefore(iter1, md), - "psListAddBefore: return false for non-mutable iterator input."); - iter1->mutable = true; - } - { - cursor = iter1->cursor; - iter1->cursor = NULL; - ok( !psListAddBefore(iter1, md), - "psListAddBefore: return false for iterator with headptr but no cursor."); - iter1->cursor = cursor; - } - //Add before a middle list element - { - psListIteratorSet(iter2, -2); - ok( psListAddBefore(iter2, md), - "psListAddBefore: return true for adding a list element to the middle."); - } - //Set the iterator to the 2nd element, then add after a wrong index. return true - { - skip_start( !psListIteratorSet(iter2, 1), 1, - "Skipping 1 tests because psListIteratorSet failed"); - ((psListIterator*)(iter2->list->iterators->data[0]))->index = 10; - ok( psListAddBefore(iter2, md), - "psListAddBefore: return true for adding a list element to the head."); - skip_end(); - } - //Return true for adding to an empty list - { + } + //Make sure psMemCheckList works correctly - return false + { + int j = 2; + ok( !psMemCheckList(&j), + "psMemCheckList: return false for non-List input."); + } + + //Tests for ListIteratorAlloc + //Return NULL for attempt to allocate iterator with NULL list input + { + noIter = psListIteratorAlloc(NULL, 0, true); + ok( noIter == NULL, + "psListIteratorAlloc: return false for NULL data input."); + } + //Attempt to Allocate a psListIterator with out-of-range location + { + iter1 = psListIteratorAlloc(noList, 10, false); + ok( iter1 == NULL, + "psListIteratorAlloc: return NULL for out-of-range location."); + } + //Return valid iterator for valid inputs + { + iter1 = psListIteratorAlloc(noList, 0, true); + ok( iter1 != NULL, + "psListIteratorAlloc: return valid iterator for valid inputs."); + } + + //Tests For ListAdd Fxns + //Return false for NULL list input + { + ok( !psListAdd(NULL, 0, md), + "psListAdd: return false for NULL list input."); + } + //Return false for NULL data input + { + ok( !psListAdd(list, 0, NULL), + "psListAdd: return false for NULL data input."); + } + //Return false for list with NULL data + { + psFree(list->iterators->data[0]); + list->iterators->data[0] = NULL; + ok( !psListAdd(list, 0, md), + "psListAdd: return false for list with NULL iterators."); + psFree(list); + list = psListAlloc(md); + } + //Return true for valid inputs - tail location + { + ok( psListAdd(list, 2, md), + "psListAdd: return true for valid inputs - Tail Location."); + } + //Return true for valid inputs - head location + { + ok( psListAdd(list, 0, md), + "psListAdd: return true for valid inputs - head Location."); + } + + //psListAddAfter Tests + //psListAddAfter - Return false for NULL data input + { + ok( !psListAddAfter(iter1, NULL), + "psListAddAfter: return false for NULL data input."); + } + //psListAddAfter - Return false for NULL iterator input + { + ok( !psListAddAfter(NULL, md), + "psListAddAfter: return false for NULL iterator input."); + } + //psListAddAfter - Return false for non-mutable iterator input + { + iter1->mutable = false; + ok( !psListAddAfter(iter1, md), + "psListAddAfter: return false for non-mutable iterator input."); + iter1->mutable = true; + psFree(iter1); + } + //psListAddAfter - Return false for iterator with NULL cursor + psList *newList = psListAlloc(md); + iter1 = psListIteratorAlloc(newList, 0, true); + psListElem *cursor = iter1->cursor; + { + iter1->cursor = NULL; + ok( !psListAddAfter(iter1, md), + "psListAddAfter: return false for iterator with headptr but no cursor."); + iter1->cursor = cursor; + } + //Set the iterator to a middle element, then add after + { + iter2 = psListIteratorAlloc(list, 1, true); + ok( psListAddAfter(iter2, md), + "psListAddAfter: return true for adding a list element to the middle."); + } + //Set the iterator to the head element, then add after a wrong index. return true + { + if (!psListIteratorSet(iter2, PS_LIST_HEAD) ) + printf("\nerror in set\n\n"); + ((psListIterator*)(iter2->list->iterators->data[0]))->index = 10; + ok( psListAddAfter(iter2, md), + "psListAddAfter: return true for adding a list element to the head."); + } + //Return true for adding to an empty list psFree(noList); noList = psListAlloc(NULL); - iter3 = psListIteratorAlloc(noList, 0, true); - psFree(iter3); - ok( psListAddBefore(iter3, md), - "psListAddBefore: return true for adding to an empty list."); - } - - //Check the length of a NULL list - { - psList *emptyList = NULL; - ok( psListLength(emptyList) == -1, - "psListLength: return -1 for NULL input psList."); - } - - //Check for Memory leaks - { + psListIterator *iter3 = psListIteratorAlloc(noList, 0, true); + { + ok( psListAddAfter(iter3, md), + "psListAddAfter: return true for adding to an empty list."); + } + + //psListAddBefore Tests + //psListAddBefore - Return false for NULL data input + { + ok( !psListAddBefore(iter1, NULL), + "psListAddBefore: return false for NULL data input."); + } + //psListAddBefore - Return false for NULL iterator input + { + ok( !psListAddBefore(NULL, md), + "psListAddBefore: return false for NULL iterator input."); + } + //psListAddBefore - Return false for non-mutable iterator input + { + iter1->mutable = false; + ok( !psListAddBefore(iter1, md), + "psListAddBefore: return false for non-mutable iterator input."); + iter1->mutable = true; + } + { + cursor = iter1->cursor; + iter1->cursor = NULL; + ok( !psListAddBefore(iter1, md), + "psListAddBefore: return false for iterator with headptr but no cursor."); + iter1->cursor = cursor; + } + //Add before a middle list element + { + psListIteratorSet(iter2, -2); + ok( psListAddBefore(iter2, md), + "psListAddBefore: return true for adding a list element to the middle."); + } + //Set the iterator to the 2nd element, then add after a wrong index. return true + { + skip_start( !psListIteratorSet(iter2, 1), 1, + "Skipping 1 tests because psListIteratorSet failed"); + ((psListIterator*)(iter2->list->iterators->data[0]))->index = 10; + ok( psListAddBefore(iter2, md), + "psListAddBefore: return true for adding a list element to the head."); + skip_end(); + } + //Return true for adding to an empty list + { + psFree(noList); + noList = psListAlloc(NULL); + iter3 = psListIteratorAlloc(noList, 0, true); + psFree(iter3); + ok( psListAddBefore(iter3, md), + "psListAddBefore: return true for adding to an empty list."); + } + + //Check the length of a NULL list + { + psList *emptyList = NULL; + ok( psListLength(emptyList) == -1, + "psListLength: return -1 for NULL input psList."); + } + psFree(iter2); psFree(list); @@ -237,182 +222,181 @@ psFree(md); psFree(noList); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } -} - -void testListManip(void) -{ - note(" >>>Test 2: psList Manipulation Fxns"); - psMetadata *md = psMetadataAlloc(); - psList *emptyList = psListAlloc(NULL); - psList *list = psListAlloc(md); - psSphere *sphere = psSphereAlloc(); - psCube *cube = psCubeAlloc(); - psArray *array = psArrayAlloc(0); - psListAdd(list, PS_LIST_TAIL, sphere); - psListAdd(list, PS_LIST_TAIL, cube); - psListAdd(list, PS_LIST_TAIL, array); - psListIterator *emptyIter = psListIteratorAlloc(emptyList, 0, true); - psListIterator *iter1 = psListIteratorAlloc(list, PS_LIST_TAIL, true); - - //Tests for psListGet - //Return NULL for NULL list input + + + // testListManip() + // psList Manipulation Fxns"); { - psMetadata *out = NULL; - out = (psMetadata*)psListGet(NULL, PS_LIST_HEAD); - ok( out == NULL, - "psListGet: return NULL for NULL list input."); - } - //Return NULL for empty list - { - psMetadata *out = NULL; - out = (psMetadata*)psListGet(emptyList, PS_LIST_HEAD); - ok( out == NULL, - "psListGet: return NULL for empty list."); - } - //Return NULL for out-of-range location - { - psMetadata *out = NULL; - out = (psMetadata*)psListGet(list, -10); - ok( out == NULL, - "psListGet: return NULL for out-of-range location."); - } - //Return correct head item for valid inputs - { - psMetadata *out = NULL; - out = (psMetadata*)psListGet(list, PS_LIST_HEAD); - ok( out != NULL && psMemCheckMetadata(out), - "psListGet: return correct head item for valid inputs."); - } - - //Tests for psListGetAndIncrement - //Return NULL for NULL iterator input - { - psMetadata *out = NULL; - out = (psMetadata*)psListGetAndIncrement(NULL); - ok( out == NULL, - "psListGetAndIncrement: return NULL for NULL iterator input."); - } - //Return NULL for empty iterator with offend = false - { - psMetadata *out = NULL; - out = (psMetadata*)psListGetAndIncrement(emptyIter); - ok( out == NULL, - "psListGetAndIncrement: return NULL for empty iterator input."); - } - //Return NULL for empty iterator with offend = true - { - emptyIter->offEnd = true; - psMetadata *out = NULL; - out = (psMetadata*)psListGetAndIncrement(emptyIter); - ok( out == NULL, - "psListGetAndIncrement: return NULL for empty iterator input."); - emptyIter->offEnd = false; - } - //Return correct tail item for valid inputs - { - psArray *out = NULL; - out = (psArray*)psListGetAndIncrement(iter1); - ok( out != NULL && psMemCheckArray(out), - "psListGetAndIncrement: return correct tail item for valid inputs."); - } - - //Tests for psListGetAndDecrement - //Return NULL for NULL iterator input - { - psMetadata *out = NULL; - out = (psMetadata*)psListGetAndDecrement(NULL); - ok( out == NULL, - "psListGetAndDecrement: return NULL for NULL iterator input."); - } - //Return NULL for empty iterator with offend = false - { - psMetadata *out = NULL; - out = (psMetadata*)psListGetAndDecrement(emptyIter); - ok( out == NULL, - "psListGetAndDecrement: return NULL for empty iterator input."); - } - //Return NULL for empty iterator with offend = true - { - emptyIter->offEnd = true; - psMetadata *out = NULL; - out = (psMetadata*)psListGetAndDecrement(emptyIter); - ok( out == NULL, - "psListGetAndDecrement: return NULL for empty iterator input."); - emptyIter->offEnd = false; - } - //Return correct tail item for valid inputs - { - psArray *out = NULL; - skip_start( !psListIteratorSet(iter1, PS_LIST_TAIL), 1, - "Skipping 1 tests because psListIteratorSet failed"); - out = (psArray*)psListGetAndDecrement(iter1); - ok( out != NULL && psMemCheckArray(out), - "psListGetAndDecrement: return correct tail item for valid inputs."); - skip_end(); - } - - //Tests for psListRemove - //Return false for NULL list input - { - ok( !psListRemove(NULL, PS_LIST_HEAD), - "psListRemove: return false for NULL list input."); - } - //Return false for invalid location - { - ok( !psListRemove(list, -10), - "psListRemove: return false for invalid location."); - } - //Return false for empty list - { - ok( !psListRemove(emptyList, PS_LIST_HEAD), - "psListRemove: return false for remove from empty list."); - } - //Return true for remove from middle of list - { - ok( psListRemove(list, 2) && list->n == 3, - "psListRemove: return true for remove from middle of list."); - } - //Return true for remove from head of list - { - ok( psListRemove(list, PS_LIST_HEAD) && list->n ==2, - "psListRemove: return true for remove from head of list."); - } - //Return true for remove from tail of list - { - ok( psListRemove(list, PS_LIST_TAIL) && list->n == 1, - "psListRemove: return true for remove from tail of list."); - } - //Tests for psListRemoveData - //Return false for NULL list input - { - ok( !psListRemoveData(NULL, md), - "psListRemoveData: return false for NULL list input."); - } - //Return false for NULL data input - { - ok( !psListRemoveData(list, NULL), - "psListRemoveData: return false for NULL data input."); - } - //Return false for non-matching data - { - ok( !psListRemoveData(list, md), - "psListRemoveData: return false for non-matching data."); - } - //Return false for trying to remove from an empty list - { - ok( !psListRemoveData(emptyList, md), - "psListRemoveData: return false for trying to remove from an empty list."); - } - //Return true for remove of valid data - psListAdd(list, PS_LIST_HEAD, cube); - psListAdd(list, PS_LIST_HEAD, array); - { - ok( psListRemoveData(list, sphere), - "psListRemoveData: return true for remove of valid data."); - } - - //Check for Memory leaks - { + psMemId id = psMemGetId(); + psMetadata *md = psMetadataAlloc(); + psList *emptyList = psListAlloc(NULL); + psList *list = psListAlloc(md); + psSphere *sphere = psSphereAlloc(); + psCube *cube = psCubeAlloc(); + psArray *array = psArrayAlloc(0); + psListAdd(list, PS_LIST_TAIL, sphere); + psListAdd(list, PS_LIST_TAIL, cube); + psListAdd(list, PS_LIST_TAIL, array); + psListIterator *emptyIter = psListIteratorAlloc(emptyList, 0, true); + psListIterator *iter1 = psListIteratorAlloc(list, PS_LIST_TAIL, true); + + //Tests for psListGet + //Return NULL for NULL list input + { + psMetadata *out = NULL; + out = (psMetadata*)psListGet(NULL, PS_LIST_HEAD); + ok( out == NULL, + "psListGet: return NULL for NULL list input."); + } + //Return NULL for empty list + { + psMetadata *out = NULL; + out = (psMetadata*)psListGet(emptyList, PS_LIST_HEAD); + ok( out == NULL, + "psListGet: return NULL for empty list."); + } + //Return NULL for out-of-range location + { + psMetadata *out = NULL; + out = (psMetadata*)psListGet(list, -10); + ok( out == NULL, + "psListGet: return NULL for out-of-range location."); + } + //Return correct head item for valid inputs + { + psMetadata *out = NULL; + out = (psMetadata*)psListGet(list, PS_LIST_HEAD); + ok( out != NULL && psMemCheckMetadata(out), + "psListGet: return correct head item for valid inputs."); + } + + //Tests for psListGetAndIncrement + //Return NULL for NULL iterator input + { + psMetadata *out = NULL; + out = (psMetadata*)psListGetAndIncrement(NULL); + ok( out == NULL, + "psListGetAndIncrement: return NULL for NULL iterator input."); + } + //Return NULL for empty iterator with offend = false + { + psMetadata *out = NULL; + out = (psMetadata*)psListGetAndIncrement(emptyIter); + ok( out == NULL, + "psListGetAndIncrement: return NULL for empty iterator input."); + } + //Return NULL for empty iterator with offend = true + { + emptyIter->offEnd = true; + psMetadata *out = NULL; + out = (psMetadata*)psListGetAndIncrement(emptyIter); + ok( out == NULL, + "psListGetAndIncrement: return NULL for empty iterator input."); + emptyIter->offEnd = false; + } + //Return correct tail item for valid inputs + { + psArray *out = NULL; + out = (psArray*)psListGetAndIncrement(iter1); + ok( out != NULL && psMemCheckArray(out), + "psListGetAndIncrement: return correct tail item for valid inputs."); + } + + //Tests for psListGetAndDecrement + //Return NULL for NULL iterator input + { + psMetadata *out = NULL; + out = (psMetadata*)psListGetAndDecrement(NULL); + ok( out == NULL, + "psListGetAndDecrement: return NULL for NULL iterator input."); + } + //Return NULL for empty iterator with offend = false + { + psMetadata *out = NULL; + out = (psMetadata*)psListGetAndDecrement(emptyIter); + ok( out == NULL, + "psListGetAndDecrement: return NULL for empty iterator input."); + } + //Return NULL for empty iterator with offend = true + { + emptyIter->offEnd = true; + psMetadata *out = NULL; + out = (psMetadata*)psListGetAndDecrement(emptyIter); + ok( out == NULL, + "psListGetAndDecrement: return NULL for empty iterator input."); + emptyIter->offEnd = false; + } + //Return correct tail item for valid inputs + { + psArray *out = NULL; + skip_start( !psListIteratorSet(iter1, PS_LIST_TAIL), 1, + "Skipping 1 tests because psListIteratorSet failed"); + out = (psArray*)psListGetAndDecrement(iter1); + ok( out != NULL && psMemCheckArray(out), + "psListGetAndDecrement: return correct tail item for valid inputs."); + skip_end(); + } + + //Tests for psListRemove + //Return false for NULL list input + { + ok( !psListRemove(NULL, PS_LIST_HEAD), + "psListRemove: return false for NULL list input."); + } + //Return false for invalid location + { + ok( !psListRemove(list, -10), + "psListRemove: return false for invalid location."); + } + //Return false for empty list + { + ok( !psListRemove(emptyList, PS_LIST_HEAD), + "psListRemove: return false for remove from empty list."); + } + //Return true for remove from middle of list + { + ok( psListRemove(list, 2) && list->n == 3, + "psListRemove: return true for remove from middle of list."); + } + //Return true for remove from head of list + { + ok( psListRemove(list, PS_LIST_HEAD) && list->n ==2, + "psListRemove: return true for remove from head of list."); + } + //Return true for remove from tail of list + { + ok( psListRemove(list, PS_LIST_TAIL) && list->n == 1, + "psListRemove: return true for remove from tail of list."); + } + //Tests for psListRemoveData + //Return false for NULL list input + { + ok( !psListRemoveData(NULL, md), + "psListRemoveData: return false for NULL list input."); + } + //Return false for NULL data input + { + ok( !psListRemoveData(list, NULL), + "psListRemoveData: return false for NULL data input."); + } + //Return false for non-matching data + { + ok( !psListRemoveData(list, md), + "psListRemoveData: return false for non-matching data."); + } + //Return false for trying to remove from an empty list + { + ok( !psListRemoveData(emptyList, md), + "psListRemoveData: return false for trying to remove from an empty list."); + } + //Return true for remove of valid data + psListAdd(list, PS_LIST_HEAD, cube); + psListAdd(list, PS_LIST_HEAD, array); + { + ok( psListRemoveData(list, sphere), + "psListRemoveData: return true for remove of valid data."); + } + psFree(md); psFree(emptyList); @@ -421,100 +405,98 @@ psFree(cube); psFree(array); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } -} - -void testListConvertSort(void) -{ - note(" >>>Test 3: psList Conversion and Sorting Fxns"); - psList *emptyList = psListAlloc(NULL); - psS32 *s1 = (psS32*)psAlloc(sizeof(psS32)); - *s1 = 2; - psS32 *s2 = (psS32*)psAlloc(sizeof(psS32)); - *s2 = 3; - psS32 *s3 = (psS32*)psAlloc(sizeof(psS32)); - *s3 = 1; - psList *list = psListAlloc(s1); - psListAdd(list, PS_LIST_TAIL, s2); - psListAdd(list, PS_LIST_TAIL, s3); - psArray *array = NULL; - psArray *emptyArray = psArrayAlloc(0); - psList *out = NULL; - - //Tests for psListToArray - //Return NULL for NULL list input + + + // testListConvertSort() + // psList Conversion and Sorting Fxns"); { - array = psListToArray(NULL); - ok( array == NULL, - "psListToArray: return NULL for NULL list input."); - } - //Return empty array for empty list input - { - array = psListToArray(emptyList); - ok( array->n == 0 && psMemCheckArray(array), - "psListToArray: return empty array for empty list input."); - psFree(array); - array = NULL; - } - //Return correct array for valid list input - { - array = psListToArray(list); - ok( array->n == 3 && *((psS32*)(array->data[0])) == 2, - "psListToArray: return correct array for valid list input."); - } - - //Tests for psArrayToList - //Return NULL for NULL array input - { - out = psArrayToList(NULL); - ok( out == NULL, - "psArrayToList: return NULL for NULL array input."); - } - //Return empty list for empty array input - { - out = psArrayToList(emptyArray); - ok( out->n == 0 && psMemCheckList(out), - "psArrayToList: return empty list for empty array input."); - psFree(out); - out = NULL; - } - //Return correct list for valid array input - { - out = psArrayToList(array); - ok( out->n == 3 && *((psS32*)psListGet(out, PS_LIST_HEAD)) == 2, - "psArrayToList: return correct list for valid array input."); - } - - //Tests for psListSort - //Return NULL for NULL list input - { - psList *none = NULL; - none = psListSort(none, (psComparePtrFunc)psCompareDescendingS32Ptr); - ok( none == NULL, - "psListSort: return NULL for NULL list input."); - } - //Return empty list for empty list input - { - emptyList = psListSort(emptyList, (psComparePtrFunc)psCompareDescendingS32Ptr); - ok( emptyList != NULL, - "psListSort: return empty list for empty list input."); - } - //Return properly sorted list for valid inputs - { - list = psListSort(list, (psComparePtrFunc)psCompareS32Ptr); - ok( *((psS32*)psListGet(list, 0)) == 1 && *((psS32*)psListGet(list, 1)) == 2, - "psListSort: return properly sorted list for valid inputs."); - } - //Return unchanged list for NULL psComparePtrFunc - { - psList *tempList = NULL; - tempList = psListSort(list, NULL); - ok( tempList == NULL, - "psListSort: return NULL for NULL psComparePtrFunc."); - } - - - //Check for Memory leaks - { + psMemId id = psMemGetId(); + psList *emptyList = psListAlloc(NULL); + psS32 *s1 = (psS32*)psAlloc(sizeof(psS32)); + *s1 = 2; + psS32 *s2 = (psS32*)psAlloc(sizeof(psS32)); + *s2 = 3; + psS32 *s3 = (psS32*)psAlloc(sizeof(psS32)); + *s3 = 1; + psList *list = psListAlloc(s1); + psListAdd(list, PS_LIST_TAIL, s2); + psListAdd(list, PS_LIST_TAIL, s3); + psArray *array = NULL; + psArray *emptyArray = psArrayAlloc(0); + psList *out = NULL; + + //Tests for psListToArray + //Return NULL for NULL list input + { + array = psListToArray(NULL); + ok( array == NULL, + "psListToArray: return NULL for NULL list input."); + } + //Return empty array for empty list input + { + array = psListToArray(emptyList); + ok( array->n == 0 && psMemCheckArray(array), + "psListToArray: return empty array for empty list input."); + psFree(array); + array = NULL; + } + //Return correct array for valid list input + { + array = psListToArray(list); + ok( array->n == 3 && *((psS32*)(array->data[0])) == 2, + "psListToArray: return correct array for valid list input."); + } + + //Tests for psArrayToList + //Return NULL for NULL array input + { + out = psArrayToList(NULL); + ok( out == NULL, + "psArrayToList: return NULL for NULL array input."); + } + //Return empty list for empty array input + { + out = psArrayToList(emptyArray); + ok( out->n == 0 && psMemCheckList(out), + "psArrayToList: return empty list for empty array input."); + psFree(out); + out = NULL; + } + //Return correct list for valid array input + { + out = psArrayToList(array); + ok( out->n == 3 && *((psS32*)psListGet(out, PS_LIST_HEAD)) == 2, + "psArrayToList: return correct list for valid array input."); + } + + //Tests for psListSort + //Return NULL for NULL list input + { + psList *none = NULL; + none = psListSort(none, (psComparePtrFunc)psCompareDescendingS32Ptr); + ok( none == NULL, + "psListSort: return NULL for NULL list input."); + } + //Return empty list for empty list input + { + emptyList = psListSort(emptyList, (psComparePtrFunc)psCompareDescendingS32Ptr); + ok( emptyList != NULL, + "psListSort: return empty list for empty list input."); + } + //Return properly sorted list for valid inputs + { + list = psListSort(list, (psComparePtrFunc)psCompareS32Ptr); + ok( *((psS32*)psListGet(list, 0)) == 1 && *((psS32*)psListGet(list, 1)) == 2, + "psListSort: return properly sorted list for valid inputs."); + } + //Return unchanged list for NULL psComparePtrFunc + { + psList *tempList = NULL; + tempList = psListSort(list, NULL); + ok( tempList == NULL, + "psListSort: return NULL for NULL psComparePtrFunc."); + } + psFree(array); psFree(out); @@ -525,6 +507,5 @@ psFree(s2); psFree(s3); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - } Index: trunk/psLib/test/types/tap_psLookupTable_all.c =================================================================== --- trunk/psLib/test/types/tap_psLookupTable_all.c (revision 12777) +++ trunk/psLib/test/types/tap_psLookupTable_all.c (revision 12781) @@ -8,17 +8,15 @@ * Author: dRob , (C) 2006 * + * XXX: Must add correct build directories. This file reads a file in the + * types/ subdirectory and will not execute directly if not run from psLib/test + * * Copyright: See COPYING file that comes with this distribution * */ - #include #include - #include "tap.h" #include "pstap.h" -void testLookupTableAlloc(void); -void testLookupTableReadImport(void); -void testLookupTableInterpolates(void); int main(void) @@ -26,277 +24,266 @@ psLogSetFormat("HLNM"); psLogSetLevel(PS_LOG_INFO); - plan_tests(29); - - // note("Tests for psLookupTable Functions"); - - testLookupTableAlloc(); - testLookupTableReadImport(); - testLookupTableInterpolates(); - - done(); -} - -void testLookupTableAlloc(void) -{ - // note(" >>>Test 1: psLookupTableAlloc & psMemCheckLookupTable Fxns"); - - psLookupTable *lt = NULL; - - //Tests for psLookupTableAlloc - //Return NULL for NULL filename input + plan_tests(31); + + // Tests for psLookupTable Functions + + + // testLookupTableAlloc() + // psLookupTableAlloc & psMemCheckLookupTable Fxns { - lt = psLookupTableAlloc(NULL, "\%f \%lf \%d \%ld", 10); - ok( lt == NULL, - "psLookupTableAlloc: return NULL for NULL filename input."); + psMemId id = psMemGetId(); + psLookupTable *lt = NULL; + //Tests for psLookupTableAlloc + //Return NULL for NULL filename input + { + lt = psLookupTableAlloc(NULL, "\%f \%lf \%d \%ld", 10); + ok( lt == NULL, + "psLookupTableAlloc: return NULL for NULL filename input."); + } + //Return NULL for NULL format input + { + lt = psLookupTableAlloc("table.dat", NULL, 10); + ok( lt == NULL, + "psLookupTableAlloc: return NULL for NULL format input."); + } + //Return properly allocated lookupTable for valid inputs + { + lt = psLookupTableAlloc("table.dat", "\%f \%lf \%d \%ld", 10); + ok( lt != NULL && psMemCheckLookupTable(lt), + "psLookupTableAlloc: " + "return properly allocated lookupTable for valid inputs."); + } + + //Tests for psMemCheckArray + //Make sure psMemCheckArray works correctly - return false + { + int j = 2; + ok( !psMemCheckLookupTable(&j), + "psMemCheckLookupTable: return false for non-LookupTable input."); + } + + psFree(lt); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - //Return NULL for NULL format input + + + // testLookupTableReadImport() + // psVectorsReadFromFile, psLookupTableImport, psLookupTableRead Fxns"); { - lt = psLookupTableAlloc("table.dat", NULL, 10); - ok( lt == NULL, - "psLookupTableAlloc: return NULL for NULL format input."); - } - //Return properly allocated lookupTable for valid inputs - { - lt = psLookupTableAlloc("table.dat", "\%f \%lf \%d \%ld", 10); - ok( lt != NULL && psMemCheckLookupTable(lt), - "psLookupTableAlloc: " - "return properly allocated lookupTable for valid inputs."); - } - - //Tests for psMemCheckArray - //Make sure psMemCheckArray works correctly - return false - { - int j = 2; - ok( !psMemCheckLookupTable(&j), - "psMemCheckLookupTable: return false for non-LookupTable input."); - } - - //Check for Memory leaks - { - psFree(lt); - checkMem(); - } - -} - -void testLookupTableReadImport(void) -{ - // diag(" >>>Test 2: psVectorsReadFromFile, psLookupTableImport, psLookupTableRead Fxns"); - psArray *outVec = NULL; - psArray *vectors = NULL; - psLookupTable* table1 = NULL; - long numRows = 0; - - //Tests for psVectorReadFromFile - // Attempt to read from NULL filename input - { - outVec = psVectorsReadFromFile(NULL, - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); - ok( outVec == NULL, - "psVectorsReadFromFile: return NULL for NULL filename input."); - } - // Attempt to read from NULL format input - { - outVec = psVectorsReadFromFile("table.dat", NULL); - ok( outVec == NULL, - "psVectorsReadFromFile: return NULL for NULL format input."); - } - // Attempt to read from invalid filename input - { - outVec = psVectorsReadFromFile("tableS32.dat", - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); - ok( outVec == NULL, - "psVectorsReadFromFile: return NULL for invalid filename input."); - } - // Attempt to read from invalid format input - { - outVec = psVectorsReadFromFile("table.dat", "\%s"); - ok( outVec == NULL, - "psVectorsReadFromFile: return NULL for invalid format input."); - } - // Attempt to read from table containing invalid entry - F32 - { - outVec = psVectorsReadFromFile("tableF32_err.dat", - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); - ok( outVec == NULL, - "psVectorsReadFromFile: return NULL for table containing invalid entry."); - } - // Attempt to read from table containing invalid entry - F64 - { - outVec = psVectorsReadFromFile("tableF64_err.dat", - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); - ok( outVec == NULL, - "psVectorsReadFromFile: return NULL for table containing invalid entry."); - } - // Attempt to read from table containing invalid entry - S32 - { - outVec = psVectorsReadFromFile("tableS32_err.dat", - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); - ok( outVec == NULL, - "psVectorsReadFromFile: return NULL for table containing invalid entry."); - } - // Attempt to read from table containing invalid entry - S64 - { - outVec = psVectorsReadFromFile("tableS64_err.dat", - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); - ok( outVec == NULL, - "psVectorsReadFromFile: return NULL for table containing invalid entry."); - } - // Attempt to read from empty table - { - outVec = psVectorsReadFromFile("tableF32_2.dat", - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); - ok( outVec == NULL, - "psVectorsReadFromFile: return NULL for empty table."); - } - // Attempt to read from file with partially constructed row - { - outVec = psVectorsReadFromFile("table3.dat", - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); - ok( outVec == NULL, - "psVectorsReadFromFile: return NULL for table with partially" - " constructed row."); - } - //Attempt to read with valid inputs - { - outVec = psVectorsReadFromFile("types/table.dat", - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); - ok( outVec != NULL && outVec->n == 9 && - ((psVector*)(outVec->data[6]))->data.S32[1] == -8, - "psVectorsReadFromFile: return correct array for valid format input."); - } - - //Tests for psLookupTableRead - // Attempt to read table with NULL input table specified - numRows = psLookupTableRead(table1); - { - ok( numRows == 0, - "psLookupTableRead: return NULL for NULL filename input."); - } - // Attempt to read table with bad filename specified - table1 = psLookupTableAlloc("psTable.dat", "\%f \%lf \%d \%ld", 10); - numRows = psLookupTableRead(table1); - { - ok( numRows == 0, - "psLookupTableRead: return NULL for table with invalid filename."); - } - - // Attempt to read valid table with wrong indexCol - psFree(table1); - table1 = psLookupTableAlloc("table.dat", + psMemId id = psMemGetId(); + psArray *outVec = NULL; + psArray *vectors = NULL; + psLookupTable* table1 = NULL; + long numRows = 0; + + //Tests for psVectorReadFromFile + // Attempt to read from NULL filename input + { + outVec = psVectorsReadFromFile(NULL, + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); + ok( outVec == NULL, + "psVectorsReadFromFile: return NULL for NULL filename input."); + } + // Attempt to read from NULL format input + { + outVec = psVectorsReadFromFile("table.dat", NULL); + ok( outVec == NULL, + "psVectorsReadFromFile: return NULL for NULL format input."); + } + // Attempt to read from invalid filename input + { + outVec = psVectorsReadFromFile("tableS32.dat", + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); + ok( outVec == NULL, + "psVectorsReadFromFile: return NULL for invalid filename input."); + } + // Attempt to read from invalid format input + { + outVec = psVectorsReadFromFile("table.dat", "\%s"); + ok( outVec == NULL, + "psVectorsReadFromFile: return NULL for invalid format input."); + } + // Attempt to read from table containing invalid entry - F32 + { + outVec = psVectorsReadFromFile("tableF32_err.dat", + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); + ok( outVec == NULL, + "psVectorsReadFromFile: return NULL for table containing invalid entry."); + } + // Attempt to read from table containing invalid entry - F64 + { + outVec = psVectorsReadFromFile("tableF64_err.dat", + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); + ok( outVec == NULL, + "psVectorsReadFromFile: return NULL for table containing invalid entry."); + } + // Attempt to read from table containing invalid entry - S32 + { + outVec = psVectorsReadFromFile("tableS32_err.dat", + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); + ok( outVec == NULL, + "psVectorsReadFromFile: return NULL for table containing invalid entry."); + } + // Attempt to read from table containing invalid entry - S64 + { + outVec = psVectorsReadFromFile("tableS64_err.dat", + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); + ok( outVec == NULL, + "psVectorsReadFromFile: return NULL for table containing invalid entry."); + } + // Attempt to read from empty table + { + outVec = psVectorsReadFromFile("tableF32_2.dat", + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); + ok( outVec == NULL, + "psVectorsReadFromFile: return NULL for empty table."); + } + // Attempt to read from file with partially constructed row + { + outVec = psVectorsReadFromFile("table3.dat", + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); + ok( outVec == NULL, + "psVectorsReadFromFile: return NULL for table with partially" + " constructed row."); + } + //Attempt to read with valid inputs + { + outVec = psVectorsReadFromFile("types/table.dat", + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf"); + ok( outVec != NULL && outVec->n == 9 && + ((psVector*)(outVec->data[6]))->data.S32[1] == -8, + "psVectorsReadFromFile: return correct array for valid format input."); + } + + //Tests for psLookupTableRead + // Attempt to read table with NULL input table specified + numRows = psLookupTableRead(table1); + { + ok( numRows == 0, + "psLookupTableRead: return NULL for NULL filename input."); + } + // Attempt to read table with bad filename specified + table1 = psLookupTableAlloc("psTable.dat", "\%f \%lf \%d \%ld", 10); + numRows = psLookupTableRead(table1); + { + ok( numRows == 0, + "psLookupTableRead: return NULL for table with invalid filename."); + } + + // Attempt to read valid table with wrong indexCol + psFree(table1); + table1 = psLookupTableAlloc("table.dat", "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 10); - numRows = psLookupTableRead(table1); - { - ok( numRows == 0, - "psLookupTableRead: return correct number of rows for valid inputs."); - } - // Attempt to read valid table - psFree(table1); - table1 = psLookupTableAlloc("types/table.dat", - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0); - numRows = psLookupTableRead(table1); - { - ok( numRows == 4, - "psLookupTableRead: return correct number of rows for valid inputs."); - } - - //Tests for psLookupTableImport (remaining cases) - // Attempt to import table with negative indexCol - vectors = psVectorsReadFromFile(table1->filename, table1->format); - { - ok( !psLookupTableImport(table1, vectors, -1 ), - "psLookupTableImport: return false for negative indexCol input."); - } - //Attempt to import table with unsorted array column - psFree(table1); - table1 = psLookupTableAlloc("types/table.dat", - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0); - { - ok( psLookupTableImport(table1, vectors, 7 ), - "psLookupTableImport: return true for array with unsorted column"); - } - - //Check for Memory leaks - { + numRows = psLookupTableRead(table1); + { + ok( numRows == 0, + "psLookupTableRead: return correct number of rows for valid inputs."); + } + // Attempt to read valid table + psFree(table1); + table1 = psLookupTableAlloc("types/table.dat", + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0); + numRows = psLookupTableRead(table1); + { + ok( numRows == 4, + "psLookupTableRead: return correct number of rows for valid inputs."); + } + + //Tests for psLookupTableImport (remaining cases) + // Attempt to import table with negative indexCol + vectors = psVectorsReadFromFile(table1->filename, table1->format); + { + ok( !psLookupTableImport(table1, vectors, -1 ), + "psLookupTableImport: return false for negative indexCol input."); + } + //Attempt to import table with unsorted array column + psFree(table1); + table1 = psLookupTableAlloc("types/table.dat", + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0); + { + ok( psLookupTableImport(table1, vectors, 7 ), + "psLookupTableImport: return true for array with unsorted column"); + } + psFree(vectors); psFree(outVec); psFree(table1); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } -} - -void testLookupTableInterpolates(void) -{ - // diag(" >>>Test 3: psLookupTableInterpolate & psLookupTableInterpolateAll Fxns"); - psLookupTable *table1 = NULL; - psVector *vec = NULL; - table1 = psLookupTableAlloc("types/table.dat", - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0); - psLookupTable *table2 = NULL; - table2 = psLookupTableAlloc("types/table.dat", - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0); - psLookupTableRead(table2); - - //Tests for psLookupTableInterpolateAll - //Return NULL for NULL table input + + + // testLookupTableInterpolates() + // psLookupTableInterpolate & psLookupTableInterpolateAll Fxns { - vec = psLookupTableInterpolateAll(NULL, 0); - ok( vec == NULL, - "psLookupTableInterpolateAll: return NULL for NULL table input."); - } - //Return NULL for NULL table values - { - vec = psLookupTableInterpolateAll(table1, 0); - ok( vec == NULL, - "psLookupTableInterpolateAll: return NULL for NULL table values."); - } - - ok(table2->values != NULL, "table->values not NULL"); - //Return NULL for table with table->values->n == 0 - { - long n = table2->values->n; - table2->values->n = 0; - vec = psLookupTableInterpolateAll(table2, 0); - ok( vec == NULL, - "psLookupTableInterpolateAll: return NULL for table with no columns."); - table2->values->n = n; - } - //Return NULL for invalid index input - { - vec = psLookupTableInterpolateAll(table2, -10.5); - ok( vec == NULL, - "psLookupTableInterpolateAll: return NULL for invalid index input."); - } - //Return correct vector output for valid inputs - { - vec = psLookupTableInterpolateAll(table2, 1); - skip_start( vec == NULL, 1, - "Skipping 1 tests because psLookupTableInterpolateAll failed"); - is_double(vec->data.F64[0], 1.0, - "psLookupTableInterpolateAll: return correct output vector for valid inputs."); - skip_end(); - } - - //Remaining tests for psLookupTableInterpolate - //Return NAN for invalid index - divide by zero error - psLookupTable *table3 = NULL; - table3 = psLookupTableAlloc("table2.dat", - "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0); - psLookupTableRead(table3); - { - double retVal; - retVal = psLookupTableInterpolate(table3, 1.5e-20, 0); - ok( isnan(retVal), - "psLookupTableInterpolateAll: return NAN for invalid index input."); - } - - //Check for Memory leaks - { + psMemId id = psMemGetId(); + psLookupTable *table1 = NULL; + psVector *vec = NULL; + // XXX: Remove the "types" path here + table1 = psLookupTableAlloc("types/table.dat", + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0); + psLookupTable *table2 = NULL; + // XXX: Remove the "types" path here + table2 = psLookupTableAlloc("types/table.dat", + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0); + psLookupTableRead(table2); + + //Tests for psLookupTableInterpolateAll + //Return NULL for NULL table input + { + vec = psLookupTableInterpolateAll(NULL, 0); + ok( vec == NULL, + "psLookupTableInterpolateAll: return NULL for NULL table input."); + } + //Return NULL for NULL table values + { + vec = psLookupTableInterpolateAll(table1, 0); + ok( vec == NULL, + "psLookupTableInterpolateAll: return NULL for NULL table values."); + } + + ok(table2->values != NULL, "table->values not NULL"); + //Return NULL for table with table->values->n == 0 + { + long n = table2->values->n; + table2->values->n = 0; + vec = psLookupTableInterpolateAll(table2, 0); + ok( vec == NULL, + "psLookupTableInterpolateAll: return NULL for table with no columns."); + table2->values->n = n; + } + //Return NULL for invalid index input + { + vec = psLookupTableInterpolateAll(table2, -10.5); + ok( vec == NULL, + "psLookupTableInterpolateAll: return NULL for invalid index input."); + } + //Return correct vector output for valid inputs + { + vec = psLookupTableInterpolateAll(table2, 1); + skip_start( vec == NULL, 1, + "Skipping 1 tests because psLookupTableInterpolateAll failed"); + is_double(vec->data.F64[0], 1.0, + "psLookupTableInterpolateAll: return correct output vector for valid inputs."); + skip_end(); + } + + //Remaining tests for psLookupTableInterpolate + //Return NAN for invalid index - divide by zero error + psLookupTable *table3 = NULL; + table3 = psLookupTableAlloc("table2.dat", + "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0); + psLookupTableRead(table3); + { + double retVal; + retVal = psLookupTableInterpolate(table3, 1.5e-20, 0); + ok( isnan(retVal), + "psLookupTableInterpolateAll: return NAN for invalid index input."); + } + psFree(table3); psFree(vec); psFree(table2); psFree(table1); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - } Index: trunk/psLib/test/types/tap_psMetadataConfigFormat.c =================================================================== --- trunk/psLib/test/types/tap_psMetadataConfigFormat.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadataConfigFormat.c (revision 12781) @@ -9,8 +9,6 @@ * */ - #include #include - #include "tap.h" #include "pstap.h" @@ -18,11 +16,11 @@ int main(void) { + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); plan_tests(16 + 1); psMetadata *md = NULL; psString out = NULL; - //psString psMetadataConfigFormat(psMetadata *md); - //Return NULL for NULL metadata input { Index: trunk/psLib/test/types/tap_psMetadataConfigParse.c =================================================================== --- trunk/psLib/test/types/tap_psMetadataConfigParse.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadataConfigParse.c (revision 12781) @@ -10,10 +10,8 @@ * */ - #include #include #include #include - #include "tap.h" #include "pstap.h" @@ -21,8 +19,7 @@ int main(void) { - plan_tests(35 + 1); - psLogSetFormat("HLNM"); -// psTraceSetLevel("err", 10); + psLogSetLevel(PS_LOG_INFO); + plan_tests(35); @@ -38,4 +35,5 @@ } + // Return empty metadata for incorrect string input { @@ -48,4 +46,5 @@ ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return correct metadata for correct string input - S32 @@ -69,4 +68,5 @@ } + // Return correct metadata for correct string input - F64 { @@ -89,4 +89,5 @@ ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return correct metadata for string with duplicate entry - S8 @@ -114,4 +115,5 @@ } + // Return correct metadata for correct string input - Vector { @@ -137,4 +139,5 @@ } + // Return empty metadata for incorrect string input { @@ -148,6 +151,4 @@ ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); } - - done(); } Index: trunk/psLib/test/types/tap_psMetadataConfigParse_time.c =================================================================== --- trunk/psLib/test/types/tap_psMetadataConfigParse_time.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadataConfigParse_time.c (revision 12781) @@ -1,5 +1,4 @@ #include #include - #include "tap.h" #include "pstap.h" @@ -7,11 +6,12 @@ int main (void) { + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); plan_tests(39 + 1); + { psMemId id = psMemGetId(); - char *testStr = "time UTC 2005-03-18T16:05:00Z\n"; - psU32 nBad = 0; psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false); @@ -28,13 +28,11 @@ psFree(md); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); } + { psMemId id = psMemGetId(); - char *testStr = "time UT1 2005-03-18T16:05:00Z\n"; - psU32 nBad = 0; psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false); @@ -51,13 +49,11 @@ psFree(md); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); } + { psMemId id = psMemGetId(); - char *testStr = "time TAI 2005-03-18T16:05:00Z\n"; - psU32 nBad = 0; psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false); @@ -74,13 +70,11 @@ psFree(md); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); } + { psMemId id = psMemGetId(); - char *testStr = "time TT 2005-03-18T16:05:00Z"; - psU32 nBad = 0; psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false); @@ -97,14 +91,12 @@ psFree(md); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); } + { psMemId id = psMemGetId(); - // missing Z char *testStr = "broken UTC 2005-03-18T16:05:00"; - psU32 nBad = 0; psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false); @@ -120,8 +112,6 @@ { psMemId id = psMemGetId(); - // missing Z char *testStr = "broken UT1 2005-03-18T16:05:00"; - psU32 nBad = 0; psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false); @@ -137,8 +127,6 @@ { psMemId id = psMemGetId(); - // missing Z char *testStr = "broken TAI 2005-03-18T16:05:00"; - psU32 nBad = 0; psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false); @@ -149,14 +137,12 @@ psFree(md); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); } + { psMemId id = psMemGetId(); - // missing Z char *testStr = "broken TT 2005-03-18T16:05:00"; - psU32 nBad = 0; psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false); @@ -167,8 +153,5 @@ psFree(md); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); } - - return exit_status(); } Index: trunk/psLib/test/types/tap_psMetadataConfigPrint.c =================================================================== --- trunk/psLib/test/types/tap_psMetadataConfigPrint.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadataConfigPrint.c (revision 12781) @@ -9,8 +9,6 @@ * */ - #include #include - #include "tap.h" #include "pstap.h" @@ -18,8 +16,12 @@ int main(void) { - plan_tests(7); + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(11); + //Return false for NULL metadata input { + psMemId id = psMemGetId(); FILE *openfile = fopen("mdcfg.prt", "w+"); @@ -28,10 +30,12 @@ fclose(openfile); - remove - ("mdcfg.prt"); + remove("mdcfg.prt"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + //Return false for empty metadata input { + psMemId id = psMemGetId(); FILE *openfile = fopen("mdcfg.prt", "w+"); psMetadata *md = psMetadataAlloc(); @@ -42,10 +46,12 @@ psFree(md); fclose(openfile); - remove - ("mdcfg.prt"); + remove("mdcfg.prt"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + //Return false for NULL file input { + psMemId id = psMemGetId(); psMetadata *md = psMetadataAlloc(); psMetadataAddS32(md, PS_LIST_HEAD, "new S32", 0, "", 666); @@ -55,8 +61,11 @@ psFree(md); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return false for read-only file input { + psMemId id = psMemGetId(); // create an empty file to open read only later { @@ -74,10 +83,12 @@ psFree(md); fclose(openfile); - remove - ("mdcfg.prt"); + remove("mdcfg.prt"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return true for valid inputs { + psMemId id = psMemGetId(); FILE *openfile = fopen("mdcfg.prt", "w+"); psMetadata *md = psMetadataAlloc(); @@ -100,8 +111,6 @@ fclose(mdcfg); - remove - ("mdcfg.prt"); + remove("mdcfg.prt"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - - done(); } Index: trunk/psLib/test/types/tap_psMetadataConfigRead.c =================================================================== --- trunk/psLib/test/types/tap_psMetadataConfigRead.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadataConfigRead.c (revision 12781) @@ -109,4 +109,5 @@ ) { + psMemId id = psMemGetId(); skip_start(!item, 3, "Skipping 4 tests because !item"); ok(strcmp(item->name, name) == 0, "item->name = %s", item->name); @@ -142,11 +143,14 @@ } skip_end(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); return NULL; } -int main (void) +int main(void) { - plan_tests(52); + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(62); generateMDConfig(); Index: trunk/psLib/test/types/tap_psMetadataConfigWrite.c =================================================================== --- trunk/psLib/test/types/tap_psMetadataConfigWrite.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadataConfigWrite.c (revision 12781) @@ -9,47 +9,62 @@ * */ - #include #include - #include "tap.h" #include "pstap.h" + int main(void) { - plan_tests(7); + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(11); + //Return false for NULL metadata input { + psMemId id = psMemGetId(); ok( !psMetadataConfigWrite(NULL, "mdcfg.wrt"), "return false for NULL metadata input."); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + //Return false for NULL filename input { + psMemId id = psMemGetId(); psMetadata *md = psMetadataAlloc(); ok( !psMetadataConfigWrite(md, NULL), "return false for NULL filename input."); psFree(md); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + //Return false for invalid filename input { + psMemId id = psMemGetId(); psMetadata *md = psMetadataAlloc(); ok( !psMetadataConfigWrite(md, "."), "return false for invalid filename input."); psFree(md); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + //Return false for empty metadata input { + psMemId id = psMemGetId(); psMetadata *md = psMetadataAlloc(); ok( !psMetadataConfigWrite(md, "mdcfg.wrt"), "return false for empty metadata input."); psFree(md); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + //Return true for valid inputs { + psMemId id = psMemGetId(); psMetadata *md = psMetadataAlloc(); psMetadataAddBool(md, PS_LIST_TAIL, "item1-1", 0, "I am a boolean", true); @@ -68,6 +83,5 @@ ("mdcfg.wrt"); psFree(md); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - - done(); } Index: trunk/psLib/test/types/tap_psMetadataConfig_input.c =================================================================== --- trunk/psLib/test/types/tap_psMetadataConfig_input.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadataConfig_input.c (revision 12781) @@ -10,11 +10,8 @@ * */ - #include #include #include #include - - #include "tap.h" #include "pstap.h" @@ -22,8 +19,7 @@ int main(void) { - plan_tests(30 + 1); - psLogSetFormat("HLNM"); -// psTraceSetLevel("err", 10); + psLogSetLevel(PS_LOG_INFO); + plan_tests(30); @@ -33,9 +29,8 @@ unsigned int nfail = 0; psMetadata *md = psMetadataConfigRead(NULL, &nfail, NULL, false); - ok(md == NULL, "return NULL for NULL filename input."); - ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return NULL for invalid filename input @@ -44,9 +39,8 @@ unsigned int nfail = 0; psMetadata *md = psMetadataConfigRead(NULL, &nfail, ".", false); - ok(md == NULL, "return NULL for invalid filename input."); - ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return NULL for missing file input @@ -56,7 +50,7 @@ psMetadata *md = psMetadataConfigRead(NULL, &nfail, "table4.dat", false); ok(md == NULL, "return NULL for missing file input."); - ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return NULL for read-only file with comments, bad syntax, and no good @@ -68,8 +62,8 @@ ok(md == NULL, "return NULL for all bad syntax"); is_int(nfail, 0, "correct nfail"); - psFree(md); ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return true for valid inputs - overwrite = false @@ -100,9 +94,9 @@ is_int(item->data.S32, 666, "metdataItem value"); is_str(item->comment, "this line is \"GOOD\" but parsed in the top level", "metadataItem comment."); - skip_end(); psFree(md); ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } + // Return true for valid inputs - overwrite = true @@ -136,10 +130,7 @@ is_str(item->comment, "", "metadataItem comment"); - skip_end(); psFree(md); ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - - done(); } Index: trunk/psLib/test/types/tap_psMetadataItemCompare.c =================================================================== --- trunk/psLib/test/types/tap_psMetadataItemCompare.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadataItemCompare.c (revision 12781) @@ -9,226 +9,190 @@ * */ - #include - #include "tap.h" #include "pstap.h" -void testItemCompare(void); -int main (void) +int main(void) { + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); plan_tests(22); - note("psMetadataItemCompare() tests"); + // psMetadataItemCompare() tests + { + psMemId id = psMemGetId(); + psMetadataItem *compare = NULL; + psMetadataItem *template = NULL; + psMetadataItem *itemCopy = NULL; + psMetadataItem *item = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", true) + ; + + //Return false for NULL compare psMetadataItem + { + ok( !psMetadataItemCompare(compare, item), + "psMetadataItemCompare: return false for NULL compare input." ); + } + //Return false for NULL template psMetadataItem + { + ok( !psMetadataItemCompare(item, template), + "psMetadataItemCompare: return false for NULL template input." ); + } + + //Return false for psMetadataItem's with different names + { + template = psMetadataItemAlloc("Milky Way", PS_DATA_BOOL, "No Comment", true) + ; + compare = psMetadataItemAlloc("Snickers", PS_DATA_S32, "No Comment", 1); + ok( !psMetadataItemCompare(template, item), + "psMetadataItemCompare: return false for input with different names."); + } - testItemCompare(); + //Return true for an exact match (copied psMetadataItem) + { + itemCopy = psMetadataItemCopy(item); + ok( psMetadataItemCompare(itemCopy, item), + "psMetadataItemCompare: return true for comparison of identical psMetadataItem's."); + } + + //Return true for psMetadataItem's with different types but otherwise identical + { + ok( psMetadataItemCompare(compare, item), + "psMetadataItemCompare: return true for valid compare of different type."); + } + + //Return true for comparing Bool with F64 + { + psFree(compare); + compare = psMetadataItemAlloc("Snickers", PS_DATA_F64, "No Comment", 1.0000); + ok( psMetadataItemCompare(compare, item), + "psMetadataItemCompare: return false for comparison of F64 to bool." ); + } - done(); -} + //Return true for comparing F64 with Bool + { + ok( psMetadataItemCompare(item, compare), + "psMetadataItemCompare: return false for comparison of bool to F64." ); + } + + //Return true for comparing S32 with F32 of same value + { + psFree(template); + template = psMetadataItemAlloc("Snickers", PS_DATA_S32, "No Comment", 1); + psFree(compare); + compare = psMetadataItemAlloc("Snickers", PS_DATA_F32, "No Comment", 1.00); + ok( psMetadataItemCompare(compare, template), + "psMetadataItemCompare: return true for comparison of S32 to F32." ); + } -void testItemCompare(void) -{ - note(" >>>Test 1: psMetadataItemCompare"); + //Return true for comparing F32 with S32 of same value + { + ok( psMetadataItemCompare(template, compare), + "psMetadataItemCompare: return true for comparison of F32 to S32." ); + } + + //Return true for comparing U32 with S16 of same value + { + psFree(template); + template = psMetadataItemAlloc("Snickers", PS_DATA_S16, "No Comment", 1); + psFree(compare); + compare = psMetadataItemAlloc("Snickers", PS_DATA_U32, "No Comment", 1); + ok( psMetadataItemCompare(compare, template), + "psMetadataItemCompare: return true for comparison of S16 to U32." ); + } - psMetadataItem *compare = NULL; - psMetadataItem *template = NULL; - psMetadataItem *itemCopy = NULL; - psMetadataItem *item = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", true) - ; + //Return true for comparing S16 with U32 of same value + { + ok( psMetadataItemCompare(template, compare), + "psMetadataItemCompare: return true for comparison of U32 to S16." ); + } + + //Return true for comparing U8 with U16 of same value + { + psFree(template); + template = psMetadataItemAlloc("Snickers", PS_DATA_U8, "No Comment", 1); + psFree(compare); + compare = psMetadataItemAlloc("Snickers", PS_DATA_U16, "No Comment", 1); + ok( psMetadataItemCompare(compare, template), + "psMetadataItemCompare: return true for comparison of U8 to U16." ); + } - //Return false for NULL compare psMetadataItem - { - ok( !psMetadataItemCompare(compare, item), - "psMetadataItemCompare: return false for NULL compare input." ); - } - //Return false for NULL template psMetadataItem - { - ok( !psMetadataItemCompare(item, template), - "psMetadataItemCompare: return false for NULL template input." ) - ; - } + //Return true for comparing U16 with U8 of same value + { + ok( psMetadataItemCompare(template, compare), + "psMetadataItemCompare: return true for comparison of U16 to U8." ); + } + + //Return true for comparing U8 with S8 of same value + { + psFree(compare); + compare = psMetadataItemAlloc("Snickers", PS_DATA_S8, "No Comment", 1); + ok( psMetadataItemCompare(compare, template), + "psMetadataItemCompare: return true for comparison of U8 to S8." ); + } - //Return false for psMetadataItem's with different names - { - template = psMetadataItemAlloc("Milky Way", PS_DATA_BOOL, "No Comment", true) - ; - compare = psMetadataItemAlloc("Snickers", PS_DATA_S32, "No Comment", 1); - ok( !psMetadataItemCompare(template, item), - "psMetadataItemCompare: return false for input with different names.") - ; - } - //Return true for an exact match (copied psMetadataItem) - { - itemCopy = psMetadataItemCopy(item); - ok( psMetadataItemCompare(itemCopy, item), - "psMetadataItemCompare: return true for comparison of identical psMetadataItem's."); - } + //Return true for comparing S8 with U8 of same value + { + ok( psMetadataItemCompare(template, compare), + "psMetadataItemCompare: return true for comparison of S8 to U8." ); + } + + //Return false for comparing U8 with S64 of same value + { + psFree(compare); + compare = psMetadataItemAlloc("Snickers", PS_DATA_S64, "No Comment", 1); + ok( !psMetadataItemCompare(compare, template), + "psMetadataItemCompare: return false for comparison of U8 to S64*. " + "*not yet implemented" ); + } - //Return true for psMetadataItem's with different types but otherwise identical - { - ok( psMetadataItemCompare(compare, item), - "psMetadataItemCompare: return true for valid compare of different type."); - } + //Return false for comparing S64 with U8 of same value + { + ok( !psMetadataItemCompare(template, compare), + "psMetadataItemCompare: return false for comparison of S64* to U8. " + "*not yet implemented" ); + } + + //Return false for comparing string of different value + { + psFree(compare); + compare = psMetadataItemAlloc("Snickers", PS_DATA_STRING, "No Comment", + "Not Going Anywhere?"); + psFree(template); + template = psMetadataItemAlloc("Snickers", PS_DATA_STRING, "No Comment", "For a While?"); + ok( !psMetadataItemCompare(compare, template), + "psMetadataItemCompare: return false for comparison of different psString's."); + } + + //Return true for comparing string of same value + { + psFree(template); + template = psMetadataItemAlloc("Snickers", PS_DATA_STRING, "No Comment", + "Not Going Anywhere?"); + ok( psMetadataItemCompare(compare, template), + "psMetadataItemCompare: return true for comparison of identical psString's."); + } + + //Return false for comparing string with bool + { + psFree(template); + template = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", false); + ok( !psMetadataItemCompare(compare, template), + "psMetadataItemCompare: return false for comparison of psString with bool."); + } - //Return true for comparing Bool with F64 - { + //Return false for comparing bool with string + { + psFree(template); + template = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", false); + ok( !psMetadataItemCompare(template, compare), + "psMetadataItemCompare: return false for comparison of psString with bool."); + } + psFree(compare); - compare = psMetadataItemAlloc("Snickers", PS_DATA_F64, "No Comment", 1.0000); - ok( psMetadataItemCompare(compare, item), - "psMetadataItemCompare: return false for comparison of F64 to bool." ); - } - //Return true for comparing F64 with Bool - { - ok( psMetadataItemCompare(item, compare), - "psMetadataItemCompare: return false for comparison of bool to F64." ); - } - - //Return true for comparing S32 with F32 of same value - { - psFree(template) - ; - template = psMetadataItemAlloc("Snickers", PS_DATA_S32, "No Comment", 1) - ; - psFree(compare); - compare = psMetadataItemAlloc("Snickers", PS_DATA_F32, "No Comment", 1.00); - ok( psMetadataItemCompare(compare, template), - "psMetadataItemCompare: return true for comparison of S32 to F32." ) - ; - } - //Return true for comparing F32 with S32 of same value - { - ok( psMetadataItemCompare(template, compare), - "psMetadataItemCompare: return true for comparison of F32 to S32." ) - ; - } - - //Return true for comparing U32 with S16 of same value - { - psFree(template) - ; - template = psMetadataItemAlloc("Snickers", PS_DATA_S16, "No Comment", 1) - ; - psFree(compare); - compare = psMetadataItemAlloc("Snickers", PS_DATA_U32, "No Comment", 1); - ok( psMetadataItemCompare(compare, template), - "psMetadataItemCompare: return true for comparison of S16 to U32." ) - ; - } - //Return true for comparing S16 with U32 of same value - { - ok( psMetadataItemCompare(template, compare), - "psMetadataItemCompare: return true for comparison of U32 to S16." ) - ; - } - - //Return true for comparing U8 with U16 of same value - { - psFree(template) - ; - template = psMetadataItemAlloc("Snickers", PS_DATA_U8, "No Comment", 1) - ; - psFree(compare); - compare = psMetadataItemAlloc("Snickers", PS_DATA_U16, "No Comment", 1); - ok( psMetadataItemCompare(compare, template), - "psMetadataItemCompare: return true for comparison of U8 to U16." ) - ; - } - //Return true for comparing U16 with U8 of same value - { - ok( psMetadataItemCompare(template, compare), - "psMetadataItemCompare: return true for comparison of U16 to U8." ) - ; - } - - //Return true for comparing U8 with S8 of same value - { - psFree(compare); - compare = psMetadataItemAlloc("Snickers", PS_DATA_S8, "No Comment", 1); - ok( psMetadataItemCompare(compare, template), - "psMetadataItemCompare: return true for comparison of U8 to S8." ) - ; - } - //Return true for comparing S8 with U8 of same value - { - ok( psMetadataItemCompare(template, compare), - "psMetadataItemCompare: return true for comparison of S8 to U8." ) - ; - } - - //Return false for comparing U8 with S64 of same value - { - psFree(compare); - compare = psMetadataItemAlloc("Snickers", PS_DATA_S64, "No Comment", 1); - ok( !psMetadataItemCompare(compare, template), - "psMetadataItemCompare: return false for comparison of U8 to S64*. " - "*not yet implemented" ) - ; - } - //Return false for comparing S64 with U8 of same value - { - ok( !psMetadataItemCompare(template, compare), - "psMetadataItemCompare: return false for comparison of S64* to U8. " - "*not yet implemented" ) - ; - } - - //Return false for comparing string of different value - { - psFree(compare); - compare = psMetadataItemAlloc("Snickers", PS_DATA_STRING, "No Comment", - "Not Going Anywhere?"); - psFree(template) - ; - template = psMetadataItemAlloc("Snickers", PS_DATA_STRING, "No Comment", "For a While?") - ; - ok( !psMetadataItemCompare(compare, template), - "psMetadataItemCompare: return false for comparison of different psString's.") - ; - } - - //Return true for comparing string of same value - { - psFree(template) - ; - template = psMetadataItemAlloc("Snickers", PS_DATA_STRING, "No Comment", - "Not Going Anywhere?") - ; - ok( psMetadataItemCompare(compare, template), - "psMetadataItemCompare: return true for comparison of identical psString's.") - ; - } - - //Return false for comparing string with bool - { - psFree(template) - ; - template = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", false) - ; - ok( !psMetadataItemCompare(compare, template), - "psMetadataItemCompare: return false for comparison of psString with bool.") - ; - } - //Return false for comparing bool with string - { - psFree(template) - ; - template = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", false) - ; - ok( !psMetadataItemCompare(template, compare), - "psMetadataItemCompare: return false for comparison of psString with bool.") - ; - } - - //Check for Memory leaks - { - psFree(compare); - psFree(template) - ; + psFree(template); psFree(itemCopy); psFree(item); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } } - - Index: trunk/psLib/test/types/tap_psMetadataItemParse.c =================================================================== --- trunk/psLib/test/types/tap_psMetadataItemParse.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadataItemParse.c (revision 12781) @@ -9,507 +9,496 @@ * */ - #include #include - #include "tap.h" #include "pstap.h" - void testItemParse(void); int main (void) { + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); plan_tests(112); - note("psMetadataItemParse() tests"); - - testItemParse(); - - done(); -} - -void testItemParse(void) -{ - note(" >>>Test 1: psMetadataItemParse"); - - psMetadataItem *itemBool = psMetadataItemAlloc("bool", PS_DATA_BOOL, "No Comment", true); - psMetadataItem *itemF32 = psMetadataItemAlloc("f32", PS_DATA_F32, "No Comment", 0.00); - psMetadataItem *itemF64 = psMetadataItemAlloc("f64", PS_DATA_F64, "No Comment", 0.50); - psMetadataItem *itemS8 = psMetadataItemAlloc("s8", PS_DATA_S8, "No Comment", 1); - psMetadataItem *itemS16 = psMetadataItemAlloc("s16", PS_DATA_S16, "No Comment", 0); - psMetadataItem *itemS32 = psMetadataItemAlloc("s32", PS_DATA_S32, "No Comment", 1); - psMetadataItem *itemU8 = psMetadataItemAlloc("u8", PS_DATA_U8, "No Comment", 2); - psMetadataItem *itemU16 = psMetadataItemAlloc("u16", PS_DATA_U16, "No Comment", 0); - psMetadataItem *itemU32 = psMetadataItemAlloc("u32", PS_DATA_U32, "No Comment", 1); - psMetadataItem *itemString1 = psMetadataItemAlloc("String", PS_DATA_STRING, "", "true"); - psMetadataItem *itemString2 = psMetadataItemAlloc("String", PS_DATA_STRING, "", "1.666"); - psMetadataItem *itemString11 = psMetadataItemAlloc("String", PS_DATA_STRING, "", "false"); - psMetadataItem *itemUnsupported = psMetadataItemAlloc("s64", PS_DATA_S64, "", 1); - - //TESTS: Bool, F32, F64, S8, S16, S32, U8, U16, U32, String - //BOOL Test + // psMetadataItemParse() tests { - //Return false for NULL item - ok ( !psMetadataItemParseBool(NULL), - "psMetadataItemParse: return false in BOOL for NULL psMetadataItem " - "input." ); - //Return false for non-supported type S64 - ok ( !psMetadataItemParseBool(itemUnsupported), - "psMetadataItemParse: return false in BOOL for S64 (unsupported) " - "psMetadataItem input." ); - //Return true for string with "true" - ok ( psMetadataItemParseBool(itemString1), - "psMetadataItemParse: return true in BOOL for string-item with " - "value 'true'." ); - //Return false for string with "false" - ok ( !psMetadataItemParseBool(itemString11), - "psMetadataItemParse: return false in BOOL for string-item with " - "value 'false'." ); - //Return false for F32 value 0.0 - ok ( !psMetadataItemParseBool(itemF32), - "psMetadataItemParse: return false in BOOL for F32-item with " - "value '0.0'." ); - //Return true for F64 value 0.5 - ok ( psMetadataItemParseBool(itemF64), - "psMetadataItemParse: return true in BOOL for F64-item with " - "value '0.5'." ); - //Return true for S8 value 1 - ok ( psMetadataItemParseBool(itemS8), - "psMetadataItemParse: return true in BOOL for S8-item with " - "value '1'." ); - //Return false for S16 value 0 - ok ( !psMetadataItemParseBool(itemS16), - "psMetadataItemParse: return false in BOOL for S16-item with " - "value '0'." ); - //Return true for S32 value 1 - ok ( psMetadataItemParseBool(itemS32), - "psMetadataItemParse: return true in BOOL for S32-item with " - "value '1'." ); - //Return true for U8 value 2 - ok ( psMetadataItemParseBool(itemU8), - "psMetadataItemParse: return true in BOOL for U8-item with " - "value '2'." ); - //Return false for U16 value 0 - ok ( !psMetadataItemParseBool(itemU16), - "psMetadataItemParse: return false in BOOL for U16-item with " - "value '0'." ); - //Return true for U32 value 1 - ok ( psMetadataItemParseBool(itemU32), - "psMetadataItemParse: return true in BOOL for U32-item with " - "value '1'." ); - } - - //F32 Test - { - //Return NaN for NULL item - ok ( isnan(psMetadataItemParseF32(NULL)), - "psMetadataItemParse: return NaN for NULL psMetadataItem input." ); - //Return NaN for non-supported type S64 - ok ( isnan(psMetadataItemParseF32(itemUnsupported)), - "psMetadataItemParse: return NaN in F32 for S64 (unsupported) " - "psMetadataItem input." ); - //Return 1.666 for string with "1.666" - is_float( psMetadataItemParseF32(itemString2), 1.666, - "psMetadataItemParse: return 1.666 in F32 for string-item with " - "value '1.666'." ); - //Return 0.0 for F32 value 0.0 - is_float( psMetadataItemParseF32(itemF32), 0.0, - "psMetadataItemParse: return 0.0 in F32 for F32-item with " - "value '0.0'." ); - //Return 0.5 for F64 value 0.5 - is_float( psMetadataItemParseF32(itemF64), 0.5, - "psMetadataItemParse: return 0.5 in F32 for F64-item with " - "value '0.5'." ); - //Return 1.0 for S8 value 1 - is_float( psMetadataItemParseF32(itemS8), 1.0, - "psMetadataItemParse: return 1.0 in F32 for S8-item with " - "value '1'." ); - //Return 0.0 for S16 value 0 - is_float( psMetadataItemParseF32(itemS16), 0.0, - "psMetadataItemParse: return 0.0 in F32 for S16-item with " - "value '0'." ); - //Return 1.0 for S32 value 1 - is_float( psMetadataItemParseF32(itemS32), 1.0, - "psMetadataItemParse: return 1.0 in F32 for S32-item with " - "value '1'." ); - //Return 2.0 for U8 value 2 - is_float( psMetadataItemParseF32(itemU8), 2.0, - "psMetadataItemParse: return 2.0 in F32 for U8-item with " - "value '2'." ); - //Return 0.0 for U16 value 0 - is_float( psMetadataItemParseF32(itemU16), 0.0, - "psMetadataItemParse: return 0.0 in F32 for U16-item with " - "value '0'." ); - //Return 1.0 for U32 value 1 - is_float( psMetadataItemParseF32(itemU32), 1.0, - "psMetadataItemParse: return 1.0 in F32 for U32-item with " - "value '1'." ); - } - - //F64 Test - { - //Return NaN for NULL item - ok ( isnan(psMetadataItemParseF64(NULL)), - "psMetadataItemParse: return NaN for NULL psMetadataItem input." ); - //Return NaN for non-supported type S64 - ok ( isnan(psMetadataItemParseF64(itemUnsupported)), - "psMetadataItemParse: return NaN in F64 for S64 (unsupported) " - "psMetadataItem input." ); - //Return 1.666 for string with "1.666" - is_double_tol( psMetadataItemParseF64(itemString2), 1.666, 0.00001, - "psMetadataItemParse: return 1.666 in F64 for string-item with " - "value '1.666'." ); - //Return 0.0 for F32 value 0.0 - is_double( psMetadataItemParseF64(itemF32), 0.0, - "psMetadataItemParse: return 0.0 in F64 for F32-item with " - "value '0.0'." ); - //Return 0.5 for F64 value 0.5 - is_double( psMetadataItemParseF64(itemF64), 0.5, - "psMetadataItemParse: return 0.5 in F64 for F64-item with " - "value '0.5'." ); - //Return 1.0 for S8 value 1 - is_double( psMetadataItemParseF64(itemS8), 1.0, - "psMetadataItemParse: return 1.0 in F64 for S8-item with " - "value '1'." ); - //Return 0.0 for S16 value 0 - is_double( psMetadataItemParseF64(itemS16), 0.0, - "psMetadataItemParse: return 0.0 in F64 for S16-item with " - "value '0'." ); - //Return 1.0 for S32 value 1 - is_double( psMetadataItemParseF64(itemS32), 1.0, - "psMetadataItemParse: return 1.0 in F64 for S32-item with " - "value '1'." ); - //Return 2.0 for U8 value 2 - is_double( psMetadataItemParseF64(itemU8), 2.0, - "psMetadataItemParse: return 2.0 in F64 for U8-item with " - "value '2'." ); - //Return 0.0 for U16 value 0 - is_double( psMetadataItemParseF64(itemU16), 0.0, - "psMetadataItemParse: return 0.0 in F64 for U16-item with " - "value '0'." ); - //Return 1.0 for U32 value 1 - is_double( psMetadataItemParseF64(itemU32), 1.0, - "psMetadataItemParse: return 1.0 in F64 for U32-item with " - "value '1'." ); - } - - //S8 Test - { - //Return 0 for NULL item - ok ( psMetadataItemParseS8(NULL) == 0, - "psMetadataItemParse: return 0 for NULL psMetadataItem input." ); - //Return 0 for non-supported type S64 - ok ( psMetadataItemParseS8(itemUnsupported) == 0, - "psMetadataItemParse: return 0 in S8 for S64 (unsupported) " - "psMetadataItem input." ); - //Return 2 for string with "1.666" - ok ( psMetadataItemParseS8(itemString2) == 1, - "psMetadataItemParse: return 1 in S8 for string-item with " - "value '1.666'." ); - //Return 0 for F32 value 0.0 - ok ( psMetadataItemParseS8(itemF32) == 0, - "psMetadataItemParse: return 0 in S8 for F32-item with " - "value '0.0'." ); - //Return 1 for F64 value 0.5 - ok ( psMetadataItemParseS8(itemF64) == 0, - "psMetadataItemParse: return 0 in S8 for F64-item with " - "value '0.5'." ); - //Return 1 for S8 value 1 - ok ( psMetadataItemParseS8(itemS8) == 1, - "psMetadataItemParse: return 1 in S8 for S8-item with " - "value '1'." ); - //Return 0 for S16 value 0 - ok ( psMetadataItemParseS8(itemS16) == 0, - "psMetadataItemParse: return 0 in S8 for S16-item with " - "value '0'." ); - //Return 1 for S32 value 1 - ok ( psMetadataItemParseS8(itemS32) == 1, - "psMetadataItemParse: return 1 in S8 for S32-item with " - "value '1'." ); - //Return 2 for U8 value 2 - ok ( psMetadataItemParseS8(itemU8) == 2, - "psMetadataItemParse: return 2 in S8 for U8-item with " - "value '2'." ); - //Return 0 for U16 value 0 - ok ( psMetadataItemParseS8(itemU16) == 0, - "psMetadataItemParse: return 0 in S8 for U16-item with " - "value '0'." ); - //Return 1 for U32 value 1 - ok ( psMetadataItemParseS8(itemU32) == 1, - "psMetadataItemParse: return 1 in S8 for U32-item with " - "value '1'." ); - } - - //S16 Test - { - //Return 0 for NULL item - ok ( psMetadataItemParseS16(NULL) == 0, - "psMetadataItemParse: return 0 for NULL psMetadataItem input." ); - //Return 0 for non-supported type S64 - ok ( psMetadataItemParseS16(itemUnsupported) == 0, - "psMetadataItemParse: return 0 in S16 for S64 (unsupported) " - "psMetadataItem input." ); - //Return 2 for string with "1.666" - ok ( psMetadataItemParseS16(itemString2) == 1, - "psMetadataItemParse: return 1 in S16 for string-item with " - "value '1.666'." ); - //Return 0 for F32 value 0.0 - ok ( psMetadataItemParseS16(itemF32) == 0, - "psMetadataItemParse: return 0 in S16 for F32-item with value '0.0'." ); - //Return 1 for F64 value 0.5 - ok ( psMetadataItemParseS16(itemF64) == 0, - "psMetadataItemParse: return 0 in S16 for F64-item with value '0.5'." ); - //Return 1 for S8 value 1 - ok ( psMetadataItemParseS16(itemS8) == 1, - "psMetadataItemParse: return 1 in S16 for S8-item with value '1'." ); - //Return 0 for S16 value 0 - ok ( psMetadataItemParseS16(itemS16) == 0, - "psMetadataItemParse: return 0 in S16 for S16-item with value '0'." ); - //Return 1 for S32 value 1 - ok ( psMetadataItemParseS16(itemS32) == 1, - "psMetadataItemParse: return 1 in S16 for S32-item with value '1'." ); - //Return 2 for U8 value 2 - ok ( psMetadataItemParseS16(itemU8) == 2, - "psMetadataItemParse: return 2 in S16 for U8-item with value '2'." ); - //Return 0 for U16 value 0 - ok ( psMetadataItemParseS16(itemU16) == 0, - "psMetadataItemParse: return 0 in S16 for U16-item with value '0'." ); - //Return 1 for U32 value 1 - ok ( psMetadataItemParseS16(itemU32) == 1, - "psMetadataItemParse: return 1 in S16 for U32-item with value '1'." ); - } - - //S32 Test - { - //Return 0 for NULL item - ok ( psMetadataItemParseS32(NULL) == 0, - "psMetadataItemParse: return 0 for NULL psMetadataItem input." ); - //Return 0 for non-supported type S64 - ok ( psMetadataItemParseS32(itemUnsupported) == 0, - "psMetadataItemParse: return 0 in S32 for S64 (unsupported) " - "psMetadataItem input." ); - //Return 2 for string with "1.666" - ok ( psMetadataItemParseS32(itemString2) == 1, - "psMetadataItemParse: return 1 in S32 for string-item with " - "value '1.666'." ); - //Return 0 for F32 value 0.0 - ok ( psMetadataItemParseS32(itemF32) == 0, - "psMetadataItemParse: return 0 in S32 for F32-item with value '0.0'." ); - //Return 1 for F64 value 0.5 - ok ( psMetadataItemParseS32(itemF64) == 0, - "psMetadataItemParse: return 0 in S32 for F64-item with value '0.5'." ); - //Return 1 for S8 value 1 - ok ( psMetadataItemParseS32(itemS8) == 1, - "psMetadataItemParse: return 1 in S32 for S8-item with value '1'." ); - //Return 0 for S16 value 0 - ok ( psMetadataItemParseS32(itemS16) == 0, - "psMetadataItemParse: return 0 in S32 for S16-item with value '0'." ); - //Return 1 for S32 value 1 - ok ( psMetadataItemParseS32(itemS32) == 1, - "psMetadataItemParse: return 1 in S32 for S32-item with value '1'." ); - //Return 2 for U8 value 2 - ok ( psMetadataItemParseS32(itemU8) == 2, - "psMetadataItemParse: return 2 in S32 for U8-item with value '2'." ); - //Return 0 for U16 value 0 - ok ( psMetadataItemParseS32(itemU16) == 0, - "psMetadataItemParse: return 0 in S32 for U16-item with value '0'." ); - //Return 1 for U32 value 1 - ok ( psMetadataItemParseS32(itemU32) == 1, - "psMetadataItemParse: return 1 in S32 for U32-item with value '1'." ); - } - - //U8 Test - { - //Return 0 for NULL item - ok ( psMetadataItemParseU8(NULL) == 0, - "psMetadataItemParse: return 0 for NULL psMetadataItem input." ); - //Return 0 for non-supported type S64 - ok ( psMetadataItemParseU8(itemUnsupported) == 0, - "psMetadataItemParse: return 0 in U8 for S64 (unsupported) " - "psMetadataItem input." ); - //Return 2 for string with "1.666" - ok ( psMetadataItemParseU8(itemString2) == 1, - "psMetadataItemParse: return 1 in U8 for string-item with " - "value '1.666'." ); - //Return 0 for F32 value 0.0 - ok ( psMetadataItemParseU8(itemF32) == 0, - "psMetadataItemParse: return 0 in U8 for F32-item with value '0.0'." ); - //Return 1 for F64 value 0.5 - ok ( psMetadataItemParseU8(itemF64) == 0, - "psMetadataItemParse: return 0 in U8 for F64-item with value '0.5'." ); - //Return 1 for S8 value 1 - ok ( psMetadataItemParseU8(itemS8) == 1, - "psMetadataItemParse: return 1 in U8 for S8-item with value '1'." ); - //Return 0 for S16 value 0 - ok ( psMetadataItemParseU8(itemS16) == 0, - "psMetadataItemParse: return 0 in U8 for S16-item with value '0'." ); - //Return 1 for S32 value 1 - ok ( psMetadataItemParseU8(itemS32) == 1, - "psMetadataItemParse: return 1 in U8 for S32-item with value '1'." ); - //Return 2 for U8 value 2 - ok ( psMetadataItemParseU8(itemU8) == 2, - "psMetadataItemParse: return 2 in U8 for U8-item with value '2'." ); - //Return 0 for U16 value 0 - ok ( psMetadataItemParseU8(itemU16) == 0, - "psMetadataItemParse: return 0 in U8 for U16-item with value '0'." ); - //Return 1 for U32 value 1 - ok ( psMetadataItemParseU8(itemU32) == 1, - "psMetadataItemParse: return 1 in U8 for U32-item with value '1'." ); - } - - //U16 Test - { - //Return 0 for NULL item - ok ( psMetadataItemParseU16(NULL) == 0, - "psMetadataItemParse: return 0 for NULL psMetadataItem input." ); - //Return 0 for non-supported type S64 - ok ( psMetadataItemParseU16(itemUnsupported) == 0, - "psMetadataItemParse: return 0 in U16 for S64 (unsupported) " - "psMetadataItem input." ); - //Return 2 for string with "1.666" - ok ( psMetadataItemParseU16(itemString2) == 1, - "psMetadataItemParse: return 1 in U16 for string-item with " - "value '1.666'." ); - //Return 0 for F32 value 0.0 - ok ( psMetadataItemParseU16(itemF32) == 0, - "psMetadataItemParse: return 0 in U16 for F32-item with value '0.0'." ); - //Return 1 for F64 value 0.5 - ok ( psMetadataItemParseU16(itemF64) == 0, - "psMetadataItemParse: return 0 in U16 for F64-item with value '0.5'." ); - //Return 1 for S8 value 1 - ok ( psMetadataItemParseU16(itemS8) == 1, - "psMetadataItemParse: return 1 in U16 for S8-item with value '1'." ); - //Return 0 for S16 value 0 - ok ( psMetadataItemParseU16(itemS16) == 0, - "psMetadataItemParse: return 0 in S8 for S16-item with value '0'." ); - //Return 1 for S32 value 1 - ok ( psMetadataItemParseU16(itemS32) == 1, - "psMetadataItemParse: return 1 in U16 for S32-item with value '1'." ); - //Return 2 for U8 value 2 - ok ( psMetadataItemParseU16(itemU8) == 2, - "psMetadataItemParse: return 2 in U16 for U8-item with value '2'." ); - //Return 0 for U16 value 0 - ok ( psMetadataItemParseU16(itemU16) == 0, - "psMetadataItemParse: return 0 in U16 for U16-item with value '0'." ); - //Return 1 for U32 value 1 - ok ( psMetadataItemParseU16(itemU32) == 1, - "psMetadataItemParse: return 1 in U16 for U32-item with value '1'." ); - } - - //U32 Test - { - //Return 0 for NULL item - ok ( psMetadataItemParseU32(NULL) == 0, - "psMetadataItemParse: return 0 for NULL psMetadataItem input." ); - //Return 0 for non-supported type S64 - ok ( psMetadataItemParseU32(itemUnsupported) == 0, - "psMetadataItemParse: return 0 in U32 for S64 (unsupported) " - "psMetadataItem input." ); - //Return 2 for string with "1.666" - ok ( psMetadataItemParseU32(itemString2) == 1, - "psMetadataItemParse: return 1 in U32 for string-item with " - "value '1.666'." ); - //Return 0 for F32 value 0.0 - ok ( psMetadataItemParseU32(itemF32) == 0, - "psMetadataItemParse: return 0 in U32 for F32-item with value '0.0'." ); - //Return 1 for F64 value 0.5 - ok ( psMetadataItemParseU32(itemF64) == 0, - "psMetadataItemParse: return 0 in U32 for F64-item with value '0.5'." ); - //Return 1 for S8 value 1 - ok ( psMetadataItemParseU32(itemS8) == 1, - "psMetadataItemParse: return 1 in U32 for S8-item with value '1'." ); - //Return 0 for S16 value 0 - ok ( psMetadataItemParseU32(itemS16) == 0, - "psMetadataItemParse: return 0 in U32 for S16-item with value '0'." ); - //Return 1 for S32 value 1 - ok ( psMetadataItemParseU32(itemS32) == 1, - "psMetadataItemParse: return 1 in U32 for S32-item with value '1'." ); - //Return 2 for U8 value 2 - ok ( psMetadataItemParseU32(itemU8) == 2, - "psMetadataItemParse: return 2 in U32 for U8-item with value '2'." ); - //Return 0 for U16 value 0 - ok ( psMetadataItemParseU32(itemU16) == 0, - "psMetadataItemParse: return 0 in U32 for U16-item with value '0'." ); - //Return 1 for U32 value 1 - ok ( psMetadataItemParseU32(itemU32) == 1, - "psMetadataItemParse: return 1 in U32 for U32-item with value '1'." ); - } - - //STRING Test - { - //Return NULL for NULL item - ok ( psMetadataItemParseString(NULL) == NULL, - "psMetadataItemParse: return NULL for NULL STRING psMetadataItem " - "input." ); - //Return NULL for non-supported type S64 - ok ( psMetadataItemParseString(itemUnsupported) == NULL, - "psMetadataItemParse: return NULL in STRING for S64 (unsupported)" - " psMetadataItem input." ); - //Return "true" for STRING of value "true" - psString tempString = psMetadataItemParseString(itemString1); - is_strn( tempString, "true", 6, - "psMetadataItemParse: return 'true' in STRING for STRING with " + psMemId id = psMemGetId(); + psMetadataItem *itemBool = psMetadataItemAlloc("bool", PS_DATA_BOOL, "No Comment", true); + psMetadataItem *itemF32 = psMetadataItemAlloc("f32", PS_DATA_F32, "No Comment", 0.00); + psMetadataItem *itemF64 = psMetadataItemAlloc("f64", PS_DATA_F64, "No Comment", 0.50); + psMetadataItem *itemS8 = psMetadataItemAlloc("s8", PS_DATA_S8, "No Comment", 1); + psMetadataItem *itemS16 = psMetadataItemAlloc("s16", PS_DATA_S16, "No Comment", 0); + psMetadataItem *itemS32 = psMetadataItemAlloc("s32", PS_DATA_S32, "No Comment", 1); + psMetadataItem *itemU8 = psMetadataItemAlloc("u8", PS_DATA_U8, "No Comment", 2); + psMetadataItem *itemU16 = psMetadataItemAlloc("u16", PS_DATA_U16, "No Comment", 0); + psMetadataItem *itemU32 = psMetadataItemAlloc("u32", PS_DATA_U32, "No Comment", 1); + psMetadataItem *itemString1 = psMetadataItemAlloc("String", PS_DATA_STRING, "", "true"); + psMetadataItem *itemString2 = psMetadataItemAlloc("String", PS_DATA_STRING, "", "1.666"); + psMetadataItem *itemString11 = psMetadataItemAlloc("String", PS_DATA_STRING, "", "false"); + psMetadataItem *itemUnsupported = psMetadataItemAlloc("s64", PS_DATA_S64, "", 1); + + //TESTS: Bool, F32, F64, S8, S16, S32, U8, U16, U32, String + //BOOL Test + { + //Return false for NULL item + ok ( !psMetadataItemParseBool(NULL), + "psMetadataItemParse: return false in BOOL for NULL psMetadataItem " + "input." ); + //Return false for non-supported type S64 + ok ( !psMetadataItemParseBool(itemUnsupported), + "psMetadataItemParse: return false in BOOL for S64 (unsupported) " + "psMetadataItem input." ); + //Return true for string with "true" + ok ( psMetadataItemParseBool(itemString1), + "psMetadataItemParse: return true in BOOL for string-item with " "value 'true'." ); - psFree(tempString); - - //Return 0.000000 for F32 of value 0.000000 - tempString = psMetadataItemParseString(itemF32); - is_strn( tempString, "0.000000", 4, - "psMetadataItemParse: return '0.000000' in STRING for F32 with " - "value '0.000000'. (actual result=%s)", tempString); - psFree(tempString); - - //Return 0.500000 for F64 value 0.5 - tempString = psMetadataItemParseString(itemF64); - is_strn( tempString, "0.500000", 10, - "psMetadataItemParse: return '0.500000' in STRING for F64 with " - "value '0.5'. (actual result=%s)", tempString); - psFree(tempString); - - //Return 1 for S8 value 1 - tempString = psMetadataItemParseString(itemS8); - is_strn( tempString, "1", 3, - "psMetadataItemParse: return '1' in STRING for S8 with " - "value '1'. (actual result=%s)", tempString); - psFree(tempString); - - //Return 0 for S16 value 0 - tempString = psMetadataItemParseString(itemS16); - is_strn( tempString, "0", 3, - "psMetadataItemParse: return '0' in STRING for S8 with " - "value '0'. (actual result=%s)", tempString); - psFree(tempString); - - //Return 1 for S32 value 1 - tempString = psMetadataItemParseString(itemS32); - is_strn( tempString, "1", 3, - "psMetadataItemParse: return '1' in STRING for S8 with " - "value '1'. (actual result=%s)", tempString); - psFree(tempString); - - //Return 2 for U8 value 2 - tempString = psMetadataItemParseString(itemU8); - is_strn( tempString, "2", 3, - "psMetadataItemParse: return '2' in STRING for S8 with " - "value '2'. (actual result=%s)", tempString); - psFree(tempString); - - //Return 0 for U16 value 0 - tempString = psMetadataItemParseString(itemU16); - is_strn( tempString, "0", 3, - "psMetadataItemParse: return '0' in STRING for S8 with " - "value '0'. (actual result=%s)", tempString); - psFree(tempString); - - //Return 1 for U32 value 1 - tempString = psMetadataItemParseString(itemU32); - is_strn( tempString, "1", 3, - "psMetadataItemParse: return '1' in STRING for S8 with " - "value '1'. (actual result=%s)", tempString); - psFree(tempString); - } - - //Check for Memory leaks - { + //Return false for string with "false" + ok ( !psMetadataItemParseBool(itemString11), + "psMetadataItemParse: return false in BOOL for string-item with " + "value 'false'." ); + //Return false for F32 value 0.0 + ok ( !psMetadataItemParseBool(itemF32), + "psMetadataItemParse: return false in BOOL for F32-item with " + "value '0.0'." ); + //Return true for F64 value 0.5 + ok ( psMetadataItemParseBool(itemF64), + "psMetadataItemParse: return true in BOOL for F64-item with " + "value '0.5'." ); + //Return true for S8 value 1 + ok ( psMetadataItemParseBool(itemS8), + "psMetadataItemParse: return true in BOOL for S8-item with " + "value '1'." ); + //Return false for S16 value 0 + ok ( !psMetadataItemParseBool(itemS16), + "psMetadataItemParse: return false in BOOL for S16-item with " + "value '0'." ); + //Return true for S32 value 1 + ok ( psMetadataItemParseBool(itemS32), + "psMetadataItemParse: return true in BOOL for S32-item with " + "value '1'." ); + //Return true for U8 value 2 + ok ( psMetadataItemParseBool(itemU8), + "psMetadataItemParse: return true in BOOL for U8-item with " + "value '2'." ); + //Return false for U16 value 0 + ok ( !psMetadataItemParseBool(itemU16), + "psMetadataItemParse: return false in BOOL for U16-item with " + "value '0'." ); + //Return true for U32 value 1 + ok ( psMetadataItemParseBool(itemU32), + "psMetadataItemParse: return true in BOOL for U32-item with " + "value '1'." ); + } + + //F32 Test + { + //Return NaN for NULL item + ok ( isnan(psMetadataItemParseF32(NULL)), + "psMetadataItemParse: return NaN for NULL psMetadataItem input." ); + //Return NaN for non-supported type S64 + ok ( isnan(psMetadataItemParseF32(itemUnsupported)), + "psMetadataItemParse: return NaN in F32 for S64 (unsupported) " + "psMetadataItem input." ); + //Return 1.666 for string with "1.666" + is_float( psMetadataItemParseF32(itemString2), 1.666, + "psMetadataItemParse: return 1.666 in F32 for string-item with " + "value '1.666'." ); + //Return 0.0 for F32 value 0.0 + is_float( psMetadataItemParseF32(itemF32), 0.0, + "psMetadataItemParse: return 0.0 in F32 for F32-item with " + "value '0.0'." ); + //Return 0.5 for F64 value 0.5 + is_float( psMetadataItemParseF32(itemF64), 0.5, + "psMetadataItemParse: return 0.5 in F32 for F64-item with " + "value '0.5'." ); + //Return 1.0 for S8 value 1 + is_float( psMetadataItemParseF32(itemS8), 1.0, + "psMetadataItemParse: return 1.0 in F32 for S8-item with " + "value '1'." ); + //Return 0.0 for S16 value 0 + is_float( psMetadataItemParseF32(itemS16), 0.0, + "psMetadataItemParse: return 0.0 in F32 for S16-item with " + "value '0'." ); + //Return 1.0 for S32 value 1 + is_float( psMetadataItemParseF32(itemS32), 1.0, + "psMetadataItemParse: return 1.0 in F32 for S32-item with " + "value '1'." ); + //Return 2.0 for U8 value 2 + is_float( psMetadataItemParseF32(itemU8), 2.0, + "psMetadataItemParse: return 2.0 in F32 for U8-item with " + "value '2'." ); + //Return 0.0 for U16 value 0 + is_float( psMetadataItemParseF32(itemU16), 0.0, + "psMetadataItemParse: return 0.0 in F32 for U16-item with " + "value '0'." ); + //Return 1.0 for U32 value 1 + is_float( psMetadataItemParseF32(itemU32), 1.0, + "psMetadataItemParse: return 1.0 in F32 for U32-item with " + "value '1'." ); + } + + //F64 Test + { + //Return NaN for NULL item + ok ( isnan(psMetadataItemParseF64(NULL)), + "psMetadataItemParse: return NaN for NULL psMetadataItem input." ); + //Return NaN for non-supported type S64 + ok ( isnan(psMetadataItemParseF64(itemUnsupported)), + "psMetadataItemParse: return NaN in F64 for S64 (unsupported) " + "psMetadataItem input." ); + //Return 1.666 for string with "1.666" + is_double_tol( psMetadataItemParseF64(itemString2), 1.666, 0.00001, + "psMetadataItemParse: return 1.666 in F64 for string-item with " + "value '1.666'." ); + //Return 0.0 for F32 value 0.0 + is_double( psMetadataItemParseF64(itemF32), 0.0, + "psMetadataItemParse: return 0.0 in F64 for F32-item with " + "value '0.0'." ); + //Return 0.5 for F64 value 0.5 + is_double( psMetadataItemParseF64(itemF64), 0.5, + "psMetadataItemParse: return 0.5 in F64 for F64-item with " + "value '0.5'." ); + //Return 1.0 for S8 value 1 + is_double( psMetadataItemParseF64(itemS8), 1.0, + "psMetadataItemParse: return 1.0 in F64 for S8-item with " + "value '1'." ); + //Return 0.0 for S16 value 0 + is_double( psMetadataItemParseF64(itemS16), 0.0, + "psMetadataItemParse: return 0.0 in F64 for S16-item with " + "value '0'." ); + //Return 1.0 for S32 value 1 + is_double( psMetadataItemParseF64(itemS32), 1.0, + "psMetadataItemParse: return 1.0 in F64 for S32-item with " + "value '1'." ); + //Return 2.0 for U8 value 2 + is_double( psMetadataItemParseF64(itemU8), 2.0, + "psMetadataItemParse: return 2.0 in F64 for U8-item with " + "value '2'." ); + //Return 0.0 for U16 value 0 + is_double( psMetadataItemParseF64(itemU16), 0.0, + "psMetadataItemParse: return 0.0 in F64 for U16-item with " + "value '0'." ); + //Return 1.0 for U32 value 1 + is_double( psMetadataItemParseF64(itemU32), 1.0, + "psMetadataItemParse: return 1.0 in F64 for U32-item with " + "value '1'." ); + } + + //S8 Test + { + //Return 0 for NULL item + ok ( psMetadataItemParseS8(NULL) == 0, + "psMetadataItemParse: return 0 for NULL psMetadataItem input." ); + //Return 0 for non-supported type S64 + ok ( psMetadataItemParseS8(itemUnsupported) == 0, + "psMetadataItemParse: return 0 in S8 for S64 (unsupported) " + "psMetadataItem input." ); + //Return 2 for string with "1.666" + ok ( psMetadataItemParseS8(itemString2) == 1, + "psMetadataItemParse: return 1 in S8 for string-item with " + "value '1.666'." ); + //Return 0 for F32 value 0.0 + ok ( psMetadataItemParseS8(itemF32) == 0, + "psMetadataItemParse: return 0 in S8 for F32-item with " + "value '0.0'." ); + //Return 1 for F64 value 0.5 + ok ( psMetadataItemParseS8(itemF64) == 0, + "psMetadataItemParse: return 0 in S8 for F64-item with " + "value '0.5'." ); + //Return 1 for S8 value 1 + ok ( psMetadataItemParseS8(itemS8) == 1, + "psMetadataItemParse: return 1 in S8 for S8-item with " + "value '1'." ); + //Return 0 for S16 value 0 + ok ( psMetadataItemParseS8(itemS16) == 0, + "psMetadataItemParse: return 0 in S8 for S16-item with " + "value '0'." ); + //Return 1 for S32 value 1 + ok ( psMetadataItemParseS8(itemS32) == 1, + "psMetadataItemParse: return 1 in S8 for S32-item with " + "value '1'." ); + //Return 2 for U8 value 2 + ok ( psMetadataItemParseS8(itemU8) == 2, + "psMetadataItemParse: return 2 in S8 for U8-item with " + "value '2'." ); + //Return 0 for U16 value 0 + ok ( psMetadataItemParseS8(itemU16) == 0, + "psMetadataItemParse: return 0 in S8 for U16-item with " + "value '0'." ); + //Return 1 for U32 value 1 + ok ( psMetadataItemParseS8(itemU32) == 1, + "psMetadataItemParse: return 1 in S8 for U32-item with " + "value '1'." ); + } + + //S16 Test + { + //Return 0 for NULL item + ok ( psMetadataItemParseS16(NULL) == 0, + "psMetadataItemParse: return 0 for NULL psMetadataItem input." ); + //Return 0 for non-supported type S64 + ok ( psMetadataItemParseS16(itemUnsupported) == 0, + "psMetadataItemParse: return 0 in S16 for S64 (unsupported) " + "psMetadataItem input." ); + //Return 2 for string with "1.666" + ok ( psMetadataItemParseS16(itemString2) == 1, + "psMetadataItemParse: return 1 in S16 for string-item with " + "value '1.666'." ); + //Return 0 for F32 value 0.0 + ok ( psMetadataItemParseS16(itemF32) == 0, + "psMetadataItemParse: return 0 in S16 for F32-item with value '0.0'." ); + //Return 1 for F64 value 0.5 + ok ( psMetadataItemParseS16(itemF64) == 0, + "psMetadataItemParse: return 0 in S16 for F64-item with value '0.5'." ); + //Return 1 for S8 value 1 + ok ( psMetadataItemParseS16(itemS8) == 1, + "psMetadataItemParse: return 1 in S16 for S8-item with value '1'." ); + //Return 0 for S16 value 0 + ok ( psMetadataItemParseS16(itemS16) == 0, + "psMetadataItemParse: return 0 in S16 for S16-item with value '0'." ); + //Return 1 for S32 value 1 + ok ( psMetadataItemParseS16(itemS32) == 1, + "psMetadataItemParse: return 1 in S16 for S32-item with value '1'." ); + //Return 2 for U8 value 2 + ok ( psMetadataItemParseS16(itemU8) == 2, + "psMetadataItemParse: return 2 in S16 for U8-item with value '2'." ); + //Return 0 for U16 value 0 + ok ( psMetadataItemParseS16(itemU16) == 0, + "psMetadataItemParse: return 0 in S16 for U16-item with value '0'." ); + //Return 1 for U32 value 1 + ok ( psMetadataItemParseS16(itemU32) == 1, + "psMetadataItemParse: return 1 in S16 for U32-item with value '1'." ); + } + + //S32 Test + { + //Return 0 for NULL item + ok ( psMetadataItemParseS32(NULL) == 0, + "psMetadataItemParse: return 0 for NULL psMetadataItem input." ); + //Return 0 for non-supported type S64 + ok ( psMetadataItemParseS32(itemUnsupported) == 0, + "psMetadataItemParse: return 0 in S32 for S64 (unsupported) " + "psMetadataItem input." ); + //Return 2 for string with "1.666" + ok ( psMetadataItemParseS32(itemString2) == 1, + "psMetadataItemParse: return 1 in S32 for string-item with " + "value '1.666'." ); + //Return 0 for F32 value 0.0 + ok ( psMetadataItemParseS32(itemF32) == 0, + "psMetadataItemParse: return 0 in S32 for F32-item with value '0.0'." ); + //Return 1 for F64 value 0.5 + ok ( psMetadataItemParseS32(itemF64) == 0, + "psMetadataItemParse: return 0 in S32 for F64-item with value '0.5'." ); + //Return 1 for S8 value 1 + ok ( psMetadataItemParseS32(itemS8) == 1, + "psMetadataItemParse: return 1 in S32 for S8-item with value '1'." ); + //Return 0 for S16 value 0 + ok ( psMetadataItemParseS32(itemS16) == 0, + "psMetadataItemParse: return 0 in S32 for S16-item with value '0'." ); + //Return 1 for S32 value 1 + ok ( psMetadataItemParseS32(itemS32) == 1, + "psMetadataItemParse: return 1 in S32 for S32-item with value '1'." ); + //Return 2 for U8 value 2 + ok ( psMetadataItemParseS32(itemU8) == 2, + "psMetadataItemParse: return 2 in S32 for U8-item with value '2'." ); + //Return 0 for U16 value 0 + ok ( psMetadataItemParseS32(itemU16) == 0, + "psMetadataItemParse: return 0 in S32 for U16-item with value '0'." ); + //Return 1 for U32 value 1 + ok ( psMetadataItemParseS32(itemU32) == 1, + "psMetadataItemParse: return 1 in S32 for U32-item with value '1'." ); + } + + //U8 Test + { + //Return 0 for NULL item + ok ( psMetadataItemParseU8(NULL) == 0, + "psMetadataItemParse: return 0 for NULL psMetadataItem input." ); + //Return 0 for non-supported type S64 + ok ( psMetadataItemParseU8(itemUnsupported) == 0, + "psMetadataItemParse: return 0 in U8 for S64 (unsupported) " + "psMetadataItem input." ); + //Return 2 for string with "1.666" + ok ( psMetadataItemParseU8(itemString2) == 1, + "psMetadataItemParse: return 1 in U8 for string-item with " + "value '1.666'." ); + //Return 0 for F32 value 0.0 + ok ( psMetadataItemParseU8(itemF32) == 0, + "psMetadataItemParse: return 0 in U8 for F32-item with value '0.0'." ); + //Return 1 for F64 value 0.5 + ok ( psMetadataItemParseU8(itemF64) == 0, + "psMetadataItemParse: return 0 in U8 for F64-item with value '0.5'." ); + //Return 1 for S8 value 1 + ok ( psMetadataItemParseU8(itemS8) == 1, + "psMetadataItemParse: return 1 in U8 for S8-item with value '1'." ); + //Return 0 for S16 value 0 + ok ( psMetadataItemParseU8(itemS16) == 0, + "psMetadataItemParse: return 0 in U8 for S16-item with value '0'." ); + //Return 1 for S32 value 1 + ok ( psMetadataItemParseU8(itemS32) == 1, + "psMetadataItemParse: return 1 in U8 for S32-item with value '1'." ); + //Return 2 for U8 value 2 + ok ( psMetadataItemParseU8(itemU8) == 2, + "psMetadataItemParse: return 2 in U8 for U8-item with value '2'." ); + //Return 0 for U16 value 0 + ok ( psMetadataItemParseU8(itemU16) == 0, + "psMetadataItemParse: return 0 in U8 for U16-item with value '0'." ); + //Return 1 for U32 value 1 + ok ( psMetadataItemParseU8(itemU32) == 1, + "psMetadataItemParse: return 1 in U8 for U32-item with value '1'." ); + } + + //U16 Test + { + //Return 0 for NULL item + ok ( psMetadataItemParseU16(NULL) == 0, + "psMetadataItemParse: return 0 for NULL psMetadataItem input." ); + //Return 0 for non-supported type S64 + ok ( psMetadataItemParseU16(itemUnsupported) == 0, + "psMetadataItemParse: return 0 in U16 for S64 (unsupported) " + "psMetadataItem input." ); + //Return 2 for string with "1.666" + ok ( psMetadataItemParseU16(itemString2) == 1, + "psMetadataItemParse: return 1 in U16 for string-item with " + "value '1.666'." ); + //Return 0 for F32 value 0.0 + ok ( psMetadataItemParseU16(itemF32) == 0, + "psMetadataItemParse: return 0 in U16 for F32-item with value '0.0'." ); + //Return 1 for F64 value 0.5 + ok ( psMetadataItemParseU16(itemF64) == 0, + "psMetadataItemParse: return 0 in U16 for F64-item with value '0.5'." ); + //Return 1 for S8 value 1 + ok ( psMetadataItemParseU16(itemS8) == 1, + "psMetadataItemParse: return 1 in U16 for S8-item with value '1'." ); + //Return 0 for S16 value 0 + ok ( psMetadataItemParseU16(itemS16) == 0, + "psMetadataItemParse: return 0 in S8 for S16-item with value '0'." ); + //Return 1 for S32 value 1 + ok ( psMetadataItemParseU16(itemS32) == 1, + "psMetadataItemParse: return 1 in U16 for S32-item with value '1'." ); + //Return 2 for U8 value 2 + ok ( psMetadataItemParseU16(itemU8) == 2, + "psMetadataItemParse: return 2 in U16 for U8-item with value '2'." ); + //Return 0 for U16 value 0 + ok ( psMetadataItemParseU16(itemU16) == 0, + "psMetadataItemParse: return 0 in U16 for U16-item with value '0'." ); + //Return 1 for U32 value 1 + ok ( psMetadataItemParseU16(itemU32) == 1, + "psMetadataItemParse: return 1 in U16 for U32-item with value '1'." ); + } + + //U32 Test + { + //Return 0 for NULL item + ok ( psMetadataItemParseU32(NULL) == 0, + "psMetadataItemParse: return 0 for NULL psMetadataItem input." ); + //Return 0 for non-supported type S64 + ok ( psMetadataItemParseU32(itemUnsupported) == 0, + "psMetadataItemParse: return 0 in U32 for S64 (unsupported) " + "psMetadataItem input." ); + //Return 2 for string with "1.666" + ok ( psMetadataItemParseU32(itemString2) == 1, + "psMetadataItemParse: return 1 in U32 for string-item with " + "value '1.666'." ); + //Return 0 for F32 value 0.0 + ok ( psMetadataItemParseU32(itemF32) == 0, + "psMetadataItemParse: return 0 in U32 for F32-item with value '0.0'." ); + //Return 1 for F64 value 0.5 + ok ( psMetadataItemParseU32(itemF64) == 0, + "psMetadataItemParse: return 0 in U32 for F64-item with value '0.5'." ); + //Return 1 for S8 value 1 + ok ( psMetadataItemParseU32(itemS8) == 1, + "psMetadataItemParse: return 1 in U32 for S8-item with value '1'." ); + //Return 0 for S16 value 0 + ok ( psMetadataItemParseU32(itemS16) == 0, + "psMetadataItemParse: return 0 in U32 for S16-item with value '0'." ); + //Return 1 for S32 value 1 + ok ( psMetadataItemParseU32(itemS32) == 1, + "psMetadataItemParse: return 1 in U32 for S32-item with value '1'." ); + //Return 2 for U8 value 2 + ok ( psMetadataItemParseU32(itemU8) == 2, + "psMetadataItemParse: return 2 in U32 for U8-item with value '2'." ); + //Return 0 for U16 value 0 + ok ( psMetadataItemParseU32(itemU16) == 0, + "psMetadataItemParse: return 0 in U32 for U16-item with value '0'." ); + //Return 1 for U32 value 1 + ok ( psMetadataItemParseU32(itemU32) == 1, + "psMetadataItemParse: return 1 in U32 for U32-item with value '1'." ); + } + + //STRING Test + { + //Return NULL for NULL item + ok ( psMetadataItemParseString(NULL) == NULL, + "psMetadataItemParse: return NULL for NULL STRING psMetadataItem " + "input." ); + //Return NULL for non-supported type S64 + ok ( psMetadataItemParseString(itemUnsupported) == NULL, + "psMetadataItemParse: return NULL in STRING for S64 (unsupported)" + " psMetadataItem input." ); + //Return "true" for STRING of value "true" + psString tempString = psMetadataItemParseString(itemString1); + is_strn( tempString, "true", 6, + "psMetadataItemParse: return 'true' in STRING for STRING with " + "value 'true'." ); + psFree(tempString); + + //Return 0.000000 for F32 of value 0.000000 + tempString = psMetadataItemParseString(itemF32); + is_strn( tempString, "0.000000", 4, + "psMetadataItemParse: return '0.000000' in STRING for F32 with " + "value '0.000000'. (actual result=%s)", tempString); + psFree(tempString); + + //Return 0.500000 for F64 value 0.5 + tempString = psMetadataItemParseString(itemF64); + is_strn( tempString, "0.500000", 10, + "psMetadataItemParse: return '0.500000' in STRING for F64 with " + "value '0.5'. (actual result=%s)", tempString); + psFree(tempString); + + //Return 1 for S8 value 1 + tempString = psMetadataItemParseString(itemS8); + is_strn( tempString, "1", 3, + "psMetadataItemParse: return '1' in STRING for S8 with " + "value '1'. (actual result=%s)", tempString); + psFree(tempString); + + //Return 0 for S16 value 0 + tempString = psMetadataItemParseString(itemS16); + is_strn( tempString, "0", 3, + "psMetadataItemParse: return '0' in STRING for S8 with " + "value '0'. (actual result=%s)", tempString); + psFree(tempString); + + //Return 1 for S32 value 1 + tempString = psMetadataItemParseString(itemS32); + is_strn( tempString, "1", 3, + "psMetadataItemParse: return '1' in STRING for S8 with " + "value '1'. (actual result=%s)", tempString); + psFree(tempString); + + //Return 2 for U8 value 2 + tempString = psMetadataItemParseString(itemU8); + is_strn( tempString, "2", 3, + "psMetadataItemParse: return '2' in STRING for S8 with " + "value '2'. (actual result=%s)", tempString); + psFree(tempString); + + //Return 0 for U16 value 0 + tempString = psMetadataItemParseString(itemU16); + is_strn( tempString, "0", 3, + "psMetadataItemParse: return '0' in STRING for S8 with " + "value '0'. (actual result=%s)", tempString); + psFree(tempString); + + //Return 1 for U32 value 1 + tempString = psMetadataItemParseString(itemU32); + is_strn( tempString, "1", 3, + "psMetadataItemParse: return '1' in STRING for S8 with " + "value '1'. (actual result=%s)", tempString); + psFree(tempString); + } + psFree(itemBool); psFree(itemF32); @@ -525,5 +514,5 @@ psFree(itemString11); psFree(itemUnsupported); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } } Index: trunk/psLib/test/types/tap_psMetadataIterator.c =================================================================== --- trunk/psLib/test/types/tap_psMetadataIterator.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadataIterator.c (revision 12781) @@ -2,8 +2,6 @@ #include #include - #include "tap.h" #include "pstap.h" - #define NAME1 "SIMPLE" @@ -102,10 +100,12 @@ int main (void) { - plan_tests(242); - - note("psMetadataIterator tests"); - - { - note("No regular expressions, forwards"); + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(254); + + // psMetadataIterator tests + // No regular expressions, forwards + { + psMemId id = psMemGetId(); psMetadata *md = mdGenerate(); psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL); @@ -124,8 +124,11 @@ psFree(iter); psFree(md); - } - - { - note("No regular expressions, backwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // No regular expressions, backwards + { + psMemId id = psMemGetId(); psMetadata *md = mdGenerate(); psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_TAIL, NULL); @@ -144,8 +147,11 @@ psFree(iter); psFree(md); - } - - { - note("No regular expressions, jumping in halfway through (using allocator), forwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // No regular expressions, jumping in halfway through (using allocator), forwards + { + psMemId id = psMemGetId(); psMetadata *md = mdGenerate(); psMetadataIterator *iter = psMetadataIteratorAlloc(md, 3, NULL); @@ -161,8 +167,11 @@ psFree(iter); psFree(md); - } - - { - note("No regular expressions, jumping in halfway through (using allocator), backwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // No regular expressions, jumping in halfway through (using allocator), backwards + { + psMemId id = psMemGetId(); psMetadata *md = mdGenerate(); psMetadataIterator *iter = psMetadataIteratorAlloc(md, -4, NULL); @@ -178,8 +187,11 @@ psFree(iter); psFree(md); - } - - { - note("No regular expressions, jumping in halfway through (using set), forwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // No regular expressions, jumping in halfway through (using set), forwards"); + { + psMemId id = psMemGetId(); psMetadata *md = mdGenerate(); psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL); @@ -196,8 +208,11 @@ psFree(iter); psFree(md); - } - - { - note("No regular expressions, jumping in halfway through (using set), backwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // No regular expressions, jumping in halfway through (using set), backwards"); + { + psMemId id = psMemGetId(); psMetadata *md = mdGenerate(); psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL); @@ -214,8 +229,11 @@ psFree(iter); psFree(md); - } - - { - note("With regular expressions, forwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // With regular expressions, forwards"); + { + psMemId id = psMemGetId(); psMetadata *md = mdGenerate(); psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "^" MULTI_NAME "$"); @@ -231,8 +249,11 @@ psFree(iter); psFree(md); - } - - { - note("With regular expressions, backwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // With regular expressions, backwards"); + { + psMemId id = psMemGetId(); psMetadata *md = mdGenerate(); psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_TAIL, "^" MULTI_NAME "$"); @@ -248,8 +269,11 @@ psFree(iter); psFree(md); - } - - { - note("With regular expressions, jumping in halfway through (using allocator), forwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // With regular expressions, jumping in halfway through (using allocator), forwards"); + { + psMemId id = psMemGetId(); psMetadata *md = mdGenerate(); psMetadataIterator *iter = psMetadataIteratorAlloc(md, 2, "^" MULTI_NAME "$"); @@ -263,8 +287,11 @@ psFree(iter); psFree(md); - } - - { - note("With regular expressions, jumping in halfway through (using allocator), backwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // With regular expressions, jumping in halfway through (using allocator), backwards"); + { + psMemId id = psMemGetId(); psMetadata *md = mdGenerate(); psMetadataIterator *iter = psMetadataIteratorAlloc(md, -3, "^" MULTI_NAME "$"); @@ -278,8 +305,11 @@ psFree(iter); psFree(md); - } - - { - note("With regular expressions, jumping in halfway through (using set), forwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // With regular expressions, jumping in halfway through (using set), forwards"); + { + psMemId id = psMemGetId(); psMetadata *md = mdGenerate(); psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "^" MULTI_NAME "$"); @@ -294,8 +324,11 @@ psFree(iter); psFree(md); - } - - { - note("With regular expressions, jumping in halfway through (using set), backwards"); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // With regular expressions, jumping in halfway through (using set), backwards"); + { + psMemId id = psMemGetId(); psMetadata *md = mdGenerate(); psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "^" MULTI_NAME "$"); @@ -310,7 +343,5 @@ psFree(iter); psFree(md); - } - - - return exit_status(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } } Index: trunk/psLib/test/types/tap_psMetadataUpdate.c =================================================================== --- trunk/psLib/test/types/tap_psMetadataUpdate.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadataUpdate.c (revision 12781) @@ -9,8 +9,6 @@ * */ - #include #include - #include "tap.h" #include "pstap.h" @@ -18,11 +16,12 @@ int main(void) { + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); plan_tests(16); + // psMetadataUpdate Tests - note("psMetadataUpdate Tests"); { psMemId id = psMemGetId(); - psMetadata *md = psMetadataAlloc(); psMetadataAddS32 (md, PS_LIST_TAIL, "TEST1", 0, "", 1); @@ -33,7 +32,7 @@ } + { psMemId id = psMemGetId(); - psMetadata *md = psMetadataAlloc(); psMetadataAddS32 (md, PS_LIST_TAIL, "TEST1", 0, "", 1); @@ -44,7 +43,7 @@ } + { psMemId id = psMemGetId(); - psMetadata *md = psMetadataAlloc(); psMetadataAddS32 (md, PS_LIST_TAIL, "TEST1", 0, "", 1); @@ -55,7 +54,7 @@ } + { psMemId id = psMemGetId(); - psMetadata *md = psMetadataAlloc(); psMetadataAddS32 (md, PS_LIST_TAIL, "TEST1", 0, "", 1); @@ -66,7 +65,7 @@ } + { psMemId id = psMemGetId(); - psMetadata *md = psMetadataAlloc(); psMetadataAddS32 (md, PS_LIST_TAIL, "TEST1", 0, "", 1); @@ -77,7 +76,7 @@ } + { psMemId id = psMemGetId(); - psMetadata *input = psMetadataAlloc(); psMetadata *output = psMetadataAlloc(); @@ -86,5 +85,4 @@ psMetadataAddS32 (input, PS_LIST_TAIL, "TEST2", 0, "", 2); psMetadataAddS32 (input, PS_LIST_TAIL, "TEST3", 0, "", 2); - psMetadataAddS32 (output, PS_LIST_TAIL, "TEST1", 0, "", 1); psMetadataAddS32 (output, PS_LIST_TAIL, "TEST2", 0, "", 1); @@ -98,7 +96,7 @@ } + { psMemId id = psMemGetId(); - psMetadata *input = psMetadataAlloc(); psMetadata *output = psMetadataAlloc(); @@ -107,5 +105,4 @@ psMetadataAddS32 (input, PS_LIST_TAIL, "TEST2", 0, "", 2); psMetadataAddS32 (input, PS_LIST_TAIL, "TEST3", 0, "", 2); - psMetadataAddS32 (output, PS_LIST_TAIL, "TEST1", 0, "", 1); psMetadataAddS32 (output, PS_LIST_TAIL, "TEST3", 0, "", 1); @@ -118,7 +115,7 @@ } + { psMemId id = psMemGetId(); - psMetadata *input = psMetadataAlloc(); psMetadata *output = psMetadataAlloc(); Index: trunk/psLib/test/types/tap_psMetadata_copying.c =================================================================== --- trunk/psLib/test/types/tap_psMetadata_copying.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadata_copying.c (revision 12781) @@ -10,393 +10,380 @@ * */ - #include #include - #include "tap.h" #include "pstap.h" -void testMetadataCopy(void); -void testMetadataItemCopy(void); -void testMetadataItemTransfer(void); int main(void) { psLogSetFormat("HLNM"); - plan_tests(39); - - testMetadataCopy(); - testMetadataItemCopy(); - testMetadataItemTransfer(); - - done(); -} - -void testMetadataCopy(void) -{ - psMetadata *in = NULL; - psMetadata *out = NULL; - psMetadataItem *tempItem = NULL; - psMetadataItem *outItem = NULL; - psMetadataItem *inItem = NULL; - psMetadata *outTest = NULL; - - //Return NULL for NULL psMetadata input + psLogSetLevel(PS_LOG_INFO); + plan_tests(41); + + + // testMetadataCopy() { - outTest = psMetadataCopy(out, NULL); - ok( outTest == NULL, - "psMetadataCopy: return NULL for NULL input metadata."); - } - //Return allocated out for NULL psMetadata input (with allocated out) - { - out = psMetadataAlloc(); - outTest = psMetadataCopy(out, NULL); - ok( outTest == NULL, - "psMetadataCopy: return out for NULL input metadata."); + psMemId id = psMemGetId(); + psMetadata *in = NULL; + psMetadata *out = NULL; + psMetadataItem *tempItem = NULL; + psMetadataItem *outItem = NULL; + psMetadataItem *inItem = NULL; + psMetadata *outTest = NULL; + + //Return NULL for NULL psMetadata input + { + outTest = psMetadataCopy(out, NULL); + ok( outTest == NULL, + "psMetadataCopy: return NULL for NULL input metadata."); + } + //Return allocated out for NULL psMetadata input (with allocated out) + { + out = psMetadataAlloc(); + outTest = psMetadataCopy(out, NULL); + ok( outTest == NULL, + "psMetadataCopy: return out for NULL input metadata."); + psFree(out); + out = NULL; + } + //Return NULL for attempt to copy item of unsupported data type - NULL out metadata + psMetadataItem *notype = NULL; + { + in = psMetadataAlloc(); + psMetadataAddS32(in, PS_LIST_HEAD, "S32", 0, "", 1); + notype = psMetadataGet(in, PS_LIST_HEAD); + notype->type = -1; + outTest = psMetadataCopy(out, in); + ok( outTest == NULL, + "psMetadataCopy: return NULL for metadata with item of bad type."); + psFree(out); + out = NULL; + } + //Return NULL for attempt to copy item of unsupported data type - allocated out metadata + { + out = psMetadataAlloc(); + psMetadataAddS32(out, PS_LIST_TAIL, "S32", 0, "", 2); + outTest = psMetadataCopy(out, in); + ok( outTest == NULL, + "psMetadataCopy: return NULL for metadata with item of bad type."); + notype->type = PS_DATA_S32; + psFree(out); + out = NULL; + psFree(in); + in = NULL; + } + + //Return NULL for NULL psMetadata input->list + in = psMetadataAlloc(); + if (in->list != NULL) { + psFree(in->list); + in->list = NULL; + } + { + outTest = psMetadataCopy(out, in); + ok( outTest == NULL, + "psMetadataCopy: return NULL for NULL metadata input->list."); + } + /* //Return NULL for NULL psMetadata input->list (with allocated out) + { + out = psMetadataAlloc(); + out = psMetadataCopy(out, in); + ok( out == NULL, + "psMetadataCopy: return NULL for NULL metadata input->list."); + } + */ + //Return valid (but empty) metadata for NULL out input and empty input metadata. + in->list = psListAlloc(NULL); + psFree(in); + in = psMetadataAlloc(); + if (out != NULL) { + psFree(out); + out = NULL; + } + outTest = psMetadataCopy(out, in); + tempItem = psMetadataGet(in, PS_LIST_HEAD); + { + ok( outTest != NULL && tempItem == NULL, + "psMetadataCopy: return empty copy with no items for empty input metadata."); + psFree(out); + psFree(outTest); + out = NULL; + outTest = NULL; + } + + //Test case: multiCheckItem->type == PS_DATA_METADATA_MULTI + psMetadataAddS32(in, PS_LIST_HEAD, "S32", 0, "", 1); + psMetadataAddS32(in, PS_LIST_TAIL, "S32", PS_META_DUPLICATE_OK, "", 1); + outTest = psMetadataCopy(out, in); + tempItem = psMetadataGet(outTest, PS_LIST_HEAD); + { + ok( tempItem->type == PS_DATA_S32 && tempItem->data.S32 == 1, + "psMetadataCopy: return valid copy for a PS_DATA_METADATA_MULTI entry."); + psFree(outTest); + outTest = NULL; + } + + //Test case: !psMetadataAddItem(out, newItem, PS_LIST_TAIL, flag) + //XXX: doesn't seem to be easily reachable, certainly by the user... Skipping. + + //Test case: simple valid test + psFree(in); psFree(out); out = NULL; - } - //Return NULL for attempt to copy item of unsupported data type - NULL out metadata - psMetadataItem *notype = NULL; - { in = psMetadataAlloc(); - psMetadataAddS32(in, PS_LIST_HEAD, "S32", 0, "", 1); - notype = psMetadataGet(in, PS_LIST_HEAD); - notype->type = -1; + psMetadataAddS32(in, PS_LIST_HEAD, "S32", 0, "", 666); outTest = psMetadataCopy(out, in); - ok( outTest == NULL, - "psMetadataCopy: return NULL for metadata with item of bad type."); - psFree(out); - out = NULL; - } - //Return NULL for attempt to copy item of unsupported data type - allocated out metadata - { - out = psMetadataAlloc(); - psMetadataAddS32(out, PS_LIST_TAIL, "S32", 0, "", 2); - outTest = psMetadataCopy(out, in); - ok( outTest == NULL, - "psMetadataCopy: return NULL for metadata with item of bad type."); - notype->type = PS_DATA_S32; - psFree(out); - out = NULL; - psFree(in); - in = NULL; - } - - //Return NULL for NULL psMetadata input->list - in = psMetadataAlloc(); - if (in->list != NULL) { - psFree(in->list); - in->list = NULL; - } - { - outTest = psMetadataCopy(out, in); - ok( outTest == NULL, - "psMetadataCopy: return NULL for NULL metadata input->list."); - } - /* //Return NULL for NULL psMetadata input->list (with allocated out) - { - out = psMetadataAlloc(); - out = psMetadataCopy(out, in); - ok( out == NULL, - "psMetadataCopy: return NULL for NULL metadata input->list."); - } - */ - //Return valid (but empty) metadata for NULL out input and empty input metadata. - in->list = psListAlloc(NULL); - psFree(in); - in = psMetadataAlloc(); - if (out != NULL) { - psFree(out); - out = NULL; - } - outTest = psMetadataCopy(out, in); - tempItem = psMetadataGet(in, PS_LIST_HEAD); - { - ok( outTest != NULL && tempItem == NULL, - "psMetadataCopy: return empty copy with no items for empty input metadata."); - psFree(out); + outItem = psMetadataGet(outTest, PS_LIST_HEAD); + inItem = psMetadataGet(in, PS_LIST_HEAD); + { + ok( outItem->type == PS_DATA_S32 && outItem->data.S32 == inItem->data.S32 && + (strncmp(inItem->name, outItem->name, 10) == 0), + "psMetadataCopy: return valid copy of metadata with 1 S32 entry."); + } psFree(outTest); - out = NULL; - outTest = NULL; - } - - //Test case: multiCheckItem->type == PS_DATA_METADATA_MULTI - psMetadataAddS32(in, PS_LIST_HEAD, "S32", 0, "", 1); - psMetadataAddS32(in, PS_LIST_TAIL, "S32", PS_META_DUPLICATE_OK, "", 1); - outTest = psMetadataCopy(out, in); - tempItem = psMetadataGet(outTest, PS_LIST_HEAD); - { - ok( tempItem->type == PS_DATA_S32 && tempItem->data.S32 == 1, - "psMetadataCopy: return valid copy for a PS_DATA_METADATA_MULTI entry."); - psFree(outTest); - outTest = NULL; - } - - //Test case: !psMetadataAddItem(out, newItem, PS_LIST_TAIL, flag) - //XXX: doesn't seem to be easily reachable, certainly by the user... Skipping. - - //Test case: simple valid test - psFree(in); - psFree(out); - out = NULL; - in = psMetadataAlloc(); - psMetadataAddS32(in, PS_LIST_HEAD, "S32", 0, "", 666); - outTest = psMetadataCopy(out, in); - outItem = psMetadataGet(outTest, PS_LIST_HEAD); - inItem = psMetadataGet(in, PS_LIST_HEAD); - { - ok( outItem->type == PS_DATA_S32 && outItem->data.S32 == inItem->data.S32 && - (strncmp(inItem->name, outItem->name, 10) == 0), - "psMetadataCopy: return valid copy of metadata with 1 S32 entry."); - } - psFree(outTest); - //Check for Memory Leaks - { psFree(in); psFree(out); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } -} - -void testMetadataItemCopy(void) -{ - //Return NULL for NULL input psMetadataItem + + // testMetadataItemCopy() { - ok( psMetadataItemCopy(NULL) == NULL, - "psMetadataItemCopy: return NULL for NULL input metadataItem."); - } - - //Test Simple types: Bool, S8, S16, S32, S64, U8, U16, U32, U64, F32, F64, STRING - psMetadataItem *itemBool = psMetadataItemAlloc("itemBool", PS_DATA_BOOL, "", false); - psMetadataItem *itemS8 = psMetadataItemAlloc("itemS8", PS_DATA_S8, "", 1); - psMetadataItem *itemS16 = psMetadataItemAlloc("itemS16", PS_DATA_S16, "", 2); - psMetadataItem *itemS32 = psMetadataItemAlloc("itemS32", PS_DATA_S32, "", 3); - psMetadataItem *itemS64 = psMetadataItemAlloc("itemS64", PS_DATA_S64, "", (psS64)4); - psMetadataItem *itemU8 = psMetadataItemAlloc("itemU8", PS_DATA_U8, "", 1); - psMetadataItem *itemU16 = psMetadataItemAlloc("itemU16", PS_DATA_U16, "", 2); - psMetadataItem *itemU32 = psMetadataItemAlloc("itemU32", PS_DATA_U32, "", 3); - psMetadataItem *itemU64 = psMetadataItemAlloc("itemU64", PS_DATA_U64, "", 4); - psMetadataItem *itemF32 = psMetadataItemAlloc("itemF32", PS_DATA_F32, "", 3.0); - psMetadataItem *itemF64 = psMetadataItemAlloc("itemF64", PS_DATA_F64, "", 4.0); - psMetadataItem *itemString = psMetadataItemAlloc("itemString", PS_DATA_STRING, "", "I M STRiNG"); - psMetadataItem *copy = NULL; - //Bool case - { - copy = psMetadataItemCopy(itemBool); - ok( (copy->type == PS_DATA_BOOL && (strncmp(copy->name, "itemBool", 10) == 0) && - !copy->data.B && strncmp(copy->comment, "", 2) == 0), - "psMetadataItemCopy: return valid copy of BOOL item."); - psFree(copy); - } - //S8 case - { - copy = psMetadataItemCopy(itemS8); - ok( (copy->type == PS_DATA_S8 && (strncmp(copy->name, "itemS8", 10) == 0) && - copy->data.S8 == 1 && strncmp(copy->comment, "", 2) == 0), - "psMetadataItemCopy: return valid copy of S8 item."); - psFree(copy); - } - //S16 case - { - copy = psMetadataItemCopy(itemS16); - ok( (copy->type == PS_DATA_S16 && (strncmp(copy->name, "itemS16", 10) == 0) && - copy->data.S16 == 2 && strncmp(copy->comment, "", 2) == 0), - "psMetadataItemCopy: return valid copy of S16 item."); - psFree(copy); - } - //S32 case - { - copy = psMetadataItemCopy(itemS32); - ok( (copy->type == PS_DATA_S32 && (strncmp(copy->name, "itemS32", 10) == 0) && - copy->data.S32 == 3 && strncmp(copy->comment, "", 2) == 0), - "psMetadataItemCopy: return valid copy of S32 item."); - psFree(copy); - } - - // S64 case - { - psMetadataItem *copy = psMetadataItemCopy(itemS64); - - ok(copy->type == PS_DATA_S64, "item type"); - is_str(copy->name, "itemS64", "item name"); - is_long(copy->data.S64, 4, "item data"); - is_str(copy->comment, "", "item comment"); - - psFree(copy); - } - - //U8 case - { - copy = psMetadataItemCopy(itemU8); - ok( (copy->type == PS_DATA_U8 && (strncmp(copy->name, "itemU8", 10) == 0) && - copy->data.U8 == 1 && strncmp(copy->comment, "", 2) == 0), - "psMetadataItemCopy: return valid copy of U8 item."); - psFree(copy); - } - //U16 case - { - copy = psMetadataItemCopy(itemU16); - ok( (copy->type == PS_DATA_U16 && (strncmp(copy->name, "itemU16", 10) == 0) && - copy->data.U16 == 2 && strncmp(copy->comment, "", 2) == 0), - "psMetadataItemCopy: return valid copy of U16 item."); - psFree(copy); - } - //U32 case - { - copy = psMetadataItemCopy(itemU32); - ok( (copy->type == PS_DATA_U32 && (strncmp(copy->name, "itemU32", 10) == 0) && - copy->data.U32 == 3 && strncmp(copy->comment, "", 2) == 0), - "psMetadataItemCopy: return valid copy of U32 item."); - psFree(copy); - } - //U64 case - { - copy = psMetadataItemCopy(itemU64); - ok( (copy->type == PS_DATA_U64 && (strncmp(copy->name, "itemU64", 10) == 0) && - copy->data.U64 == 4 && strncmp(copy->comment, "", 2) == 0), - "psMetadataItemCopy: return valid copy of U64 item."); - psFree(copy); - } - //F32 case - { - copy = psMetadataItemCopy(itemF32); - ok( (copy->type == PS_DATA_F32 && (strncmp(copy->name, "itemF32", 10) == 0) && - abs(copy->data.F32-3.0) < FLT_EPSILON && strncmp(copy->comment, "", 2) == 0), - "psMetadataItemCopy: return valid copy of F32 item."); - psFree(copy); - } - //F64 case - { - copy = psMetadataItemCopy(itemF64); - ok( (copy->type == PS_DATA_F64 && (strncmp(copy->name, "itemF64", 10) == 0) && - abs(copy->data.F64-4.0) < DBL_EPSILON && strncmp(copy->comment, "", 2) == 0), - "psMetadataItemCopy: return valid copy of F64 item."); - psFree(copy); - } - //STRING case - { - copy = psMetadataItemCopy(itemString); - ok( (copy->type == PS_DATA_STRING && (strncmp(copy->name, "itemString", 12) == 0) && - strncmp(copy->data.str,"I M STRiNG",12) == 0 && strncmp(copy->comment,"",2) == 0), - "psMetadataItemCopy: return valid copy of STRING item."); - psFree(copy); - } - - //Test Remaining types: Vector, Time, Metadata, Region - psVector *inV = psVectorAlloc(2, PS_TYPE_S32); - psVectorSet(inV, 0, 666); - psVectorSet(inV, 1, 667); - psMetadataItem *itemVector = psMetadataItemAlloc("itemVector", PS_DATA_VECTOR, "", inV); - psTime *teaTime = psTimeAlloc(PS_TIME_TAI); - teaTime->sec = 1; - teaTime->nsec = 0; - teaTime->leapsecond = true; - psMetadataItem *itemTime = psMetadataItemAlloc("itemTime", PS_DATA_TIME, "", teaTime); - psMetadata *md = psMetadataAlloc(); - psMetadataAddS32(md, PS_LIST_HEAD, "mdS32", 0, "", 666); - psMetadataItem *itemMD = psMetadataItemAlloc("itemMD", PS_DATA_METADATA, "", md); - psRegion *reg = psRegionAlloc(0.0, 2.0, 1.0, 3.0); - psMetadataItem *itemRegion = psMetadataItemAlloc("itemRegion", PS_DATA_REGION, "", reg); - //Vector case - { - copy = psMetadataItemCopy(itemVector); - int int0 = ((psVector*)(copy->data.V))->data.S32[0]; - int int1 = ((psVector*)(copy->data.V))->data.S32[1]; - ok( (copy->type == PS_DATA_VECTOR && (strncmp(copy->name, "itemVector", 12) == 0) - && int0 == 666 && int1 == 667 && strncmp(copy->comment,"",2) == 0), - "psMetadataItemCopy: return valid copy of Vector item."); - psFree(copy); - } - //Vector case - invalid vector item - { - psFree(itemVector->data.V); - itemVector->data.V = NULL; - copy = psMetadataItemCopy(itemVector); - ok( copy == NULL, "psMetadataItemCopy: return NULL for invalid vector item"); - // itemVector->data.V = psVectorAlloc(1, PS_TYPE_S32); - } - //Time case - { - copy = psMetadataItemCopy(itemTime); - int int0 = (int)((psTime*)(copy->data.V))->sec; - int int1 = (int)((psTime*)(copy->data.V))->nsec; - bool leap = ((psTime*)(copy->data.V))->leapsecond; - ok( (copy->type == PS_DATA_TIME && (strncmp(copy->name, "itemTime", 12) == 0) - && int0 == 1 && int1 == 0 && strncmp(copy->comment,"",2) == 0) && leap, - "psMetadataItemCopy: return valid copy of Time item."); - psFree(copy); - } - //Time case - invalid time item - { - psTime *t = psTimeAlloc(PS_TIME_TT); - t->type += 1; - psMetadataItem *itemTime2 = psMetadataItemAlloc("itemTime", PS_DATA_TIME, "", t); - copy = psMetadataItemCopy(itemTime2); - ok( copy != NULL && copy->data.V == NULL, - "psMetadataItemCopy: return non-NULL item for invalid input time item"); - psFree(t); - psFree(copy); - psFree(itemTime2); - } - //Time case - NULL time item - { - psFree(itemTime->data.V); - itemTime->data.V = NULL; - copy = psMetadataItemCopy(itemTime); - ok( copy != NULL && copy->data.V == NULL, - "psMetadataItemCopy: return non-NULL item for NULL input time item"); - // (itemTime->data.V) = psTimeAlloc(PS_TIME_TAI); - psFree(copy); - } - //Metadata case - { - copy = psMetadataItemCopy(itemMD); - psMetadataItem *testItem = NULL; - testItem = psMetadataGet(((psMetadata*)(copy->data.V)), PS_LIST_HEAD); - if (testItem == NULL) - printf("\nError in psMetadataGet.\n"); - ok( copy->type == PS_DATA_METADATA && strncmp(copy->name, "itemMD", 8) == 0 - && (strncmp(copy->comment, "",2) == 0) && testItem->type == PS_DATA_S32 - && (strncmp(testItem->name, "mdS32", 10) == 0) && testItem->data.S32 == 666 - && (strncmp(testItem->comment,"",2) == 0), - "psMetadataItemCopy: return valid copy of Metadata item."); - psFree(copy); - } - //Region case - { - copy = psMetadataItemCopy(itemRegion); - float x0 = ((psRegion*)(copy->data.V))->x0; - float x1 = ((psRegion*)(copy->data.V))->x1; - float y0 = ((psRegion*)(copy->data.V))->y0; - float y1 = ((psRegion*)(copy->data.V))->y1; - ok( (copy->type == PS_DATA_REGION && (strncmp(copy->name, "itemRegion", 12) == 0) - && abs(x0-0.0) < FLT_EPSILON && abs(x1-2.0) < FLT_EPSILON - && abs(y0-1.0) < FLT_EPSILON && abs(y1-3.0) < FLT_EPSILON - && strncmp(copy->comment,"",2) == 0), - "psMetadataItemCopy: return valid copy of Region item."); - psFree(copy); - } - - //Test Unsupported type - (sphere for example) - psSphere *sphere = psSphereAlloc(); - sphere->r = 1.0; - sphere->d = 6.66; - psMetadataItem *itemSphere = psMetadataItemAlloc("itemSphere", PS_DATA_SPHERE, "", sphere); - psFree(sphere); - { - copy = psMetadataItemCopy(itemSphere); - float R = ((psSphere*)(copy->data.V))->r; - float D = ((psSphere*)(copy->data.V))->d; - ok( (copy->type == PS_DATA_SPHERE && (strncmp(copy->name, "itemSphere", 12) == 0) && - abs(R - 1.0) < FLT_EPSILON && abs(D - 6.66) < FLT_EPSILON && - strncmp(copy->comment,"",2) == 0), - "psMetadataItemCopy: return valid copy of SPHERE item."); - psFree(copy); - } - - //Check for Memory Leaks before exit - { + psMemId id = psMemGetId(); + //Return NULL for NULL input psMetadataItem + { + ok( psMetadataItemCopy(NULL) == NULL, + "psMetadataItemCopy: return NULL for NULL input metadataItem."); + } + + //Test Simple types: Bool, S8, S16, S32, S64, U8, U16, U32, U64, F32, F64, STRING + psMetadataItem *itemBool = psMetadataItemAlloc("itemBool", PS_DATA_BOOL, "", false); + psMetadataItem *itemS8 = psMetadataItemAlloc("itemS8", PS_DATA_S8, "", 1); + psMetadataItem *itemS16 = psMetadataItemAlloc("itemS16", PS_DATA_S16, "", 2); + psMetadataItem *itemS32 = psMetadataItemAlloc("itemS32", PS_DATA_S32, "", 3); + psMetadataItem *itemS64 = psMetadataItemAlloc("itemS64", PS_DATA_S64, "", (psS64)4); + psMetadataItem *itemU8 = psMetadataItemAlloc("itemU8", PS_DATA_U8, "", 1); + psMetadataItem *itemU16 = psMetadataItemAlloc("itemU16", PS_DATA_U16, "", 2); + psMetadataItem *itemU32 = psMetadataItemAlloc("itemU32", PS_DATA_U32, "", 3); + psMetadataItem *itemU64 = psMetadataItemAlloc("itemU64", PS_DATA_U64, "", 4); + psMetadataItem *itemF32 = psMetadataItemAlloc("itemF32", PS_DATA_F32, "", 3.0); + psMetadataItem *itemF64 = psMetadataItemAlloc("itemF64", PS_DATA_F64, "", 4.0); + psMetadataItem *itemString = psMetadataItemAlloc("itemString", PS_DATA_STRING, "", "I M STRiNG"); + psMetadataItem *copy = NULL; + //Bool case + { + copy = psMetadataItemCopy(itemBool); + ok( (copy->type == PS_DATA_BOOL && (strncmp(copy->name, "itemBool", 10) == 0) && + !copy->data.B && strncmp(copy->comment, "", 2) == 0), + "psMetadataItemCopy: return valid copy of BOOL item."); + psFree(copy); + } + //S8 case + { + copy = psMetadataItemCopy(itemS8); + ok( (copy->type == PS_DATA_S8 && (strncmp(copy->name, "itemS8", 10) == 0) && + copy->data.S8 == 1 && strncmp(copy->comment, "", 2) == 0), + "psMetadataItemCopy: return valid copy of S8 item."); + psFree(copy); + } + //S16 case + { + copy = psMetadataItemCopy(itemS16); + ok( (copy->type == PS_DATA_S16 && (strncmp(copy->name, "itemS16", 10) == 0) && + copy->data.S16 == 2 && strncmp(copy->comment, "", 2) == 0), + "psMetadataItemCopy: return valid copy of S16 item."); + psFree(copy); + } + //S32 case + { + copy = psMetadataItemCopy(itemS32); + ok( (copy->type == PS_DATA_S32 && (strncmp(copy->name, "itemS32", 10) == 0) && + copy->data.S32 == 3 && strncmp(copy->comment, "", 2) == 0), + "psMetadataItemCopy: return valid copy of S32 item."); + psFree(copy); + } + + // S64 case + { + psMetadataItem *copy = psMetadataItemCopy(itemS64); + + ok(copy->type == PS_DATA_S64, "item type"); + is_str(copy->name, "itemS64", "item name"); + is_long(copy->data.S64, 4, "item data"); + is_str(copy->comment, "", "item comment"); + + psFree(copy); + } + + //U8 case + { + copy = psMetadataItemCopy(itemU8); + ok( (copy->type == PS_DATA_U8 && (strncmp(copy->name, "itemU8", 10) == 0) && + copy->data.U8 == 1 && strncmp(copy->comment, "", 2) == 0), + "psMetadataItemCopy: return valid copy of U8 item."); + psFree(copy); + } + //U16 case + { + copy = psMetadataItemCopy(itemU16); + ok( (copy->type == PS_DATA_U16 && (strncmp(copy->name, "itemU16", 10) == 0) && + copy->data.U16 == 2 && strncmp(copy->comment, "", 2) == 0), + "psMetadataItemCopy: return valid copy of U16 item."); + psFree(copy); + } + //U32 case + { + copy = psMetadataItemCopy(itemU32); + ok( (copy->type == PS_DATA_U32 && (strncmp(copy->name, "itemU32", 10) == 0) && + copy->data.U32 == 3 && strncmp(copy->comment, "", 2) == 0), + "psMetadataItemCopy: return valid copy of U32 item."); + psFree(copy); + } + //U64 case + { + copy = psMetadataItemCopy(itemU64); + ok( (copy->type == PS_DATA_U64 && (strncmp(copy->name, "itemU64", 10) == 0) && + copy->data.U64 == 4 && strncmp(copy->comment, "", 2) == 0), + "psMetadataItemCopy: return valid copy of U64 item."); + psFree(copy); + } + //F32 case + { + copy = psMetadataItemCopy(itemF32); + ok( (copy->type == PS_DATA_F32 && (strncmp(copy->name, "itemF32", 10) == 0) && + abs(copy->data.F32-3.0) < FLT_EPSILON && strncmp(copy->comment, "", 2) == 0), + "psMetadataItemCopy: return valid copy of F32 item."); + psFree(copy); + } + //F64 case + { + copy = psMetadataItemCopy(itemF64); + ok( (copy->type == PS_DATA_F64 && (strncmp(copy->name, "itemF64", 10) == 0) && + abs(copy->data.F64-4.0) < DBL_EPSILON && strncmp(copy->comment, "", 2) == 0), + "psMetadataItemCopy: return valid copy of F64 item."); + psFree(copy); + } + //STRING case + { + copy = psMetadataItemCopy(itemString); + ok( (copy->type == PS_DATA_STRING && (strncmp(copy->name, "itemString", 12) == 0) && + strncmp(copy->data.str,"I M STRiNG",12) == 0 && strncmp(copy->comment,"",2) == 0), + "psMetadataItemCopy: return valid copy of STRING item."); + psFree(copy); + } + + //Test Remaining types: Vector, Time, Metadata, Region + psVector *inV = psVectorAlloc(2, PS_TYPE_S32); + psVectorSet(inV, 0, 666); + psVectorSet(inV, 1, 667); + psMetadataItem *itemVector = psMetadataItemAlloc("itemVector", PS_DATA_VECTOR, "", inV); + psTime *teaTime = psTimeAlloc(PS_TIME_TAI); + teaTime->sec = 1; + teaTime->nsec = 0; + teaTime->leapsecond = true; + psMetadataItem *itemTime = psMetadataItemAlloc("itemTime", PS_DATA_TIME, "", teaTime); + psMetadata *md = psMetadataAlloc(); + psMetadataAddS32(md, PS_LIST_HEAD, "mdS32", 0, "", 666); + psMetadataItem *itemMD = psMetadataItemAlloc("itemMD", PS_DATA_METADATA, "", md); + psRegion *reg = psRegionAlloc(0.0, 2.0, 1.0, 3.0); + psMetadataItem *itemRegion = psMetadataItemAlloc("itemRegion", PS_DATA_REGION, "", reg); + //Vector case + { + copy = psMetadataItemCopy(itemVector); + int int0 = ((psVector*)(copy->data.V))->data.S32[0]; + int int1 = ((psVector*)(copy->data.V))->data.S32[1]; + ok( (copy->type == PS_DATA_VECTOR && (strncmp(copy->name, "itemVector", 12) == 0) + && int0 == 666 && int1 == 667 && strncmp(copy->comment,"",2) == 0), + "psMetadataItemCopy: return valid copy of Vector item."); + psFree(copy); + } + //Vector case - invalid vector item + { + psFree(itemVector->data.V); + itemVector->data.V = NULL; + copy = psMetadataItemCopy(itemVector); + ok( copy == NULL, "psMetadataItemCopy: return NULL for invalid vector item"); + // itemVector->data.V = psVectorAlloc(1, PS_TYPE_S32); + } + //Time case + { + copy = psMetadataItemCopy(itemTime); + int int0 = (int)((psTime*)(copy->data.V))->sec; + int int1 = (int)((psTime*)(copy->data.V))->nsec; + bool leap = ((psTime*)(copy->data.V))->leapsecond; + ok( (copy->type == PS_DATA_TIME && (strncmp(copy->name, "itemTime", 12) == 0) + && int0 == 1 && int1 == 0 && strncmp(copy->comment,"",2) == 0) && leap, + "psMetadataItemCopy: return valid copy of Time item."); + psFree(copy); + } + //Time case - invalid time item + { + psTime *t = psTimeAlloc(PS_TIME_TT); + t->type += 1; + psMetadataItem *itemTime2 = psMetadataItemAlloc("itemTime", PS_DATA_TIME, "", t); + copy = psMetadataItemCopy(itemTime2); + ok( copy != NULL && copy->data.V == NULL, + "psMetadataItemCopy: return non-NULL item for invalid input time item"); + psFree(t); + psFree(copy); + psFree(itemTime2); + } + //Time case - NULL time item + { + psFree(itemTime->data.V); + itemTime->data.V = NULL; + copy = psMetadataItemCopy(itemTime); + ok( copy != NULL && copy->data.V == NULL, + "psMetadataItemCopy: return non-NULL item for NULL input time item"); + // (itemTime->data.V) = psTimeAlloc(PS_TIME_TAI); + psFree(copy); + } + //Metadata case + { + copy = psMetadataItemCopy(itemMD); + psMetadataItem *testItem = NULL; + testItem = psMetadataGet(((psMetadata*)(copy->data.V)), PS_LIST_HEAD); + if (testItem == NULL) + printf("\nError in psMetadataGet.\n"); + ok( copy->type == PS_DATA_METADATA && strncmp(copy->name, "itemMD", 8) == 0 + && (strncmp(copy->comment, "",2) == 0) && testItem->type == PS_DATA_S32 + && (strncmp(testItem->name, "mdS32", 10) == 0) && testItem->data.S32 == 666 + && (strncmp(testItem->comment,"",2) == 0), + "psMetadataItemCopy: return valid copy of Metadata item."); + psFree(copy); + } + //Region case + { + copy = psMetadataItemCopy(itemRegion); + float x0 = ((psRegion*)(copy->data.V))->x0; + float x1 = ((psRegion*)(copy->data.V))->x1; + float y0 = ((psRegion*)(copy->data.V))->y0; + float y1 = ((psRegion*)(copy->data.V))->y1; + ok( (copy->type == PS_DATA_REGION && (strncmp(copy->name, "itemRegion", 12) == 0) + && abs(x0-0.0) < FLT_EPSILON && abs(x1-2.0) < FLT_EPSILON + && abs(y0-1.0) < FLT_EPSILON && abs(y1-3.0) < FLT_EPSILON + && strncmp(copy->comment,"",2) == 0), + "psMetadataItemCopy: return valid copy of Region item."); + psFree(copy); + } + + //Test Unsupported type - (sphere for example) + psSphere *sphere = psSphereAlloc(); + sphere->r = 1.0; + sphere->d = 6.66; + psMetadataItem *itemSphere = psMetadataItemAlloc("itemSphere", PS_DATA_SPHERE, "", sphere); + psFree(sphere); + { + copy = psMetadataItemCopy(itemSphere); + float R = ((psSphere*)(copy->data.V))->r; + float D = ((psSphere*)(copy->data.V))->d; + ok( (copy->type == PS_DATA_SPHERE && (strncmp(copy->name, "itemSphere", 12) == 0) && + abs(R - 1.0) < FLT_EPSILON && abs(D - 6.66) < FLT_EPSILON && + strncmp(copy->comment,"",2) == 0), + "psMetadataItemCopy: return valid copy of SPHERE item."); + psFree(copy); + } + psFree(itemSphere); psFree(inV); @@ -420,77 +407,74 @@ psFree(itemMD); psFree(itemRegion); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } -} - -void testMetadataItemTransfer(void) -{ - psMetadata *out = psMetadataAlloc(); - psMetadata *in = psMetadataAlloc(); - psString key = psStringAlloc(30); - strncpy(key, "key", 4); - - //Return false for NULL in input + + // testMetadataItemTransfer() { - ok( !psMetadataItemSupplement(out, NULL, key), - "psMetadataItemSupplement: return false for NULL in metadata."); - } - //Return false for NULL out input - { - ok( !psMetadataItemSupplement(NULL, in, key), - "psMetadataItemSupplement: return false for NULL out metadata."); - } - //Return false for NULL key input - { - ok( !psMetadataItemSupplement(out, in, NULL), - "psMetadataItemSupplement: return false for NULL key string."); - } - psMetadataAddS32(in, PS_LIST_HEAD, "key", PS_META_NO_REPLACE, "", 666); - psMetadataAddF32(out, PS_LIST_HEAD, "out", 0, "", 6.66); - - //Return true for valid inputs - { - bool transfered = psMetadataItemSupplement(out, in, key); - psMetadataItem *item = NULL; - if (transfered) - item = psMetadataGet(out, PS_LIST_TAIL); - ok(transfered && item->type == PS_DATA_S32 && strncmp(item->name, "key", 4) == 0 - && item->data.S32 == 666 && strncmp(item->comment, "", 2) == 0, - "psMetadataItemSupplement: return true for valid inputs."); - } - /* Attempt here was to return false inside of ItemTransfer at psMetadataAddItem. - //Return false for duplicate entry with PS_META_DEFAULT (no duplicates) - { - psMetadataRemoveKey(out, key); - psMetadataItem *item = psMetadataGet(in, PS_LIST_HEAD); - psMetadataAddItem(out, item, PS_LIST_TAIL, PS_META_NO_REPLACE); - ok( !psMetadataItemSupplement(out, in, key), - "psMetadataItemSupplement: return false for duplicate metadataItem."); - } - */ - //Return false for invalid key - { - strncpy(key, "not MY key", 15); - ok( !psMetadataItemSupplement(out, in, key), - "psMetadataItemSupplement: return false for invalid key."); - } - //Return false for invalid metadata - psMetadata *invalid = psMetadataAlloc(); - psFree(invalid->hash); - invalid->hash = NULL; - { - ok( !psMetadataItemSupplement(invalid, in, "key"), - "psMetadataItemSupplement: return false for invalid metadata."); - } - psFree(invalid); - - //Check for Memory Leaks - { + psMemId id = psMemGetId(); + psMetadata *out = psMetadataAlloc(); + psMetadata *in = psMetadataAlloc(); + psString key = psStringAlloc(30); + strncpy(key, "key", 4); + + //Return false for NULL in input + { + ok( !psMetadataItemSupplement(out, NULL, key), + "psMetadataItemSupplement: return false for NULL in metadata."); + } + //Return false for NULL out input + { + ok( !psMetadataItemSupplement(NULL, in, key), + "psMetadataItemSupplement: return false for NULL out metadata."); + } + //Return false for NULL key input + { + ok( !psMetadataItemSupplement(out, in, NULL), + "psMetadataItemSupplement: return false for NULL key string."); + } + psMetadataAddS32(in, PS_LIST_HEAD, "key", PS_META_NO_REPLACE, "", 666); + psMetadataAddF32(out, PS_LIST_HEAD, "out", 0, "", 6.66); + + //Return true for valid inputs + { + bool transfered = psMetadataItemSupplement(out, in, key); + psMetadataItem *item = NULL; + if (transfered) + item = psMetadataGet(out, PS_LIST_TAIL); + ok(transfered && item->type == PS_DATA_S32 && strncmp(item->name, "key", 4) == 0 + && item->data.S32 == 666 && strncmp(item->comment, "", 2) == 0, + "psMetadataItemSupplement: return true for valid inputs."); + } + /* Attempt here was to return false inside of ItemTransfer at psMetadataAddItem. + //Return false for duplicate entry with PS_META_DEFAULT (no duplicates) + { + psMetadataRemoveKey(out, key); + psMetadataItem *item = psMetadataGet(in, PS_LIST_HEAD); + psMetadataAddItem(out, item, PS_LIST_TAIL, PS_META_NO_REPLACE); + ok( !psMetadataItemSupplement(out, in, key), + "psMetadataItemSupplement: return false for duplicate metadataItem."); + } + */ + //Return false for invalid key + { + strncpy(key, "not MY key", 15); + ok( !psMetadataItemSupplement(out, in, key), + "psMetadataItemSupplement: return false for invalid key."); + } + //Return false for invalid metadata + psMetadata *invalid = psMetadataAlloc(); + psFree(invalid->hash); + invalid->hash = NULL; + { + ok( !psMetadataItemSupplement(invalid, in, "key"), + "psMetadataItemSupplement: return false for invalid metadata."); + } + psFree(invalid); + psFree(out); psFree(in); psFree(key); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } - } Index: trunk/psLib/test/types/tap_psMetadata_creating.c =================================================================== --- trunk/psLib/test/types/tap_psMetadata_creating.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadata_creating.c (revision 12781) @@ -12,236 +12,225 @@ * */ - #include #include - #include "tap.h" #include "pstap.h" -void testItemAllocs(void); -void testMDAlloc_AddItem(void); -void testIterAlloc(void); int main(void) { - plan_tests(42); - - note("psMetadata & psMetadataItem Creation Functions"); - - testItemAllocs(); - testMDAlloc_AddItem(); - testIterAlloc(); - - done(); -} - -void testItemAllocs(void) -{ - note(" >>>Test 1: psMetadataItemAlloc Fxns"); - psMetadataItem *itemStr = psMetadataItemAllocStr("itemStr", "", "itemStr"); - psMetadataItem *itemF32 = psMetadataItemAllocF32("itemF32", "", 6.66); - psMetadataItem *itemF64 = psMetadataItemAllocF64("itemF64", "", 0.666); - psMetadataItem *itemS8 = psMetadataItemAllocS8("itemS8", "", 0); - psMetadataItem *itemS16 = psMetadataItemAllocS16("itemS16", "", 1); - psMetadataItem *itemS32 = psMetadataItemAllocS32("itemS32", "", 2); - psMetadataItem *itemS64 = psMetadataItemAllocS64("itemS64", "", 3); - psMetadataItem *itemU8 = psMetadataItemAllocU8("itemU8", "", 0); - psMetadataItem *itemU16 = psMetadataItemAllocU16("itemU16", "", 1); - psMetadataItem *itemU32 = psMetadataItemAllocU32("itemU32", "", 2); - psMetadataItem *itemU64 = psMetadataItemAllocU64("itemU64", "", 3); - psMetadataItem *itemBool = psMetadataItemAllocBool("itemBool", "", true); - - //First try to free a NULL item - psMetadataItem *nullItem = NULL; - psFree(nullItem); - //Verify correct allocation - //String + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(44); + // psMetadata & psMetadataItem Creation Functions + + + // testItemAllocs(void) + // psMetadataItemAlloc Fxns { - skip_start(itemStr == NULL, 1, - "Skipping 1 tests because psMetadataItemAllocStr() failed"); - ok(itemStr->type == PS_DATA_STRING - && !strncmp(itemStr->name, "itemStr", 10) - && !strncmp(itemStr->data.V, "itemStr", 10) - && !strncmp(itemStr->comment, "", 2), - "psMetadataItemAllocStr: create valid string item."); - skip_end(); - } - //F32 - { - skip_start(itemF32 == NULL, 1, - "Skipping 1 tests because psMetadataItemAllocF32() failed"); - ok(itemF32->type == PS_DATA_F32 - && !strncmp(itemF32->name, "itemF32", 10) - && abs(itemF32->data.F32 - 6.66) < FLT_EPSILON - && !strncmp(itemF32->comment, "", 2), - "psMetadataItemAllocF32: create valid F32 item."); - skip_end(); - } - //F64 - { - skip_start(itemF64 == NULL, 1, - "Skipping 1 tests because psMetadataItemAllocF64() failed"); - ok(itemF64->type == PS_DATA_F64 - && !strncmp(itemF64->name, "itemF64", 10) - && abs(itemF64->data.F64 - 0.666) < DBL_EPSILON - && !strncmp(itemF64->comment, "", 2), - "psMetadataItemAllocF64: create valid F64 item."); - skip_end(); - } - //S8 - { - skip_start(itemS8 == NULL, 1, - "Skipping 1 tests because psMetadataItemAllocS8() failed"); - ok(itemS8->type == PS_DATA_S8 - && !strncmp(itemS8->name, "itemS8", 10) - && itemS8->data.S8 == 0 - && !strncmp(itemS8->comment, "", 2), - "psMetadataItemAllocS8: create valid S8 item."); - skip_end(); - } - //S16 - { - skip_start(itemS16 == NULL, 1, - "Skipping 1 tests because psMetadataItemAllocS16() failed"); - ok(itemS16->type == PS_DATA_S16 - && !strncmp(itemS16->name, "itemS16", 10) - && itemS16->data.S16 == 1 - && !strncmp(itemS16->comment, "", 2), - "psMetadataItemAllocS16: create valid S16 item."); - skip_end(); - } - //S32 - { - skip_start(itemS32 == NULL, 1, - "Skipping 1 tests because psMetadataItemAllocS32() failed"); - ok(itemS32->type == PS_DATA_S32 - && !strncmp(itemS32->name, "itemS32", 10) - && itemS32->data.S32 == 2 - && !strncmp(itemS32->comment, "", 2), - "psMetadataItemAllocS32: create valid S32 item."); - skip_end(); - } - //S64 - { - skip_start(itemS64 == NULL, 1, - "Skipping 1 tests because psMetadataItemAllocS64() failed"); - ok(itemS64->type == PS_DATA_S64 - && !strncmp(itemS64->name, "itemS64", 10) - && itemS64->data.S64 == 3 - && !strncmp(itemS64->comment, "", 2), - "psMetadataItemAllocS64: create valid S64 item."); - skip_end(); - } - //U8 - { - skip_start(itemU8 == NULL, 1, - "Skipping 1 tests because psMetadataItemAllocU8() failed"); - ok(itemU8->type == PS_DATA_U8 - && !strncmp(itemU8->name, "itemU8", 10) - && itemU8->data.U8 == 0 - && !strncmp(itemU8->comment, "", 2), - "psMetadataItemAllocU8: create valid U8 item."); - skip_end(); - } - //U16 - { - skip_start(itemU16 == NULL, 1, - "Skipping 1 tests because psMetadataItemAllocU16() failed"); - ok(itemU16->type == PS_DATA_U16 - && !strncmp(itemU16->name, "itemU16", 10) - && itemU16->data.U16 == 1 - && !strncmp(itemU16->comment, "", 2), - "psMetadataItemAllocU16: create valid U16 item."); - skip_end(); - } - //U32 - { - skip_start(itemU32 == NULL, 1, - "Skipping 1 tests because psMetadataItemAllocU32() failed"); - ok(itemU32->type == PS_DATA_U32 - && !strncmp(itemU32->name, "itemU32", 10) - && itemU32->data.U32 == 2 - && !strncmp(itemU32->comment, "", 2), - "psMetadataItemAllocU32: create valid U32 item."); - skip_end(); - } - //U64 - { - skip_start(itemU64 == NULL, 1, - "Skipping 1 tests because psMetadataItemAllocU64() failed"); - ok(itemU64->type == PS_DATA_U64 - && !strncmp(itemU64->name, "itemU64", 10) - && itemU64->data.U64 == 3 - && !strncmp(itemU64->comment, "", 2), - "psMetadataItemAllocU64: create valid U64 item."); - skip_end(); - } - //Bool - { - skip_start(itemBool == NULL, 1, - "Skipping 1 tests because psMetadataItemAllocBool() failed"); - ok(itemBool->type == PS_DATA_BOOL - && !strncmp(itemBool->name, "itemBool", 10) - && itemBool->data.B - && !strncmp(itemBool->comment, "", 2), - "psMetadataItemAllocBool: create valid Bool item."); - skip_end(); - } - - //Allocate a pointer. Example= psSphere - { - psSphere *s = psSphereAlloc(); - s->r = 1.1; - s->d = 2.1; - psMetadataItem *itemPtr = psMetadataItemAllocPtr("itemPtr", PS_DATA_SPHERE, "", s); - skip_start(itemPtr == NULL, 1, - "Skipping 1 tests because psMetadataItemAllocPtr() failed"); - float r = ((psSphere*)(itemPtr->data.V))->r; - float d = ((psSphere*)(itemPtr->data.V))->d; - ok( itemPtr->type == PS_DATA_SPHERE - && !strncmp(itemPtr->name, "itemPtr", 10) - && abs(r-1.1) < FLT_EPSILON && abs(d-2.1) < FLT_EPSILON - && !strncmp(itemPtr->comment, "", 2), - "psMetadataItemAllocPtr: create valid ptr (psSphere) item."); - skip_end(); - psFree(s); - psFree(itemPtr); - } - - //Try to Allocate an unsupported type with AllocV - { - psMetadataItem *itemNULL = NULL; - psLine *line = psLineAlloc(2); - itemNULL = psMetadataItemAlloc("itemNULL", PS_DATA_LINE, NULL, line); - ok( itemNULL == NULL, - "psMetadataItemAlloc: return NULL for unsupported type."); - psFree(line); - } - - //Now Allocate the item with Alloc and test MemCheck for it's type. - { - psMetadataItem *itemAllocV = psMetadataItemAlloc("itemAllocV", PS_DATA_S32, NULL, 4); - skip_start(itemAllocV == NULL, 2, - "Skipping 2 tests because psMetadataItemAllocV() failed"); - ok (itemAllocV->type == PS_DATA_S32 - && !strncmp(itemAllocV->name, "itemAllocV", 10) - && itemAllocV->data.S32 == 4 - && !strncmp(itemAllocV->comment, "", 2), - "psMetadataItemAlloc: create valid S32 item."); - ok ( psMemCheckMetadataItem(itemAllocV), - "psMemCheckMetadataItem: return true for valid MetadataItem."); - skip_end(); - psFree(itemAllocV); - } - - //Make sure MemCheckItem worked. Try primitive type. Expect false. - { - int j = 2; - ok( !psMemCheckMetadataItem(&j), - "psMemCheckMetadataItem: return false for non-MetadataItem input."); - } - - //Check for Memory Leaks - { + psMemId id = psMemGetId(); + psMetadataItem *itemStr = psMetadataItemAllocStr("itemStr", "", "itemStr"); + psMetadataItem *itemF32 = psMetadataItemAllocF32("itemF32", "", 6.66); + psMetadataItem *itemF64 = psMetadataItemAllocF64("itemF64", "", 0.666); + psMetadataItem *itemS8 = psMetadataItemAllocS8("itemS8", "", 0); + psMetadataItem *itemS16 = psMetadataItemAllocS16("itemS16", "", 1); + psMetadataItem *itemS32 = psMetadataItemAllocS32("itemS32", "", 2); + psMetadataItem *itemS64 = psMetadataItemAllocS64("itemS64", "", 3); + psMetadataItem *itemU8 = psMetadataItemAllocU8("itemU8", "", 0); + psMetadataItem *itemU16 = psMetadataItemAllocU16("itemU16", "", 1); + psMetadataItem *itemU32 = psMetadataItemAllocU32("itemU32", "", 2); + psMetadataItem *itemU64 = psMetadataItemAllocU64("itemU64", "", 3); + psMetadataItem *itemBool = psMetadataItemAllocBool("itemBool", "", true); + + //First try to free a NULL item + psMetadataItem *nullItem = NULL; + psFree(nullItem); + //Verify correct allocation + //String + { + skip_start(itemStr == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocStr() failed"); + ok(itemStr->type == PS_DATA_STRING + && !strncmp(itemStr->name, "itemStr", 10) + && !strncmp(itemStr->data.V, "itemStr", 10) + && !strncmp(itemStr->comment, "", 2), + "psMetadataItemAllocStr: create valid string item."); + skip_end(); + } + //F32 + { + skip_start(itemF32 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocF32() failed"); + ok(itemF32->type == PS_DATA_F32 + && !strncmp(itemF32->name, "itemF32", 10) + && abs(itemF32->data.F32 - 6.66) < FLT_EPSILON + && !strncmp(itemF32->comment, "", 2), + "psMetadataItemAllocF32: create valid F32 item."); + skip_end(); + } + //F64 + { + skip_start(itemF64 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocF64() failed"); + ok(itemF64->type == PS_DATA_F64 + && !strncmp(itemF64->name, "itemF64", 10) + && abs(itemF64->data.F64 - 0.666) < DBL_EPSILON + && !strncmp(itemF64->comment, "", 2), + "psMetadataItemAllocF64: create valid F64 item."); + skip_end(); + } + //S8 + { + skip_start(itemS8 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocS8() failed"); + ok(itemS8->type == PS_DATA_S8 + && !strncmp(itemS8->name, "itemS8", 10) + && itemS8->data.S8 == 0 + && !strncmp(itemS8->comment, "", 2), + "psMetadataItemAllocS8: create valid S8 item."); + skip_end(); + } + //S16 + { + skip_start(itemS16 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocS16() failed"); + ok(itemS16->type == PS_DATA_S16 + && !strncmp(itemS16->name, "itemS16", 10) + && itemS16->data.S16 == 1 + && !strncmp(itemS16->comment, "", 2), + "psMetadataItemAllocS16: create valid S16 item."); + skip_end(); + } + //S32 + { + skip_start(itemS32 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocS32() failed"); + ok(itemS32->type == PS_DATA_S32 + && !strncmp(itemS32->name, "itemS32", 10) + && itemS32->data.S32 == 2 + && !strncmp(itemS32->comment, "", 2), + "psMetadataItemAllocS32: create valid S32 item."); + skip_end(); + } + //S64 + { + skip_start(itemS64 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocS64() failed"); + ok(itemS64->type == PS_DATA_S64 + && !strncmp(itemS64->name, "itemS64", 10) + && itemS64->data.S64 == 3 + && !strncmp(itemS64->comment, "", 2), + "psMetadataItemAllocS64: create valid S64 item."); + skip_end(); + } + //U8 + { + skip_start(itemU8 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocU8() failed"); + ok(itemU8->type == PS_DATA_U8 + && !strncmp(itemU8->name, "itemU8", 10) + && itemU8->data.U8 == 0 + && !strncmp(itemU8->comment, "", 2), + "psMetadataItemAllocU8: create valid U8 item."); + skip_end(); + } + //U16 + { + skip_start(itemU16 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocU16() failed"); + ok(itemU16->type == PS_DATA_U16 + && !strncmp(itemU16->name, "itemU16", 10) + && itemU16->data.U16 == 1 + && !strncmp(itemU16->comment, "", 2), + "psMetadataItemAllocU16: create valid U16 item."); + skip_end(); + } + //U32 + { + skip_start(itemU32 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocU32() failed"); + ok(itemU32->type == PS_DATA_U32 + && !strncmp(itemU32->name, "itemU32", 10) + && itemU32->data.U32 == 2 + && !strncmp(itemU32->comment, "", 2), + "psMetadataItemAllocU32: create valid U32 item."); + skip_end(); + } + //U64 + { + skip_start(itemU64 == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocU64() failed"); + ok(itemU64->type == PS_DATA_U64 + && !strncmp(itemU64->name, "itemU64", 10) + && itemU64->data.U64 == 3 + && !strncmp(itemU64->comment, "", 2), + "psMetadataItemAllocU64: create valid U64 item."); + skip_end(); + } + //Bool + { + skip_start(itemBool == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocBool() failed"); + ok(itemBool->type == PS_DATA_BOOL + && !strncmp(itemBool->name, "itemBool", 10) + && itemBool->data.B + && !strncmp(itemBool->comment, "", 2), + "psMetadataItemAllocBool: create valid Bool item."); + skip_end(); + } + + //Allocate a pointer. Example= psSphere + { + psSphere *s = psSphereAlloc(); + s->r = 1.1; + s->d = 2.1; + psMetadataItem *itemPtr = psMetadataItemAllocPtr("itemPtr", PS_DATA_SPHERE, "", s); + skip_start(itemPtr == NULL, 1, + "Skipping 1 tests because psMetadataItemAllocPtr() failed"); + float r = ((psSphere*)(itemPtr->data.V))->r; + float d = ((psSphere*)(itemPtr->data.V))->d; + ok( itemPtr->type == PS_DATA_SPHERE + && !strncmp(itemPtr->name, "itemPtr", 10) + && abs(r-1.1) < FLT_EPSILON && abs(d-2.1) < FLT_EPSILON + && !strncmp(itemPtr->comment, "", 2), + "psMetadataItemAllocPtr: create valid ptr (psSphere) item."); + skip_end(); + psFree(s); + psFree(itemPtr); + } + + //Try to Allocate an unsupported type with AllocV + { + psMetadataItem *itemNULL = NULL; + psLine *line = psLineAlloc(2); + itemNULL = psMetadataItemAlloc("itemNULL", PS_DATA_LINE, NULL, line); + ok( itemNULL == NULL, + "psMetadataItemAlloc: return NULL for unsupported type."); + psFree(line); + } + + //Now Allocate the item with Alloc and test MemCheck for it's type. + { + psMetadataItem *itemAllocV = psMetadataItemAlloc("itemAllocV", PS_DATA_S32, NULL, 4); + skip_start(itemAllocV == NULL, 2, + "Skipping 2 tests because psMetadataItemAllocV() failed"); + ok (itemAllocV->type == PS_DATA_S32 + && !strncmp(itemAllocV->name, "itemAllocV", 10) + && itemAllocV->data.S32 == 4 + && !strncmp(itemAllocV->comment, "", 2), + "psMetadataItemAlloc: create valid S32 item."); + ok ( psMemCheckMetadataItem(itemAllocV), + "psMemCheckMetadataItem: return true for valid MetadataItem."); + skip_end(); + psFree(itemAllocV); + } + + //Make sure MemCheckItem worked. Try primitive type. Expect false. + { + int j = 2; + ok( !psMemCheckMetadataItem(&j), + "psMemCheckMetadataItem: return false for non-MetadataItem input."); + } + psFree(itemStr); psFree(itemF32); @@ -256,243 +245,241 @@ psFree(itemU64); psFree(itemBool); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } -} - -void testMDAlloc_AddItem(void) -{ - note(" >>>Test 2: psMetadataAlloc & psMetadataAdd Fxns"); - psMetadata *md = NULL; - md = psMetadataAlloc(); - psMetadata *md1 = psMetadataAlloc(); - psMetadata *md2 = psMetadataAlloc(); - //test MemCheck for a valid psMetadata + + // psMetadataAlloc & psMetadataAdd Fxns"); { - ok( psMemCheckMetadata(md), - "psMemCheckMetadata: return true for valid Metadata."); - } - //Make sure MemCheck worked. Try primitive type. Expect false. - { - int j = 2; - ok( !psMemCheckMetadata(&j), - "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."); - } - psFree(md1); - md1 = psMetadataAlloc(); - - //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."); - } - //Return false for metadata with NULL hash - psFree(md1->hash); - md1->hash = NULL; - { - ok( !psMetadataAddItem(md1, item, PS_LIST_HEAD, PS_META_DEFAULT), - "psMetadataAddItem: return false for metadata with no hash."); - } - psFree(md1); - //Return false for metadata with NULL list - psFree(md2->list); - md2->list = NULL; - { - ok( !psMetadataAddItem(md2, item, PS_LIST_HEAD, PS_META_DEFAULT), - "psMetadataAddItem: return false for metadata with no list."); - } - psFree(md2); - //Return false for NULL psMetadataItem input - { - ok( !psMetadataAddItem(md, NULL, PS_LIST_HEAD, PS_META_DEFAULT), - "psMetadataAddItem: return false for NULL item input."); - } - //Return false for psMetadataItem with NULL name - psFree(item->name); - item->name = NULL; - { - ok( !psMetadataAddItem(md, item, PS_LIST_HEAD, PS_META_DEFAULT), - "psMetadataAddItem: return false for item with no name."); - } - psFree(item); - - psMetadata *itemMD = psMetadataAlloc(); - psMetadataAddS32(itemMD, PS_LIST_HEAD, "s", PS_META_DUPLICATE_OK, "", 2); - psMetadataItem *item2 = psMetadataItemAllocS32("s", "", 2); - - //Return true for addition of multi - { - ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), - "psMetadataAddItem: return true for addition of PS_DATA_METADATA_MULTI."); - } - psFree(item2); - psFree(itemMD); - - //Existing entry with duplicate key found. - 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."); - } - /* 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."); - } - */ - //FLAG = PS_META_DEFAULT - { - ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DEFAULT), - "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 - item2 = psMetadataItemAllocS32("new", "", 2); - { - ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), - "psMetadataAddItem: return true for new item."); - } - - //Check for Memory leaks - { + psMemId id = psMemGetId(); + psMetadata *md = NULL; + md = psMetadataAlloc(); + psMetadata *md1 = psMetadataAlloc(); + psMetadata *md2 = psMetadataAlloc(); + //test MemCheck for a valid psMetadata + { + ok( psMemCheckMetadata(md), + "psMemCheckMetadata: return true for valid Metadata."); + } + //Make sure MemCheck worked. Try primitive type. Expect false. + { + int j = 2; + ok( !psMemCheckMetadata(&j), + "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."); + } + psFree(md1); + md1 = psMetadataAlloc(); + + //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."); + } + //Return false for metadata with NULL hash + psFree(md1->hash); + md1->hash = NULL; + { + ok( !psMetadataAddItem(md1, item, PS_LIST_HEAD, PS_META_DEFAULT), + "psMetadataAddItem: return false for metadata with no hash."); + } + psFree(md1); + //Return false for metadata with NULL list + psFree(md2->list); + md2->list = NULL; + { + ok( !psMetadataAddItem(md2, item, PS_LIST_HEAD, PS_META_DEFAULT), + "psMetadataAddItem: return false for metadata with no list."); + } + psFree(md2); + //Return false for NULL psMetadataItem input + { + ok( !psMetadataAddItem(md, NULL, PS_LIST_HEAD, PS_META_DEFAULT), + "psMetadataAddItem: return false for NULL item input."); + } + //Return false for psMetadataItem with NULL name + psFree(item->name); + item->name = NULL; + { + ok( !psMetadataAddItem(md, item, PS_LIST_HEAD, PS_META_DEFAULT), + "psMetadataAddItem: return false for item with no name."); + } + psFree(item); + + psMetadata *itemMD = psMetadataAlloc(); + psMetadataAddS32(itemMD, PS_LIST_HEAD, "s", PS_META_DUPLICATE_OK, "", 2); + psMetadataItem *item2 = psMetadataItemAllocS32("s", "", 2); + + //Return true for addition of multi + { + ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), + "psMetadataAddItem: return true for addition of PS_DATA_METADATA_MULTI."); + } + psFree(item2); + psFree(itemMD); + + //Existing entry with duplicate key found. + 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."); + } + /* 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."); + } + */ + //FLAG = PS_META_DEFAULT + { + ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DEFAULT), + "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 + item2 = psMetadataItemAllocS32("new", "", 2); + { + ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK), + "psMetadataAddItem: return true for new item."); + } + psFree(item2); psFree(md); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // psMetadataIteratorAlloc + { + psMemId id = psMemGetId(); + psMetadata *md = psMetadataAlloc(); + psMetadata *md2 = NULL; + psMetadataAddS32(md, PS_LIST_HEAD, "S32_1", PS_META_NO_REPLACE, "", 1); + psMetadataAddS32(md, PS_LIST_TAIL, "S32_2", PS_META_DEFAULT, "", 2); + + psMetadataIterator *iter = NULL; + //Return NULL for NULL metadata input + { + iter = psMetadataIteratorAlloc(md2, PS_LIST_HEAD, NULL); + ok( iter == NULL, + "psMetadataIteratorAlloc: return NULL for NULL metadata input."); + } + //Return NULL for metadata with no List + md2 = psMetadataAlloc(); + psFree(md2->list); + md2->list = NULL; + { + iter = psMetadataIteratorAlloc(md2, PS_LIST_HEAD, NULL); + ok( iter == NULL, + "psMetadataIteratorAlloc: return NULL for metadata with no list."); + } + psFree(md2); + + //Return newly allocated MetadataIterator, regex=NULL + { + iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL); + ok( iter != NULL, + "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 + { + psFree(iter); + psFree(md); + checkMem(); + } + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } } - -void testIterAlloc(void) -{ - note(" >>>Test 3: psMetadataIteratorAlloc"); - psMetadata *md = psMetadataAlloc(); - psMetadata *md2 = NULL; - psMetadataAddS32(md, PS_LIST_HEAD, "S32_1", PS_META_NO_REPLACE, "", 1); - psMetadataAddS32(md, PS_LIST_TAIL, "S32_2", PS_META_DEFAULT, "", 2); - - psMetadataIterator *iter = NULL; - //Return NULL for NULL metadata input - { - iter = psMetadataIteratorAlloc(md2, PS_LIST_HEAD, NULL); - ok( iter == NULL, - "psMetadataIteratorAlloc: return NULL for NULL metadata input."); - } - //Return NULL for metadata with no List - md2 = psMetadataAlloc(); - psFree(md2->list); - md2->list = NULL; - { - iter = psMetadataIteratorAlloc(md2, PS_LIST_HEAD, NULL); - ok( iter == NULL, - "psMetadataIteratorAlloc: return NULL for metadata with no list."); - } - psFree(md2); - - //Return newly allocated MetadataIterator, regex=NULL - { - iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL); - ok( iter != NULL, - "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 - { - psFree(iter); - psFree(md); - checkMem(); - } -} - Index: trunk/psLib/test/types/tap_psMetadata_manip.c =================================================================== --- trunk/psLib/test/types/tap_psMetadata_manip.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadata_manip.c (revision 12781) @@ -10,468 +10,451 @@ * */ - #include #include - #include "tap.h" #include "pstap.h" -void testIter(void); -void testLookups(void); -void testRemoves(void); int main(void) { - plan_tests(48); - - note("psMetadataLookup, Remove, and Iterator Fxns"); - - testLookups(); - testRemoves(); - testIter(); - - done(); -} - -void testLookups(void) -{ - note(" >>>Test 1: psMetadataLookup Functions"); - psMetadata *md = psMetadataAlloc(); - psMetadataAddStr(md, PS_LIST_TAIL, "itemStr", 0, "I am a string", "GNIRTS"); - psMetadataAddBool(md, PS_LIST_TAIL, "itemBool", 0, "I am a boolean", true); - psMetadataAddS8(md, PS_LIST_TAIL, "itemS8", 0, "I am S8", 6); - psMetadataAddS16(md, PS_LIST_TAIL, "itemS16", 0, "I am S16", -666); - psMetadataAddS32(md, PS_LIST_TAIL, "itemS32", 0, "I am a integer", 55); - psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", 0, "I am S64", 666); - psMetadataAddU8(md, PS_LIST_TAIL, "itemU8", 0, "I am U8", 6); - psMetadataAddU16(md, PS_LIST_TAIL, "itemU16", 0, "I am U16", 666); - psMetadataAddU32(md, PS_LIST_TAIL, "itemU32", 0, "I am U32", 666); - psMetadataAddU64(md, PS_LIST_TAIL, "itemU64", 0, "I am U64", 666); - psMetadataAddF32(md, PS_LIST_TAIL, "itemF32", 0, NULL, 3.14); - psMetadataAddF64(md, PS_LIST_TAIL, "itemF64", 0, "", 6.28); - psSphere *sphere = psSphereAlloc(); - sphere->r = 6.66; - sphere->d = 666.666; - psMetadataAddPtr(md, PS_LIST_HEAD, "ptr", PS_DATA_SPHERE, "", sphere); - // psMetadataAddPtr(md, PS_LIST_TAIL, "ptr", PS_DATA_METADATA_MULTI, "", sphere); - psTime *time; - time = psTimeAlloc(PS_TIME_TAI); - time->sec = 1000; - time->nsec = 25; - time->leapsecond = true; - psMetadataAddTime(md, PS_LIST_TAIL, "time01", 0, "I am time", time); - psMetadata *newMD = psMetadataAlloc(); - psMetadataAddS32(newMD, PS_LIST_TAIL, "1", 0, "", 666); - psMetadataAddMetadata(md, PS_LIST_TAIL, "metadata7", 0, "I am a metadata", newMD); - - //Lookup Standard number-types (valid cases) - //U8 + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(50); + // psMetadataLookup, Remove, and Iterator Fxns + + + // psMetadataLookup Functions { - bool status = false; - psU8 u8 = 0; - u8 = psMetadataLookupU8(&status, md, "itemU8"); - ok( status && u8 == 6, - "psMetadataLookupU8: return correct U8 value on lookup."); - } - //U16 - { - bool status = false; - psU16 u16 = 0; - u16 = psMetadataLookupU16(&status, md, "itemU16"); - ok( status && u16 == 666, - "psMetadataLookupU16: return correct U16 value on lookup."); - } - //U32 - { - bool status = false; - psU32 u32 = 0; - u32 = psMetadataLookupU32(&status, md, "itemU32"); - ok( status && u32 == 666, - "psMetadataLookupU32: return correct U32 value on lookup."); - } - //U64 - { - bool status = false; - psU64 u64 = 0; - u64 = psMetadataLookupU64(&status, md, "itemU64"); - ok( status && u64 == 666, - "psMetadataLookupU64: return correct U64 value on lookup."); - } - //S8 - { - bool status = false; - psS8 s8 = 0; - s8 = psMetadataLookupS8(&status, md, "itemS8"); - ok( status && s8 == 6, - "psMetadataLookupS8: return correct S8 value on lookup."); - } - //S16 - { - bool status = false; - psS16 s16 = 0; - s16 = psMetadataLookupS16(&status, md, "itemS16"); - ok( status && s16 == -666, - "psMetadataLookupS16: return correct S16 value on lookup."); - } - //S32 - { - bool status = false; - psS32 s32 = 0; - s32 = psMetadataLookupS32(&status, md, "itemS32"); - ok( status && s32 == 55, - "psMetadataLookupS32: return correct S32 value on lookup."); - } - //S64 - { - bool status = false; - psS64 s64 = 0; - s64 = psMetadataLookupS64(&status, md, "itemS64"); - ok( status && s64 == 666, - "psMetadataLookupS64: return correct S64 value on lookup."); - } - //F32 - { - bool status = false; - psF32 f32 = 0; - f32 = psMetadataLookupF32(&status, md, "itemF32"); - ok( status && abs(f32 - 3.14) < FLT_EPSILON, - "psMetadataLookupF32: return correct F32 value on lookup."); - } - //F64 - { - bool status = false; - psF64 f64 = 0; - f64 = psMetadataLookupF64(&status, md, "itemF64"); - ok( status && abs(f64 - 6.28) < DBL_EPSILON, - "psMetadataLookupF64: return correct F64 value on lookup."); - } - //Bool - { - bool status = false; - bool stat = false; - stat = psMetadataLookupBool(&status, md, "itemBool"); - ok( status && stat, - "psMetadataLookupBool: return correct Bool value on lookup."); - } - //String - { - bool status = false; - psString str = NULL; - str = psMetadataLookupStr(&status, md, "itemStr"); - ok( status && !strncmp(str, "GNIRTS", 8), - "psMetadataLookupStr: return correct String value on lookup."); - } - //Pointer - { - bool status = false; - psSphere *sph = NULL; - sph = (psSphere*)(psMetadataLookupPtr(&status, md, "ptr")); - ok( status && sph != NULL && abs(sph->r-6.66) < FLT_EPSILON, - "psMetadataLookupPtr: return correct pointer value on lookup."); - } - //Time - { - bool status = false; - psTime *t = NULL; - t = psMetadataLookupTime(&status, md, "time01"); - ok( status && t->sec == 1000, - "psMetadataLookupTime: return correct time value on lookup."); - } - //Metadata - { - bool status = false; - psMetadata *mdtemp = NULL; - mdtemp = psMetadataLookupMetadata(&status, md, "metadata7"); - psMetadataItem *itemtemp = psMetadataGet(mdtemp, PS_LIST_HEAD); - ok( status && itemtemp->type == PS_DATA_S32 && itemtemp->data.S32 == 666, - "psMetadataLookupMD: return correct metadata value on lookup."); - } - - //Try Negatives and non-standard lookup cases - //String - invalid key name - { - bool status = false; - psString str = NULL; - str = psMetadataLookupStr(&status, md, "item"); - ok( !status && str == NULL, - "psMetadataLookupStr: return NULL for incorrect key."); - str = NULL; - str = psMetadataLookupStr(NULL, md, "item"); - ok( str == NULL, - "psMetadataLookupStr: return NULL for incorrect key (& NULL status)."); - } - //String - wrong key-> lookup s8 data - { - bool status = false; - psString str = NULL; - str = psMetadataLookupStr(&status, md, "itemS8"); - ok( !status && str == NULL, - "psMetadataLookupStr: return NULL for incorrect key ."); - str = NULL; - str = psMetadataLookupStr(NULL, md, "itemS8"); - ok( str == NULL, - "psMetadataLookupStr: return NULL for incorrect key (& NULL status)."); - } - //Pointer - invalid key name - { - bool status = false; - psSphere *sph = NULL; - sph = psMetadataLookupPtr(&status, md, "item"); - ok( !status && sph == NULL, - "psMetadataLookupPtr: return NULL for incorrect key."); - } - //Pointer - wrong key -> lookup s8 data - { - bool status = false; - psSphere *sph = NULL; - sph = psMetadataLookupPtr(&status, md, "itemS8"); - ok( !status && sph == NULL, - "psMetadataLookupPtr: return NULL for incorrect key."); - } - - //Pointer** - lookup a PS_DATA_METADATA_MULTI - { - psMetadata *metadata = psMetadataAlloc(); - psMetadataItem *multi = psMetadataItemAlloc("ptr", PS_DATA_METADATA_MULTI, "", NULL); - psMetadataAddItem(metadata, multi, PS_LIST_HEAD, PS_META_DUPLICATE_OK); - psMetadataAddPtr(metadata, PS_LIST_TAIL, "ptr", - PS_DATA_SPHERE | PS_META_DUPLICATE_OK, "", sphere); - psSphere *s = psSphereAlloc(); - s->r = 0.666; - psMetadataAddPtr(metadata, PS_LIST_TAIL, "ptr", PS_DATA_SPHERE | PS_META_DUPLICATE_OK, "", s); - psFree(s); - psMetadataItem *metadataItem = NULL; - metadataItem = psMetadataLookup(metadata, "ptr"); - bool status = false; - psSphere *sph = NULL; - sph = (psSphere*)(psMetadataLookupPtr(&status, metadata, "ptr")); - ok( status && sph != NULL && fabs(sph->r - 6.66) < FLT_EPSILON, - "psMetadataLookupPtr: return correct value on lookup of MULTI item."); - psFree(metadata); - psFree(multi); - } - - //Metadata - invalid key name - { - bool status = false; - psMetadata *met = NULL; - met = psMetadataLookupMetadata(&status, md, "item"); - ok( !status && met == NULL, - "psMetadataLookupMD: return NULL for incorrect key."); - met = NULL; - met = psMetadataLookupMetadata(NULL, md, "item"); - ok( met == NULL, - "psMetadataLookupMD: return NULL for incorrect key (& NULL status)."); - } - //Metadata - wrong key -> lookup s8 data - { - bool status = false; - psMetadata *met = NULL; - met = psMetadataLookupMetadata(&status, md, "itemS8"); - ok( !status && met == NULL, - "psMetadataLookupMD: return NULL for incorrect key (& NULL status)."); - met = NULL; - met = psMetadataLookupMetadata(NULL, md, "itemS8"); - ok( met == NULL, - "psMetadataLookupMD: return NULL for incorrect key."); - } - //Time - invalid key name - { - bool status = false; - psTime *time = NULL; - time = psMetadataLookupTime(&status, md, "item"); - ok( !status && time == NULL, - "psMetadataLookupTime: return NULL for incorrect key."); - time = NULL; - time = psMetadataLookupTime(NULL, md, "item"); - ok( time == NULL, - "psMetadataLookupTime: return NULL for incorrect key (& NULL status)."); - } - //Time - wrong key -> lookup s8 data - { - bool status = false; - psTime *time = NULL; - time = psMetadataLookupTime(&status, md, "itemS8"); - ok( !status && time == NULL, - "psMetadataLookupTime: return NULL for incorrect key."); - time = NULL; - time = psMetadataLookupTime(NULL, md, "itemS8"); - ok( time == NULL, - "psMetadataLookupTime: return NULL for incorrect key (& NULL status)."); - } - - - - //Check for Memory leaks - { + psMemId id = psMemGetId(); + psMetadata *md = psMetadataAlloc(); + psMetadataAddStr(md, PS_LIST_TAIL, "itemStr", 0, "I am a string", "GNIRTS"); + psMetadataAddBool(md, PS_LIST_TAIL, "itemBool", 0, "I am a boolean", true); + psMetadataAddS8(md, PS_LIST_TAIL, "itemS8", 0, "I am S8", 6); + psMetadataAddS16(md, PS_LIST_TAIL, "itemS16", 0, "I am S16", -666); + psMetadataAddS32(md, PS_LIST_TAIL, "itemS32", 0, "I am a integer", 55); + psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", 0, "I am S64", 666); + psMetadataAddU8(md, PS_LIST_TAIL, "itemU8", 0, "I am U8", 6); + psMetadataAddU16(md, PS_LIST_TAIL, "itemU16", 0, "I am U16", 666); + psMetadataAddU32(md, PS_LIST_TAIL, "itemU32", 0, "I am U32", 666); + psMetadataAddU64(md, PS_LIST_TAIL, "itemU64", 0, "I am U64", 666); + psMetadataAddF32(md, PS_LIST_TAIL, "itemF32", 0, NULL, 3.14); + psMetadataAddF64(md, PS_LIST_TAIL, "itemF64", 0, "", 6.28); + psSphere *sphere = psSphereAlloc(); + sphere->r = 6.66; + sphere->d = 666.666; + psMetadataAddPtr(md, PS_LIST_HEAD, "ptr", PS_DATA_SPHERE, "", sphere); + // psMetadataAddPtr(md, PS_LIST_TAIL, "ptr", PS_DATA_METADATA_MULTI, "", sphere); + psTime *time; + time = psTimeAlloc(PS_TIME_TAI); + time->sec = 1000; + time->nsec = 25; + time->leapsecond = true; + psMetadataAddTime(md, PS_LIST_TAIL, "time01", 0, "I am time", time); + psMetadata *newMD = psMetadataAlloc(); + psMetadataAddS32(newMD, PS_LIST_TAIL, "1", 0, "", 666); + psMetadataAddMetadata(md, PS_LIST_TAIL, "metadata7", 0, "I am a metadata", newMD); + + //Lookup Standard number-types (valid cases) + //U8 + { + bool status = false; + psU8 u8 = 0; + u8 = psMetadataLookupU8(&status, md, "itemU8"); + ok( status && u8 == 6, + "psMetadataLookupU8: return correct U8 value on lookup."); + } + //U16 + { + bool status = false; + psU16 u16 = 0; + u16 = psMetadataLookupU16(&status, md, "itemU16"); + ok( status && u16 == 666, + "psMetadataLookupU16: return correct U16 value on lookup."); + } + //U32 + { + bool status = false; + psU32 u32 = 0; + u32 = psMetadataLookupU32(&status, md, "itemU32"); + ok( status && u32 == 666, + "psMetadataLookupU32: return correct U32 value on lookup."); + } + //U64 + { + bool status = false; + psU64 u64 = 0; + u64 = psMetadataLookupU64(&status, md, "itemU64"); + ok( status && u64 == 666, + "psMetadataLookupU64: return correct U64 value on lookup."); + } + //S8 + { + bool status = false; + psS8 s8 = 0; + s8 = psMetadataLookupS8(&status, md, "itemS8"); + ok( status && s8 == 6, + "psMetadataLookupS8: return correct S8 value on lookup."); + } + //S16 + { + bool status = false; + psS16 s16 = 0; + s16 = psMetadataLookupS16(&status, md, "itemS16"); + ok( status && s16 == -666, + "psMetadataLookupS16: return correct S16 value on lookup."); + } + //S32 + { + bool status = false; + psS32 s32 = 0; + s32 = psMetadataLookupS32(&status, md, "itemS32"); + ok( status && s32 == 55, + "psMetadataLookupS32: return correct S32 value on lookup."); + } + //S64 + { + bool status = false; + psS64 s64 = 0; + s64 = psMetadataLookupS64(&status, md, "itemS64"); + ok( status && s64 == 666, + "psMetadataLookupS64: return correct S64 value on lookup."); + } + //F32 + { + bool status = false; + psF32 f32 = 0; + f32 = psMetadataLookupF32(&status, md, "itemF32"); + ok( status && abs(f32 - 3.14) < FLT_EPSILON, + "psMetadataLookupF32: return correct F32 value on lookup."); + } + //F64 + { + bool status = false; + psF64 f64 = 0; + f64 = psMetadataLookupF64(&status, md, "itemF64"); + ok( status && abs(f64 - 6.28) < DBL_EPSILON, + "psMetadataLookupF64: return correct F64 value on lookup."); + } + //Bool + { + bool status = false; + bool stat = false; + stat = psMetadataLookupBool(&status, md, "itemBool"); + ok( status && stat, + "psMetadataLookupBool: return correct Bool value on lookup."); + } + //String + { + bool status = false; + psString str = NULL; + str = psMetadataLookupStr(&status, md, "itemStr"); + ok( status && !strncmp(str, "GNIRTS", 8), + "psMetadataLookupStr: return correct String value on lookup."); + } + //Pointer + { + bool status = false; + psSphere *sph = NULL; + sph = (psSphere*)(psMetadataLookupPtr(&status, md, "ptr")); + ok( status && sph != NULL && abs(sph->r-6.66) < FLT_EPSILON, + "psMetadataLookupPtr: return correct pointer value on lookup."); + } + //Time + { + bool status = false; + psTime *t = NULL; + t = psMetadataLookupTime(&status, md, "time01"); + ok( status && t->sec == 1000, + "psMetadataLookupTime: return correct time value on lookup."); + } + //Metadata + { + bool status = false; + psMetadata *mdtemp = NULL; + mdtemp = psMetadataLookupMetadata(&status, md, "metadata7"); + psMetadataItem *itemtemp = psMetadataGet(mdtemp, PS_LIST_HEAD); + ok( status && itemtemp->type == PS_DATA_S32 && itemtemp->data.S32 == 666, + "psMetadataLookupMD: return correct metadata value on lookup."); + } + + //Try Negatives and non-standard lookup cases + //String - invalid key name + { + bool status = false; + psString str = NULL; + str = psMetadataLookupStr(&status, md, "item"); + ok( !status && str == NULL, + "psMetadataLookupStr: return NULL for incorrect key."); + str = NULL; + str = psMetadataLookupStr(NULL, md, "item"); + ok( str == NULL, + "psMetadataLookupStr: return NULL for incorrect key (& NULL status)."); + } + //String - wrong key-> lookup s8 data + { + bool status = false; + psString str = NULL; + str = psMetadataLookupStr(&status, md, "itemS8"); + ok( !status && str == NULL, + "psMetadataLookupStr: return NULL for incorrect key ."); + str = NULL; + str = psMetadataLookupStr(NULL, md, "itemS8"); + ok( str == NULL, + "psMetadataLookupStr: return NULL for incorrect key (& NULL status)."); + } + //Pointer - invalid key name + { + bool status = false; + psSphere *sph = NULL; + sph = psMetadataLookupPtr(&status, md, "item"); + ok( !status && sph == NULL, + "psMetadataLookupPtr: return NULL for incorrect key."); + } + //Pointer - wrong key -> lookup s8 data + { + bool status = false; + psSphere *sph = NULL; + sph = psMetadataLookupPtr(&status, md, "itemS8"); + ok( !status && sph == NULL, + "psMetadataLookupPtr: return NULL for incorrect key."); + } + + //Pointer** - lookup a PS_DATA_METADATA_MULTI + { + psMetadata *metadata = psMetadataAlloc(); + psMetadataItem *multi = psMetadataItemAlloc("ptr", PS_DATA_METADATA_MULTI, "", NULL); + psMetadataAddItem(metadata, multi, PS_LIST_HEAD, PS_META_DUPLICATE_OK); + psMetadataAddPtr(metadata, PS_LIST_TAIL, "ptr", + PS_DATA_SPHERE | PS_META_DUPLICATE_OK, "", sphere); + psSphere *s = psSphereAlloc(); + s->r = 0.666; + psMetadataAddPtr(metadata, PS_LIST_TAIL, "ptr", PS_DATA_SPHERE | PS_META_DUPLICATE_OK, "", s); + psFree(s); + psMetadataItem *metadataItem = NULL; + metadataItem = psMetadataLookup(metadata, "ptr"); + bool status = false; + psSphere *sph = NULL; + sph = (psSphere*)(psMetadataLookupPtr(&status, metadata, "ptr")); + ok( status && sph != NULL && fabs(sph->r - 6.66) < FLT_EPSILON, + "psMetadataLookupPtr: return correct value on lookup of MULTI item."); + psFree(metadata); + psFree(multi); + } + + //Metadata - invalid key name + { + bool status = false; + psMetadata *met = NULL; + met = psMetadataLookupMetadata(&status, md, "item"); + ok( !status && met == NULL, + "psMetadataLookupMD: return NULL for incorrect key."); + met = NULL; + met = psMetadataLookupMetadata(NULL, md, "item"); + ok( met == NULL, + "psMetadataLookupMD: return NULL for incorrect key (& NULL status)."); + } + //Metadata - wrong key -> lookup s8 data + { + bool status = false; + psMetadata *met = NULL; + met = psMetadataLookupMetadata(&status, md, "itemS8"); + ok( !status && met == NULL, + "psMetadataLookupMD: return NULL for incorrect key (& NULL status)."); + met = NULL; + met = psMetadataLookupMetadata(NULL, md, "itemS8"); + ok( met == NULL, + "psMetadataLookupMD: return NULL for incorrect key."); + } + //Time - invalid key name + { + bool status = false; + psTime *time = NULL; + time = psMetadataLookupTime(&status, md, "item"); + ok( !status && time == NULL, + "psMetadataLookupTime: return NULL for incorrect key."); + time = NULL; + time = psMetadataLookupTime(NULL, md, "item"); + ok( time == NULL, + "psMetadataLookupTime: return NULL for incorrect key (& NULL status)."); + } + //Time - wrong key -> lookup s8 data + { + bool status = false; + psTime *time = NULL; + time = psMetadataLookupTime(&status, md, "itemS8"); + ok( !status && time == NULL, + "psMetadataLookupTime: return NULL for incorrect key."); + time = NULL; + time = psMetadataLookupTime(NULL, md, "itemS8"); + ok( time == NULL, + "psMetadataLookupTime: return NULL for incorrect key (& NULL status)."); + } + psFree(sphere); psFree(time); psFree(newMD); psFree(md); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // psMetadataRemove Functions + { + psMemId id = psMemGetId(); + psMetadata *md = psMetadataAlloc(); + psMetadataAddStr(md, PS_LIST_TAIL, "itemStr", 0, "I am a string", "GNIRTS"); + psMetadataAddBool(md, PS_LIST_TAIL, "itemBool", 0, "I am a boolean", true); + psMetadataAddS8(md, PS_LIST_TAIL, "itemS8", 0, "I am S8", 6); + psMetadataAddS16(md, PS_LIST_TAIL, "itemS16", 0, "I am S16", -666); + psMetadataAddS32(md, PS_LIST_TAIL, "itemS32", 0, "I am a integer", 55); + psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 666); + psMetadataAddU8(md, PS_LIST_TAIL, "itemU8", 0, "I am U8", 6); + + //psMetadataRemoveKey + { + bool status = psMetadataRemoveKey(md, "itemU8"); + psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL); + ok( status && temp->type == PS_DATA_S64, + "psMetadataRemoveKey: return true for valid case."); + } + //psMetadataRemoveIndex + { + bool status = psMetadataRemoveIndex(md, PS_LIST_HEAD); + psMetadataItem *temp = psMetadataGet(md, PS_LIST_HEAD); + ok( status && temp->type == PS_DATA_BOOL, + "psMetadataRemoveIndex: return true for valid case."); + } + //Attempt to remove an incorrect key - Return false + { + ok( !psMetadataRemoveKey(md, "BigDog"), + "psMetadataRemoveKey: return false for incorrect key."); + } + //Attempt to remove an out-of-range index - Return false + { + ok( !psMetadataRemoveIndex(md, 20), + "psMetadataRemoveIndex: return false for incorrect index."); + } + //Attempt to remove an item with NULL name + { + psMetadataItem *temp = psMetadataGet(md, PS_LIST_HEAD); + psFree(temp->name); + temp->name = NULL; + ok( !psMetadataRemoveIndex(md, PS_LIST_HEAD), + "psMetadataRemoveIndex: return false for item with no name."); + } + //Attempt to remove an item with wrong hash table + { + psMetadata *md2 = psMetadataAlloc(); + psMetadataAddBool(md2, PS_LIST_TAIL, "Bool", 0, "I am a boolean", true); + psMetadataAddS8(md2, PS_LIST_TAIL, "S8", 0, "I am S8", 6); + psMetadataAddS16(md2, PS_LIST_TAIL, "S16", 0, "I am S16", -666); + psMetadataAddS32(md2, PS_LIST_TAIL, "S32", 0, "I am a integer", 55); + psMetadataAddS64(md2, PS_LIST_TAIL, "S64", 0, "I am S64", 666); + + psFree(md2->hash); + md2->hash = NULL; + md2->hash = md->hash; + ok( !psMetadataRemoveIndex(md2, PS_LIST_HEAD), + "psMetadataRemoveIndex: return false for item with bad table."); + md2->hash = NULL; + psFree(md2); + } + //Attempt to remove a METADATA_MULTI item by key + { + psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 667); + psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 668); + bool status = psMetadataRemoveKey(md, "itemS64"); + psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL); + ok( status && temp->type == PS_DATA_S32, + "psMetadataRemoveKey: return true for valid METADATA_MULTI case."); + + } + //Attempt to remove a METADATA_MULTI item by index + { + psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 667); + psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 668); + bool status = psMetadataRemoveIndex(md, PS_LIST_TAIL); + psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL); + ok( status && temp->type == PS_DATA_S64, + "psMetadataRemoveIndex: return true for valid METADATA_MULTI case."); + } + + psFree(md); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // psMetadataIterator Functions + { + psMemId id = psMemGetId(); + psMetadata *md = psMetadataAlloc(); + psMetadataAddS32(md, PS_LIST_HEAD, "S32_1", PS_META_NO_REPLACE, "", 1); + psMetadataAddS32(md, PS_LIST_TAIL, "S32_2", PS_META_NO_REPLACE, "", 2); + psMetadataAddS32(md, PS_LIST_TAIL, "S32_3", PS_META_NO_REPLACE, "", 3); + + psMetadataIterator *iter = NULL; + + //Return NULL in psMetadataGetAnd(In/De)crement for NULL iterator input + { + ok( psMetadataGetAndIncrement(NULL) == NULL, + "psMetadataGetAndIncrement: return NULL for NULL iterator input."); + ok( psMetadataGetAndDecrement(NULL) == NULL, + "psMetadataGetAndDecrement: return NULL for NULL iterator input."); + } + //Return NULL in psMetadataGetAnd(In/De)crement for iterator with no list iterator + psMetadataIterator *iter2 = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL); + psFree(iter2->iter); + iter2->iter = NULL; + { + ok( psMetadataGetAndIncrement(iter2) == NULL, + "psMetadataGetAndIncrement: return NULL for iterator with no list iterator."); + ok( psMetadataGetAndDecrement(iter2) == NULL, + "psMetadataGetAndDecrement: return NULL for iterator with no list iterator."); + } + psFree(iter2); + + //Return valid iterator for valid inputs, regex= NULL + psMetadataItem *item = NULL; + { + iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL); + ok( iter != NULL, + "psMetadataIteratorAlloc: return valid iterator for valid inputs, regex=NULL."); + skip_start(iter == NULL, 4, + "Skipping 4 tests because psMetadataIteratorAlloc failed"); + + item = psMetadataGetAndIncrement(iter); + ok( item != NULL, + "psMetadataGetAndIncrement: return valid item for valid iterator input."); + skip_start(item == NULL, 1, + "Skipping 1 tests because psMetadataGetAndIncrement failed"); + ok(item->type == PS_DATA_S32 + && !strncmp(item->name, "S32_1", 7) + && item->data.S32 == 1 + && !strncmp(item->comment, "", 2), + "psMetadataGetAndIncrement: retrieve correct item from valid iterator."); + skip_end(); + + item = psMetadataGetAndDecrement(iter); + ok( item != NULL, + "psMetadataGetAndDecrement: return valid item for valid iterator input."); + skip_start(item == NULL, 1, + "Skipping 1 tests because psMetadataGetAndDecrement failed"); + ok(item->type == PS_DATA_S32 + && !strncmp(item->name, "S32_2", 7) + && item->data.S32 == 2 + && !strncmp(item->comment, "", 2), + "psMetadataGetAndDecrement: retrieve correct item from valid iterator."); + skip_end(); + + skip_end(); + + } + + psFree(iter); + psFree(md); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } } - -void testRemoves(void) -{ - note(" >>>Test 2: psMetadataRemove Functions"); - psMetadata *md = psMetadataAlloc(); - psMetadataAddStr(md, PS_LIST_TAIL, "itemStr", 0, "I am a string", "GNIRTS"); - psMetadataAddBool(md, PS_LIST_TAIL, "itemBool", 0, "I am a boolean", true); - psMetadataAddS8(md, PS_LIST_TAIL, "itemS8", 0, "I am S8", 6); - psMetadataAddS16(md, PS_LIST_TAIL, "itemS16", 0, "I am S16", -666); - psMetadataAddS32(md, PS_LIST_TAIL, "itemS32", 0, "I am a integer", 55); - psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 666); - psMetadataAddU8(md, PS_LIST_TAIL, "itemU8", 0, "I am U8", 6); - - //psMetadataRemoveKey - { - bool status = psMetadataRemoveKey(md, "itemU8"); - psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL); - ok( status && temp->type == PS_DATA_S64, - "psMetadataRemoveKey: return true for valid case."); - } - //psMetadataRemoveIndex - { - bool status = psMetadataRemoveIndex(md, PS_LIST_HEAD); - psMetadataItem *temp = psMetadataGet(md, PS_LIST_HEAD); - ok( status && temp->type == PS_DATA_BOOL, - "psMetadataRemoveIndex: return true for valid case."); - } - //Attempt to remove an incorrect key - Return false - { - ok( !psMetadataRemoveKey(md, "BigDog"), - "psMetadataRemoveKey: return false for incorrect key."); - } - //Attempt to remove an out-of-range index - Return false - { - ok( !psMetadataRemoveIndex(md, 20), - "psMetadataRemoveIndex: return false for incorrect index."); - } - //Attempt to remove an item with NULL name - { - psMetadataItem *temp = psMetadataGet(md, PS_LIST_HEAD); - psFree(temp->name); - temp->name = NULL; - ok( !psMetadataRemoveIndex(md, PS_LIST_HEAD), - "psMetadataRemoveIndex: return false for item with no name."); - } - //Attempt to remove an item with wrong hash table - { - psMetadata *md2 = psMetadataAlloc(); - psMetadataAddBool(md2, PS_LIST_TAIL, "Bool", 0, "I am a boolean", true); - psMetadataAddS8(md2, PS_LIST_TAIL, "S8", 0, "I am S8", 6); - psMetadataAddS16(md2, PS_LIST_TAIL, "S16", 0, "I am S16", -666); - psMetadataAddS32(md2, PS_LIST_TAIL, "S32", 0, "I am a integer", 55); - psMetadataAddS64(md2, PS_LIST_TAIL, "S64", 0, "I am S64", 666); - - psFree(md2->hash); - md2->hash = NULL; - md2->hash = md->hash; - ok( !psMetadataRemoveIndex(md2, PS_LIST_HEAD), - "psMetadataRemoveIndex: return false for item with bad table."); - md2->hash = NULL; - psFree(md2); - } - //Attempt to remove a METADATA_MULTI item by key - { - psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 667); - psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 668); - bool status = psMetadataRemoveKey(md, "itemS64"); - psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL); - ok( status && temp->type == PS_DATA_S32, - "psMetadataRemoveKey: return true for valid METADATA_MULTI case."); - - } - //Attempt to remove a METADATA_MULTI item by index - { - psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 667); - psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 668); - bool status = psMetadataRemoveIndex(md, PS_LIST_TAIL); - psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL); - ok( status && temp->type == PS_DATA_S64, - "psMetadataRemoveIndex: return true for valid METADATA_MULTI case."); - } - - //Check for Memory leaks - { - psFree(md); - checkMem(); - } -} - -void testIter(void) -{ - note(" >>>Test 3: psMetadataIterator Functions"); - psMetadata *md = psMetadataAlloc(); - psMetadataAddS32(md, PS_LIST_HEAD, "S32_1", PS_META_NO_REPLACE, "", 1); - psMetadataAddS32(md, PS_LIST_TAIL, "S32_2", PS_META_NO_REPLACE, "", 2); - psMetadataAddS32(md, PS_LIST_TAIL, "S32_3", PS_META_NO_REPLACE, "", 3); - - psMetadataIterator *iter = NULL; - - //Return NULL in psMetadataGetAnd(In/De)crement for NULL iterator input - { - ok( psMetadataGetAndIncrement(NULL) == NULL, - "psMetadataGetAndIncrement: return NULL for NULL iterator input."); - ok( psMetadataGetAndDecrement(NULL) == NULL, - "psMetadataGetAndDecrement: return NULL for NULL iterator input."); - } - //Return NULL in psMetadataGetAnd(In/De)crement for iterator with no list iterator - psMetadataIterator *iter2 = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL); - psFree(iter2->iter); - iter2->iter = NULL; - { - ok( psMetadataGetAndIncrement(iter2) == NULL, - "psMetadataGetAndIncrement: return NULL for iterator with no list iterator."); - ok( psMetadataGetAndDecrement(iter2) == NULL, - "psMetadataGetAndDecrement: return NULL for iterator with no list iterator."); - } - psFree(iter2); - - //Return valid iterator for valid inputs, regex= NULL - psMetadataItem *item = NULL; - { - iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL); - ok( iter != NULL, - "psMetadataIteratorAlloc: return valid iterator for valid inputs, regex=NULL."); - skip_start(iter == NULL, 4, - "Skipping 4 tests because psMetadataIteratorAlloc failed"); - - item = psMetadataGetAndIncrement(iter); - ok( item != NULL, - "psMetadataGetAndIncrement: return valid item for valid iterator input."); - skip_start(item == NULL, 1, - "Skipping 1 tests because psMetadataGetAndIncrement failed"); - ok(item->type == PS_DATA_S32 - && !strncmp(item->name, "S32_1", 7) - && item->data.S32 == 1 - && !strncmp(item->comment, "", 2), - "psMetadataGetAndIncrement: retrieve correct item from valid iterator."); - skip_end(); - - item = psMetadataGetAndDecrement(iter); - ok( item != NULL, - "psMetadataGetAndDecrement: return valid item for valid iterator input."); - skip_start(item == NULL, 1, - "Skipping 1 tests because psMetadataGetAndDecrement failed"); - ok(item->type == PS_DATA_S32 - && !strncmp(item->name, "S32_2", 7) - && item->data.S32 == 2 - && !strncmp(item->comment, "", 2), - "psMetadataGetAndDecrement: retrieve correct item from valid iterator."); - skip_end(); - - skip_end(); - - } - - //Check for Memory leaks - { - psFree(iter); - psFree(md); - checkMem(); - } -} - - + + + Index: trunk/psLib/test/types/tap_psMetadata_polynomials.c =================================================================== --- trunk/psLib/test/types/tap_psMetadata_polynomials.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadata_polynomials.c (revision 12781) @@ -10,841 +10,819 @@ * */ - #include #include - #include "tap.h" #include "pstap.h" -void test1Dcase(void); -void test2Dcase(void); -void test3Dcase(void); -void test4Dcase(void); - int main(void) { - plan_tests(89); - - note("psPolynomial(1D, 2D, 3D, & 4D)(to/from)Metadata tests"); - - test1Dcase(); - test2Dcase(); - test3Dcase(); - test4Dcase(); - - done(); -} - - -void test1Dcase(void) -{ - note(" >>>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 + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(92); + // psPolynomial(1D, 2D, 3D, & 4D)(to/from)Metadata tests + + + // psPolynomial1DtoMetadata & psPolynomial1DfromMetadata functions { - note ("example of 1DtoMD using the names not the sequence"); - - ok( psPolynomial1DtoMetadata(md, p1d, "polyMD"), - "psPolynomial1DtoMetadata: return true for valid inputs."); + psMemId id = psMemGetId(); + 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 + { + note ("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"); + is_double(val, 1.1, + "psPolynomial1DtoMetadata: VAL_X00 is %lf", val); + + val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X01"); + ok(status, + "psPolynomial1DtoMetadata: found VAL_X01"); + is_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"); - 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"); - is_double(val, 1.1, - "psPolynomial1DtoMetadata: VAL_X00 is %lf", val); - - val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X01"); - ok(status, - "psPolynomial1DtoMetadata: found VAL_X01"); - is_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 - { + 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"); + } + psFree(outPoly); psFree(p1d); psFree(md); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // psPolynomial2DtoMetadata & psPolynomial2DfromMetadata functions + { + psMemId id = psMemGetId(); + psMetadata *md = psMetadataAlloc(); + psPolynomial2D *p2d = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 1, 1); + p2d->coeff[0][0] = 1.1; + p2d->coeff[0][1] = 2.2; + 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; + + //psPolynomial2DtoMetadata + //Return a valid metadata containing a polynomial-metadata structure + { + ok( psPolynomial2DtoMetadata(md, p2d, "polyMD"), + "psPolynomial2DtoMetadata: return true for valid inputs."); + + // psMetadataConfigWrite (md, "test.md"); + + //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, + "Skipping 1 tests because psPolynomial2DtoMetadata has errors"); + psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); + skip_start( polyItem == NULL, 2, + "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."); + polyItem = psMetadataGet(polyMDtemp, 1); + ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1, + "psPolynomial2DtoMetadata: return correct number of y orders."); + skip_end(); + polyItem = psMetadataGet(polyMDtemp, 2); + skip_start( polyItem == NULL, 2, + "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, + "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."); + skip_end(); + skip_end(); + } + + //psPolynomial2DtoMetadata + //Return a valid metadata containing a polynomial-metadata structure + { + note ("example of 2DtoMD using the names not the sequence"); + + 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 = psMetadataLookupMetadata(NULL, md, "polyMD"); + skip_start( polyMDtemp == NULL , 1, + "Skipping 1 tests because psPolynomial2DtoMetadata has errors"); + + bool status; + int nX = psMetadataLookupS32(&status, polyMDtemp, "NORDER_X"); + 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"); + + double val; + val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X00_Y00"); + ok(status, + "psPolynomial2DtoMetadata: found VAL_X00_Y00"); + is_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"); + is_double(val, 4.4, + "psPolynomial2DtoMetadata: VAL_X01_Y01 is %lf", val); + + skip_end(); + } + + //Return false for no-name polynomial + { + ok( !psPolynomial2DtoMetadata(md, p2d, ""), + "psPolynomial2DtoMetadata: return false for no-name."); + } + //Return false for NULL-name polynomial + { + ok( !psPolynomial2DtoMetadata(md, p2d, NULL), + "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."); + } + //Return false for NULL polynomial input + { + ok( !psPolynomial2DtoMetadata(md, NULL, "polyMD"), + "psPolynomial2DtoMetadata: return false for NULL polynomial input."); + } + //Return true for polynomial with 1 element, a constant + { + psPolynomial2D *constPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0); + constPoly->coeff[0][0] = 6.66; + ok( psPolynomial2DtoMetadata(md, constPoly, "polyMD"), + "psPolynomial2DtoMetadata: 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( !psPolynomial2DtoMetadata(md, p2d2, "polyMD"), + "psPolynomial2DtoMetadata: return false for chebyshev polynomial"); + psFree(p2d2); + } + + //psPolynomial2DfromMetadata Tests + //Return NULL for NULL metadata input. + { + psPolynomial2D *emptyPoly2D = NULL; + emptyPoly2D = psPolynomial2DfromMetadata(NULL); + ok( emptyPoly2D == NULL, + "psPolynomial2DfromMetadata: return NULL for NULL metadata input."); + } + //Get a polynomial from Metadata. + psPolynomial2D *outPoly = NULL; + psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD"); + outPoly = psPolynomial2DfromMetadata(polyMDtemp); + { + skip_start( outPoly == NULL, 1, + "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, + "psPolynomial2DfromMetadata: return correct polynomial from metadata"); + skip_end(); + } + //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 == 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"); + } + //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"); + } + + psFree(outPoly); + psFree(p2d); + psFree(md); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // psPolynomial3DtoMetadata & psPolynomial3DfromMetadata functions + { + psMemId id = psMemGetId(); + psMetadata *md = psMetadataAlloc(); + 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; + + //psPolynomial3DtoMetadata + //Return a valid metadata containing a polynomial-metadata structure + { + 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 psPolynomial3DtoMetadata has errors"); + psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); + skip_start( polyItem == NULL, 2, + "Skipping 3 tests because psPolynomial3DtoMetadata has errors in order elements"); + ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1, + "psPolynomial3DtoMetadata: return correct number of x orders."); + polyItem = psMetadataGet(polyMDtemp, 1); + ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1, + "psPolynomial3DtoMetadata: return correct number of y orders."); + polyItem = psMetadataGet(polyMDtemp, 2); + ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1, + "psPolynomial3DtoMetadata: return correct number of z orders."); + skip_end(); + polyItem = psMetadataGet(polyMDtemp, 3); + skip_start( polyItem == NULL, 2, + "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, + "psPolynomial3DtoMetadata: return correct first element."); + polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL-1); + ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01", 14) && + abs(polyItem->data.F64-0.8) < DBL_EPSILON, + "psPolynomial3DtoMetadata: return correct last element."); + skip_end(); + skip_end(); + } + //Return false for no-name polynomial + { + ok( !psPolynomial3DtoMetadata(md, p3d, ""), + "psPolynomial3DtoMetadata: return false for no-name."); + } + //Return false for NULL-name polynomial + { + ok( !psPolynomial3DtoMetadata(md, p3d, NULL), + "psPolynomial3DtoMetadata: return false for NULL name input."); + } + //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( !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( !psPolynomial3DtoMetadata(md, emptyPoly, "polyMD"), + "psPolynomial3DtoMetadata: 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( psPolynomial3DtoMetadata(md, constPoly, "polyMD"), + "psPolynomial3DtoMetadata: 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( !psPolynomial3DtoMetadata(md, p3d2, "polyMD"), + "psPolynomial3DtoMetadata: return false for chebyshev polynomial"); + psFree(p3d2); + } + + //psPolynomial3DfromMetadata Tests + //Return NULL for NULL metadata input. + { + psPolynomial3D *emptyPoly2D = NULL; + emptyPoly2D = psPolynomial3DfromMetadata(NULL); + ok( emptyPoly2D == NULL, + "psPolynomial3DfromMetadata: return NULL for NULL metadata input."); + } + //Get a polynomial from Metadata. + psPolynomial3D *outPoly = NULL; + psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD"); + outPoly = psPolynomial3DfromMetadata(polyMDtemp); + { + skip_start( outPoly == NULL, 1, + "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, + "psPolynomial3DfromMetadata: return correct polynomial from metadata"); + skip_end(); + } + + //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 == 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); + { + 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"); + psFree(outPoly); + outPoly = NULL; + 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"); + psFree(outPoly); + outPoly = NULL; + outPoly = psPolynomial3DfromMetadata(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial3DfromMetadata: return NULL for metadata-polynomial with no x-order"); + } + + psFree(outPoly); + psFree(p3d); + psFree(md); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // psPolynomial4DtoMetadata & psPolynomial4DfromMetadata functions + { + psMemId id = psMemGetId(); + psMetadata *md = psMetadataAlloc(); + 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; + + //psPolynomial4DtoMetadata + //Return a valid metadata containing a polynomial-metadata structure + { + 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 psPolynomial4DtoMetadata has errors"); + psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); + skip_start( polyItem == NULL, 2, + "Skipping 4 tests because psPolynomial4DtoMetadata has errors in order elements"); + ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1, + "psPolynomial4DtoMetadata: return correct number of x orders."); + polyItem = psMetadataGet(polyMDtemp, 1); + ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1, + "psPolynomial4DtoMetadata: return correct number of y orders."); + polyItem = psMetadataGet(polyMDtemp, 2); + ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1, + "psPolynomial4DtoMetadata: return correct number of z orders."); + polyItem = psMetadataGet(polyMDtemp, 3); + ok( !strncmp(polyItem->name, "NORDER_T", 10) && polyItem->data.S32 == 1, + "psPolynomial4DtoMetadata: return correct number of t orders."); + skip_end(); + polyItem = psMetadataGet(polyMDtemp, 4); + skip_start( polyItem == NULL, 2, + "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, + "psPolynomial4DtoMetadata: return correct first element."); + 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, + "psPolynomial4DtoMetadata: return correct last element."); + skip_end(); + skip_end(); + } + //Return false for no-name polynomial + { + ok( !psPolynomial4DtoMetadata(md, p4d, ""), + "psPolynomial4DtoMetadata: return false for no-name."); + } + //Return false for NULL-name polynomial + { + ok( !psPolynomial4DtoMetadata(md, p4d, NULL), + "psPolynomial4DtoMetadata: return false for NULL name input."); + } + //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( !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( !psPolynomial4DtoMetadata(md, emptyPoly, "polyMD"), + "psPolynomial4DtoMetadata: 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( psPolynomial4DtoMetadata(md, constPoly, "polyMD"), + "psPolynomial4DtoMetadata: 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( !psPolynomial4DtoMetadata(md, p4d2, "polyMD"), + "psPolynomial4DtoMetadata: return false for chebyshev polynomial"); + psFree(p4d2); + } + + //psPolynomial4DfromMetadata Tests + //Return NULL for NULL metadata input. + { + psPolynomial4D *emptyPoly2D = NULL; + emptyPoly2D = psPolynomial4DfromMetadata(NULL); + ok( emptyPoly2D == NULL, + "psPolynomial4DfromMetadata: return NULL for NULL metadata input."); + } + //Get a polynomial from Metadata. + psPolynomial4D *outPoly = NULL; + psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD"); + outPoly = psPolynomial4DfromMetadata(polyMDtemp); + { + skip_start( outPoly == NULL, 1, + "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, + "psPolynomial4DfromMetadata: return correct polynomial from metadata"); + skip_end(); + } + //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 == 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); + { + 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"); + psFree(outPoly); + outPoly = NULL; + 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"); + psFree(outPoly); + outPoly = NULL; + 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"); + psFree(outPoly); + outPoly = NULL; + outPoly = psPolynomial4DfromMetadata(polyMDtemp); + { + ok( outPoly == NULL, + "psPolynomial4DfromMetadata: return NULL for metadata-polynomial with no x-order"); + } + + psFree(outPoly); + psFree(p4d); + psFree(md); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } } - -void test2Dcase(void) -{ - note(" >>>Test 2: psPolynomial2DtoMetadata & psPolynomial2DfromMetadata functions"); - psMetadata *md = psMetadataAlloc(); - psPolynomial2D *p2d = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 1, 1); - p2d->coeff[0][0] = 1.1; - p2d->coeff[0][1] = 2.2; - 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; - - //psPolynomial2DtoMetadata - //Return a valid metadata containing a polynomial-metadata structure - { - ok( psPolynomial2DtoMetadata(md, p2d, "polyMD"), - "psPolynomial2DtoMetadata: return true for valid inputs."); - - // psMetadataConfigWrite (md, "test.md"); - - //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, - "Skipping 1 tests because psPolynomial2DtoMetadata has errors"); - psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); - skip_start( polyItem == NULL, 2, - "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."); - polyItem = psMetadataGet(polyMDtemp, 1); - ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1, - "psPolynomial2DtoMetadata: return correct number of y orders."); - skip_end(); - polyItem = psMetadataGet(polyMDtemp, 2); - skip_start( polyItem == NULL, 2, - "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, - "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."); - skip_end(); - skip_end(); - } - - //psPolynomial2DtoMetadata - //Return a valid metadata containing a polynomial-metadata structure - { - note ("example of 2DtoMD using the names not the sequence"); - - 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 = psMetadataLookupMetadata(NULL, md, "polyMD"); - skip_start( polyMDtemp == NULL , 1, - "Skipping 1 tests because psPolynomial2DtoMetadata has errors"); - - bool status; - int nX = psMetadataLookupS32(&status, polyMDtemp, "NORDER_X"); - 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"); - - double val; - val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X00_Y00"); - ok(status, - "psPolynomial2DtoMetadata: found VAL_X00_Y00"); - is_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"); - is_double(val, 4.4, - "psPolynomial2DtoMetadata: VAL_X01_Y01 is %lf", val); - - skip_end(); - } - - //Return false for no-name polynomial - { - ok( !psPolynomial2DtoMetadata(md, p2d, ""), - "psPolynomial2DtoMetadata: return false for no-name."); - } - //Return false for NULL-name polynomial - { - ok( !psPolynomial2DtoMetadata(md, p2d, NULL), - "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."); - } - //Return false for NULL polynomial input - { - ok( !psPolynomial2DtoMetadata(md, NULL, "polyMD"), - "psPolynomial2DtoMetadata: return false for NULL polynomial input."); - } - //Return true for polynomial with 1 element, a constant - { - psPolynomial2D *constPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0); - constPoly->coeff[0][0] = 6.66; - ok( psPolynomial2DtoMetadata(md, constPoly, "polyMD"), - "psPolynomial2DtoMetadata: 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( !psPolynomial2DtoMetadata(md, p2d2, "polyMD"), - "psPolynomial2DtoMetadata: return false for chebyshev polynomial"); - psFree(p2d2); - } - - //psPolynomial2DfromMetadata Tests - //Return NULL for NULL metadata input. - { - psPolynomial2D *emptyPoly2D = NULL; - emptyPoly2D = psPolynomial2DfromMetadata(NULL); - ok( emptyPoly2D == NULL, - "psPolynomial2DfromMetadata: return NULL for NULL metadata input."); - } - //Get a polynomial from Metadata. - psPolynomial2D *outPoly = NULL; - psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD"); - outPoly = psPolynomial2DfromMetadata(polyMDtemp); - { - skip_start( outPoly == NULL, 1, - "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, - "psPolynomial2DfromMetadata: return correct polynomial from metadata"); - skip_end(); - } - //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 == 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"); - } - //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"); - } - - //Check for Memory leaks - { - psFree(outPoly); - psFree(p2d); - psFree(md); - checkMem(); - } -} - -void test3Dcase(void) -{ - note(" >>>Test 3: psPolynomial3DtoMetadata & psPolynomial3DfromMetadata functions"); - psMetadata *md = psMetadataAlloc(); - 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; - - //psPolynomial3DtoMetadata - //Return a valid metadata containing a polynomial-metadata structure - { - 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 psPolynomial3DtoMetadata has errors"); - psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); - skip_start( polyItem == NULL, 2, - "Skipping 3 tests because psPolynomial3DtoMetadata has errors in order elements"); - ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1, - "psPolynomial3DtoMetadata: return correct number of x orders."); - polyItem = psMetadataGet(polyMDtemp, 1); - ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1, - "psPolynomial3DtoMetadata: return correct number of y orders."); - polyItem = psMetadataGet(polyMDtemp, 2); - ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1, - "psPolynomial3DtoMetadata: return correct number of z orders."); - skip_end(); - polyItem = psMetadataGet(polyMDtemp, 3); - skip_start( polyItem == NULL, 2, - "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, - "psPolynomial3DtoMetadata: return correct first element."); - polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL-1); - ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01", 14) && - abs(polyItem->data.F64-0.8) < DBL_EPSILON, - "psPolynomial3DtoMetadata: return correct last element."); - skip_end(); - skip_end(); - } - //Return false for no-name polynomial - { - ok( !psPolynomial3DtoMetadata(md, p3d, ""), - "psPolynomial3DtoMetadata: return false for no-name."); - } - //Return false for NULL-name polynomial - { - ok( !psPolynomial3DtoMetadata(md, p3d, NULL), - "psPolynomial3DtoMetadata: return false for NULL name input."); - } - //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( !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( !psPolynomial3DtoMetadata(md, emptyPoly, "polyMD"), - "psPolynomial3DtoMetadata: 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( psPolynomial3DtoMetadata(md, constPoly, "polyMD"), - "psPolynomial3DtoMetadata: 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( !psPolynomial3DtoMetadata(md, p3d2, "polyMD"), - "psPolynomial3DtoMetadata: return false for chebyshev polynomial"); - psFree(p3d2); - } - - //psPolynomial3DfromMetadata Tests - //Return NULL for NULL metadata input. - { - psPolynomial3D *emptyPoly2D = NULL; - emptyPoly2D = psPolynomial3DfromMetadata(NULL); - ok( emptyPoly2D == NULL, - "psPolynomial3DfromMetadata: return NULL for NULL metadata input."); - } - //Get a polynomial from Metadata. - psPolynomial3D *outPoly = NULL; - psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD"); - outPoly = psPolynomial3DfromMetadata(polyMDtemp); - { - skip_start( outPoly == NULL, 1, - "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, - "psPolynomial3DfromMetadata: return correct polynomial from metadata"); - skip_end(); - } - - //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 == 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); - { - 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"); - psFree(outPoly); - outPoly = NULL; - 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"); - psFree(outPoly); - outPoly = NULL; - outPoly = psPolynomial3DfromMetadata(polyMDtemp); - { - ok( outPoly == NULL, - "psPolynomial3DfromMetadata: return NULL for metadata-polynomial with no x-order"); - } - - //Check for Memory leaks - { - psFree(outPoly); - psFree(p3d); - psFree(md); - checkMem(); - } -} - -void test4Dcase(void) -{ - note(" >>>Test 4: psPolynomial4DtoMetadata & psPolynomial4DfromMetadata functions"); - psMetadata *md = psMetadataAlloc(); - 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; - - //psPolynomial4DtoMetadata - //Return a valid metadata containing a polynomial-metadata structure - { - 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 psPolynomial4DtoMetadata has errors"); - psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0); - skip_start( polyItem == NULL, 2, - "Skipping 4 tests because psPolynomial4DtoMetadata has errors in order elements"); - ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1, - "psPolynomial4DtoMetadata: return correct number of x orders."); - polyItem = psMetadataGet(polyMDtemp, 1); - ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1, - "psPolynomial4DtoMetadata: return correct number of y orders."); - polyItem = psMetadataGet(polyMDtemp, 2); - ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1, - "psPolynomial4DtoMetadata: return correct number of z orders."); - polyItem = psMetadataGet(polyMDtemp, 3); - ok( !strncmp(polyItem->name, "NORDER_T", 10) && polyItem->data.S32 == 1, - "psPolynomial4DtoMetadata: return correct number of t orders."); - skip_end(); - polyItem = psMetadataGet(polyMDtemp, 4); - skip_start( polyItem == NULL, 2, - "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, - "psPolynomial4DtoMetadata: return correct first element."); - 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, - "psPolynomial4DtoMetadata: return correct last element."); - skip_end(); - skip_end(); - } - //Return false for no-name polynomial - { - ok( !psPolynomial4DtoMetadata(md, p4d, ""), - "psPolynomial4DtoMetadata: return false for no-name."); - } - //Return false for NULL-name polynomial - { - ok( !psPolynomial4DtoMetadata(md, p4d, NULL), - "psPolynomial4DtoMetadata: return false for NULL name input."); - } - //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( !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( !psPolynomial4DtoMetadata(md, emptyPoly, "polyMD"), - "psPolynomial4DtoMetadata: 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( psPolynomial4DtoMetadata(md, constPoly, "polyMD"), - "psPolynomial4DtoMetadata: 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( !psPolynomial4DtoMetadata(md, p4d2, "polyMD"), - "psPolynomial4DtoMetadata: return false for chebyshev polynomial"); - psFree(p4d2); - } - - //psPolynomial4DfromMetadata Tests - //Return NULL for NULL metadata input. - { - psPolynomial4D *emptyPoly2D = NULL; - emptyPoly2D = psPolynomial4DfromMetadata(NULL); - ok( emptyPoly2D == NULL, - "psPolynomial4DfromMetadata: return NULL for NULL metadata input."); - } - //Get a polynomial from Metadata. - psPolynomial4D *outPoly = NULL; - psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD"); - outPoly = psPolynomial4DfromMetadata(polyMDtemp); - { - skip_start( outPoly == NULL, 1, - "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, - "psPolynomial4DfromMetadata: return correct polynomial from metadata"); - skip_end(); - } - //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 == 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); - { - 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"); - psFree(outPoly); - outPoly = NULL; - 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"); - psFree(outPoly); - outPoly = NULL; - 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"); - psFree(outPoly); - outPoly = NULL; - outPoly = psPolynomial4DfromMetadata(polyMDtemp); - { - ok( outPoly == NULL, - "psPolynomial4DfromMetadata: return NULL for metadata-polynomial with no x-order"); - } - - //Check for Memory leaks - { - psFree(outPoly); - psFree(p4d); - psFree(md); - checkMem(); - } -} - - - - + + + + Index: trunk/psLib/test/types/tap_psMetadata_printing.c =================================================================== --- trunk/psLib/test/types/tap_psMetadata_printing.c (revision 12777) +++ trunk/psLib/test/types/tap_psMetadata_printing.c (revision 12781) @@ -10,27 +10,9 @@ * */ - #include #include #include - #include "tap.h" #include "pstap.h" - -static psMetadata *setupMeta(void); -void testMetaPrint(void); -void testMetaItemPrint(void); - -int main(void) -{ - plan_tests(29); - - note("psMetadataPrint and psMetadataItemPrint tests"); - - testMetaPrint(); - testMetaItemPrint(); - - done(); -} static psMetadata *setupMeta(void) @@ -179,216 +161,219 @@ } -void testMetaPrint(void) + +int main(void) { - note(" >>Test 1: psMetadataPrint"); - FILE *fd = fopen("psMetadataPrint.out", "w+"); - FILE *fd_read = fopen("Makefile", "r"); - psMetadata *md = NULL; - psMetadata *md2 = NULL; - md = setupMeta(); - md2 = psMetadataAlloc(); - psSphere *sphere = psSphereAlloc(); - psMetadataAddPtr(md2, PS_LIST_HEAD, "ptr", PS_DATA_SPHERE, "", sphere); - psMetadataAddUnknown(md2, PS_LIST_TAIL, "unknown", 0, "", sphere); - - psImage *image = psImageAlloc(1, 1, PS_TYPE_S32); - psImageSet(image, 0, 0, 1); - psMetadataAddImage(md2, PS_LIST_TAIL, "image1", 0, "I am an Image", image); - - psHash *hash = psHashAlloc(1); - psHashAdd(hash, "hash", image); - psMetadataAddHash(md2, PS_LIST_TAIL, "hash1", 0, "I am a Hash", hash); - - psLookupTable *lookup = psLookupTableAlloc("table2.dat", "%s", 0); - psMetadataAddLookupTable(md2, PS_LIST_TAIL, "lookup", 0, "I am a LookupTable", lookup); - - psArray *array = psArrayAlloc(1); - psArraySet(array, 0, image); - psMetadataAddArray(md2, PS_LIST_TAIL, "array", 0, "I am an Array", array); - - psFree(array); - psFree(lookup); - psFree(image); - psFree(hash); - - //Return false for NULL psMetadata input + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(30); + + + // psMetadataPrint { - ok( !psMetadataPrint(NULL, NULL, 0), - "psMetadataPrint: return false for NULL psMetadata input."); - } - //Return false for read-only file descriptor - { - ok ( !psMetadataPrint(fd_read, md, 0), - "psMetadataPrint: return false for read-only file descriptor."); - } - fclose(fd_read); - //Error and then return true for unprintable datatype (sphere) and DATA_UNKNOWN - { - ok ( !psMetadataPrint(NULL, md2, 0), - "psMetadataPrint: return false for metadata with unknown datatype."); - } - psFree(md2); - - //Valid case where fd is NULL -> stdout - md2 = psMetadataAlloc(); - psMetadataAddStr(md2, PS_LIST_HEAD, - " >>Hello Wally", 0, "My name is Bubbles", "Pet Me"); - { - ok ( psMetadataPrint(NULL, md2, 0), - "psMetadataPrint: return true for NULL file pointer."); - } - psFree(md2); - //Valid case where fd is "psMetadataPrint.out" - { - ok ( psMetadataPrint(fd, md, 0), - "psMetadataPrint: return true for file='psMetadataPrint.out'."); - } - - //Check for Memory Leaks before exit - { + psMemId id = psMemGetId(); + FILE *fd = fopen("psMetadataPrint.out", "w+"); + FILE *fd_read = fopen("Makefile", "r"); + psMetadata *md = NULL; + psMetadata *md2 = NULL; + md = setupMeta(); + md2 = psMetadataAlloc(); + psSphere *sphere = psSphereAlloc(); + psMetadataAddPtr(md2, PS_LIST_HEAD, "ptr", PS_DATA_SPHERE, "", sphere); + psMetadataAddUnknown(md2, PS_LIST_TAIL, "unknown", 0, "", sphere); + + psImage *image = psImageAlloc(1, 1, PS_TYPE_S32); + psImageSet(image, 0, 0, 1); + psMetadataAddImage(md2, PS_LIST_TAIL, "image1", 0, "I am an Image", image); + + psHash *hash = psHashAlloc(1); + psHashAdd(hash, "hash", image); + psMetadataAddHash(md2, PS_LIST_TAIL, "hash1", 0, "I am a Hash", hash); + + psLookupTable *lookup = psLookupTableAlloc("table2.dat", "%s", 0); + psMetadataAddLookupTable(md2, PS_LIST_TAIL, "lookup", 0, "I am a LookupTable", lookup); + + psArray *array = psArrayAlloc(1); + psArraySet(array, 0, image); + psMetadataAddArray(md2, PS_LIST_TAIL, "array", 0, "I am an Array", array); + + psFree(array); + psFree(lookup); + psFree(image); + psFree(hash); + + //Return false for NULL psMetadata input + { + ok( !psMetadataPrint(NULL, NULL, 0), + "psMetadataPrint: return false for NULL psMetadata input."); + } + //Return false for read-only file descriptor + { + ok ( !psMetadataPrint(fd_read, md, 0), + "psMetadataPrint: return false for read-only file descriptor."); + } + fclose(fd_read); + //Error and then return true for unprintable datatype (sphere) and DATA_UNKNOWN + { + ok ( !psMetadataPrint(NULL, md2, 0), + "psMetadataPrint: return false for metadata with unknown datatype."); + } + psFree(md2); + + //Valid case where fd is NULL -> stdout + md2 = psMetadataAlloc(); + psMetadataAddStr(md2, PS_LIST_HEAD, + " >>Hello Wally", 0, "My name is Bubbles", "Pet Me"); + { + ok ( psMetadataPrint(NULL, md2, 0), + "psMetadataPrint: return true for NULL file pointer."); + } + psFree(md2); + //Valid case where fd is "psMetadataPrint.out" + { + ok ( psMetadataPrint(fd, md, 0), + "psMetadataPrint: return true for file='psMetadataPrint.out'."); + } + + //Check for Memory Leaks before exit fclose(fd); - remove - ("psMetadataPrint.out"); + remove("psMetadataPrint.out"); psFree(sphere); psFree(md); - checkMem(); - } -} - -void testMetaItemPrint(void) -{ - note(" >>Test2: psMetadataItemPrint"); - FILE *fd; - //bool psMetadataItemPrint(FILE * fd, const char *format, const psMetadataItem* item) - fd = fopen("psMetadataItemPrint.out", "w"); - psMetadataItem *item1 = psMetadataItemAlloc("bool", PS_DATA_BOOL, "No Comment", true); - psMetadataItem *item2 = psMetadataItemAlloc("f32", PS_DATA_F32, "No Comment", 0.66601); - psMetadataItem *item3 = psMetadataItemAlloc("string", PS_DATA_STRING, "", "Can't touch this"); - psMetadataItem *item4 = psMetadataItemAlloc("U16", PS_DATA_U16, "", 1); - psMetadataItem *item5 = psMetadataItemAlloc("string", PS_DATA_U8, "", "a"); - - //Return false for NULL file-pointer + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); + } + + + // psMetadataItemPrint { - ok( !psMetadataItemPrint(NULL, "%s", item1), - "psMetadataItemPrint: return false for NULL FILE*."); - } - //Return false for NULL format paramter - { - ok( !psMetadataItemPrint(fd, NULL, item1), - "psMetadataItemPrint: return false for NULL format."); - } - //Return false for NULL metadataItem - { - ok( !psMetadataItemPrint(fd, "%s", NULL), - "psMetadataItemPrint: return false for NULL psMetadataItem."); - } - //Return false for incorrect format parameter - { - ok( !psMetadataItemPrint(fd, "sos \n", item1), - "psMetadataItemPrint: return false for incorrect format."); - } - //Return false for type that doesn't match format (ie, %s for f32 value) - { - ok( !psMetadataItemPrint(fd, "%s", item2), - "psMetadataItemPrint: return false for item that doesn't match format."); - } - - //Return false for incorrect format parameter - { - ok( !psMetadataItemPrint(fd, "%z", item1), - "psMetadataItemPrint: return false for incorrect format."); - } - - - //Return true for format parameter containing additional modifiers (F32) - { - ok( psMetadataItemPrint(fd, "%.3f\n", item2), - "psMetadataItemPrint: return true for format with .3 modifier."); - } - //Return true for valid string input - { - ok( psMetadataItemPrint(fd, "%s\n", item3), - "psMetadataItemPrint: return true for valid string case w/s."); - } - //Return true for valid ptr input - { - ok( psMetadataItemPrint(fd, "%p\n", item3), - "psMetadataItemPrint: return true for valid ptr case w/p."); - } - - //Return true for format = %d, type = int - { - ok( psMetadataItemPrint(fd, "%d\n", item4), - "psMetadataItemPrint: return true for valid case w/d."); - } - //Return true for format = %i, type = int - { - ok( psMetadataItemPrint(fd, "%i\n", item4), - "psMetadataItemPrint: return true for valid case w/i."); - } - //Return true for format = %c, type = int - { - ok( psMetadataItemPrint(fd, "%c\n", item5), - "psMetadataItemPrint: return true for valid case w/c."); - } - //Return true for format = %o, type = int - { - ok( psMetadataItemPrint(fd, "%o\n", item4), - "psMetadataItemPrint: return true for valid case w/d."); - } - //Return true for format = %u, type = int - { - ok( psMetadataItemPrint(fd, "%u\n", item4), - "psMetadataItemPrint: return true for valid case w/i."); - } - //Return true for format = %x, type = int - { - ok( psMetadataItemPrint(fd, "%x\n", item5), - "psMetadataItemPrint: return true for valid case w/c."); - } - //Return true for format = %X, type = int - { - ok( psMetadataItemPrint(fd, "%X\n", item5), - "psMetadataItemPrint: return true for valid case w/c."); - } - - //Return true for format = %e, type = int - { - ok( psMetadataItemPrint(fd, "%.1e\n", item2), - "psMetadataItemPrint: return true for valid case w/e."); - } - //Return true for format = %E, type = int - { - ok( psMetadataItemPrint(fd, "%.2E\n", item2), - "psMetadataItemPrint: return true for valid case w/E."); - } - //Return true for format = %F, type = int - { - ok( psMetadataItemPrint(fd, "%.3F\n", item2), - "psMetadataItemPrint: return true for valid case w/F."); - } - //Return true for format = %g, type = int - { - ok( psMetadataItemPrint(fd, "%.3g\n", item2), - "psMetadataItemPrint: return true for valid case w/g."); - } - //Return true for format = %G, type = int - { - ok( psMetadataItemPrint(fd, "%.4G\n", item2), - "psMetadataItemPrint: return true for valid case w/G."); - } - //Return true for format = %a, type = int - { - ok( psMetadataItemPrint(fd, "%.4a\n", item2), - "psMetadataItemPrint: return true for valid case w/a."); - } - //Return true for format = %A, type = int - { - ok( psMetadataItemPrint(fd, "%A\n", item2), - "psMetadataItemPrint: return true for valid case w/A."); - } - - //Check for Memory Leaks before exit - { + psMemId id = psMemGetId(); + FILE *fd; + fd = fopen("psMetadataItemPrint.out", "w"); + psMetadataItem *item1 = psMetadataItemAlloc("bool", PS_DATA_BOOL, "No Comment", true); + psMetadataItem *item2 = psMetadataItemAlloc("f32", PS_DATA_F32, "No Comment", 0.66601); + psMetadataItem *item3 = psMetadataItemAlloc("string", PS_DATA_STRING, "", "Can't touch this"); + psMetadataItem *item4 = psMetadataItemAlloc("U16", PS_DATA_U16, "", 1); + psMetadataItem *item5 = psMetadataItemAlloc("string", PS_DATA_U8, "", "a"); + + //Return false for NULL file-pointer + { + ok( !psMetadataItemPrint(NULL, "%s", item1), + "psMetadataItemPrint: return false for NULL FILE*."); + } + //Return false for NULL format paramter + { + ok( !psMetadataItemPrint(fd, NULL, item1), + "psMetadataItemPrint: return false for NULL format."); + } + //Return false for NULL metadataItem + { + ok( !psMetadataItemPrint(fd, "%s", NULL), + "psMetadataItemPrint: return false for NULL psMetadataItem."); + } + //Return false for incorrect format parameter + { + ok( !psMetadataItemPrint(fd, "sos \n", item1), + "psMetadataItemPrint: return false for incorrect format."); + } + //Return false for type that doesn't match format (ie, %s for f32 value) + { + ok( !psMetadataItemPrint(fd, "%s", item2), + "psMetadataItemPrint: return false for item that doesn't match format."); + } + + //Return false for incorrect format parameter + { + ok( !psMetadataItemPrint(fd, "%z", item1), + "psMetadataItemPrint: return false for incorrect format."); + } + + + //Return true for format parameter containing additional modifiers (F32) + { + ok( psMetadataItemPrint(fd, "%.3f\n", item2), + "psMetadataItemPrint: return true for format with .3 modifier."); + } + //Return true for valid string input + { + ok( psMetadataItemPrint(fd, "%s\n", item3), + "psMetadataItemPrint: return true for valid string case w/s."); + } + //Return true for valid ptr input + { + ok( psMetadataItemPrint(fd, "%p\n", item3), + "psMetadataItemPrint: return true for valid ptr case w/p."); + } + + //Return true for format = %d, type = int + { + ok( psMetadataItemPrint(fd, "%d\n", item4), + "psMetadataItemPrint: return true for valid case w/d."); + } + //Return true for format = %i, type = int + { + ok( psMetadataItemPrint(fd, "%i\n", item4), + "psMetadataItemPrint: return true for valid case w/i."); + } + //Return true for format = %c, type = int + { + ok( psMetadataItemPrint(fd, "%c\n", item5), + "psMetadataItemPrint: return true for valid case w/c."); + } + //Return true for format = %o, type = int + { + ok( psMetadataItemPrint(fd, "%o\n", item4), + "psMetadataItemPrint: return true for valid case w/d."); + } + //Return true for format = %u, type = int + { + ok( psMetadataItemPrint(fd, "%u\n", item4), + "psMetadataItemPrint: return true for valid case w/i."); + } + //Return true for format = %x, type = int + { + ok( psMetadataItemPrint(fd, "%x\n", item5), + "psMetadataItemPrint: return true for valid case w/c."); + } + //Return true for format = %X, type = int + { + ok( psMetadataItemPrint(fd, "%X\n", item5), + "psMetadataItemPrint: return true for valid case w/c."); + } + + //Return true for format = %e, type = int + { + ok( psMetadataItemPrint(fd, "%.1e\n", item2), + "psMetadataItemPrint: return true for valid case w/e."); + } + //Return true for format = %E, type = int + { + ok( psMetadataItemPrint(fd, "%.2E\n", item2), + "psMetadataItemPrint: return true for valid case w/E."); + } + //Return true for format = %F, type = int + { + ok( psMetadataItemPrint(fd, "%.3F\n", item2), + "psMetadataItemPrint: return true for valid case w/F."); + } + //Return true for format = %g, type = int + { + ok( psMetadataItemPrint(fd, "%.3g\n", item2), + "psMetadataItemPrint: return true for valid case w/g."); + } + //Return true for format = %G, type = int + { + ok( psMetadataItemPrint(fd, "%.4G\n", item2), + "psMetadataItemPrint: return true for valid case w/G."); + } + //Return true for format = %a, type = int + { + ok( psMetadataItemPrint(fd, "%.4a\n", item2), + "psMetadataItemPrint: return true for valid case w/a."); + } + //Return true for format = %A, type = int + { + ok( psMetadataItemPrint(fd, "%A\n", item2), + "psMetadataItemPrint: return true for valid case w/A."); + } + fclose(fd); unlink ("psMetadataItemPrint.out"); @@ -398,5 +383,5 @@ psFree(item4); psFree(item5); - checkMem(); + ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks"); } } Index: trunk/psLib/test/types/tap_psPixels_all.c =================================================================== --- trunk/psLib/test/types/tap_psPixels_all.c (revision 12777) +++ trunk/psLib/test/types/tap_psPixels_all.c (revision 12781) @@ -12,7 +12,5 @@ * */ - #include - #include "tap.h" #include "pstap.h"