IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 12781 for trunk/psLib


Ignore:
Timestamp:
Apr 10, 2007, 11:09:31 AM (19 years ago)
Author:
gusciora
Message:

This is a fairly large checkin. Most of the files were modified so they have
the same basic structure and format for testing: reporting errors, checking
memory leaks etc. Several bug fixes are included as well.

Location:
trunk/psLib/test
Files:
42 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/math/tap_psPolynomialEval1D.c

    r11422 r12781  
    44*  ORD and CHEB type polynomials.
    55*
    6 *  @version  $Revision: 1.5 $  $Name: not supported by cvs2svn $
    7 *  @date  $Date: 2007-01-30 04:49:52 $
     6*  @version  $Revision: 1.6 $  $Name: not supported by cvs2svn $
     7*  @date  $Date: 2007-04-10 21:09:30 $
    88*
    99*  XXX: Probably should test single- and multi-dimensional polynomials in
    … …  
    7575        skip_end();
    7676        psFree(polyOrd);
    77         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     77        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    7878    }
    7979

  • trunk/psLib/test/math/tap_psStats00.c

    r12607 r12781  
    99 *  @author GLG, MHPCC
    1010 *
    11  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    12  *  @date $Date: 2007-03-27 22:52:03 $
     11 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     12 *  @date $Date: 2007-04-10 21:09:30 $
    1313 *
    1414 *  Copyright 2004-2005 Maui High Performance Computing Center, Univ. of Hawaii
    … …  
    242242        }
    243243        bool result = psVectorStats(myStats, myVector, NULL, maskVector, 1);
    244         ok(result == false, "psVectorStats suceeded (All values masked)");
     244        ok(result == true, "psVectorStats() returned TRUE (All values masked)");
    245245        ok(isnan(myStats->sampleMean), "psVectorStats() returned NAN");
    246246        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");

  • trunk/psLib/test/math/tap_psStats09.c

    r11686 r12781  
    115115        for (psS32 i=0;i<numData;i++) {
    116116            errors->data.F32[i] = ERRORS;
    117             errors->n++;
    118117        }
    119118    }
    … …  
    125124        for (psS32 i=0;i<numData;i++) {
    126125            errors->data.F64[i] = ERRORS;
    127             errors->n++;
    128126        }
    129127    }
    … …  
    135133        for (psS32 i=0;i<numData;i++) {
    136134            errors->data.S8[i] = (psS8) ERRORS;
    137             errors->n++;
    138135        }
    139136    }
    … …  
    145142        for (psS32 i=0;i<numData;i++) {
    146143            errors->data.U16[i] = (psU16) ERRORS;
    147             errors->n++;
    148144        }
    149145    }
    … …  
    155151        for (psS32 i=0;i<numData;i++) {
    156152            errors->data.S32[i] = (psS32) ERRORS;
    157             errors->n++;
    158153        }
    159154    }
    … …  
    171166        for (psS32 i=0;i<numData;i++) {
    172167            mask->data.U8[i] = (psU8) 0;
    173             mask->n++;
    174168        }
    175169    }
    … …  
    181175        for (psS32 i=0;i<numData;i++) {
    182176            mask->data.S32[i] = (psS32) 0;
    183             mask->n++;
    184177        }
    185178    }
    … …  
    282275        bool rc = psVectorStats(myStats, in, errors, outliers, 1);
    283276        if (rc == false) {
    284             diag("TEST ERROR: the psVectorStats() function returned NULL.\n");
     277            diag("TEST ERROR: the psVectorStats() function returned NULL (a).\n");
    285278            testStatus = false;
    286279        } else {
    … …  
    301294    if (rc == false) {
    302295        if (expectedRC == true) {
    303             diag("TEST ERROR: the psVectorStats() function returned NULL.\n");
     296            diag("TEST ERROR: the psVectorStats() function returned NULL (b).\n");
    304297            testStatus = false;
    305298        }

  • trunk/psLib/test/mathtypes/tap_psImage.c

    r12513 r12781  
    66 *  @author Robert DeSonia, MHPCC
    77 *
    8  *  @version $Revision: 1.5 $ $Name: not supported by cvs2svn $
    9  *  @date $Date: 2007-03-20 03:57:25 $
     8 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
     9 *  @date $Date: 2007-04-10 21:09:30 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1616#include <string.h>
    1717#include <stdlib.h>
    18 
    1918#include "pslib.h"
    2019#include "psType.h"
    21 
    2220#include "tap.h"
    2321#include "pstap.h"
    2422
    25 
    26 //static int Okay = 1;
    27 //static int setOkay( int okay )
    28 //{
    29 //    Okay = okay;
    30 //    return okay;
    31 //}
    3223
    3324#define OK(exp) \
    … …  
    4031}
    4132
    42 
    43 
    4433int main(int argc, char* argv[])
    4534{
    46     plan_tests(383);
    47 
    48     void testImageAlloc(void);
    49     testImageAlloc();
    50 
    51     void testRegion(void);
    52     testRegion();
    53 
    54     void testRegion2(void);
    55     testRegion2();
    56 
    57     void testRegion3(void);
    58     testRegion3();
    59 
    60     void testImageInit(void);
    61     testImageInit();
    62 
    63     void testImageSet(void);
    64     testImageSet();
     35    psLogSetFormat("HLNM");
     36    psLogSetLevel(PS_LOG_INFO);
     37    plan_tests(402);
     38
     39    // testImageAlloc()
     40    {
     41        psMemId id = psMemGetId();
     42        psImage* image = NULL;
     43        psU32 sizes = 6;
     44        psU32 numCols[] = {0,1,1,100,100,150};
     45        psU32 numRows[] = {0,1,100,1,150,100};
     46        psU32 types = 12;
     47        psElemType type[] = { PS_TYPE_S8, PS_TYPE_S16, PS_TYPE_S32, PS_TYPE_S64,
     48                              PS_TYPE_U8, PS_TYPE_U16, PS_TYPE_U32, PS_TYPE_U64,
     49                              PS_TYPE_F32, PS_TYPE_F64 };
     50        for (psU32 t=0;t<types;t++) {
     51            for (psU32 i=0;i<sizes;i++) {
     52                // Following should be an error if numRows[i] == 0 || numCols[i]==0
     53                image = psImageAlloc(numCols[i],numRows[i],type[t]);
     54                if (image == NULL) {
     55                    if (numRows[i] == 0 || numCols[i] == 0) {
     56                        continue;
     57                    }
     58                    ok(0, "psImageAlloc returned NULL for type %x, size %dx%d.",
     59                       type[t], numCols[i], numRows[i]);
     60                    psFree(image);
     61                }
     62
     63                ok(image->type.dimen==PS_DIMEN_IMAGE && image->type.type==type[t],
     64                    "psImageAlloc allocated dimen/type (%d/%d), expecting "
     65                    "PS_IMAGE_DIMEN/%d", image->type.dimen,
     66                    image->type.type, type[t]);
     67                ok(image->numCols == numCols[i] && image->numRows == numRows[i],
     68                    "psImageAlloc allocated size %dx%d, expecting be %dx%d "
     69                    "(type = %d)", image->numCols, image->numRows, numCols[i],
     70                    numRows[i],type[t]);
     71                ok(image->col0 == 0 && image->row0 == 0,
     72                    "psImageAlloc returned row0/col0 of %d/%d.  Expected 0/0.",
     73                    image->row0, image->row0);
     74                ok(image->parent == NULL, "psImageAlloc returned NULL parent");
     75                ok(image->children == NULL,
     76                    "psImageAlloc returned NULL children array");
     77
     78
     79                if (image->children != NULL) {
     80                    psFree(image);
     81                }
     82
     83                switch (type[t]) {
     84                case PS_TYPE_U16: {
     85                        psU32 rows = numRows[i];
     86                        psU32 cols = numCols[i];
     87   
     88                        for (psS32 r=0;r<rows;r++) {
     89                            for (psS32 c=0;c<cols;c++) {
     90                                image->data.U16[r][c] = 2*c+r;
     91                            }
     92                        }
     93                        bool errorFlag = false;
     94                        for (psS32 r=0;r<rows;r++) {
     95                            for (psS32 c=0;c<cols;c++) {
     96                                if (image->data.U16[r][c] != 2*c+r) {
     97                                    errorFlag = true;
     98                                }
     99                            }
     100                        }
     101                        ok(!errorFlag, "psImageAlloc() set data correctly (U16)");
     102                    }
     103                    break;
     104                case PS_TYPE_F32: {
     105                        psU32 rows = numRows[i];
     106                        psU32 cols = numCols[i];
     107   
     108                        for (psS32 r=0;r<rows;r++) {
     109                            for (psS32 c=0;c<cols;c++) {
     110                                image->data.F32[r][c] = 2.0f*c+r;
     111                            }
     112                        }
     113                        bool errorFlag = false;
     114                        for (psS32 r=0;r<rows;r++) {
     115                            for (psS32 c=0;c<cols;c++) {
     116                                if (fabsf(image->data.F32[r][c] - (2.0f*c+r)) > FLT_EPSILON) {
     117                                    errorFlag = true;
     118                                }
     119                            }
     120                        }
     121                        ok(!errorFlag, "psImageAlloc() set data correctly (F32)");
     122                    }
     123                    break;
     124                case PS_TYPE_F64: {
     125                        psU32 rows = numRows[i];
     126                        psU32 cols = numCols[i];
     127   
     128                        for (psS32 r=0;r<rows;r++) {
     129                            for (psS32 c=0;c<cols;c++) {
     130                                image->data.F64[r][c] = 2.0f*c+r;
     131                            }
     132                        }
     133                        bool errorFlag = false;
     134                        for (psS32 r=0;r<rows;r++) {
     135                            for (psS32 c=0;c<cols;c++) {
     136                                if (fabs(image->data.F64[r][c] - (2.0f*c+r)) > DBL_EPSILON) {
     137                                    errorFlag = true;
     138                                }
     139                            }
     140                        }
     141                        ok(!errorFlag, "psImageAlloc() set data correctly (F64)");
     142                    }
     143                    break;
     144                default: {
     145                        // ignore type and just use as byte bucket.
     146                        psU32 rows = numRows[i];
     147                        psU32 cols = numCols[i]*PSELEMTYPE_SIZEOF(type[t]);
     148   
     149                        for (psS32 r=0;r<rows;r++) {
     150                            for (psS32 c=0;c<cols;c++) {
     151                                image->data.U8[r][c] = (uint8_t)(r + c);
     152                            }
     153                        }
     154                        bool errorFlag = false;
     155                        for (psS32 r=0;r<rows;r++) {
     156                            for (psS32 c=0;c<cols;c++) {
     157                                if (image->data.U8[r][c] != (uint8_t)(r + c)) {
     158                                    errorFlag = true;
     159                                }
     160                            }
     161                        }
     162                        ok(!errorFlag, "psImageAlloc() set data correctly (default)");
     163                    }
     164                }
     165                psFree(image);
     166            }
     167        }
     168
     169        // #548: Verify no memory leaks or corruption are detected after a valid psImage structure with multiple
     170        // children is freed.
     171        image = psImageAlloc(100,100,PS_TYPE_F32);
     172        psImageSubset(image,(psRegion) {50,0,70,20});
     173        psImageSubset(image,(psRegion) {70,20,90,40});
     174        psFree(image);
     175        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     176    }
     177
     178
     179    // testRegion()
     180    {
     181        psMemId id = psMemGetId();
     182        psRegion region = psRegionSet(1,2,3,4);
     183        char *tmpStr = psRegionToString(region);
     184        ok(!(region.x0 != 1 || region.x1 != 2 || region.y0 != 3 || region.y1 != 4),
     185            "The region attributes are set to (%s)", tmpStr);
     186        psFree(tmpStr);
     187        region = psRegionFromString("[1:2,3:4]");
     188        tmpStr = psRegionToString(region);
     189        ok(!(region.x0 != 0 || region.x1 != 2 || region.y0 != 2 || region.y1 != 4),
     190            "The region attributes are set to (%s)", tmpStr);
     191        psFree(tmpStr);
     192        region = psRegionFromString("[1:2,3:]");
     193        ok(isnan(region.x0),
     194            "psRegionFromString returned a NULL pointer given a malformed string.");
     195        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     196    }
     197
     198
     199    //psRegionForImage
     200    {
     201        psMemId id = psMemGetId();
     202        psImage *in;
     203        psRegion inReg;
     204        psRegion out;
     205        in = psImageAlloc(1, 1, PS_TYPE_S32);
     206        inReg = psRegionSet(1, 2, 1, 2);
     207        out = psRegionForImage(in,inReg);
     208        psRegion inReg2;
     209        psRegion out2;
     210        inReg2 = psRegionSet(-1, 0, -2, -1);
     211        out2 = psRegionForImage(in, inReg2);
     212   
     213        ok(!( out.x0 != 1 || out.x1 != 1 || out.y0 != 1 || out.y1 != 1 ),
     214           "Region For Image returned correct values");
     215   
     216        ok(!( out2.x0 != 0 || out2.x1 != 1 || out2.y0 != 0 || out2.y1 != 0 ),
     217           "Region For Image returned correct values");
     218        psFree(in);
     219        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     220    }
     221
     222
     223    //psRegionForSquare//
     224    {
     225        psMemId id = psMemGetId();
     226        float X = 1;
     227        float Y = 1;
     228        float RAD = 1;
     229        psRegion out;
     230        out = psRegionForSquare(X, Y, RAD);
     231        ok(!(out.x0 != 0 || out.x1 != 3 || out.y0 != 0 || out.y1!= 3),
     232            "Region For Square returned correct values");
     233        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     234    }
     235
     236
     237    //Initialize an image with a given value.//
     238    {
     239        psMemId id = psMemGetId();
     240        psImage *in1 = NULL;
     241        psImage *in2 = NULL;
     242        psImage *in3 = NULL;
     243        psImage *in4 = NULL;
     244        int nRow = 1;
     245        int nCol = 1;
     246        in1 = psImageAlloc(nRow, nCol, PS_TYPE_U8);
     247        ok(psImageInit(in1, 5 ),
     248             "ImageAlloc.  U8 Case - 1x1");
     249        nRow = 5;
     250        in2 = psImageAlloc(nRow, nCol, PS_TYPE_F32);
     251        ok(psImageInit(in2, 3),
     252             "ImageAlloc.  F32 Case - 5x1");
     253   
     254        nCol = 5;
     255        in3 = psImageAlloc(nRow, nCol, PS_TYPE_F64);
     256        ok(psImageInit(in3, 3.14),
     257             "ImageAlloc.  F64 Case - 5x5");
     258   
     259        in4 = psImageAlloc(nRow, nCol, PS_TYPE_S32);
     260        ok(psImageInit(in4, 3),
     261             "ImageAlloc.  S32 Case - 5x5");
     262        psFree(in1);
     263        psFree(in2);
     264        psFree(in3);
     265        psFree(in4);
     266        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     267    }
     268
     269
     270    // testImageSet()
     271    {
     272        psMemId id = psMemGetId();
     273        psImage *image = NULL;
     274        image = psImageAlloc(5, 4, PS_TYPE_S32);
     275
     276        //Set the position of the subimage relative to the parent.
     277        image->col0 = 10;
     278        image->row0 = 10;
     279        for (int i = 0; i < 4; i++) {
     280            for (int j = 0; j < 5; j++) {
     281                image->data.S32[i][j] = i+j;
     282            }
     283        }
     284
     285        //Attempt to set a position in a NULL psImage*
     286        psImage *none = NULL;
     287        ok(! psImageSet(none, 1, 1, 1),
     288            "psImageSet returned non-null");
     289
     290        //Attempt to set a position in a psImage* with negative numCols, numRows
     291        none = psImageAlloc(2, 2, PS_TYPE_S32);
     292        *(int*)&none->numCols = -1;
     293        ok(! psImageSet(none, 1, 1, 1),
     294            "psImageSet return false when passed an image with negative numCols");
     295
     296        *(int*)&none->numCols = 2;
     297        *(int*)&none->numRows = -1;
     298        ok(!psImageSet(none, 1, 1, 1),
     299             "psImageSet failed to return false when passed an image with negative numRows");
     300
     301        //Attempt to set a position in a psImage* with negative col0, row0
     302        *(int*)&none->numRows = 2;
     303        none->row0 = -1;
     304        ok(!psImageSet(none, 1, 1, 1),
     305             "psImageSet failed to return false when passed an image with negative col0");
     306
     307        none->row0 = 0;
     308        none->col0 = -1;
     309        ok(!psImageSet(none, 1, 1, 1),
     310             "psImageSet failed to return false when passed an image with negative col0");
     311        psFree(none);
     312
     313        //Try to set a position inside of the subimage.
     314        ok(psImageSet(image, 14, 12, 666),
     315             "psImageSet failed to return true when passed valid parameters");
     316
     317        ok(image->data.S32[2][4] == 666,
     318            "psImageSet set the data value. value=%d", image->data.S32[2][4]);
     319
     320        //Try to set a position inside of the subimage from the tail.
     321        ok(psImageSet(image, -1, -1, 666),
     322             "psImageSet return true when passed valid parameters");
     323
     324        ok(image->data.S32[3][4] == 666,
     325            "psImageSet set (from the tail) the data values correctly");
     326
     327        //Try to set a position outside of the subimage but inside of the parent image.
     328        ok(!psImageSet(image, 0, 0, 666),
     329             "psImageSet return false when passed an invalid location");
     330
     331        ok(!psImageSet(image, 9, 10, 666),
     332             "psImageSet return false when passed an invalid location");
     333
     334        //Try to set a position outside of the subimage.
     335        ok(!psImageSet(image, 15, 14, 666),
     336             "psImageSet return false when passed an invalid location");
     337
     338        //Try to set a position outside of the subimage, indexing from the tail.
     339        ok(!psImageSet(image, -6, -1, 666),
     340             "psImageSet return false when passed an invalid location");
     341        psFree(image);
     342        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     343    }
     344
     345
     346    // testImageGet()
     347    {
     348        psMemId id = psMemGetId();
     349        psImage *image = NULL;
     350        image = psImageAlloc(5, 3, PS_TYPE_S32);
     351
     352        //Set the position of the subimage relative to the parent.
     353        image->col0 = 10;
     354        image->row0 = 10;
     355        for (int i = 0; i < 3; i++) {
     356            for (int j = 0; j < 5; j++) {
     357                image->data.S32[i][j] = i+j;
     358            }
     359        }
     360   
     361        //Attempt to get a position in a NULL psImage*
     362        psImage *none = NULL;
     363        ok(isnan( psImageGet(none, 1, 1) ),
     364             "psImageGet return false when passed a NULL image");
     365   
     366        //Attempt to get a position in a psImage* with negative numCols, numRows
     367        none = psImageAlloc(2, 2, PS_TYPE_S32);
     368        *(int*)&none->numCols = -1;
     369        ok(isnan( psImageGet(none, 1, 1) ),
     370             "psImageGet return false when passed an image with negative numCols");
     371   
     372        *(int*)&none->numCols = 2;
     373        *(int*)&none->numRows = -1;
     374        ok(isnan( psImageGet(none, 1, 1) ),
     375             "psImageGet return false when passed an image with negative numRows");
     376   
     377        //Attempt to get a position in a psImage* with negative col0, row0
     378        *(int*)&none->numRows = 2;
     379        none->row0 = -1;
     380        ok(isnan( psImageGet(none, 1, 1) ),
     381             "psImageGet return false when passed an image with negative col0");
     382   
     383        none->row0 = 0;
     384        none->col0 = -1;
     385        ok(isnan( psImageGet(none, 1, 1) ),
     386             "psImageGet return false when passed an image with negative col0");
     387   
     388        psFree(none);
     389   
     390   
     391        //Try to get a position inside of the subimage.
     392        ok(psImageGet(image, 14, 12) == 6,
     393             "psImageGet return the correct value");
     394   
     395        //Try to get a position inside of the subimage from the tail.
     396        ok(psImageGet(image, -1, -1) == 6,
     397             "psImageGet return the correct value");
     398   
     399        //Try to get a position outside of the subimage but inside of the parent image.
     400        ok(isnan( psImageGet(image, 1, 1) ),
     401             "psImageGet return NAN when passed an invalid location");
     402   
     403        ok(isnan( psImageGet(image, 9, 10) ),
     404             "psImageGet return NAN when passed an invalid location");
     405   
     406        //Try to set a position outside of the subimage.
     407        ok(isnan( psImageGet(image, 15, 14) ),
     408             "psImageGet return NAN when passed an invalid location");
     409   
     410        //Try to set a position outside of the subimage, indexing from the tail.
     411        ok(isnan( psImageGet(image, -6, -1) ),
     412             "psImageGet failed to return NAN when passed an invalid location");
     413        psFree(image);
     414        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     415        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     416    }
    65417}
    66 
    67 
    68 void testImageAlloc()
    69 {
    70 //    diag("testImageAlloc");
    71 
    72     psImage* image = NULL;
    73     psU32 sizes = 6;
    74     psU32 numCols[] = {
    75                           0,1,1,100,100,150
    76                       };
    77     psU32 numRows[] = {
    78                           0,1,100,1,150,100
    79                       };
    80     psU32 types = 12;
    81     psElemType type[] = { PS_TYPE_S8, PS_TYPE_S16, PS_TYPE_S32, PS_TYPE_S64,
    82                           PS_TYPE_U8, PS_TYPE_U16, PS_TYPE_U32, PS_TYPE_U64,
    83                           PS_TYPE_F32, PS_TYPE_F64 };
    84 
    85     for (psU32 t=0;t<types;t++) {
    86 
    87         for (psU32 i=0;i<sizes;i++) {
    88 
    89             // Following should be an error if numRows[i] == 0 || numCols[i]==0
    90 
    91             image = psImageAlloc(numCols[i],numRows[i],type[t]);
    92 
    93             if (image == NULL) {
    94                 if (numRows[i] == 0 || numCols[i] == 0) {
    95                     continue;
    96                 }
    97                 ok(0, "psImageAlloc returned NULL for type %x, size %dx%d.",
    98                    type[t], numCols[i], numRows[i]);
    99                 psFree(image);
    100                 return;
    101             }
    102 
    103             ok (image->type.dimen==PS_DIMEN_IMAGE && image->type.type==type[t],
    104                 "psImageAlloc allocated dimen/type (%d/%d), expecting "
    105                 "PS_IMAGE_DIMEN/%d", image->type.dimen,
    106                 image->type.type, type[t]);
    107             skip_start (!(image->type.dimen==PS_DIMEN_IMAGE && image->type.type==type[t]),
    108                         4, "psImageAlloc allocated wrong dimen/type");
    109 
    110             ok (image->numCols == numCols[i] && image->numRows == numRows[i],
    111                 "psImageAlloc allocated size %dx%d, expecting be %dx%d "
    112                 "(type = %d)", image->numCols, image->numRows, numCols[i],
    113                 numRows[i],type[t]);
    114             skip_start (!(image->numCols == numCols[i] && image->numRows == numRows[i]),
    115                         3, "psImageAlloc allocated wrong size");
    116 
    117             ok (image->col0 == 0 && image->row0 == 0,
    118                 "psImageAlloc returned row0/col0 of %d/%d.  Expected 0/0.",
    119                 image->row0, image->row0);
    120             skip_start (!(image->col0 == 0 && image->row0 == 0),
    121                         2, "psImageAlloc returned wrong row0/col0");
    122 
    123             ok (image->parent == NULL, "psImageAlloc returned NULL parent");
    124             skip_start (image->parent != NULL,
    125                         1, "psImageAlloc returned NULL parent");
    126 
    127             ok (image->children == NULL,
    128                 "psImageAlloc returned NULL children array");
    129 
    130             skip_end();
    131             skip_end();
    132             skip_end();
    133             skip_end();
    134 
    135             if (image->children != NULL) {
    136                 psFree(image);
    137                 return;
    138             }
    139 
    140             switch (type[t]) {
    141             case PS_TYPE_U16: {
    142                     psU32 rows = numRows[i];
    143                     psU32 cols = numCols[i];
    144 
    145                     for (psS32 r=0;r<rows;r++) {
    146                         for (psS32 c=0;c<cols;c++) {
    147                             image->data.U16[r][c] = 2*c+r;
    148                         }
    149                     }
    150                     bool errorFlag = false;
    151                     for (psS32 r=0;r<rows;r++) {
    152                         for (psS32 c=0;c<cols;c++) {
    153                             if (image->data.U16[r][c] != 2*c+r) {
    154 //                                diag("ERROR: Could not set all pixels in uint16 image at (%d,%d)",c,r);
    155                                 errorFlag = true;
    156                             }
    157                         }
    158                     }
    159                     ok(!errorFlag, "psImageAlloc() set data correctly (U16)");
    160                 }
    161                 break;
    162             case PS_TYPE_F32: {
    163                     psU32 rows = numRows[i];
    164                     psU32 cols = numCols[i];
    165 
    166                     for (psS32 r=0;r<rows;r++) {
    167                         for (psS32 c=0;c<cols;c++) {
    168                             image->data.F32[r][c] = 2.0f*c+r;
    169                         }
    170                     }
    171                     bool errorFlag = false;
    172                     for (psS32 r=0;r<rows;r++) {
    173                         for (psS32 c=0;c<cols;c++) {
    174                             if (fabsf(image->data.F32[r][c] - (2.0f*c+r)) > FLT_EPSILON) {
    175 //                                diag("Could not set all pixels in float image at (%d,%d)",c,r);
    176                                 errorFlag = true;
    177                             }
    178                         }
    179                     }
    180                     ok(!errorFlag, "psImageAlloc() set data correctly (F32)");
    181                 }
    182                 break;
    183             case PS_TYPE_F64: {
    184                     psU32 rows = numRows[i];
    185                     psU32 cols = numCols[i];
    186 
    187                     for (psS32 r=0;r<rows;r++) {
    188                         for (psS32 c=0;c<cols;c++) {
    189                             image->data.F64[r][c] = 2.0f*c+r;
    190                         }
    191                     }
    192                     bool errorFlag = false;
    193                     for (psS32 r=0;r<rows;r++) {
    194                         for (psS32 c=0;c<cols;c++) {
    195                             if (fabs(image->data.F64[r][c] - (2.0f*c+r)) > DBL_EPSILON) {
    196 //                                diag("Set all pixels in double image at (%d,%d)",c,r);
    197                                 errorFlag = true;
    198                             }
    199                         }
    200                     }
    201                     ok(!errorFlag, "psImageAlloc() set data correctly (F64)");
    202                 }
    203                 break;
    204             default: {
    205                     // ignore type and just use as byte bucket.
    206                     psU32 rows = numRows[i];
    207                     psU32 cols = numCols[i]*PSELEMTYPE_SIZEOF(type[t]);
    208 
    209                     for (psS32 r=0;r<rows;r++) {
    210                         for (psS32 c=0;c<cols;c++) {
    211                             image->data.U8[r][c] = (uint8_t)(r + c);
    212                         }
    213                     }
    214                     bool errorFlag = false;
    215                     for (psS32 r=0;r<rows;r++) {
    216                         for (psS32 c=0;c<cols;c++) {
    217                             if (image->data.U8[r][c] != (uint8_t)(r + c)) {
    218 //                                diag("Set all pixels in image (type=%d) at (%d,%d)", type[t],c,r);
    219                                 errorFlag = true;
    220                             }
    221                         }
    222                     }
    223                     ok(!errorFlag, "psImageAlloc() set data correctly (default)");
    224                 }
    225             }
    226             psFree(image);
    227         }
    228     }
    229 
    230     // #548: Verify no memory leaks or corruption are detected after a valid psImage structure with multiple
    231     // children is freed.
    232     image = psImageAlloc(100,100,PS_TYPE_F32);
    233     psImageSubset(image,(psRegion) {
    234                       50,0,70,20
    235                   }
    236                  );
    237     psImageSubset(image,(psRegion) {
    238                       70,20,90,40
    239                   }
    240                  );
    241 
    242     psFree(image);
    243 }
    244 
    245 
    246 
    247 void testRegion()
    248 {
    249     // Testpoint #790
    250 
    251 //    diag("testRegion");
    252 
    253     psRegion region = psRegionSet(1,2,3,4);
    254     ok (!(region.x0 != 1 || region.x1 != 2 || region.y0 != 3 || region.y1 != 4),
    255         "The region attributes are set to (%s)", psRegionToString(region));
    256 
    257     // Testpoint #791
    258 
    259     region = psRegionFromString("[1:2,3:4]");
    260     ok (!(region.x0 != 0 || region.x1 != 2 || region.y0 != 2 || region.y1 != 4),
    261         "The region attributes are set to (%s)", psRegionToString(region));
    262 
    263     region = psRegionFromString("[1:2,3:]");
    264     ok (isnan(region.x0),
    265         "psRegionFromString returned a NULL pointer given a malformed string.");
    266 }
    267 
    268 
    269 //psRegionForImage//
    270 void testRegion2()
    271 {
    272 //    diag("testRegion2");
    273 
    274     psImage *in;
    275     psRegion inReg;
    276     psRegion out;
    277     in = psImageAlloc(1, 1, PS_TYPE_S32);
    278     inReg = psRegionSet(1, 2, 1, 2);
    279     out = psRegionForImage(in,inReg);
    280     psRegion inReg2;
    281     psRegion out2;
    282     inReg2 = psRegionSet(-1, 0, -2, -1);
    283     out2 = psRegionForImage(in, inReg2);
    284 
    285     ok(!( out.x0 != 1 || out.x1 != 1 || out.y0 != 1 || out.y1 != 1 ),
    286        "Region For Image returned correct values.\n");
    287 
    288     ok(!( out2.x0 != 0 || out2.x1 != 1 || out2.y0 != 0 || out2.y1 != 0 ),
    289        "Region For Image returned correct values.\n");
    290 
    291     psFree(in);
    292 }
    293 
    294 
    295 //psRegionForSquare//
    296 void testRegion3()
    297 {
    298 //    diag("testRegion3");
    299 
    300     float X = 1;
    301     float Y = 1;
    302     float RAD = 1;
    303     psRegion out;
    304     out = psRegionForSquare(X, Y, RAD);
    305     ok (!(out.x0 != 0 || out.x1 != 3 || out.y0 != 0 || out.y1!= 3),
    306         "Region For Square returned correct values.\n");
    307 }
    308 
    309 
    310 //Initialize an image with a given value.//
    311 void testImageInit()
    312 {
    313 //    diag("testImageInit");
    314 
    315     psImage *in1 = NULL;
    316     psImage *in2 = NULL;
    317     psImage *in3 = NULL;
    318     psImage *in4 = NULL;
    319     int nRow = 1;
    320     int nCol = 1;
    321     in1 = psImageAlloc(nRow, nCol, PS_TYPE_U8);
    322     ok ( psImageInit(in1, 5 ),
    323          "ImageAlloc.  U8 Case - 1x1\n");
    324     nRow = 5;
    325     in2 = psImageAlloc(nRow, nCol, PS_TYPE_F32);
    326     ok ( psImageInit(in2, 3),
    327          "ImageAlloc.  F32 Case - 5x1\n");
    328 
    329     nCol = 5;
    330     in3 = psImageAlloc(nRow, nCol, PS_TYPE_F64);
    331     ok ( psImageInit(in3, 3.14),
    332          "ImageAlloc.  F64 Case - 5x5\n");
    333 
    334     in4 = psImageAlloc(nRow, nCol, PS_TYPE_S32);
    335     ok ( psImageInit(in4, 3),
    336          "ImageAlloc.  S32 Case - 5x5\n");
    337 
    338     psFree(in1);
    339     psFree(in2);
    340     psFree(in3);
    341     psFree(in4);
    342 }
    343 
    344 
    345 void testImageSet()
    346 {
    347 //    diag("testImageSet");
    348 
    349     psImage *image = NULL;
    350     image = psImageAlloc(5, 4, PS_TYPE_S32);
    351 
    352     //Set the position of the subimage relative to the parent.
    353     image->col0 = 10;
    354     image->row0 = 10;
    355     for (int i = 0; i < 4; i++) {
    356         for (int j = 0; j < 5; j++) {
    357             image->data.S32[i][j] = i+j;
    358         }
    359     }
    360 
    361     //Attempt to set a position in a NULL psImage*
    362     psImage *none = NULL;
    363     ok (! psImageSet(none, 1, 1, 1),
    364         "psImageSet returned non-null.\n");
    365     skip_start ( psImageSet(none, 1, 1, 1),
    366                  12, "psImageSet failed");
    367 
    368     //Attempt to set a position in a psImage* with negative numCols, numRows
    369     none = psImageAlloc(2, 2, PS_TYPE_S32);
    370     *(int*)&none->numCols = -1;
    371     ok (! psImageSet(none, 1, 1, 1),
    372         "psImageSet return false when passed an image with negative numCols");
    373     skip_start ( psImageSet(none, 1, 1, 1),
    374                  11,"psImageSet return true when passed an image with negative numCols");
    375 
    376     *(int*)&none->numCols = 2;
    377     *(int*)&none->numRows = -1;
    378     ok ( !psImageSet(none, 1, 1, 1),
    379          "psImageSet failed to return false when passed an image with negative numRows.\n");
    380     skip_start ( psImageSet(none, 1, 1, 1),
    381                  10,"psImageSet return true when passed an image with negative numRows.");
    382 
    383     //Attempt to set a position in a psImage* with negative col0, row0
    384     *(int*)&none->numRows = 2;
    385     none->row0 = -1;
    386     ok ( !psImageSet(none, 1, 1, 1),
    387          "psImageSet failed to return false when passed an image with negative col0.\n");
    388     skip_start ( psImageSet(none, 1, 1, 1),
    389                  9,"psImageSet return true when passed an image with negative col0.\n");
    390 
    391     none->row0 = 0;
    392     none->col0 = -1;
    393     ok ( !psImageSet(none, 1, 1, 1),
    394          "psImageSet failed to return false when passed an image with negative col0.\n");
    395     skip_start ( psImageSet(none, 1, 1, 1),
    396                  8,"psImageSet return true when passed an image with negative col0.\n");
    397 
    398     psFree(none);
    399 
    400     //Try to set a position inside of the subimage.
    401     ok ( psImageSet(image, 14, 12, 666),
    402          "psImageSet failed to return true when passed valid parameters.\n");
    403     skip_start ( !psImageSet(image, 14, 12, 666),
    404                  7,"psImageSet failed to return true when passed valid parameters.\n");
    405 
    406     ok (image->data.S32[2][4] == 666,
    407         "psImageSet set the data value. value=%d\n", image->data.S32[2][4]);
    408     skip_start (image->data.S32[2][4] != 666,
    409                 6,"psImageSet set the data value. value=%d\n", image->data.S32[2][4]);
    410 
    411     //Try to set a position inside of the subimage from the tail.
    412     ok ( psImageSet(image, -1, -1, 666),
    413          "psImageSet return true when passed valid parameters.\n");
    414     skip_start ( !psImageSet(image, -1, -1, 666),
    415                  5,"psImageSet failed to return true when passed valid parameters.\n");
    416 
    417     ok (image->data.S32[3][4] == 666,
    418         "psImageSet set (from the tail) the data values correctly.\n");
    419     skip_start (image->data.S32[3][4] != 666,
    420                 4,"psImageSet set (from the tail) the data values incorrectly.\n");
    421 
    422 
    423     //Try to set a position outside of the subimage but inside of the parent image.
    424     ok ( !psImageSet(image, 0, 0, 666),
    425          "psImageSet return false when passed an invalid location.\n");
    426     skip_start ( psImageSet(image, 0, 0, 666),
    427                  3,"psImageSet failed to return false when passed an invalid location");
    428 
    429     ok ( !psImageSet(image, 9, 10, 666),
    430          "psImageSet return false when passed an invalid location.\n");
    431     skip_start ( psImageSet(image, 9, 10, 666),
    432                  2,"psImageSet return false when passed an invalid location.\n");
    433 
    434     //Try to set a position outside of the subimage.
    435     ok ( !psImageSet(image, 15, 14, 666),
    436          "psImageSet return false when passed an invalid location.\n");
    437     skip_start ( psImageSet(image, 15, 14, 666),
    438                  1,"psImageSet failed to return false when passed an invalid location");
    439 
    440     //Try to set a position outside of the subimage, indexing from the tail.
    441     ok ( !psImageSet(image, -6, -1, 666),
    442          "psImageSet return false when passed an invalid location.\n");
    443 
    444     skip_end();
    445     skip_end();
    446     skip_end();
    447     skip_end();
    448     skip_end();
    449     skip_end();
    450     skip_end();
    451     skip_end();
    452     skip_end();
    453     skip_end();
    454     skip_end();
    455     skip_end();
    456 
    457     psFree(image);
    458 }
    459 
    460 
    461 void testImageGet()
    462 {
    463 //    diag("testImageGet");
    464 
    465     psImage *image = NULL;
    466     image = psImageAlloc(5, 3, PS_TYPE_S32);
    467 
    468     //Set the position of the subimage relative to the parent.
    469     image->col0 = 10;
    470     image->row0 = 10;
    471     for (int i = 0; i < 3; i++) {
    472         for (int j = 0; j < 5; j++) {
    473             image->data.S32[i][j] = i+j;
    474         }
    475     }
    476 
    477     //Attempt to get a position in a NULL psImage*
    478     psImage *none = NULL;
    479     ok ( isnan( psImageGet(none, 1, 1) ),
    480          "psImageGet return false when passed a NULL image.\n");
    481     skip_start ( !isnan( psImageGet(none, 1, 1) ),
    482                  10,"psImageGet failed to return false when passed a NULL image.\n");
    483 
    484     //Attempt to get a position in a psImage* with negative numCols, numRows
    485     none = psImageAlloc(2, 2, PS_TYPE_S32);
    486     *(int*)&none->numCols = -1;
    487     ok ( isnan( psImageGet(none, 1, 1) ),
    488          "psImageGet return false when passed an image with negative numCols");
    489     skip_start ( !isnan( psImageGet(none, 1, 1) ),
    490                  9,"psImageGet return true when passed an image with negative numCols");
    491 
    492     *(int*)&none->numCols = 2;
    493     *(int*)&none->numRows = -1;
    494     ok ( isnan( psImageGet(none, 1, 1) ),
    495          "psImageGet return false when passed an image with negative numRows");
    496     skip_start ( !isnan( psImageGet(none, 1, 1) ),
    497                  8,"psImageGet failed to return false when passed an image with negative numRows.\n");
    498 
    499     //Attempt to get a position in a psImage* with negative col0, row0
    500     *(int*)&none->numRows = 2;
    501     none->row0 = -1;
    502     ok ( isnan( psImageGet(none, 1, 1) ),
    503          "psImageGet return false when passed an image with negative col0.\n");
    504     skip_start ( !isnan( psImageGet(none, 1, 1) ),
    505                  7,"psImageGet return false when passed an image with negative col0.\n");
    506 
    507     none->row0 = 0;
    508     none->col0 = -1;
    509     ok ( isnan( psImageGet(none, 1, 1) ),
    510          "psImageGet return false when passed an image with negative col0.\n");
    511     skip_start ( !isnan( psImageGet(none, 1, 1) ),
    512                  6,"psImageGet failed to return false when passed an image with negative col0.\n");
    513 
    514     psFree(none);
    515 
    516 
    517     //Try to get a position inside of the subimage.
    518     ok ( psImageGet(image, 14, 12) == 6,
    519          "psImageGet return the correct value.\n");
    520     skip_start ( psImageGet(image, 14, 12) != 6,
    521                  5,"psImageGet failed to return the correct value.\n");
    522 
    523     //Try to get a position inside of the subimage from the tail.
    524     ok ( psImageGet(image, -1, -1) == 6,
    525          "psImageGet return the correct value.\n");
    526     skip_start ( psImageGet(image, -1, -1) == 6,
    527                  4, "psImageGet failed to return the correct value.\n");
    528 
    529     //Try to get a position outside of the subimage but inside of the parent image.
    530     ok ( isnan( psImageGet(image, 1, 1) ),
    531          "psImageGet return NAN when passed an invalid location.\n");
    532     skip_start ( !isnan( psImageGet(image, 1, 1) ),
    533                  3, "psImageGet didn't return NAN when passed an invalid location.\n");
    534 
    535     ok ( isnan( psImageGet(image, 9, 10) ),
    536          "psImageGet return NAN when passed an invalid location.\n");
    537     skip_start ( ! isnan( psImageGet(image, 9, 10) ),
    538                  2,"psImageGet failed to return NAN when passed an invalid location.\n");
    539 
    540     //Try to set a position outside of the subimage.
    541     ok ( isnan( psImageGet(image, 15, 14) ),
    542          "psImageGet return NAN when passed an invalid location.\n");
    543     skip_start ( !isnan( psImageGet(image, 15, 14) ),
    544                  1, "psImageGet didn't return NAN when passed an invalid location.\n");
    545 
    546     //Try to set a position outside of the subimage, indexing from the tail.
    547     ok ( isnan( psImageGet(image, -6, -1) ),
    548          "psImageGet failed to return NAN when passed an invalid location.\n");
    549 
    550     skip_end();
    551     skip_end();
    552     skip_end();
    553     skip_end();
    554     skip_end();
    555     skip_end();
    556     skip_end();
    557     skip_end();
    558     skip_end();
    559     skip_end();
    560 
    561 
    562     psFree(image);
    563 }

  • trunk/psLib/test/mathtypes/tap_psImageInterpolate.c

    r12741 r12781  
    88int main (void)
    99{
    10     plan_tests(88);
    11 
    12 //    diag("psImageInterpolate() tests");
     10    psLogSetFormat("HLNM");
     11    psLogSetLevel(PS_LOG_INFO);
     12    plan_tests(47);
    1313
    1414    // very simple tests: no mask, bilinear mode, xramp image only
    1515    {
    1616        psMemId id = psMemGetId();
    17 
    18 //        diag ("interpolate a delta function");
    19 
    20         // generate simple image (x ramp)
    21         psImage *image = psImageAlloc(32, 32, PS_TYPE_F64);
    22         ok(image != NULL, "psImage successfully allocated");
    23         skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
    24 
    25         psImageInit(image, 0.0);
    26         image->data.F64[10][10] = 1;
    27 
    28         // center of pixels is 0.5, 0.5
    29         double value;
    30 
    31         psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BILINEAR,
    32                                                                            image, NULL, NULL, 0, 0.0, 0.0,
    33                                                                            0, 0, 0.0);
    34         ok(interp, "Interpolation options set");
    35 
    36         ok(psImageInterpolate(&value, NULL, NULL, 10.5, 10.5, interp), "Interpolation");
    37         is_double (value, 1.0, "pixel center value - %f", value);
    38 
    39 //        diag ("why do I need to have tolerances of 4epsilon or so??");
    40 
    41         ok(psImageInterpolate(&value, NULL, NULL, 10.9, 10.5, interp), "Interpolation");
    42         is_double_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value);
    43 
    44         ok(psImageInterpolate(&value, NULL, NULL, 10.5, 10.9, interp), "Interpolation");
    45         is_double_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value);
    46 
    47         ok(psImageInterpolate(&value, NULL, NULL, 10.1, 10.5, interp), "Interpolation");
    48         is_double_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value);
    49 
    50         psFree(interp);
    51 
    52         skip_end();
    53 
    54         psFree(image);
    55         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    56     }
     17        // generate simple image (x ramp)
     18        psImage *image = psImageAlloc(32, 32, PS_TYPE_F32);
     19        ok(image != NULL, "psImage successfully allocated");
     20        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
     21
     22        image->data.F32[10][10] = 1;
     23
     24        // center of pixels is 0.5, 0.5
     25        float value;
     26
     27        value = psImagePixelInterpolate (image, 10.5, 10.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     28        is_float (value, 1.0, "pixel center value - %f", value);
     29
     30        value = psImagePixelInterpolate (image, 10.9, 10.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     31        is_float_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value);
     32
     33        value = psImagePixelInterpolate (image, 10.5, 10.9, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     34        is_float_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value);
     35
     36        value = psImagePixelInterpolate (image, 10.1, 10.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     37        is_float_tol (value, 0.6, 4.0*FLT_EPSILON, "pixel value - %.20f", value);
     38
     39        skip_end();
     40
     41        psFree(image);
     42        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     43    }
     44
    5745
    5846    // very simple tests: no mask, bilinear mode, xramp image only
    5947    {
    6048        psMemId id = psMemGetId();
    61 
    62 //        diag ("interpolate an x-ramp");
    63 
    64         // generate simple image (x ramp)
    65         psImage *image = psImageAlloc(32, 32, PS_TYPE_F64);
    66         ok(image != NULL, "psImage successfully allocated");
    67         skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
    68 
    69         for (int j = 0; j < image->numRows; j++) {
    70             for (int i = 0; i < image->numCols; i++) {
    71                 image->data.F64[j][i] = i + 0.5;
    72             }
    73         }
    74 
    75         // center of pixels is 0.5, 0.5
    76         double value;
    77 
    78         psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BILINEAR,
    79                                                                            image, NULL, NULL, 0, 0.0, 0.0,
    80                                                                            0, 0, 0.0);
    81         ok(interp, "Interpolation options set");
    82 
    83         ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation");
    84         is_double_tol (value, 2.5, 5.0e-8, "pixel center value - %f", value);
    85 
    86         ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.5, interp), "Interpolation");
    87         is_double_tol (value, 2.2, 5.0e-8, "coord: 2.2, 2.5, value: %f", value);
    88 
    89         ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.5, interp), "Interpolation");
    90         is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
    91 
    92         ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.2, interp), "Interpolation");
    93         is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
    94 
    95         ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation");
    96         is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
    97 
    98         ok(psImageInterpolate(&value, NULL, NULL, 0.8, 2.8, interp), "Interpolation");
    99         is_double_tol (value, 0.8, 5.0e-8, "coord: 0.8, value: %f", value);
     49        // generate simple image (x ramp)
     50        psImage *image = psImageAlloc(32, 32, PS_TYPE_F32);
     51        ok(image != NULL, "psImage successfully allocated");
     52        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
     53
     54        for (int j = 0; j < image->numRows; j++)
     55        {
     56            for (int i = 0; i < image->numCols; i++) {
     57                image->data.F32[j][i] = i + 0.5;
     58            }
     59        }
     60
     61        // center of pixels is 0.5, 0.5
     62        float value;
     63
     64        value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     65        is_float (value, 2.5, "pixel center value - %f", value);
     66
     67        value = psImagePixelInterpolate (image, 2.2, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     68        is_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value);
     69
     70        value = psImagePixelInterpolate (image, 2.8, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     71        is_float (value, 2.8, "coord: 2.8, value: %f", value);
     72
     73        value = psImagePixelInterpolate (image, 2.8, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     74        is_float (value, 2.8, "coord: 2.8, value: %f", value);
     75
     76        value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     77        is_float (value, 2.8, "coord: 2.8, value: %f", value);
     78
     79        value = psImagePixelInterpolate (image, 0.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     80        is_float (value, 0.8, "coord: 0.8, value: %f", value);
    10081
    10182        // no extrapolation
    102         ok(psImageInterpolate(&value, NULL, NULL, 0.3, 2.8, interp), "Interpolation");
    103         is_double (value, 0.0, "coord: 0.3, value: %f", value);
    104 
    105         ok(psImageInterpolate(&value, NULL, NULL, -0.2, 2.8, interp), "Interpolation");
    106         is_double (value, 0.0, "coord: -0.2, value: %f", value);
    107 
    108         psFree(interp);
    109 
    110         skip_end();
    111 
    112         psFree(image);
    113         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    114     }
     83        value = psImagePixelInterpolate (image, 0.3, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     84        is_float (value, 0.5, "coord: 0.3, value: %f", value);
     85
     86        value = psImagePixelInterpolate (image, -0.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     87        is_float (value, 0.5, "coord: -0.2, value: %f", value);
     88
     89        skip_end();
     90
     91        psFree(image);
     92        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     93    }
     94
    11595
    11696    // very simple tests: no mask, bilinear mode, yramp image only
    11797    {
    11898        psMemId id = psMemGetId();
    119 
    120 //        diag ("interpolate a y-ramp: ");
    121 
    12299        // generate simple image (y ramp)
    123         psImage *image = psImageAlloc(32, 32, PS_TYPE_F64);
    124         ok(image != NULL, "psImage successfully allocated");
    125         skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
    126 
    127         for (int j = 0; j < image->numRows; j++)
    128         {
    129             for (int i = 0; i < image->numCols; i++) {
    130                 image->data.F64[j][i] = j + 0.5;
    131             }
    132         }
    133 
    134         // center of pixels is 0.5, 0.5
    135         double value;
    136 
    137         psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BILINEAR,
    138                                                                            image, NULL, NULL, 0, 0.0, 0.0,
    139                                                                            0, 0, 0.0);
    140         ok(interp, "Interpolation options set");
    141 
    142         ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation");
    143         is_double_tol (value, 2.5, 5.0e-8, "pixel center value - %f", value);
    144 
    145         ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.2, interp), "Interpolation");
    146         is_double_tol (value, 2.2, 5.0e-8, "coord: 2.2, 2.2, value: %f", value);
    147 
    148         ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.8, interp), "Interpolation");
    149         is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
    150 
    151         ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.8, interp), "Interpolation");
    152         is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
    153 
    154         ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation");
    155         is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
    156 
    157         psFree(interp);
    158 
    159         skip_end();
    160 
    161         psFree(image);
    162         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    163     }
     100        psImage *image = psImageAlloc(32, 32, PS_TYPE_F32);
     101        ok(image != NULL, "psImage successfully allocated");
     102        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
     103
     104        for (int j = 0; j < image->numRows; j++)
     105        {
     106            for (int i = 0; i < image->numCols; i++) {
     107                image->data.F32[j][i] = j + 0.5;
     108            }
     109        }
     110
     111        // center of pixels is 0.5, 0.5
     112        float value;
     113
     114        value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     115        is_float (value, 2.5, "pixel center value - %f", value);
     116
     117        value = psImagePixelInterpolate (image, 2.2, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     118        is_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value);
     119
     120        value = psImagePixelInterpolate (image, 2.5, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     121        is_float (value, 2.8, "coord: 2.8, value: %f", value);
     122
     123        value = psImagePixelInterpolate (image, 2.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     124        is_float (value, 2.8, "coord: 2.8, value: %f", value);
     125
     126        value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BILINEAR);
     127        is_float (value, 2.8, "coord: 2.8, value: %f", value);
     128
     129        skip_end();
     130
     131        psFree(image);
     132        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     133    }
     134
    164135
    165136    // very simple tests: no mask, bicube mode, xramp image only
    166137    {
    167138        psMemId id = psMemGetId();
    168 
    169 //        diag ("interpolate an x-ramp (bicube)");
    170 
    171         // generate simple image (x ramp)
    172         psImage *image = psImageAlloc(32, 32, PS_TYPE_F64);
    173         ok(image != NULL, "psImage successfully allocated");
    174         skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
    175 
    176         for (int j = 0; j < image->numRows; j++)
    177         {
    178             for (int i = 0; i < image->numCols; i++) {
    179                 image->data.F64[j][i] = i + 0.5;
    180             }
    181         }
    182 
    183         // center of pixels is 0.5, 0.5
    184         double value;
    185 
    186         psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BICUBE,
    187                                                                            image, NULL, NULL, 0, 0.0, 0.0,
    188                                                                            0, 0, 0.0);
    189         ok(interp, "Interpolation options set");
    190 
    191         ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation");
    192         is_double_tol (value, 2.5, 5.0e-8, "coord; 2.5, 2.5, value - %f", value);
    193 
    194         ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.5, interp), "Interpolation");
    195         is_double_tol (value, 2.2, 5.0e-8, "coord: 2.2, 2.5, value: %f", value);
    196 
    197         ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.5, interp), "Interpolation");
    198         is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, 2.5, value: %f", value);
    199 
    200         ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.2, interp), "Interpolation");
    201         is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, 2.2, value: %f", value);
    202 
    203         ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation");
    204         is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, 2.8, value: %f", value);
    205 
    206 //        diag ("coords outside of nominal range (1 < x < Nx - 2) return 'uncover'");
     139        // generate simple image (x ramp)
     140        psImage *image = psImageAlloc(32, 32, PS_TYPE_F32);
     141        ok(image != NULL, "psImage successfully allocated");
     142        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
     143
     144        for (int j = 0; j < image->numRows; j++)
     145        {
     146            for (int i = 0; i < image->numCols; i++) {
     147                image->data.F32[j][i] = i + 0.5;
     148            }
     149        }
     150
     151        // center of pixels is 0.5, 0.5
     152        float value;
     153
     154        value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     155        is_float (value, 2.5, "coord; 2.5, 2.5, value - %f", value);
     156
     157        value = psImagePixelInterpolate (image, 2.2, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     158        is_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value);
     159
     160        value = psImagePixelInterpolate (image, 2.8, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     161        is_float (value, 2.8, "coord: 2.8, 2.5, value: %f", value);
     162
     163        value = psImagePixelInterpolate (image, 2.8, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     164        is_float (value, 2.8, "coord: 2.8, 2.2, value: %f", value);
     165
     166        value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     167        is_float (value, 2.8, "coord: 2.8, 2.8, value: %f", value);
    207168
    208169        // no extrapolation: these return the 'uncover' value
    209         ok(psImageInterpolate(&value, NULL, NULL, 0.8, 2.8, interp), "Interpolation");
    210         is_double (value, 0.0, "coord: 0.8, 2.8, value: %f", value);
    211 
    212         ok(psImageInterpolate(&value, NULL, NULL, 0.3, 2.8, interp), "Interpolation");
    213         is_double (value, 0.0, "coord: 0.3, 2.8, value: %f", value);
    214 
    215         ok(psImageInterpolate(&value, NULL, NULL, -0.2, 2.8, interp), "Interpolation");
    216         is_double (value, 0.0, "coord: -0.2, 2.8, value: %f", value);
    217 
    218         psFree(interp);
    219 
    220         skip_end();
    221 
    222         psFree(image);
    223         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    224     }
     170        value = psImagePixelInterpolate (image, 0.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     171        is_float (value, 0.0, "coord: 0.8, 2.8, value: %f", value);
     172
     173        value = psImagePixelInterpolate (image, 0.3, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     174        is_float (value, 0.0, "coord: 0.3, 2.8, value: %f", value);
     175
     176        value = psImagePixelInterpolate (image, -0.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     177        is_float (value, 0.0, "coord: -0.2, 2.8, value: %f", value);
     178
     179        skip_end();
     180
     181        psFree(image);
     182        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     183    }
     184
    225185
    226186    // very simple tests: no mask, bilinear mode, yramp image only
    227187    {
    228188        psMemId id = psMemGetId();
    229 
    230 //        diag ("interpolate a y-ramp (bicube)");
    231 
    232189        // generate simple image (y ramp)
    233         psImage *image = psImageAlloc(32, 32, PS_TYPE_F64);
    234         ok(image != NULL, "psImage successfully allocated");
    235         skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
    236 
    237         for (int j = 0; j < image->numRows; j++)
    238         {
    239             for (int i = 0; i < image->numCols; i++) {
    240                 image->data.F64[j][i] = j + 0.5;
    241             }
    242         }
    243 
    244         // center of pixels is 0.5, 0.5
    245         double value;
    246 
    247         psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BICUBE,
    248                                                                            image, NULL, NULL, 0, 0.0, 0.0,
    249                                                                            0, 0, 0.0);
    250         ok(interp, "Interpolation options set");
    251 
    252         ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation");
    253         is_double_tol (value, 2.5, 5.0e-8, "pixel center value - %f", value);
    254 
    255         ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.2, interp), "Interpolation");
    256         is_double_tol (value, 2.2, 5.0e-8, "coord: 2.2, 2.5, value: %f", value);
    257 
    258         ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.8, interp), "Interpolation");
    259         is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
    260 
    261         ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.8, interp), "Interpolation");
    262         is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
    263 
    264         ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation");
    265         is_double_tol (value, 2.8, 5.0e-8, "coord: 2.8, value: %f", value);
    266 
    267         psFree(interp);
    268 
    269         skip_end();
    270 
    271         psFree(image);
    272         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    273     }
     190        psImage *image = psImageAlloc(32, 32, PS_TYPE_F32);
     191        ok(image != NULL, "psImage successfully allocated");
     192        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
     193
     194        for (int j = 0; j < image->numRows; j++)
     195        {
     196            for (int i = 0; i < image->numCols; i++) {
     197                image->data.F32[j][i] = j + 0.5;
     198            }
     199        }
     200
     201        // center of pixels is 0.5, 0.5
     202        float value;
     203
     204        value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     205        is_float (value, 2.5, "pixel center value - %f", value);
     206
     207        value = psImagePixelInterpolate (image, 2.2, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     208        is_float (value, 2.2, "coord: 2.2, 2.5, value: %f", value);
     209
     210        value = psImagePixelInterpolate (image, 2.5, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     211        is_float (value, 2.8, "coord: 2.8, value: %f", value);
     212
     213        value = psImagePixelInterpolate (image, 2.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     214        is_float (value, 2.8, "coord: 2.8, value: %f", value);
     215
     216        value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     217        is_float (value, 2.8, "coord: 2.8, value: %f", value);
     218
     219        skip_end();
     220
     221        psFree(image);
     222        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     223    }
     224
    274225
    275226    // very simple tests: no mask, bilinear mode, x,y 2nd order shape
    276227    {
    277228        psMemId id = psMemGetId();
    278 
    279 //        diag ("interpolate a quadratic shape (bicube)");
    280 
    281         // generate simple image (x ramp)
    282         psImage *image = psImageAlloc(32, 32, PS_TYPE_F64);
    283         ok(image != NULL, "psImage successfully allocated");
    284         skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
    285 
    286         for (int j = 0; j < image->numRows; j++)
    287         {
    288             for (int i = 0; i < image->numCols; i++) {
    289                 image->data.F64[j][i] = 0.25*PS_SQR(i + 0.5) + j + 0.5;
    290             }
    291         }
    292 
    293         // center of pixels is 0.5, 0.5
    294         double value;
    295 
    296         psImageInterpolateOptions *interp = psImageInterpolateOptionsAlloc(PS_INTERPOLATE_BICUBE,
    297                                                                            image, NULL, NULL, 0, 0.0, 0.0,
    298                                                                            0, 0, 0.0);
    299         ok(interp, "Interpolation options set");
    300 
    301         ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.5, interp), "Interpolation");
    302         is_double_tol (value, 4.0625, 2.0e-7, "pixel center value - %f", value);
    303 
    304         ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.2, interp), "Interpolation");
    305         is_double_tol (value, 3.41, 2.0e-7, "coord: 2.2, 2.5, value: %f", value);
    306 
    307         ok(psImageInterpolate(&value, NULL, NULL, 2.5, 2.8, interp), "Interpolation");
    308         is_double_tol (value, 4.3625, 2.0e-7, "coord: 2.5, 2.8, value: %f", value);
    309 
    310         ok(psImageInterpolate(&value, NULL, NULL, 2.2, 2.8, interp), "Interpolation");
    311         is_double_tol (value, 4.01, 2.0e-7, "coord: 2.2, 2.8, value: %f", value);
    312 
    313         ok(psImageInterpolate(&value, NULL, NULL, 2.8, 2.8, interp), "Interpolation");
    314         is_double_tol (value, 4.76, 2.0e-7, "coord: 2.8, 2.8, value: %f", value);
    315 
    316         psFree(interp);
    317 
    318         skip_end();
    319 
    320         psFree(image);
    321         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    322     }
    323 
    324     return exit_status();
     229        // generate simple image (x ramp)
     230        psImage *image = psImageAlloc(32, 32, PS_TYPE_F32);
     231        ok(image != NULL, "psImage successfully allocated");
     232        skip_start(image == NULL, 5, "Skipping tests because psImageAlloc() failed");
     233
     234        for (int j = 0; j < image->numRows; j++)
     235        {
     236            for (int i = 0; i < image->numCols; i++) {
     237                image->data.F32[j][i] = 0.25*PS_SQR(i + 0.5) + j + 0.5;
     238            }
     239        }
     240
     241        // center of pixels is 0.5, 0.5
     242        float value;
     243
     244        value = psImagePixelInterpolate (image, 2.5, 2.5, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     245        is_float (value, 4.0625, "pixel center value - %f", value);
     246
     247        value = psImagePixelInterpolate (image, 2.2, 2.2, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     248        is_float (value, 3.41, "coord: 2.2, 2.5, value: %f", value);
     249
     250        value = psImagePixelInterpolate (image, 2.5, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     251        is_float (value, 4.3625002, "coord: 2.5, 2.8, value: %f", value);
     252
     253        value = psImagePixelInterpolate (image, 2.2, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     254        is_float (value, 4.010000229, "coord: 2.2, 2.8, value: %f", value);
     255
     256        value = psImagePixelInterpolate (image, 2.8, 2.8, NULL, 0, 0.0, PS_INTERPOLATE_BICUBE);
     257        is_float (value, 4.75999975, "coord: 2.8, 2.8, value: %f", value);
     258
     259        skip_end();
     260
     261        psFree(image);
     262        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     263    }
    325264}

  • trunk/psLib/test/mathtypes/tap_psScalar.c

    r12513 r12781  
    55 *  @author Eric Van Alst, MHPCC
    66 *
    7  *  @version $Revision: 1.4 $
     7 *  @version $Revision: 1.5 $
    88 *           $Name: not supported by cvs2svn $
    9  *  @date $Date: 2007-03-20 03:57:25 $
     9 *  @date $Date: 2007-04-10 21:09:30 $
    1010 *
    1111 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1212 */
    13 
    1413#include <pslib.h>
    15 
    1614#include "tap.h"
    1715#include "pstap.h"
    … …  
    4947int main(void)
    5048{
    51     plan_tests(43);
     49    psLogSetFormat("HLNM");
     50    psLogSetLevel(PS_LOG_INFO);
     51    plan_tests(47);
    5252
    53     void testScalarAlloc();
    54     testScalarAlloc();
    55     void testBadScalarAlloc();
    56     testBadScalarAlloc();
    5753
    58     void testScalarCopy();
    59     testScalarCopy();
    60     void testBadScalarCopy();
    61     testBadScalarCopy();
    62 }
     54    // Verify return is null for invalid scalar type
     55    {
     56        psMemId id = psMemGetId();
     57        psScalar* scalar = psScalarAlloc(true,PS_TYPE_BOOL);
     58        ok(scalar == NULL, "psScalarAlloc returns null for invalid type");
     59        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     60    }
    6361
    64 void testScalarAlloc(void)
    65 {
    66 //    diag("psTestScalarAlloc");
    6762
    6863    //Verify the proper allocation/deallocation of scalar objects of valid types
    69     tstScalarAllocByType(S8,10);
    70     tstScalarAllocByType(U8,12);
    71     tstScalarAllocByType(S16,14);
    72     tstScalarAllocByType(U16,16);
    73     tstScalarAllocByType(S32,18);
    74     tstScalarAllocByType(U32,20);
    75     tstScalarAllocByType(S64,22);
    76     tstScalarAllocByType(U64,24);
    77     tstScalarAllocByType(F32,26);
    78     tstScalarAllocByType(F64,28);
    79 }
     64    {
     65        psMemId id = psMemGetId();
     66        tstScalarAllocByType(S8,10);
     67        tstScalarAllocByType(U8,12);
     68        tstScalarAllocByType(S16,14);
     69        tstScalarAllocByType(U16,16);
     70        tstScalarAllocByType(S32,18);
     71        tstScalarAllocByType(U32,20);
     72        tstScalarAllocByType(S64,22);
     73        tstScalarAllocByType(U64,24);
     74        tstScalarAllocByType(F32,26);
     75        tstScalarAllocByType(F64,28);
     76        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     77    }
    8078
    8179
    82 void testBadScalarAlloc(void)
    83 {
    84 //    diag("psTestBadScalarAlloc");
    85 
    86     // Verify return is null for invalid scalar type
    87     psScalar* scalar = psScalarAlloc(true,PS_TYPE_BOOL);
    88     ok(scalar == NULL, "psScalarAlloc returns null for invalid type");
    89 }
     80    // Verify the return is null for invalid scalar type in the original
     81    {
     82        psMemId id = psMemGetId();
     83        psScalar* scalarOrig = psScalarAlloc(0,PS_TYPE_S8);
     84        scalarOrig->type.type = PS_TYPE_BOOL;
     85        psScalar* scalarCopy = psScalarCopy(scalarOrig);
     86        ok(scalarCopy == NULL, "psScalarCopy returns NULL for invalid type");
     87        scalarCopy = psScalarCopy(NULL);
     88        ok(scalarCopy == NULL, "psScalarCopy returns NULL for NULL argument");
     89        psFree(scalarOrig);
     90        psFree(scalarCopy);
     91        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     92    }
    9093
    9194
    92 void testScalarCopy(void)
    93 {
    94 //    diag("psTestScalarCopy");
    95 
    9695    // Verify the proper copying of scalar objects for all valid types
    97     tstScalarCopyByType(S8,100);
    98     tstScalarCopyByType(U8,110);
    99     tstScalarCopyByType(S16,120);
    100     tstScalarCopyByType(U16,130);
    101     tstScalarCopyByType(S32,140);
    102     tstScalarCopyByType(U32,150);
    103     tstScalarCopyByType(S64,160);
    104     tstScalarCopyByType(U64,170);
    105     tstScalarCopyByType(F32,180);
    106     tstScalarCopyByType(F64,190);
     96    {
     97        psMemId id = psMemGetId();
     98        tstScalarCopyByType(S8,100);
     99        tstScalarCopyByType(U8,110);
     100        tstScalarCopyByType(S16,120);
     101        tstScalarCopyByType(U16,130);
     102        tstScalarCopyByType(S32,140);
     103        tstScalarCopyByType(U32,150);
     104        tstScalarCopyByType(S64,160);
     105        tstScalarCopyByType(U64,170);
     106        tstScalarCopyByType(F32,180);
     107        tstScalarCopyByType(F64,190);
     108        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     109    }
    107110}
    108 
    109 
    110 void testBadScalarCopy(void)
    111 {
    112 //    diag("psTestBadScalarCopy");
    113 
    114     // Verify the return is null for invalid scalar type in the original
    115     psScalar* scalarOrig = psScalarAlloc(0,PS_TYPE_S8);
    116     scalarOrig->type.type = PS_TYPE_BOOL;
    117     psScalar* scalarCopy = psScalarCopy(scalarOrig);
    118     ok(scalarCopy == NULL, "psScalarCopy returns NULL for invalid type");
    119 
    120     scalarCopy = psScalarCopy(NULL);
    121     ok(scalarCopy == NULL, "psScalarCopy returns NULL for NULL argument");
    122 }

  • trunk/psLib/test/mathtypes/tap_psVector.c

    r12513 r12781  
    88int main (void)
    99{
    10     plan_tests(209);
    11 
    12 //    diag("psVectorAlloc() tests");
     10    plan_tests(285);
     11
    1312
    1413    {
    1514        psMemId id = psMemGetId();
    1615        psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
    17 
    1816        ok(psVec != NULL, "psVector successfully allocated");
    1917        skip_start(psVec == NULL, 4, "Skipping 4 tests because psVectorAlloc() failed");
    … …  
    2321        ok(psVec->type.dimen == PS_DIMEN_VECTOR, "Vector dimen = %d", psVec->type.dimen);
    2422        skip_end();
    25 
    2623        psFree(psVec);
    2724        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    2825    }
    2926
    30     {
     27
     28    {
     29        psMemId id = psMemGetId();
    3130        psVector* vecZero = psVectorAlloc(0, PS_TYPE_S32);
    32 
    3331        ok(vecZero != NULL, "zero-length vector allocated");
    3432        skip_start(vecZero == NULL, 2, "Skipping 2 tests because psVectorAlloc() failed");
    … …  
    3634        ok(vecZero->n == 0, "Vector population = %ld", vecZero->n);
    3735        skip_end();
    38 
    3936        psFree(vecZero);
    40     }
    41 
    42     {
     37        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     38    }
     39
     40
     41    {
     42        psMemId id = psMemGetId();
    4343        psVector* vecBogus = psVectorAlloc(10, 0);
    44 
    4544        ok(vecBogus == NULL, "psVectorAlloc() doesn't not accept bogus type");
    4645        psErr *err = psErrorLast();
    47 
    4846        skip_start(err == NULL, 2, "Skipping 2 tests because psVectorAlloc() didn't fail as expect");
    4947        ok(strstr(err->name, "vectorAlloc"), "alloc failure - got error name %s", err->name);
    5048        ok(err->code == PS_ERR_BAD_PARAMETER_TYPE, "alloc failure - got error code %d", err->code);
    5149        skip_end();
    52 
    5350        psFree(vecBogus);
    54     }
    55 
    56 
    57 //    diag("psVectorRealloc() tests");
    58 
    59     {
    60         // create new psVector
     51        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     52    }
     53
     54
     55    // psVectorRealloc() tests
     56    {
     57        psMemId id = psMemGetId();
    6158        psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
    6259        ok(psVec->n == 5, "Vector population = %ld", psVec->n);
    63 //        for(psS32 i = 0; i < 5; i++) {
    64 //            printf ("Elem %d = %d\n", i, psVec->data.S32[i]);
    65 //        }
    6660
    6761        // generate first part of vector
    … …  
    9387        }
    9488        skip_end();
    95 
    9689        psFree(psVec);
    97     }
    98 
    99     {
    100         // Test D - Reallocate S32 vector smaller
     90        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     91    }
     92
     93
     94    // Test D - Reallocate S32 vector smaller
     95    {
     96        psMemId id = psMemGetId();
    10197        psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
    102         psVec->n = 5;
    103 
    10498        // generate test data values
    10599        for(psS32 i = 0; i < 5; i++) {
    … …  
    107101            psVec->n++;
    108102        }
    109 
    110103        psVec = psVectorRealloc(psVec, 3);
    111 
    112104        ok(psVec != NULL, "test vector reallocated to smaller size");
    113105        skip_start(psVec == NULL, 5, "Skipping 6 tests because psVectorRealloc() failed");
    … …  
    120112        }
    121113        skip_end();
    122     }
    123 
    124     {
    125         // reallocate to 0 length
     114        psFree(psVec);
     115        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     116    }
     117
     118
     119    // reallocate to 0 length
     120    {
     121        psMemId id = psMemGetId();
    126122        psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
    127123        psVec = psVectorRealloc(psVec,0);
    … …  
    136132        // XXX not really a test...
    137133        psFree(psVec);
    138     }
    139 
    140     {
    141         psVector *vecBogus = psVectorAlloc(5, PS_TYPE_S32);
    142         vecBogus = psVectorRealloc(NULL, 6);
    143 
     134        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     135    }
     136
     137
     138    {
     139        psMemId id = psMemGetId();
     140        psVector *vecBogus = psVectorRealloc(NULL, 6);
    144141        ok(vecBogus == NULL, "psVectorRealloc() doesn't not accept bogus type");
    145142        psErr *err = psErrorLast();
    146 
    147143        skip_start(err == NULL, 2, "Skipping 2 tests because psVectorRealloc() didn't fail as expect");
    148144        ok(strstr(err->name, "psVectorRealloc"), "alloc failure - got error name %s", err->name);
    149145        ok(err->code == PS_ERR_BAD_PARAMETER_NULL, "alloc failure - got error code %d", err->code);
    150146        skip_end();
    151 
    152147        psFree(vecBogus);
    153     }
    154 
    155 //    diag("psVectorExtend() tests");
    156     {
    157         // create new psVector
     148        psFree(err);
     149        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     150    }
     151
     152
     153    // psVectorExtend() tests
     154    {
     155        psMemId id = psMemGetId();
    158156        psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
    159157        psVec = psVectorExtend(psVec, 0, 2);
    … …  
    164162        ok(psVec->n == 7, "Vector population = %ld", psVec->n);
    165163        skip_end();
    166 
    167164        psFree(psVec);
    168     }
    169 
    170     {
     165        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     166    }
     167
     168
     169    {
     170        psMemId id = psMemGetId();
    171171        psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
    172172        psVec = psVectorExtend(psVec, 0, 2);
    173173        psVec = psVectorExtend(psVec, 0, 2);
    174 
    175174        ok(psVec != NULL, "test vector extended");
    176175        skip_start(psVec == NULL, 2, "Skipping 2 tests because psVectorExtend() failed");
    … …  
    179178        ok(psVec->n == 9,"Vector population = %ld", psVec->n);
    180179        skip_end();
    181 
    182180        psFree(psVec);
    183     }
    184 
    185     {
     181        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     182    }
     183
     184
     185    {
     186        psMemId id = psMemGetId();
    186187        psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
    187188        psVec = psVectorExtend(psVec, 0, 2);
    188189        psVec = psVectorExtend(psVec, 0, 2);
    189190        psVec = psVectorExtend(psVec, 0, -2);
    190 
    191191        ok(psVec != NULL, "test vector extended");
    192192        skip_start(psVec == NULL, 2, "Skipping 2 tests because psVectorExtend() failed");
    … …  
    195195        ok(psVec->n == 7, "Vector population = %ld", psVec->n);
    196196        skip_end();
    197 
    198197        psFree(psVec);
    199     }
    200 
    201     {
     198        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     199    }
     200
     201
     202    {
     203        psMemId id = psMemGetId();
    202204        psVector *psVec = psVectorAlloc(5, PS_TYPE_S32);
    203205        psVec = psVectorExtend(psVec, 0, 2);
    … …  
    205207        psVec = psVectorExtend(psVec, 0, -2);
    206208        psVec = psVectorExtend(psVec, 0, -20);
    207 
    208209        ok(psVec != NULL, "test vector extended");
    209210        skip_start(psVec == NULL, 2, "Skipping 2 tests because psVectorExtend() failed");
    … …  
    212213        ok(psVec->n == 0, "Vector population = %ld", psVec->n);
    213214        skip_end();
    214 
    215215        psFree(psVec);
    216     }
    217 
    218 
    219 //    diag("psVectorInit() tests");
    220 
    221     {
     216        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     217    }
     218
     219
     220    // psVectorInit() tests
     221    {
     222        psMemId id = psMemGetId();
    222223        psVector *vec = psVectorAlloc(1, PS_TYPE_U8);
    223224        ok(psVectorInit(vec, 1 ), "U8 Case");
    224225        psFree(vec);
    225     }
    226 
    227     {
     226        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     227    }
     228
     229
     230    {
     231        psMemId id = psMemGetId();
    228232        psVector *vec = psVectorAlloc(1, PS_TYPE_U16);
    229233        ok(!psVectorInit(vec, PS_MAX_U64), "VectorInit failed.  U16 Case");
    230234        psFree(vec);
    231     }
    232 
    233     {
     235        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     236    }
     237
     238
     239    {
     240        psMemId id = psMemGetId();
    234241        psVector *vec = psVectorAlloc(1, PS_TYPE_U32);
    235242        ok(psVectorInit(vec, 10), "U32 Case");
    236243        psFree(vec);
    237     }
    238 
    239     {
     244        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     245    }
     246
     247
     248    {
     249        psMemId id = psMemGetId();
    240250        psVector *vec = psVectorAlloc(1, PS_TYPE_U64);
    241251        ok(psVectorInit(vec, PS_MIN_U64), "U64 Case");
    242252        psFree(vec);
    243     }
    244 
    245     {
     253        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     254    }
     255
     256
     257    {
     258        psMemId id = psMemGetId();
    246259        psVector *vec = psVectorAlloc(1, PS_TYPE_S8);
    247260        ok(!psVectorInit(vec, PS_MAX_S16), "VectorInit failed.  S8 Case");
    248261        psFree(vec);
    249     }
    250 
    251     {
     262        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     263    }
     264
     265
     266    {
     267        psMemId id = psMemGetId();
    252268        psVector *vec = psVectorAlloc(1, PS_TYPE_S16);
    253269        ok(psVectorInit(vec, -100), "S16 Case");
    254270        psFree(vec);
    255     }
    256 
    257     {
     271        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     272    }
     273
     274
     275    {
     276        psMemId id = psMemGetId();
    258277        psVector *vec = psVectorAlloc(1, PS_TYPE_S32);
    259278        ok(psVectorInit(vec, 1), "S32 Case");
    260279        psFree(vec);
    261     }
    262 
    263     {
    264         // XXX is this test ok?
     280        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     281    }
     282
     283
     284    // XXX is this test ok?
     285    {
     286        psMemId id = psMemGetId();
    265287        psVector *vec = psVectorAlloc(1, PS_TYPE_S64);
    266288        ok(psVectorInit(vec, PS_MAX_S64), "S64 Case");
    267289        psFree(vec);
    268     }
    269 
    270     {
     290        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     291    }
     292
     293
     294    {
     295        psMemId id = psMemGetId();
    271296        psVector *vec = psVectorAlloc(1, PS_TYPE_F32);
    272297        ok(psVectorInit(vec, 1.1), "F32 Case");
    273298        psFree(vec);
    274     }
    275 
    276     {
     299        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     300    }
     301
     302
     303    {
     304        psMemId id = psMemGetId();
    277305        psVector *vec = psVectorAlloc(1, PS_TYPE_F64);
    278306        ok(psVectorInit(vec, 1.4 ), "F64 Case");
    279307        psFree(vec);
    280     }
    281 
    282 
    283 //    diag("psVectorCreate() tests");
    284 
    285     {
     308        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     309    }
     310
     311
     312    // psVectorCreate() tests
     313    {
     314        psMemId id = psMemGetId();
    286315        psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S8);
    287316        for (int i = 0; i < 10; i++) {
    … …  
    290319        }
    291320        psFree(test);
    292     }
    293 
    294     {
     321        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     322    }
     323
     324
     325    {
     326        psMemId id = psMemGetId();
    295327        psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U8);
    296328        for (int i = 0; i < 10; i++) {
    … …  
    299331        }
    300332        psFree(test);
    301     }
    302 
    303 
    304     {
     333        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     334    }
     335
     336
     337    {
     338        psMemId id = psMemGetId();
    305339        psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U32);
    306340        for (int i = 0; i < 10; i++) {
    … …  
    309343        }
    310344        psFree(test);
    311     }
    312 
    313 
    314     {
     345        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     346    }
     347
     348
     349    {
     350        psMemId id = psMemGetId();
    315351        psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S32);
    316352        for (int i = 0; i < 10; i++) {
    … …  
    319355        }
    320356        psFree(test);
    321     }
    322 
    323 
    324     {
     357        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     358    }
     359
     360
     361    {
     362        psMemId id = psMemGetId();
    325363        psVector *input = psVectorAlloc(5, PS_TYPE_F32);
    326364        psVector *test = psVectorCreate(input, 0.0, 5.0, 0.5, PS_TYPE_F32);
    … …  
    330368               "Vector data matches. i = %d, data=%f", i, test->data.F32[i]);
    331369        }
    332 
    333370        psFree(input);
    334     }
     371        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     372    }
     373
    335374
    336375    //  Test PS_TYPE_F64
    337376    //       PS_TYPE_S64
    338377    //       PS_TYPE_U64
    339 
    340     {
     378    {
     379        psMemId id = psMemGetId();
    341380        psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S64);
    342381        for (int i = 0; i < 10; i++)
    … …  
    347386        }
    348387        psFree(test);
    349     }
    350 
    351     {
     388        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     389    }
     390
     391
     392    {
     393        psMemId id = psMemGetId();
    352394        psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_U64);
    353395        for (int i = 0; i < 10; i++)
    … …  
    358400        }
    359401        psFree(test);
    360     }
    361 
    362     {
     402        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     403    }
     404
     405
     406    {
     407        psMemId id = psMemGetId();
    363408        psVector *input = psVectorAlloc(5, PS_TYPE_F64);
    364409        psVector *test = psVectorCreate(input, 0.0, 5.0, 0.5, PS_TYPE_F64);
    365 
    366410        for (int i = 0; i < 10; i++)
    367411        {
    … …  
    371415        }
    372416        psFree(input);
    373     }
     417        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     418    }
     419
    374420
    375421    //  Test PS_TYPE_U16
    376422    //       PS_TYPE_S16
    377423    {
     424        psMemId id = psMemGetId();
    378425        psVector *test = psVectorCreate(NULL, 0.0, 10.0, 1.0, PS_TYPE_S16);
    379426        for (int i = 0; i < 10; i++)
    … …  
    383430        }
    384431        psFree(test);
    385     }
    386 
    387     {
     432        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     433    }
     434
     435
     436    {
     437        psMemId id = psMemGetId();
    388438        psVector *input = psVectorAlloc(5, PS_TYPE_U16);
    389439        psVector *test = psVectorCreate(input, 0.0, 20.0, 2.0, PS_TYPE_U16);
    390 
    391440        for (int i = 0; i < 10; i++)
    392441        {
    … …  
    395444        }
    396445        psFree(input);
    397     }
    398 
    399 
    400 
    401 //    diag("psVectorToString() tests");
     446        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     447    }
     448
     449
    402450
    403451    #define TEST_VECTOR_TO_STRING(TYPE, SIZE, START, INC, EXPECTED)         \
    404452    {                                                                       \
     453        psMemId id = psMemGetId(); \
    405454        const int asize = SIZE;  /* alloc size */                           \
    406455        const int osize = 100;   /* output size (max) */                    \
    … …  
    416465        \
    417466        psFree(input);                                                      \
    418     }
    419 
    420 
     467        psFree(result);                                                      \
     468        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); \
     469    }
     470//HERE
     471    // psVectorToString() tests
    421472    TEST_VECTOR_TO_STRING(PS_TYPE_U8,  5, 1, 1, "[1,2,3,4,5]");
    422 
    423473    TEST_VECTOR_TO_STRING(PS_TYPE_U16, 5, 1, 1, "[1,2,3,4,5]");
    424 
    425474    TEST_VECTOR_TO_STRING(PS_TYPE_U32, 5, 1, 1, "[1,2,3,4,5]");
    426 
    427475    TEST_VECTOR_TO_STRING(PS_TYPE_U64, 5, 1, 1, "[1,2,3,4,5]");
    428 
    429476    TEST_VECTOR_TO_STRING(PS_TYPE_S8,  5, -100, 10,"[-100,-90,-80,-70,-60]");
    430 
    431477    TEST_VECTOR_TO_STRING(PS_TYPE_S16, 5, 0, -100, "[0,-100,-200,-300,-400]");
    432 
    433478    TEST_VECTOR_TO_STRING(PS_TYPE_S32, 5, 0, -100, "[0,-100,-200,-300,-400]");
    434 
    435479    TEST_VECTOR_TO_STRING(PS_TYPE_S64, 5, 0, -100, "[0,-100,-200,-300,-400]");
    436 
    437480    TEST_VECTOR_TO_STRING(PS_TYPE_F32,5,.123,1,"[0.123,1.123,2.123,3.123,4.123]");
    438481    TEST_VECTOR_TO_STRING(PS_TYPE_F64,5,.123,1,"[0.123,1.123,2.123,3.123,4.123]");
    439482
    440 
    441 //    diag("p_psVectorGetElementF64() tests");
    442483
    443484    #define TEST_VECTOR_GET_ELEMENT_F64(ELEM_TYPE, SIZE, VALUE_TYPE,        \
    444485                                        INIT_VALUE )                                                        \
    445486    {                                                                       \
     487        psMemId id = psMemGetId(); \
    446488        psVector *vec = psVectorAlloc(SIZE, ELEM_TYPE);                     \
    447489        vec->n = SIZE;                                                      \
    … …  
    454496        \
    455497        psFree(vec);                                                        \
    456     }
    457 
     498        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); \
     499    }
     500    // p_psVectorGetElementF64() tests
    458501    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U8, 1, psU8, 1);
    459 
    460502    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U16, 2, psU16, 2);
    461 
    462503    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U32, 3, psU32, 3);
    463 
    464504    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_U64, 100, psU64, 999999);
    465 
    466505    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S8,  1, psS8, -1);
    467 
    468506    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S16, 2, psS16, -2);
    469 
    470507    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S32, 3, psS32, -3);
    471 
    472508    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_S64, 100, psS64, -999999);
    473 
    474509    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_F32,1, psF32, .123);
    475 
    476510    TEST_VECTOR_GET_ELEMENT_F64(PS_TYPE_F64,2, psF64, -123.123);
    477511
    478512
    479 //    diag("p_psVectorPrint() tests");
    480513    // XXX: Why are we testing private functions?
    481514    #define TEST_VECTOR_PRINT(ELEM_TYPE, SIZE, VALUE_TYPE, INIT_VALUE, FD,  \
    482515                              OUT_NAME, EXPECTED_RC )                                             \
    483516    {                                                                       \
     517        psMemId id = psMemGetId(); \
    484518        psVector *vec = psVectorAlloc(SIZE, ELEM_TYPE);                     \
    485519        vec->n = SIZE;                                                      \
    … …  
    491525        \
    492526        psFree(vec);                                                        \
    493     }
    494 
     527        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); \
     528    }
     529    // p_psVectorPrint() tests
    495530    TEST_VECTOR_PRINT(PS_TYPE_U8, 1, psU8, 1, 1, "PS_TYPE_U8", TRUE);
    496 
    497531    TEST_VECTOR_PRINT(PS_TYPE_U16, 2, psU16, 2, 1, "PS_TYPE_U16", TRUE);
    498 
    499532    TEST_VECTOR_PRINT(PS_TYPE_U32, 3, psU32, 3, 1, "PS_TYPE_U32", TRUE);
    500 
    501533    TEST_VECTOR_PRINT(PS_TYPE_U64, 4, psU64, 999999, 1, "PS_TYPE_U64", TRUE);
    502 
    503534    TEST_VECTOR_PRINT(PS_TYPE_S8,  1, psS8, -1, 1, "PS_TYPE_S8", TRUE);
    504 
    505535    TEST_VECTOR_PRINT(PS_TYPE_S16, 2, psS16, -2, 1, "PS_TYPE_S16", TRUE);
    506 
    507536    TEST_VECTOR_PRINT(PS_TYPE_S32, 3, psS32, -3, 1, "PS_TYPE_S32", TRUE);
    508 
    509537    TEST_VECTOR_PRINT(PS_TYPE_S64, 4, psS64, -999999, 1, "PS_TYPE_S64", TRUE);
    510 
    511538    TEST_VECTOR_PRINT(PS_TYPE_F32,1, psF32, .123, 1, "PS_TYPE_F32", TRUE);
    512 
    513539    TEST_VECTOR_PRINT(PS_TYPE_F64,2, psF64, -123.123, 1, "PS_TYPE_F64", TRUE);
    514540
    515 //    diag("psVectorSet() tests");
    516 
    517     {
     541    // psVectorSet() tests
     542    {
     543        psMemId id = psMemGetId();
    518544        psVector *vec = psVectorAlloc(5, PS_TYPE_S32);
    519 
    520545        ok(psVectorSet(vec, 0, 10),
    521546           "VectorSet set S32 at position 0");
    522 
    523         psFree(vec);
    524     }
    525 
    526     {
     547        psFree(vec);
     548        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     549    }
     550
     551
     552    {
     553        psMemId id = psMemGetId();
    527554        psVector *vec = psVectorAlloc(5, PS_TYPE_S32);
    528 
    529555        ok(!psVectorSet(vec, 10, 10),
    530556           "VectorSet failes to set S32 at out of range position");
    531 
    532         psFree(vec);
    533     }
    534 
    535     {
     557        psFree(vec);
     558        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     559    }
     560
     561
     562    {
     563        psMemId id = psMemGetId();
    536564        psVector *vec = psVectorAlloc(5, PS_TYPE_S32);
    537 
    538565        ok(psVectorSet(vec, 1, 4) == true,
    539566           "VectorSet set S32 at position 1");
    540 
    541         psFree(vec);
    542     }
    543 
    544 
    545 //    diag("psVectorGet() tests");
    546 
    547     {
     567        psFree(vec);
     568        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     569    }
     570
     571
     572    // psVectorGet() tests
     573    {
     574        psMemId id = psMemGetId();
    548575        psVector *vec = psVectorAlloc(10, PS_TYPE_S32);
    549576        psVectorSet(vec, 0, 10);
    550 
    551577        ok((psS32)psVectorGet(vec, 0) == 10,
    552578           "VectorGet returned the correct S32 from position 0");
    553 
    554         psFree(vec);
    555     }
    556 
    557     {
     579        psFree(vec);
     580        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     581    }
     582
     583
     584    {
     585        psMemId id = psMemGetId();
    558586        psVector *vec = psVectorAlloc(5, PS_TYPE_S32);
    559587        psVectorSet(vec, -1, 4);
    560 
    561588        ok((psS32)psVectorGet(vec, -1) == 4,
    562589           "VectorGet returned the correct S32 from tail using -1");
    563 
    564         psFree(vec);
    565     }
    566 
    567 
    568 //    diag("psVectorCountPixelMask() tests");
    569 
    570     {
     590        psFree(vec);
     591        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     592    }
     593
     594
     595    // psVectorCountPixelMask() tests
     596    {
     597        psMemId id = psMemGetId();
    571598        ok(psVectorCountPixelMask(NULL, 1) == -1,
    572599           "psVectorCountPixelMask returned -1 for NULL Vector input");
    573     }
    574 
    575     {
     600        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     601    }
     602
     603
     604    {
     605        psMemId id = psMemGetId();
    576606        psVector *vec = psVectorAlloc(5, PS_TYPE_S32);
    577607        vec->data.S32[0] = 0;
    … …  
    580610        vec->data.S32[3] = 1;
    581611        vec->data.S32[4] = 0;
    582         vec->n = 5;
    583 
    584612        ok(psVectorCountPixelMask(vec, 1) == -1,
    585613           "returned -1 for wrong type of Vector input");
    586 
    587         psFree(vec);
    588     }
    589 
    590     {
     614        psFree(vec);
     615        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     616    }
     617
     618
     619    {
     620        psMemId id = psMemGetId();
    591621        psVector *vec = psVectorAlloc(5, PS_TYPE_U8);
    592622        vec->data.U8[0] = 0;
    … …  
    595625        vec->data.U8[3] = 1;
    596626        vec->data.U8[4] = 0;
    597         vec->n = 5;
    598627        long numPix = psVectorCountPixelMask(vec, 1);
    599 
    600628        ok(numPix != -1, "returned -1 for correct Vector input");
    601629        ok(numPix == 2, "returned pixel count %d", numPix);
    602 
    603         psFree(vec);
    604     }
    605 
    606 
    607 //    diag("psVectorLength() tests");
    608     {
     630        psFree(vec);
     631        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     632    }
     633
     634
     635    // psVectorLength() tests
     636    {
     637        psMemId id = psMemGetId();
    609638        psVector *vector = psVectorAlloc(5, PS_TYPE_F32);
    610639        ok(psVectorLength(vector) == 5,
    611640           "returned the correct length of vector (was %d, should be 5)", psVectorLength(vector));
    612641        psFree(vector);
    613     }
    614 
    615     {
     642        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     643    }
     644
     645
     646    {
     647        psMemId id = psMemGetId();
    616648        psVector *vector = psVectorAlloc(5, PS_TYPE_F32);
    617         vector->n = 5;
    618 
    619649        ok(psVectorLength(vector) == 5,
    620650           "returned the correct length of vector");
    621 
    622651        psFree(vector);
    623     }
    624 
    625     {
     652        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     653    }
     654
     655
     656    {
     657        psMemId id = psMemGetId();
    626658        psVector *vector = psVectorAlloc(6, PS_TYPE_F32);
    627         vector->n = 6;
    628 
    629659        ok(psVectorLength(vector) == 6,
    630660           "returned the correct length of vector");
    631 
    632661        psFree(vector);
    633     }
    634 
    635     {
     662        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     663    }
     664
     665
     666    {
     667        psMemId id = psMemGetId();
    636668        ok(psVectorLength(NULL) == -1, "returned -1 for a NULL input vector");
    637     }
    638 
    639     {
     669        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     670    }
     671
     672
     673    {
     674        psMemId id = psMemGetId();
    640675        psArray *array = psArrayAlloc(5);
    641 
    642676        ok(psVectorLength((psVector*)array) == -1,
    643677           "returned -1 for an invalid input vector");
    644 
    645678        psFree(array);
    646     }
    647 
    648 
    649 //    diag("psVectorCopy() tests");
    650 
    651     {
    652 
     679        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     680    }
     681
     682
     683    // psVectorCopy() tests
     684    {
     685        psMemId id = psMemGetId();
    653686        ok(psVectorCopy(NULL, NULL, PS_TYPE_F32) == NULL,
    654687           "returned a NULL vector for NULL input");
    655     }
    656 
    657     {
     688        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     689    }
     690
     691
     692    {
     693        psMemId id = psMemGetId();
    658694        psVector *in = psVectorAlloc(5, PS_TYPE_F32);
    659         in->n = 5;
    660 
    661695        for (int i = 0; i < 5; i++) {
    662696            in->data.F32[i] = i;
    663697        }
    664 
    665698        //Try copy of different type
    666699        psVector *copy = psVectorCopy(NULL, in, PS_TYPE_F64);
    … …  
    671704           copy->data.F64[2], in->data.F32[2]);
    672705        skip_end();
    673 
    674706        psFree(in);
    675707        psFree(copy);
    676     }
     708        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     709    }
     710
    677711
    678712    // XXX psVectorRecycle needs it's own tests
    679713    // copy = psVectorRecycle(copy, in->n + 2, PS_TYPE_F64);
    680 
    681     {
     714    {
     715        psMemId id = psMemGetId();
    682716        // Try copy of same type and non-NULL outVector of different type and
    683717        // size.
    … …  
    700734        psFree(in);
    701735        psFree(copy);
    702     }
    703 
    704     return exit_status();
     736        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     737    }
    705738}

  • trunk/psLib/test/mathtypes/tap_psVectorSort_01.c

    r12513 r12781  
    1212 *  @author  Ross Harman, MHPCC
    1313 *
    14  *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
    15  *  @date  $Date: 2007-03-20 03:57:25 $
     14 *  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
     15 *  @date  $Date: 2007-04-10 21:09:31 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1818 *
    1919 */
    20 
    2120#include <pslib.h>
    22 
    2321#include "tap.h"
    2422#include "pstap.h"
    2523
    26 
    2724#define tstVectorSortByType(datatype,value)   \
    2825in = psVectorAlloc(7,PS_TYPE_##datatype); \
    29 in->n = 7;  \
    3026out = psVectorAlloc(7,PS_TYPE_##datatype); \
    31 out->n = 7;  \
    3227in->data.datatype[0] = 7+value; \
    3328in->data.datatype[1] = 9+value; \
    … …  
    4540ok(out->data.datatype[0] == in->data.datatype[6], \
    4641   "sort out[0] type %s",#datatype); \
    47 skip_start(out->data.datatype[0] != in->data.datatype[6], \
    48            6,"sort out[0] type %s",#datatype); \
    4942ok(out->data.datatype[1] == in->data.datatype[3], \
    5043   "sort out[1] type %s",#datatype); \
    51 skip_start(out->data.datatype[1] != in->data.datatype[3], \
    52            5,"Improper sort out[1] type %s",#datatype); \
    5344ok(out->data.datatype[2] == in->data.datatype[2], \
    5445   "sort out[2] type %s",#datatype); \
    55 skip_start(out->data.datatype[2] != in->data.datatype[2], \
    56            4,"Improper sort out[2] type %s",#datatype); \
    5746ok(out->data.datatype[3] == in->data.datatype[4], \
    5847   "sort out[3] type %s",#datatype); \
    59 skip_start(out->data.datatype[3] != in->data.datatype[4], \
    60            3,"Improper sort out[3] type %s",#datatype); \
    6148ok(out->data.datatype[4] == in->data.datatype[5], \
    6249   "sort out[4] %s",#datatype); \
    63 skip_start(out->data.datatype[4] != in->data.datatype[5], \
    64            2,"Improper sort out[4] %s",#datatype); \
    6550ok(out->data.datatype[5] == in->data.datatype[0], \
    6651   "sort out[5] %s",#datatype); \
    67 skip_start(out->data.datatype[5] != in->data.datatype[0], \
    68            1,"Improper sort out[5] %s",#datatype); \
    6952ok(out->data.datatype[6] == in->data.datatype[1], \
    7053   "sort out[6] %s",#datatype); \
    71 skip_end(); \
    72 skip_end(); \
    73 skip_end(); \
    74 skip_end(); \
    75 skip_end(); \
    76 skip_end(); \
    7754skip_end(); \
    7855psFree(in); \
    … …  
    8461           char* argv[])
    8562{
    86     plan_tests(92);
     63    psLogSetFormat("HLNM");
     64    psLogSetLevel(PS_LOG_INFO);
     65    plan_tests(97);
    8766
    8867    psVector *in = NULL;
    … …  
    9170
    9271    // Test A - Verify the sort for all supported types
    93 
    94     tstVectorSortByType(S8,0);
    95     tstVectorSortByType(S16,1);
    96     tstVectorSortByType(S32,2);
    97     tstVectorSortByType(S64,3);
    98     tstVectorSortByType(U8,4);
    99     tstVectorSortByType(U16,5);
    100     tstVectorSortByType(U32,6);
    101     tstVectorSortByType(U64,7);
    102     tstVectorSortByType(F32,8);
    103     tstVectorSortByType(F64,9);
     72    {
     73        psMemId id = psMemGetId();
     74        tstVectorSortByType(S8,0);
     75        tstVectorSortByType(S16,1);
     76        tstVectorSortByType(S32,2);
     77        tstVectorSortByType(S64,3);
     78        tstVectorSortByType(U8,4);
     79        tstVectorSortByType(U16,5);
     80        tstVectorSortByType(U32,6);
     81        tstVectorSortByType(U64,7);
     82        tstVectorSortByType(F32,8);
     83        tstVectorSortByType(F64,9);
     84        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     85    }
    10486
    10587
    10688    // Test B - Sort input vector into itself
     89    {
     90        psMemId id = psMemGetId();
     91        psVector *in = psVectorAlloc(7, PS_TYPE_F32);
     92        in->data.F32[0] = 0.7f;
     93        in->data.F32[1] = 0.9f;
     94        in->data.F32[2] = 0.3f;
     95        in->data.F32[3] = 0.1f;
     96        in->data.F32[4] = 0.5f;
     97        in->data.F32[5] = 0.5f;
     98        in->data.F32[6] = -2.0f;
     99        in = psVectorSort(in, in);
     100        ok(in->data.F32[0] == -2.0f,"self sort in[0]");
     101        ok(in->data.F32[1] == 0.1f,"self sort in[1]");
     102        ok(in->data.F32[2] == 0.3f, "self sort in[2]");
     103        ok(in->data.F32[3] == 0.5f, "self sort in[3]");
     104        ok(in->data.F32[4] == 0.5f, "self sort in[4]");
     105        ok(in->data.F32[5] == 0.7f, "self sort in[5]");
     106        ok(in->data.F32[6] == 0.9f, "self sort in[6]");
     107        psFree(in);
     108        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     109    }
    107110
    108     in = psVectorAlloc(7, PS_TYPE_F32);
    109     in->n = 7;
    110     in->data.F32[0] = 0.7f;
    111     in->data.F32[1] = 0.9f;
    112     in->data.F32[2] = 0.3f;
    113     in->data.F32[3] = 0.1f;
    114     in->data.F32[4] = 0.5f;
    115     in->data.F32[5] = 0.5f;
    116     in->data.F32[6] = -2.0f;
    117     in = psVectorSort(in, in);
    118     ok(in->data.F32[0] == -2.0f,"self sort in[0]");
    119     ok(in->data.F32[1] == 0.1f,"self sort in[1]");
    120     ok(in->data.F32[2] == 0.3f, "self sort in[2]");
    121     ok(in->data.F32[3] == 0.5f, "self sort in[3]");
    122     ok(in->data.F32[4] == 0.5f, "self sort in[4]");
    123     ok(in->data.F32[5] == 0.7f, "self sort in[5]");
    124     ok(in->data.F32[6] == 0.9f, "self sort in[6]");
    125111
    126112    // Test C - Attempt to sort vector with invalid type
    127     in->type.type = PS_TYPE_BOOL;
    128     out = psVectorAlloc(7,PS_TYPE_F32);
    129     tempVec = psVectorSort(out,in);
    130     ok(tempVec == NULL, "Did return NULL on error");
     113    {
     114        psMemId id = psMemGetId();
     115        psVector *in = psVectorAlloc(7, PS_TYPE_F32);
     116        in->type.type = PS_TYPE_BOOL;
     117        out = psVectorAlloc(7,PS_TYPE_F32);
     118        tempVec = psVectorSort(out,in);
     119        ok(tempVec == NULL, "Did return NULL on error");
     120        psFree(out);
     121        psFree(in);
     122        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     123    }
     124
    131125
    132126    // Test D - Sort vector with zero elements
    133     out = psVectorAlloc(7,PS_TYPE_F32);
    134     in->n = 0;
    135     out = psVectorSort(out,in);
    136     ok (out != NULL, "psVectorSort returned a non-NULL vector" );
    137     skip_start (out == NULL, 1, "psVectorSort returned a NULL vector" );
    138     ok (out->n == 0, "psVectorSort correctly return a 0-length vector.\n");
    139     skip_end();
    140 
    141     psFree(out);
     127    {
     128        psMemId id = psMemGetId();
     129        out = psVectorAlloc(7,PS_TYPE_F32);
     130        in->n = 0;
     131        out = psVectorSort(out,in);
     132        ok(out != NULL, "psVectorSort returned a non-NULL vector" );
     133        skip_start (out == NULL, 1, "psVectorSort returned a NULL vector" );
     134        ok(out->n == 0, "psVectorSort correctly return a 0-length vector");
     135        skip_end();
     136        psFree(out);
     137        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     138    }
    142139
    143140
    144141    // Test D - Free float vectors
    145     psFree(in);
    146     ok ( ! psMemCheckLeaks(0, NULL, stdout, false),"Memory leaks not detected");
    147 
    148     psS32 nBad = psMemCheckCorruption(stderr, false);
    149     ok(!nBad, "Found %d bad memory blocks\n", nBad);
     142    {
     143        psMemId id = psMemGetId();
     144        psVector *in = psVectorAlloc(7, PS_TYPE_F32);
     145        psFree(in);
     146        ok( ! psMemCheckLeaks(0, NULL, stdout, false),"Memory leaks not detected");
     147        psS32 nBad = psMemCheckCorruption(stderr, false);
     148        ok(!nBad, "Found %d bad memory blocks", nBad);
     149        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     150    }
    150151}

  • trunk/psLib/test/mathtypes/tap_psVectorSort_02.c

    r12513 r12781  
    1414 *  @author  Ross Harman, MHPCC
    1515 *
    16  *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
    17  *  @date  $Date: 2007-03-20 03:57:25 $
     16 *  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
     17 *  @date  $Date: 2007-04-10 21:09:31 $
    1818 *
    1919 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2828#define tstVectorSortIndexByType(datatype,value) \
    2929in = psVectorAlloc( 5, PS_TYPE_##datatype ); \
    30 in->n = 5; \
    3130in->data.datatype[0] = 7+value; \
    3231in->data.datatype[1] = 9+value; \
    … …  
    5251psS32 main(psS32 argc, char* argv[])
    5352{
    54     plan_tests(71);
     53    psLogSetFormat("HLNM");
     54    psLogSetLevel(PS_LOG_INFO);
     55    plan_tests(77);
    5556
    5657    psVector *in = NULL;
    … …  
    5960
    6061    // Test A - Sort vectors by index for all types
    61     tstVectorSortIndexByType(S8,0)
    62     tstVectorSortIndexByType(U8,1)
    63     tstVectorSortIndexByType(S16,2)
    64     tstVectorSortIndexByType(U16,3)
    65     tstVectorSortIndexByType(S32,4)
    66     tstVectorSortIndexByType(U32,5)
    67     tstVectorSortIndexByType(S64,6)
    68     tstVectorSortIndexByType(U64,7)
    69     tstVectorSortIndexByType(F32,8)
    70     tstVectorSortIndexByType(F64,9)
    71     psFree(out);
     62    {
     63        psMemId id = psMemGetId();
     64        tstVectorSortIndexByType(S8,0)
     65        tstVectorSortIndexByType(U8,1)
     66        tstVectorSortIndexByType(S16,2)
     67        tstVectorSortIndexByType(U16,3)
     68        tstVectorSortIndexByType(S32,4)
     69        tstVectorSortIndexByType(U32,5)
     70        tstVectorSortIndexByType(S64,6)
     71        tstVectorSortIndexByType(U64,7)
     72        tstVectorSortIndexByType(F32,8)
     73        tstVectorSortIndexByType(F64,9)
     74        psFree(out);
     75        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     76    }
     77
    7278
    7379    // Test  C  Attempt to sort with null input vector
    74     in = NULL;
    75     out = psVectorAlloc(5,PS_TYPE_U32);
    76     out = psVectorSortIndex(out,in);
    77     ok(out == NULL, "Did return NULL with NULL input specified");
     80    {
     81        psMemId id = psMemGetId();
     82        in = NULL;
     83        out = psVectorAlloc(5,PS_TYPE_U32);
     84        out = psVectorSortIndex(out,in);
     85        ok(out == NULL, "Did return NULL with NULL input specified");
     86        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     87    }
     88
    7889
    7990    // Test  D  Sort with output vector which needs to be resized
    80     in = psVectorAlloc(5,PS_TYPE_U8);
    81     in->n=5;
    82     for(psS32 m=0; m<5; m++) {
    83         in->data.U8[m]= 20-m;
     91    {
     92        psMemId id = psMemGetId();
     93        in = psVectorAlloc(5,PS_TYPE_U8);
     94        in->n=5;
     95        for(psS32 m=0; m<5; m++) {
     96            in->data.U8[m]= 20-m;
     97        }
     98        out = psVectorAlloc(5,PS_TYPE_U32);
     99        out->n = 5;
     100        out = psVectorSortIndex(out,in);
     101        ok(out->n == 5, "Did properly resize output vector...out->n=%d, in->n=%d", out->n, in->n);
     102        ok(out->data.U32[0] == 4,
     103           "Did properly sort index out[0] = %d",out->data.U32[0]);
     104        ok(out->data.U32[1] == 3,
     105           "Did properly sort index out[1] = %d",out->data.U32[1]);
     106        ok(out->data.U32[2] == 2,
     107           "Did properly sort index out[2] = %d",out->data.U32[2]);
     108        ok(out->data.U32[3] == 1,
     109           "Did properly sort index out[3] = %d",out->data.U32[3]);
     110        ok(out->data.U32[4] == 0,
     111           "Did properly sort index out[4] = %d",out->data.U32[4]);
     112        psFree(in);
     113        psFree(out);
     114        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    84115    }
    85     out = psVectorAlloc(5,PS_TYPE_U32);
    86     out->n = 5;
    87     out = psVectorSortIndex(out,in);
    88     ok(out->n == 5, "Did properly resize output vector...out->n=%d, in->n=%d", out->n, in->n);
    89     ok(out->data.U32[0] == 4,
    90        "Did properly sort index out[0] = %d",out->data.U32[0]);
    91     ok(out->data.U32[1] == 3,
    92        "Did properly sort index out[1] = %d",out->data.U32[1]);
    93     ok(out->data.U32[2] == 2,
    94        "Did properly sort index out[2] = %d",out->data.U32[2]);
    95     ok(out->data.U32[3] == 1,
    96        "Did properly sort index out[3] = %d",out->data.U32[3]);
    97     ok(out->data.U32[4] == 0,
    98        "Did properly sort index out[4] = %d",out->data.U32[4]);
    99116
    100     psFree(in);
    101     psFree(out);
    102117
    103118    // Test E - Sort input vector with zero elements
    104     in = psVectorAlloc(5,PS_TYPE_U8);
    105     out = psVectorAlloc(5,PS_TYPE_U32);
    106     in->n = 0;
    107     out->n = 0;
    108     tempVect = out;
    109     out = psVectorSortIndex(out,in);
    110     ok ( out == tempVect, "Did not return the same output vector");
    111     in->n=5;
    112     out->n=5;
    113     psFree(out);
    114     psFree(in);
     119    {
     120        psMemId id = psMemGetId();
     121        in = psVectorAlloc(5,PS_TYPE_U8);
     122        out = psVectorAlloc(5,PS_TYPE_U32);
     123        in->n = 0;
     124        out->n = 0;
     125        tempVect = out;
     126        out = psVectorSortIndex(out,in);
     127        ok ( out == tempVect, "Did not return the same output vector");
     128        in->n=5;
     129        out->n=5;
     130        psFree(out);
     131        psFree(in);
     132        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     133    }
     134
    115135
    116136    // Test F - Attempt to sort input vector with invalid type
    117     in = psVectorAlloc(5,PS_TYPE_U8);
    118     out = psVectorAlloc(5,PS_TYPE_U32);
    119     in->n = 5;
    120     out->n = 5;
    121     tempVect = out;
    122     in->type.type = PS_TYPE_BOOL;
    123     out = psVectorSortIndex(out,in);
    124     ok( out == NULL, "Did return NULL");
    125     in->type.type = PS_TYPE_U8;
    126     psFree(in);
     137    {
     138        psMemId id = psMemGetId();
     139        in = psVectorAlloc(5,PS_TYPE_U8);
     140        out = psVectorAlloc(5,PS_TYPE_U32);
     141        in->n = 5;
     142        out->n = 5;
     143        tempVect = out;
     144        in->type.type = PS_TYPE_BOOL;
     145        out = psVectorSortIndex(out,in);
     146        ok( out == NULL, "Did return NULL");
     147        in->type.type = PS_TYPE_U8;
     148        psFree(in);
     149        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     150    }
     151
    127152
    128153    // Test G - Free vectors
    129     psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false);
    130     ok(!nLeaks, "Found %d memory leaks\n", nLeaks);
    131     psS32 nBad = psMemCheckCorruption(stderr, false);
    132     ok(!nBad, "Found %d bad memory blocks\n", nBad);
     154    {
     155        psMemId id = psMemGetId();
     156        psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false);
     157        ok(!nLeaks, "Found %d memory leaks", nLeaks);
     158        psS32 nBad = psMemCheckCorruption(stderr, false);
     159        ok(!nBad, "Found %d bad memory blocks", nBad);
     160        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     161    }
    133162}

  • trunk/psLib/test/mathtypes/tap_psVectorSort_03.c

    r11265 r12781  
    33 *  @brief Test driver for psVectorSort functions
    44 *
    5  *  This test driver contains the following tests for psVectorSort test point 3:
    6  *     A)  Create float vectors of different sizes
    7  *     B)  Attempt to sort vectors...should get errors
    8  *     C)  Create float vector and double vector
    9  *     D)  Attempt to sort vectors...should get errors
    10  *     E)  Free float, double vectors
    11  *
    125 *  @author  Ross Harman, MHPCC
    136 *
    14  *  @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
    15  *  @date  $Date: 2007-01-24 22:14:48 $
     7 *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
     8 *  @date  $Date: 2007-04-10 21:09:31 $
     9 *
     10 *  XXX: These tests are obsolete.  psVectorSOrt no longer returns error
     11 *  with incorrect input vector types or sizes
    1612 *
    1713 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2824           char* argv[])
    2925{
    30     plan_tests(2);
     26    psLogSetFormat("HLNM");
     27    psLogSetLevel(PS_LOG_INFO);
     28    plan_tests(1);
     29    ok(true, "cake");
    3130
    32     psVector *in = NULL;
    33     psVector *out = NULL;
    34     psVector *in2 = NULL;
    35     psVector *out2 = NULL;
    36 
    37     // Test A - Create float vectors
    38     in = psVectorAlloc(5, PS_TYPE_F32);
    39     in->n = 5;
    40     out = psVectorAlloc(6, PS_TYPE_F32);
    41     out->n = 6;
    42     in->n = 5;
    43     for(psS32 i=0; i<5; i++) {
    44         //printf("arr[%d] = %f\n", i, in->data.F32[i]);
     31    // Create float vectors with incorrect sizes
     32    if (0) {
     33        psMemId id = psMemGetId();
     34        psVector *in = psVectorAlloc(5, PS_TYPE_F32);
     35        psVector *out = psVectorAlloc(6, PS_TYPE_F32);
     36        psVector *out2 = psVectorSort(out, in);
     37        ok(out2 == NULL, "psVectorSort() returned() NULL with non-uniform verctor input sizes");
     38        psFree(in);
     39        psFree(out);
     40        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    4541    }
    4642
    4743
    48     // Test B - Sort input float vector and put results into output float vector
    49     out = psVectorSort(out, in);
    50 
    51     // Test C - Create float vector and double vector
    52     in2 = psVectorAlloc(5, PS_TYPE_F32);
    53     in2->n = 5;
    54     out2 = psVectorAlloc(5, PS_TYPE_F64);
    55     out2->n = 5;
    56     for(psS32 j=0; j<5; j++) {
    57         //printf("vec[%d] = %f\n", j, in2->data.F32[j]);
     44    // Create float vector and double vector
     45    if (0) {
     46        psMemId id = psMemGetId();
     47        psVector *in2 = psVectorAlloc(5, PS_TYPE_F32);
     48        psVector *out2 = psVectorAlloc(5, PS_TYPE_F64);
     49        psVector *out3 = psVectorSort(out2, in2);
     50        ok(out3 == NULL, "psVectorSort() returned() NULL with non-uniform verctor input types");
     51        psFree(in2);
     52        psFree(out2);
     53        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    5854    }
    59 
    60     // Test D - Attempt to sort vectors with output of different type should create error
    61     out2 = psVectorSort(out2, in2);
    62 
    63     // Test C - Free float vectors
    64     psFree(in);
    65     psFree(in2);
    66     psFree(out);
    67     psFree(out2);
    68     psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false);
    69     ok(!nLeaks, "Found %d memory leaks\n", nLeaks);
    70     psS32 nBad = psMemCheckCorruption(stderr, false);
    71     ok(!nBad, "Found %d bad memory blocks\n", nBad);
    7255}

  • trunk/psLib/test/mathtypes/tap_psVectorSort_04.c

    r11265 r12781  
    33 *  @brief Test driver for psVectorSort functions
    44 *
    5  *  This test driver contains the following tests for psVectorSort test point 4:
    6  *     A)  Attempt to sort with null input vector
    7  *     B)  Free vectors
    8  *
    95 *  @author  Ross Harman, MHPCC
    106 *
    11  *  @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
    12  *  @date  $Date: 2007-01-24 22:14:48 $
     7 *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
     8 *  @date  $Date: 2007-04-10 21:09:31 $
    139 *
    1410 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    1511 *
    1612 */
    17 
    1813#include <pslib.h>
    19 
    2014#include "tap.h"
    2115#include "pstap.h"
    … …  
    2519           char* argv[])
    2620{
     21    psLogSetFormat("HLNM");
     22    psLogSetLevel(PS_LOG_INFO);
    2723    plan_tests(2);
    2824
    29     psVector *badIn = NULL;
    30     psVector *goodOut = psVectorAlloc(5, PS_TYPE_F32);
    3125
    32     // Test A - Attempt to sort with null input vector
    33     goodOut = psVectorSort(goodOut, badIn);
    34 
    35     // Test B - Free vectors
    36     psFree(goodOut);
    37     psS32 nLeaks = psMemCheckLeaks(0, NULL, stdout, false);
    38     ok(!nLeaks, "Found %d memory blocks\n", nLeaks);
    39     psS32 nBad = psMemCheckCorruption(stderr, false);
    40     ok(!nBad, "Found %d bad memory blocks\n", nBad);
     26    // Attempt to sort with null input vector
     27    {
     28        psMemId id = psMemGetId();
     29        psVector *goodOut = psVectorAlloc(5, PS_TYPE_F32);
     30        goodOut = psVectorSort(goodOut, NULL);
     31        ok(goodOut == NULL, "psVectorSort() returned NULL with NULL input vector");
     32        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     33    }
    4134}

  • trunk/psLib/test/sys/tap_psConfigure.c

    r11685 r12781  
    1111 *  @author  Ross Harman, MHPCC
    1212 *
    13  *  @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
    14  *  @date  $Date: 2007-02-07 22:50:18 $
     13 *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
     14 *  @date  $Date: 2007-04-10 21:09:31 $
    1515 *
    1616 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2424
    2525
    26 static psS32 psLibVersion00(void);
    27 
    28 
    2926psS32 main(psS32 argc, char* argv[])
    3027{
    31     plan_tests(1);
     28    plan_tests(2);
    3229
    33     psLibVersion00();
     30    // Simple test of psLibVersion()
     31    // XX: Must somehow verify the output is correct.
     32    {
     33        psMemId id = psMemGetId();
     34        char *stringVal = NULL;
     35        stringVal = psLibVersion();
     36        ok(stringVal != NULL && strlen(stringVal), "Version is cool");
     37        psFree(stringVal);
     38        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     39    }
    3440}
    3541
    36 
    37 static psS32 psLibVersion00(void)
    38 {
    39     diag("psLibVersion00");
    40 
    41     char *stringVal = NULL;
    42     stringVal = psLibVersion();
    43     ok( stringVal != NULL && strlen(stringVal), "Version is cool");
    44     psFree(stringVal);
    45 
    46     return 0;
    47 }
    48 

  • trunk/psLib/test/sys/tap_psError.c

    r12513 r12781  
    33 *  @brief Test driver for psError function
    44 *
    5  *  This test driver contains the following test points for psError
    6  *     testError00 - psError()                          (Testpoint #486)
    7  *     testError01 - psErrorMsg(), psErrorStackPrint()  (Testpoint #725)
    8  *     testError02 - psErrorStackPrintV()               (Testpoint #726)
    9  *     testError03 - psErrorGet(), psErrorLast()        (Testpoint #727)
    10  *     testError04 - psErrorClear()                     (Testpoint #728)
    11  *     testError05 - psErrorCodeString()                (Testpoint #729)
    12  *
    135 *  @author  Eric Van Alst, MHPCC
    146 *
    15  *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
    16  *  @date  $Date: 2007-03-20 03:57:25 $
     7 *  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
     8 *  @date  $Date: 2007-04-10 21:09:31 $
    179 *
    1810 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2820
    2921// Function used in testError02 to verify the psErrorStackPrintV function
    30 static void myErrorStackPrint(FILE *fd,
    31                               const char *fmt,
    32                               ...)
     22static void myErrorStackPrint(
     23    FILE *fd,
     24    const char *fmt,
     25    ...)
    3326{
    3427    va_list ap;
    … …  
    4134
    4235
    43 static psS32 testError00(void)
    44 {
    45 //    diag("testError00");
    46 
    47     psS32  intval=1;
    48     psS64 longval = 2;
    49     float floatval = 3.01;
    50     char  charval = 'E';
    51     char *stringval = "E R R O R";
    52 
    53     // Test point #1 Multiple type values placed in the error string
    54     psError(PS_ERR_UNKNOWN, true,
    55             "ALL TYPES intval = %d longval = %lld floatval = %f charval = %c strval = %s",
    56             intval,longval,floatval,charval,stringval);
    57 
    58     // Test point #2 String values in error message
    59     psError(PS_ERR_UNKNOWN, true, "NO VALUES");
    60 
    61     // Test point #3 Empty strings in error message
    62     psError(PS_ERR_UNKNOWN, true, " ");
    63 
    64     return 0;
    65 }
    66 
    67 
    68 static psS32 testError01(void)
    69 {
    70 //    diag("testError01");
    71 
    72     psErrorCode code=PS_ERR_BAD_PARAMETER_VALUE;
    73 
    74     // Verify the return value of psErrorMsg is the psErrorCode passed
    75     ok ( psError(code, true, "Error code = %d", code) == code,
    76          "Failed return value verify.");
    77     skip_start ( psError(code, true, "Error code = %d", code) != code,
    78                  4, "Failed return value verify.");
    79 
    80     psErrorStackPrint(stderr,"ERROR STACK PRINT Test1A");
    81 
    82     // test1B empty string in for name argument
    83     ok ( psError(code+1, true, "Error code = %d", code+1) == code+1,
    84          "Failed return with empty string.");
    85     skip_start ( psError(code+1, true, "Error code = %d", code+1) != code+1,
    86                  3, "Failed return with empty string.");
    87 
    88     psErrorStackPrint(stderr,"ERROR STACK PRINT Test1B");
    89 
    90     // test1D undefined code
    91     ok ( psError(-1, true, "Error code = %d", -1) == -1,
    92          "Failed return with undefined code.");
    93     skip_start ( psError(-1, true, "Error code = %d", -1) != -1,
    94                  2, "Failed return with undefined code.");
    95 
    96     psErrorStackPrint(stderr,"ERROR STACK PRINT Test1D");
    97 
    98     // test1E set psErrorMsg argument to false
    99     ok( psError(code, false, "Error code = %d", code) == code,
    100         "Failed return with false new arg.");
    101     skip_start( psError(code, false, "Error code = %d", code) != code,
    102                 1, "Failed return with false new arg.");
    103 
    104     psErrorStackPrint(stderr,"ERROR STACK PRINT Test1E");
    105 
    106     // test1F psErrorMsg with a error code less then PS_ERR_BASE(256)
    107     ok( psError(9, true, "Errno code = %d", 9) == 9, "Error Code" );
    108 
    109     psErrorStackPrint(stderr,"ERROR STACK PRINT Test1F");
    110 
    111     skip_end();
    112     skip_end();
    113     skip_end();
    114     skip_end();
    115 
    116     return 0;
    117 }
    118 
    119 
    120 static psS32 testError02(void)
    121 {
    122 //    diag("testError02");
    123 
    124     psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE;
    125 
    126     // Generate error message and verify return value
    127     ok (psError(code, true, "Error code = %d", code) == code,
    128         "Failed return value verify.");
    129 
    130     myErrorStackPrint(stderr,"ERROR STACK PRINT Test%dA",2);
    131 
    132     return 0;
    133 }
    134 
    135 
    136 static psS32 testError03(void)
    137 {
    138 //    diag("testError03");
    139 
    140     psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE;
    141     psErr *last = NULL;
    142     psErr *getErr = NULL;
    143 
    144     // Attempt to get last error message with an empty stack verify psErr with code PS_ERR_NONE
    145     last = psErrorLast();
    146     ok(last->code == PS_ERR_NONE,
    147        "psErrorLast did return PS_ERR_NONE for empty stack (%d)", last->code);
    148     skip_start(last->code == PS_ERR_NONE,
    149                9, "psErrorLast did return PS_ERR_NONE for empty stack");
    150 
    151     psFree(last);
    152 
    153     // HEY
    154     // Attempt to get specific error message with empty stack verify psErr with code PS_ERR_NONE
    155     getErr= psErrorGet(2);
    156     ok(getErr->code == PS_ERR_NONE,
    157        "psErrorGet did not return PS_ERR_NONE  for empty stack (%d)", getErr->code);
    158     skip_start(getErr->code == PS_ERR_NONE,
    159                8, "psErrorGet did not return PS_ERR_NONE  for empty stack");
    160 
    161     psFree(getErr);
    162 
    163     // Attempt to get error message with invalid index and an empty stack
    164     getErr= psErrorGet(-1);
    165     ok(getErr->code == PS_ERR_NONE,
    166        "psErrorGet with invalid index/empty stack");
    167     skip_start(getErr->code != PS_ERR_NONE,
    168                7, "psErrorGet with invalid index/empty stack");
    169 
    170     psFree(getErr);
    171 
    172     // Generate three error messages
    173     ok (psError(code, true, "Error code = %d", code) ==  code,
    174         "return value verify-1.");
    175     skip_start (psError(code, true, "Error code = %d", code !=  code),
    176                 6, "return value verify-2.");
    177 
    178     ok (psError((code+1), false, "Error code = %d", (code+1)) == (code+1),
    179         "Failed return value verify-3.");
    180     skip_start (psError((code+1), false, "Error code = %d", (code+1))!=(code+1),
    181                 5, "Failed return value verify-4.");
    182 
    183     ok (psError((code+2), false, "Error code = %d", (code+2)) == (code+2),
    184         "Failed return value verify-5.");
    185     skip_start (psError((code+2), false, "Error code = %d", (code+2))!=(code+2),
    186                 4, "Failed return value verify-6.");
    187 
    188     last = psErrorLast();
    189     getErr= psErrorGet(0);
    190 
    191     // Check that last and get with 0 index are equal
    192     ok(last == getErr, "psErrorGet(0) equal to psErrorLast");
    193     skip_start(last != getErr, 3, "psErrorGet(0) equal to psErrorLast");
    194 
    195     psFree(last);
    196 
    197     // Verify the last error message was returned
    198     ok ( getErr->code == (code+2),
    199          "psErrorLast() did not retrieve last error");
    200     skip_start ( getErr->code != (code+2),
    201                  2, "psErrorLast() did not retrieve last error");
    202 
    203     psFree(getErr);
    204 
    205     // Verify the middle error message can be retrieved
    206     getErr= psErrorGet(1);
    207     ok ( getErr->code == (code+1),
    208          "psErrorGet() did not retrieve proper error");
    209     skip_start ( getErr->code != (code+1),
    210                  1, "psErrorGet() did not retrieve proper error");
    211 
    212     psFree(getErr);
    213 
    214     // Verify the psErrorGet returns NULL if an invalid index is given
    215     getErr= psErrorGet(-1);
    216     ok ( getErr->code == PS_ERR_NONE,
    217          "psErrorGet() did not return PS_ERR_NONE w/ invalid arg");
    218 
    219     skip_end();
    220     skip_end();
    221     skip_end();
    222     skip_end();
    223     skip_end();
    224     skip_end();
    225     skip_end();
    226     skip_end();
    227     skip_end();
    228 
    229     psFree(getErr);
    230 
    231     return 0;
    232 }
    233 
    234 
    235 static psS32 testError04(void)
    236 {
    237     //diag("testError04");
    238 
    239     psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE;
    240     psErr *last = NULL;
    241     psErr *lastAfterClear = NULL;
    242 
    243     // With an attemp error stack call psErrorClear
    244     psErrorClear();
    245 
    246     // Get the last error message and verify PS_ERR_NONE (empty stack)
    247     lastAfterClear = psErrorLast();
    248     ok(lastAfterClear->code == PS_ERR_NONE, "psErrorLast return expected.");
    249     skip_start(lastAfterClear->code != PS_ERR_NONE,
    250                5, "psErrorLast return expected.");
    251 
    252     psFree(lastAfterClear);
    253 
    254     // Generate three error messages to have messages on error stack
    255     ok (psError(code, true, "Error code = %d", code) ==  code,
    256         "Failed return value verify.");
    257     skip_start (psError(code, true, "Error code = %d", code) !=  code,
    258                 4, "Failed return value verify.");
    259 
    260     ok (psError((code+1), false, "Error code = %d", (code+1)) == (code+1),
    261         "Failed return value verify.");
    262     skip_start (psError((code+1), false, "Error code = %d", (code+1))!=(code+1),
    263                 3, "Failed return value verify.");
    264 
    265     ok (psError((code+2), false, "Error code = %d", (code+2)) == (code+2),
    266         "Failed return value verify.");
    267     skip_start (psError((code+2), false, "Error code = %d", (code+2))!=(code+2),
    268                 2, "Failed return value verify.");
    269 
    270     // Get the last error message and verify it has the expected code
    271     last = psErrorLast();
    272     ok(last->code == (code+2), "psErrorLast return expected.");
    273     skip_start(last->code != (code+2), 1, "psErrorLast return expected.");
    274 
    275     psFree(last);
    276 
    277     // Clear the error stack
    278     psErrorClear();
    279 
    280     // Get the last error message after clear and verify is has PS_ERR_NONE code
    281     lastAfterClear = psErrorLast();
    282     ok(lastAfterClear->code == PS_ERR_NONE, "psErrorLast return expected.");
    283 
    284     skip_end();
    285     skip_end();
    286     skip_end();
    287     skip_end();
    288     skip_end();
    289 
    290     psFree(lastAfterClear);
    291 
    292     return 0;
    293 }
    294 
    295 
    296 static psS32 testError05(void)
    297 {
    298     //diag("testError05");
    299 
    300     // Verify the return value of psErrorCodeString
    301     // psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE;
    302     // psLogMsg("tst_psError05", PS_LOG_INFO, psErrorCodeString(code));
    303 
    304     // Verify the return value of psErrorCodeString if code is negative
    305     ok( psErrorCodeString(-1) == NULL, "error string with neg. code");
    306 
    307     return 0;
    308 }
    309 
    310 
    311 static psS32 testErrorRegister(void)
    312 {
    313     //diag("testErrorRegister");
    314 
    315     psS32 numErr = 4;
    316     psErrorDescription errDesc[] = { {PS_ERR_N_ERR_CLASSES+1,"first"},
    317                                      {PS_ERR_N_ERR_CLASSES+2,"second"},
    318                                      {PS_ERR_N_ERR_CLASSES+3,"third"},
    319                                      {PS_ERR_N_ERR_CLASSES+4,"fourth"} };
    320     /*
    321         1. invoke psErrorRegister with a n>1 array of psErrorDescriptions. Verify that:
    322             a. Each error description given is retrievable with psErrorCodeString.
    323     */
    324     psErrorRegister(errDesc,numErr);
    325 
    326     for (psS32 i = 0; i < numErr; i++) {
    327         const char* desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES+1+i);
    328         ok (desc != NULL,
    329             "psErrorCode didn't find registered error code.");
    330 
    331         ok (strcmp(desc,errDesc[i].description) == 0,
    332             "psErrorCode didn't return the proper description.  Got '%s', expected '%s'.", desc,errDesc[i].description);
    333     }
    334 
    335     /*
    336         2. invoke psErrorCodeString with a static/builtin psLib error code. Verify:
    337             a. the result is correct.
    338     */
    339     const char* desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES);
    340     ok (desc != NULL, "psErrorCode didn't find static error code.");
    341     ok (strcmp(desc,"error classes end marker") == 0,
    342         "psErrorCode didn't return the proper description.  Got '%s', expected '%s'.",
    343         desc,"error classes end marker");
    344 
    345     desc = psErrorCodeString(PS_ERR_NONE);
    346     ok (desc != NULL,
    347         "psErrorCode didn't find static error code.");
    348     ok (strcmp(desc,"not an error") == 0,
    349         "psErrorCode didn't return the proper description.  Got '%s', expected '%s'.",
    350         desc,"not an error");
    351 
    352     /*
    353         3. invoke psErrorCodeString with an invalid code. Verify a NULL is returned.
    354     */
    355     desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES+numErr+1);
    356     ok (desc == NULL,
    357         "psErrorCode didn't return a NULL with a bogus input code.");
    358 
    359     /*
    360         4. invoke psErrorRegister with a NULL psErrorDescription. Verify that:
    361             a. the execution does not cease.
    362             b. an appropriate error is generated.
    363     */
    364     psLogMsg(__func__,PS_LOG_INFO,"Following should be an error.");
    365     psErrorClear();
    366     psErrorRegister(NULL,1);
    367     psErr* err = psErrorLast();
    368     ok (err->code == PS_ERR_BAD_PARAMETER_NULL,
    369         "psErrorCode didn't generate proper error code for NULL input.");
    370 
    371     psFree(err);
    372 
    373     /*
    374         5. invoke psErrorRegister with nerror=0. Verify that no error occurs.
    375     */
    376     psErrorClear();
    377     psErrorRegister(errDesc,0);
    378     err = psErrorLast();
    379     ok (err->code == PS_ERR_NONE,
    380         "psErrorCode generated an error for nErrors = 0.");
    381 
    382     psFree(err);
    383     return 0;
    384 }
    385 
    386 
    38736psS32 main( psS32 argc, char* argv[] )
    38837{
    38938    psLogSetFormat("HLNM");
    390     plan_tests(38);
    391 
    392     // XXX: testError03() fails if we put it in sequence with the others.
    393     testError03();
    394     testError00();
    395     testError01();
    396     testError02();
    397     testError04();
    398     testError05();
    399     testErrorRegister();
     39    plan_tests(60);
     40
     41
     42    //psError() tests
     43    {
     44        psS32  intval=1;
     45        psS64 longval = 2;
     46        float floatval = 3.01;
     47        char  charval = 'E';
     48        char *stringval = "E R R O R";
     49
     50        // Multiple type values placed in the error string
     51        // XX: The output is never verified
     52        {
     53            psMemId id = psMemGetId();
     54            psError(PS_ERR_UNKNOWN, true,
     55                    "ALL TYPES intval = %d longval = %lld floatval = %f charval = %c strval = %s",
     56                    intval,longval,floatval,charval,stringval);
     57            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     58        }
     59   
     60
     61        // String values in error message
     62        // XX: The output is never verified
     63        {
     64            psMemId id = psMemGetId();
     65            psError(PS_ERR_UNKNOWN, true, "NO VALUES");
     66            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     67        }
     68
     69
     70        // Empty strings in error message
     71        // XX: The output is never verified
     72        {
     73            psMemId id = psMemGetId();
     74            psError(PS_ERR_UNKNOWN, true, " ");
     75            ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     76        }
     77
     78
     79        // Verify the return value of psErrorMsg is the psErrorCode passed
     80        {
     81            psMemId id = psMemGetId();
     82            psErrorCode code=PS_ERR_BAD_PARAMETER_VALUE;
     83            ok(psError(code, true, "Error code = %d", code) == code, "Failed return value verify.");
     84            psErrorStackPrint(stderr,"ERROR STACK PRINT Test1A");
     85            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     86        }
     87
     88
     89        // test1B empty string in for name argument
     90        {
     91            psMemId id = psMemGetId();
     92            psErrorCode code=PS_ERR_BAD_PARAMETER_VALUE;
     93            ok(psError(code+1, true, "Error code = %d", code+1) == code+1,
     94                 "Failed return with empty string.");
     95            psErrorStackPrint(stderr,"ERROR STACK PRINT Test1B");
     96            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     97        }
     98
     99
     100        // test1D undefined code
     101        {
     102            psMemId id = psMemGetId();
     103            ok(psError(-1, true, "Error code = %d", -1) == -1,
     104                 "Failed return with undefined code.");
     105            psErrorStackPrint(stderr,"ERROR STACK PRINT Test1D");
     106            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     107        }
     108
     109
     110        // test1E set psErrorMsg argument to false
     111        {
     112            psMemId id = psMemGetId();
     113            psErrorCode code=PS_ERR_BAD_PARAMETER_VALUE;
     114            ok(psError(code, false, "Error code = %d", code) == code,
     115                "Failed return with false new arg.");
     116            psErrorStackPrint(stderr,"ERROR STACK PRINT Test1E");
     117            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     118        }
     119
     120
     121        // test1F psErrorMsg with a error code less then PS_ERR_BASE(256)
     122        {
     123            psMemId id = psMemGetId();
     124            ok(psError(9, true, "Errno code = %d", 9) == 9, "Error Code" );
     125            psErrorStackPrint(stderr,"ERROR STACK PRINT Test1F");
     126            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     127        }
     128    }
     129
     130
     131    //testError02()
     132    {
     133        // Generate error message and verify return value
     134        {
     135            psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE;
     136            psMemId id = psMemGetId();
     137            ok(psError(code, true, "Error code = %d", code) == code,
     138                "Failed return value verify.");
     139            myErrorStackPrint(stderr,"ERROR STACK PRINT Test%dA",2);
     140            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     141        }
     142    }
     143
     144
     145    //psErrorGet(), psErrorLast()
     146    {
     147        // Attempt to get last error message with an empty stack verify
     148        // psErr with code PS_ERR_NONE
     149        {
     150            psMemId id = psMemGetId();
     151            psErrorClear();
     152            psErr *last = psErrorLast();
     153            ok(last != NULL, "psErrorLast() returned non-NULL");
     154            skip_start(last == NULL, 1, "Skipping tests because psErrorLast() returned NULL");
     155            ok(last->code == PS_ERR_NONE,
     156              "psErrorLast did return PS_ERR_NONE for empty stack(%d)", last->code);
     157            skip_end();
     158            psFree(last);
     159            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     160        }
     161
     162        // Attempt to get specific error message with empty stack verify
     163        // psErr with code PS_ERR_NONE
     164        {
     165            psMemId id = psMemGetId();
     166            psErr *getErr= psErrorGet(2);
     167            ok(getErr != NULL, "psErrorGet(2) returned non-NULL");
     168            skip_start(getErr == NULL, 1, "Skipping tests because psErrorGet() returned NULL");
     169            ok(getErr->code == PS_ERR_NONE,
     170               "psErrorGet(2) did return PS_ERR_NONE for empty stack(%d)", getErr->code);
     171            skip_end();
     172            psFree(getErr);
     173            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     174        }
     175
     176
     177        // Attempt to get error message with invalid index and an empty stack
     178        {
     179            psMemId id = psMemGetId();
     180            psErr *getErr= psErrorGet(-1);
     181            ok(getErr != NULL, "psErrorGet(-1) returned non-NULL");
     182            skip_start(getErr == NULL, 1, "Skipping tests because psErrorGet(-1) returned NULL");
     183            ok(getErr->code == PS_ERR_NONE, "psErrorGet with invalid index/empty stack");
     184            skip_end();
     185            psFree(getErr);
     186            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     187        }
     188
     189
     190        // Generate three error messages, ensure they are correctly returned by psError()
     191        {
     192            psMemId id = psMemGetId();
     193            psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE;
     194            ok(psError(code, true, "Error code = %d", code) ==  code,
     195                "psError() returned correct error code (example 1)");
     196            ok(psError((code+1), false, "Error code = %d", (code+1)) == (code+1),
     197                "psError() returned correct error code (example 2)");
     198            ok(psError((code+2), false, "Error code = %d", (code+2)) == (code+2),
     199                "psError() returned correct error code (example 3)");
     200   
     201            psErr *last = psErrorLast();
     202            psErr *getErr= psErrorGet(0);
     203   
     204            // Check that last and get with 0 index are equal
     205            ok(last == getErr, "psErrorGet(0) equal to psErrorLast()");
     206            psFree(last);
     207
     208            // Verify the last error message was returned
     209            ok(getErr->code == (code+2), "psErrorLast() did retrieve last error");
     210            psFree(getErr);
     211            psErrorClear();
     212            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     213        }
     214
     215
     216        // Verify the middle error message can be retrieved
     217        {
     218            psMemId id = psMemGetId();
     219            psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE;
     220            psError(code, true, "Error code = %d", code);
     221            psError((code+1), false, "Error code = %d", (code+1));
     222            psError((code+2), false, "Error code = %d", (code+2));
     223            psErr *getErr= psErrorGet(1);
     224            ok(getErr->code == (code+1), "psErrorGet() did not retrieve proper error");
     225            psFree(getErr);
     226            psErrorClear();
     227            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     228        }
     229
     230        // Verify the psErrorGet returns non-NULL PS_ERR_NONE if an invalid index
     231        // is given with non-empty error stack
     232        {
     233            psMemId id = psMemGetId();
     234            psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE;
     235            psError(code, true, "Error code = %d", code);
     236            psError((code+1), false, "Error code = %d", (code+1));
     237            psError((code+2), false, "Error code = %d", (code+2));
     238            psErr *getErr= psErrorGet(-1);
     239            ok(getErr->code == PS_ERR_NONE, "psErrorGet() did not return PS_ERR_NONE w/ invalid arg");
     240            psFree(getErr);
     241            psErrorClear();
     242            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     243        }
     244    }
     245
     246
     247    // psErrorClear()
     248    {
     249        // With an attemp error stack call psErrorClear
     250        {
     251            psMemId id = psMemGetId();
     252            psErrorClear();
     253            // Get the last error message and verify PS_ERR_NONE (empty stack)
     254            psErr *lastAfterClear = psErrorLast();
     255            ok(lastAfterClear->code == PS_ERR_NONE, "psErrorLast return expected.");
     256            psFree(lastAfterClear);
     257            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     258        }
     259
     260
     261        // Generate three error messages to have messages on error stack
     262        {
     263            psMemId id = psMemGetId();
     264            psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE;
     265            ok(psError(code, true, "Error code = %d", code) == code,
     266                "Failed return value verify.");
     267            ok(psError((code+1), false, "Error code = %d", (code+1)) == (code+1),
     268                "Failed return value verify.");
     269            ok(psError((code+2), false, "Error code = %d", (code+2)) == (code+2),
     270                "Failed return value verify.");
     271            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     272        }
     273
     274        // Get the last error message and verify it has the expected code
     275        {
     276            psMemId id = psMemGetId();
     277            psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE;
     278            psErr *last = psErrorLast();
     279            ok(last->code == (code+2), "psErrorLast return expected.");
     280            psFree(last);
     281            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     282        }
     283
     284        // Clear the error stack
     285        {
     286            psMemId id = psMemGetId();
     287            psErrorClear();
     288            // Get the last error message after clear and verify is has PS_ERR_NONE code
     289            psErr *lastAfterClear  = psErrorLast();
     290            ok(lastAfterClear->code == PS_ERR_NONE, "psErrorLast return expected.");
     291            psFree(lastAfterClear);
     292            ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     293        }
     294    }
     295
     296
     297    // psErrorCodeString()
     298    {
     299        // Verify the return value of psErrorCodeString
     300        // psErrorCode code = PS_ERR_BAD_PARAMETER_VALUE;
     301        // psLogMsg("tst_psError05", PS_LOG_INFO, psErrorCodeString(code));
     302
     303        // Verify the return value of psErrorCodeString if code is negative
     304        ok( psErrorCodeString(-1) == NULL, "error string with neg. code");
     305    }
     306
     307
     308    //testErrorRegister()
     309    {
     310        psS32 numErr = 4;
     311        psErrorDescription errDesc[] = { {PS_ERR_N_ERR_CLASSES+1,"first"},
     312                                         {PS_ERR_N_ERR_CLASSES+2,"second"},
     313                                         {PS_ERR_N_ERR_CLASSES+3,"third"},
     314                                         {PS_ERR_N_ERR_CLASSES+4,"fourth"} };
     315        /*
     316            1. invoke psErrorRegister with a n>1 array of psErrorDescriptions. Verify that:
     317                a. Each error description given is retrievable with psErrorCodeString.
     318        */
     319        psErrorRegister(errDesc,numErr);
     320
     321        for (psS32 i = 0; i < numErr; i++) {
     322            const char* desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES+1+i);
     323            ok(desc != NULL,
     324                "psErrorCode didn't find registered error code.");
     325
     326            ok(strcmp(desc,errDesc[i].description) == 0,
     327                "psErrorCode didn't return the proper description.  Got '%s', expected '%s'.", desc,errDesc[i].description);
     328        }
     329
     330        /*
     331            2. invoke psErrorCodeString with a static/builtin psLib error code. Verify:
     332                a. the result is correct.
     333        */
     334        const char* desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES);
     335        ok(desc != NULL, "psErrorCode didn't find static error code.");
     336        ok(strcmp(desc,"error classes end marker") == 0,
     337            "psErrorCode didn't return the proper description.  Got '%s', expected '%s'.",
     338            desc,"error classes end marker");
     339
     340        desc = psErrorCodeString(PS_ERR_NONE);
     341        ok(desc != NULL,
     342            "psErrorCode didn't find static error code.");
     343        ok(strcmp(desc,"not an error") == 0,
     344            "psErrorCode didn't return the proper description.  Got '%s', expected '%s'.",
     345            desc,"not an error");
     346   
     347        /*
     348            3. invoke psErrorCodeString with an invalid code. Verify a NULL is returned.
     349        */
     350        desc = psErrorCodeString(PS_ERR_N_ERR_CLASSES+numErr+1);
     351        ok(desc == NULL,
     352            "psErrorCode didn't return a NULL with a bogus input code.");
     353
     354        /*
     355            4. invoke psErrorRegister with a NULL psErrorDescription. Verify that:
     356                a. the execution does not cease.
     357                b. an appropriate error is generated.
     358        */
     359        psLogMsg(__func__,PS_LOG_INFO,"Following should be an error.");
     360        psErrorClear();
     361        psErrorRegister(NULL,1);
     362        psErr* err = psErrorLast();
     363        ok(err->code == PS_ERR_BAD_PARAMETER_NULL,
     364        "psErrorCode didn't generate proper error code for NULL input.");
     365
     366        psFree(err);
     367
     368        /*
     369            5. invoke psErrorRegister with nerror=0. Verify that no error occurs.
     370        */
     371        psErrorClear();
     372        psErrorRegister(errDesc,0);
     373        err = psErrorLast();
     374        ok(err->code == PS_ERR_NONE,
     375            "psErrorCode generated an error for nErrors = 0.");
     376        psFree(err);
     377    }
    400378}
    401 
    402 
     379//HERE

  • trunk/psLib/test/sys/tap_psLine.c

    r12550 r12781  
    55 *  @author  dRob, MHPCC
    66 *
    7  *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
    8  *  @date  $Date: 2007-03-22 22:47:07 $
     7 *  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
     8 *  @date  $Date: 2007-04-10 21:09:31 $
    99 *
    1010 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    1717#include "string.h"
    1818
    19 static psS32 testLineAlloc(void);
    20 static psS32 testLineInit(void);
    21 static psS32 testLineAdd(void);
    22 static psS32 testLineChk(void);
     19psS32 main( psS32 argc, char* argv[] )
     20{
     21    plan_tests(16);
     22    psLogSetFormat("HLNM");
     23    psLogSetLevel(PS_LOG_INFO);
     24
     25    //testLineAlloc()
     26    {
     27        psMemId id = psMemGetId();
     28        psLine *lineline = NULL;
     29        lineline = psLineAlloc(20);
     30        ok(lineline->NLINE==20, "psLine set NLINE parameter during Allocation");
     31        ok(lineline->Nline == 0, "psLine set Nline parameter during Allocation");
     32        strncpy(lineline->line, "Hello World", 20);
     33        ok(!strncmp(lineline->line, "Hello World", 20),
     34            "psLine was stored a simple string!");
     35        psFree(lineline);
     36        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     37    }
     38
     39    // testLineInit()
     40    {
     41        psMemId id = psMemGetId();
     42        psLine *line = NULL;
     43        //Return false for NULL input
     44        int okay = !psLineInit(line);
     45        ok(okay, "psLineInit.  Expected false for NULL psLine input");
     46        //Allocate a line and return true on Init
     47        line = psLineAlloc(1);
     48        okay = psLineInit(line);
     49        ok(okay, "psLineInit.  Expected true for valid psLine input");
     50        ok(line->NLINE == 1 && line->Nline == 0, "psLineInit returned line parameters.");
     51        psFree(line);
     52        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     53    }
    2354
    2455
    25 psS32 main( psS32 argc, char* argv[] )
    26 {
    27     plan_tests(12);
    28 
    29     testLineAlloc();
    30     testLineInit();
    31     testLineAdd();
    32     testLineChk();
    33 }
    34 
    35 psS32 testLineAlloc(void)
    36 {
    37 //    diag("testLineAlloc");
    38 
    39     psLine *lineline = NULL;
    40     lineline = psLineAlloc(20);
    41 
    42     ok (lineline->NLINE==20, "psLine set NLINE parameter during Allocation");
    43     skip_start (lineline->NLINE != 20,
    44                 2, "psLine set NLINE parameter during Allocation");
    45 
    46     ok (lineline->Nline == 0,
    47         "psLine set Nline parameter during Allocation\n");
    48     skip_start (lineline->Nline == 0,
    49                 1, "psLine set Nline parameter during Allocation\n");
    50 
    51     strncpy(lineline->line, "Hello World", 20);
    52     ok (!strncmp(lineline->line, "Hello World", 20),
    53         "psLine was stored a simple string!\n");
    54 
    55     skip_end();
    56     skip_end();
    57 
    58     psFree(lineline);
    59 
    60     return 0;
    61 }
    62 
    63 psS32 testLineInit(void)
    64 {
    65 //    diag("testLineInit");
    66 
    67     psLine *line = NULL;
    68     //Return false for NULL input
    69     int okay = !psLineInit(line);
    70     ok (okay, "psLineInit.  Expected false for NULL psLine input.\n");
    71     skip_start (!okay, 2, "psLineInit.  Expected NULL psLine input.\n");
    72 
    73     //Allocate a line and return true on Init
    74     line = psLineAlloc(1);
    75     okay = psLineInit(line);
    76     ok( okay, "psLineInit.  Expected true for valid psLine input.\n");
    77     skip_start( !okay, 1, "psLineInit. Expected true for valid psLine input.");
    78 
    79     ok (line->NLINE == 1 && line->Nline == 0,
    80         "psLineInit returned line parameters.");
    81 
    82     skip_end();
    83     skip_end();
    84 
    85     psFree(line);
    86 
    87     return 0;
    88 }
     56    // testLineAdd()
     57    {
     58        psMemId id = psMemGetId();
     59        psLine *line = NULL;
     60        //Return false for NULL input
     61        ok(!psLineAdd(line, "Hello World"),
     62            "psLineAdd.  Expected false for NULL psLine input.");
     63        //Allocate and return true for valid input.
     64        line = psLineAlloc(20);
     65        int okay = psLineAdd(line, "Hello %s", "World");
     66        ok( okay, "psLineAdd.  Expected true for valid psLine input");
     67        ok(line->NLINE == 20 && line->Nline == 11,
     68            "psLineAdd failed to return the correct line parameters");
     69        ok(!strncmp(line->line, "Hello World", 20),
     70            "psLineAdd failed to store the correct line string.");
     71        psFree(line);
     72        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     73    }
    8974
    9075
    91 psS32 testLineAdd(void)
    92 {
    93 //    diag("testLineAdd");
    94 
    95     psLine *line = NULL;
    96     //Return false for NULL input
    97     ok (!psLineAdd(line, "Hello World"),
    98         "psLineAdd.  Expected false for NULL psLine input.");
    99     skip_start(psLineAdd(line, "Hello World"),
    100                3, "psLineAdd.  Expected false for NULL psLine input.");
    101 
    102     //Allocate and return true for valid input.
    103     line = psLineAlloc(20);
    104     int okay = psLineAdd(line, "Hello %s", "World");
    105     ok( okay, "psLineAdd.  Expected true for valid psLine input.\n");
    106     skip_start( !okay, 2, "psLineAdd.Expected true for valid psLine input.\n");
    107 
    108     ok (line->NLINE == 20 && line->Nline == 11,
    109         "psLineAdd failed to return the correct line parameters.\n");
    110     skip_start (line->NLINE != 20 || line->Nline != 11,
    111                 1,"psLineAdd failed to return the correct line parameters.\n");
    112 
    113     ok (!strncmp(line->line, "Hello World", 20),
    114         "psLineAdd failed to store the correct line string.");
    115 
    116     skip_end();
    117     skip_end();
    118     skip_end();
    119 
    120     psFree(line);
    121 
    122     return 0;
     76    // testLineChk()
     77    {
     78        psMemId id = psMemGetId();
     79        psLine *line = NULL;
     80        //Return false for Null input line
     81        ok(!psMemCheckLine(line),
     82            "psMemCheckLine return false for NULL line input");
     83        line = psLineAlloc(1);
     84        ok(psMemCheckLine(line),
     85            "psMemCheckLine return true for valid line input");
     86        psFree(line);
     87        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     88    }
    12389}
    124 
    125 psS32 testLineChk(void)
    126 {
    127 //    diag("testLineChk");
    128 
    129     psLine *line = NULL;
    130     //Return false for Null input line
    131     ok (!psMemCheckLine(line),
    132         "psMemCheckLine return false for NULL line input.\n");
    133     skip_start (psMemCheckLine(line),
    134                 1, "psMemCheckLine return false for NULL line input.\n");
    135 
    136     line = psLineAlloc(1);
    137     ok (psMemCheckLine(line),
    138         "psMemCheckLine return true for valid line input.\n");
    139 
    140     psFree(line);
    141 
    142     skip_end();
    143 
    144     return 0;
    145 }

  • trunk/psLib/test/sys/tap_psMemory.c

    r12513 r12781  
    33*  @brief Contains the tests for psMemory.[ch]
    44*
    5 *
    65*  @author Robert DeSonia, MHPCC
    76*
    8 *  @version $Revision: 1.6 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2007-03-20 03:57:25 $
     7*  @version $Revision: 1.7 $ $Name: not supported by cvs2svn $
     8*  @date $Date: 2007-04-10 21:09:31 $
    109*
    1110*  XXXX: Several tests fail with an Abort and are commented out.
    … …  
    4241    psLogSetFormat("HLNM");
    4342    psLogSetLevel(PS_LOG_INFO);
    44     plan_tests(10);
    45 
    46     void TPFreeReferencedMemory( void );
    47     if (1) {
    48         TPFreeReferencedMemory();
    49     }
    50 
    51     void TPOutOfMemory( void );
     43    plan_tests(46);
     44
     45    // TPFreeReferencedMemory()
     46    {
     47        psMemId id = psMemGetId();
     48        psS32 *mem  = ( psS32* ) psAlloc( 100 * sizeof( psS32 ) );
     49        psS32 ref = psMemGetRefCounter( mem );
     50        ok(ref == 1, "buffer reference count %d.", ref );
     51        skip_start ( ref != 1, 3, "buffer reference count %d.", ref );
     52        psMemIncrRefCounter(mem);
     53        psMemIncrRefCounter(mem);
     54        psMemIncrRefCounter(mem);
     55
     56        ref = psMemGetRefCounter( mem );
     57        ok(ref == 4, "buffer reference count was %d.", ref );
     58        skip_start ( ref != 4, 2, "buffer reference count was %d.", ref );
     59
     60        psMemDecrRefCounter( mem );
     61        psMemDecrRefCounter( mem );
     62
     63        ref = psMemGetRefCounter( mem );
     64        ok(ref == 2, "Found buffer reference count to be %d.", ref );
     65        skip_start ( ref != 2, 1, "Found buffer reference count to be %d.", ref );
     66
     67        psMemDecrRefCounter( mem );
     68        ref = psMemGetRefCounter( mem );
     69        ok(ref == 1, "Found buffer reference count to be %d.", ref );
     70        skip_end();
     71        skip_end();
     72        skip_end();
     73        psFree(mem);
     74        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     75    }
     76
     77
     78    // Upon requesting more memory than is available, psalloc shall call
     79    // the psMemExhaustedCallback.
    5280    // XXXX: Skipping TPOutOfMemory() because of test abort failure
    5381    if (0) {
    54         TPOutOfMemory();
    55     }
    56 
    57     void TPReallocOutOfMemory( void );
     82        psMemId id = psMemGetId();
     83        psS32 *mem[ 100 ];
     84        psMemExhaustedCallback cb;
     85        for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
     86            mem[ lcv ] = NULL;
     87        }
     88        exhaustedCallbackCalled = 0;
     89        cb = psMemExhaustedCallbackSet( TPOutOfMemoryExhaustedCallback );
     90        #ifdef COMMENTED_OUT
     91        // Don't include since intentionally aborts
     92        for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
     93            mem[ lcv ] = ( psS32* ) psAlloc( SIZE_MAX/2 - 1000 );
     94        }
     95        psMemExhaustedCallbackSet( cb );
     96        ok(exhaustedCallbackCalled != 0,
     97             "Called psAlloc with HUGE memory requirement and survived!");
     98        for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
     99            psFree( mem[ lcv ] );
     100        }
     101        #endif
     102        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     103    }
     104
     105
     106
     107    // Bug/Task #562 regression test.  Upon requesting more memory than is available,
     108    // psRealloc shall call the psMemExhaustedCallback.
    58109    // XXXX: Skipping TPReallocOutOfMemory() because of test abort failure
    59110    if (0) {
    60         TPReallocOutOfMemory();
    61     }
    62 
    63     void TPCheckBufferPositive( void );
    64     if (1) {
    65         TPCheckBufferPositive();
    66     }
    67 
    68     void TPrealloc( void );
    69     if (1) {
    70         TPrealloc();
    71     }
    72 
    73     void TPallocCallback( void );
    74     if (1) {
    75         TPallocCallback();
    76     }
    77 
    78     void TPcheckLeaks( void );
     111        psMemId id = psMemGetId();
     112        psS32 *mem[ 100 ];
     113        psMemExhaustedCallback cb;
     114        for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
     115            mem[ lcv ] = NULL;
     116        }
     117        exhaustedCallbackCalled = 0;
     118        cb = psMemExhaustedCallbackSet( TPOutOfMemoryExhaustedCallback );
     119        for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
     120            mem[ lcv ] = ( psS32* ) psAlloc( 10 );
     121        }
     122        for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
     123            mem[ lcv ] = ( psS32* ) psRealloc( mem[ lcv ], SIZE_MAX/2 - 1000 );
     124        }
     125        psMemExhaustedCallbackSet( cb );
     126        ok(exhaustedCallbackCalled != 0,
     127             "Called psRealloc with HUGE memory requirement and survived in %s!", __func__ );
     128        for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
     129            psFree( mem[ lcv ] );
     130        }
     131        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     132    }
     133
     134
     135    // psAlloc shall allocate memory blocks writeable by caller.
     136    {
     137        psMemId id = psMemGetId();
     138        const psS32 size = 100;
     139        psS32 *mem = ( psS32* ) psAlloc( size * sizeof( psS32 ) );
     140        ok(mem != NULL, "psAlloc returned non-NULL value" );
     141        for ( psS32 index = 0;index < size;index++ ) {
     142            mem[ index ] = index;
     143        }
     144        psS32 failed = 0;
     145        for ( psS32 index = 0;index < size;index++ ) {
     146            if ( mem[ index ] != index ) {
     147                failed++;
     148            }
     149        }
     150        ok(failed == 0, "mem legit" );
     151        psFree( mem );
     152        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     153    }
     154
     155
     156    // psRealloc shall increase/decrease memory buffer while preserving contents
     157    {
     158        psMemId id = psMemGetId();
     159        const psS32 initialSize = 100;
     160        // allocate buffer with known values.
     161        psS32 *mem1 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
     162        psS32 *mem2 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
     163        psS32 *mem3 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
     164        for ( psS32 lcv = 0;lcv < initialSize;lcv++ ) {
     165            mem1[lcv] = mem2[lcv] = mem3[lcv] = lcv;
     166        }
     167        psMemCheckCorruption(stderr, false);
     168        // realloc to 2x
     169        mem1 = ( psS32* ) psRealloc( mem1, 2 * initialSize * sizeof( psS32 ) );
     170        mem2 = ( psS32* ) psRealloc( mem2, 2 * initialSize * sizeof( psS32 ) );
     171        mem3 = ( psS32* ) psRealloc( mem3, 2 * initialSize * sizeof( psS32 ) );
     172        // check values of initial block
     173        int error = 0;
     174        for ( psS32 i = 0;i < initialSize;i++ ) {
     175            if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) {
     176                error = 1;
     177                break;
     178            }
     179        }
     180        ok(error==0, "Realloc preserve the contents with expanding buffer");
     181        psMemCheckCorruption(stderr, false);
     182        // realloc to 1/2 initial value.
     183        mem1 = ( psS32* ) psRealloc( mem1, ( initialSize / 2 ) * sizeof( psS32 ) );
     184        mem2 = ( psS32* ) psRealloc( mem2, ( initialSize / 2 ) * sizeof( psS32 ) );
     185        mem3 = ( psS32* ) psRealloc( mem3, ( initialSize / 2 ) * sizeof( psS32 ) );
     186        // check values of initial block
     187        error = 0;
     188        for ( psS32 i = 0;i < initialSize / 2;i++ ) {
     189            if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) {
     190                error = 1;
     191                break;
     192            }
     193        }
     194        ok(error==0, "Realloc preserved the contents with shrinking buffer");
     195        psFree( mem1 );
     196        psFree( mem2 );
     197        psFree( mem3 );
     198        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     199    }
     200
     201
     202    // TPallocCallback()
     203    {
     204        psMemId id = psMemGetId();
     205        psS32 currentId = psMemGetId();
     206        const psS32 initialSize = 100;
     207        psS32 mark;
     208        allocCallbackCalled = 0;
     209        freeCallbackCalled = 0;
     210        psMemAllocCallbackSet( memAllocCallback );
     211        psMemFreeCallbackSet( memFreeCallback );
     212        psMemAllocCallbackSetID( currentId + 1 );
     213        psMemFreeCallbackSetID( currentId + 1 );
     214        // allocate buffer with known values.
     215        psS32 *mem1 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
     216        psS32 *mem2 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
     217        psS32 *mem3 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
     218        psFree(mem1);
     219        psFree(mem2);
     220        psFree(mem3);
     221        ok(allocCallbackCalled == 2 && freeCallbackCalled == 2,
     222            "alloc/free callbacks called the proper number of times" );
     223        allocCallbackCalled = 0;
     224        freeCallbackCalled = 0;
     225        mark = psMemGetId();
     226        mem1 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
     227        psMemAllocCallbackSetID( mark );
     228        mem1 = ( psS32* ) psRealloc( mem1, initialSize * 2 * sizeof( psS32 ) );
     229        psFree( mem1 );
     230        ok(allocCallbackCalled == 2,
     231             "realloc callbacks were called the proper number of times" );
     232        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     233    }
     234
     235
     236    // TPcheckLeaks()
    79237    // XXXX: Skipping TPcheckLeaks() because of test abort failure
    80238    if (0) {
    81         TPcheckLeaks();
    82     }
     239        const psS32 numBuffers = 5;
     240        psS32* buffers[ 5 ];
     241        psS32 lcv;
     242        psS32 currentId = psMemGetId();
     243        psMemBlock** blks;
     244        psS32 nLeaks = 0;
     245        psS32 lineMark = 0;
     246
     247        for ( lcv = 0;lcv < numBuffers;lcv++ ) {
     248            lineMark = __LINE__ + 1;
     249            buffers[ lcv ] = psAlloc( sizeof( psS32 ) );
     250        }
     251        for ( lcv = 1;lcv < numBuffers;lcv++ ) {
     252            psFree( buffers[ lcv ] );
     253        }
     254        nLeaks = psMemCheckLeaks( currentId, &blks, stderr, false );
     255        ok(nLeaks == 1, "psMemCheckLeaks found %d leaks", nLeaks );
     256        ok(blks[ 0 ] ->lineno == lineMark,
     257             "psMemCheckLeaks found a leak other than the expected one (line %d vs %d)", lineMark, blks[ 0 ] ->lineno );
     258        psFree( buffers[ 0 ] );
     259        psFree( blks );
     260        psMemCheckLeaks(currentId,NULL,stderr, false);
     261        for ( lcv = 0;lcv < numBuffers;lcv++ ) {
     262            lineMark = __LINE__ + 1;
     263            buffers[ lcv ] = psAlloc( sizeof( psS32 ) );
     264        }
     265        for ( lcv = 0;lcv < numBuffers - 1;lcv++ ) {
     266            psFree( buffers[ lcv ] );
     267        }
     268        nLeaks = psMemCheckLeaks( currentId, &blks, stderr, false );
     269        ok(nLeaks == 1, "psMemCheckLeaks found %d leaks.", nLeaks );
     270        ok(blks[ 0 ] ->lineno == lineMark, "psMemCheckLeaks found leaks");
     271        psFree( buffers[ 4 ] );
     272        psFree( blks );
     273        for ( lcv = 0;lcv < numBuffers;lcv++ ) {
     274            lineMark = __LINE__ + 1;
     275            buffers[ lcv ] = psAlloc( sizeof( psS32 ) );
     276        }
     277        for ( lcv = 0;lcv < numBuffers;lcv++ ) {
     278            if ( lcv % 2 == 0 ) {
     279                psFree( buffers[ lcv ] );
     280            }
     281        }
     282        nLeaks = psMemCheckLeaks( currentId, &blks, stderr, false );
     283        ok(nLeaks == 2, "psMemCheckLeaks found %d leaks.", nLeaks);
     284        ok(blks[ 0 ] ->lineno == lineMark,
     285             "psMemCheckLeaks found a leak other than the expected." );
     286        psFree(blks);
     287        psFree(buffers[1]);
     288        psFree(buffers[3]);
     289    }
     290
    83291
    84292    void TPmultipleFree( void );
    … …  
    87295        TPmultipleFree();
    88296    }
    89 }
    90 
    91 // Testpoint #449, psAlloc shall allocate memory blocks writeable by caller.
    92 void TPCheckBufferPositive( void )
    93 {
    94 //    diag("TPCheckBufferPositive");
    95 
    96     psS32 * mem;
    97     const psS32 size = 100;
    98     psS32 failed = 0;
    99 
    100     mem = ( psS32* ) psAlloc( size * sizeof( psS32 ) );
    101     ok ( mem != NULL, "psAlloc returned non-NULL value" );
    102 
    103     for ( psS32 index = 0;index < size;index++ ) {
    104         mem[ index ] = index;
    105     }
    106 
    107     for ( psS32 index = 0;index < size;index++ ) {
    108         if ( mem[ index ] != index ) {
    109             failed++;
    110         }
    111     }
    112     ok( failed == 0, "mem legit" );
    113 
    114     psFree( mem );
    115 }
    116 
    117 void TPFreeReferencedMemory( void )
    118 {
    119     // diag("TPFreeReferencedMemory");
    120 
    121     // create memory
    122     psS32 * mem;
    123     psS32 ref = 0;
    124 
    125     mem = ( psS32* ) psAlloc( 100 * sizeof( psS32 ) );
    126 
    127     ref = psMemGetRefCounter( mem );
    128     ok ( ref == 1, "buffer reference count %d.", ref );
    129     skip_start ( ref != 1, 3, "buffer reference count %d.", ref );
    130 
    131     psMemIncrRefCounter( mem );
    132     psMemIncrRefCounter( mem );
    133     psMemIncrRefCounter( mem );
    134 
    135     ref = psMemGetRefCounter( mem );
    136     ok ( ref == 4, "buffer reference count was %d.", ref );
    137     skip_start ( ref != 4, 2, "buffer reference count was %d.", ref );
    138 
    139     psMemDecrRefCounter( mem );
    140     psMemDecrRefCounter( mem );
    141 
    142     ref = psMemGetRefCounter( mem );
    143     ok ( ref == 2, "Found buffer reference count to be %d.", ref );
    144     skip_start ( ref != 2, 1, "Found buffer reference count to be %d.", ref );
    145 
    146     psMemDecrRefCounter( mem );
    147 
    148     ref = psMemGetRefCounter( mem );
    149     ok ( ref == 1, "Found buffer reference count to be %d.", ref );
    150 
    151     skip_end();
    152     skip_end();
    153     skip_end();
    154 
    155     psFree( mem );
    156 }
    157 
    158 // Bug/Task #562 regression test.  Upon requesting more memory than is available, psRealloc shall call
    159 // the psMemExhaustedCallback.
    160 void TPReallocOutOfMemory( void )
    161 {
    162     // diag("TPReallocOutOfMemory");
    163 
    164     psS32 * mem[ 100 ];
    165     psMemExhaustedCallback cb;
    166 
    167     for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
    168         mem[ lcv ] = NULL;
    169     }
    170 
    171     exhaustedCallbackCalled = 0;
    172 
    173     cb = psMemExhaustedCallbackSet( TPOutOfMemoryExhaustedCallback );
    174 
    175     for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
    176         mem[ lcv ] = ( psS32* ) psAlloc( 10 );
    177     }
    178 
    179     for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
    180         mem[ lcv ] = ( psS32* ) psRealloc( mem[ lcv ], SIZE_MAX/2 - 1000 );
    181     }
    182 
    183     psMemExhaustedCallbackSet( cb );
    184 
    185     ok ( exhaustedCallbackCalled != 0,
    186          "Called psRealloc with HUGE memory requirement and survived in %s!", __func__ );
    187 
    188     for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
    189         psFree( mem[ lcv ] );
    190     }
    191 }
    192 
    193 
    194 // Testpoint #450,  Upon requesting more memory than is available, psalloc shall call
    195 // the psMemExhaustedCallback.
    196 void TPOutOfMemory( void )
    197 {
    198     // diag("TPOutOfMemory");
    199 
    200     psS32 * mem[ 100 ];
    201     psMemExhaustedCallback cb;
    202 
    203     for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
    204         mem[ lcv ] = NULL;
    205     }
    206 
    207     exhaustedCallbackCalled = 0;
    208     cb = psMemExhaustedCallbackSet( TPOutOfMemoryExhaustedCallback );
    209 
    210     #ifdef COMMENTED_OUT
    211     // Don't include since intentionally aborts
    212 
    213     for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
    214         mem[ lcv ] = ( psS32* ) psAlloc( SIZE_MAX/2 - 1000 );
    215     }
    216 
    217     psMemExhaustedCallbackSet( cb );
    218 
    219     ok ( exhaustedCallbackCalled != 0,
    220          "Called psAlloc with HUGE memory requirement and survived!");
    221 
    222     for ( psS32 lcv = 0; lcv < 100; lcv++ ) {
    223         psFree( mem[ lcv ] );
    224     }
    225     #endif
    226 }
    227 
    228 
    229 // Testpoint #451,  psRealloc shall increase/decrease memory buffer while preserving contents
    230 void TPrealloc( void )
    231 {
    232     // diag("TPrealloc");
    233 
    234     psS32 * mem1;
    235     psS32* mem2;
    236     psS32* mem3;
    237     const psS32 initialSize = 100;
    238 
    239     // allocate buffer with known values.
    240     mem1 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
    241     mem2 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
    242     mem3 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
    243     for ( psS32 lcv = 0;lcv < initialSize;lcv++ ) {
    244         mem1[ lcv ] = mem2[ lcv ] = mem3[ lcv ] = lcv;
    245     }
    246 
    247     psMemCheckCorruption(stderr, false);
    248 
    249     // realloc to 2x
    250     mem1 = ( psS32* ) psRealloc( mem1, 2 * initialSize * sizeof( psS32 ) );
    251     mem2 = ( psS32* ) psRealloc( mem2, 2 * initialSize * sizeof( psS32 ) );
    252     mem3 = ( psS32* ) psRealloc( mem3, 2 * initialSize * sizeof( psS32 ) );
    253 
    254     // check values of initial block
    255     int error = 0;
    256     for ( psS32 i = 0;i < initialSize;i++ ) {
    257         if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) {
    258             error = 1;
    259             break;
    260         }
    261     }
    262     ok(error==0, "Realloc preserve the contents with expanding buffer");
    263 
    264     psMemCheckCorruption(stderr, false);
    265 
    266     // realloc to 1/2 initial value.
    267     mem1 = ( psS32* ) psRealloc( mem1, ( initialSize / 2 ) * sizeof( psS32 ) );
    268     mem2 = ( psS32* ) psRealloc( mem2, ( initialSize / 2 ) * sizeof( psS32 ) );
    269     mem3 = ( psS32* ) psRealloc( mem3, ( initialSize / 2 ) * sizeof( psS32 ) );
    270 
    271     // check values of initial block
    272     error = 0;
    273     for ( psS32 i = 0;i < initialSize / 2;i++ ) {
    274         if ( mem1[ i ] != i || mem2[ i ] != i || mem3[ i ] != i ) {
    275             error = 1;
    276             break;
    277         }
    278     }
    279     ok(error==0, "Realloc preserved the contents with shrinking buffer");
    280 
    281     psFree( mem1 );
    282     psFree( mem2 );
    283     psFree( mem3 );
    284 }
    285 
    286 
    287 void TPallocCallback( void )
    288 {
    289     // diag("TPallocCallback");
    290 
    291     psS32 * mem1;
    292     psS32* mem2;
    293     psS32* mem3;
    294     psS32 currentId = psMemGetId();
    295     const psS32 initialSize = 100;
    296     psS32 mark;
    297 
    298     allocCallbackCalled = 0;
    299     freeCallbackCalled = 0;
    300     psMemAllocCallbackSet( memAllocCallback );
    301     psMemFreeCallbackSet( memFreeCallback );
    302 
    303     psMemAllocCallbackSetID( currentId + 1 );
    304     psMemFreeCallbackSetID( currentId + 1 );
    305 
    306     // allocate buffer with known values.
    307     mem1 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
    308     mem2 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
    309     mem3 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
    310 
    311     psFree( mem1 );
    312     psFree( mem2 );
    313     psFree( mem3 );
    314 
    315     ok( allocCallbackCalled == 2 && freeCallbackCalled == 2,
    316         "alloc/free callbacks called the proper number of times" );
    317     skip_start( allocCallbackCalled != 2 || freeCallbackCalled != 2,
    318                 1, "alloc/free callbacks called the proper number of times" );
    319 
    320     allocCallbackCalled = 0;
    321     freeCallbackCalled = 0;
    322 
    323     mark = psMemGetId();
    324 
    325     mem1 = ( psS32* ) psAlloc( initialSize * sizeof( psS32 ) );
    326 
    327     psMemAllocCallbackSetID( mark );
    328 
    329     mem1 = ( psS32* ) psRealloc( mem1, initialSize * 2 * sizeof( psS32 ) );
    330 
    331     psFree( mem1 );
    332 
    333     ok ( allocCallbackCalled == 2,
    334          "realloc callbacks were called the proper number of times" );
    335 
    336     skip_end();
    337 }
    338 
    339 
    340 void TPcheckLeaks( void )
    341 {
    342     const psS32 numBuffers = 5;
    343     psS32* buffers[ 5 ];
    344     psS32 lcv;
    345     psS32 currentId = psMemGetId();
    346     psMemBlock** blks;
    347     psS32 nLeaks = 0;
    348     psS32 lineMark = 0;
    349 
    350     for ( lcv = 0;lcv < numBuffers;lcv++ ) {
    351         lineMark = __LINE__ + 1;
    352         buffers[ lcv ] = psAlloc( sizeof( psS32 ) );
    353     }
    354 
    355     for ( lcv = 1;lcv < numBuffers;lcv++ ) {
    356         psFree( buffers[ lcv ] );
    357     }
    358 
    359     nLeaks = psMemCheckLeaks( currentId, &blks, stderr, false );
    360 
    361     ok ( nLeaks == 1, "psMemCheckLeaks found %d leaks", nLeaks );
    362     skip_start ( nLeaks != 1, 5, "psMemCheckLeaks found %d leaks", nLeaks );
    363 
    364     ok ( blks[ 0 ] ->lineno == lineMark,
    365          "psMemCheckLeaks found a leak other than the expected one (line %d vs %d)", lineMark, blks[ 0 ] ->lineno );
    366     skip_start ( blks[ 0 ] ->lineno != lineMark,
    367                  4,"psMemCheckLeaks found a leak other than the expected one (line %d vs %d)", lineMark, blks[ 0 ] ->lineno );
    368 
    369     psFree( buffers[ 0 ] );
    370     psFree( blks );
    371 
    372     psMemCheckLeaks(currentId,NULL,stderr, false);
    373 
    374     for ( lcv = 0;lcv < numBuffers;lcv++ ) {
    375         lineMark = __LINE__ + 1;
    376         buffers[ lcv ] = psAlloc( sizeof( psS32 ) );
    377     }
    378 
    379     for ( lcv = 0;lcv < numBuffers - 1;lcv++ ) {
    380         psFree( buffers[ lcv ] );
    381     }
    382 
    383     nLeaks = psMemCheckLeaks( currentId, &blks, stderr, false );
    384 
    385     ok ( nLeaks == 1, "psMemCheckLeaks found %d leaks.", nLeaks );
    386     skip_start ( nLeaks != 1, 3, "psMemCheckLeaks found %d leaks.", nLeaks );
    387 
    388     ok ( blks[ 0 ] ->lineno == lineMark, "psMemCheckLeaks found leaks");
    389     skip_start ( blks[ 0 ] ->lineno==lineMark,2,"psMemCheckLeaks found leaks");
    390 
    391     psFree( buffers[ 4 ] );
    392     psFree( blks );
    393 
    394     for ( lcv = 0;lcv < numBuffers;lcv++ ) {
    395         lineMark = __LINE__ + 1;
    396         buffers[ lcv ] = psAlloc( sizeof( psS32 ) );
    397     }
    398 
    399     for ( lcv = 0;lcv < numBuffers;lcv++ ) {
    400         if ( lcv % 2 == 0 ) {
    401             psFree( buffers[ lcv ] );
    402         }
    403     }
    404 
    405     nLeaks = psMemCheckLeaks( currentId, &blks, stderr, false );
    406 
    407     ok ( nLeaks == 2, "psMemCheckLeaks found %d leaks.", nLeaks);
    408     skip_start ( nLeaks != 2, 1, "psMemCheckLeaks found %d leaks.", nLeaks);
    409 
    410     ok ( blks[ 0 ] ->lineno == lineMark,
    411          "psMemCheckLeaks found a leak other than the expected." );
    412 
    413     skip_end();
    414     skip_end();
    415     skip_end();
    416     skip_end();
    417     skip_end();
    418 
    419     psFree( blks );
    420     psFree( buffers[ 1 ] );
    421     psFree( buffers[ 3 ] );
     297
     298//HERE
     299    // memCheckTypes()
     300    if (1) {
     301        psMemId id = psMemGetId();
     302        psArray *negative = psArrayAlloc(2);
     303        psMetadata *neg = psMetadataAlloc();
     304
     305        psArray *array = psArrayAlloc(100);
     306        int okay = psMemCheckType(PS_DATA_ARRAY,array);
     307        if (!okay) {
     308            psFree(array);
     309        }
     310        ok(okay, "psMemCheckArray in memCheckType");
     311
     312        ok(!psMemCheckType(PS_DATA_ARRAY, neg), "psMemCheckType with metadata input");
     313        psFree(array);
     314
     315        psBitSet *bits;
     316        bits = psBitSetAlloc(100);
     317        okay = psMemCheckType(PS_DATA_BITSET, bits);
     318        if (!okay )
     319            psFree(bits);
     320        ok(okay, "psMemCheckBitSet in memCheckType");
     321        ok(!psMemCheckType(PS_DATA_BITSET, negative), "psMemCheckType on psArray");
     322        psFree(bits);
     323
     324        psCube *cube;
     325        cube = psCubeAlloc();
     326        okay = psMemCheckType(PS_DATA_CUBE, cube);
     327        if (!okay )
     328            psFree(cube);
     329        ok(okay, "psMemCheckCube in memCheckType");
     330        psFree(cube);
     331
     332        psFits *fits;
     333        fits = psFitsOpen("test.fits","w");
     334        psImage* img = psImageAlloc(16,16,PS_TYPE_F32);
     335        psFitsWriteImage(fits,NULL,img,1,NULL);
     336        psFree(img);
     337        okay = psMemCheckType(PS_DATA_FITS, fits);
     338        if (!okay )
     339            psFree(fits);
     340        ok(okay, "psMemCheckFits in memCheckType");
     341        psFitsClose(fits);
     342
     343        psHash *hash;
     344        hash = psHashAlloc(100);
     345        okay = psMemCheckType(PS_DATA_HASH, hash);
     346        if (!okay )
     347            psFree(hash);
     348        ok(okay, "psMemCheckHash in memCheckType");
     349        psFree(hash);
     350
     351        psHistogram *histogram;
     352        histogram = psHistogramAlloc(1.1, 2.2, 2);
     353        okay = psMemCheckType(PS_DATA_HISTOGRAM, histogram);
     354        if (!okay )
     355            psFree(histogram);
     356        ok(okay, "psMemCheckHistogram in memCheckType");
     357        psFree(histogram);
     358
     359        psImage *image;
     360        image = psImageAlloc(5, 5, PS_TYPE_F32);
     361        okay = psMemCheckType(PS_DATA_IMAGE, image);
     362        if (!okay )
     363            psFree(image);
     364        ok(okay, "psMemCheckImage in memCheckType");
     365        psFree(image);
     366
     367        psKernel *kernel;
     368        kernel = psKernelAlloc(0, 1, 0, 1);
     369        okay = psMemCheckType(PS_DATA_KERNEL, kernel);
     370        if (!okay )
     371            psFree(kernel);
     372        ok(okay, "psMemCheckKernel in memCheckType");
     373        psFree(kernel);
     374
     375        psList *list;
     376        list = psListAlloc(NULL);
     377        okay = psMemCheckType(PS_DATA_LIST, list);
     378        if (!okay )
     379            psFree(list);
     380        ok(okay, "psMemCheckList in memCheckType");
     381        psFree(list);
     382
     383        psLookupTable *lookup;
     384        char *file = "tableF32.dat";
     385        char *format = "\%f \%lf \%d \%ld";
     386        lookup = psLookupTableAlloc(file, format, 10);
     387        okay = psMemCheckType(PS_DATA_LOOKUPTABLE, lookup);
     388        if (!okay )
     389            psFree(lookup);
     390        ok(okay, "psMemCheckLookupTable in memCheckType");
     391        psFree(lookup);
     392
     393        psMetadata *metadata;
     394        metadata = psMetadataAlloc();
     395        okay = psMemCheckType(PS_DATA_METADATA, metadata);
     396        if (!okay )
     397            psFree(metadata);
     398        ok(okay, "psMemCheckMetadata in memCheckType");
     399        psFree(metadata);
     400
     401        psMetadataItem *metaItem;
     402        metaItem = psMetadataItemAlloc("name", PS_DATA_S32, "COMMENT", 1);
     403        okay = psMemCheckType(PS_DATA_METADATAITEM, metaItem);
     404        if (!okay )
     405            psFree(metaItem);
     406        ok(okay, "psMemCheckMetadataItem in memCheckType");
     407        psFree(metaItem);
     408
     409        psMinimization *min;
     410        min = psMinimizationAlloc(3, 0.1);
     411        okay = psMemCheckType(PS_DATA_MINIMIZATION, min);
     412        if (!okay )
     413            psFree(min);
     414        ok(okay, "psMemCheckMinimization in memCheckType");
     415        psFree(min);
     416
     417        psPixels *pixels;
     418        pixels = psPixelsAlloc(100);
     419        okay = psMemCheckType(PS_DATA_PIXELS, pixels);
     420        if (!okay )
     421            psFree(pixels);
     422        ok(okay, "psMemCheckPixels in memCheckType");
     423        psFree(pixels);
     424
     425        psPlane *plane;
     426        plane = psPlaneAlloc();
     427        okay = psMemCheckType(PS_DATA_PLANE, plane);
     428        if (!okay )
     429            psFree(plane);
     430        ok(okay, "psMemCheckPlane in memCheckType.");
     431        psFree(plane);
     432
     433        psPlaneDistort *planeDistort;
     434        planeDistort = psPlaneDistortAlloc(1, 1, 1, 1);
     435        okay =  psMemCheckType(PS_DATA_PLANEDISTORT, planeDistort);
     436        if (!okay )
     437            psFree(planeDistort);
     438        ok(okay, "psMemCheckPlaneDistort in memCheckType.");
     439        psFree(planeDistort);
     440
     441        psPlaneTransform *planeTransform;
     442        planeTransform = psPlaneTransformAlloc(1, 1);
     443        okay = psMemCheckType(PS_DATA_PLANETRANSFORM, planeTransform);
     444        if (!okay )
     445            psFree(planeTransform);
     446        ok(okay, "psMemCheckPlaneTransform in memCheckType");
     447        psFree(planeTransform);
     448   
     449        psPolynomial1D *poly1;
     450        poly1 = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 2);
     451        okay = psMemCheckType(PS_DATA_POLYNOMIAL1D, poly1);
     452        if (!okay )
     453            psFree(poly1);
     454        ok(okay, "psMemCheckPolynomial1D in memCheckType");
     455        psFree(poly1);
     456   
     457        psPolynomial2D *poly2;
     458        poly2 = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 2, 1);
     459        okay = psMemCheckType(PS_DATA_POLYNOMIAL2D, poly2);
     460        if (!okay )
     461            psFree(poly2);
     462        ok(okay, "psMemCheckPolynomial2D in memCheckType");
     463        psFree(poly2);
     464   
     465        psPolynomial3D *poly3;
     466        poly3 = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 2, 1, 1);
     467        okay = psMemCheckType(PS_DATA_POLYNOMIAL3D, poly3);
     468        if (!okay )
     469            psFree(poly3);
     470        ok(okay, "psMemCheckPolynomial3D in memCheckType");
     471        psFree(poly3);
     472   
     473        psPolynomial4D *poly4;
     474        poly4 = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 2, 1, 2, 1);
     475        okay = psMemCheckType(PS_DATA_POLYNOMIAL4D, poly4);
     476        if (!okay )
     477            psFree(poly4);
     478        ok(okay, "psMemCheckPolynomial4D in memCheckType");
     479        psFree(poly4);
     480   
     481        psProjection *proj;
     482        proj = psProjectionAlloc(1, 1, 2.1, 2.1, PS_PROJ_TAN);
     483        okay = psMemCheckType(PS_DATA_PROJECTION, proj);
     484        if (!okay )
     485            psFree(proj);
     486        ok(okay, "psMemCheckProjection in memCheckType.");
     487        psFree(proj);
     488   
     489        psScalar *scalar;
     490        psF64 f64 = 1.1;
     491        scalar = psScalarAlloc(f64, PS_TYPE_F64);
     492        okay = psMemCheckType(PS_DATA_SCALAR, scalar);
     493        if (!okay )
     494            psFree(scalar);
     495        ok(okay, "psMemCheckScalar in memCheckType");
     496        psFree(scalar);
     497   
     498        psSphere *sphere;
     499        sphere = psSphereAlloc();
     500        okay = psMemCheckType(PS_DATA_SPHERE, sphere);
     501        if (!okay )
     502            psFree(sphere);
     503        ok(okay, "psMemCheckSphere in memCheckType");
     504        psFree(sphere);
     505   
     506        psSphereRot *sphereRot;
     507        sphereRot = psSphereRotAlloc(0, 0, 20);
     508        okay = psMemCheckType(PS_DATA_SPHEREROT, sphereRot);
     509        if (!okay )
     510            psFree(sphereRot);
     511        ok(okay, "psMemCheckSphereRot in memCheckType");
     512        psFree(sphereRot);
     513   
     514        psSpline1D *spline;
     515        spline = psSpline1DAlloc(2, 1, 0, 2);
     516        okay = psMemCheckType(PS_DATA_SPLINE1D, spline);
     517        if (!okay )
     518            psFree(spline);
     519        ok(okay, "psMemCheckSpline1D in memCheckType");
     520        psFree(spline);
     521   
     522        psStats *stats;
     523        stats = psStatsAlloc(PS_STAT_MAX);
     524        okay = psMemCheckType(PS_DATA_STATS, stats);
     525        if (!okay )
     526            psFree(stats);
     527        ok(okay, "psMemCheckStats in memCheckType");
     528        psFree(stats);
     529   
     530        psTime *time;
     531        time = psTimeAlloc(PS_TIME_UT1);
     532        okay = psMemCheckType(PS_DATA_TIME, time);
     533        if (!okay )
     534            psFree(time);
     535        ok(okay, "psMemCheckTime in memCheckType");
     536        psFree(time);
     537   
     538        psVector *vector;
     539        vector = psVectorAlloc(100, PS_TYPE_F32);
     540        okay = psMemCheckType(PS_DATA_VECTOR, vector);
     541        ok(okay, "psMemCheckVector in memCheckType");
     542        psFree(vector);
     543        psFree(negative);
     544        psFree(neg);
     545        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     546    }
    422547}
    423548
    … …  
    455580    psFree( buffer );
    456581
    457     ok ( corruptions == 1,
     582    ok(corruptions == 1,
    458583         "Expected one memory corruption but found %d", corruptions );
    459     skip_start ( corruptions != 1,
    460                  1, "Expected one memory corruption but found %d", corruptions );
    461 
    462     ok ( problemCallbackCalled == 1, "The memProblemCallback was invoked" );
    463 
    464     skip_end();
     584    ok(problemCallbackCalled == 1, "The memProblemCallback was invoked" );
    465585}
    466586#endif
    … …  
    500620}
    501621
    502 psS32 memCheckTypes( void )
    503 {
    504     psArray *negative;
    505     negative = psArrayAlloc(2);
    506     psMetadata *neg;
    507     neg = psMetadataAlloc();
    508 
    509     psArray *array;
    510     array = psArrayAlloc(100);
    511     int okay = psMemCheckType(PS_DATA_ARRAY,array);
    512     if ( ! okay )
    513         psFree(array);
    514     ok ( okay, "psMemCheckArray in memCheckType");
    515     skip_start( ! okay, 28, "psMemCheckArray in memCheckType");
    516 
    517     ok ( psMemCheckType(PS_DATA_ARRAY, neg), "psMemCheckArray in memCheckType");
    518     psFree(array);
    519 
    520     psBitSet *bits;
    521     bits = psBitSetAlloc(100);
    522     okay = psMemCheckType(PS_DATA_BITSET, bits);
    523     if ( ! okay )
    524         psFree(bits);
    525     ok ( okay, "psMemCheckBitSet in memCheckType");
    526     skip_start ( !okay, 27, "psMemCheckBitSet in memCheckType");
    527 
    528     ok ( psMemCheckType(PS_DATA_BITSET, negative),
    529          "psMemCheckBitSet in memCheckType");
    530     psFree(bits);
    531 
    532     psCube *cube;
    533     cube = psCubeAlloc();
    534     okay = psMemCheckType(PS_DATA_CUBE, cube);
    535     if ( ! okay )
    536         psFree(cube);
    537     ok ( okay, "psMemCheckCube in memCheckType");
    538     skip_start ( !okay, 26, "psMemCheckCube in memCheckType");
    539     psFree(cube);
    540 
    541     psFits *fits;
    542     fits = psFitsOpen("test.fits","w");
    543     psImage* img = psImageAlloc(16,16,PS_TYPE_F32);
    544     psFitsWriteImage(fits,NULL,img,1,NULL);
    545     psFree(img);
    546     okay = psMemCheckType(PS_DATA_FITS, fits);
    547     if ( ! okay )
    548         psFree(fits);
    549     ok ( okay, "psMemCheckFits in memCheckType");
    550     skip_start ( !okay, 25,"psMemCheckFits in memCheckType");
    551     psFitsClose(fits);
    552 
    553     psHash *hash;
    554     hash = psHashAlloc(100);
    555     okay = psMemCheckType(PS_DATA_HASH, hash);
    556     if ( ! okay )
    557         psFree(hash);
    558     ok ( okay, "psMemCheckHash in memCheckType");
    559     skip_start ( !okay, 24, "psMemCheckHash in memCheckType");
    560     psFree(hash);
    561 
    562     psHistogram *histogram;
    563     histogram = psHistogramAlloc(1.1, 2.2, 2);
    564     okay = psMemCheckType(PS_DATA_HISTOGRAM, histogram);
    565     if ( ! okay )
    566         psFree(histogram);
    567     ok ( okay, "psMemCheckHistogram in memCheckType");
    568     skip_start ( !okay, 23, "psMemCheckHistogram in memCheckType");
    569     psFree(histogram);
    570 
    571     psImage *image;
    572     image = psImageAlloc(5, 5, PS_TYPE_F32);
    573     okay = psMemCheckType(PS_DATA_IMAGE, image);
    574     if ( ! okay )
    575         psFree(image);
    576     ok ( okay, "psMemCheckImage in memCheckType");
    577     skip_start ( !okay, 22, "psMemCheckImage in memCheckType");
    578     psFree(image);
    579 
    580     psKernel *kernel;
    581     kernel = psKernelAlloc(0, 1, 0, 1);
    582     okay = psMemCheckType(PS_DATA_KERNEL, kernel);
    583     if ( ! okay )
    584         psFree(kernel);
    585     ok ( okay, "psMemCheckKernel in memCheckType");
    586     skip_start ( !okay, 21, "psMemCheckKernel in memCheckType");
    587     psFree(kernel);
    588 
    589     psList *list;
    590     list = psListAlloc(NULL);
    591     okay = psMemCheckType(PS_DATA_LIST, list);
    592     if ( ! okay )
    593         psFree(list);
    594     ok ( okay, "psMemCheckList in memCheckType");
    595     skip_start ( !okay, 20, "psMemCheckList in memCheckType");
    596     psFree(list);
    597 
    598     psLookupTable *lookup;
    599     char *file = "tableF32.dat";
    600     char *format = "\%f \%lf \%d \%ld";
    601     lookup = psLookupTableAlloc(file, format, 10);
    602     okay = psMemCheckType(PS_DATA_LOOKUPTABLE, lookup);
    603     if ( ! okay )
    604         psFree(lookup);
    605     ok ( okay, "psMemCheckLookupTable in memCheckType");
    606     skip_start ( !okay, 19, "psMemCheckLookupTable in memCheckType");
    607     psFree(lookup);
    608 
    609     psMetadata *metadata;
    610     metadata = psMetadataAlloc();
    611     okay = psMemCheckType(PS_DATA_METADATA, metadata);
    612     if ( ! okay )
    613         psFree(metadata);
    614     ok ( okay, "psMemCheckMetadata in memCheckType");
    615     skip_start ( !okay, 18, "psMemCheckMetadata in memCheckType");
    616     psFree(metadata);
    617 
    618     psMetadataItem *metaItem;
    619     metaItem = psMetadataItemAlloc("name", PS_DATA_S32, "COMMENT", 1);
    620     okay = psMemCheckType(PS_DATA_METADATAITEM, metaItem);
    621     if ( ! okay )
    622         psFree(metaItem);
    623     ok ( okay, "psMemCheckMetadataItem in memCheckType");
    624     skip_start ( !okay, 17, "psMemCheckMetadataItem in memCheckType");
    625     psFree(metaItem);
    626 
    627     psMinimization *min;
    628     min = psMinimizationAlloc(3, 0.1);
    629     okay = psMemCheckType(PS_DATA_MINIMIZATION, min);
    630     if ( ! okay )
    631         psFree(min);
    632     ok ( okay, "psMemCheckMinimization in memCheckType");
    633     skip_start ( !okay, 16, "psMemCheckMinimization in memCheckType");
    634     psFree(min);
    635 
    636     psPixels *pixels;
    637     pixels = psPixelsAlloc(100);
    638     okay = psMemCheckType(PS_DATA_PIXELS, pixels);
    639     if ( ! okay )
    640         psFree(pixels);
    641     ok ( okay, "psMemCheckPixels in memCheckType");
    642     skip_start ( !okay, 15, "psMemCheckPixels in memCheckType");
    643     psFree(pixels);
    644 
    645     psPlane *plane;
    646     plane = psPlaneAlloc();
    647     okay = psMemCheckType(PS_DATA_PLANE, plane);
    648     if ( ! okay )
    649         psFree(plane);
    650     ok ( okay, "psMemCheckPlane in memCheckType.");
    651     skip_start ( !okay, 14, "psMemCheckPlane in memCheckType.");
    652     psFree(plane);
    653 
    654     psPlaneDistort *planeDistort;
    655     planeDistort = psPlaneDistortAlloc(1, 1, 1, 1);
    656     okay =  psMemCheckType(PS_DATA_PLANEDISTORT, planeDistort);
    657     if ( ! okay )
    658         psFree(planeDistort);
    659     ok ( okay, "psMemCheckPlaneDistort in memCheckType.");
    660     skip_start ( !okay, 13, "psMemCheckPlaneDistort in memCheckType.");
    661     psFree(planeDistort);
    662 
    663     psPlaneTransform *planeTransform;
    664     planeTransform = psPlaneTransformAlloc(1, 1);
    665     okay = psMemCheckType(PS_DATA_PLANETRANSFORM, planeTransform);
    666     if ( ! okay )
    667         psFree(planeTransform);
    668     ok ( okay, "psMemCheckPlaneTransform in memCheckType");
    669     skip_start ( !okay, 12, "psMemCheckPlaneTransform in memCheckType");
    670     psFree(planeTransform);
    671 
    672     psPolynomial1D *poly1;
    673     poly1 = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 2);
    674     okay = psMemCheckType(PS_DATA_POLYNOMIAL1D, poly1);
    675     if ( ! okay )
    676         psFree(poly1);
    677     ok ( okay, "psMemCheckPolynomial1D in memCheckType");
    678     skip_start ( !okay, 11, "psMemCheckPolynomial1D in memCheckType");
    679     psFree(poly1);
    680 
    681     psPolynomial2D *poly2;
    682     poly2 = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 2, 1);
    683     okay = psMemCheckType(PS_DATA_POLYNOMIAL2D, poly2);
    684     if ( ! okay )
    685         psFree(poly2);
    686     ok ( okay, "psMemCheckPolynomial2D in memCheckType");
    687     skip_start ( !okay, 10, "psMemCheckPolynomial2D in memCheckType");
    688     psFree(poly2);
    689 
    690     psPolynomial3D *poly3;
    691     poly3 = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 2, 1, 1);
    692     okay = psMemCheckType(PS_DATA_POLYNOMIAL3D, poly3);
    693     if ( ! okay )
    694         psFree(poly3);
    695     ok ( okay, "psMemCheckPolynomial3D in memCheckType");
    696     skip_start ( !okay, 9, "psMemCheckPolynomial3D in memCheckType");
    697     psFree(poly3);
    698 
    699     psPolynomial4D *poly4;
    700     poly4 = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 2, 1, 2, 1);
    701     okay = psMemCheckType(PS_DATA_POLYNOMIAL4D, poly4);
    702     if ( ! okay )
    703         psFree(poly4);
    704     ok ( okay, "psMemCheckPolynomial4D in memCheckType");
    705     skip_start ( !okay, 8, "psMemCheckPolynomial4D in memCheckType");
    706     psFree(poly4);
    707 
    708     psProjection *proj;
    709     proj = psProjectionAlloc(1, 1, 2.1, 2.1, PS_PROJ_TAN);
    710     okay = psMemCheckType(PS_DATA_PROJECTION, proj);
    711     if ( ! okay )
    712         psFree(proj);
    713     ok ( okay, "psMemCheckProjection in memCheckType.");
    714     skip_start ( !okay, 7, "psMemCheckProjection in memCheckType.");
    715     psFree(proj);
    716 
    717     psScalar *scalar;
    718     psF64 f64 = 1.1;
    719     scalar = psScalarAlloc(f64, PS_TYPE_F64);
    720     okay = psMemCheckType(PS_DATA_SCALAR, scalar);
    721     if ( ! okay )
    722         psFree(scalar);
    723     ok ( okay, "psMemCheckScalar in memCheckType");
    724     skip_start ( !okay, 6, "psMemCheckScalar in memCheckType");
    725     psFree(scalar);
    726 
    727     psSphere *sphere;
    728     sphere = psSphereAlloc();
    729     okay = psMemCheckType(PS_DATA_SPHERE, sphere);
    730     if ( ! okay )
    731         psFree(sphere);
    732     ok ( okay, "psMemCheckSphere in memCheckType");
    733     skip_start ( !okay, 5, "psMemCheckSphere in memCheckType");
    734     psFree(sphere);
    735 
    736     psSphereRot *sphereRot;
    737     sphereRot = psSphereRotAlloc(0, 0, 20);
    738     okay = psMemCheckType(PS_DATA_SPHEREROT, sphereRot);
    739     if ( ! okay )
    740         psFree(sphereRot);
    741     ok( okay, "psMemCheckSphereRot in memCheckType");
    742     skip_start( !okay, 4, "psMemCheckSphereRot in memCheckType");
    743     psFree(sphereRot);
    744 
    745     psSpline1D *spline;
    746     spline = psSpline1DAlloc(2, 1, 0, 2);
    747     okay = psMemCheckType(PS_DATA_SPLINE1D, spline);
    748     if ( ! okay )
    749         psFree(spline);
    750     ok( okay, "psMemCheckSpline1D in memCheckType");
    751     skip_start( !okay, 3, "psMemCheckSpline1D in memCheckType");
    752     psFree(spline);
    753 
    754     psStats *stats;
    755     stats = psStatsAlloc(PS_STAT_MAX);
    756     okay = psMemCheckType(PS_DATA_STATS, stats);
    757     if ( ! okay )
    758         psFree(stats);
    759     ok( okay, "psMemCheckStats in memCheckType");
    760     skip_start( !okay, 2, "psMemCheckStats in memCheckType");
    761     psFree(stats);
    762 
    763     psTime *time;
    764     time = psTimeAlloc(PS_TIME_UT1);
    765     okay = psMemCheckType(PS_DATA_TIME, time);
    766     if ( ! okay )
    767         psFree(time);
    768     ok( okay, "psMemCheckTime in memCheckType");
    769     skip_start( !okay, 1, "psMemCheckTime in memCheckType");
    770     psFree(time);
    771 
    772     psVector *vector;
    773     vector = psVectorAlloc(100, PS_TYPE_F32);
    774     okay = psMemCheckType(PS_DATA_VECTOR, vector);
    775     ok( okay, "psMemCheckVector in memCheckType");
    776     psFree(vector);
    777 
    778     skip_end();
    779     skip_end();
    780     skip_end();
    781     skip_end();
    782     skip_end();
    783     skip_end();
    784     skip_end();
    785     skip_end();
    786     skip_end();
    787     skip_end();
    788     skip_end();
    789     skip_end();
    790     skip_end();
    791     skip_end();
    792     skip_end();
    793     skip_end();
    794     skip_end();
    795     skip_end();
    796     skip_end();
    797     skip_end();
    798     skip_end();
    799     skip_end();
    800     skip_end();
    801     skip_end();
    802     skip_end();
    803     skip_end();
    804     skip_end();
    805     skip_end();
    806 
    807     psFree(negative);
    808     psFree(neg);
    809 
    810     return 0;
    811 }
     622

  • trunk/psLib/test/sys/tap_psString.c

    r12607 r12781  
    2020 *  @author  Eric Van Alst, MHPCC
    2121 *
    22  *  @version $Revision: 1.7 $  $Name: not supported by cvs2svn $
    23  *  @date  $Date: 2007-03-27 22:52:03 $
     22 *  @version $Revision: 1.8 $  $Name: not supported by cvs2svn $
     23 *  @date  $Date: 2007-04-10 21:09:31 $
    2424 *
    2525 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3535#define STR_0 "binky had a leeeetle lamb"
    3636
    37 psS32 testStringCopy00(void);
    38 psS32 testStringCopy01(void);
    39 psS32 testStringCopy02(void);
    40 psS32 testStringCopy03(void);
    41 psS32 testStringCopy04(void);
    42 //psS32 testStringCopy05(void);
    43 psS32 testStringCopy06(void);
    44 
    45 psS32 testStrAppend00(void);
    46 psS32 testStrAppend01(void);
    47 psS32 testStrAppend02(void);
    48 psS32 testStrAppend03(void);
    49 
    50 psS32 testStrPrepend00(void);
    51 psS32 testStrPrepend01(void);
    52 psS32 testStrPrepend02(void);
    53 psS32 testStrPrepend03(void);
    54 
    55 psS32 testStrSplit00(void);
    56 psS32 testNULLStrings(void);
    57 psS32 testStrCheck(void);
    58 
    5937
    6038psS32 main( psS32 argc, char* argv[] )
    6139{
    62     plan_tests(55);
    63 
    64     testStringCopy00();
    65     testStringCopy01();
    66     testStringCopy02();
    67     testStringCopy03();
    68     testStringCopy04();
    69     testStringCopy06();
    70 
    71     testStrAppend00();
    72     testStrAppend01();
    73     testStrAppend02();
    74     testStrAppend03();
    75 
    76     testStrPrepend00();
    77     testStrPrepend01();
    78     testStrPrepend02();
    79     testStrPrepend03();
    80 
    81     testStrSplit00();
    82     testNULLStrings();
    83     testStrCheck();
    84 }
    85 
    86 
    87 psS32 testStringCopy00(void)
    88 {
    89 //    diag("testStringCopy00");
    90 
    91     char  stringval[20] = "E R R O R";
    92     psS32   result = 0;
    93     psS32   result1 = 0;
    94     char  *strResult;
    95 
    96     // Test point #1 Verify string copy - psStringCopy
    97     strResult = psStringCopy(stringval);
    98     // Perform string compare
    99     result = strcmp(strResult, stringval);
    100     // Modify original string
    101     stringval[0]='G';
    102     result1 = strcmp(strResult, stringval);
    103     stringval[0]='E';
    104     ok ( ( result == 0 ) && ( result1 != 0),
    105          "Failed test point #1 strcmp result = %d expected 0\n",result);
    106 
    107     // Free memory allocated
    108     psFree(strResult);
    109 
    110     return 0;
    111 }
    112 
    113 
    114 psS32 testStringCopy01(void)
    115 {
    116 //    diag("testStringCopy01");
    117 
    118     char  *emptyval = "";
    119     psS32   result = 0;
    120     char  *strResult;
    121 
    122     // Test point #2 Verify empty string copy - psStringCopy
    123     strResult = psStringCopy(emptyval);
    124     // Perform string compare
    125     result = strcmp(strResult, emptyval);
    126     ok ( result == 0,
    127          "test point #2 strcmp result = %d expected 0\n",result);
    128 
    129     // Free memory allocated
    130     psFree(strResult);
    131 
    132     return 0;
    133 }
    134 
    135 
    136 psS32 testStringCopy02(void)
    137 {
    138 //    diag("testStringCopy02");
    139 
    140     psS32   result = 0;
    141     psS32   result1 = 0;
    142     char  *strResult;
    143     char  stringval1[20] = "e r r o r";
    144     psS32   substringlen = 5;
    145     char  *substringval = "e r r";
    146 
    147     // Test point #3 Verify string copy with length - psStringNCopy
    148     strResult = psStringNCopy(stringval1, substringlen);
    149     // Perform string compare and get string length
    150     result = strncmp(strResult, substringval, substringlen);
    151     // Change original string
    152     stringval1[0] = 'g';
    153     result1 = strncmp(strResult, substringval, substringlen);
    154     ok ( ( result == 0 ) && ( result1 == 0 ),
    155          "Failed test point #3 strcmp result = %d expected 0\n",result);
    156 
    157     // Free memory allocated
    158     psFree(strResult);
    159 
    160     return 0;
    161 }
    162 
    163 psS32 testStringCopy03(void)
    164 {
    165 //    diag("testStringCopy03");
    166 
    167     psS32   result = 0;
    168     psS32   result1 = 0;
    169     char  *strResult;
    170     char  *stringvalnocopy = "F A I L";
    171 
    172     // Test point #4 Verify empty string copy with length - psStringNCopy
    173     strResult = psStringNCopy(stringvalnocopy, 0);
    174     // Perform string compare and get sting length
    175     result = strcmp(strResult, stringvalnocopy);
    176     result1 = strlen(strResult);
    177     ok ( result != 0,
    178          "test point #4 strcmp result = %d didn't expected %d\n",result,0);
    179 
    180     // Free memory
    181     psFree(strResult);
    182 
    183     return 0;
    184 }
    185 
    186 psS32 testStringCopy04(void)
    187 {
    188 //    diag("testStringCopy04");
    189 
    190     psS32   result = 0;
    191     psS32   result1 = 0;
    192     char  *strResult;
    193     char  stringval[20] = "E R R O R";
    194     psS32   increaseSize = 5;
    195 
    196     // Test point #5 Copy string to larger string - psStringNCopy
    197     strResult = psStringNCopy(stringval, (strlen(stringval) + increaseSize));
    198     // Perform string compare and get string length
    199     result = strcmp(strResult, stringval);
    200     result1 = strlen(strResult);
    201     // The strings should still compare
    202     ok ( result == 0 && result1 == strlen(stringval),
    203          "test point #5 strcmp result = %d expected %d\n",result,0);
    204 
    205     // Free memory
    206     psFree(strResult);
    207 
    208     return 0;
    209 }
     40    psLogSetFormat("HLNM");
     41    psLogSetLevel(PS_LOG_INFO);
     42    plan_tests(72);
     43
     44
     45    //testStringCopy00()
     46    {
     47        psMemId id = psMemGetId();
     48        char  stringval[20] = "E R R O R";
     49        psS32   result = 0;
     50        psS32   result1 = 0;
     51        char  *strResult;
     52
     53        // Test point #1 Verify string copy - psStringCopy
     54        strResult = psStringCopy(stringval);
     55        // Perform string compare
     56        result = strcmp(strResult, stringval);
     57        // Modify original string
     58        stringval[0]='G';
     59        result1 = strcmp(strResult, stringval);
     60        stringval[0]='E';
     61        ok(( result == 0 ) && ( result1 != 0),
     62             "Failed test point #1 strcmp result = %d expected 0",result);
     63        // Free memory allocated
     64        psFree(strResult);
     65        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     66    }
     67
     68
     69    // testStringCopy01()
     70    {
     71        psMemId id = psMemGetId();
     72        char  *emptyval = "";
     73        psS32   result = 0;
     74        char  *strResult;
     75
     76        // Test point #2 Verify empty string copy - psStringCopy
     77        strResult = psStringCopy(emptyval);
     78        // Perform string compare
     79        result = strcmp(strResult, emptyval);
     80        ok(result == 0,
     81             "test point #2 strcmp result = %d expected 0",result);
     82        // Free memory allocated
     83        psFree(strResult);
     84        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     85    }
     86
     87
     88    // testStringCopy02()
     89    {
     90        psMemId id = psMemGetId();
     91        psS32   result = 0;
     92        psS32   result1 = 0;
     93        char  *strResult;
     94        char  stringval1[20] = "e r r o r";
     95        psS32   substringlen = 5;
     96        char  *substringval = "e r r";
     97
     98        // Test point #3 Verify string copy with length - psStringNCopy
     99        strResult = psStringNCopy(stringval1, substringlen);
     100        // Perform string compare and get string length
     101        result = strncmp(strResult, substringval, substringlen);
     102        // Change original string
     103        stringval1[0] = 'g';
     104        result1 = strncmp(strResult, substringval, substringlen);
     105        ok(( result == 0 ) && ( result1 == 0 ),
     106             "Failed test point #3 strcmp result = %d expected 0",result);
     107        psFree(strResult);
     108        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     109    }
     110
     111
     112    // testStringCopy03()
     113    {
     114        psMemId id = psMemGetId();
     115        psS32   result = 0;
     116        psS32   result1 = 0;
     117        char  *strResult;
     118        char  *stringvalnocopy = "F A I L";
     119
     120        // Test point #4 Verify empty string copy with length - psStringNCopy
     121        strResult = psStringNCopy(stringvalnocopy, 0);
     122        // Perform string compare and get sting length
     123        result = strcmp(strResult, stringvalnocopy);
     124        result1 = strlen(strResult);
     125        ok(result != 0,
     126             "test point #4 strcmp result = %d didn't expected %d",result,0);
     127        psFree(strResult);
     128        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     129    }
     130
     131
     132    // testStringCopy04()
     133    {
     134        psMemId id = psMemGetId();
     135        psS32   result = 0;
     136        psS32   result1 = 0;
     137        char  *strResult;
     138        char  stringval[20] = "E R R O R";
     139        psS32   increaseSize = 5;
     140
     141        // Test point #5 Copy string to larger string - psStringNCopy
     142        strResult = psStringNCopy(stringval, (strlen(stringval) + increaseSize));
     143        // Perform string compare and get string length
     144        result = strcmp(strResult, stringval);
     145        result1 = strlen(strResult);
     146        // The strings should still compare
     147        ok(result == 0 && result1 == strlen(stringval),
     148             "test point #5 strcmp result = %d expected %d",result,0);
     149        psFree(strResult);
     150        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     151    }
    210152
    211153// XXX This test needs to be modified to check for maximum size
    212154//     This will require a mod to psStringNCopy source to check for maximum size
    213155//
    214 //psS32 testStringCopy05(void)
     156//psS32 testStringCopy05()
    215157//{
    216158//    char  *strResult;
    … …  
    231173
    232174
    233 psS32 testStringCopy06(void)
    234 {
    235 //    diag("testStringCopy06");
    236 
    237     char  *strResult;
    238     char  stringval[20] = "E R R O R";
    239     psS32   result = 0;
    240 
    241     // Test point #7 Verify creation of string literal - PS_STRING
    242     strResult = PS_STRING(E R R O R);
    243     result = strcmp(strResult, stringval);
    244     ok ( result == 0,
    245          "test point #7 strcmp result = %d expected %d",result,0);
    246 
    247     // Memory should not have been allocated
    248     return 0;
     175    // testStringCopy06()
     176    {
     177        psMemId id = psMemGetId();
     178        char  *strResult;
     179        char  stringval[20] = "E R R O R";
     180        psS32   result = 0;
     181
     182        // Test point #7 Verify creation of string literal - PS_STRING
     183        strResult = PS_STRING(E R R O R);
     184        result = strcmp(strResult, stringval);
     185        ok(result == 0,
     186             "test point #7 strcmp result = %d expected %d",result,0);
     187        // Memory should not have been allocated
     188        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     189    }
     190
     191
     192    // testStrAppend00()
     193    {
     194        psMemId id = psMemGetId();
     195        char *str = psStringCopy("3.14159");
     196        psStringAppend(&str, "%d%s", 2653589, "79323846");
     197        // Test point: Verify string append
     198        int result = strcmp(str, "3.14159265358979323846");
     199        ok(result == 0, "Failed test point");
     200        psFree(str);
     201        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     202    }
     203
     204
     205    // testStrAppend01()
     206    {
     207        psMemId id = psMemGetId();
     208        char *str=NULL;
     209        // test nonsensical invocations ...
     210        ssize_t sz = psStringAppend(NULL, NULL);
     211        ok(sz == 0, "Failed test point");
     212        sz = psStringAppend(&str, NULL);
     213        ok(sz == 0, "Failed test point");
     214        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     215    }
     216
     217
     218    // testStrAppend02()
     219    {
     220        psMemId id = psMemGetId();
     221        char *str=NULL;
     222        // test string creation
     223        psStringAppend(&str, "%s", "fubar");
     224        int result = strcmp(str, "fubar");
     225        ok(result == 0, "Failed test point");
     226        psFree(str);
     227        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     228    }
     229
     230
     231    // testStrAppend03()
     232    {
     233        psMemId id = psMemGetId();
     234        char *str =psStringCopy(STR_0);
     235        // test null-op
     236        psStringAppend(&str, "%s", "");
     237        is_str(str, STR_0, "Failed test point");
     238        psFree(str);
     239        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     240    }
     241
     242
     243    // testStrPrepend00()
     244    {
     245        psMemId id = psMemGetId();
     246        char *str = psStringCopy("79323846");
     247        psStringPrepend(&str, "%s%d","3.14159", 2653589 );
     248        // Test point: Verify string append
     249        int result = strcmp(str, "3.14159265358979323846");
     250        ok(result == 0, "Failed test point");
     251        psFree(str);
     252        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     253    }
     254
     255
     256    // testStrPrepend01()
     257    {
     258        psMemId id = psMemGetId();
     259        char *str=NULL;
     260        // test nonsensical invocations ...
     261        ssize_t sz = psStringPrepend(NULL, NULL);
     262        ok(sz == 0, "Failed test point");
     263        sz = psStringPrepend(&str, NULL);
     264        ok(sz == 0, "Failed test point");
     265        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     266    }
     267
     268
     269    // testStrPrepend02()
     270    {
     271        psMemId id = psMemGetId();
     272        char *str=NULL;
     273        // test string creation
     274        psStringPrepend(&str, "%s", "fubar");
     275        int result = strcmp(str, "fubar");
     276        ok(result == 0, "Failed test point");
     277        psFree(str);
     278        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     279    }
     280
     281
     282    // testStrPrepend03()
     283    {
     284        // test null-op
     285        psMemId id = psMemGetId();
     286        char *str =  psStringCopy(STR_0);
     287        psStringPrepend(&str, "%s", "");
     288        int result = strcmp(str, STR_0);
     289        ok(result == 0, "test point str=[%s]", str);
     290        psFree(str);
     291        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     292    }
     293
     294
     295    // testStrSplit00()
     296    {
     297        psMemId id = psMemGetId();
     298        psList *strList = NULL;
     299        char str[35];
     300        char split[5];
     301        strncpy(str, "This is, a, test case, to check", 35);
     302        strncpy(split, ",", 2);
     303        psString psStr;
     304        psString psSplit;
     305        psStr = psStringCopy(str);
     306        psSplit = psStringCopy(split);
     307
     308        //Return NULL for NULL inputs
     309        strList = psStringSplit(NULL, NULL, true);
     310        ok(!strList, "psStringSplit" );
     311        psFree(strList);
     312
     313        strList = NULL;
     314        //Return empty list for NULL string input
     315        strList = psStringSplit(NULL, split, true);
     316        ok(!psListLength(strList), "psListLength()" );
     317        psFree(strList);
     318
     319        strList = NULL;
     320        //Return NULL for NULL splitter input
     321        strList = psStringSplit(str, NULL, true);
     322        ok(!strList, "psStringSplit" );
     323        psFree(strList);
     324
     325        strList = NULL;
     326        //Return a psList* of psStrings
     327        strList = psStringSplit(str, split, true);
     328        ok(strList->n == 4,
     329            "psStringSplit to return the correct number of strings");
     330        ok(!strncmp((psString)(strList->head->data), "This is", 10),
     331             "psStringSplit to return expected strings");
     332        ok(!strncmp((psString)(strList->head->next->data), " a", 10),
     333             "psStringSplit to return expected strings");
     334        ok(!strncmp((psString)(strList->head->next->next->data), " test case",10),
     335             "psStringSplit to return expected strings");
     336        ok(!strncmp((psString)(strList->head->next->next->next->data), " to check", 10),
     337             "psStringSplit failed to return expected strings");
     338
     339        psFree(strList);
     340        //Return correct psList when using (psString, char*)
     341        strList = psStringSplit(psStr, split, true);
     342        ok(strList->n == 4,
     343            "psStringSplit to return the correct number of strings");
     344        ok(!strncmp((psString)(strList->head->data), "This is", 10),
     345             "psStringSplit to return expected strings");
     346        ok(!strncmp((psString)(strList->head->next->data), " a", 10),
     347             "psStringSplit failed to return expected strings");
     348        ok(!strncmp((psString)(strList->head->next->next->data), " test case",10),
     349             "psStringSplit failed to return expected strings");
     350        ok(!strncmp((psString)(strList->head->next->next->next->data), " to check", 10),
     351             "psStringSplit to return expected strings");
     352
     353        psFree(strList);
     354        //Return correct psList when using (char*, psString)
     355        strList = psStringSplit(str, psSplit, true);
     356        ok(strList->n == 4,
     357            "psStringSplit to return the correct number of strings");
     358        ok(!strncmp((psString)(strList->head->data), "This is", 10),
     359             "psStringSplit to return expected strings");
     360        ok(!strncmp((psString)(strList->head->next->data), " a", 10),
     361             "psStringSplit to return expected strings");
     362        ok(!strncmp((psString)(strList->head->next->next->data), " test case",10),
     363             "psStringSplit to return expected strings");
     364        ok(!strncmp((psString)(strList->head->next->next->next->data), " to check", 10),
     365             "psStringSplit to return expected strings");
     366
     367        psFree(strList);
     368        //Return correct psList when using (psString, psString)
     369        strList = psStringSplit(psStr, psSplit, true);
     370        ok(strList->n == 4,
     371            "psStringSplit to return the correct number of strings");
     372        ok(!strncmp((psString)(strList->head->data), "This is", 10),
     373             "psStringSplit to return expected strings");
     374        ok(!strncmp((psString)(strList->head->next->data), " a", 10),
     375             "psStringSplit to return expected strings");
     376        ok(!strncmp((psString)(strList->head->next->next->data), " test case",10),
     377             "psStringSplit  to return expected strings");
     378        ok(!strncmp((psString)(strList->head->next->next->next->data), " to check", 10),
     379             "psStringSplit to return expected strings");
     380   
     381        psFree(strList);
     382        //Return correct psList output for string of zero length case
     383        strncpy(str, "This is,, a,, test case,, to check", 35);
     384        strList = psStringSplit(str, split, false);
     385        ok(strList->n == 4,
     386            "psStringSplit to return the correct number of strings");
     387        ok(!strncmp((psString)(strList->head->data), "This is", 10),
     388             "psStringSplit to return expected strings");
     389        ok(!strncmp((psString)(strList->head->next->data), " a", 10),
     390             "psStringSplit to return expected strings");
     391        ok(!strncmp((psString)(strList->head->next->next->data), " test case",10),
     392             "psStringSplit to return expected strings");
     393        ok(!strncmp((psString)(strList->head->next->next->next->data), " to check", 10),
     394             "psStringSplit to return expected strings");
     395        psFree(strList);
     396        psFree(psStr);
     397        psFree(psSplit);
     398        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     399    }
     400
     401
     402    // testNULLStrings()
     403    {
     404        psMemId id = psMemGetId();
     405        psString nullTest = NULL;
     406        psString output = NULL;
     407        ssize_t outSize = 0;
     408        char** nullDest = NULL;
     409        char** test = NULL;
     410        //psStringCopy should return NULL for NULL input string
     411        //    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message");
     412        output = psStringCopy(nullTest);
     413        ok(output == NULL, "psStringCopy to return NULL for NULL input string");
     414   
     415        //psStringNCopy should return NULL for NULL input string
     416        output = psStringNCopy(nullTest, 100);
     417        ok(output == NULL, "psStringNCopy to return NULL for NULL input string");
     418   
     419        //psStringAppend should return 0 for NULL input destination
     420        outSize = psStringAppend(nullDest, "%s", "");
     421        ok(outSize == 0, "psStringAppend to return 0 for NULL input destination");
     422   
     423        //psStringAppend should return 0 for NULL input format
     424        outSize = psStringAppend(test, nullTest);
     425        ok(outSize == 0, "psStringAppend to return 0 for NULL input format");
     426   
     427        //psStringPrepend should return 0 for NULL input destination
     428        outSize = psStringPrepend(nullDest, " ");
     429        ok(outSize == 0, "psStringPrepend to return 0 for NULL input destination");
     430   
     431        //psStringPrepend should return 0 for NULL input format
     432        outSize = psStringPrepend(test, nullTest);
     433        ok(outSize == 0, "psStringPrepend to return 0 for NULL input format");
     434   
     435        //psStringSplit should return empty list for NULL input string
     436        psList *nullList = NULL;
     437        nullList = psStringSplit(nullTest, ",", true);
     438        ok(!psListLength(nullList), "psStringSplit to return NULL for NULL input string");
     439        psFree(nullList);
     440   
     441        nullList = NULL;
     442        //psStringSplit should return NULL for NULL input splitter
     443        nullList = psStringSplit("Hello World", nullTest, true);
     444        ok(!nullList, "psStringSplit to return NULL for NULL input splitter");
     445        psFree(nullList);
     446        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     447    }
     448
     449
     450    // testStrCheck()
     451    {
     452        psMemId id = psMemGetId();
     453        psString str = psStringAlloc(10);
     454        strcpy(str, "Hello");
     455        ok(psMemCheckString(str), "psString allocated!");
     456        ok(psMemCheckType(PS_DATA_STRING, str), "psString allocated");
     457        psFree(str);
     458   
     459        char charStr[10];
     460        ok(!psMemCheckType(PS_DATA_STRING, charStr),
     461            "Input string is a psDataType");
     462        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     463    }
    249464}
    250 
    251 
    252 psS32 testStrAppend00(void)
    253 {
    254 //    diag("testStrAppend00");
    255 
    256     char *str=NULL;
    257     int result = 0;
    258 
    259     str = psStringCopy("3.14159");
    260 
    261     psStringAppend(&str, "%d%s", 2653589, "79323846");
    262 
    263     // Test point: Verify string append
    264     result = strcmp(str, "3.14159265358979323846");
    265     ok ( result == 0, "Failed test point\n");
    266 
    267     psFree(str);
    268 
    269     return 0;
    270 }
    271 
    272 psS32 testStrAppend01(void)
    273 {
    274 //    diag("testStrAppend01");
    275 
    276     ssize_t sz;
    277     char *str=NULL;
    278 
    279     // test nonsensical invocations ...
    280     sz = psStringAppend(NULL, NULL);
    281     ok ( sz == 0, "Failed test point\n");
    282 
    283     sz = psStringAppend(&str, NULL);
    284     ok ( sz == 0, "Failed test point\n");
    285 
    286     return 0;
    287 }
    288 
    289 
    290 psS32 testStrAppend02(void)
    291 {
    292 //    diag("testStrAppend02");
    293 
    294     char *str=NULL;
    295     int result;
    296 
    297     // test string creation
    298     psStringAppend(&str, "%s", "fubar");
    299     result = strcmp(str, "fubar");
    300     ok ( result == 0, "Failed test point\n");
    301 
    302     psFree(str);
    303 
    304     return 0;
    305 }
    306 
    307 psS32 testStrAppend03(void)
    308 {
    309 //    diag("testStrAppend03");
    310 
    311     char *str =psStringCopy(STR_0);
    312 
    313     // test null-op
    314     psStringAppend(&str, "%s", "");
    315     is_str(str, STR_0, "Failed test point");
    316     psFree(str);
    317 
    318     return 0;
    319 }
    320 
    321 
    322 psS32 testStrPrepend00(void)
    323 {
    324 //    diag("testStrPrepend00");
    325 
    326     char *str=NULL;
    327     int result = 0;
    328 
    329     str = psStringCopy("79323846");
    330 
    331     psStringPrepend(&str, "%s%d","3.14159", 2653589 );
    332 
    333     // Test point: Verify string append
    334     result = strcmp(str, "3.14159265358979323846");
    335     ok ( result == 0, "Failed test point\n");
    336 
    337     psFree(str);
    338 
    339     return 0;
    340 }
    341 
    342 
    343 psS32 testStrPrepend01(void)
    344 {
    345 //    diag("testStrPrepend01");
    346 
    347     ssize_t sz;
    348     char *str=NULL;
    349 
    350     // test nonsensical invocations ...
    351     sz = psStringPrepend(NULL, NULL);
    352     ok ( sz == 0, "Failed test point\n");
    353 
    354     sz = psStringPrepend(&str, NULL);
    355     ok ( sz == 0, "Failed test point\n");
    356 
    357     return 0;
    358 }
    359 
    360 psS32 testStrPrepend02(void)
    361 {
    362 //    diag("testStrPrepend02");
    363 
    364     char *str=NULL;
    365     int result;
    366 
    367     // test string creation
    368     psStringPrepend(&str, "%s", "fubar");
    369     result = strcmp(str, "fubar");
    370     ok ( result == 0, "Failed test point\n");
    371 
    372     psFree(str);
    373 
    374     return 0;
    375 }
    376 
    377 psS32 testStrPrepend03(void)
    378 {
    379 //    diag("testStrPrepend03");
    380 
    381     char *str=NULL;
    382     int result;
    383 
    384     str = psStringCopy(STR_0);
    385 
    386     // test null-op
    387     psStringPrepend(&str, "%s", "");
    388     result = strcmp(str, STR_0);
    389     ok ( result == 0, "test point str=[%s]\n", str);
    390 
    391     psFree(str);
    392 
    393     return 0;
    394 }
    395 
    396 
    397 psS32 testStrSplit00(void)
    398 {
    399 //    diag("testStrSplit00");
    400 
    401     psList *strList = NULL;
    402     char str[35];
    403     char split[5];
    404     strncpy(str, "This is, a, test case, to check.", 35);
    405     strncpy(split, ",", 2);
    406     psString psStr;
    407     psString psSplit;
    408     psStr = psStringCopy(str);
    409     psSplit = psStringCopy(split);
    410 
    411     //Return NULL for NULL inputs
    412     strList = psStringSplit(NULL, NULL, true);
    413     ok (!strList, "psStringSplit" );
    414     psFree(strList);
    415 
    416     strList = NULL;
    417     //Return empty list for NULL string input
    418     strList = psStringSplit(NULL, split, true);
    419     ok ( !psListLength(strList), "psListLength()" );
    420     psFree(strList);
    421 
    422     strList = NULL;
    423     //Return NULL for NULL splitter input
    424     strList = psStringSplit(str, NULL, true);
    425     ok ( !strList, "psStringSplit" );
    426     psFree(strList);
    427 
    428     strList = NULL;
    429     //Return a psList* of psStrings
    430     strList = psStringSplit(str, split, true);
    431     ok (strList->n == 4,
    432         "psStringSplit to return the correct number of strings.\n");
    433 
    434     ok ( !strncmp((psString)(strList->head->data), "This is", 10),
    435          "psStringSplit to return expected strings.");
    436 
    437     ok ( !strncmp((psString)(strList->head->next->data), " a", 10),
    438          "psStringSplit to return expected strings.");
    439 
    440     ok ( !strncmp((psString)(strList->head->next->next->data), " test case",10),
    441          "psStringSplit to return expected strings.");
    442 
    443     ok ( !strncmp((psString)(strList->head->next->next->next->data), " to check.", 10),
    444          "psStringSplit failed to return expected strings.");
    445 
    446     psFree(strList);
    447     //Return correct psList when using (psString, char*)
    448     strList = psStringSplit(psStr, split, true);
    449     ok (strList->n == 4,
    450         "psStringSplit to return the correct number of strings.\n");
    451 
    452     ok ( !strncmp((psString)(strList->head->data), "This is", 10),
    453          "psStringSplit to return expected strings.");
    454 
    455     ok ( !strncmp((psString)(strList->head->next->data), " a", 10),
    456          "psStringSplit failed to return expected strings.");
    457 
    458     ok ( !strncmp((psString)(strList->head->next->next->data), " test case",10),
    459          "psStringSplit failed to return expected strings.");
    460 
    461     ok ( !strncmp((psString)(strList->head->next->next->next->data), " to check.", 10),
    462          "psStringSplit to return expected strings.");
    463 
    464     psFree(strList);
    465     //Return correct psList when using (char*, psString)
    466     strList = psStringSplit(str, psSplit, true);
    467     ok (strList->n == 4,
    468         "psStringSplit to return the correct number of strings.\n");
    469 
    470     ok ( !strncmp((psString)(strList->head->data), "This is", 10),
    471          "psStringSplit to return expected strings.");
    472 
    473     ok ( !strncmp((psString)(strList->head->next->data), " a", 10),
    474          "psStringSplit to return expected strings.");
    475 
    476     ok ( !strncmp((psString)(strList->head->next->next->data), " test case",10),
    477          "psStringSplit to return expected strings.");
    478 
    479     ok ( !strncmp((psString)(strList->head->next->next->next->data), " to check.", 10),
    480          "psStringSplit to return expected strings.");
    481 
    482     psFree(strList);
    483     //Return correct psList when using (psString, psString)
    484     strList = psStringSplit(psStr, psSplit, true);
    485     ok (strList->n == 4,
    486         "psStringSplit to return the correct number of strings.\n");
    487 
    488     ok ( !strncmp((psString)(strList->head->data), "This is", 10),
    489          "psStringSplit to return expected strings.");
    490 
    491     ok ( !strncmp((psString)(strList->head->next->data), " a", 10),
    492          "psStringSplit to return expected strings.");
    493 
    494     ok ( !strncmp((psString)(strList->head->next->next->data), " test case",10),
    495          "psStringSplit  to return expected strings.");
    496 
    497     ok ( !strncmp((psString)(strList->head->next->next->next->data), " to check.", 10),
    498          "psStringSplit to return expected strings.");
    499 
    500     psFree(strList);
    501     //Return correct psList output for string of zero length case
    502     strncpy(str, "This is,, a,, test case,, to check.", 35);
    503     strList = psStringSplit(str, split, false);
    504     ok (strList->n == 4,
    505         "psStringSplit to return the correct number of strings.\n");
    506 
    507     ok ( !strncmp((psString)(strList->head->data), "This is", 10),
    508          "psStringSplit to return expected strings.");
    509 
    510     ok ( !strncmp((psString)(strList->head->next->data), " a", 10),
    511          "psStringSplit to return expected strings.");
    512 
    513     ok ( !strncmp((psString)(strList->head->next->next->data), " test case",10),
    514          "psStringSplit to return expected strings.");
    515 
    516     ok ( !strncmp((psString)(strList->head->next->next->next->data), " to check.", 10),
    517          "psStringSplit to return expected strings.");
    518 
    519     psFree(strList);
    520     psFree(psStr);
    521     psFree(psSplit);
    522     return 0;
    523 }
    524 
    525 psS32 testNULLStrings(void)
    526 {
    527 //    diag("test""s");
    528 
    529     psString nullTest = NULL;
    530     psString output = NULL;
    531     ssize_t outSize = 0;
    532     char** nullDest = NULL;
    533     char** test = NULL;
    534     //psStringCopy should return NULL for NULL input string
    535     //    psLogMsg(__func__,PS_LOG_INFO,"Following should generate error message");
    536     output = psStringCopy(nullTest);
    537     ok (output == NULL,
    538         "psStringCopy to return NULL for NULL input string.\n");
    539 
    540     //psStringNCopy should return NULL for NULL input string
    541     output = psStringNCopy(nullTest, 100);
    542     ok (output == NULL,
    543         "psStringNCopy to return NULL for NULL input string.\n");
    544 
    545     //psStringAppend should return 0 for NULL input destination
    546     outSize = psStringAppend(nullDest, "%s", "");
    547     ok (outSize == 0,
    548         "psStringAppend to return 0 for NULL input destination.\n");
    549 
    550     //psStringAppend should return 0 for NULL input format
    551     outSize = psStringAppend(test, nullTest);
    552     ok (outSize == 0,
    553         "psStringAppend to return 0 for NULL input format.\n");
    554 
    555     //psStringPrepend should return 0 for NULL input destination
    556     outSize = psStringPrepend(nullDest, " ");
    557     ok (outSize == 0,
    558         "psStringPrepend to return 0 for NULL input destination.\n");
    559 
    560     //psStringPrepend should return 0 for NULL input format
    561     outSize = psStringPrepend(test, nullTest);
    562     ok (outSize == 0,
    563         "psStringPrepend to return 0 for NULL input format.\n");
    564 
    565     //psStringSplit should return empty list for NULL input string
    566     psList *nullList = NULL;
    567     nullList = psStringSplit(nullTest, ",", true);
    568     ok ( !psListLength(nullList),
    569          "psStringSplit to return NULL for NULL input string.\n");
    570     psFree(nullList);
    571 
    572     nullList = NULL;
    573     //psStringSplit should return NULL for NULL input splitter
    574     nullList = psStringSplit("Hello World", nullTest, true);
    575     ok ( !nullList,
    576          "psStringSplit to return NULL for NULL input splitter.\n");
    577     psFree(nullList);
    578 
    579     return 0;
    580 }
    581 
    582 psS32 testStrCheck(void)
    583 {
    584 //    diag("testStrCheck");
    585 
    586     psString str = NULL;
    587     str = psStringAlloc(10);
    588     strcpy(str, "Hello");
    589     ok (psMemCheckString(str), "psString allocated!\n");
    590 
    591     ok (psMemCheckType(PS_DATA_STRING, str), "psString allocated!\n");
    592     psFree(str);
    593 
    594     char charStr[10];
    595     ok (!psMemCheckType(PS_DATA_STRING, charStr),
    596         "Input string is a psDataType");
    597 
    598     return 0;
    599 }
     465// HERE

  • trunk/psLib/test/sys/tap_psStringSubstitute.c

    r10446 r12781  
    1111int main (void)
    1212{
     13    psLogSetFormat("HLNM");
     14    psLogSetLevel(PS_LOG_INFO);
    1315    plan_tests(16);
    1416
    15     diag("psStringSubstitute() tests");
    1617
    1718    // Return input for NULL key
    1819    {
     20        psMemId id = psMemGetId();
    1921        psString input = psStringCopy(ORIGINAL);
    2022        psStringSubstitute(&input, ",", NULL);
    2123        ok(input && strcmp(input, ORIGINAL) == 0, "output = %s", input);
    2224        psFree(input);
    23         //        ok(psMemCheckLeaks(0, NULL, stdout, false) == 0, "Memory Leaks");
    24         mem();
     25        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    2526    }
     27
    2628
    2729    // Return input for empty key
    2830    {
     31        psMemId id = psMemGetId();
    2932        psString input = psStringCopy(ORIGINAL);
    3033        psStringSubstitute(&input, "XXX", "");
    3134        ok(input && strcmp(input, ORIGINAL) == 0, "output = %s", input);
    3235        psFree(input);
    33         //        ok(psMemCheckLeaks(0, NULL, stdout, false) == 0, "Memory Leaks");
    34         mem();
     36        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    3537    }
     38
    3639
    3740    // Return corrected version for NULL replace
    3841    {
     42        psMemId id = psMemGetId();
    3943        psString input = psStringCopy(ORIGINAL);
    4044        psStringSubstitute(&input, NULL, ",");
    4145        ok(input && strcmp(input, CORRECTED) == 0, "output = %s", input);
    4246        psFree(input);
    43         mem();
     47        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    4448    }
     49
    4550
    4651    // Return corrected version for empty replace
    4752    {
     53        psMemId id = psMemGetId();
    4854        psString input = psStringCopy(ORIGINAL);
    4955        psStringSubstitute(&input, "", ",");
    5056        ok(input && strcmp(input, CORRECTED) == 0, "output = %s", input);
    5157        psFree(input);
    52         mem();
     58        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    5359    }
     60
    5461
    5562    // Return NULL for NULL input
    5663    {
     64        psMemId id = psMemGetId();
    5765        int status = psStringSubstitute(NULL, "XXX", ",");
    5866        ok(status == 0, "status = %d", status);
    59         mem();
     67        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    6068    }
     69
    6170
    6271    // Return emptry string for empty input
    6372    {
     73        psMemId id = psMemGetId();
    6474        psString input = psStringCopy("");
    6575        psStringSubstitute(&input, "XXX", ",");
    6676        ok(input && strcmp(input, "") == 0, "output = %s", input);
    6777        psFree(input);
    68         mem();
     78        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    6979    }
     80
    7081
    7182    // Change commas to bangs
    7283    {
     84        psMemId id = psMemGetId();
    7385        psString input = psStringCopy(ORIGINAL);
    7486        psStringSubstitute(&input, "!", ",");
    7587        ok(input && strcmp(input, "This is! a! test case! to check.") == 0, "output = %s", input);
    7688        psFree(input);
    77         mem();
     89        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    7890    }
     91
    7992
    8093    // Long replacement text --- should allocate new space
    8194    {
     95        psMemId id = psMemGetId();
    8296        psString input = psStringCopy(ORIGINAL);
    8397        psStringSubstitute(&input, "; This string is too long to fit in input(35 chars)", ".");
    … …  
    86100           "output = %s", input);
    87101        psFree(input);
    88         mem();
     102        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    89103    }
    90 
    91 
    92     return exit_status();
    93104}

  • trunk/psLib/test/sys/tap_psTrace.c

    r12513 r12781  
    88#include <fcntl.h>
    99#include <unistd.h>
    10 
    1110#include "pslib.h"
    1211#include "tap.h"
    … …  
    1413
    1514
    16 static psS32 testTrace00(void);
    17 static psS32 testTrace01(void);
    18 static psS32 testTrace02(void);
    19 static psS32 testTrace03(void);
    20 static psS32 testTrace04(void);
    21 static psS32 testTrace05(void);
    22 static psS32 testTrace05a(void);
    23 static psS32 testTrace06(void);
    24 static psS32 testTrace08(void);
    25 
    26 
    2715psS32 main( psS32 argc, char* argv[] )
    2816{
    29     plan_tests(45);
    30 
    31     testTrace00();
    32     testTrace01();
    33     testTrace02();
    34     testTrace03();
    35     testTrace04();
    36     testTrace05();
    37     testTrace05a();
    38     testTrace06();
    39     testTrace08();
    40 }
    41 
    42 
    43 static psS32 testTrace00(void)
    44 {
    45 //    diag("testTrace00");
    46 
    47     psS32 i;
    48     psS32 lev = 0;
    49 
    50     //    psTraceSetDestination(stderr);
    51     (void)psTraceSetDestination(2);
    52 
    53     for (i=0;i<10;i++) {
    54         (void)psTraceSetLevel(".", i);
    55         lev = psTraceGetLevel(".");
    56         ok(lev == i, "trace level was %d, actual was %d\n", i, lev);
    57     }
    58 
    59     (void)psTraceSetLevel(".", 3);
    60 
    61     for (i=5;i<10;i++) {
    62         (void)psTraceSetLevel(".NODE00", i);
    63         lev = psTraceGetLevel(".NODE00");
    64         ok (lev == i,"(.NODE00) expected trace level was %d, actual was %d\n",
    65             i, lev);
    66 
    67         lev = psTraceGetLevel(".");
    68         ok (lev == 3,
    69             "expected trace level was %d, actual was %d\n", i, 3);
    70     }
    71 
    72 
    73     (void)psTraceSetLevel(".NODE00.NODE01", 4);
    74     for (i=0;i<10;i++) {
    75         (void)psTraceSetLevel(".NODE00.NODE01", i);
    76         lev = psTraceGetLevel(".NODE00.NODE01");
    77         ok (lev == i,
    78             "(.NODE00.NODE01) expected trace level was %d, actual was %d\n",
    79             i, lev);
    80     }
    81 
    82     return 0;
    83 }
    84 
    85 
    86 static psS32 testTrace01(void)
    87 {
    88 //    diag("testTrace01");
    89 
    90     //    psTraceSetDestination(stderr);
    91     (void)psTraceSetDestination(2);
    92     (void)psTraceSetLevel(".A.B.C.D.E", 5);
    93 
    94     psTrace(".A.C.D.C",1,"You should not see this.\n");
    95     psTrace(".A.B.C.D.E",2,"You should see this.\n");
    96     psTrace(".A.B.C.D.E.F",3,"You should see this too.\n");
    97 
    98     psTracePrintLevels();
    99 
    100     return 0;
    101 }
    102 
    103 static psS32 testTrace02(void)
    104 {
    105 //    diag("testTrace02");
    106 
    107     psTraceReset();
    108     //    psTraceSetDestination(stderr);
    109     (void)psTraceSetDestination(2);
    110     (void)psTraceSetLevel(".A.B", 2);
    111     (void)psTraceSetLevel(".A.B.C.D.E", 5);
    112     psTracePrintLevels();
    113     (void)psTraceSetLevel(".A.B", 10);
    114     psTracePrintLevels();
    115 
    116     ok (10 == psTraceGetLevel(".A.B.C"),
    117         ".A.B.C did not dynamically inherit a trace level (%d)\n",
    118         psTraceGetLevel(".A.B.C"));
    119 
    120     ok (10 == psTraceGetLevel(".A.B.C.D"),
    121         ".A.B.C.D did not dynamically inherit a trace level (%d)\n",
    122         psTraceGetLevel(".A.B.C.D"));
    123 
    124     ok (5 == psTraceGetLevel(".A.B.C.D.E"),
    125         ".A.B.C.D.E did dynamically inherit a trace level (%d)\n",
    126         psTraceGetLevel(".A.B.C.D.E"));
    127 
    128     return 0;
    129 }
    130 
    131 static psS32 testTrace03(void)
    132 {
    133 //    diag("testTrace03");
    134 
    135     psS32 i = 0;
    136     psS32 lev = 0;
    137 
    138     //    psTraceSetDestination(stderr);
    139     (void)psTraceSetDestination(2);
    140 
    141     for (i=0;i<10;i++) {
    142         (void)psTraceSetLevel(".", i);
    143         psTraceReset();
    144 
    145         lev = psTraceGetLevel(".");
    146         ok (lev == PS_UNKNOWN_TRACE_LEVEL,
    147             "expected trace level was %d, actual was %d\n",
    148             PS_UNKNOWN_TRACE_LEVEL, lev);
    149     }
    150 
    151     (void)psTraceSetLevel(".", 5);
    152     (void)psTraceSetLevel(".a", 4);
    153     (void)psTraceSetLevel(".a.b", 3);
    154     (void)psTraceSetLevel(".a.b.c", 2);
    155     ok (!((5 != psTraceGetLevel(".")) ||
    156           (4 != psTraceGetLevel(".a")) ||
    157           (3 != psTraceGetLevel(".a.b")) ||
    158           (2 != psTraceGetLevel(".a.b.c"))),
    159         "trace successFlag = false;levels were not settable?\n");
    160 
    161     psTraceReset();
    162     ok (!((PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".")) ||
    163           (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a")) ||
    164           (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a.b")) ||
    165           (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a.b.c"))),
    166         "trace levels were not reset properly\n");
    167 
    168     return 0;
    169 }
    170 
    171 
    172 static psS32 testTrace04(void)
    173 {
    174 //    diag("testTrace04");
    175 
    176     int FD;
    177     psS32 nb = 0;
    178     FD = creat("tst_psTrace02_OUT", 0666);
    179     //    printf("\nFD = %d\n", FD);
    180     //    fp = fopen("tst_psTrace02_OUT", "w");
    181     for (nb = 0 ; nb<4;nb++) {
    182         if (nb == 0)
    183             //            psTraceSetDestination(stdout);
    184             (void)psTraceSetDestination(1);
    185         if (nb == 1)
    186             //            psTraceSetDestination(stderr);
    187             (void)psTraceSetDestination(2);
    188         if (nb == 2)
    189             (void)psTraceSetDestination(0); //NULL
    190         if (nb == 3)
    191             (void)psTraceSetDestination(FD);
    192 
    193         (void)psTraceSetLevel(".", 4);
    194         psTrace(".", 5, "(0) This message should not be displayed (%x)\n",
    195                 0xbeefface);
    196         (void)psTraceSetLevel(".", 7);
    197         psTrace(".", 5, "(0) This message should be displayed (%x)\n",
    198                 0xbeefface);
    199 
     17    psLogSetFormat("HLNM");
     18    psLogSetLevel(PS_LOG_INFO);
     19    plan_tests(54);
     20
     21    // testTrace00()
     22    {
     23        psMemId id = psMemGetId();
     24        psS32 lev = 0;
     25        (void)psTraceSetDestination(2);
     26        for (int i=0;i<10;i++) {
     27            (void)psTraceSetLevel(".", i);
     28            lev = psTraceGetLevel(".");
     29            ok(lev == i, "trace level was %d, actual was %d", i, lev);
     30        }
     31
     32        (void)psTraceSetLevel(".", 3);
     33        for (int i=5;i<10;i++) {
     34            (void)psTraceSetLevel(".NODE00", i);
     35            lev = psTraceGetLevel(".NODE00");
     36            ok (lev == i,"(.NODE00) expected trace level was %d, actual was %d",
     37                i, lev);
     38   
     39            lev = psTraceGetLevel(".");
     40            ok (lev == 3,
     41                "expected trace level was %d, actual was %d", i, 3);
     42        }
     43   
     44        (void)psTraceSetLevel(".NODE00.NODE01", 4);
     45        for (int i=0;i<10;i++) {
     46            (void)psTraceSetLevel(".NODE00.NODE01", i);
     47            lev = psTraceGetLevel(".NODE00.NODE01");
     48            ok (lev == i,
     49                "(.NODE00.NODE01) expected trace level was %d, actual was %d",
     50                i, lev);
     51        }
     52
     53        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     54    }
     55
     56
     57    // testTrace01()
     58    {
     59        psMemId id = psMemGetId();
     60        (void)psTraceSetDestination(2);
     61        (void)psTraceSetLevel(".A.B.C.D.E", 5);
     62        psTrace(".A.C.D.C",1,"You should not see this");
     63        psTrace(".A.B.C.D.E",2,"You should see this");
     64        psTrace(".A.B.C.D.E.F",3,"You should see this too");
     65        psTracePrintLevels();
     66        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     67    }
     68
     69
     70    // testTrace02()
     71    {
     72        psMemId id = psMemGetId();
     73        psTraceReset();
     74        (void)psTraceSetDestination(2);
     75        (void)psTraceSetLevel(".A.B", 2);
     76        (void)psTraceSetLevel(".A.B.C.D.E", 5);
     77        psTracePrintLevels();
     78        (void)psTraceSetLevel(".A.B", 10);
     79        psTracePrintLevels();
     80
     81        ok (10 == psTraceGetLevel(".A.B.C"),
     82            ".A.B.C did not dynamically inherit a trace level (%d)",
     83            psTraceGetLevel(".A.B.C"));
     84
     85        ok (10 == psTraceGetLevel(".A.B.C.D"),
     86            ".A.B.C.D did not dynamically inherit a trace level (%d)",
     87            psTraceGetLevel(".A.B.C.D"));
     88
     89        ok (5 == psTraceGetLevel(".A.B.C.D.E"),
     90            ".A.B.C.D.E did dynamically inherit a trace level (%d)",
     91            psTraceGetLevel(".A.B.C.D.E"));
     92        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     93    }
     94
     95
     96    // testTrace03()
     97    {
     98        psMemId id = psMemGetId();
     99        (void)psTraceSetDestination(2);
     100
     101        for (int i=0;i<10;i++) {
     102            (void)psTraceSetLevel(".", i);
     103            psTraceReset();
     104            int lev = psTraceGetLevel(".");
     105            ok (lev == PS_UNKNOWN_TRACE_LEVEL,
     106                "expected trace level was %d, actual was %d",
     107                PS_UNKNOWN_TRACE_LEVEL, lev);
     108        }
     109
     110        (void)psTraceSetLevel(".", 5);
    200111        (void)psTraceSetLevel(".a", 4);
    201         psTrace(".a", 5, "(1) This message should not be displayed (%x)\n",
    202                 0xbeefface);
    203         (void)psTraceSetLevel(".a", 7);
    204         psTrace(".a", 5, "(1) This message should be displayed (%x)\n",
    205                 0xbeefface);
    206 
    207 
    208         (void)psTraceSetLevel(".a.b", 4);
    209         psTrace(".a.b", 5, "(2) This message should not be displayed (%x)\n",
    210                 0xbeefface);
    211         (void)psTraceSetLevel(".a.b", 7);
    212         psTrace(".a.b", 5, "(2) This message should be displayed (%x)\n",
    213                 0xbeefface);
    214         (void)psTraceSetLevel(".a.b.c", 12);
    215         psTrace(".a.b.c", 11, "(3) This message should be displayed (%x)\n",
    216                 0xbeefface);
    217 
    218     }
    219 
    220     close(FD);
    221 
    222     return(0);
    223 }
    224 
    225 static psS32 testTrace05(void)
    226 {
    227     //    psTraceSetDestination(stderr);
    228     (void)psTraceSetDestination(2);
    229 
    230     (void)psTraceSetLevel(".", 9);
    231 
    232     (void)psTraceSetLevel(".a", 8);
    233     (void)psTraceSetLevel(".b", 7);
    234     (void)psTraceSetLevel(".c", 5);
    235 
    236     (void)psTraceSetLevel(".a.a", 4);
    237     (void)psTraceSetLevel(".a.b", 3);
    238 
    239     (void)psTraceSetLevel(".b.a", 2);
    240     (void)psTraceSetLevel(".b.b", 1);
    241 
    242     (void)psTraceSetLevel(".c.a", 0);
    243     (void)psTraceSetLevel(".c.b", 3);
    244     (void)psTraceSetLevel(".c.c", 5);
    245 
    246     psTracePrintLevels();
    247 
    248     return 0;
    249 
    250 }
    251 
    252 static psS32 testTrace05a(void)
    253 {
    254     (void)psTraceSetLevel(".", 9);
    255 
    256     (void)psTraceSetLevel("a", 8);
    257     (void)psTraceSetLevel("b", 7);
    258     (void)psTraceSetLevel("c", 5);
    259 
    260     (void)psTraceSetLevel("a.a", 4);
    261     (void)psTraceSetLevel("a.b", 3);
    262 
    263     (void)psTraceSetLevel("b.a", 2);
    264     (void)psTraceSetLevel("b.b", 1);
    265 
    266     (void)psTraceSetLevel("c.a", 0);
    267     (void)psTraceSetLevel("c.b", 3);
    268     (void)psTraceSetLevel("c.c", 5);
    269 
    270     psTracePrintLevels();
    271 
    272     return 0;
    273 
    274 }
    275 
    276 static psS32 testTrace06(void)
    277 {
    278     //    psTraceSetDestination(stderr);
    279     (void)psTraceSetDestination(2);
    280 
    281     (void)psTraceSetLevel(".", 9);
    282 
    283     (void)psTraceSetLevel(".a", 8);
    284     (void)psTraceSetLevel(".b", 7);
    285     (void)psTraceSetLevel(".c", 5);
    286 
    287     (void)psTraceSetLevel(".a.a", 4);
    288     (void)psTraceSetLevel(".a.b", 3);
    289 
    290     (void)psTraceSetLevel(".b.a", 2);
    291     (void)psTraceSetLevel(".b.b", 1);
    292 
    293     (void)psTraceSetLevel(".c.a", 0);
    294     (void)psTraceSetLevel(".c.b", 3);
    295     (void)psTraceSetLevel(".c.c", 5);
    296 
    297     psTraceReset();
    298 
    299     if ((psTraceGetLevel(".")!=PS_UNKNOWN_TRACE_LEVEL) ||
     112        (void)psTraceSetLevel(".a.b", 3);
     113        (void)psTraceSetLevel(".a.b.c", 2);
     114        ok (!((5 != psTraceGetLevel(".")) ||
     115              (4 != psTraceGetLevel(".a")) ||
     116              (3 != psTraceGetLevel(".a.b")) ||
     117              (2 != psTraceGetLevel(".a.b.c"))),
     118            "trace successFlag = false;levels were not settable?");
     119
     120        psTraceReset();
     121        ok (!((PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".")) ||
     122              (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a")) ||
     123              (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a.b")) ||
     124              (PS_UNKNOWN_TRACE_LEVEL != psTraceGetLevel(".a.b.c"))),
     125            "trace levels were not reset properly");
     126        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     127    }
     128
     129
     130    // testTrace04()
     131    {
     132        psMemId id = psMemGetId();
     133        int FD = creat("tst_psTrace02_OUT", 0666);
     134        for (int nb = 0 ; nb<4;nb++) {
     135            if (nb == 0)
     136                (void)psTraceSetDestination(1);
     137            if (nb == 1)
     138                (void)psTraceSetDestination(2);
     139            if (nb == 2)
     140                (void)psTraceSetDestination(0);
     141            if (nb == 3)
     142                (void)psTraceSetDestination(FD);
     143
     144            (void)psTraceSetLevel(".", 4);
     145            psTrace(".", 5, "(0) This message should not be displayed (%x)",
     146                    0xbeefface);
     147            (void)psTraceSetLevel(".", 7);
     148            psTrace(".", 5, "(0) This message should be displayed (%x)",
     149                    0xbeefface);
     150
     151            (void)psTraceSetLevel(".a", 4);
     152            psTrace(".a", 5, "(1) This message should not be displayed (%x)",
     153                    0xbeefface);
     154            (void)psTraceSetLevel(".a", 7);
     155            psTrace(".a", 5, "(1) This message should be displayed (%x)",
     156                    0xbeefface);
     157
     158            (void)psTraceSetLevel(".a.b", 4);
     159            psTrace(".a.b", 5, "(2) This message should not be displayed (%x)",
     160                    0xbeefface);
     161            (void)psTraceSetLevel(".a.b", 7);
     162            psTrace(".a.b", 5, "(2) This message should be displayed (%x)",
     163                    0xbeefface);
     164            (void)psTraceSetLevel(".a.b.c", 12);
     165            psTrace(".a.b.c", 11, "(3) This message should be displayed (%x)",
     166                    0xbeefface);
     167        }
     168        close(FD);
     169        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     170    }
     171
     172
     173    // testTrace05()
     174    {
     175        psMemId id = psMemGetId();
     176        (void)psTraceSetDestination(2);
     177        (void)psTraceSetLevel(".", 9);
     178        (void)psTraceSetLevel(".a", 8);
     179        (void)psTraceSetLevel(".b", 7);
     180        (void)psTraceSetLevel(".c", 5);
     181        (void)psTraceSetLevel(".a.a", 4);
     182        (void)psTraceSetLevel(".a.b", 3);
     183        (void)psTraceSetLevel(".b.a", 2);
     184        (void)psTraceSetLevel(".b.b", 1);
     185        (void)psTraceSetLevel(".c.a", 0);
     186        (void)psTraceSetLevel(".c.b", 3);
     187        (void)psTraceSetLevel(".c.c", 5);
     188        psTracePrintLevels();
     189        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     190    }
     191
     192
     193    // testTrace05a()
     194    {
     195        psMemId id = psMemGetId();
     196        (void)psTraceSetLevel(".", 9);
     197        (void)psTraceSetLevel("a", 8);
     198        (void)psTraceSetLevel("b", 7);
     199        (void)psTraceSetLevel("c", 5);
     200        (void)psTraceSetLevel("a.a", 4);
     201        (void)psTraceSetLevel("a.b", 3);
     202        (void)psTraceSetLevel("b.a", 2);
     203        (void)psTraceSetLevel("b.b", 1);
     204        (void)psTraceSetLevel("c.a", 0);
     205        (void)psTraceSetLevel("c.b", 3);
     206        (void)psTraceSetLevel("c.c", 5);
     207        psTracePrintLevels();
     208        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     209    }
     210
     211
     212    // testTrace06()
     213    {
     214        psMemId id = psMemGetId();
     215        (void)psTraceSetDestination(2);
     216        (void)psTraceSetLevel(".", 9);
     217        (void)psTraceSetLevel(".a", 8);
     218        (void)psTraceSetLevel(".b", 7);
     219        (void)psTraceSetLevel(".c", 5);
     220        (void)psTraceSetLevel(".a.a", 4);
     221        (void)psTraceSetLevel(".a.b", 3);
     222        (void)psTraceSetLevel(".b.a", 2);
     223        (void)psTraceSetLevel(".b.b", 1);
     224        (void)psTraceSetLevel(".c.a", 0);
     225        (void)psTraceSetLevel(".c.b", 3);
     226        (void)psTraceSetLevel(".c.c", 5);
     227        psTraceReset();
     228
     229        if ((psTraceGetLevel(".")!=PS_UNKNOWN_TRACE_LEVEL) ||
    300230            (psTraceGetLevel(".a")!=PS_UNKNOWN_TRACE_LEVEL) ||
    301231            (psTraceGetLevel(".b")!=PS_UNKNOWN_TRACE_LEVEL) ||
    … …  
    308238            (psTraceGetLevel(".c.b")!=PS_UNKNOWN_TRACE_LEVEL) ||
    309239            (psTraceGetLevel(".c.c")!=PS_UNKNOWN_TRACE_LEVEL)) {
    310         return 1;
    311     }
    312 
    313     return 0;
    314 }
    315 
    316 // Ensure that the leading dot in the component names are optional.
    317 static psS32 testTrace08(void)
    318 {
    319     psTraceReset();
    320     (void)psTraceSetLevel(".", 9);
    321 
    322     (void)psTraceSetLevel(".a", 8);
    323     (void)psTraceSetLevel(".b", 7);
    324     (void)psTraceSetLevel(".c", 5);
    325 
    326     (void)psTraceSetLevel(".a.a", 4);
    327     (void)psTraceSetLevel(".a.b", 3);
    328 
    329     (void)psTraceSetLevel(".b.a", 2);
    330     (void)psTraceSetLevel(".b.b", 1);
    331 
    332     (void)psTraceSetLevel(".c.a", 0);
    333     (void)psTraceSetLevel(".c.b", 3);
    334     (void)psTraceSetLevel(".c.c", 5);
    335 
    336     psTracePrintLevels();
    337 
    338     if ((psTraceGetLevel(".")!=9) ||
     240            return 1;
     241        }
     242        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     243    }
     244
     245
     246    // Ensure that the leading dot in the component names are optional.
     247    // testTrace08()
     248    {
     249        psMemId id = psMemGetId();
     250        psTraceReset();
     251        (void)psTraceSetLevel(".", 9);
     252        (void)psTraceSetLevel(".a", 8);
     253        (void)psTraceSetLevel(".b", 7);
     254        (void)psTraceSetLevel(".c", 5);
     255        (void)psTraceSetLevel(".a.a", 4);
     256        (void)psTraceSetLevel(".a.b", 3);
     257        (void)psTraceSetLevel(".b.a", 2);
     258        (void)psTraceSetLevel(".b.b", 1);
     259        (void)psTraceSetLevel(".c.a", 0);
     260        (void)psTraceSetLevel(".c.b", 3);
     261        (void)psTraceSetLevel(".c.c", 5);
     262        psTracePrintLevels();
     263        if ((psTraceGetLevel(".")!=9) ||
    339264            (psTraceGetLevel("a")!=8) ||
    340265            (psTraceGetLevel("b")!=7) ||
    … …  
    347272            (psTraceGetLevel("c.b")!=3) ||
    348273            (psTraceGetLevel("c.c")!=5)) {
    349         printf("psTraceGetLevel(.) is %d\n", psTraceGetLevel("."));
    350         printf("psTraceGetLevel(a) is %d\n", psTraceGetLevel("a"));
    351         printf("psTraceGetLevel(b) is %d\n", psTraceGetLevel("b"));
    352         printf("psTraceGetLevel(c) is %d\n", psTraceGetLevel("c"));
    353         printf("psTraceGetLevel(a.a) is %d\n", psTraceGetLevel("a.a"));
    354         printf("psTraceGetLevel(a.b) is %d\n", psTraceGetLevel("a.b"));
    355         printf("psTraceGetLevel(b.a) is %d\n", psTraceGetLevel("b.a"));
    356         printf("psTraceGetLevel(b.b) is %d\n", psTraceGetLevel("b.b"));
    357         printf("psTraceGetLevel(c.a) is %d\n", psTraceGetLevel("c.a"));
    358         printf("psTraceGetLevel(c.b) is %d\n", psTraceGetLevel("c.b"));
    359         printf("psTraceGetLevel(c.c) is %d\n", psTraceGetLevel("c.c"));
    360 
    361         return 1;
    362     }
    363 
    364     return 0;
     274            printf("psTraceGetLevel(.) is %d", psTraceGetLevel("."));
     275            printf("psTraceGetLevel(a) is %d", psTraceGetLevel("a"));
     276            printf("psTraceGetLevel(b) is %d", psTraceGetLevel("b"));
     277            printf("psTraceGetLevel(c) is %d", psTraceGetLevel("c"));
     278            printf("psTraceGetLevel(a.a) is %d", psTraceGetLevel("a.a"));
     279            printf("psTraceGetLevel(a.b) is %d", psTraceGetLevel("a.b"));
     280            printf("psTraceGetLevel(b.a) is %d", psTraceGetLevel("b.a"));
     281            printf("psTraceGetLevel(b.b) is %d", psTraceGetLevel("b.b"));
     282            printf("psTraceGetLevel(c.a) is %d", psTraceGetLevel("c.a"));
     283            printf("psTraceGetLevel(c.b) is %d", psTraceGetLevel("c.b"));
     284            printf("psTraceGetLevel(c.c) is %d", psTraceGetLevel("c.c"));
     285            return 1;
     286        }
     287        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     288    }
    365289}

  • trunk/psLib/test/types/tap_psArguments_all.c

    r12239 r12781  
    1111 *
    1212 */
    13 
    1413#include <pslib.h>
    15 
    1614#include "tap.h"
    1715#include "pstap.h"
    18 
    19 void testArgumentGetParse(void);
    20 void testArgumentVerbosity(void);
    21 //void testLogTraceArguments(void);
    2216
    2317int main(void)
    … …  
    2519    psLogSetFormat("HLNM");
    2620    psLogSetLevel(PS_LOG_INFO);
    27     plan_tests(27);
    28 
    29     note("Tests for psArguments Functions");
    30 
    31     testArgumentGetParse();
    32     testArgumentVerbosity();
    33     //    testLogTraceArguments();
    34 
    35     done();
     21    plan_tests(28);
     22
     23    // testArgumentGetParse()
     24    {
     25        psMemId id = psMemGetId();
     26        psMetadata *arg = NULL;
     27        char *argv[25];
     28        argv[0] = "./program";
     29        argv[1] = "-string";
     30        argv[2] = "new";
     31        argv[3] = "-float";
     32        argv[4] = "6.66";
     33        argv[5] = "-double";
     34        argv[6] = "0.666";
     35        argv[7] = "-int";
     36        argv[8] = "8";
     37        argv[9] = "-int";
     38        argv[10] = "16";
     39        argv[11] = "-int";
     40        argv[12] = "32";
     41        argv[13] = "-int";
     42        argv[14] = "64";
     43        argv[15] = "-U8";
     44        argv[16] = "1";
     45        argv[17] = "-U16";
     46        argv[18] = "666";
     47        argv[19] = "-U32";
     48        argv[20] = "666";
     49        argv[21] = "-Bool";
     50        argv[22] = "true";
     51        argv[23] = "-int";
     52        //    argv[24] = "32";
     53        argv[24] = "-vvv";
     54        int argc = 25;
     55
     56        //Try to get an argument's position
     57        int i = psArgumentGet(argc, argv, "-float");
     58        {
     59            ok( i == 3,
     60                "psArgumentGet:         return correct location of input argument.");
     61        }
     62
     63        //Return 0 for attempting to get from a NULL input argument.
     64        {
     65            ok( psArgumentGet(argc, NULL, "-float") == 0,
     66                "psArgumentGet:         return 0 for a NULL input argument.");
     67        }
     68
     69        //Return 0 for attempting to find a NULL string
     70        {
     71            ok( psArgumentGet(argc, argv, NULL) == 0,
     72                "psArgumentGet:         return 0 for a NULL input string.");
     73        }
     74
     75        //Return 0 for attempting to find an empty string
     76        {
     77            ok( psArgumentGet(argc, argv, "") == 0,
     78                "psArgumentGet:         return 0 for an empty input string.");
     79        }
     80
     81        //Return 0 for attempting to get an argument that doesn't match
     82        {
     83            ok( psArgumentGet(argc, argv, "-xxx") == 0,
     84                "psArgumentGet:         return 0 for an empty input string.");
     85        }
     86
     87        //Return false for attempting to remove argnum = 0
     88        {
     89            ok( !psArgumentRemove(0, &argc, argv),
     90                "psArgumentRemove:      return false for argnum = 0.");
     91        }
     92
     93        //Return false for attempting to remove NULL argc
     94        {
     95            ok( !psArgumentRemove(0, NULL, argv),
     96                "psArgumentRemove:      return false for NULL argc.");
     97        }
     98
     99        //Setup the argument list for comparison
     100        psMetadata *args = psMetadataAlloc();
     101        psMetadataAdd(args, PS_LIST_TAIL, "-string", PS_DATA_STRING, "Test String", "SomeString");
     102        psMetadataAdd(args, PS_LIST_TAIL, "-float", PS_DATA_F32, "Test Float", 0.666);
     103        psMetadataAdd(args, PS_LIST_TAIL, "-double", PS_DATA_F64, "Test Double", 0.666);
     104        psMetadata *ints = psMetadataAlloc();
     105        psMetadataAdd(ints, PS_LIST_TAIL, "int1", PS_DATA_S8, "Int1", 8);
     106        psMetadataAdd(ints, PS_LIST_TAIL, "int2", PS_DATA_S16, "Int2", 16);
     107        psMetadataAdd(ints, PS_LIST_TAIL, "int3", PS_DATA_S32, "Int3", 32);
     108        psMetadataAdd(ints, PS_LIST_TAIL, "int4", PS_DATA_S64, "Int4", 64);
     109        psMetadataAdd(args, PS_LIST_TAIL, "-int", PS_DATA_METADATA, "Integers", ints);
     110        psFree(ints);                  // Drop reference
     111        psMetadataAddS32(args, PS_LIST_TAIL, "-multi", 0, "666", 2);
     112        psMetadataAddS32(args, PS_LIST_TAIL, "-multi", PS_META_DUPLICATE_OK, "hello kitty", 1);
     113
     114        psMetadataAddU8(args, PS_LIST_TAIL, "-U8", 0, "U8", 1);
     115        psMetadataAddU16(args, PS_LIST_TAIL, "-U16", 0, "U16", 666);
     116        psMetadataAddU32(args, PS_LIST_TAIL, "-U32", 0, "U32", 666);
     117        psMetadataAddU64(args, PS_LIST_TAIL, "-U64", 0, "U64", 666);
     118        psMetadataAddBool(args, PS_LIST_TAIL, "-Bool", 0, "boolean", true);
     119        psMetadataAddBool(args, PS_LIST_TAIL, "-Bool2", 0, "boolean", false);
     120        psSphere *sphere = psSphereAlloc();
     121        sphere->r = 6.66;
     122        sphere->d = 666.666;
     123        psMetadataAddPtr(args, PS_LIST_TAIL, "ptr", PS_DATA_SPHERE, "", sphere);
     124        psFree(sphere);
     125
     126        //psArgumentHelp test
     127        //Do nothing for NULL input (exit gracefully)
     128        psArgumentHelp(NULL);
     129        //Print the Argument help for valid metadata
     130        psArgumentHelp(args);
     131
     132        //psArgumentParse tests
     133        //Return false for NULL input arguments
     134        {
     135            ok( !psArgumentParse(NULL, &argc, argv),
     136                "psArgumentParse:       return false for NULL argument metadata input.");
     137        }
     138
     139        //Return false for NULL input argc
     140        {
     141            ok( !psArgumentParse(args, NULL, argv),
     142                "psArgumentParse:       return false for NULL argc input.");
     143        }
     144
     145        //Return false for NULL input argv
     146        {
     147            ok( !psArgumentParse(args, &argc, NULL),
     148                "psArgumentParse:       return false for NULL argv input.");
     149        }
     150
     151        //Return false for argc = 0
     152        {
     153            int tempc = 0;
     154            ok( !psArgumentParse(args, &tempc, argv),
     155                "psArgumentParse:       return false for argc = 1 input.");
     156        }
     157
     158        //Return false for string not found in metadata arguments
     159        {
     160            ok( !psArgumentParse(args, &argc, argv),
     161                "psArgumentParse:      return false for argv containing unspecified input.");
     162        }
     163
     164        //Return true for valid case
     165        {
     166            psArgumentRemove(25, &argc, argv);
     167            ok( psArgumentParse(args, &argc, argv),
     168                "psArgumentParse:      return true for valid inputs.");
     169        }
     170
     171        //Return false for inconsistent argc in metadata
     172        {
     173            psMetadata *tempArg = psMetadataAlloc();
     174            psMetadata *mdtemp = psMetadataAlloc();
     175            psMetadataAdd(mdtemp, PS_LIST_TAIL, "int1", PS_DATA_S8, "Int1", 8);
     176            psMetadataAdd(mdtemp, PS_LIST_TAIL, "int2", PS_DATA_S16, "Int2", 16);
     177            psMetadataAdd(mdtemp, PS_LIST_TAIL, "int3", PS_DATA_S32, "Int3", 32);
     178            psMetadataAdd(tempArg, PS_LIST_TAIL, "-int", PS_DATA_METADATA, "Integers", mdtemp);
     179            psFree(mdtemp);
     180            int argcc = 2;
     181            char *argvv[2];
     182            argvv[0] = "./program";
     183            argvv[1] = "-string";
     184            ok( !psArgumentParse(tempArg, &argcc, argvv),
     185                "psArgumentParse:      return false for inconsistent argc.");
     186            psFree(tempArg);
     187        }
     188
     189        //Return false for argc = 1
     190        {
     191            int argcc = 2;
     192            char *argvv[2];
     193            argvv[0] = "./program";
     194            argvv[1] = "-string";
     195            ok( !psArgumentParse(args, &argcc, argvv),
     196                "psArgumentParse:      return false for incomplete string syntax.");
     197        }
     198
     199        //Return true for an unfound MULTI match
     200        {
     201            int argcc = 3;
     202            char *argvv[3];
     203            argvv[0] = "./program";
     204            argvv[1] = "-multi";
     205            argvv[2] = "2";
     206            ok( psArgumentParse(args, &argcc, argvv),
     207                "psArgumentParse:      return true for MULTI.");
     208        }
     209
     210        //Check for Memory leaks
     211        {
     212            psFree(args);
     213            psFree(arg);
     214            checkMem();
     215        }
     216        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     217    }
     218
     219
     220    // testArgumentVerbosity()
     221    {
     222        psMemId id = psMemGetId();
     223        //Return 2 (default) for NULL input argument
     224        {
     225            int argc = 1;
     226            ok( psArgumentVerbosity(&argc, NULL) == 2,
     227                "psArgumentVerbosity:  return 2 for NULL argument input.");
     228        }
     229
     230        //Return 2 for NULL argc input
     231        {
     232            char *argv[1];
     233            argv[0] = "./program";
     234            ok( psArgumentVerbosity(NULL, argv) == 2,
     235                "psArgumentVerbosity:  return 2 for NULL argument input.");
     236        }
     237
     238        //Return 3 for "-v" option
     239        {
     240            int argc = 2;
     241            char *argv[2];
     242            argv[0] = "./program";
     243            argv[1] = "-v";
     244            ok( psArgumentVerbosity(&argc, argv) == 3,
     245                "psArgumentVerbosity:  return 3 for '-v' argument input.");
     246        }
     247
     248        //Return 4 for "-vv" option
     249        {
     250            int argc = 2;
     251            char *argv[2];
     252            argv[0] = "./program";
     253            argv[1] = "-vv";
     254            ok( psArgumentVerbosity(&argc, argv) == 4,
     255                "psArgumentVerbosity:  return 4 for '-vv' argument input.");
     256        }
     257
     258        //Return 5 for "-vvv" option
     259        {
     260            int argc = 2;
     261            char *argv[2];
     262            argv[0] = "./program";
     263            argv[1] = "-vvv";
     264            ok( psArgumentVerbosity(&argc, argv) == 5,
     265                "psArgumentVerbosity:  return 5 for '-vvv' argument input.");
     266        }
     267
     268        //These routines should return 5 since that was the last level set above with -vvv
     269        //Return 5 for "-logfmt" option
     270        {
     271            int argc = 2;
     272            char *argv[2];
     273            argv[0] = "./program";
     274            argv[1] = "-logfmt";
     275            int rc = psArgumentVerbosity(&argc, argv);
     276            ok(rc == 5, "psArgumentVerbosity:  return 5 for '-logfmt' argument input (was %d)", rc);
     277        }
     278
     279        //Return 5 for "-logfmt" option with "H"
     280        {
     281            int argc = 3;
     282            char *argv[3];
     283            argv[0] = "./program";
     284            argv[1] = "-logfmt";
     285            argv[2] = "H";
     286            int rc = psArgumentVerbosity(&argc, argv);
     287            ok(rc == 5, "psArgumentVerbosity:  return 5 for '-logfmt H' argument inputs (was %d)", rc);
     288        }
     289
     290        //Return 5 for "-trace" option
     291        {
     292            int argc = 2;
     293            char *argv[2];
     294            argv[0] = "./program";
     295            argv[1] = "-trace";
     296            int rc = psArgumentVerbosity(&argc, argv);
     297            ok(rc == 5, "psArgumentVerbosity:  return 5 for '-trace' argument input (was %d)", rc);
     298        }
     299
     300        //Return 5 for "-trace 1 2" option
     301        {
     302            int argc = 4;
     303            char *argv[4];
     304            argv[0] = "./program";
     305            argv[1] = "-trace";
     306            argv[2] = "1";
     307            argv[3] = "2";
     308            int rc = psArgumentVerbosity(&argc, argv);
     309            ok(rc == 5, "psArgumentVerbosity:  return 5 for '-trace 1 2' argument inputs (was %d", rc);
     310        }
     311
     312        //Return 5 for "-trace-levels" option
     313        {
     314            int argc = 2;
     315            char *argv[2];
     316            argv[0] = "./program";
     317            argv[1] = "-trace-levels";
     318            int rc = psArgumentVerbosity(&argc, argv);
     319            ok(rc == 5, "psArgumentVerbosity:  return 5 for '-trace-levels' argument input (was %d)", rc);
     320        }
     321        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     322    }
    36323}
    37324
    38 void testArgumentGetParse(void)
    39 {
    40     note("  >>>Test 1:  psArgument Get, Remove, Parse, and Help Fxns");
    41     psMetadata *arg = NULL;
    42     char *argv[25];
    43     argv[0] = "./program";
    44     argv[1] = "-string";
    45     argv[2] = "new";
    46     argv[3] = "-float";
    47     argv[4] = "6.66";
    48     argv[5] = "-double";
    49     argv[6] = "0.666";
    50     argv[7] = "-int";
    51     argv[8] = "8";
    52     argv[9] = "-int";
    53     argv[10] = "16";
    54     argv[11] = "-int";
    55     argv[12] = "32";
    56     argv[13] = "-int";
    57     argv[14] = "64";
    58     argv[15] = "-U8";
    59     argv[16] = "1";
    60     argv[17] = "-U16";
    61     argv[18] = "666";
    62     argv[19] = "-U32";
    63     argv[20] = "666";
    64     argv[21] = "-Bool";
    65     argv[22] = "true";
    66     argv[23] = "-int";
    67     //    argv[24] = "32";
    68     argv[24] = "-vvv";
    69     int argc = 25;
    70 
    71     //Try to get an argument's position
    72     int i = psArgumentGet(argc, argv, "-float");
    73     {
    74         ok( i == 3,
    75             "psArgumentGet:         return correct location of input argument.");
    76     }
    77     //Return 0 for attempting to get from a NULL input argument.
    78     {
    79         ok( psArgumentGet(argc, NULL, "-float") == 0,
    80             "psArgumentGet:         return 0 for a NULL input argument.");
    81     }
    82     //Return 0 for attempting to find a NULL string
    83     {
    84         ok( psArgumentGet(argc, argv, NULL) == 0,
    85             "psArgumentGet:         return 0 for a NULL input string.");
    86     }
    87     //Return 0 for attempting to find an empty string
    88     {
    89         ok( psArgumentGet(argc, argv, "") == 0,
    90             "psArgumentGet:         return 0 for an empty input string.");
    91     }
    92     //Return 0 for attempting to get an argument that doesn't match
    93     {
    94         ok( psArgumentGet(argc, argv, "-xxx") == 0,
    95             "psArgumentGet:         return 0 for an empty input string.");
    96     }
    97     //Return false for attempting to remove argnum = 0
    98     {
    99         ok( !psArgumentRemove(0, &argc, argv),
    100             "psArgumentRemove:      return false for argnum = 0.");
    101     }
    102     //Return false for attempting to remove NULL argc
    103     {
    104         ok( !psArgumentRemove(0, NULL, argv),
    105             "psArgumentRemove:      return false for NULL argc.");
    106     }
    107 
    108     //Setup the argument list for comparison
    109     psMetadata *args = psMetadataAlloc();
    110     psMetadataAdd(args, PS_LIST_TAIL, "-string", PS_DATA_STRING, "Test String", "SomeString");
    111     psMetadataAdd(args, PS_LIST_TAIL, "-float", PS_DATA_F32, "Test Float", 0.666);
    112     psMetadataAdd(args, PS_LIST_TAIL, "-double", PS_DATA_F64, "Test Double", 0.666);
    113     psMetadata *ints = psMetadataAlloc();
    114     psMetadataAdd(ints, PS_LIST_TAIL, "int1", PS_DATA_S8, "Int1", 8);
    115     psMetadataAdd(ints, PS_LIST_TAIL, "int2", PS_DATA_S16, "Int2", 16);
    116     psMetadataAdd(ints, PS_LIST_TAIL, "int3", PS_DATA_S32, "Int3", 32);
    117     psMetadataAdd(ints, PS_LIST_TAIL, "int4", PS_DATA_S64, "Int4", 64);
    118     psMetadataAdd(args, PS_LIST_TAIL, "-int", PS_DATA_METADATA, "Integers", ints);
    119     psFree(ints);                  // Drop reference
    120     psMetadataAddS32(args, PS_LIST_TAIL, "-multi", 0, "666", 2);
    121     psMetadataAddS32(args, PS_LIST_TAIL, "-multi", PS_META_DUPLICATE_OK, "hello kitty", 1);
    122 
    123     psMetadataAddU8(args, PS_LIST_TAIL, "-U8", 0, "U8", 1);
    124     psMetadataAddU16(args, PS_LIST_TAIL, "-U16", 0, "U16", 666);
    125     psMetadataAddU32(args, PS_LIST_TAIL, "-U32", 0, "U32", 666);
    126     psMetadataAddU64(args, PS_LIST_TAIL, "-U64", 0, "U64", 666);
    127     psMetadataAddBool(args, PS_LIST_TAIL, "-Bool", 0, "boolean", true);
    128     psMetadataAddBool(args, PS_LIST_TAIL, "-Bool2", 0, "boolean", false);
    129     psSphere *sphere = psSphereAlloc();
    130     sphere->r = 6.66;
    131     sphere->d = 666.666;
    132     psMetadataAddPtr(args, PS_LIST_TAIL, "ptr", PS_DATA_SPHERE, "", sphere);
    133     psFree(sphere);
    134 
    135     //psArgumentHelp test
    136     //Do nothing for NULL input (exit gracefully)
    137     psArgumentHelp(NULL);
    138     //Print the Argument help for valid metadata
    139     psArgumentHelp(args);
    140 
    141     //psArgumentParse tests
    142     //Return false for NULL input arguments
    143     {
    144         ok( !psArgumentParse(NULL, &argc, argv),
    145             "psArgumentParse:       return false for NULL argument metadata input.");
    146     }
    147     //Return false for NULL input argc
    148     {
    149         ok( !psArgumentParse(args, NULL, argv),
    150             "psArgumentParse:       return false for NULL argc input.");
    151     }
    152     //Return false for NULL input argv
    153     {
    154         ok( !psArgumentParse(args, &argc, NULL),
    155             "psArgumentParse:       return false for NULL argv input.");
    156     }
    157     //Return false for argc = 0
    158     {
    159         int tempc = 0;
    160         ok( !psArgumentParse(args, &tempc, argv),
    161             "psArgumentParse:       return false for argc = 1 input.");
    162     }
    163     //Return false for string not found in metadata arguments
    164     {
    165         ok( !psArgumentParse(args, &argc, argv),
    166             "psArgumentParse:      return false for argv containing unspecified input.");
    167     }
    168     //Return true for valid case
    169     {
    170         psArgumentRemove(25, &argc, argv);
    171         ok( psArgumentParse(args, &argc, argv),
    172             "psArgumentParse:      return true for valid inputs.");
    173     }
    174     //Return false for inconsistent argc in metadata
    175     {
    176         psMetadata *tempArg = psMetadataAlloc();
    177         psMetadata *mdtemp = psMetadataAlloc();
    178         psMetadataAdd(mdtemp, PS_LIST_TAIL, "int1", PS_DATA_S8, "Int1", 8);
    179         psMetadataAdd(mdtemp, PS_LIST_TAIL, "int2", PS_DATA_S16, "Int2", 16);
    180         psMetadataAdd(mdtemp, PS_LIST_TAIL, "int3", PS_DATA_S32, "Int3", 32);
    181         psMetadataAdd(tempArg, PS_LIST_TAIL, "-int", PS_DATA_METADATA, "Integers", mdtemp);
    182         psFree(mdtemp);
    183         int argcc = 2;
    184         char *argvv[2];
    185         argvv[0] = "./program";
    186         argvv[1] = "-string";
    187         ok( !psArgumentParse(tempArg, &argcc, argvv),
    188             "psArgumentParse:      return false for inconsistent argc.");
    189         psFree(tempArg);
    190     }
    191     //Return false for argc = 1
    192     {
    193         int argcc = 2;
    194         char *argvv[2];
    195         argvv[0] = "./program";
    196         argvv[1] = "-string";
    197         ok( !psArgumentParse(args, &argcc, argvv),
    198             "psArgumentParse:      return false for incomplete string syntax.");
    199     }
    200     //Return true for an unfound MULTI match
    201     {
    202         int argcc = 3;
    203         char *argvv[3];
    204         argvv[0] = "./program";
    205         argvv[1] = "-multi";
    206         argvv[2] = "2";
    207         ok( psArgumentParse(args, &argcc, argvv),
    208             "psArgumentParse:      return true for MULTI.");
    209     }
    210 
    211     //Check for Memory leaks
    212     {
    213         psFree(args);
    214         psFree(arg);
    215         checkMem();
    216     }
    217 }
    218 
    219 
    220 
    221 
    222 
    223 
    224 
    225 void testArgumentVerbosity(void)
    226 {
    227     note("  >>>Test 2:  psArgumentRemove & psArgumentVerbosity Fxns");
    228 
    229     //Return 2 (default) for NULL input argument
    230     {
    231         int argc = 1;
    232         ok( psArgumentVerbosity(&argc, NULL) == 2,
    233             "psArgumentVerbosity:  return 2 for NULL argument input.");
    234     }
    235     //Return 2 for NULL argc input
    236     {
    237         char *argv[1];
    238         argv[0] = "./program";
    239         ok( psArgumentVerbosity(NULL, argv) == 2,
    240             "psArgumentVerbosity:  return 2 for NULL argument input.");
    241     }
    242     //Return 3 for "-v" option
    243     {
    244         int argc = 2;
    245         char *argv[2];
    246         argv[0] = "./program";
    247         argv[1] = "-v";
    248         ok( psArgumentVerbosity(&argc, argv) == 3,
    249             "psArgumentVerbosity:  return 3 for '-v' argument input.");
    250     }
    251     //Return 4 for "-vv" option
    252     {
    253         int argc = 2;
    254         char *argv[2];
    255         argv[0] = "./program";
    256         argv[1] = "-vv";
    257         ok( psArgumentVerbosity(&argc, argv) == 4,
    258             "psArgumentVerbosity:  return 4 for '-vv' argument input.");
    259     }
    260     //Return 5 for "-vvv" option
    261     {
    262         int argc = 2;
    263         char *argv[2];
    264         argv[0] = "./program";
    265         argv[1] = "-vvv";
    266         ok( psArgumentVerbosity(&argc, argv) == 5,
    267             "psArgumentVerbosity:  return 5 for '-vvv' argument input.");
    268     }
    269     //These routines should return 5 since that was the last level set above with -vvv
    270     //Return 5 for "-logfmt" option
    271     {
    272         int argc = 2;
    273         char *argv[2];
    274         argv[0] = "./program";
    275         argv[1] = "-logfmt";
    276         int rc = psArgumentVerbosity(&argc, argv);
    277         ok(rc == 5, "psArgumentVerbosity:  return 5 for '-logfmt' argument input (was %d)", rc);
    278     }
    279     //Return 5 for "-logfmt" option with "H"
    280     {
    281         int argc = 3;
    282         char *argv[3];
    283         argv[0] = "./program";
    284         argv[1] = "-logfmt";
    285         argv[2] = "H";
    286         int rc = psArgumentVerbosity(&argc, argv);
    287         ok(rc == 5, "psArgumentVerbosity:  return 5 for '-logfmt H' argument inputs (was %d)", rc);
    288     }
    289     //Return 5 for "-trace" option
    290     {
    291         int argc = 2;
    292         char *argv[2];
    293         argv[0] = "./program";
    294         argv[1] = "-trace";
    295         int rc = psArgumentVerbosity(&argc, argv);
    296         ok(rc == 5, "psArgumentVerbosity:  return 5 for '-trace' argument input (was %d)", rc);
    297     }
    298     //Return 5 for "-trace 1 2" option
    299     {
    300         int argc = 4;
    301         char *argv[4];
    302         argv[0] = "./program";
    303         argv[1] = "-trace";
    304         argv[2] = "1";
    305         argv[3] = "2";
    306         int rc = psArgumentVerbosity(&argc, argv);
    307         ok(rc == 5, "psArgumentVerbosity:  return 5 for '-trace 1 2' argument inputs (was %d", rc);
    308     }
    309     //Return 5 for "-trace-levels" option
    310     {
    311         int argc = 2;
    312         char *argv[2];
    313         argv[0] = "./program";
    314         argv[1] = "-trace-levels";
    315         int rc = psArgumentVerbosity(&argc, argv);
    316         ok(rc == 5, "psArgumentVerbosity:  return 5 for '-trace-levels' argument input (was %d)", rc);
    317     }
    318 
    319     //Check for Memory leaks
    320     {
    321         checkMem();
    322     }
    323 }
    324 
    325 /*
     325
     326/* XXX: Why is this commented out?
    326327void testLogTraceArguments(void)
    327328{

  • trunk/psLib/test/types/tap_psArray_all.c

    r10822 r12781  
    1111 *
    1212 */
    13 
    1413#include <pslib.h>
    15 
    1614#include "tap.h"
    1715#include "pstap.h"
    1816
    19 void testArrayAllocs(void);
    20 void testArrayAddRemove(void);
    21 void testArraySetGet(void);
    22 void testArraySort(void);
    2317
    2418int main(void)
    2519{
    26     plan_tests(29);
    27 
    28     note("Tests for psArray Functions");
    29 
    30     testArrayAllocs();
    31     testArrayAddRemove( );
    32     testArraySetGet( );
    33     testArraySort();
    34 
    35     done();
    36 }
    37 
    38 void testArrayAllocs(void)
    39 {
    40     note("  >>>Test 1:  psArrayAlloc, Realloc, & Free Fxns");
    41     psArray *a = NULL;
    42 
    43     //Tests for psArrayAlloc
    44     //Return NULL on attempting to allocate a negative size array
     20    psLogSetFormat("HLNM");
     21    psLogSetLevel(PS_LOG_INFO);
     22    plan_tests(32);
     23
     24    // testArrayAllocs()
    4525    {
    46         a = psArrayAlloc(-2);
    47         ok( a == NULL,
    48             "psArrayAlloc:           return NULL for negative array-size input.");
     26        psMemId id = psMemGetId();
     27        psArray *a = NULL;
     28
     29        //Tests for psArrayAlloc
     30        //Return NULL on attempting to allocate a negative size array
     31        {
     32            a = psArrayAlloc(-2);
     33            ok( a == NULL,
     34                "psArrayAlloc:           return NULL for negative array-size input.");
     35        }
     36        //Return NULL for negative array size - psArrayAllocEmpty
     37        {
     38            a = psArrayAllocEmpty(-2);
     39            ok( a == NULL,
     40                "psArrayAllocEmpty:      return NULL for negative array-size input.");
     41        }
     42        //Return properly allocated psArray
     43        {
     44            a = psArrayAlloc(0);
     45            ok( a != NULL && psMemCheckArray(a),
     46                "psArrayAlloc:           return properly allocated psArray.");
     47        }
     48
     49        //Tests for psMemCheckArray
     50        //Make sure psMemCheckArray works correctly - return false
     51        {
     52            int j = 2;
     53            ok( !psMemCheckArray(&j),
     54                "psMemCheckArray:        return false for non-Array input.");
     55        }
     56        //Tests for psArrayRealloc
     57        //Now try to reallocate the psArray - bigger
     58        {
     59            a = psArrayRealloc(a, 2);
     60            ok ( psArrayLength(a) == 0 && a->nalloc == 2,
     61                 "psArrayRealloc:         return properly reallocated psArray.");
     62        }
     63        //Return NULL when trying to reallocate a NULL psArray
     64        {
     65            psArray *temp = NULL;
     66            temp = psArrayRealloc(temp, 1);
     67            ok( temp == NULL,
     68                "psArrayRealloc:         return NULL for NULL input psArray.");
     69        }
     70        //Attempt to reallocate the psArray - smaller
     71        {
     72            psS32 *s32 = (psS32*)psAlloc(sizeof(psS32));
     73            *s32 = 1;
     74            psS32 *s32_2 = (psS32*)psAlloc(sizeof(psS32));
     75            *s32_2 = 2;
     76            skip_start(  !psArraySet(a, 0, s32) || !psArraySet(a, 1, s32), 1,
     77                         "Skipping 1 tests because psArraySet failed");
     78            a = psArrayRealloc(a, 1);
     79            *s32_2 = *((psS32*)(a->data[0]));
     80            ok( a->n == 1 && a->nalloc == 1 && *s32_2 == 1,
     81                "psArrayRealloc:         return properly reallocated psArray.");
     82            skip_end();
     83            psFree(s32);
     84            psFree(s32_2);
     85        }
     86        //Attempt to reallocate the psArray to negative size
     87        {
     88            a = psArrayRealloc(a, -1);
     89            psS32 *s32 = (psS32*)psAlloc(sizeof(psS32));
     90            *s32 = 2;
     91            *s32 = *((psS32*)(a->data[0]));
     92            ok( a->n == 1 && a->nalloc == 1 && *s32 == 1,
     93                "psArrayRealloc:         return same psArray for negative-size input.");
     94            psFree(s32);
     95        }
     96   
     97        //Attempt to free a NULL psArray
     98        psArrayElementsFree(NULL);
     99        //Check the length of a NULL array
     100        {
     101            psArray *emptyArray = NULL;
     102            ok( psArrayLength(emptyArray) == -1,
     103                "psArrayLength:          return -1 for NULL input psArray.");
     104        }
     105        psFree(a);
     106        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    49107    }
    50     //Return NULL for negative array size - psArrayAllocEmpty
     108
     109
     110    // testArrayAddRemove()
    51111    {
    52         a = psArrayAllocEmpty(-2);
    53         ok( a == NULL,
    54             "psArrayAllocEmpty:      return NULL for negative array-size input.");
    55     }
    56     //Return properly allocated psArray
    57     {
    58         a = psArrayAlloc(0);
    59         ok( a != NULL && psMemCheckArray(a),
    60             "psArrayAlloc:           return properly allocated psArray.");
    61     }
    62 
    63     //Tests for psMemCheckArray
    64     //Make sure psMemCheckArray works correctly - return false
    65     {
    66         int j = 2;
    67         ok( !psMemCheckArray(&j),
    68             "psMemCheckArray:        return false for non-Array input.");
    69     }
    70     //Tests for psArrayRealloc
    71     //Now try to reallocate the psArray - bigger
    72     {
    73         a = psArrayRealloc(a, 2);
    74         ok ( psArrayLength(a) == 0 && a->nalloc == 2,
    75              "psArrayRealloc:         return properly reallocated psArray.");
    76     }
    77     //Return NULL when trying to reallocate a NULL psArray
    78     {
    79         psArray *temp = NULL;
    80         temp = psArrayRealloc(temp, 1);
    81         ok( temp == NULL,
    82             "psArrayRealloc:         return NULL for NULL input psArray.");
    83     }
    84     //Attempt to reallocate the psArray - smaller
    85     {
    86         psS32 *s32 = (psS32*)psAlloc(sizeof(psS32));
    87         *s32 = 1;
    88         psS32 *s32_2 = (psS32*)psAlloc(sizeof(psS32));
    89         *s32_2 = 2;
    90         skip_start(  !psArraySet(a, 0, s32) || !psArraySet(a, 1, s32), 1,
    91                      "Skipping 1 tests because psArraySet failed");
    92         a = psArrayRealloc(a, 1);
    93         *s32_2 = *((psS32*)(a->data[0]));
    94         ok( a->n == 1 && a->nalloc == 1 && *s32_2 == 1,
    95             "psArrayRealloc:         return properly reallocated psArray.");
    96         skip_end();
    97         psFree(s32);
    98         psFree(s32_2);
    99     }
    100     //Attempt to reallocate the psArray to negative size
    101     {
    102         a = psArrayRealloc(a, -1);
    103         psS32 *s32 = (psS32*)psAlloc(sizeof(psS32));
    104         *s32 = 2;
    105         *s32 = *((psS32*)(a->data[0]));
    106         ok( a->n == 1 && a->nalloc == 1 && *s32 == 1,
    107             "psArrayRealloc:         return same psArray for negative-size input.");
    108         psFree(s32);
    109     }
    110 
    111     //Attempt to free a NULL psArray
    112     psArrayElementsFree(NULL);
    113     //Check the length of a NULL array
    114     {
    115         psArray *emptyArray = NULL;
    116         ok( psArrayLength(emptyArray) == -1,
    117             "psArrayLength:          return -1 for NULL input psArray.");
    118     }
    119 
    120     //Check for Memory leaks
    121     {
    122         psFree(a);
    123         checkMem();
    124     }
    125 }
    126 
    127 void testArrayAddRemove(void)
    128 {
    129     note("  >>>Test 2:  psArrayAdd & psArrayRemove Fxns");
    130     psArray *a = psArrayAlloc(0);
    131     psS32 *s1 = (psS32*)psAlloc(sizeof(psS32));
    132     *s1 = 2;
    133     psS32 *s2 = (psS32*)psAlloc(sizeof(psS32));
    134     psS32 *s3 = (psS32*)psAlloc(sizeof(psS32));
    135 
    136     //Tests for psArrayAdd
    137     //Attempt to add element to NULL psArray.
    138     {
    139         psArray *temp = NULL;
    140         temp = psArrayAdd(temp, 1, (psPtr)s1);
    141         *s3 = *((psS32*)(temp->data[0]));
    142         ok( temp->n == 1 && temp->nalloc == 1 && *s3 == 2,
    143             "psArrayAdd:             return array with newly added data.");
    144         psFree(temp);
    145     }
    146     //Attempt to add an element to empty array.
    147     {
    148         a = psArrayAdd(a, 1, (psPtr)s1);
    149         *s2 = 666;
    150         *s3 = 212;
    151         a = psArrayAdd(a, 1, s2);
    152         a = psArrayAdd(a, 1, s3);
    153         *s2 = *((psS32*)(a->data[0]));
    154         ok ( a->n == 3 && a->nalloc == 3 && *s2 == 2,
    155              "psArrayAdd:            return array with newly added data.");
    156     }
    157 
    158     //Tests for psArrayRemoveData
    159     //Setup array with 3 elements to test remove function
    160     //Return false for attempting to remove from a NULL array
    161     {
    162         psArray *temp = NULL;
    163         ok( !psArrayRemoveData(temp, s2),
    164             "psArrayRemoveData:     return false for NULL input psArray.");
    165     }
    166     //Return true for successful removal
    167     {
    168         ok( psArrayRemoveData(a, s2) && a->n == 2,
    169             "psArrayRemoveData:     return true for successful removal.");
    170     }
    171 
    172     //Tests for psArrayRemoveIndex
    173     //Return false for NULL array input
    174     {
    175         ok( !psArrayRemoveIndex(NULL, 0),
    176             "psArrayRemoveIndex:    return false for NULL input psArray.");
    177     }
    178     //Return false for out-of-range index
    179     {
    180         ok( !psArrayRemoveIndex(a, 5),
    181             "psArrayRemoveIndex:    return false for out-of-range location.");
    182     }
    183     //Return true for successful removal
    184     {
    185         ok( psArrayRemoveIndex(a, 1) && a->n == 1,
    186             "psArrayRemoveIndex:    return true for successful removal.");
    187     }
    188 
    189     //Check for Memory leaks
    190     {
     112        psMemId id = psMemGetId();
     113        psArray *a = psArrayAlloc(0);
     114        psS32 *s1 = (psS32*)psAlloc(sizeof(psS32));
     115        *s1 = 2;
     116        psS32 *s2 = (psS32*)psAlloc(sizeof(psS32));
     117        psS32 *s3 = (psS32*)psAlloc(sizeof(psS32));
     118   
     119        //Tests for psArrayAdd
     120        //Attempt to add element to NULL psArray.
     121        {
     122            psArray *temp = NULL;
     123            temp = psArrayAdd(temp, 1, (psPtr)s1);
     124            *s3 = *((psS32*)(temp->data[0]));
     125            ok( temp->n == 1 && temp->nalloc == 1 && *s3 == 2,
     126                "psArrayAdd:             return array with newly added data.");
     127            psFree(temp);
     128        }
     129        //Attempt to add an element to empty array.
     130        {
     131            a = psArrayAdd(a, 1, (psPtr)s1);
     132            *s2 = 666;
     133            *s3 = 212;
     134            a = psArrayAdd(a, 1, s2);
     135            a = psArrayAdd(a, 1, s3);
     136            *s2 = *((psS32*)(a->data[0]));
     137            ok ( a->n == 3 && a->nalloc == 3 && *s2 == 2,
     138                 "psArrayAdd:            return array with newly added data.");
     139        }
     140   
     141        //Tests for psArrayRemoveData
     142        //Setup array with 3 elements to test remove function
     143        //Return false for attempting to remove from a NULL array
     144        {
     145            psArray *temp = NULL;
     146            ok( !psArrayRemoveData(temp, s2),
     147                "psArrayRemoveData:     return false for NULL input psArray.");
     148        }
     149        //Return true for successful removal
     150        {
     151            ok( psArrayRemoveData(a, s2) && a->n == 2,
     152                "psArrayRemoveData:     return true for successful removal.");
     153        }
     154   
     155        //Tests for psArrayRemoveIndex
     156        //Return false for NULL array input
     157        {
     158            ok( !psArrayRemoveIndex(NULL, 0),
     159                "psArrayRemoveIndex:    return false for NULL input psArray.");
     160        }
     161        //Return false for out-of-range index
     162        {
     163            ok( !psArrayRemoveIndex(a, 5),
     164                "psArrayRemoveIndex:    return false for out-of-range location.");
     165        }
     166        //Return true for successful removal
     167        {
     168            ok( psArrayRemoveIndex(a, 1) && a->n == 1,
     169                "psArrayRemoveIndex:    return true for successful removal.");
     170        }
     171   
    191172        psFree(s1);
    192173        psFree(s2);
    193174        psFree(s3);
    194175        psFree(a);
    195         checkMem();
     176        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    196177    }
    197178
    198 }
    199 
    200 void testArraySetGet(void)
    201 {
    202     note("  >>>Test 3:  psArraySet & psArrayGet Fxns");
    203     psArray *a = NULL;
    204     psArray *b = NULL;
    205     psS32 *s1 = (psS32*)psAlloc(sizeof(psS32));
    206     *s1 = 2;
    207     psS32 *s2 = (psS32*)psAlloc(sizeof(psS32));
    208     *s2 = 1;
    209     psS32 *s3 = (psS32*)psAlloc(sizeof(psS32));
    210     *s3 = 3;
    211 
    212     //Tests for psArraySet
    213     //Return false for trying to set a NULL psArray
     179   
     180    // testArraySetGet()
    214181    {
    215         ok( !psArraySet(a, 0, (psPtr)s1),
    216             "psArraySet:            return false for NULL input psArray.");
    217     }
    218     //Return false for trying to set an invalid position
    219     a = psArrayAlloc(1);
    220     {
    221         ok( !psArraySet(a, 2, (psPtr)s1),
    222             "psArraySet:            return false for invalid input position.");
    223     }
    224     //Return false for trying to set nalloc position
    225     psArraySet(a, 0, (psPtr)s1);
    226     {
    227         ok( !psArraySet(a, a->nalloc, (psPtr)s2),
    228             "psArraySet:            return false for out-of-range position.");
    229     }
    230     //Return false for an invalid position (-2 = out-of-range neg. index)
    231     {
    232         ok( !psArraySet(a, -2, (psPtr)s2),
    233             "psArraySet:            return false for out-of-range negative position.");
    234     }
    235     //Return true for set to a->n position (< nalloc)
    236     a = psArrayRealloc(a, 10);
    237     {
    238         ok( psArraySet(a, a->n, (psPtr)s2)  && a->n == 2,
    239             "psArraySet:            return true for valid input position.");
    240     }
    241     //Return true for a negative index input
    242     {
    243         ok( psArraySet(a, -2, (psPtr)s3) && a->n == 2 &&
    244             *((psS32*)(a->data[0])) == 3,
    245             "psArraySet:            return true for valid negative input position.");
    246     }
    247 
    248     //Tests for psArrayGet
    249     //Return NULL for NULL array input
    250     psS32 *s4 = NULL;
    251     {
    252         s4 = (psS32*)psArrayGet(b, 0);
    253         ok( s4 == NULL,
    254             "psArrayGet:            return NULL for NULL input psArray.");
    255     }
    256     //Return NULL for an out-of-range index
    257     {
    258         s4 = (psS32*)psArrayGet(a, a->n);
    259         ok( s4 == NULL,
    260             "psArrayGet:            return NULL for out-of-range position.");
    261     }
    262     //Return NULL for an out-of-range negative index
    263     {
    264         s4 = (psS32*)psArrayGet(a, -1-a->n);
    265         ok( s4 == NULL,
    266             "psArrayGet:            return NULL for out-of-range negative position.");
    267     }
    268     //Return valid case
    269     {
    270         s4 = (psS32*)psArrayGet(a, 1);
    271         ok( *s4 == 1,
    272             "psArrayGet:            return correct value for valid position.");
    273     }
    274 
    275     //Check for Memory leaks
    276     {
     182        psMemId id = psMemGetId();
     183        psArray *a = NULL;
     184        psArray *b = NULL;
     185        psS32 *s1 = (psS32*)psAlloc(sizeof(psS32));
     186        *s1 = 2;
     187        psS32 *s2 = (psS32*)psAlloc(sizeof(psS32));
     188        *s2 = 1;
     189        psS32 *s3 = (psS32*)psAlloc(sizeof(psS32));
     190        *s3 = 3;
     191   
     192        //Tests for psArraySet
     193        //Return false for trying to set a NULL psArray
     194        {
     195            ok( !psArraySet(a, 0, (psPtr)s1),
     196                "psArraySet:            return false for NULL input psArray.");
     197        }
     198        //Return false for trying to set an invalid position
     199        a = psArrayAlloc(1);
     200        {
     201            ok( !psArraySet(a, 2, (psPtr)s1),
     202                "psArraySet:            return false for invalid input position.");
     203        }
     204        //Return false for trying to set nalloc position
     205        psArraySet(a, 0, (psPtr)s1);
     206        {
     207            ok( !psArraySet(a, a->nalloc, (psPtr)s2),
     208                "psArraySet:            return false for out-of-range position.");
     209        }
     210        //Return false for an invalid position (-2 = out-of-range neg. index)
     211        {
     212            ok( !psArraySet(a, -2, (psPtr)s2),
     213                "psArraySet:            return false for out-of-range negative position.");
     214        }
     215        //Return true for set to a->n position (< nalloc)
     216        a = psArrayRealloc(a, 10);
     217        {
     218            ok( psArraySet(a, a->n, (psPtr)s2)  && a->n == 2,
     219                "psArraySet:            return true for valid input position.");
     220        }
     221        //Return true for a negative index input
     222        {
     223            ok( psArraySet(a, -2, (psPtr)s3) && a->n == 2 &&
     224                *((psS32*)(a->data[0])) == 3,
     225                "psArraySet:            return true for valid negative input position.");
     226        }
     227   
     228        //Tests for psArrayGet
     229        //Return NULL for NULL array input
     230        psS32 *s4 = NULL;
     231        {
     232            s4 = (psS32*)psArrayGet(b, 0);
     233            ok( s4 == NULL,
     234                "psArrayGet:            return NULL for NULL input psArray.");
     235        }
     236        //Return NULL for an out-of-range index
     237        {
     238            s4 = (psS32*)psArrayGet(a, a->n);
     239            ok( s4 == NULL,
     240                "psArrayGet:            return NULL for out-of-range position.");
     241        }
     242        //Return NULL for an out-of-range negative index
     243        {
     244            s4 = (psS32*)psArrayGet(a, -1-a->n);
     245            ok( s4 == NULL,
     246                "psArrayGet:            return NULL for out-of-range negative position.");
     247        }
     248        //Return valid case
     249        {
     250            s4 = (psS32*)psArrayGet(a, 1);
     251            ok( *s4 == 1,
     252                "psArrayGet:            return correct value for valid position.");
     253        }
     254   
    277255        psFree(a);
    278256        psFree(s1);
    279257        psFree(s2);
    280258        psFree(s3);
    281         checkMem();
     259        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    282260    }
    283 }
    284 
    285 void testArraySort(void)
    286 {
    287     note("  >>>Test 4:  psArray Sort Function");
    288     psArray *a = NULL;
    289     a = psArrayAlloc(3);
    290     a->n = 0;
    291     psS32 *s1 = (psS32*)psAlloc(sizeof(psS32));
    292     *s1 = 2;
    293     psS32 *s2 = (psS32*)psAlloc(sizeof(psS32));
    294     *s2 = 1;
    295     psS32 *s3 = (psS32*)psAlloc(sizeof(psS32));
    296     *s3 = 3;
    297     psArraySet(a, a->n, (psPtr)s1);
    298     psArraySet(a, a->n, (psPtr)s2);
    299     psArraySet(a, a->n, (psPtr)s3);
    300     psS32 *s4 = (psS32*)psAlloc(sizeof(psS32));
    301     psS32 *s5 = (psS32*)psAlloc(sizeof(psS32));
    302     psS32 *s6 = (psS32*)psAlloc(sizeof(psS32));
    303 
    304     //Tests for psArraySort
    305     //Return NULL for attempt to sort NULL psArray input.
     261
     262
     263    // testArraySort()
    306264    {
    307         psArray *temp = NULL;
    308         temp = psArraySort(temp, (psComparePtrFunc)psCompareDescendingS32Ptr);
    309         ok( temp == NULL,
    310             "psArraySort:           return NULL for NULL input psArray.");
    311     }
    312     //Return properly sorted psArray with descending psS32 elements - 3,2,1
    313     {
    314         a = psArraySort(a, (psComparePtrFunc)psCompareDescendingS32Ptr);
    315         *s4 = *((psS32*)(a->data[0]));
    316         *s5 = *((psS32*)(a->data[1]));
    317         *s6 = *((psS32*)(a->data[2]));
    318         ok( *s4 == 3 && *s5 == 2 && *s6 == 1,
    319             "psArraySort:           return properly sorted psArray.");
    320     }
    321 
    322     //Check for Memory leaks
    323     {
     265        psMemId id = psMemGetId();
     266        psArray *a = NULL;
     267        a = psArrayAlloc(3);
     268        a->n = 0;
     269        psS32 *s1 = (psS32*)psAlloc(sizeof(psS32));
     270        *s1 = 2;
     271        psS32 *s2 = (psS32*)psAlloc(sizeof(psS32));
     272        *s2 = 1;
     273        psS32 *s3 = (psS32*)psAlloc(sizeof(psS32));
     274        *s3 = 3;
     275        psArraySet(a, a->n, (psPtr)s1);
     276        psArraySet(a, a->n, (psPtr)s2);
     277        psArraySet(a, a->n, (psPtr)s3);
     278        psS32 *s4 = (psS32*)psAlloc(sizeof(psS32));
     279        psS32 *s5 = (psS32*)psAlloc(sizeof(psS32));
     280        psS32 *s6 = (psS32*)psAlloc(sizeof(psS32));
     281   
     282        //Tests for psArraySort
     283        //Return NULL for attempt to sort NULL psArray input.
     284        {
     285            psArray *temp = NULL;
     286            temp = psArraySort(temp, (psComparePtrFunc)psCompareDescendingS32Ptr);
     287            ok( temp == NULL,
     288                "psArraySort:           return NULL for NULL input psArray.");
     289        }
     290        //Return properly sorted psArray with descending psS32 elements - 3,2,1
     291        {
     292            a = psArraySort(a, (psComparePtrFunc)psCompareDescendingS32Ptr);
     293            *s4 = *((psS32*)(a->data[0]));
     294            *s5 = *((psS32*)(a->data[1]));
     295            *s6 = *((psS32*)(a->data[2]));
     296            ok( *s4 == 3 && *s5 == 2 && *s6 == 1,
     297                "psArraySort:           return properly sorted psArray.");
     298        }
     299   
    324300        psFree(s1);
    325301        psFree(s2);
    … …  
    329305        psFree(s6);
    330306        psFree(a);
    331         checkMem();
     307        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    332308    }
    333 
    334309}
    335310

  • trunk/psLib/test/types/tap_psBitSet_all.c

    r12210 r12781  
    1010 *
    1111 */
    12 
    1312#include <pslib.h>
    1413#include <string.h>
    15 
    1614#include "tap.h"
    1715#include "pstap.h"
    1816
    19 void testBitSetBasics(void);
    20 void testBitSetOps(void);
    2117
    2218int main(void)
    2319{
    24     plan_tests(31);
    25 
    26     note("Tests for psBitSet Functions");
    27 
    28     testBitSetBasics();
    29     testBitSetOps();
    30 
    31     done();
    32 }
    33 
    34 void testBitSetBasics(void)
    35 {
    36     note("  >>>Test 1:  psBitSet Basic Fxns");
    37 
    38     psBitSet *noBits = NULL;
    39     psBitSet *bs = NULL;
    40 
    41     //Return NULL for attempt to Allocate BitSet of negative size.
     20    psLogSetFormat("HLNM");
     21    psLogSetLevel(PS_LOG_INFO);
     22    plan_tests(32);
     23
     24
     25    // testBitSetBasics()
    4226    {
    43         noBits = psBitSetAlloc(-1);
    44         ok( noBits == NULL,
    45             "psBitSetAlloc:         return NULL for negative BitSet-size input.");
     27        psMemId id = psMemGetId();
     28        psBitSet *noBits = NULL;
     29        psBitSet *bs = NULL;
     30
     31        //Return NULL for attempt to Allocate BitSet of negative size.
     32        {
     33            noBits = psBitSetAlloc(-1);
     34            ok( noBits == NULL,
     35                "psBitSetAlloc:         return NULL for negative BitSet-size input.");
     36        }
     37        //Return properly allocated 0-size psBitSet
     38        {
     39            bs = psBitSetAlloc(0);
     40            ok( bs != NULL && psMemCheckBitSet(bs) && bs->n == 0,
     41                "psBitSetAlloc:         return properly allocated psBitSet.");
     42        }
     43        //Return properly allocated psBitSet
     44        {
     45            psFree(bs);
     46            bs = psBitSetAlloc(8);
     47            ok( bs != NULL && psMemCheckBitSet(bs) && bs->n == 1,
     48                "psBitSetAlloc:         return properly allocated psBitSet.");
     49        }
     50        //Make sure psMemCheckBitSet works correctly - return false
     51        {
     52            int j = 2;
     53            ok( !psMemCheckBitSet(&j),
     54                "psMemCheckBitSet:      return false for non-BitSet input.");
     55        }
     56
     57        //BitSetSet Tests
     58        //Return FALSE for NULL input psBitSet
     59        {
     60            bool rc = psBitSetSet(NULL, 0);
     61            ok(rc == false,
     62                "psBitSetSet:           return FALSE for NULL BitSet input.");
     63        }
     64        //Return FALSE for negative bit input
     65        {
     66            bool rc = psBitSetSet(bs, -1);
     67            ok( rc == false,
     68                "psBitSetSet:           return TRUE for negative bits input.");
     69            noBits = NULL;
     70        }
     71        //Return FALSE for out-of-range bits
     72        {
     73            psFree(bs);
     74            bs = psBitSetAlloc(8);
     75            bool rc = psBitSetSet(bs, 8);
     76            ok( rc == false,
     77                "psBitSetSet:           return TRUE for out-of-range bits input.");
     78            noBits = NULL;
     79        }
     80
     81        //Return set BitSet for valid inputs
     82        {
     83            psBitSetSet(bs, 2);
     84            ok( bs->bits[0] == 4,
     85                "psBitSetSet:           return properly set BitSet for valid inputs.");
     86        }
     87
     88        //BitSetClear Tests
     89        //Return FALSE for NULL input psBitSet
     90        {
     91            bool rc = psBitSetClear(noBits, 0);
     92            ok( rc == false,
     93                "psBitSetClear:         return FALSE for NULL BitSet input.");
     94        }
     95        //Return FALSE for negative bit input
     96        {
     97            bool rc = psBitSetClear(bs, -1);
     98            ok( rc == false,
     99                "psBitSetClear:        return TRUE for negative bits input.");
     100            noBits = NULL;
     101        }
     102        //Return FALSE for out-of-range bits
     103        {
     104            bool rc = psBitSetClear(bs, 8);
     105            ok( rc == false,
     106                "psBitSetClear:        return FALSE for out-of-range bits input.");
     107            noBits = NULL;
     108        }
     109
     110        //Return cleared BitSet for valid inputs
     111        {
     112            psBitSetClear(bs, 2);
     113            ok( bs->bits[0] == 0,
     114                "psBitSetClear:        return properly cleared BitSet for valid inputs.");
     115        }
     116
     117        //BitSetTest Tests
     118        //Return false for NULL input psBitSet
     119        {
     120            ok( !psBitSetTest(noBits, 0),
     121                "psBitSetTest:         return false for NULL BitSet input.");
     122        }
     123        //Return false for negative bit input
     124        {
     125            ok( !psBitSetTest(bs, -1),
     126                "psBitSetTest:         return false for negative bits input.");
     127        }
     128        //Return false for out-of-range bits
     129        {
     130            ok( !psBitSetTest(bs, 8),
     131                "psBitSetTest:         return false for out-of-range bits input.");
     132        }
     133        //Return false for non-matching bit in BitSet
     134        {
     135            ok( !psBitSetTest(bs, 2),
     136                "psBitSetTest:         return false for non-matching bit in BitSet.");
     137        }
     138        //Return false for non-matching bit in BitSet
     139        {
     140            psBitSetSet(bs, 2);
     141            ok( psBitSetTest(bs, 2),
     142                "psBitSetTest:         return true for matching bit in BitSet.");
     143        }
     144
     145        psFree(bs);
     146        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    46147    }
    47     //Return properly allocated 0-size psBitSet
     148
     149
     150    // testBitSetOps()
    48151    {
    49         bs = psBitSetAlloc(0);
    50         ok( bs != NULL && psMemCheckBitSet(bs) && bs->n == 0,
    51             "psBitSetAlloc:         return properly allocated psBitSet.");
    52     }
    53     //Return properly allocated psBitSet
    54     {
    55         psFree(bs);
    56         bs = psBitSetAlloc(8);
    57         ok( bs != NULL && psMemCheckBitSet(bs) && bs->n == 1,
    58             "psBitSetAlloc:         return properly allocated psBitSet.");
    59     }
    60     //Make sure psMemCheckBitSet works correctly - return false
    61     {
    62         int j = 2;
    63         ok( !psMemCheckBitSet(&j),
    64             "psMemCheckBitSet:      return false for non-BitSet input.");
    65     }
    66 
    67     //BitSetSet Tests
    68     //Return FALSE for NULL input psBitSet
    69     {
    70         bool rc = psBitSetSet(NULL, 0);
    71         ok(rc == false,
    72             "psBitSetSet:           return FALSE for NULL BitSet input.");
    73     }
    74     //Return FALSE for negative bit input
    75     {
    76         bool rc = psBitSetSet(bs, -1);
    77         ok( rc == false,
    78             "psBitSetSet:           return TRUE for negative bits input.");
    79         noBits = NULL;
    80     }
    81     //Return FALSE for out-of-range bits
    82     {
    83         psFree(bs);
    84         bs = psBitSetAlloc(8);
    85         bool rc = psBitSetSet(bs, 8);
    86         ok( rc == false,
    87             "psBitSetSet:           return TRUE for out-of-range bits input.");
    88         noBits = NULL;
    89     }
    90 
    91     //Return set BitSet for valid inputs
    92     {
    93         psBitSetSet(bs, 2);
    94         ok( bs->bits[0] == 4,
    95             "psBitSetSet:           return properly set BitSet for valid inputs.");
    96     }
    97 
    98     //BitSetClear Tests
    99     //Return FALSE for NULL input psBitSet
    100     {
    101         bool rc = psBitSetClear(noBits, 0);
    102         ok( rc == false,
    103             "psBitSetClear:         return FALSE for NULL BitSet input.");
    104     }
    105     //Return FALSE for negative bit input
    106     {
    107         bool rc = psBitSetClear(bs, -1);
    108         ok( rc == false,
    109             "psBitSetClear:        return TRUE for negative bits input.");
    110         noBits = NULL;
    111     }
    112     //Return FALSE for out-of-range bits
    113     {
    114         bool rc = psBitSetClear(bs, 8);
    115         ok( rc == false,
    116             "psBitSetClear:        return FALSE for out-of-range bits input.");
    117         noBits = NULL;
    118     }
    119 
    120     //Return cleared BitSet for valid inputs
    121     {
    122         psBitSetClear(bs, 2);
    123         ok( bs->bits[0] == 0,
    124             "psBitSetClear:        return properly cleared BitSet for valid inputs.");
    125     }
    126 
    127     //BitSetTest Tests
    128     //Return false for NULL input psBitSet
    129     {
    130         ok( !psBitSetTest(noBits, 0),
    131             "psBitSetTest:         return false for NULL BitSet input.");
    132     }
    133     //Return false for negative bit input
    134     {
    135         ok( !psBitSetTest(bs, -1),
    136             "psBitSetTest:         return false for negative bits input.");
    137     }
    138     //Return false for out-of-range bits
    139     {
    140         ok( !psBitSetTest(bs, 8),
    141             "psBitSetTest:         return false for out-of-range bits input.");
    142     }
    143     //Return false for non-matching bit in BitSet
    144     {
    145         ok( !psBitSetTest(bs, 2),
    146             "psBitSetTest:         return false for non-matching bit in BitSet.");
    147     }
    148     //Return false for non-matching bit in BitSet
    149     {
    150         psBitSetSet(bs, 2);
    151         ok( psBitSetTest(bs, 2),
    152             "psBitSetTest:         return true for matching bit in BitSet.");
    153     }
    154 
    155 
    156     //Check for Memory leaks
    157     {
    158         psFree(bs);
    159         checkMem();
    160     }
    161 }
    162 
    163 void testBitSetOps(void)
    164 {
    165     note("  >>>Test 2:  psBitSet Operation Fxns");
    166     psBitSet *noBits = NULL;
    167     psBitSet *bs = NULL;
    168     bs = psBitSetAlloc(8);
    169     psBitSetSet(bs, 2);  // 0000 0100 == 4
    170     psBitSetSet(bs, 3);  // 0000 1100 == 12
    171     psBitSetSet(bs, 4);  // 0001 1100 == 28
    172     psBitSetSet(bs, 5);  // 0011 1100 == 60
    173     psBitSetSet(bs, 6);  // 0111 1100 == 124
    174     psBitSetSet(bs, 7);  // 1111 1100 == 252
    175     psBitSet *out = NULL;
    176 
    177     //psBitSetNot Tests
    178     //Return NULL for NULL BitSet input
    179     {
    180         out = psBitSetNot(out, noBits);
    181         ok( out == NULL,
    182             "psBitSetNot:          return NULL for NULL BitSet input.");
    183     }
    184     //Return correct BitSet for valid BitSet input
    185     {
    186         out = psBitSetNot(out, bs);  //bs = 1111 1100  so out should = 0000 0011 = 3
    187         ok( out->bits[0] == 3,
    188             "psBitSetNot:          return correct BitSet for valid BitSet input.");
    189     }
    190 
    191     //psBitSetOp Tests   out = psBitSetOp(out, bs1, "op", bs2);
    192     //Return NULL for NULL BitSet input
    193     {
    194         psFree(out);
    195         out = NULL;
    196         out = psBitSetOp(out, noBits, "op", noBits);
    197         ok( out == NULL,
    198             "psBitSetOp:           return NULL for NULL BitSet input.");
    199     }
    200     //Return NULL for NULL operator input
    201     {
    202         out = psBitSetOp(out, bs, NULL, noBits);
    203         ok( out == NULL,
    204             "psBitSetOp:           return NULL for NULL operator input.");
    205     }
    206     //Return NULL for invalid operator input
    207     {
    208         out = psBitSetOp(out, bs, "XAND", noBits);
    209         ok( out == NULL,
    210             "psBitSetOp:           return NULL for invalid operator input.");
    211     }
    212     //Return NULL for AND operator with NULL second BitSet input
    213     {
    214         out = psBitSetOp(out, bs, "AND", noBits);
    215         ok( out == NULL,
    216             "psBitSetOp:           return NULL for AND operator with NULL second BitSet input.");
    217     }
    218     //Return NULL for AND operator with BitSet inputs of differing size.
    219     psBitSet *bs2 = psBitSetAlloc(16);
    220     {
    221         out = psBitSetOp(out, bs, "AND", bs2);
    222         ok( out == NULL,
    223             "psBitSetOp:           return NULL for AND operator with BitSet inputs of"
    224             " differing size.");
    225     }
    226     psFree(bs);
    227     bs = psBitSetAlloc(16);
    228     psBitSetSet(bs, 1);     // 0000 0010 == 2
    229     psBitSetSet(bs2, 2);   // 0000 0100 == 4
    230     //Return correct psBitSet output for valid inputs with AND operator
    231     {
    232         out = psBitSetOp(out, bs, "AND", bs2);
    233         ok( out->bits[0] == 0,
    234             "psBitSetOp:           return correct psBitSet output for valid inputs"
    235             " with AND operator.");
    236     }
    237     //Return correct psBitSet output for valid inputs with OR operator
    238     {
    239         out = psBitSetOp(out, bs, "OR", bs2);
    240         ok( out->bits[0] == 6,
    241             "psBitSetOp:           return correct psBitSet output for valid inputs"
    242             " with OR operator.");
    243     }
    244     //Return correct psBitSet output for valid inputs with XOR operator
    245     psBitSetSet(bs2, 1);     // 0000 0110 == 6
    246     {
    247         out = psBitSetOp(out, bs, "XOR", bs2);
    248         ok( out->bits[0] == 4,
    249             "psBitSetOp:           return correct psBitSet output for valid inputs"
    250             " with XOR operator.");
    251     }
    252     //Return correct psBitSet output for valid inputs with NOT operator
    253     {
    254         psFree(out);
    255         out = psBitSetAlloc(0);
    256         psBitSetSet(bs, 2);  // 0000 0110 == 4
    257         psBitSetSet(bs, 3);  // 0000 1110 == 12
    258         psBitSetSet(bs, 4);  // 0001 1110 == 28
    259         psBitSetSet(bs, 5);  // 0011 1110 == 60
    260         psBitSetSet(bs, 6);  // 0111 1110 == 124
    261         psBitSetSet(bs, 7);  // 1111 1110 == 252
    262         out = psBitSetOp(out, bs, "NOT", bs2);
    263         ok( out->bits[0] == 1,
    264             "psBitSetOp:           return correct psBitSet output for valid inputs"
    265             " with NOT operator.");
    266     }
    267 
    268     //psBitSetToString Tests
    269     //Return NULL for NULL BitSet input
    270     psString bitStr = NULL;
    271     {
    272         bitStr = psBitSetToString(noBits);
    273         ok( bitStr == NULL,
    274             "psBitSetToString:     return NULL for NULL BitSet input.");
    275     }
    276     //Return correct string for valid BitSet input
    277     {
    278         psFree(bs);
     152        psMemId id = psMemGetId();
     153        psBitSet *noBits = NULL;
     154        psBitSet *bs = NULL;
    279155        bs = psBitSetAlloc(8);
    280156        psBitSetSet(bs, 2);  // 0000 0100 == 4
    281         bitStr = psBitSetToString(bs);
    282         ok( !strncmp(bitStr, "00000100", 10),
    283             "psBitSetToString:     return correct string for valid BitSet input.");
    284     }
    285 
    286 
    287     //Check for Memory leaks
    288     {
     157        psBitSetSet(bs, 3);  // 0000 1100 == 12
     158        psBitSetSet(bs, 4);  // 0001 1100 == 28
     159        psBitSetSet(bs, 5);  // 0011 1100 == 60
     160        psBitSetSet(bs, 6);  // 0111 1100 == 124
     161        psBitSetSet(bs, 7);  // 1111 1100 == 252
     162        psBitSet *out = NULL;
     163
     164        //psBitSetNot Tests
     165        //Return NULL for NULL BitSet input
     166        {
     167            out = psBitSetNot(out, noBits);
     168            ok( out == NULL,
     169                "psBitSetNot:          return NULL for NULL BitSet input.");
     170        }
     171        //Return correct BitSet for valid BitSet input
     172        {
     173            out = psBitSetNot(out, bs);  //bs = 1111 1100  so out should = 0000 0011 = 3
     174            ok( out->bits[0] == 3,
     175                "psBitSetNot:          return correct BitSet for valid BitSet input.");
     176        }
     177
     178        //psBitSetOp Tests   out = psBitSetOp(out, bs1, "op", bs2);
     179        //Return NULL for NULL BitSet input
     180        {
     181            psFree(out);
     182            out = NULL;
     183            out = psBitSetOp(out, noBits, "op", noBits);
     184            ok( out == NULL,
     185                "psBitSetOp:           return NULL for NULL BitSet input.");
     186        }
     187        //Return NULL for NULL operator input
     188        {
     189            out = psBitSetOp(out, bs, NULL, noBits);
     190            ok( out == NULL,
     191                "psBitSetOp:           return NULL for NULL operator input.");
     192        }
     193        //Return NULL for invalid operator input
     194        {
     195            out = psBitSetOp(out, bs, "XAND", noBits);
     196            ok( out == NULL,
     197                "psBitSetOp:           return NULL for invalid operator input.");
     198        }
     199        //Return NULL for AND operator with NULL second BitSet input
     200        {
     201            out = psBitSetOp(out, bs, "AND", noBits);
     202            ok( out == NULL,
     203                "psBitSetOp:           return NULL for AND operator with NULL second BitSet input.");
     204        }
     205        //Return NULL for AND operator with BitSet inputs of differing size.
     206        psBitSet *bs2 = psBitSetAlloc(16);
     207        {
     208            out = psBitSetOp(out, bs, "AND", bs2);
     209            ok( out == NULL,
     210                "psBitSetOp:           return NULL for AND operator with BitSet inputs of"
     211                " differing size.");
     212        }
     213        psFree(bs);
     214        bs = psBitSetAlloc(16);
     215        psBitSetSet(bs, 1);     // 0000 0010 == 2
     216        psBitSetSet(bs2, 2);   // 0000 0100 == 4
     217        //Return correct psBitSet output for valid inputs with AND operator
     218        {
     219            out = psBitSetOp(out, bs, "AND", bs2);
     220            ok( out->bits[0] == 0,
     221                "psBitSetOp:           return correct psBitSet output for valid inputs"
     222                " with AND operator.");
     223        }
     224        //Return correct psBitSet output for valid inputs with OR operator
     225        {
     226            out = psBitSetOp(out, bs, "OR", bs2);
     227            ok( out->bits[0] == 6,
     228                "psBitSetOp:           return correct psBitSet output for valid inputs"
     229                " with OR operator.");
     230        }
     231        //Return correct psBitSet output for valid inputs with XOR operator
     232        psBitSetSet(bs2, 1);     // 0000 0110 == 6
     233        {
     234            out = psBitSetOp(out, bs, "XOR", bs2);
     235            ok( out->bits[0] == 4,
     236                "psBitSetOp:           return correct psBitSet output for valid inputs"
     237                " with XOR operator.");
     238        }
     239        //Return correct psBitSet output for valid inputs with NOT operator
     240        {
     241            psFree(out);
     242            out = psBitSetAlloc(0);
     243            psBitSetSet(bs, 2);  // 0000 0110 == 4
     244            psBitSetSet(bs, 3);  // 0000 1110 == 12
     245            psBitSetSet(bs, 4);  // 0001 1110 == 28
     246            psBitSetSet(bs, 5);  // 0011 1110 == 60
     247            psBitSetSet(bs, 6);  // 0111 1110 == 124
     248            psBitSetSet(bs, 7);  // 1111 1110 == 252
     249            out = psBitSetOp(out, bs, "NOT", bs2);
     250            ok( out->bits[0] == 1,
     251                "psBitSetOp:           return correct psBitSet output for valid inputs"
     252                " with NOT operator.");
     253        }
     254
     255        //psBitSetToString Tests
     256        //Return NULL for NULL BitSet input
     257        psString bitStr = NULL;
     258        {
     259            bitStr = psBitSetToString(noBits);
     260            ok( bitStr == NULL,
     261                "psBitSetToString:     return NULL for NULL BitSet input.");
     262        }
     263        //Return correct string for valid BitSet input
     264        {
     265            psFree(bs);
     266            bs = psBitSetAlloc(8);
     267            psBitSetSet(bs, 2);  // 0000 0100 == 4
     268            bitStr = psBitSetToString(bs);
     269            ok( !strncmp(bitStr, "00000100", 10),
     270                "psBitSetToString:     return correct string for valid BitSet input.");
     271        }
     272
    289273        psFree(bitStr);
    290274        psFree(out);
    291275        psFree(bs);
    292276        psFree(bs2);
    293         checkMem();
     277        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    294278    }
    295279}

  • trunk/psLib/test/types/tap_psHash_845.c

    r10123 r12781  
    22#include "pslib.h"
    33#include "pstap.h"
    4 
    54#define SIZE 128
    6 
    75
    86int main(int argc, char *argv[])
    97{
     8    psLogSetFormat("HLNM");
     9    psLogSetLevel(PS_LOG_INFO);
    1010    plan_tests(5);
    1111
    12     char *stuff1 = psAlloc(SIZE);       // Stuff to put on hash
    13     char *stuff2 = psAlloc(SIZE);       // Stuff to put on hash
     12    // Very basic test: create a psHash, then add data to it.
     13    // XXX: Remove this test, or mearge it with another file.
     14    {
     15        psMemId id = psMemGetId();
     16        char *stuff1 = psAlloc(SIZE);       // Stuff to put on hash
     17        char *stuff2 = psAlloc(SIZE);       // Stuff to put on hash
    1418
    15     psHash *hash = psHashAlloc(16);     // Hash to test
    16     ok(hash, "Hash allocated");
     19        psHash *hash = psHashAlloc(16);     // Hash to test
     20        ok(hash, "Hash allocated");
     21        bool status1 = psHashAdd(hash, "stuff", stuff1);
     22        ok(status1, "Added 1 to hash");
     23        psFree(stuff1);                     // Drop reference
     24        psMemId last = psMemGetId();        // Last memory I.D.
     25        bool status2 = psHashAdd(hash, "stuff", stuff2);
     26        ok(status2, "Added 2 to hash");
     27        psFree(stuff2);                     // Drop reference
     28        int numLeaks = psMemCheckLeaks(last, NULL, NULL, false); // Number of leaks
     29        ok(numLeaks == 0, "No leaks.");
     30        psFree(hash);
     31        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     32    }
    1733
    18     bool status1 = psHashAdd(hash, "stuff", stuff1);
    19     ok(status1, "Added 1 to hash");
    20     psFree(stuff1);                     // Drop reference
    21 
    22     psMemId last = psMemGetId();        // Last memory I.D.
    23     bool status2 = psHashAdd(hash, "stuff", stuff2);
    24     ok(status2, "Added 2 to hash");
    25     psFree(stuff2);                     // Drop reference
    26 
    27     int numLeaks = psMemCheckLeaks(last, NULL, NULL, false); // Number of leaks
    28     ok(numLeaks == 0, "No leaks.");
    29 
    30     psFree(hash);
    31 
    32     done();
    3334}

  • trunk/psLib/test/types/tap_psListIterator.c

    r10822 r12781  
    22#include <pslib.h>
    33#include <string.h>
    4 
    54#include "tap.h"
    65#include "pstap.h"
    … …  
    7271int main (void)
    7372{
    74     plan_tests(66);
     73    psLogSetFormat("HLNM");
     74    psLogSetLevel(PS_LOG_INFO);
     75    plan_tests(72);
    7576
    7677    note("psListIterator tests");
    77 
    78     {
    79         note("Forwards");
     78    // Forwards
     79    {
     80        psMemId id = psMemGetId();
    8081        psList *list = listGenerate();
    8182        psListIterator *iter = psListIteratorAlloc(list, PS_LIST_HEAD, false);
    … …  
    9495        psFree(iter);
    9596        psFree(list);
    96     }
    97 
    98     {
    99         note("Backwards");
     97        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     98    }
     99
     100
     101    // Backwards
     102    {
     103        psMemId id = psMemGetId();
    100104        psList *list = listGenerate();
    101105        psListIterator *iter = psListIteratorAlloc(list, PS_LIST_TAIL, NULL);
    … …  
    114118        psFree(iter);
    115119        psFree(list);
    116     }
    117 
    118     {
    119         note("Jumping in halfway through (using allocator), forwards");
     120        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     121    }
     122
     123
     124    // Jumping in halfway through (using allocator), forwards
     125    {
     126        psMemId id = psMemGetId();
    120127        psList *list = listGenerate();
    121128        psListIterator *iter = psListIteratorAlloc(list, 3, NULL);
    … …  
    131138        psFree(iter);
    132139        psFree(list);
    133     }
    134 
    135     {
    136         note("Jumping in halfway through (using allocator), backwards");
     140        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     141    }
     142
     143
     144    // Jumping in halfway through (using allocator), backwards
     145    {
     146        psMemId id = psMemGetId();
    137147        psList *list = listGenerate();
    138148        psListIterator *iter = psListIteratorAlloc(list, -4, NULL);
    … …  
    148158        psFree(iter);
    149159        psFree(list);
    150     }
    151 
    152     {
    153         note("Jumping in halfway through (using set), forwards");
     160        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     161    }
     162
     163
     164    // Jumping in halfway through (using set), forwards
     165    {
     166        psMemId id = psMemGetId();
    154167        psList *list = listGenerate();
    155168        psListIterator *iter = psListIteratorAlloc(list, PS_LIST_HEAD, NULL);
    … …  
    166179        psFree(iter);
    167180        psFree(list);
    168     }
    169 
    170     {
    171         note("Jumping in halfway through (using set), backwards");
     181        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     182    }
     183
     184
     185    // Jumping in halfway through (using set), backwards
     186    {
     187        psMemId id = psMemGetId();
    172188        psList *list = listGenerate();
    173189        psListIterator *iter = psListIteratorAlloc(list, PS_LIST_HEAD, NULL);
    … …  
    184200        psFree(iter);
    185201        psFree(list);
    186     }
    187 
    188     return exit_status();
     202        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     203    }
    189204}

  • trunk/psLib/test/types/tap_psList_all.c

    r12318 r12781  
    1313 *
    1414 */
    15 
    1615#include <pslib.h>
    1716#include <string.h>
    18 
    1917#include "tap.h"
    2018#include "pstap.h"
    2119
    22 void testListCreate(void);
    23 void testListManip(void);
    24 void testListConvertSort(void);
    25 
    2620int main(void)
    2721{
    28     plan_tests(60);
    29 
    30     note("Tests for psList Functions");
    31 
    32     testListCreate();
    33     testListManip();
    34     testListConvertSort();
    35 
    36     done();
    37 }
    38 
    39 void testListCreate(void)
    40 {
    41     note("  >>>Test 1:  psList Creation Fxns");
    42     psList *noList = NULL;
    43     psListIterator *noIter = NULL;
    44     psList *list = psListAlloc(NULL);
    45     psMetadata *md = psMetadataAlloc();
    46     psListIterator *iter1 = NULL;
    47     psListIterator *iter2 = NULL;
    48 
    49     //Tests for psListAlloc & psMemCheckList
    50     //Return empty list for NULL data input.
     22    psLogSetFormat("HLNM");
     23    psLogSetLevel(PS_LOG_INFO);
     24    plan_tests(62);
     25
     26    // Test 1:  psList Creation Fxns");
     27    // testListCreate(void)
    5128    {
    52         noList = psListAlloc(NULL);
    53         ok( psListLength(noList) == 0 && psMemCheckList(noList),
    54             "psListAlloc:             return empty list for NULL data input.");
    55     }
    56     //Return allocated list for non-NULL data input.
    57     psFree(noList);
    58     {
    59 
    60         noList = psListAlloc(md);
    61         ok( psListLength(noList) == 1,
     29        psMemId id = psMemGetId();
     30        psList *noList = NULL;
     31        psListIterator *noIter = NULL;
     32        psList *list = psListAlloc(NULL);
     33        psMetadata *md = psMetadataAlloc();
     34        psListIterator *iter1 = NULL;
     35        psListIterator *iter2 = NULL;
     36
     37        //Tests for psListAlloc & psMemCheckList
     38        //Return empty list for NULL data input.
     39        {
     40            noList = psListAlloc(NULL);
     41            ok( psListLength(noList) == 0 && psMemCheckList(noList),
     42                "psListAlloc:             return empty list for NULL data input.");
     43        }
     44        //Return allocated list for non-NULL data input.
     45        psFree(noList);
     46        {
     47            noList = psListAlloc(md);
     48            ok( psListLength(noList) == 1,
    6249            "psListAlloc:             return correct list for non-NULL data input.");
    63     }
    64     //Make sure psMemCheckList works correctly - return false
    65     {
    66         int j = 2;
    67         ok( !psMemCheckList(&j),
    68             "psMemCheckList:          return false for non-List input.");
    69     }
    70 
    71     //Tests for ListIteratorAlloc
    72     //Return NULL for attempt to allocate iterator with NULL list input
    73     {
    74         noIter = psListIteratorAlloc(NULL, 0, true);
    75         ok( noIter == NULL,
    76             "psListIteratorAlloc:     return false for NULL data input.");
    77     }
    78     //Attempt to Allocate a psListIterator with out-of-range location
    79     {
    80         iter1 = psListIteratorAlloc(noList, 10, false);
    81         ok( iter1 == NULL,
    82             "psListIteratorAlloc:     return NULL for out-of-range location.");
    83     }
    84     //Return valid iterator for valid inputs
    85     {
    86         iter1 = psListIteratorAlloc(noList, 0, true);
    87         ok( iter1 != NULL,
    88             "psListIteratorAlloc:     return valid iterator for valid inputs.");
    89     }
    90 
    91     //Tests For ListAdd Fxns
    92     //Return false for NULL list input
    93     {
    94         ok( !psListAdd(NULL, 0, md),
    95             "psListAdd:               return false for NULL list input.");
    96     }
    97     //Return false for NULL data input
    98     {
    99         ok( !psListAdd(list, 0, NULL),
    100             "psListAdd:               return false for NULL data input.");
    101     }
    102     //Return false for list with NULL data
    103     {
    104         psFree(list->iterators->data[0]);
    105         list->iterators->data[0] = NULL;
    106         ok( !psListAdd(list, 0, md),
    107             "psListAdd:               return false for list with NULL iterators.");
    108         psFree(list);
    109         list = psListAlloc(md);
    110     }
    111     //Return true for valid inputs - tail location
    112     {
    113         ok( psListAdd(list, 2, md),
    114             "psListAdd:              return true for valid inputs - Tail Location.");
    115     }
    116     //Return true for valid inputs - head location
    117     {
    118         ok( psListAdd(list, 0, md),
    119             "psListAdd:              return true for valid inputs - head Location.");
    120     }
    121 
    122     //psListAddAfter Tests
    123     //psListAddAfter - Return false for NULL data input
    124     {
    125         ok( !psListAddAfter(iter1, NULL),
    126             "psListAddAfter:         return false for NULL data input.");
    127     }
    128     //psListAddAfter - Return false for NULL iterator input
    129     {
    130         ok( !psListAddAfter(NULL, md),
    131             "psListAddAfter:         return false for NULL iterator input.");
    132     }
    133     //psListAddAfter - Return false for non-mutable iterator input
    134     {
    135         iter1->mutable = false;
    136         ok( !psListAddAfter(iter1, md),
    137             "psListAddAfter:         return false for non-mutable iterator input.");
    138         iter1->mutable = true;
    139         psFree(iter1);
    140     }
    141     //psListAddAfter - Return false for iterator with NULL cursor
    142     psList *newList = psListAlloc(md);
    143     iter1 = psListIteratorAlloc(newList, 0, true);
    144     psListElem *cursor = iter1->cursor;
    145     {
    146         iter1->cursor = NULL;
    147         ok( !psListAddAfter(iter1, md),
    148             "psListAddAfter:         return false for iterator with headptr but no cursor.");
    149         iter1->cursor = cursor;
    150     }
    151     //Set the iterator to a middle element, then add after
    152     {
    153         iter2 = psListIteratorAlloc(list, 1, true);
    154         ok( psListAddAfter(iter2, md),
    155             "psListAddAfter:         return true for adding a list element to the middle.");
    156     }
    157     //Set the iterator to the head element, then add after a wrong index.  return true
    158     {
    159         if (!psListIteratorSet(iter2, PS_LIST_HEAD) )
    160             printf("\nerror in set\n\n");
    161         ((psListIterator*)(iter2->list->iterators->data[0]))->index = 10;
    162         ok( psListAddAfter(iter2, md),
    163             "psListAddAfter:         return true for adding a list element to the head.");
    164     }
    165     //Return true for adding to an empty list
    166     psFree(noList);
    167     noList = psListAlloc(NULL);
    168     psListIterator *iter3 = psListIteratorAlloc(noList, 0, true);
    169     {
    170         ok( psListAddAfter(iter3, md),
    171             "psListAddAfter:         return true for adding to an empty list.");
    172     }
    173 
    174     //psListAddBefore Tests
    175     //psListAddBefore - Return false for NULL data input
    176     {
    177         ok( !psListAddBefore(iter1, NULL),
    178             "psListAddBefore:        return false for NULL data input.");
    179     }
    180     //psListAddBefore - Return false for NULL iterator input
    181     {
    182         ok( !psListAddBefore(NULL, md),
    183             "psListAddBefore:        return false for NULL iterator input.");
    184     }
    185     //psListAddBefore - Return false for non-mutable iterator input
    186     {
    187         iter1->mutable = false;
    188         ok( !psListAddBefore(iter1, md),
    189             "psListAddBefore:        return false for non-mutable iterator input.");
    190         iter1->mutable = true;
    191     }
    192     {
    193         cursor = iter1->cursor;
    194         iter1->cursor = NULL;
    195         ok( !psListAddBefore(iter1, md),
    196             "psListAddBefore:        return false for iterator with headptr but no cursor.");
    197         iter1->cursor = cursor;
    198     }
    199     //Add before a middle list element
    200     {
    201         psListIteratorSet(iter2, -2);
    202         ok( psListAddBefore(iter2, md),
    203             "psListAddBefore:        return true for adding a list element to the middle.");
    204     }
    205     //Set the iterator to the 2nd element, then add after a wrong index.  return true
    206     {
    207         skip_start(  !psListIteratorSet(iter2, 1), 1,
    208                      "Skipping 1 tests because psListIteratorSet failed");
    209         ((psListIterator*)(iter2->list->iterators->data[0]))->index = 10;
    210         ok( psListAddBefore(iter2, md),
    211             "psListAddBefore:        return true for adding a list element to the head.");
    212         skip_end();
    213     }
    214     //Return true for adding to an empty list
    215     {
     50        }
     51        //Make sure psMemCheckList works correctly - return false
     52        {
     53            int j = 2;
     54            ok( !psMemCheckList(&j),
     55                "psMemCheckList:          return false for non-List input.");
     56        }
     57
     58        //Tests for ListIteratorAlloc
     59        //Return NULL for attempt to allocate iterator with NULL list input
     60        {
     61            noIter = psListIteratorAlloc(NULL, 0, true);
     62            ok( noIter == NULL,
     63                "psListIteratorAlloc:     return false for NULL data input.");
     64        }
     65        //Attempt to Allocate a psListIterator with out-of-range location
     66        {
     67            iter1 = psListIteratorAlloc(noList, 10, false);
     68            ok( iter1 == NULL,
     69                "psListIteratorAlloc:     return NULL for out-of-range location.");
     70        }
     71        //Return valid iterator for valid inputs
     72        {
     73            iter1 = psListIteratorAlloc(noList, 0, true);
     74            ok( iter1 != NULL,
     75                "psListIteratorAlloc:     return valid iterator for valid inputs.");
     76        }
     77
     78        //Tests For ListAdd Fxns
     79        //Return false for NULL list input
     80        {
     81            ok( !psListAdd(NULL, 0, md),
     82                "psListAdd:               return false for NULL list input.");
     83        }
     84        //Return false for NULL data input
     85        {
     86            ok( !psListAdd(list, 0, NULL),
     87                "psListAdd:               return false for NULL data input.");
     88        }
     89        //Return false for list with NULL data
     90        {
     91            psFree(list->iterators->data[0]);
     92            list->iterators->data[0] = NULL;
     93            ok( !psListAdd(list, 0, md),
     94                "psListAdd:               return false for list with NULL iterators.");
     95            psFree(list);
     96            list = psListAlloc(md);
     97        }
     98        //Return true for valid inputs - tail location
     99        {
     100            ok( psListAdd(list, 2, md),
     101                "psListAdd:              return true for valid inputs - Tail Location.");
     102        }
     103        //Return true for valid inputs - head location
     104        {
     105            ok( psListAdd(list, 0, md),
     106                "psListAdd:              return true for valid inputs - head Location.");
     107        }
     108
     109        //psListAddAfter Tests
     110        //psListAddAfter - Return false for NULL data input
     111        {
     112            ok( !psListAddAfter(iter1, NULL),
     113                "psListAddAfter:         return false for NULL data input.");
     114        }
     115        //psListAddAfter - Return false for NULL iterator input
     116        {
     117            ok( !psListAddAfter(NULL, md),
     118                "psListAddAfter:         return false for NULL iterator input.");
     119        }
     120        //psListAddAfter - Return false for non-mutable iterator input
     121        {
     122            iter1->mutable = false;
     123            ok( !psListAddAfter(iter1, md),
     124                "psListAddAfter:         return false for non-mutable iterator input.");
     125            iter1->mutable = true;
     126            psFree(iter1);
     127        }
     128        //psListAddAfter - Return false for iterator with NULL cursor
     129        psList *newList = psListAlloc(md);
     130        iter1 = psListIteratorAlloc(newList, 0, true);
     131        psListElem *cursor = iter1->cursor;
     132        {
     133            iter1->cursor = NULL;
     134            ok( !psListAddAfter(iter1, md),
     135                "psListAddAfter:         return false for iterator with headptr but no cursor.");
     136            iter1->cursor = cursor;
     137        }
     138        //Set the iterator to a middle element, then add after
     139        {
     140            iter2 = psListIteratorAlloc(list, 1, true);
     141            ok( psListAddAfter(iter2, md),
     142                "psListAddAfter:         return true for adding a list element to the middle.");
     143        }
     144        //Set the iterator to the head element, then add after a wrong index.  return true
     145        {
     146            if (!psListIteratorSet(iter2, PS_LIST_HEAD) )
     147                printf("\nerror in set\n\n");
     148            ((psListIterator*)(iter2->list->iterators->data[0]))->index = 10;
     149            ok( psListAddAfter(iter2, md),
     150                "psListAddAfter:         return true for adding a list element to the head.");
     151        }
     152        //Return true for adding to an empty list
    216153        psFree(noList);
    217154        noList = psListAlloc(NULL);
    218         iter3 = psListIteratorAlloc(noList, 0, true);
    219         psFree(iter3);
    220         ok( psListAddBefore(iter3, md),
    221             "psListAddBefore:        return true for adding to an empty list.");
    222     }
    223 
    224     //Check the length of a NULL list
    225     {
    226         psList *emptyList = NULL;
    227         ok( psListLength(emptyList) == -1,
    228             "psListLength:           return -1 for NULL input psList.");
    229     }
    230 
    231     //Check for Memory leaks
    232     {
     155        psListIterator *iter3 = psListIteratorAlloc(noList, 0, true);
     156        {
     157            ok( psListAddAfter(iter3, md),
     158                "psListAddAfter:         return true for adding to an empty list.");
     159        }
     160
     161        //psListAddBefore Tests
     162        //psListAddBefore - Return false for NULL data input
     163        {
     164            ok( !psListAddBefore(iter1, NULL),
     165                "psListAddBefore:        return false for NULL data input.");
     166        }
     167        //psListAddBefore - Return false for NULL iterator input
     168        {
     169            ok( !psListAddBefore(NULL, md),
     170                "psListAddBefore:        return false for NULL iterator input.");
     171        }
     172        //psListAddBefore - Return false for non-mutable iterator input
     173        {
     174            iter1->mutable = false;
     175            ok( !psListAddBefore(iter1, md),
     176                "psListAddBefore:        return false for non-mutable iterator input.");
     177            iter1->mutable = true;
     178        }
     179        {
     180            cursor = iter1->cursor;
     181            iter1->cursor = NULL;
     182            ok( !psListAddBefore(iter1, md),
     183                "psListAddBefore:        return false for iterator with headptr but no cursor.");
     184            iter1->cursor = cursor;
     185        }
     186        //Add before a middle list element
     187        {
     188            psListIteratorSet(iter2, -2);
     189            ok( psListAddBefore(iter2, md),
     190                "psListAddBefore:        return true for adding a list element to the middle.");
     191        }
     192        //Set the iterator to the 2nd element, then add after a wrong index.  return true
     193        {
     194            skip_start(  !psListIteratorSet(iter2, 1), 1,
     195                         "Skipping 1 tests because psListIteratorSet failed");
     196            ((psListIterator*)(iter2->list->iterators->data[0]))->index = 10;
     197            ok( psListAddBefore(iter2, md),
     198                "psListAddBefore:        return true for adding a list element to the head.");
     199            skip_end();
     200        }
     201        //Return true for adding to an empty list
     202        {
     203            psFree(noList);
     204            noList = psListAlloc(NULL);
     205            iter3 = psListIteratorAlloc(noList, 0, true);
     206            psFree(iter3);
     207            ok( psListAddBefore(iter3, md),
     208                "psListAddBefore:        return true for adding to an empty list.");
     209        }
     210   
     211        //Check the length of a NULL list
     212        {
     213            psList *emptyList = NULL;
     214            ok( psListLength(emptyList) == -1,
     215                "psListLength:           return -1 for NULL input psList.");
     216        }
     217   
    233218        psFree(iter2);
    234219        psFree(list);
    … …  
    237222        psFree(md);
    238223        psFree(noList);
    239         checkMem();
     224        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    240225    }
    241 }
    242 
    243 void testListManip(void)
    244 {
    245     note("  >>>Test 2:  psList Manipulation Fxns");
    246     psMetadata *md = psMetadataAlloc();
    247     psList *emptyList = psListAlloc(NULL);
    248     psList *list = psListAlloc(md);
    249     psSphere *sphere = psSphereAlloc();
    250     psCube *cube = psCubeAlloc();
    251     psArray *array = psArrayAlloc(0);
    252     psListAdd(list, PS_LIST_TAIL, sphere);
    253     psListAdd(list, PS_LIST_TAIL, cube);
    254     psListAdd(list, PS_LIST_TAIL, array);
    255     psListIterator *emptyIter = psListIteratorAlloc(emptyList, 0, true);
    256     psListIterator *iter1 = psListIteratorAlloc(list, PS_LIST_TAIL, true);
    257 
    258     //Tests for psListGet
    259     //Return NULL for NULL list input
     226
     227
     228    // testListManip()
     229    // psList Manipulation Fxns");
    260230    {
    261         psMetadata *out = NULL;
    262         out = (psMetadata*)psListGet(NULL, PS_LIST_HEAD);
    263         ok( out == NULL,
    264             "psListGet:              return NULL for NULL list input.");
    265     }
    266     //Return NULL for empty list
    267     {
    268         psMetadata *out = NULL;
    269         out = (psMetadata*)psListGet(emptyList, PS_LIST_HEAD);
    270         ok( out == NULL,
    271             "psListGet:              return NULL for empty list.");
    272     }
    273     //Return NULL for out-of-range location
    274     {
    275         psMetadata *out = NULL;
    276         out = (psMetadata*)psListGet(list, -10);
    277         ok( out == NULL,
    278             "psListGet:              return NULL for out-of-range location.");
    279     }
    280     //Return correct head item for valid inputs
    281     {
    282         psMetadata *out = NULL;
    283         out = (psMetadata*)psListGet(list, PS_LIST_HEAD);
    284         ok( out != NULL && psMemCheckMetadata(out),
    285             "psListGet:              return correct head item for valid inputs.");
    286     }
    287 
    288     //Tests for psListGetAndIncrement
    289     //Return NULL for NULL iterator input
    290     {
    291         psMetadata *out = NULL;
    292         out = (psMetadata*)psListGetAndIncrement(NULL);
    293         ok( out == NULL,
    294             "psListGetAndIncrement:  return NULL for NULL iterator input.");
    295     }
    296     //Return NULL for empty iterator with offend = false
    297     {
    298         psMetadata *out = NULL;
    299         out = (psMetadata*)psListGetAndIncrement(emptyIter);
    300         ok( out == NULL,
    301             "psListGetAndIncrement:  return NULL for empty iterator input.");
    302     }
    303     //Return NULL for empty iterator with offend = true
    304     {
    305         emptyIter->offEnd = true;
    306         psMetadata *out = NULL;
    307         out = (psMetadata*)psListGetAndIncrement(emptyIter);
    308         ok( out == NULL,
    309             "psListGetAndIncrement:  return NULL for empty iterator input.");
    310         emptyIter->offEnd = false;
    311     }
    312     //Return correct tail item for valid inputs
    313     {
    314         psArray *out = NULL;
    315         out = (psArray*)psListGetAndIncrement(iter1);
    316         ok( out != NULL && psMemCheckArray(out),
    317             "psListGetAndIncrement:  return correct tail item for valid inputs.");
    318     }
    319 
    320     //Tests for psListGetAndDecrement
    321     //Return NULL for NULL iterator input
    322     {
    323         psMetadata *out = NULL;
    324         out = (psMetadata*)psListGetAndDecrement(NULL);
    325         ok( out == NULL,
    326             "psListGetAndDecrement:  return NULL for NULL iterator input.");
    327     }
    328     //Return NULL for empty iterator with offend = false
    329     {
    330         psMetadata *out = NULL;
    331         out = (psMetadata*)psListGetAndDecrement(emptyIter);
    332         ok( out == NULL,
    333             "psListGetAndDecrement:  return NULL for empty iterator input.");
    334     }
    335     //Return NULL for empty iterator with offend = true
    336     {
    337         emptyIter->offEnd = true;
    338         psMetadata *out = NULL;
    339         out = (psMetadata*)psListGetAndDecrement(emptyIter);
    340         ok( out == NULL,
    341             "psListGetAndDecrement:  return NULL for empty iterator input.");
    342         emptyIter->offEnd = false;
    343     }
    344     //Return correct tail item for valid inputs
    345     {
    346         psArray *out = NULL;
    347         skip_start(  !psListIteratorSet(iter1, PS_LIST_TAIL), 1,
    348                      "Skipping 1 tests because psListIteratorSet failed");
    349         out = (psArray*)psListGetAndDecrement(iter1);
    350         ok( out != NULL && psMemCheckArray(out),
    351             "psListGetAndDecrement:  return correct tail item for valid inputs.");
    352         skip_end();
    353     }
    354 
    355     //Tests for psListRemove
    356     //Return false for NULL list input
    357     {
    358         ok( !psListRemove(NULL, PS_LIST_HEAD),
    359             "psListRemove:           return false for NULL list input.");
    360     }
    361     //Return false for invalid location
    362     {
    363         ok( !psListRemove(list, -10),
    364             "psListRemove:           return false for invalid location.");
    365     }
    366     //Return false for empty list
    367     {
    368         ok( !psListRemove(emptyList, PS_LIST_HEAD),
    369             "psListRemove:           return false for remove from empty list.");
    370     }
    371     //Return true for remove from middle of list
    372     {
    373         ok( psListRemove(list, 2) && list->n == 3,
    374             "psListRemove:           return true for remove from middle of list.");
    375     }
    376     //Return true for remove from head of list
    377     {
    378         ok( psListRemove(list, PS_LIST_HEAD) && list->n ==2,
    379             "psListRemove:           return true for remove from head of list.");
    380     }
    381     //Return true for remove from tail of list
    382     {
    383         ok( psListRemove(list, PS_LIST_TAIL) && list->n == 1,
    384             "psListRemove:           return true for remove from tail of list.");
    385     }
    386     //Tests for psListRemoveData
    387     //Return false for NULL list input
    388     {
    389         ok( !psListRemoveData(NULL, md),
    390             "psListRemoveData:       return false for NULL list input.");
    391     }
    392     //Return false for NULL data input
    393     {
    394         ok( !psListRemoveData(list, NULL),
    395             "psListRemoveData:       return false for NULL data input.");
    396     }
    397     //Return false for non-matching data
    398     {
    399         ok( !psListRemoveData(list, md),
    400             "psListRemoveData:       return false for non-matching data.");
    401     }
    402     //Return false for trying to remove from an empty list
    403     {
    404         ok( !psListRemoveData(emptyList, md),
    405             "psListRemoveData:       return false for trying to remove from an empty list.");
    406     }
    407     //Return true for remove of valid data
    408     psListAdd(list, PS_LIST_HEAD, cube);
    409     psListAdd(list, PS_LIST_HEAD, array);
    410     {
    411         ok( psListRemoveData(list, sphere),
    412             "psListRemoveData:       return true for remove of valid data.");
    413     }
    414 
    415     //Check for Memory leaks
    416     {
     231        psMemId id = psMemGetId();
     232        psMetadata *md = psMetadataAlloc();
     233        psList *emptyList = psListAlloc(NULL);
     234        psList *list = psListAlloc(md);
     235        psSphere *sphere = psSphereAlloc();
     236        psCube *cube = psCubeAlloc();
     237        psArray *array = psArrayAlloc(0);
     238        psListAdd(list, PS_LIST_TAIL, sphere);
     239        psListAdd(list, PS_LIST_TAIL, cube);
     240        psListAdd(list, PS_LIST_TAIL, array);
     241        psListIterator *emptyIter = psListIteratorAlloc(emptyList, 0, true);
     242        psListIterator *iter1 = psListIteratorAlloc(list, PS_LIST_TAIL, true);
     243   
     244        //Tests for psListGet
     245        //Return NULL for NULL list input
     246        {
     247            psMetadata *out = NULL;
     248            out = (psMetadata*)psListGet(NULL, PS_LIST_HEAD);
     249            ok( out == NULL,
     250                "psListGet:              return NULL for NULL list input.");
     251        }
     252        //Return NULL for empty list
     253        {
     254            psMetadata *out = NULL;
     255            out = (psMetadata*)psListGet(emptyList, PS_LIST_HEAD);
     256            ok( out == NULL,
     257                "psListGet:              return NULL for empty list.");
     258        }
     259        //Return NULL for out-of-range location
     260        {
     261            psMetadata *out = NULL;
     262            out = (psMetadata*)psListGet(list, -10);
     263            ok( out == NULL,
     264                "psListGet:              return NULL for out-of-range location.");
     265        }
     266        //Return correct head item for valid inputs
     267        {
     268            psMetadata *out = NULL;
     269            out = (psMetadata*)psListGet(list, PS_LIST_HEAD);
     270            ok( out != NULL && psMemCheckMetadata(out),
     271                "psListGet:              return correct head item for valid inputs.");
     272        }
     273   
     274        //Tests for psListGetAndIncrement
     275        //Return NULL for NULL iterator input
     276        {
     277            psMetadata *out = NULL;
     278            out = (psMetadata*)psListGetAndIncrement(NULL);
     279            ok( out == NULL,
     280                "psListGetAndIncrement:  return NULL for NULL iterator input.");
     281        }
     282        //Return NULL for empty iterator with offend = false
     283        {
     284            psMetadata *out = NULL;
     285            out = (psMetadata*)psListGetAndIncrement(emptyIter);
     286            ok( out == NULL,
     287                "psListGetAndIncrement:  return NULL for empty iterator input.");
     288        }
     289        //Return NULL for empty iterator with offend = true
     290        {
     291            emptyIter->offEnd = true;
     292            psMetadata *out = NULL;
     293            out = (psMetadata*)psListGetAndIncrement(emptyIter);
     294            ok( out == NULL,
     295                "psListGetAndIncrement:  return NULL for empty iterator input.");
     296            emptyIter->offEnd = false;
     297        }
     298        //Return correct tail item for valid inputs
     299        {
     300            psArray *out = NULL;
     301            out = (psArray*)psListGetAndIncrement(iter1);
     302            ok( out != NULL && psMemCheckArray(out),
     303                "psListGetAndIncrement:  return correct tail item for valid inputs.");
     304        }
     305   
     306        //Tests for psListGetAndDecrement
     307        //Return NULL for NULL iterator input
     308        {
     309            psMetadata *out = NULL;
     310            out = (psMetadata*)psListGetAndDecrement(NULL);
     311            ok( out == NULL,
     312                "psListGetAndDecrement:  return NULL for NULL iterator input.");
     313        }
     314        //Return NULL for empty iterator with offend = false
     315        {
     316            psMetadata *out = NULL;
     317            out = (psMetadata*)psListGetAndDecrement(emptyIter);
     318            ok( out == NULL,
     319                "psListGetAndDecrement:  return NULL for empty iterator input.");
     320        }
     321        //Return NULL for empty iterator with offend = true
     322        {
     323            emptyIter->offEnd = true;
     324            psMetadata *out = NULL;
     325            out = (psMetadata*)psListGetAndDecrement(emptyIter);
     326            ok( out == NULL,
     327                "psListGetAndDecrement:  return NULL for empty iterator input.");
     328            emptyIter->offEnd = false;
     329        }
     330        //Return correct tail item for valid inputs
     331        {
     332            psArray *out = NULL;
     333            skip_start(  !psListIteratorSet(iter1, PS_LIST_TAIL), 1,
     334                         "Skipping 1 tests because psListIteratorSet failed");
     335            out = (psArray*)psListGetAndDecrement(iter1);
     336            ok( out != NULL && psMemCheckArray(out),
     337                "psListGetAndDecrement:  return correct tail item for valid inputs.");
     338            skip_end();
     339        }
     340   
     341        //Tests for psListRemove
     342        //Return false for NULL list input
     343        {
     344            ok( !psListRemove(NULL, PS_LIST_HEAD),
     345                "psListRemove:           return false for NULL list input.");
     346        }
     347        //Return false for invalid location
     348        {
     349            ok( !psListRemove(list, -10),
     350                "psListRemove:           return false for invalid location.");
     351        }
     352        //Return false for empty list
     353        {
     354            ok( !psListRemove(emptyList, PS_LIST_HEAD),
     355                "psListRemove:           return false for remove from empty list.");
     356        }
     357        //Return true for remove from middle of list
     358        {
     359            ok( psListRemove(list, 2) && list->n == 3,
     360                "psListRemove:           return true for remove from middle of list.");
     361        }
     362        //Return true for remove from head of list
     363        {
     364            ok( psListRemove(list, PS_LIST_HEAD) && list->n ==2,
     365                "psListRemove:           return true for remove from head of list.");
     366        }
     367        //Return true for remove from tail of list
     368        {
     369            ok( psListRemove(list, PS_LIST_TAIL) && list->n == 1,
     370                "psListRemove:           return true for remove from tail of list.");
     371        }
     372        //Tests for psListRemoveData
     373        //Return false for NULL list input
     374        {
     375            ok( !psListRemoveData(NULL, md),
     376                "psListRemoveData:       return false for NULL list input.");
     377        }
     378        //Return false for NULL data input
     379        {
     380            ok( !psListRemoveData(list, NULL),
     381                "psListRemoveData:       return false for NULL data input.");
     382        }
     383        //Return false for non-matching data
     384        {
     385            ok( !psListRemoveData(list, md),
     386                "psListRemoveData:       return false for non-matching data.");
     387        }
     388        //Return false for trying to remove from an empty list
     389        {
     390            ok( !psListRemoveData(emptyList, md),
     391                "psListRemoveData:       return false for trying to remove from an empty list.");
     392        }
     393        //Return true for remove of valid data
     394        psListAdd(list, PS_LIST_HEAD, cube);
     395        psListAdd(list, PS_LIST_HEAD, array);
     396        {
     397            ok( psListRemoveData(list, sphere),
     398                "psListRemoveData:       return true for remove of valid data.");
     399        }
     400   
    417401        psFree(md);
    418402        psFree(emptyList);
    … …  
    421405        psFree(cube);
    422406        psFree(array);
    423         checkMem();
     407        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    424408    }
    425 }
    426 
    427 void testListConvertSort(void)
    428 {
    429     note("  >>>Test 3:  psList Conversion and Sorting Fxns");
    430     psList *emptyList = psListAlloc(NULL);
    431     psS32 *s1 = (psS32*)psAlloc(sizeof(psS32));
    432     *s1 = 2;
    433     psS32 *s2 = (psS32*)psAlloc(sizeof(psS32));
    434     *s2 = 3;
    435     psS32 *s3 = (psS32*)psAlloc(sizeof(psS32));
    436     *s3 = 1;
    437     psList *list = psListAlloc(s1);
    438     psListAdd(list, PS_LIST_TAIL, s2);
    439     psListAdd(list, PS_LIST_TAIL, s3);
    440     psArray *array = NULL;
    441     psArray *emptyArray = psArrayAlloc(0);
    442     psList *out = NULL;
    443 
    444     //Tests for psListToArray
    445     //Return NULL for NULL list input
     409
     410
     411    // testListConvertSort()
     412    // psList Conversion and Sorting Fxns");
    446413    {
    447         array = psListToArray(NULL);
    448         ok( array == NULL,
    449             "psListToArray:          return NULL for NULL list input.");
    450     }
    451     //Return empty array for empty list input
    452     {
    453         array = psListToArray(emptyList);
    454         ok( array->n == 0 && psMemCheckArray(array),
    455             "psListToArray:          return empty array for empty list input.");
    456         psFree(array);
    457         array = NULL;
    458     }
    459     //Return correct array for valid list input
    460     {
    461         array = psListToArray(list);
    462         ok( array->n == 3 && *((psS32*)(array->data[0])) == 2,
    463             "psListToArray:          return correct array for valid list input.");
    464     }
    465 
    466     //Tests for psArrayToList
    467     //Return NULL for NULL array input
    468     {
    469         out = psArrayToList(NULL);
    470         ok( out == NULL,
    471             "psArrayToList:          return NULL for NULL array input.");
    472     }
    473     //Return empty list for empty array input
    474     {
    475         out = psArrayToList(emptyArray);
    476         ok( out->n == 0 && psMemCheckList(out),
    477             "psArrayToList:          return empty list for empty array input.");
    478         psFree(out);
    479         out = NULL;
    480     }
    481     //Return correct list for valid array input
    482     {
    483         out = psArrayToList(array);
    484         ok( out->n == 3 && *((psS32*)psListGet(out, PS_LIST_HEAD)) == 2,
    485             "psArrayToList:          return correct list for valid array input.");
    486     }
    487 
    488     //Tests for psListSort
    489     //Return NULL for NULL list input
    490     {
    491         psList *none = NULL;
    492         none = psListSort(none, (psComparePtrFunc)psCompareDescendingS32Ptr);
    493         ok( none == NULL,
    494             "psListSort:             return NULL for NULL list input.");
    495     }
    496     //Return empty list for empty list input
    497     {
    498         emptyList = psListSort(emptyList, (psComparePtrFunc)psCompareDescendingS32Ptr);
    499         ok( emptyList != NULL,
    500             "psListSort:             return empty list for empty list input.");
    501     }
    502     //Return properly sorted list for valid inputs
    503     {
    504         list = psListSort(list, (psComparePtrFunc)psCompareS32Ptr);
    505         ok( *((psS32*)psListGet(list, 0)) == 1 &&  *((psS32*)psListGet(list, 1)) == 2,
    506             "psListSort:             return properly sorted list for valid inputs.");
    507     }
    508     //Return unchanged list for NULL psComparePtrFunc
    509     {
    510         psList *tempList = NULL;
    511         tempList = psListSort(list, NULL);
    512         ok( tempList == NULL,
    513             "psListSort:             return NULL for NULL psComparePtrFunc.");
    514     }
    515 
    516 
    517     //Check for Memory leaks
    518     {
     414        psMemId id = psMemGetId();
     415        psList *emptyList = psListAlloc(NULL);
     416        psS32 *s1 = (psS32*)psAlloc(sizeof(psS32));
     417        *s1 = 2;
     418        psS32 *s2 = (psS32*)psAlloc(sizeof(psS32));
     419        *s2 = 3;
     420        psS32 *s3 = (psS32*)psAlloc(sizeof(psS32));
     421        *s3 = 1;
     422        psList *list = psListAlloc(s1);
     423        psListAdd(list, PS_LIST_TAIL, s2);
     424        psListAdd(list, PS_LIST_TAIL, s3);
     425        psArray *array = NULL;
     426        psArray *emptyArray = psArrayAlloc(0);
     427        psList *out = NULL;
     428   
     429        //Tests for psListToArray
     430        //Return NULL for NULL list input
     431        {
     432            array = psListToArray(NULL);
     433            ok( array == NULL,
     434                "psListToArray:          return NULL for NULL list input.");
     435        }
     436        //Return empty array for empty list input
     437        {
     438            array = psListToArray(emptyList);
     439            ok( array->n == 0 && psMemCheckArray(array),
     440                "psListToArray:          return empty array for empty list input.");
     441            psFree(array);
     442            array = NULL;
     443        }
     444        //Return correct array for valid list input
     445        {
     446            array = psListToArray(list);
     447            ok( array->n == 3 && *((psS32*)(array->data[0])) == 2,
     448                "psListToArray:          return correct array for valid list input.");
     449        }
     450   
     451        //Tests for psArrayToList
     452        //Return NULL for NULL array input
     453        {
     454            out = psArrayToList(NULL);
     455            ok( out == NULL,
     456                "psArrayToList:          return NULL for NULL array input.");
     457        }
     458        //Return empty list for empty array input
     459        {
     460            out = psArrayToList(emptyArray);
     461            ok( out->n == 0 && psMemCheckList(out),
     462                "psArrayToList:          return empty list for empty array input.");
     463            psFree(out);
     464            out = NULL;
     465        }
     466        //Return correct list for valid array input
     467        {
     468            out = psArrayToList(array);
     469            ok( out->n == 3 && *((psS32*)psListGet(out, PS_LIST_HEAD)) == 2,
     470                "psArrayToList:          return correct list for valid array input.");
     471        }
     472   
     473        //Tests for psListSort
     474        //Return NULL for NULL list input
     475        {
     476            psList *none = NULL;
     477            none = psListSort(none, (psComparePtrFunc)psCompareDescendingS32Ptr);
     478            ok( none == NULL,
     479                "psListSort:             return NULL for NULL list input.");
     480        }
     481        //Return empty list for empty list input
     482        {
     483            emptyList = psListSort(emptyList, (psComparePtrFunc)psCompareDescendingS32Ptr);
     484            ok( emptyList != NULL,
     485                "psListSort:             return empty list for empty list input.");
     486        }
     487        //Return properly sorted list for valid inputs
     488        {
     489            list = psListSort(list, (psComparePtrFunc)psCompareS32Ptr);
     490            ok( *((psS32*)psListGet(list, 0)) == 1 &&  *((psS32*)psListGet(list, 1)) == 2,
     491                "psListSort:             return properly sorted list for valid inputs.");
     492        }
     493        //Return unchanged list for NULL psComparePtrFunc
     494        {
     495            psList *tempList = NULL;
     496            tempList = psListSort(list, NULL);
     497            ok( tempList == NULL,
     498                "psListSort:             return NULL for NULL psComparePtrFunc.");
     499        }
     500   
    519501        psFree(array);
    520502        psFree(out);
    … …  
    525507        psFree(s2);
    526508        psFree(s3);
    527         checkMem();
     509        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    528510    }
    529 
    530511}

  • trunk/psLib/test/types/tap_psLookupTable_all.c

    r12607 r12781  
    88 * Author: dRob <David.Robbins@mhpcc.hpc.mil>, (C) 2006
    99 *
     10 * XXX: Must add correct build directories.  This file reads a file in the
     11 * types/ subdirectory and will not execute directly if not run from psLib/test
     12 *
    1013 * Copyright: See COPYING file that comes with this distribution
    1114 *
    1215 */
    13 
    1416#include <pslib.h>
    1517#include <string.h>
    16 
    1718#include "tap.h"
    1819#include "pstap.h"
    1920
    20 void testLookupTableAlloc(void);
    21 void testLookupTableReadImport(void);
    22 void testLookupTableInterpolates(void);
    2321
    2422int main(void)
    … …  
    2624    psLogSetFormat("HLNM");
    2725    psLogSetLevel(PS_LOG_INFO);
    28     plan_tests(29);
    29 
    30     //    note("Tests for psLookupTable Functions");
    31 
    32     testLookupTableAlloc();
    33     testLookupTableReadImport();
    34     testLookupTableInterpolates();
    35 
    36     done();
    37 }
    38 
    39 void testLookupTableAlloc(void)
    40 {
    41     //    note("  >>>Test 1:  psLookupTableAlloc & psMemCheckLookupTable Fxns");
    42 
    43     psLookupTable *lt = NULL;
    44 
    45     //Tests for psLookupTableAlloc
    46     //Return NULL for NULL filename input
     26    plan_tests(31);
     27
     28    // Tests for psLookupTable Functions
     29
     30
     31    // testLookupTableAlloc()
     32    // psLookupTableAlloc & psMemCheckLookupTable Fxns
    4733    {
    48         lt = psLookupTableAlloc(NULL, "\%f \%lf \%d \%ld", 10);
    49         ok( lt == NULL,
    50             "psLookupTableAlloc:               return NULL for NULL filename input.");
     34        psMemId id = psMemGetId();
     35        psLookupTable *lt = NULL;
     36        //Tests for psLookupTableAlloc
     37        //Return NULL for NULL filename input
     38        {
     39            lt = psLookupTableAlloc(NULL, "\%f \%lf \%d \%ld", 10);
     40            ok( lt == NULL,
     41                "psLookupTableAlloc:               return NULL for NULL filename input.");
     42        }
     43        //Return NULL for NULL format input
     44        {
     45            lt = psLookupTableAlloc("table.dat", NULL, 10);
     46            ok( lt == NULL,
     47                "psLookupTableAlloc:               return NULL for NULL format input.");
     48        }
     49        //Return properly allocated lookupTable for valid inputs
     50        {
     51            lt = psLookupTableAlloc("table.dat", "\%f \%lf \%d \%ld", 10);
     52            ok( lt != NULL && psMemCheckLookupTable(lt),
     53                "psLookupTableAlloc:               "
     54                "return properly allocated lookupTable for valid inputs.");
     55        }
     56
     57        //Tests for psMemCheckArray
     58        //Make sure psMemCheckArray works correctly - return false
     59        {
     60            int j = 2;
     61            ok( !psMemCheckLookupTable(&j),
     62                "psMemCheckLookupTable:            return false for non-LookupTable input.");
     63        }
     64
     65        psFree(lt);
     66        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    5167    }
    52     //Return NULL for NULL format input
     68
     69
     70    // testLookupTableReadImport()
     71    // psVectorsReadFromFile, psLookupTableImport, psLookupTableRead Fxns");
    5372    {
    54         lt = psLookupTableAlloc("table.dat", NULL, 10);
    55         ok( lt == NULL,
    56             "psLookupTableAlloc:               return NULL for NULL format input.");
    57     }
    58     //Return properly allocated lookupTable for valid inputs
    59     {
    60         lt = psLookupTableAlloc("table.dat", "\%f \%lf \%d \%ld", 10);
    61         ok( lt != NULL && psMemCheckLookupTable(lt),
    62             "psLookupTableAlloc:               "
    63             "return properly allocated lookupTable for valid inputs.");
    64     }
    65 
    66     //Tests for psMemCheckArray
    67     //Make sure psMemCheckArray works correctly - return false
    68     {
    69         int j = 2;
    70         ok( !psMemCheckLookupTable(&j),
    71             "psMemCheckLookupTable:            return false for non-LookupTable input.");
    72     }
    73 
    74     //Check for Memory leaks
    75     {
    76         psFree(lt);
    77         checkMem();
    78     }
    79 
    80 }
    81 
    82 void testLookupTableReadImport(void)
    83 {
    84     //    diag("  >>>Test 2:  psVectorsReadFromFile, psLookupTableImport, psLookupTableRead Fxns");
    85     psArray *outVec = NULL;
    86     psArray *vectors = NULL;
    87     psLookupTable*  table1  = NULL;
    88     long           numRows = 0;
    89 
    90     //Tests for psVectorReadFromFile
    91     // Attempt to read from NULL filename input
    92     {
    93         outVec = psVectorsReadFromFile(NULL,
    94                                        "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
    95         ok( outVec == NULL,
    96             "psVectorsReadFromFile:            return NULL for NULL filename input.");
    97     }
    98     // Attempt to read from NULL format input
    99     {
    100         outVec = psVectorsReadFromFile("table.dat", NULL);
    101         ok( outVec == NULL,
    102             "psVectorsReadFromFile:            return NULL for NULL format input.");
    103     }
    104     // Attempt to read from invalid filename input
    105     {
    106         outVec = psVectorsReadFromFile("tableS32.dat",
    107                                        "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
    108         ok( outVec == NULL,
    109             "psVectorsReadFromFile:            return NULL for invalid filename input.");
    110     }
    111     // Attempt to read from invalid format input
    112     {
    113         outVec = psVectorsReadFromFile("table.dat", "\%s");
    114         ok( outVec == NULL,
    115             "psVectorsReadFromFile:            return NULL for invalid format input.");
    116     }
    117     // Attempt to read from table containing invalid entry - F32
    118     {
    119         outVec = psVectorsReadFromFile("tableF32_err.dat",
    120                                        "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
    121         ok( outVec == NULL,
    122             "psVectorsReadFromFile:            return NULL for table containing invalid entry.");
    123     }
    124     // Attempt to read from table containing invalid entry - F64
    125     {
    126         outVec = psVectorsReadFromFile("tableF64_err.dat",
    127                                        "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
    128         ok( outVec == NULL,
    129             "psVectorsReadFromFile:           return NULL for table containing invalid entry.");
    130     }
    131     // Attempt to read from table containing invalid entry - S32
    132     {
    133         outVec = psVectorsReadFromFile("tableS32_err.dat",
    134                                        "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
    135         ok( outVec == NULL,
    136             "psVectorsReadFromFile:           return NULL for table containing invalid entry.");
    137     }
    138     // Attempt to read from table containing invalid entry - S64
    139     {
    140         outVec = psVectorsReadFromFile("tableS64_err.dat",
    141                                        "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
    142         ok( outVec == NULL,
    143             "psVectorsReadFromFile:           return NULL for table containing invalid entry.");
    144     }
    145     // Attempt to read from empty table
    146     {
    147         outVec = psVectorsReadFromFile("tableF32_2.dat",
    148                                        "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
    149         ok( outVec == NULL,
    150             "psVectorsReadFromFile:           return NULL for empty table.");
    151     }
    152     // Attempt to read from file with partially constructed row
    153     {
    154         outVec = psVectorsReadFromFile("table3.dat",
    155                                        "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
    156         ok( outVec == NULL,
    157             "psVectorsReadFromFile:           return NULL for table with partially"
    158             " constructed row.");
    159     }
    160     //Attempt to read with valid inputs
    161     {
    162         outVec = psVectorsReadFromFile("types/table.dat",
    163                                        "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
    164         ok( outVec != NULL &&  outVec->n == 9 &&
    165             ((psVector*)(outVec->data[6]))->data.S32[1] == -8,
    166             "psVectorsReadFromFile:           return correct array for valid format input.");
    167     }
    168 
    169     //Tests for psLookupTableRead
    170     // Attempt to read table with NULL input table specified
    171     numRows = psLookupTableRead(table1);
    172     {
    173         ok( numRows == 0,
    174             "psLookupTableRead:               return NULL for NULL filename input.");
    175     }
    176     // Attempt to read table with bad filename specified
    177     table1 = psLookupTableAlloc("psTable.dat", "\%f \%lf \%d \%ld", 10);
    178     numRows = psLookupTableRead(table1);
    179     {
    180         ok( numRows == 0,
    181             "psLookupTableRead:               return NULL for table with invalid filename.");
    182     }
    183 
    184     // Attempt to read valid table with wrong indexCol
    185     psFree(table1);
    186     table1 = psLookupTableAlloc("table.dat",
     73        psMemId id = psMemGetId();
     74        psArray *outVec = NULL;
     75        psArray *vectors = NULL;
     76        psLookupTable*  table1  = NULL;
     77        long           numRows = 0;
     78
     79        //Tests for psVectorReadFromFile
     80        // Attempt to read from NULL filename input
     81        {
     82            outVec = psVectorsReadFromFile(NULL,
     83                                           "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
     84            ok( outVec == NULL,
     85                "psVectorsReadFromFile:            return NULL for NULL filename input.");
     86        }
     87        // Attempt to read from NULL format input
     88        {
     89            outVec = psVectorsReadFromFile("table.dat", NULL);
     90            ok( outVec == NULL,
     91                "psVectorsReadFromFile:            return NULL for NULL format input.");
     92        }
     93        // Attempt to read from invalid filename input
     94        {
     95            outVec = psVectorsReadFromFile("tableS32.dat",
     96                                           "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
     97            ok( outVec == NULL,
     98                "psVectorsReadFromFile:            return NULL for invalid filename input.");
     99        }
     100        // Attempt to read from invalid format input
     101        {
     102            outVec = psVectorsReadFromFile("table.dat", "\%s");
     103            ok( outVec == NULL,
     104                "psVectorsReadFromFile:            return NULL for invalid format input.");
     105        }
     106        // Attempt to read from table containing invalid entry - F32
     107        {
     108            outVec = psVectorsReadFromFile("tableF32_err.dat",
     109                                           "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
     110            ok( outVec == NULL,
     111                "psVectorsReadFromFile:            return NULL for table containing invalid entry.");
     112        }
     113        // Attempt to read from table containing invalid entry - F64
     114        {
     115            outVec = psVectorsReadFromFile("tableF64_err.dat",
     116                                           "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
     117            ok( outVec == NULL,
     118                "psVectorsReadFromFile:           return NULL for table containing invalid entry.");
     119        }
     120        // Attempt to read from table containing invalid entry - S32
     121        {
     122            outVec = psVectorsReadFromFile("tableS32_err.dat",
     123                                           "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
     124            ok( outVec == NULL,
     125                "psVectorsReadFromFile:           return NULL for table containing invalid entry.");
     126        }
     127        // Attempt to read from table containing invalid entry - S64
     128        {
     129            outVec = psVectorsReadFromFile("tableS64_err.dat",
     130                                           "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
     131            ok( outVec == NULL,
     132                "psVectorsReadFromFile:           return NULL for table containing invalid entry.");
     133        }
     134        // Attempt to read from empty table
     135        {
     136            outVec = psVectorsReadFromFile("tableF32_2.dat",
     137                                           "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
     138            ok( outVec == NULL,
     139                "psVectorsReadFromFile:           return NULL for empty table.");
     140        }
     141        // Attempt to read from file with partially constructed row
     142        {
     143            outVec = psVectorsReadFromFile("table3.dat",
     144                                           "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
     145            ok( outVec == NULL,
     146                "psVectorsReadFromFile:           return NULL for table with partially"
     147                " constructed row.");
     148        }
     149        //Attempt to read with valid inputs
     150        {
     151            outVec = psVectorsReadFromFile("types/table.dat",
     152                                           "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf");
     153            ok( outVec != NULL &&  outVec->n == 9 &&
     154                ((psVector*)(outVec->data[6]))->data.S32[1] == -8,
     155                "psVectorsReadFromFile:           return correct array for valid format input.");
     156        }
     157
     158        //Tests for psLookupTableRead
     159        // Attempt to read table with NULL input table specified
     160        numRows = psLookupTableRead(table1);
     161        {
     162            ok( numRows == 0,
     163                "psLookupTableRead:               return NULL for NULL filename input.");
     164        }
     165        // Attempt to read table with bad filename specified
     166        table1 = psLookupTableAlloc("psTable.dat", "\%f \%lf \%d \%ld", 10);
     167        numRows = psLookupTableRead(table1);
     168        {
     169            ok( numRows == 0,
     170                "psLookupTableRead:               return NULL for table with invalid filename.");
     171        }
     172
     173        // Attempt to read valid table with wrong indexCol
     174        psFree(table1);
     175        table1 = psLookupTableAlloc("table.dat",
    187176                                "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 10);
    188     numRows = psLookupTableRead(table1);
    189     {
    190         ok( numRows == 0,
    191             "psLookupTableRead:               return correct number of rows for valid inputs.");
    192     }
    193     // Attempt to read valid table
    194     psFree(table1);
    195     table1 = psLookupTableAlloc("types/table.dat",
    196                                 "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0);
    197     numRows = psLookupTableRead(table1);
    198     {
    199         ok( numRows == 4,
    200             "psLookupTableRead:               return correct number of rows for valid inputs.");
    201     }
    202 
    203     //Tests for psLookupTableImport (remaining cases)
    204     // Attempt to import table with negative indexCol
    205     vectors = psVectorsReadFromFile(table1->filename, table1->format);
    206     {
    207         ok( !psLookupTableImport(table1, vectors, -1 ),
    208             "psLookupTableImport:             return false for negative indexCol input.");
    209     }
    210     //Attempt to import table with unsorted array column
    211     psFree(table1);
    212     table1 = psLookupTableAlloc("types/table.dat",
    213                                 "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0);
    214     {
    215         ok( psLookupTableImport(table1, vectors, 7 ),
    216             "psLookupTableImport:             return true for array with unsorted column");
    217     }
    218 
    219     //Check for Memory leaks
    220     {
     177        numRows = psLookupTableRead(table1);
     178        {
     179            ok( numRows == 0,
     180                "psLookupTableRead:               return correct number of rows for valid inputs.");
     181        }
     182        // Attempt to read valid table
     183        psFree(table1);
     184        table1 = psLookupTableAlloc("types/table.dat",
     185                                    "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0);
     186        numRows = psLookupTableRead(table1);
     187        {
     188            ok( numRows == 4,
     189                "psLookupTableRead:               return correct number of rows for valid inputs.");
     190        }
     191
     192        //Tests for psLookupTableImport (remaining cases)
     193        // Attempt to import table with negative indexCol
     194        vectors = psVectorsReadFromFile(table1->filename, table1->format);
     195        {
     196            ok( !psLookupTableImport(table1, vectors, -1 ),
     197                "psLookupTableImport:             return false for negative indexCol input.");
     198        }
     199        //Attempt to import table with unsorted array column
     200        psFree(table1);
     201        table1 = psLookupTableAlloc("types/table.dat",
     202                                    "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0);
     203        {
     204            ok( psLookupTableImport(table1, vectors, 7 ),
     205                "psLookupTableImport:             return true for array with unsorted column");
     206        }
     207
    221208        psFree(vectors);
    222209        psFree(outVec);
    223210        psFree(table1);
    224         checkMem();
     211        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    225212    }
    226 }
    227 
    228 void testLookupTableInterpolates(void)
    229 {
    230     //    diag("  >>>Test 3:  psLookupTableInterpolate & psLookupTableInterpolateAll Fxns");
    231     psLookupTable *table1 = NULL;
    232     psVector *vec = NULL;
    233     table1 = psLookupTableAlloc("types/table.dat",
    234                                 "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0);
    235     psLookupTable *table2 = NULL;
    236     table2 = psLookupTableAlloc("types/table.dat",
    237                                 "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0);
    238     psLookupTableRead(table2);
    239 
    240     //Tests for psLookupTableInterpolateAll
    241     //Return NULL for NULL table input
     213
     214
     215    // testLookupTableInterpolates()
     216    // psLookupTableInterpolate & psLookupTableInterpolateAll Fxns
    242217    {
    243         vec = psLookupTableInterpolateAll(NULL, 0);
    244         ok( vec == NULL,
    245             "psLookupTableInterpolateAll:     return NULL for NULL table input.");
    246     }
    247     //Return NULL for NULL table values
    248     {
    249         vec = psLookupTableInterpolateAll(table1, 0);
    250         ok( vec == NULL,
    251             "psLookupTableInterpolateAll:     return NULL for NULL table values.");
    252     }
    253 
    254     ok(table2->values != NULL, "table->values not NULL");
    255     //Return NULL for table with table->values->n == 0
    256     {
    257         long n = table2->values->n;
    258         table2->values->n = 0;
    259         vec = psLookupTableInterpolateAll(table2, 0);
    260         ok( vec == NULL,
    261             "psLookupTableInterpolateAll:     return NULL for table with no columns.");
    262         table2->values->n = n;
    263     }
    264     //Return NULL for invalid index input
    265     {
    266         vec = psLookupTableInterpolateAll(table2, -10.5);
    267         ok( vec == NULL,
    268             "psLookupTableInterpolateAll:     return NULL for invalid index input.");
    269     }
    270     //Return correct vector output for valid inputs
    271     {
    272         vec = psLookupTableInterpolateAll(table2, 1);
    273         skip_start(  vec == NULL, 1,
    274                      "Skipping 1 tests because psLookupTableInterpolateAll failed");
    275         is_double(vec->data.F64[0], 1.0,
    276                   "psLookupTableInterpolateAll:     return correct output vector for valid inputs.");
    277         skip_end();
    278     }
    279 
    280     //Remaining tests for psLookupTableInterpolate
    281     //Return NAN for invalid index - divide by zero error
    282     psLookupTable *table3 = NULL;
    283     table3 = psLookupTableAlloc("table2.dat",
    284                                 "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0);
    285     psLookupTableRead(table3);
    286     {
    287         double retVal;
    288         retVal = psLookupTableInterpolate(table3, 1.5e-20, 0);
    289         ok( isnan(retVal),
    290             "psLookupTableInterpolateAll:     return NAN for invalid index input.");
    291     }
    292 
    293     //Check for Memory leaks
    294     {
     218        psMemId id = psMemGetId();
     219        psLookupTable *table1 = NULL;
     220        psVector *vec = NULL;
     221        // XXX: Remove the "types" path here
     222        table1 = psLookupTableAlloc("types/table.dat",
     223                                    "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0);
     224        psLookupTable *table2 = NULL;
     225        // XXX: Remove the "types" path here
     226        table2 = psLookupTableAlloc("types/table.dat",
     227                                    "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0);
     228        psLookupTableRead(table2);
     229   
     230        //Tests for psLookupTableInterpolateAll
     231        //Return NULL for NULL table input
     232        {
     233            vec = psLookupTableInterpolateAll(NULL, 0);
     234            ok( vec == NULL,
     235                "psLookupTableInterpolateAll:     return NULL for NULL table input.");
     236        }
     237        //Return NULL for NULL table values
     238        {
     239            vec = psLookupTableInterpolateAll(table1, 0);
     240            ok( vec == NULL,
     241                "psLookupTableInterpolateAll:     return NULL for NULL table values.");
     242        }
     243   
     244        ok(table2->values != NULL, "table->values not NULL");
     245        //Return NULL for table with table->values->n == 0
     246        {
     247            long n = table2->values->n;
     248            table2->values->n = 0;
     249            vec = psLookupTableInterpolateAll(table2, 0);
     250            ok( vec == NULL,
     251                "psLookupTableInterpolateAll:     return NULL for table with no columns.");
     252            table2->values->n = n;
     253        }
     254        //Return NULL for invalid index input
     255        {
     256            vec = psLookupTableInterpolateAll(table2, -10.5);
     257            ok( vec == NULL,
     258                "psLookupTableInterpolateAll:     return NULL for invalid index input.");
     259        }
     260        //Return correct vector output for valid inputs
     261        {
     262            vec = psLookupTableInterpolateAll(table2, 1);
     263            skip_start(  vec == NULL, 1,
     264                         "Skipping 1 tests because psLookupTableInterpolateAll failed");
     265            is_double(vec->data.F64[0], 1.0,
     266                      "psLookupTableInterpolateAll:     return correct output vector for valid inputs.");
     267            skip_end();
     268        }
     269   
     270        //Remaining tests for psLookupTableInterpolate
     271        //Return NAN for invalid index - divide by zero error
     272        psLookupTable *table3 = NULL;
     273        table3 = psLookupTableAlloc("table2.dat",
     274                                    "\%f \%d \%d \%ld \%d \%d \%d \%ld \%*d \%lf", 0);
     275        psLookupTableRead(table3);
     276        {
     277            double retVal;
     278            retVal = psLookupTableInterpolate(table3, 1.5e-20, 0);
     279            ok( isnan(retVal),
     280                "psLookupTableInterpolateAll:     return NAN for invalid index input.");
     281        }
     282   
    295283        psFree(table3);
    296284        psFree(vec);
    297285        psFree(table2);
    298286        psFree(table1);
    299         checkMem();
     287        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    300288    }
    301 
    302289}

  • trunk/psLib/test/types/tap_psMetadataConfigFormat.c

    r12607 r12781  
    99 *
    1010 */
    11 
    1211#include <pslib.h>
    1312#include <string.h>
    14 
    1513#include "tap.h"
    1614#include "pstap.h"
    … …  
    1816int main(void)
    1917{
     18    psLogSetFormat("HLNM");
     19    psLogSetLevel(PS_LOG_INFO);
    2020    plan_tests(16 + 1);
    2121
    2222    psMetadata *md = NULL;
    2323    psString out = NULL;
    24 
    2524    //psString psMetadataConfigFormat(psMetadata *md);
    26 
    2725    //Return NULL for NULL metadata input
    2826    {

  • trunk/psLib/test/types/tap_psMetadataConfigParse.c

    r12607 r12781  
    1010 *
    1111 */
    12 
    1312#include <pslib.h>
    1413#include <string.h>
    1514#include <fcntl.h>
    1615#include <unistd.h>
    17 
    1816#include "tap.h"
    1917#include "pstap.h"
    … …  
    2119int main(void)
    2220{
    23     plan_tests(35 + 1);
    24 
    2521    psLogSetFormat("HLNM");
    26 //    psTraceSetLevel("err", 10);
     22    psLogSetLevel(PS_LOG_INFO);
     23    plan_tests(35);
    2724
    2825
    … …  
    3835    }
    3936
     37
    4038    // Return empty metadata for incorrect string input
    4139    {
    … …  
    4846        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    4947    }
     48
    5049
    5150    // Return correct metadata for correct string input - S32
    … …  
    6968    }
    7069
     70
    7171    // Return correct metadata for correct string input - F64
    7272    {
    … …  
    8989        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    9090    }
     91
    9192
    9293    // Return correct metadata for string with duplicate entry - S8
    … …  
    114115    }
    115116
     117
    116118    // Return correct metadata for correct string input - Vector
    117119    {
    … …  
    137139    }
    138140
     141
    139142    // Return empty metadata for incorrect string input
    140143    {
    … …  
    148151        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    149152    }
    150 
    151     done();
    152153}
    153154

  • trunk/psLib/test/types/tap_psMetadataConfigParse_time.c

    r12478 r12781  
    11#include <stdio.h>
    22#include <pslib.h>
    3 
    43#include "tap.h"
    54#include "pstap.h"
    … …  
    76int main (void)
    87{
     8    psLogSetFormat("HLNM");
     9    psLogSetLevel(PS_LOG_INFO);
    910    plan_tests(39 + 1);
     11
    1012
    1113    {
    1214        psMemId id = psMemGetId();
    13 
    1415        char *testStr = "time    UTC     2005-03-18T16:05:00Z\n";
    15 
    1616        psU32 nBad = 0;
    1717        psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false);
    … …  
    2828
    2929        psFree(md);
    30 
    3130        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    3231    }
    3332
     33
    3434    {
    3535        psMemId id = psMemGetId();
    36 
    3736        char *testStr = "time    UT1     2005-03-18T16:05:00Z\n";
    38 
    3937        psU32 nBad = 0;
    4038        psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false);
    … …  
    5149
    5250        psFree(md);
    53 
    5451        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    5552    }
    5653
     54
    5755    {
    5856        psMemId id = psMemGetId();
    59 
    6057        char *testStr = "time    TAI     2005-03-18T16:05:00Z\n";
    61 
    6258        psU32 nBad = 0;
    6359        psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false);
    … …  
    7470
    7571        psFree(md);
    76 
    7772        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    7873    }
    7974
     75
    8076    {
    8177        psMemId id = psMemGetId();
    82 
    8378        char *testStr = "time    TT      2005-03-18T16:05:00Z";
    84 
    8579        psU32 nBad = 0;
    8680        psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false);
    … …  
    9791
    9892        psFree(md);
    99 
    10093        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    10194    }
    10295
     96
    10397    {
    10498        psMemId id = psMemGetId();
    105 
    10699        // missing Z
    107100        char *testStr = "broken      UTC     2005-03-18T16:05:00";
    108 
    109101        psU32 nBad = 0;
    110102        psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false);
    … …  
    120112    {
    121113        psMemId id = psMemGetId();
    122 
    123114        // missing Z
    124115        char *testStr = "broken      UT1     2005-03-18T16:05:00";
    125 
    126116        psU32 nBad = 0;
    127117        psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false);
    … …  
    137127    {
    138128        psMemId id = psMemGetId();
    139 
    140129        // missing Z
    141130        char *testStr = "broken      TAI     2005-03-18T16:05:00";
    142 
    143131        psU32 nBad = 0;
    144132        psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false);
    … …  
    149137
    150138        psFree(md);
    151 
    152139        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    153140    }
    154141
     142
    155143    {
    156144        psMemId id = psMemGetId();
    157 
    158145        // missing Z
    159146        char *testStr = "broken      TT      2005-03-18T16:05:00";
    160 
    161147        psU32 nBad = 0;
    162148        psMetadata *md = psMetadataConfigParse(NULL, &nBad, testStr, false);
    … …  
    167153
    168154        psFree(md);
    169 
    170155        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    171156    }
    172 
    173     return exit_status();
    174157}

  • trunk/psLib/test/types/tap_psMetadataConfigPrint.c

    r12607 r12781  
    99 *
    1010 */
    11 
    1211#include <pslib.h>
    1312#include <string.h>
    14 
    1513#include "tap.h"
    1614#include "pstap.h"
    … …  
    1816int main(void)
    1917{
    20     plan_tests(7);
     18    psLogSetFormat("HLNM");
     19    psLogSetLevel(PS_LOG_INFO);
     20    plan_tests(11);
     21
    2122
    2223    //Return false for NULL metadata input
    2324    {
     25        psMemId id = psMemGetId();
    2426        FILE *openfile = fopen("mdcfg.prt", "w+");
    2527
    … …  
    2830
    2931        fclose(openfile);
    30         remove
    31             ("mdcfg.prt");
     32        remove("mdcfg.prt");
     33        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    3234    }
     35
    3336
    3437    //Return false for empty metadata input
    3538    {
     39        psMemId id = psMemGetId();
    3640        FILE *openfile = fopen("mdcfg.prt", "w+");
    3741        psMetadata *md = psMetadataAlloc();
    … …  
    4246        psFree(md);
    4347        fclose(openfile);
    44         remove
    45             ("mdcfg.prt");
     48        remove("mdcfg.prt");
     49        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    4650    }
     51
    4752
    4853    //Return false for NULL file input
    4954    {
     55        psMemId id = psMemGetId();
    5056        psMetadata *md = psMetadataAlloc();
    5157        psMetadataAddS32(md, PS_LIST_HEAD, "new S32", 0, "", 666);
    … …  
    5561
    5662        psFree(md);
     63        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    5764    }
     65
    5866
    5967    // Return false for read-only file input
    6068    {
     69        psMemId id = psMemGetId();
    6170        // create an empty file to open read only later
    6271        {
    … …  
    7483        psFree(md);
    7584        fclose(openfile);
    76         remove
    77             ("mdcfg.prt");
     85        remove("mdcfg.prt");
     86        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    7887    }
     88
    7989
    8090    // Return true for valid inputs
    8191    {
     92        psMemId id = psMemGetId();
    8293        FILE *openfile = fopen("mdcfg.prt", "w+");
    8394        psMetadata *md = psMetadataAlloc();
    … …  
    100111
    101112        fclose(mdcfg);
    102         remove
    103             ("mdcfg.prt");
     113        remove("mdcfg.prt");
     114        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    104115    }
    105 
    106     done();
    107116}

  • trunk/psLib/test/types/tap_psMetadataConfigRead.c

    r12474 r12781  
    109109                     )
    110110{
     111    psMemId id = psMemGetId();
    111112    skip_start(!item, 3, "Skipping 4 tests because !item");
    112113    ok(strcmp(item->name, name) == 0, "item->name = %s", item->name);
    … …  
    142143    }
    143144    skip_end();
     145    ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    144146    return NULL;
    145147}
    146148
    147149
    148 int main (void)
     150int main(void)
    149151{
    150     plan_tests(52);
     152    psLogSetFormat("HLNM");
     153    psLogSetLevel(PS_LOG_INFO);
     154    plan_tests(62);
    151155
    152156    generateMDConfig();

  • trunk/psLib/test/types/tap_psMetadataConfigWrite.c

    r12607 r12781  
    99 *
    1010 */
    11 
    1211#include <pslib.h>
    1312#include <string.h>
    14 
    1513#include "tap.h"
    1614#include "pstap.h"
    1715
     16
    1817int main(void)
    1918{
    20     plan_tests(7);
     19    psLogSetFormat("HLNM");
     20    psLogSetLevel(PS_LOG_INFO);
     21    plan_tests(11);
     22
    2123
    2224    //Return false for NULL metadata input
    2325    {
     26        psMemId id = psMemGetId();
    2427        ok( !psMetadataConfigWrite(NULL, "mdcfg.wrt"),
    2528            "return false for NULL metadata input.");
     29        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    2630    }
     31
    2732
    2833    //Return false for NULL filename input
    2934    {
     35        psMemId id = psMemGetId();
    3036        psMetadata *md = psMetadataAlloc();
    3137        ok( !psMetadataConfigWrite(md, NULL),
    3238            "return false for NULL filename input.");
    3339        psFree(md);
     40        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    3441    }
     42
    3543
    3644    //Return false for invalid filename input
    3745    {
     46        psMemId id = psMemGetId();
    3847        psMetadata *md = psMetadataAlloc();
    3948        ok( !psMetadataConfigWrite(md, "."),
    4049            "return false for invalid filename input.");
    4150        psFree(md);
     51        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    4252    }
     53
    4354
    4455    //Return false for empty metadata input
    4556    {
     57        psMemId id = psMemGetId();
    4658        psMetadata *md = psMetadataAlloc();
    4759        ok( !psMetadataConfigWrite(md, "mdcfg.wrt"),
    4860            "return false for empty metadata input.");
    4961        psFree(md);
     62        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    5063    }
     64
    5165
    5266    //Return true for valid inputs
    5367    {
     68        psMemId id = psMemGetId();
    5469        psMetadata *md = psMetadataAlloc();
    5570        psMetadataAddBool(md, PS_LIST_TAIL, "item1-1", 0, "I am a boolean", true);
    … …  
    6883            ("mdcfg.wrt");
    6984        psFree(md);
     85        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    7086    }
    71 
    72     done();
    7387}

  • trunk/psLib/test/types/tap_psMetadataConfig_input.c

    r12607 r12781  
    1010 *
    1111 */
    12 
    1312#include <pslib.h>
    1413#include <string.h>
    1514#include <fcntl.h>
    1615#include <unistd.h>
    17 
    18 
    1916#include "tap.h"
    2017#include "pstap.h"
    … …  
    2219int main(void)
    2320{
    24     plan_tests(30 + 1);
    25 
    2621    psLogSetFormat("HLNM");
    27 //    psTraceSetLevel("err", 10);
     22    psLogSetLevel(PS_LOG_INFO);
     23    plan_tests(30);
    2824
    2925
    … …  
    3329        unsigned int nfail = 0;
    3430        psMetadata *md = psMetadataConfigRead(NULL, &nfail, NULL, false);
    35 
    3631        ok(md == NULL, "return NULL for NULL filename input.");
    37 
    3832        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    3933    }
     34
    4035
    4136    // Return NULL for invalid filename input
    … …  
    4439        unsigned int nfail = 0;
    4540        psMetadata *md = psMetadataConfigRead(NULL, &nfail, ".", false);
    46 
    4741        ok(md == NULL, "return NULL for invalid filename input.");
    48 
    4942        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    5043    }
     44
    5145
    5246    // Return NULL for missing file input
    … …  
    5650        psMetadata *md = psMetadataConfigRead(NULL, &nfail, "table4.dat", false);
    5751        ok(md == NULL, "return NULL for missing file input.");
    58 
    5952        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    6053    }
     54
    6155
    6256    // Return NULL for read-only file with comments, bad syntax, and no good
    … …  
    6862        ok(md == NULL, "return NULL for all bad syntax");
    6963        is_int(nfail, 0, "correct nfail");
    70 
    7164        psFree(md);
    7265        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    7366    }
     67
    7468
    7569    // Return true for valid inputs - overwrite = false
    … …  
    10094        is_int(item->data.S32, 666, "metdataItem value");
    10195        is_str(item->comment, "this line is \"GOOD\" but parsed in the top level", "metadataItem comment.");
    102 
    10396        skip_end();
    10497        psFree(md);
    10598        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    10699    }
     100
    107101
    108102    // Return true for valid inputs - overwrite = true
    … …  
    136130
    137131        is_str(item->comment, "", "metadataItem comment");
    138 
    139132        skip_end();
    140133        psFree(md);
    141134        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    142135    }
    143 
    144     done();
    145136}

  • trunk/psLib/test/types/tap_psMetadataItemCompare.c

    r10822 r12781  
    99 *
    1010 */
    11 
    1211#include <pslib.h>
    13 
    1412#include "tap.h"
    1513#include "pstap.h"
    1614
    17 void testItemCompare(void);
    1815
    19 int main (void)
     16int main(void)
    2017{
     18    psLogSetFormat("HLNM");
     19    psLogSetLevel(PS_LOG_INFO);
    2120    plan_tests(22);
    2221
    23     note("psMetadataItemCompare() tests");
     22    // psMetadataItemCompare() tests
     23    {
     24        psMemId id = psMemGetId();
     25        psMetadataItem *compare = NULL;
     26        psMetadataItem *template = NULL;
     27        psMetadataItem *itemCopy = NULL;
     28        psMetadataItem *item = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", true)
     29                               ;
     30   
     31        //Return false for NULL compare psMetadataItem
     32        {
     33            ok( !psMetadataItemCompare(compare, item),
     34                "psMetadataItemCompare:      return false for NULL compare input." );
     35        }
     36        //Return false for NULL template psMetadataItem
     37        {
     38            ok( !psMetadataItemCompare(item, template),
     39                "psMetadataItemCompare:      return false for NULL template input." );
     40        }
     41   
     42        //Return false for psMetadataItem's with different names
     43        {
     44            template = psMetadataItemAlloc("Milky Way", PS_DATA_BOOL, "No Comment", true)
     45                       ;
     46            compare = psMetadataItemAlloc("Snickers", PS_DATA_S32, "No Comment", 1);
     47            ok( !psMetadataItemCompare(template, item),
     48                "psMetadataItemCompare:      return false for input with different names.");
     49        }
    2450
    25     testItemCompare();
     51        //Return true for an exact match (copied psMetadataItem)
     52        {
     53            itemCopy = psMetadataItemCopy(item);
     54            ok( psMetadataItemCompare(itemCopy, item),
     55                "psMetadataItemCompare:      return true for comparison of identical psMetadataItem's.");
     56        }
     57   
     58        //Return true for psMetadataItem's with different types but otherwise identical
     59        {
     60            ok( psMetadataItemCompare(compare, item),
     61                "psMetadataItemCompare:      return true for valid compare of different type.");
     62        }
     63   
     64        //Return true for comparing Bool with F64
     65        {
     66            psFree(compare);
     67            compare = psMetadataItemAlloc("Snickers", PS_DATA_F64, "No Comment", 1.0000);
     68            ok( psMetadataItemCompare(compare, item),
     69                "psMetadataItemCompare:      return false for comparison of F64 to bool." );
     70        }
    2671
    27     done();
    28 }
     72        //Return true for comparing F64 with Bool
     73        {
     74            ok( psMetadataItemCompare(item, compare),
     75                "psMetadataItemCompare:      return false for comparison of bool to F64." );
     76        }
     77   
     78        //Return true for comparing S32 with F32 of same value
     79        {
     80            psFree(template);
     81            template = psMetadataItemAlloc("Snickers", PS_DATA_S32, "No Comment", 1);
     82            psFree(compare);
     83            compare = psMetadataItemAlloc("Snickers", PS_DATA_F32, "No Comment", 1.00);
     84            ok( psMetadataItemCompare(compare, template),
     85                "psMetadataItemCompare:      return true for comparison of S32 to F32." );
     86        }
    2987
    30 void testItemCompare(void)
    31 {
    32     note("  >>>Test 1:  psMetadataItemCompare");
     88        //Return true for comparing F32 with S32 of same value
     89        {
     90            ok( psMetadataItemCompare(template, compare),
     91                "psMetadataItemCompare:      return true for comparison of F32 to S32." );
     92        }
     93   
     94        //Return true for comparing U32 with S16 of same value
     95        {
     96            psFree(template);
     97            template = psMetadataItemAlloc("Snickers", PS_DATA_S16, "No Comment", 1);
     98            psFree(compare);
     99            compare = psMetadataItemAlloc("Snickers", PS_DATA_U32, "No Comment", 1);
     100            ok( psMetadataItemCompare(compare, template),
     101                "psMetadataItemCompare:     return true for comparison of S16 to U32." );
     102        }
    33103
    34     psMetadataItem *compare = NULL;
    35     psMetadataItem *template = NULL;
    36     psMetadataItem *itemCopy = NULL;
    37     psMetadataItem *item = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", true)
    38                            ;
     104        //Return true for comparing S16 with U32 of same value
     105        {
     106            ok( psMetadataItemCompare(template, compare),
     107                "psMetadataItemCompare:     return true for comparison of U32 to S16." );
     108        }
     109   
     110        //Return true for comparing U8 with U16 of same value
     111        {
     112            psFree(template);
     113            template = psMetadataItemAlloc("Snickers", PS_DATA_U8, "No Comment", 1);
     114            psFree(compare);
     115            compare = psMetadataItemAlloc("Snickers", PS_DATA_U16, "No Comment", 1);
     116            ok( psMetadataItemCompare(compare, template),
     117                "psMetadataItemCompare:     return true for comparison of U8 to U16." );
     118        }
    39119
    40     //Return false for NULL compare psMetadataItem
    41     {
    42         ok( !psMetadataItemCompare(compare, item),
    43             "psMetadataItemCompare:      return false for NULL compare input." );
    44     }
    45     //Return false for NULL template psMetadataItem
    46     {
    47         ok( !psMetadataItemCompare(item, template),
    48             "psMetadataItemCompare:      return false for NULL template input." )
    49         ;
    50     }
     120        //Return true for comparing U16 with U8 of same value
     121        {
     122            ok( psMetadataItemCompare(template, compare),
     123                "psMetadataItemCompare:     return true for comparison of U16 to U8." );
     124        }
     125   
     126        //Return true for comparing U8 with S8 of same value
     127        {
     128            psFree(compare);
     129            compare = psMetadataItemAlloc("Snickers", PS_DATA_S8, "No Comment", 1);
     130            ok( psMetadataItemCompare(compare, template),
     131                "psMetadataItemCompare:     return true for comparison of U8 to S8." );
     132        }
    51133
    52     //Return false for psMetadataItem's with different names
    53     {
    54         template = psMetadataItemAlloc("Milky Way", PS_DATA_BOOL, "No Comment", true)
    55                    ;
    56         compare = psMetadataItemAlloc("Snickers", PS_DATA_S32, "No Comment", 1);
    57         ok( !psMetadataItemCompare(template, item),
    58             "psMetadataItemCompare:      return false for input with different names.")
    59         ;
    60     }
    61     //Return true for an exact match (copied psMetadataItem)
    62     {
    63         itemCopy = psMetadataItemCopy(item);
    64         ok( psMetadataItemCompare(itemCopy, item),
    65             "psMetadataItemCompare:      return true for comparison of identical psMetadataItem's.");
    66     }
     134        //Return true for comparing S8 with U8 of same value
     135        {
     136            ok( psMetadataItemCompare(template, compare),
     137               "psMetadataItemCompare:     return true for comparison of S8 to U8." );
     138        }
     139   
     140        //Return false for comparing U8 with S64 of same value
     141        {
     142            psFree(compare);
     143            compare = psMetadataItemAlloc("Snickers", PS_DATA_S64, "No Comment", 1);
     144            ok( !psMetadataItemCompare(compare, template),
     145                "psMetadataItemCompare:     return false for comparison of U8 to S64*.  "
     146                "*not yet implemented" );
     147        }
    67148
    68     //Return true for psMetadataItem's with different types but otherwise identical
    69     {
    70         ok( psMetadataItemCompare(compare, item),
    71             "psMetadataItemCompare:      return true for valid compare of different type.");
    72     }
     149        //Return false for comparing S64 with U8 of same value
     150        {
     151            ok( !psMetadataItemCompare(template, compare),
     152                "psMetadataItemCompare:     return false for comparison of S64* to U8.  "
     153                "*not yet implemented" );
     154        }
     155   
     156        //Return false for comparing string of different value
     157        {
     158            psFree(compare);
     159            compare = psMetadataItemAlloc("Snickers", PS_DATA_STRING, "No Comment",
     160                                          "Not Going Anywhere?");
     161            psFree(template);
     162            template = psMetadataItemAlloc("Snickers", PS_DATA_STRING, "No Comment", "For a While?");
     163            ok( !psMetadataItemCompare(compare, template),
     164                "psMetadataItemCompare:     return false for comparison of different psString's.");
     165        }
     166   
     167        //Return true for comparing string of same value
     168        {
     169            psFree(template);
     170            template = psMetadataItemAlloc("Snickers", PS_DATA_STRING, "No Comment",
     171                                           "Not Going Anywhere?");
     172            ok( psMetadataItemCompare(compare, template),
     173                "psMetadataItemCompare:     return true for comparison of identical psString's.");
     174        }
     175   
     176        //Return false for comparing string with bool
     177        {
     178            psFree(template);
     179            template = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", false);
     180            ok( !psMetadataItemCompare(compare, template),
     181                "psMetadataItemCompare:     return false for comparison of psString with bool.");
     182        }
    73183
    74     //Return true for comparing Bool with F64
    75     {
     184        //Return false for comparing bool with string
     185        {
     186            psFree(template);
     187            template = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", false);
     188            ok( !psMetadataItemCompare(template, compare),
     189                "psMetadataItemCompare:     return false for comparison of psString with bool.");
     190        }
     191   
    76192        psFree(compare);
    77         compare = psMetadataItemAlloc("Snickers", PS_DATA_F64, "No Comment", 1.0000);
    78         ok( psMetadataItemCompare(compare, item),
    79             "psMetadataItemCompare:      return false for comparison of F64 to bool." );
    80     }
    81     //Return true for comparing F64 with Bool
    82     {
    83         ok( psMetadataItemCompare(item, compare),
    84             "psMetadataItemCompare:      return false for comparison of bool to F64." );
    85     }
    86 
    87     //Return true for comparing S32 with F32 of same value
    88     {
    89         psFree(template)
    90         ;
    91         template = psMetadataItemAlloc("Snickers", PS_DATA_S32, "No Comment", 1)
    92                    ;
    93         psFree(compare);
    94         compare = psMetadataItemAlloc("Snickers", PS_DATA_F32, "No Comment", 1.00);
    95         ok( psMetadataItemCompare(compare, template),
    96             "psMetadataItemCompare:      return true for comparison of S32 to F32." )
    97         ;
    98     }
    99     //Return true for comparing F32 with S32 of same value
    100     {
    101         ok( psMetadataItemCompare(template, compare),
    102             "psMetadataItemCompare:      return true for comparison of F32 to S32." )
    103         ;
    104     }
    105 
    106     //Return true for comparing U32 with S16 of same value
    107     {
    108         psFree(template)
    109         ;
    110         template = psMetadataItemAlloc("Snickers", PS_DATA_S16, "No Comment", 1)
    111                    ;
    112         psFree(compare);
    113         compare = psMetadataItemAlloc("Snickers", PS_DATA_U32, "No Comment", 1);
    114         ok( psMetadataItemCompare(compare, template),
    115             "psMetadataItemCompare:     return true for comparison of S16 to U32." )
    116         ;
    117     }
    118     //Return true for comparing S16 with U32 of same value
    119     {
    120         ok( psMetadataItemCompare(template, compare),
    121             "psMetadataItemCompare:     return true for comparison of U32 to S16." )
    122         ;
    123     }
    124 
    125     //Return true for comparing U8 with U16 of same value
    126     {
    127         psFree(template)
    128         ;
    129         template = psMetadataItemAlloc("Snickers", PS_DATA_U8, "No Comment", 1)
    130                    ;
    131         psFree(compare);
    132         compare = psMetadataItemAlloc("Snickers", PS_DATA_U16, "No Comment", 1);
    133         ok( psMetadataItemCompare(compare, template),
    134             "psMetadataItemCompare:     return true for comparison of U8 to U16." )
    135         ;
    136     }
    137     //Return true for comparing U16 with U8 of same value
    138     {
    139         ok( psMetadataItemCompare(template, compare),
    140             "psMetadataItemCompare:     return true for comparison of U16 to U8." )
    141         ;
    142     }
    143 
    144     //Return true for comparing U8 with S8 of same value
    145     {
    146         psFree(compare);
    147         compare = psMetadataItemAlloc("Snickers", PS_DATA_S8, "No Comment", 1);
    148         ok( psMetadataItemCompare(compare, template),
    149             "psMetadataItemCompare:     return true for comparison of U8 to S8." )
    150         ;
    151     }
    152     //Return true for comparing S8 with U8 of same value
    153     {
    154         ok( psMetadataItemCompare(template, compare),
    155             "psMetadataItemCompare:     return true for comparison of S8 to U8." )
    156         ;
    157     }
    158 
    159     //Return false for comparing U8 with S64 of same value
    160     {
    161         psFree(compare);
    162         compare = psMetadataItemAlloc("Snickers", PS_DATA_S64, "No Comment", 1);
    163         ok( !psMetadataItemCompare(compare, template),
    164             "psMetadataItemCompare:     return false for comparison of U8 to S64*.  "
    165             "*not yet implemented" )
    166         ;
    167     }
    168     //Return false for comparing S64 with U8 of same value
    169     {
    170         ok( !psMetadataItemCompare(template, compare),
    171             "psMetadataItemCompare:     return false for comparison of S64* to U8.  "
    172             "*not yet implemented" )
    173         ;
    174     }
    175 
    176     //Return false for comparing string of different value
    177     {
    178         psFree(compare);
    179         compare = psMetadataItemAlloc("Snickers", PS_DATA_STRING, "No Comment",
    180                                       "Not Going Anywhere?");
    181         psFree(template)
    182         ;
    183         template = psMetadataItemAlloc("Snickers", PS_DATA_STRING, "No Comment", "For a While?")
    184                    ;
    185         ok( !psMetadataItemCompare(compare, template),
    186             "psMetadataItemCompare:     return false for comparison of different psString's.")
    187         ;
    188     }
    189 
    190     //Return true for comparing string of same value
    191     {
    192         psFree(template)
    193         ;
    194         template = psMetadataItemAlloc("Snickers", PS_DATA_STRING, "No Comment",
    195                                        "Not Going Anywhere?")
    196                    ;
    197         ok( psMetadataItemCompare(compare, template),
    198             "psMetadataItemCompare:     return true for comparison of identical psString's.")
    199         ;
    200     }
    201 
    202     //Return false for comparing string with bool
    203     {
    204         psFree(template)
    205         ;
    206         template = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", false)
    207                    ;
    208         ok( !psMetadataItemCompare(compare, template),
    209             "psMetadataItemCompare:     return false for comparison of psString with bool.")
    210         ;
    211     }
    212     //Return false for comparing bool with string
    213     {
    214         psFree(template)
    215         ;
    216         template = psMetadataItemAlloc("Snickers", PS_DATA_BOOL, "No Comment", false)
    217                    ;
    218         ok( !psMetadataItemCompare(template, compare),
    219             "psMetadataItemCompare:     return false for comparison of psString with bool.")
    220         ;
    221     }
    222 
    223     //Check for Memory leaks
    224     {
    225         psFree(compare);
    226         psFree(template)
    227         ;
     193        psFree(template);
    228194        psFree(itemCopy);
    229195        psFree(item);
    230         checkMem();
     196        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    231197    }
    232198}
    233 
    234 

  • trunk/psLib/test/types/tap_psMetadataItemParse.c

    r12607 r12781  
    99 *
    1010 */
    11 
    1211#include <pslib.h>
    1312#include <string.h>
    14 
    1513#include "tap.h"
    1614#include "pstap.h"
    17 
    1815void testItemParse(void);
    1916
    2017int main (void)
    2118{
     19    psLogSetFormat("HLNM");
     20    psLogSetLevel(PS_LOG_INFO);
    2221    plan_tests(112);
    2322
    24     note("psMetadataItemParse() tests");
    25 
    26     testItemParse();
    27 
    28     done();
    29 }
    30 
    31 void testItemParse(void)
    32 {
    33     note("  >>>Test 1:  psMetadataItemParse");
    34 
    35     psMetadataItem *itemBool = psMetadataItemAlloc("bool", PS_DATA_BOOL, "No Comment", true);
    36     psMetadataItem *itemF32 = psMetadataItemAlloc("f32", PS_DATA_F32, "No Comment", 0.00);
    37     psMetadataItem *itemF64 = psMetadataItemAlloc("f64", PS_DATA_F64, "No Comment", 0.50);
    38     psMetadataItem *itemS8 = psMetadataItemAlloc("s8", PS_DATA_S8, "No Comment", 1);
    39     psMetadataItem *itemS16 = psMetadataItemAlloc("s16", PS_DATA_S16, "No Comment", 0);
    40     psMetadataItem *itemS32 = psMetadataItemAlloc("s32", PS_DATA_S32, "No Comment", 1);
    41     psMetadataItem *itemU8 = psMetadataItemAlloc("u8", PS_DATA_U8, "No Comment", 2);
    42     psMetadataItem *itemU16 = psMetadataItemAlloc("u16", PS_DATA_U16, "No Comment", 0);
    43     psMetadataItem *itemU32 = psMetadataItemAlloc("u32", PS_DATA_U32, "No Comment", 1);
    44     psMetadataItem *itemString1 = psMetadataItemAlloc("String", PS_DATA_STRING, "", "true");
    45     psMetadataItem *itemString2 = psMetadataItemAlloc("String", PS_DATA_STRING, "", "1.666");
    46     psMetadataItem *itemString11 = psMetadataItemAlloc("String", PS_DATA_STRING, "", "false");
    47     psMetadataItem *itemUnsupported = psMetadataItemAlloc("s64", PS_DATA_S64, "", 1);
    48 
    49     //TESTS:  Bool, F32, F64, S8, S16, S32, U8, U16, U32, String
    50     //BOOL Test
     23    // psMetadataItemParse() tests
    5124    {
    52         //Return false for NULL item
    53         ok ( !psMetadataItemParseBool(NULL),
    54              "psMetadataItemParse:      return false in BOOL for NULL psMetadataItem "
    55              "input." );
    56         //Return false for non-supported type S64
    57         ok ( !psMetadataItemParseBool(itemUnsupported),
    58              "psMetadataItemParse:      return false in BOOL for S64 (unsupported) "
    59              "psMetadataItem input." );
    60         //Return true for string with "true"
    61         ok ( psMetadataItemParseBool(itemString1),
    62              "psMetadataItemParse:      return true in BOOL for string-item with "
    63              "value 'true'." );
    64         //Return false for string with "false"
    65         ok ( !psMetadataItemParseBool(itemString11),
    66              "psMetadataItemParse:      return false in BOOL for string-item with "
    67              "value 'false'." );
    68         //Return false for F32 value 0.0
    69         ok ( !psMetadataItemParseBool(itemF32),
    70              "psMetadataItemParse:      return false in BOOL for F32-item with "
    71              "value '0.0'." );
    72         //Return true for F64 value 0.5
    73         ok ( psMetadataItemParseBool(itemF64),
    74              "psMetadataItemParse:      return true in BOOL for F64-item with "
    75              "value '0.5'." );
    76         //Return true for S8 value 1
    77         ok ( psMetadataItemParseBool(itemS8),
    78              "psMetadataItemParse:      return true in BOOL for S8-item with "
    79              "value '1'." );
    80         //Return false for S16 value 0
    81         ok ( !psMetadataItemParseBool(itemS16),
    82              "psMetadataItemParse:      return false in BOOL for S16-item with "
    83              "value '0'." );
    84         //Return true for S32 value 1
    85         ok ( psMetadataItemParseBool(itemS32),
    86              "psMetadataItemParse:      return true in BOOL for S32-item with "
    87              "value '1'." );
    88         //Return true for U8 value 2
    89         ok ( psMetadataItemParseBool(itemU8),
    90              "psMetadataItemParse:     return true in BOOL for U8-item with "
    91              "value '2'." );
    92         //Return false for U16 value 0
    93         ok ( !psMetadataItemParseBool(itemU16),
    94              "psMetadataItemParse:     return false in BOOL for U16-item with "
    95              "value '0'." );
    96         //Return true for U32 value 1
    97         ok ( psMetadataItemParseBool(itemU32),
    98              "psMetadataItemParse:     return true in BOOL for U32-item with "
    99              "value '1'." );
    100     }
    101 
    102     //F32 Test
    103     {
    104         //Return NaN for NULL item
    105         ok ( isnan(psMetadataItemParseF32(NULL)),
    106              "psMetadataItemParse:     return NaN for NULL psMetadataItem input." );
    107         //Return NaN for non-supported type S64
    108         ok ( isnan(psMetadataItemParseF32(itemUnsupported)),
    109              "psMetadataItemParse:     return NaN in F32 for S64 (unsupported) "
    110              "psMetadataItem input." );
    111         //Return 1.666 for string with "1.666"
    112         is_float( psMetadataItemParseF32(itemString2), 1.666,
    113                   "psMetadataItemParse:     return 1.666 in F32 for string-item with "
    114                   "value '1.666'." );
    115         //Return 0.0 for F32 value 0.0
    116         is_float( psMetadataItemParseF32(itemF32), 0.0,
    117                   "psMetadataItemParse:     return 0.0 in F32 for F32-item with "
    118                   "value '0.0'." );
    119         //Return 0.5 for F64 value 0.5
    120         is_float( psMetadataItemParseF32(itemF64), 0.5,
    121                   "psMetadataItemParse:     return 0.5 in F32 for F64-item with "
    122                   "value '0.5'." );
    123         //Return 1.0 for S8 value 1
    124         is_float( psMetadataItemParseF32(itemS8), 1.0,
    125                   "psMetadataItemParse:     return 1.0 in F32 for S8-item with "
    126                   "value '1'." );
    127         //Return 0.0 for S16 value 0
    128         is_float( psMetadataItemParseF32(itemS16), 0.0,
    129                   "psMetadataItemParse:     return 0.0 in F32 for S16-item with "
    130                   "value '0'." );
    131         //Return 1.0 for S32 value 1
    132         is_float( psMetadataItemParseF32(itemS32), 1.0,
    133                   "psMetadataItemParse:     return 1.0 in F32 for S32-item with "
    134                   "value '1'." );
    135         //Return 2.0 for U8 value 2
    136         is_float( psMetadataItemParseF32(itemU8), 2.0,
    137                   "psMetadataItemParse:     return 2.0 in F32 for U8-item with "
    138                   "value '2'." );
    139         //Return 0.0 for U16 value 0
    140         is_float( psMetadataItemParseF32(itemU16), 0.0,
    141                   "psMetadataItemParse:     return 0.0 in F32 for U16-item with "
    142                   "value '0'." );
    143         //Return 1.0 for U32 value 1
    144         is_float( psMetadataItemParseF32(itemU32), 1.0,
    145                   "psMetadataItemParse:     return 1.0 in F32 for U32-item with "
    146                   "value '1'." );
    147     }
    148 
    149     //F64 Test
    150     {
    151         //Return NaN for NULL item
    152         ok ( isnan(psMetadataItemParseF64(NULL)),
    153              "psMetadataItemParse:     return NaN for NULL psMetadataItem input." );
    154         //Return NaN for non-supported type S64
    155         ok ( isnan(psMetadataItemParseF64(itemUnsupported)),
    156              "psMetadataItemParse:     return NaN in F64 for S64 (unsupported) "
    157              "psMetadataItem input." );
    158         //Return 1.666 for string with "1.666"
    159         is_double_tol( psMetadataItemParseF64(itemString2), 1.666, 0.00001,
    160                        "psMetadataItemParse:     return 1.666 in F64 for string-item with "
    161                        "value '1.666'." );
    162         //Return 0.0 for F32 value 0.0
    163         is_double( psMetadataItemParseF64(itemF32), 0.0,
    164                    "psMetadataItemParse:     return 0.0 in F64 for F32-item with "
    165                    "value '0.0'." );
    166         //Return 0.5 for F64 value 0.5
    167         is_double( psMetadataItemParseF64(itemF64), 0.5,
    168                    "psMetadataItemParse:     return 0.5 in F64 for F64-item with "
    169                    "value '0.5'." );
    170         //Return 1.0 for S8 value 1
    171         is_double( psMetadataItemParseF64(itemS8), 1.0,
    172                    "psMetadataItemParse:     return 1.0 in F64 for S8-item with "
    173                    "value '1'." );
    174         //Return 0.0 for S16 value 0
    175         is_double( psMetadataItemParseF64(itemS16), 0.0,
    176                    "psMetadataItemParse:     return 0.0 in F64 for S16-item with "
    177                    "value '0'." );
    178         //Return 1.0 for S32 value 1
    179         is_double( psMetadataItemParseF64(itemS32), 1.0,
    180                    "psMetadataItemParse:     return 1.0 in F64 for S32-item with "
    181                    "value '1'." );
    182         //Return 2.0 for U8 value 2
    183         is_double( psMetadataItemParseF64(itemU8), 2.0,
    184                    "psMetadataItemParse:     return 2.0 in F64 for U8-item with "
    185                    "value '2'." );
    186         //Return 0.0 for U16 value 0
    187         is_double( psMetadataItemParseF64(itemU16), 0.0,
    188                    "psMetadataItemParse:     return 0.0 in F64 for U16-item with "
    189                    "value '0'." );
    190         //Return 1.0 for U32 value 1
    191         is_double( psMetadataItemParseF64(itemU32), 1.0,
    192                    "psMetadataItemParse:     return 1.0 in F64 for U32-item with "
    193                    "value '1'." );
    194     }
    195 
    196     //S8 Test
    197     {
    198         //Return 0 for NULL item
    199         ok ( psMetadataItemParseS8(NULL) == 0,
    200              "psMetadataItemParse:     return 0 for NULL psMetadataItem input." );
    201         //Return 0 for non-supported type S64
    202         ok ( psMetadataItemParseS8(itemUnsupported) == 0,
    203              "psMetadataItemParse:     return 0 in S8 for S64 (unsupported) "
    204              "psMetadataItem input." );
    205         //Return 2 for string with "1.666"
    206         ok ( psMetadataItemParseS8(itemString2) == 1,
    207              "psMetadataItemParse:     return 1 in S8 for string-item with "
    208              "value '1.666'." );
    209         //Return 0 for F32 value 0.0
    210         ok ( psMetadataItemParseS8(itemF32) == 0,
    211              "psMetadataItemParse:     return 0 in S8 for F32-item with "
    212              "value '0.0'." );
    213         //Return 1 for F64 value 0.5
    214         ok ( psMetadataItemParseS8(itemF64) == 0,
    215              "psMetadataItemParse:     return 0 in S8 for F64-item with "
    216              "value '0.5'." );
    217         //Return 1 for S8 value 1
    218         ok ( psMetadataItemParseS8(itemS8) == 1,
    219              "psMetadataItemParse:     return 1 in S8 for S8-item with "
    220              "value '1'." );
    221         //Return 0 for S16 value 0
    222         ok ( psMetadataItemParseS8(itemS16) == 0,
    223              "psMetadataItemParse:     return 0 in S8 for S16-item with "
    224              "value '0'." );
    225         //Return 1 for S32 value 1
    226         ok ( psMetadataItemParseS8(itemS32) == 1,
    227              "psMetadataItemParse:     return 1 in S8 for S32-item with "
    228              "value '1'." );
    229         //Return 2 for U8 value 2
    230         ok ( psMetadataItemParseS8(itemU8) == 2,
    231              "psMetadataItemParse:     return 2 in S8 for U8-item with "
    232              "value '2'." );
    233         //Return 0 for U16 value 0
    234         ok ( psMetadataItemParseS8(itemU16) == 0,
    235              "psMetadataItemParse:     return 0 in S8 for U16-item with "
    236              "value '0'." );
    237         //Return 1 for U32 value 1
    238         ok ( psMetadataItemParseS8(itemU32) == 1,
    239              "psMetadataItemParse:     return 1 in S8 for U32-item with "
    240              "value '1'." );
    241     }
    242 
    243     //S16 Test
    244     {
    245         //Return 0 for NULL item
    246         ok ( psMetadataItemParseS16(NULL) == 0,
    247              "psMetadataItemParse:     return 0 for NULL psMetadataItem input." );
    248         //Return 0 for non-supported type S64
    249         ok ( psMetadataItemParseS16(itemUnsupported) == 0,
    250              "psMetadataItemParse:     return 0 in S16 for S64 (unsupported) "
    251              "psMetadataItem input." );
    252         //Return 2 for string with "1.666"
    253         ok ( psMetadataItemParseS16(itemString2) == 1,
    254              "psMetadataItemParse:     return 1 in S16 for string-item with "
    255              "value '1.666'." );
    256         //Return 0 for F32 value 0.0
    257         ok ( psMetadataItemParseS16(itemF32) == 0,
    258              "psMetadataItemParse:     return 0 in S16 for F32-item with value '0.0'." );
    259         //Return 1 for F64 value 0.5
    260         ok ( psMetadataItemParseS16(itemF64) == 0,
    261              "psMetadataItemParse:     return 0 in S16 for F64-item with value '0.5'." );
    262         //Return 1 for S8 value 1
    263         ok ( psMetadataItemParseS16(itemS8) == 1,
    264              "psMetadataItemParse:     return 1 in S16 for S8-item with value '1'." );
    265         //Return 0 for S16 value 0
    266         ok ( psMetadataItemParseS16(itemS16) == 0,
    267              "psMetadataItemParse:     return 0 in S16 for S16-item with value '0'." );
    268         //Return 1 for S32 value 1
    269         ok ( psMetadataItemParseS16(itemS32) == 1,
    270              "psMetadataItemParse:     return 1 in S16 for S32-item with value '1'." );
    271         //Return 2 for U8 value 2
    272         ok ( psMetadataItemParseS16(itemU8) == 2,
    273              "psMetadataItemParse:     return 2 in S16 for U8-item with value '2'." );
    274         //Return 0 for U16 value 0
    275         ok ( psMetadataItemParseS16(itemU16) == 0,
    276              "psMetadataItemParse:     return 0 in S16 for U16-item with value '0'." );
    277         //Return 1 for U32 value 1
    278         ok ( psMetadataItemParseS16(itemU32) == 1,
    279              "psMetadataItemParse:     return 1 in S16 for U32-item with value '1'." );
    280     }
    281 
    282     //S32 Test
    283     {
    284         //Return 0 for NULL item
    285         ok ( psMetadataItemParseS32(NULL) == 0,
    286              "psMetadataItemParse:     return 0 for NULL psMetadataItem input." );
    287         //Return 0 for non-supported type S64
    288         ok ( psMetadataItemParseS32(itemUnsupported) == 0,
    289              "psMetadataItemParse:     return 0 in S32 for S64 (unsupported) "
    290              "psMetadataItem input." );
    291         //Return 2 for string with "1.666"
    292         ok ( psMetadataItemParseS32(itemString2) == 1,
    293              "psMetadataItemParse:     return 1 in S32 for string-item with "
    294              "value '1.666'." );
    295         //Return 0 for F32 value 0.0
    296         ok ( psMetadataItemParseS32(itemF32) == 0,
    297              "psMetadataItemParse:     return 0 in S32 for F32-item with value '0.0'." );
    298         //Return 1 for F64 value 0.5
    299         ok ( psMetadataItemParseS32(itemF64) == 0,
    300              "psMetadataItemParse:     return 0 in S32 for F64-item with value '0.5'." );
    301         //Return 1 for S8 value 1
    302         ok ( psMetadataItemParseS32(itemS8) == 1,
    303              "psMetadataItemParse:     return 1 in S32 for S8-item with value '1'." );
    304         //Return 0 for S16 value 0
    305         ok ( psMetadataItemParseS32(itemS16) == 0,
    306              "psMetadataItemParse:     return 0 in S32 for S16-item with value '0'." );
    307         //Return 1 for S32 value 1
    308         ok ( psMetadataItemParseS32(itemS32) == 1,
    309              "psMetadataItemParse:     return 1 in S32 for S32-item with value '1'." );
    310         //Return 2 for U8 value 2
    311         ok ( psMetadataItemParseS32(itemU8) == 2,
    312              "psMetadataItemParse:     return 2 in S32 for U8-item with value '2'." );
    313         //Return 0 for U16 value 0
    314         ok ( psMetadataItemParseS32(itemU16) == 0,
    315              "psMetadataItemParse:     return 0 in S32 for U16-item with value '0'." );
    316         //Return 1 for U32 value 1
    317         ok ( psMetadataItemParseS32(itemU32) == 1,
    318              "psMetadataItemParse:     return 1 in S32 for U32-item with value '1'." );
    319     }
    320 
    321     //U8 Test
    322     {
    323         //Return 0 for NULL item
    324         ok ( psMetadataItemParseU8(NULL) == 0,
    325              "psMetadataItemParse:     return 0 for NULL psMetadataItem input." );
    326         //Return 0 for non-supported type S64
    327         ok ( psMetadataItemParseU8(itemUnsupported) == 0,
    328              "psMetadataItemParse:     return 0 in U8 for S64 (unsupported) "
    329              "psMetadataItem input." );
    330         //Return 2 for string with "1.666"
    331         ok ( psMetadataItemParseU8(itemString2) == 1,
    332              "psMetadataItemParse:     return 1 in U8 for string-item with "
    333              "value '1.666'." );
    334         //Return 0 for F32 value 0.0
    335         ok ( psMetadataItemParseU8(itemF32) == 0,
    336              "psMetadataItemParse:     return 0 in U8 for F32-item with value '0.0'." );
    337         //Return 1 for F64 value 0.5
    338         ok ( psMetadataItemParseU8(itemF64) == 0,
    339              "psMetadataItemParse:     return 0 in U8 for F64-item with value '0.5'." );
    340         //Return 1 for S8 value 1
    341         ok ( psMetadataItemParseU8(itemS8) == 1,
    342              "psMetadataItemParse:     return 1 in U8 for S8-item with value '1'." );
    343         //Return 0 for S16 value 0
    344         ok ( psMetadataItemParseU8(itemS16) == 0,
    345              "psMetadataItemParse:     return 0 in U8 for S16-item with value '0'." );
    346         //Return 1 for S32 value 1
    347         ok ( psMetadataItemParseU8(itemS32) == 1,
    348              "psMetadataItemParse:     return 1 in U8 for S32-item with value '1'." );
    349         //Return 2 for U8 value 2
    350         ok ( psMetadataItemParseU8(itemU8) == 2,
    351              "psMetadataItemParse:     return 2 in U8 for U8-item with value '2'." );
    352         //Return 0 for U16 value 0
    353         ok ( psMetadataItemParseU8(itemU16) == 0,
    354              "psMetadataItemParse:     return 0 in U8 for U16-item with value '0'." );
    355         //Return 1 for U32 value 1
    356         ok ( psMetadataItemParseU8(itemU32) == 1,
    357              "psMetadataItemParse:     return 1 in U8 for U32-item with value '1'." );
    358     }
    359 
    360     //U16 Test
    361     {
    362         //Return 0 for NULL item
    363         ok ( psMetadataItemParseU16(NULL) == 0,
    364              "psMetadataItemParse:     return 0 for NULL psMetadataItem input." );
    365         //Return 0 for non-supported type S64
    366         ok ( psMetadataItemParseU16(itemUnsupported) == 0,
    367              "psMetadataItemParse:     return 0 in U16 for S64 (unsupported) "
    368              "psMetadataItem input." );
    369         //Return 2 for string with "1.666"
    370         ok ( psMetadataItemParseU16(itemString2) == 1,
    371              "psMetadataItemParse:     return 1 in U16 for string-item with "
    372              "value '1.666'." );
    373         //Return 0 for F32 value 0.0
    374         ok ( psMetadataItemParseU16(itemF32) == 0,
    375              "psMetadataItemParse:     return 0 in U16 for F32-item with value '0.0'." );
    376         //Return 1 for F64 value 0.5
    377         ok ( psMetadataItemParseU16(itemF64) == 0,
    378              "psMetadataItemParse:     return 0 in U16 for F64-item with value '0.5'." );
    379         //Return 1 for S8 value 1
    380         ok ( psMetadataItemParseU16(itemS8) == 1,
    381              "psMetadataItemParse:     return 1 in U16 for S8-item with value '1'." );
    382         //Return 0 for S16 value 0
    383         ok ( psMetadataItemParseU16(itemS16) == 0,
    384              "psMetadataItemParse:     return 0 in S8 for S16-item with value '0'." );
    385         //Return 1 for S32 value 1
    386         ok ( psMetadataItemParseU16(itemS32) == 1,
    387              "psMetadataItemParse:     return 1 in U16 for S32-item with value '1'." );
    388         //Return 2 for U8 value 2
    389         ok ( psMetadataItemParseU16(itemU8) == 2,
    390              "psMetadataItemParse:     return 2 in U16 for U8-item with value '2'." );
    391         //Return 0 for U16 value 0
    392         ok ( psMetadataItemParseU16(itemU16) == 0,
    393              "psMetadataItemParse:     return 0 in U16 for U16-item with value '0'." );
    394         //Return 1 for U32 value 1
    395         ok ( psMetadataItemParseU16(itemU32) == 1,
    396              "psMetadataItemParse:     return 1 in U16 for U32-item with value '1'." );
    397     }
    398 
    399     //U32 Test
    400     {
    401         //Return 0 for NULL item
    402         ok ( psMetadataItemParseU32(NULL) == 0,
    403              "psMetadataItemParse:     return 0 for NULL psMetadataItem input." );
    404         //Return 0 for non-supported type S64
    405         ok ( psMetadataItemParseU32(itemUnsupported) == 0,
    406              "psMetadataItemParse:     return 0 in U32 for S64 (unsupported) "
    407              "psMetadataItem input." );
    408         //Return 2 for string with "1.666"
    409         ok ( psMetadataItemParseU32(itemString2) == 1,
    410              "psMetadataItemParse:     return 1 in U32 for string-item with "
    411              "value '1.666'." );
    412         //Return 0 for F32 value 0.0
    413         ok ( psMetadataItemParseU32(itemF32) == 0,
    414              "psMetadataItemParse:     return 0 in U32 for F32-item with value '0.0'." );
    415         //Return 1 for F64 value 0.5
    416         ok ( psMetadataItemParseU32(itemF64) == 0,
    417              "psMetadataItemParse:     return 0 in U32 for F64-item with value '0.5'." );
    418         //Return 1 for S8 value 1
    419         ok ( psMetadataItemParseU32(itemS8) == 1,
    420              "psMetadataItemParse:     return 1 in U32 for S8-item with value '1'." );
    421         //Return 0 for S16 value 0
    422         ok ( psMetadataItemParseU32(itemS16) == 0,
    423              "psMetadataItemParse:     return 0 in U32 for S16-item with value '0'." );
    424         //Return 1 for S32 value 1
    425         ok ( psMetadataItemParseU32(itemS32) == 1,
    426              "psMetadataItemParse:     return 1 in U32 for S32-item with value '1'." );
    427         //Return 2 for U8 value 2
    428         ok ( psMetadataItemParseU32(itemU8) == 2,
    429              "psMetadataItemParse:     return 2 in U32 for U8-item with value '2'." );
    430         //Return 0 for U16 value 0
    431         ok ( psMetadataItemParseU32(itemU16) == 0,
    432              "psMetadataItemParse:     return 0 in U32 for U16-item with value '0'." );
    433         //Return 1 for U32 value 1
    434         ok ( psMetadataItemParseU32(itemU32) == 1,
    435              "psMetadataItemParse:    return 1 in U32 for U32-item with value '1'." );
    436     }
    437 
    438     //STRING Test
    439     {
    440         //Return NULL for NULL item
    441         ok ( psMetadataItemParseString(NULL) == NULL,
    442              "psMetadataItemParse:    return NULL for NULL STRING psMetadataItem "
    443              "input." );
    444         //Return NULL for non-supported type S64
    445         ok ( psMetadataItemParseString(itemUnsupported) == NULL,
    446              "psMetadataItemParse:    return NULL in STRING for S64 (unsupported)"
    447              " psMetadataItem input." );
    448         //Return "true" for STRING of value "true"
    449         psString tempString = psMetadataItemParseString(itemString1);
    450         is_strn( tempString, "true", 6,
    451                  "psMetadataItemParse:    return 'true' in STRING for STRING with "
     25        psMemId id = psMemGetId();
     26        psMetadataItem *itemBool = psMetadataItemAlloc("bool", PS_DATA_BOOL, "No Comment", true);
     27        psMetadataItem *itemF32 = psMetadataItemAlloc("f32", PS_DATA_F32, "No Comment", 0.00);
     28        psMetadataItem *itemF64 = psMetadataItemAlloc("f64", PS_DATA_F64, "No Comment", 0.50);
     29        psMetadataItem *itemS8 = psMetadataItemAlloc("s8", PS_DATA_S8, "No Comment", 1);
     30        psMetadataItem *itemS16 = psMetadataItemAlloc("s16", PS_DATA_S16, "No Comment", 0);
     31        psMetadataItem *itemS32 = psMetadataItemAlloc("s32", PS_DATA_S32, "No Comment", 1);
     32        psMetadataItem *itemU8 = psMetadataItemAlloc("u8", PS_DATA_U8, "No Comment", 2);
     33        psMetadataItem *itemU16 = psMetadataItemAlloc("u16", PS_DATA_U16, "No Comment", 0);
     34        psMetadataItem *itemU32 = psMetadataItemAlloc("u32", PS_DATA_U32, "No Comment", 1);
     35        psMetadataItem *itemString1 = psMetadataItemAlloc("String", PS_DATA_STRING, "", "true");
     36        psMetadataItem *itemString2 = psMetadataItemAlloc("String", PS_DATA_STRING, "", "1.666");
     37        psMetadataItem *itemString11 = psMetadataItemAlloc("String", PS_DATA_STRING, "", "false");
     38        psMetadataItem *itemUnsupported = psMetadataItemAlloc("s64", PS_DATA_S64, "", 1);
     39
     40        //TESTS:  Bool, F32, F64, S8, S16, S32, U8, U16, U32, String
     41        //BOOL Test
     42        {
     43            //Return false for NULL item
     44            ok ( !psMetadataItemParseBool(NULL),
     45                 "psMetadataItemParse:      return false in BOOL for NULL psMetadataItem "
     46                 "input." );
     47            //Return false for non-supported type S64
     48            ok ( !psMetadataItemParseBool(itemUnsupported),
     49                 "psMetadataItemParse:      return false in BOOL for S64 (unsupported) "
     50                 "psMetadataItem input." );
     51            //Return true for string with "true"
     52            ok ( psMetadataItemParseBool(itemString1),
     53                 "psMetadataItemParse:      return true in BOOL for string-item with "
    45254                 "value 'true'." );
    453         psFree(tempString);
    454 
    455         //Return 0.000000 for F32 of value 0.000000
    456         tempString = psMetadataItemParseString(itemF32);
    457         is_strn( tempString, "0.000000", 4,
    458                  "psMetadataItemParse:    return '0.000000' in STRING for F32 with "
    459                  "value '0.000000'.   (actual result=%s)", tempString);
    460         psFree(tempString);
    461 
    462         //Return 0.500000 for F64 value 0.5
    463         tempString = psMetadataItemParseString(itemF64);
    464         is_strn( tempString, "0.500000", 10,
    465                  "psMetadataItemParse:    return '0.500000' in STRING for F64 with "
    466                  "value '0.5'.   (actual result=%s)", tempString);
    467         psFree(tempString);
    468 
    469         //Return 1 for S8 value 1
    470         tempString = psMetadataItemParseString(itemS8);
    471         is_strn( tempString, "1", 3,
    472                  "psMetadataItemParse:    return '1' in STRING for S8 with "
    473                  "value '1'.   (actual result=%s)", tempString);
    474         psFree(tempString);
    475 
    476         //Return 0 for S16 value 0
    477         tempString = psMetadataItemParseString(itemS16);
    478         is_strn( tempString, "0", 3,
    479                  "psMetadataItemParse:    return '0' in STRING for S8 with "
    480                  "value '0'.   (actual result=%s)", tempString);
    481         psFree(tempString);
    482 
    483         //Return 1 for S32 value 1
    484         tempString = psMetadataItemParseString(itemS32);
    485         is_strn( tempString, "1", 3,
    486                  "psMetadataItemParse:    return '1' in STRING for S8 with "
    487                  "value '1'.   (actual result=%s)", tempString);
    488         psFree(tempString);
    489 
    490         //Return 2 for U8 value 2
    491         tempString = psMetadataItemParseString(itemU8);
    492         is_strn( tempString, "2", 3,
    493                  "psMetadataItemParse:    return '2' in STRING for S8 with "
    494                  "value '2'.   (actual result=%s)", tempString);
    495         psFree(tempString);
    496 
    497         //Return 0 for U16 value 0
    498         tempString = psMetadataItemParseString(itemU16);
    499         is_strn( tempString, "0", 3,
    500                  "psMetadataItemParse:    return '0' in STRING for S8 with "
    501                  "value '0'.   (actual result=%s)", tempString);
    502         psFree(tempString);
    503 
    504         //Return 1 for U32 value 1
    505         tempString = psMetadataItemParseString(itemU32);
    506         is_strn( tempString, "1", 3,
    507                  "psMetadataItemParse:    return '1' in STRING for S8 with "
    508                  "value '1'.   (actual result=%s)", tempString);
    509         psFree(tempString);
    510     }
    511 
    512     //Check for Memory leaks
    513     {
     55            //Return false for string with "false"
     56            ok ( !psMetadataItemParseBool(itemString11),
     57                 "psMetadataItemParse:      return false in BOOL for string-item with "
     58                 "value 'false'." );
     59            //Return false for F32 value 0.0
     60            ok ( !psMetadataItemParseBool(itemF32),
     61                 "psMetadataItemParse:      return false in BOOL for F32-item with "
     62                 "value '0.0'." );
     63            //Return true for F64 value 0.5
     64            ok ( psMetadataItemParseBool(itemF64),
     65                 "psMetadataItemParse:      return true in BOOL for F64-item with "
     66                 "value '0.5'." );
     67            //Return true for S8 value 1
     68            ok ( psMetadataItemParseBool(itemS8),
     69                 "psMetadataItemParse:      return true in BOOL for S8-item with "
     70                 "value '1'." );
     71            //Return false for S16 value 0
     72            ok ( !psMetadataItemParseBool(itemS16),
     73                 "psMetadataItemParse:      return false in BOOL for S16-item with "
     74                 "value '0'." );
     75            //Return true for S32 value 1
     76            ok ( psMetadataItemParseBool(itemS32),
     77                 "psMetadataItemParse:      return true in BOOL for S32-item with "
     78                 "value '1'." );
     79            //Return true for U8 value 2
     80            ok ( psMetadataItemParseBool(itemU8),
     81                 "psMetadataItemParse:     return true in BOOL for U8-item with "
     82                 "value '2'." );
     83            //Return false for U16 value 0
     84            ok ( !psMetadataItemParseBool(itemU16),
     85                 "psMetadataItemParse:     return false in BOOL for U16-item with "
     86                 "value '0'." );
     87            //Return true for U32 value 1
     88            ok ( psMetadataItemParseBool(itemU32),
     89                 "psMetadataItemParse:     return true in BOOL for U32-item with "
     90                 "value '1'." );
     91        }
     92
     93        //F32 Test
     94        {
     95            //Return NaN for NULL item
     96            ok ( isnan(psMetadataItemParseF32(NULL)),
     97                 "psMetadataItemParse:     return NaN for NULL psMetadataItem input." );
     98            //Return NaN for non-supported type S64
     99            ok ( isnan(psMetadataItemParseF32(itemUnsupported)),
     100                 "psMetadataItemParse:     return NaN in F32 for S64 (unsupported) "
     101                 "psMetadataItem input." );
     102            //Return 1.666 for string with "1.666"
     103            is_float( psMetadataItemParseF32(itemString2), 1.666,
     104                      "psMetadataItemParse:     return 1.666 in F32 for string-item with "
     105                      "value '1.666'." );
     106            //Return 0.0 for F32 value 0.0
     107            is_float( psMetadataItemParseF32(itemF32), 0.0,
     108                      "psMetadataItemParse:     return 0.0 in F32 for F32-item with "
     109                      "value '0.0'." );
     110            //Return 0.5 for F64 value 0.5
     111            is_float( psMetadataItemParseF32(itemF64), 0.5,
     112                      "psMetadataItemParse:     return 0.5 in F32 for F64-item with "
     113                      "value '0.5'." );
     114            //Return 1.0 for S8 value 1
     115            is_float( psMetadataItemParseF32(itemS8), 1.0,
     116                      "psMetadataItemParse:     return 1.0 in F32 for S8-item with "
     117                      "value '1'." );
     118            //Return 0.0 for S16 value 0
     119            is_float( psMetadataItemParseF32(itemS16), 0.0,
     120                      "psMetadataItemParse:     return 0.0 in F32 for S16-item with "
     121                      "value '0'." );
     122            //Return 1.0 for S32 value 1
     123            is_float( psMetadataItemParseF32(itemS32), 1.0,
     124                      "psMetadataItemParse:     return 1.0 in F32 for S32-item with "
     125                      "value '1'." );
     126            //Return 2.0 for U8 value 2
     127            is_float( psMetadataItemParseF32(itemU8), 2.0,
     128                      "psMetadataItemParse:     return 2.0 in F32 for U8-item with "
     129                      "value '2'." );
     130            //Return 0.0 for U16 value 0
     131            is_float( psMetadataItemParseF32(itemU16), 0.0,
     132                      "psMetadataItemParse:     return 0.0 in F32 for U16-item with "
     133                      "value '0'." );
     134            //Return 1.0 for U32 value 1
     135            is_float( psMetadataItemParseF32(itemU32), 1.0,
     136                      "psMetadataItemParse:     return 1.0 in F32 for U32-item with "
     137                      "value '1'." );
     138        }
     139
     140        //F64 Test
     141        {
     142            //Return NaN for NULL item
     143            ok ( isnan(psMetadataItemParseF64(NULL)),
     144                 "psMetadataItemParse:     return NaN for NULL psMetadataItem input." );
     145            //Return NaN for non-supported type S64
     146            ok ( isnan(psMetadataItemParseF64(itemUnsupported)),
     147                 "psMetadataItemParse:     return NaN in F64 for S64 (unsupported) "
     148                 "psMetadataItem input." );
     149            //Return 1.666 for string with "1.666"
     150            is_double_tol( psMetadataItemParseF64(itemString2), 1.666, 0.00001,
     151                           "psMetadataItemParse:     return 1.666 in F64 for string-item with "
     152                           "value '1.666'." );
     153            //Return 0.0 for F32 value 0.0
     154            is_double( psMetadataItemParseF64(itemF32), 0.0,
     155                       "psMetadataItemParse:     return 0.0 in F64 for F32-item with "
     156                       "value '0.0'." );
     157            //Return 0.5 for F64 value 0.5
     158            is_double( psMetadataItemParseF64(itemF64), 0.5,
     159                       "psMetadataItemParse:     return 0.5 in F64 for F64-item with "
     160                       "value '0.5'." );
     161            //Return 1.0 for S8 value 1
     162            is_double( psMetadataItemParseF64(itemS8), 1.0,
     163                       "psMetadataItemParse:     return 1.0 in F64 for S8-item with "
     164                       "value '1'." );
     165            //Return 0.0 for S16 value 0
     166            is_double( psMetadataItemParseF64(itemS16), 0.0,
     167                       "psMetadataItemParse:     return 0.0 in F64 for S16-item with "
     168                       "value '0'." );
     169            //Return 1.0 for S32 value 1
     170            is_double( psMetadataItemParseF64(itemS32), 1.0,
     171                       "psMetadataItemParse:     return 1.0 in F64 for S32-item with "
     172                       "value '1'." );
     173            //Return 2.0 for U8 value 2
     174            is_double( psMetadataItemParseF64(itemU8), 2.0,
     175                       "psMetadataItemParse:     return 2.0 in F64 for U8-item with "
     176                       "value '2'." );
     177            //Return 0.0 for U16 value 0
     178            is_double( psMetadataItemParseF64(itemU16), 0.0,
     179                       "psMetadataItemParse:     return 0.0 in F64 for U16-item with "
     180                       "value '0'." );
     181            //Return 1.0 for U32 value 1
     182            is_double( psMetadataItemParseF64(itemU32), 1.0,
     183                       "psMetadataItemParse:     return 1.0 in F64 for U32-item with "
     184                       "value '1'." );
     185        }
     186
     187        //S8 Test
     188        {
     189            //Return 0 for NULL item
     190            ok ( psMetadataItemParseS8(NULL) == 0,
     191                 "psMetadataItemParse:     return 0 for NULL psMetadataItem input." );
     192            //Return 0 for non-supported type S64
     193            ok ( psMetadataItemParseS8(itemUnsupported) == 0,
     194                 "psMetadataItemParse:     return 0 in S8 for S64 (unsupported) "
     195                 "psMetadataItem input." );
     196            //Return 2 for string with "1.666"
     197            ok ( psMetadataItemParseS8(itemString2) == 1,
     198                 "psMetadataItemParse:     return 1 in S8 for string-item with "
     199                 "value '1.666'." );
     200            //Return 0 for F32 value 0.0
     201            ok ( psMetadataItemParseS8(itemF32) == 0,
     202                 "psMetadataItemParse:     return 0 in S8 for F32-item with "
     203                 "value '0.0'." );
     204            //Return 1 for F64 value 0.5
     205            ok ( psMetadataItemParseS8(itemF64) == 0,
     206                 "psMetadataItemParse:     return 0 in S8 for F64-item with "
     207                 "value '0.5'." );
     208            //Return 1 for S8 value 1
     209            ok ( psMetadataItemParseS8(itemS8) == 1,
     210                 "psMetadataItemParse:     return 1 in S8 for S8-item with "
     211                 "value '1'." );
     212            //Return 0 for S16 value 0
     213            ok ( psMetadataItemParseS8(itemS16) == 0,
     214                 "psMetadataItemParse:     return 0 in S8 for S16-item with "
     215                 "value '0'." );
     216            //Return 1 for S32 value 1
     217            ok ( psMetadataItemParseS8(itemS32) == 1,
     218                 "psMetadataItemParse:     return 1 in S8 for S32-item with "
     219                 "value '1'." );
     220            //Return 2 for U8 value 2
     221            ok ( psMetadataItemParseS8(itemU8) == 2,
     222                 "psMetadataItemParse:     return 2 in S8 for U8-item with "
     223                 "value '2'." );
     224            //Return 0 for U16 value 0
     225            ok ( psMetadataItemParseS8(itemU16) == 0,
     226                 "psMetadataItemParse:     return 0 in S8 for U16-item with "
     227                 "value '0'." );
     228            //Return 1 for U32 value 1
     229            ok ( psMetadataItemParseS8(itemU32) == 1,
     230                 "psMetadataItemParse:     return 1 in S8 for U32-item with "
     231                 "value '1'." );
     232        }
     233
     234        //S16 Test
     235        {
     236            //Return 0 for NULL item
     237            ok ( psMetadataItemParseS16(NULL) == 0,
     238                 "psMetadataItemParse:     return 0 for NULL psMetadataItem input." );
     239            //Return 0 for non-supported type S64
     240            ok ( psMetadataItemParseS16(itemUnsupported) == 0,
     241                 "psMetadataItemParse:     return 0 in S16 for S64 (unsupported) "
     242                 "psMetadataItem input." );
     243            //Return 2 for string with "1.666"
     244            ok ( psMetadataItemParseS16(itemString2) == 1,
     245                 "psMetadataItemParse:     return 1 in S16 for string-item with "
     246                 "value '1.666'." );
     247            //Return 0 for F32 value 0.0
     248            ok ( psMetadataItemParseS16(itemF32) == 0,
     249                 "psMetadataItemParse:     return 0 in S16 for F32-item with value '0.0'." );
     250            //Return 1 for F64 value 0.5
     251            ok ( psMetadataItemParseS16(itemF64) == 0,
     252                 "psMetadataItemParse:     return 0 in S16 for F64-item with value '0.5'." );
     253            //Return 1 for S8 value 1
     254            ok ( psMetadataItemParseS16(itemS8) == 1,
     255                 "psMetadataItemParse:     return 1 in S16 for S8-item with value '1'." );
     256            //Return 0 for S16 value 0
     257            ok ( psMetadataItemParseS16(itemS16) == 0,
     258                 "psMetadataItemParse:     return 0 in S16 for S16-item with value '0'." );
     259            //Return 1 for S32 value 1
     260            ok ( psMetadataItemParseS16(itemS32) == 1,
     261                 "psMetadataItemParse:     return 1 in S16 for S32-item with value '1'." );
     262            //Return 2 for U8 value 2
     263            ok ( psMetadataItemParseS16(itemU8) == 2,
     264                 "psMetadataItemParse:     return 2 in S16 for U8-item with value '2'." );
     265            //Return 0 for U16 value 0
     266            ok ( psMetadataItemParseS16(itemU16) == 0,
     267                 "psMetadataItemParse:     return 0 in S16 for U16-item with value '0'." );
     268            //Return 1 for U32 value 1
     269            ok ( psMetadataItemParseS16(itemU32) == 1,
     270                 "psMetadataItemParse:     return 1 in S16 for U32-item with value '1'." );
     271        }
     272
     273        //S32 Test
     274        {
     275            //Return 0 for NULL item
     276            ok ( psMetadataItemParseS32(NULL) == 0,
     277                 "psMetadataItemParse:     return 0 for NULL psMetadataItem input." );
     278            //Return 0 for non-supported type S64
     279            ok ( psMetadataItemParseS32(itemUnsupported) == 0,
     280                 "psMetadataItemParse:     return 0 in S32 for S64 (unsupported) "
     281                 "psMetadataItem input." );
     282            //Return 2 for string with "1.666"
     283            ok ( psMetadataItemParseS32(itemString2) == 1,
     284                 "psMetadataItemParse:     return 1 in S32 for string-item with "
     285                 "value '1.666'." );
     286            //Return 0 for F32 value 0.0
     287            ok ( psMetadataItemParseS32(itemF32) == 0,
     288                 "psMetadataItemParse:     return 0 in S32 for F32-item with value '0.0'." );
     289            //Return 1 for F64 value 0.5
     290            ok ( psMetadataItemParseS32(itemF64) == 0,
     291                 "psMetadataItemParse:     return 0 in S32 for F64-item with value '0.5'." );
     292            //Return 1 for S8 value 1
     293            ok ( psMetadataItemParseS32(itemS8) == 1,
     294                 "psMetadataItemParse:     return 1 in S32 for S8-item with value '1'." );
     295            //Return 0 for S16 value 0
     296            ok ( psMetadataItemParseS32(itemS16) == 0,
     297                 "psMetadataItemParse:     return 0 in S32 for S16-item with value '0'." );
     298            //Return 1 for S32 value 1
     299            ok ( psMetadataItemParseS32(itemS32) == 1,
     300                 "psMetadataItemParse:     return 1 in S32 for S32-item with value '1'." );
     301            //Return 2 for U8 value 2
     302            ok ( psMetadataItemParseS32(itemU8) == 2,
     303                 "psMetadataItemParse:     return 2 in S32 for U8-item with value '2'." );
     304            //Return 0 for U16 value 0
     305            ok ( psMetadataItemParseS32(itemU16) == 0,
     306                 "psMetadataItemParse:     return 0 in S32 for U16-item with value '0'." );
     307            //Return 1 for U32 value 1
     308            ok ( psMetadataItemParseS32(itemU32) == 1,
     309                 "psMetadataItemParse:     return 1 in S32 for U32-item with value '1'." );
     310        }
     311
     312        //U8 Test
     313        {
     314            //Return 0 for NULL item
     315            ok ( psMetadataItemParseU8(NULL) == 0,
     316                 "psMetadataItemParse:     return 0 for NULL psMetadataItem input." );
     317            //Return 0 for non-supported type S64
     318            ok ( psMetadataItemParseU8(itemUnsupported) == 0,
     319                 "psMetadataItemParse:     return 0 in U8 for S64 (unsupported) "
     320                 "psMetadataItem input." );
     321            //Return 2 for string with "1.666"
     322            ok ( psMetadataItemParseU8(itemString2) == 1,
     323                 "psMetadataItemParse:     return 1 in U8 for string-item with "
     324                 "value '1.666'." );
     325            //Return 0 for F32 value 0.0
     326            ok ( psMetadataItemParseU8(itemF32) == 0,
     327                 "psMetadataItemParse:     return 0 in U8 for F32-item with value '0.0'." );
     328            //Return 1 for F64 value 0.5
     329            ok ( psMetadataItemParseU8(itemF64) == 0,
     330                 "psMetadataItemParse:     return 0 in U8 for F64-item with value '0.5'." );
     331            //Return 1 for S8 value 1
     332            ok ( psMetadataItemParseU8(itemS8) == 1,
     333                 "psMetadataItemParse:     return 1 in U8 for S8-item with value '1'." );
     334            //Return 0 for S16 value 0
     335            ok ( psMetadataItemParseU8(itemS16) == 0,
     336                 "psMetadataItemParse:     return 0 in U8 for S16-item with value '0'." );
     337            //Return 1 for S32 value 1
     338            ok ( psMetadataItemParseU8(itemS32) == 1,
     339                 "psMetadataItemParse:     return 1 in U8 for S32-item with value '1'." );
     340            //Return 2 for U8 value 2
     341            ok ( psMetadataItemParseU8(itemU8) == 2,
     342                 "psMetadataItemParse:     return 2 in U8 for U8-item with value '2'." );
     343            //Return 0 for U16 value 0
     344            ok ( psMetadataItemParseU8(itemU16) == 0,
     345                 "psMetadataItemParse:     return 0 in U8 for U16-item with value '0'." );
     346            //Return 1 for U32 value 1
     347            ok ( psMetadataItemParseU8(itemU32) == 1,
     348                 "psMetadataItemParse:     return 1 in U8 for U32-item with value '1'." );
     349        }
     350
     351        //U16 Test
     352        {
     353            //Return 0 for NULL item
     354            ok ( psMetadataItemParseU16(NULL) == 0,
     355                 "psMetadataItemParse:     return 0 for NULL psMetadataItem input." );
     356            //Return 0 for non-supported type S64
     357            ok ( psMetadataItemParseU16(itemUnsupported) == 0,
     358                 "psMetadataItemParse:     return 0 in U16 for S64 (unsupported) "
     359                 "psMetadataItem input." );
     360            //Return 2 for string with "1.666"
     361            ok ( psMetadataItemParseU16(itemString2) == 1,
     362                 "psMetadataItemParse:     return 1 in U16 for string-item with "
     363                 "value '1.666'." );
     364            //Return 0 for F32 value 0.0
     365            ok ( psMetadataItemParseU16(itemF32) == 0,
     366                 "psMetadataItemParse:     return 0 in U16 for F32-item with value '0.0'." );
     367            //Return 1 for F64 value 0.5
     368            ok ( psMetadataItemParseU16(itemF64) == 0,
     369                 "psMetadataItemParse:     return 0 in U16 for F64-item with value '0.5'." );
     370            //Return 1 for S8 value 1
     371            ok ( psMetadataItemParseU16(itemS8) == 1,
     372                 "psMetadataItemParse:     return 1 in U16 for S8-item with value '1'." );
     373            //Return 0 for S16 value 0
     374            ok ( psMetadataItemParseU16(itemS16) == 0,
     375                 "psMetadataItemParse:     return 0 in S8 for S16-item with value '0'." );
     376            //Return 1 for S32 value 1
     377            ok ( psMetadataItemParseU16(itemS32) == 1,
     378                 "psMetadataItemParse:     return 1 in U16 for S32-item with value '1'." );
     379            //Return 2 for U8 value 2
     380            ok ( psMetadataItemParseU16(itemU8) == 2,
     381                 "psMetadataItemParse:     return 2 in U16 for U8-item with value '2'." );
     382            //Return 0 for U16 value 0
     383            ok ( psMetadataItemParseU16(itemU16) == 0,
     384                 "psMetadataItemParse:     return 0 in U16 for U16-item with value '0'." );
     385            //Return 1 for U32 value 1
     386            ok ( psMetadataItemParseU16(itemU32) == 1,
     387                 "psMetadataItemParse:     return 1 in U16 for U32-item with value '1'." );
     388        }
     389
     390        //U32 Test
     391        {
     392            //Return 0 for NULL item
     393            ok ( psMetadataItemParseU32(NULL) == 0,
     394                 "psMetadataItemParse:     return 0 for NULL psMetadataItem input." );
     395            //Return 0 for non-supported type S64
     396            ok ( psMetadataItemParseU32(itemUnsupported) == 0,
     397                 "psMetadataItemParse:     return 0 in U32 for S64 (unsupported) "
     398                 "psMetadataItem input." );
     399            //Return 2 for string with "1.666"
     400            ok ( psMetadataItemParseU32(itemString2) == 1,
     401                 "psMetadataItemParse:     return 1 in U32 for string-item with "
     402                 "value '1.666'." );
     403            //Return 0 for F32 value 0.0
     404            ok ( psMetadataItemParseU32(itemF32) == 0,
     405                 "psMetadataItemParse:     return 0 in U32 for F32-item with value '0.0'." );
     406            //Return 1 for F64 value 0.5
     407            ok ( psMetadataItemParseU32(itemF64) == 0,
     408                 "psMetadataItemParse:     return 0 in U32 for F64-item with value '0.5'." );
     409            //Return 1 for S8 value 1
     410            ok ( psMetadataItemParseU32(itemS8) == 1,
     411                 "psMetadataItemParse:     return 1 in U32 for S8-item with value '1'." );
     412            //Return 0 for S16 value 0
     413            ok ( psMetadataItemParseU32(itemS16) == 0,
     414                 "psMetadataItemParse:     return 0 in U32 for S16-item with value '0'." );
     415            //Return 1 for S32 value 1
     416            ok ( psMetadataItemParseU32(itemS32) == 1,
     417                 "psMetadataItemParse:     return 1 in U32 for S32-item with value '1'." );
     418            //Return 2 for U8 value 2
     419            ok ( psMetadataItemParseU32(itemU8) == 2,
     420                 "psMetadataItemParse:     return 2 in U32 for U8-item with value '2'." );
     421            //Return 0 for U16 value 0
     422            ok ( psMetadataItemParseU32(itemU16) == 0,
     423                 "psMetadataItemParse:     return 0 in U32 for U16-item with value '0'." );
     424            //Return 1 for U32 value 1
     425            ok ( psMetadataItemParseU32(itemU32) == 1,
     426                 "psMetadataItemParse:    return 1 in U32 for U32-item with value '1'." );
     427        }
     428
     429        //STRING Test
     430        {
     431            //Return NULL for NULL item
     432            ok ( psMetadataItemParseString(NULL) == NULL,
     433                 "psMetadataItemParse:    return NULL for NULL STRING psMetadataItem "
     434                 "input." );
     435            //Return NULL for non-supported type S64
     436            ok ( psMetadataItemParseString(itemUnsupported) == NULL,
     437                 "psMetadataItemParse:    return NULL in STRING for S64 (unsupported)"
     438                 " psMetadataItem input." );
     439            //Return "true" for STRING of value "true"
     440            psString tempString = psMetadataItemParseString(itemString1);
     441            is_strn( tempString, "true", 6,
     442                     "psMetadataItemParse:    return 'true' in STRING for STRING with "
     443                     "value 'true'." );
     444            psFree(tempString);
     445   
     446            //Return 0.000000 for F32 of value 0.000000
     447            tempString = psMetadataItemParseString(itemF32);
     448            is_strn( tempString, "0.000000", 4,
     449                     "psMetadataItemParse:    return '0.000000' in STRING for F32 with "
     450                     "value '0.000000'.   (actual result=%s)", tempString);
     451            psFree(tempString);
     452   
     453            //Return 0.500000 for F64 value 0.5
     454            tempString = psMetadataItemParseString(itemF64);
     455            is_strn( tempString, "0.500000", 10,
     456                     "psMetadataItemParse:    return '0.500000' in STRING for F64 with "
     457                     "value '0.5'.   (actual result=%s)", tempString);
     458            psFree(tempString);
     459   
     460            //Return 1 for S8 value 1
     461            tempString = psMetadataItemParseString(itemS8);
     462            is_strn( tempString, "1", 3,
     463                     "psMetadataItemParse:    return '1' in STRING for S8 with "
     464                     "value '1'.   (actual result=%s)", tempString);
     465            psFree(tempString);
     466   
     467            //Return 0 for S16 value 0
     468            tempString = psMetadataItemParseString(itemS16);
     469            is_strn( tempString, "0", 3,
     470                     "psMetadataItemParse:    return '0' in STRING for S8 with "
     471                     "value '0'.   (actual result=%s)", tempString);
     472            psFree(tempString);
     473   
     474            //Return 1 for S32 value 1
     475            tempString = psMetadataItemParseString(itemS32);
     476            is_strn( tempString, "1", 3,
     477                     "psMetadataItemParse:    return '1' in STRING for S8 with "
     478                     "value '1'.   (actual result=%s)", tempString);
     479            psFree(tempString);
     480   
     481            //Return 2 for U8 value 2
     482            tempString = psMetadataItemParseString(itemU8);
     483            is_strn( tempString, "2", 3,
     484                     "psMetadataItemParse:    return '2' in STRING for S8 with "
     485                     "value '2'.   (actual result=%s)", tempString);
     486            psFree(tempString);
     487   
     488            //Return 0 for U16 value 0
     489            tempString = psMetadataItemParseString(itemU16);
     490            is_strn( tempString, "0", 3,
     491                     "psMetadataItemParse:    return '0' in STRING for S8 with "
     492                     "value '0'.   (actual result=%s)", tempString);
     493            psFree(tempString);
     494   
     495            //Return 1 for U32 value 1
     496            tempString = psMetadataItemParseString(itemU32);
     497            is_strn( tempString, "1", 3,
     498                     "psMetadataItemParse:    return '1' in STRING for S8 with "
     499                     "value '1'.   (actual result=%s)", tempString);
     500            psFree(tempString);
     501        }
     502
    514503        psFree(itemBool);
    515504        psFree(itemF32);
    … …  
    525514        psFree(itemString11);
    526515        psFree(itemUnsupported);
    527         checkMem();
     516        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    528517    }
    529518}

  • trunk/psLib/test/types/tap_psMetadataIterator.c

    r10822 r12781  
    22#include <pslib.h>
    33#include <string.h>
    4 
    54#include "tap.h"
    65#include "pstap.h"
    7 
    86
    97#define NAME1 "SIMPLE"
    … …  
    102100int main (void)
    103101{
    104     plan_tests(242);
    105 
    106     note("psMetadataIterator tests");
    107 
    108     {
    109         note("No regular expressions, forwards");
     102    psLogSetFormat("HLNM");
     103    psLogSetLevel(PS_LOG_INFO);
     104    plan_tests(254);
     105
     106    // psMetadataIterator tests
     107    // No regular expressions, forwards
     108    {
     109        psMemId id = psMemGetId();
    110110        psMetadata *md = mdGenerate();
    111111        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
    … …  
    124124        psFree(iter);
    125125        psFree(md);
    126     }
    127 
    128     {
    129         note("No regular expressions, backwards");
     126        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     127    }
     128
     129
     130    // No regular expressions, backwards
     131    {
     132        psMemId id = psMemGetId();
    130133        psMetadata *md = mdGenerate();
    131134        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_TAIL, NULL);
    … …  
    144147        psFree(iter);
    145148        psFree(md);
    146     }
    147 
    148     {
    149         note("No regular expressions, jumping in halfway through (using allocator), forwards");
     149        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     150    }
     151
     152
     153    // No regular expressions, jumping in halfway through (using allocator), forwards
     154    {
     155        psMemId id = psMemGetId();
    150156        psMetadata *md = mdGenerate();
    151157        psMetadataIterator *iter = psMetadataIteratorAlloc(md, 3, NULL);
    … …  
    161167        psFree(iter);
    162168        psFree(md);
    163     }
    164 
    165     {
    166         note("No regular expressions, jumping in halfway through (using allocator), backwards");
     169        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     170    }
     171
     172
     173    //  No regular expressions, jumping in halfway through (using allocator), backwards
     174    {
     175        psMemId id = psMemGetId();
    167176        psMetadata *md = mdGenerate();
    168177        psMetadataIterator *iter = psMetadataIteratorAlloc(md, -4, NULL);
    … …  
    178187        psFree(iter);
    179188        psFree(md);
    180     }
    181 
    182     {
    183         note("No regular expressions, jumping in halfway through (using set), forwards");
     189        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     190    }
     191
     192
     193    // No regular expressions, jumping in halfway through (using set), forwards");
     194    {
     195        psMemId id = psMemGetId();
    184196        psMetadata *md = mdGenerate();
    185197        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
    … …  
    196208        psFree(iter);
    197209        psFree(md);
    198     }
    199 
    200     {
    201         note("No regular expressions, jumping in halfway through (using set), backwards");
     210        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     211    }
     212
     213
     214    // No regular expressions, jumping in halfway through (using set), backwards");
     215    {
     216        psMemId id = psMemGetId();
    202217        psMetadata *md = mdGenerate();
    203218        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
    … …  
    214229        psFree(iter);
    215230        psFree(md);
    216     }
    217 
    218     {
    219         note("With regular expressions, forwards");
     231        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     232    }
     233
     234
     235    // With regular expressions, forwards");
     236    {
     237        psMemId id = psMemGetId();
    220238        psMetadata *md = mdGenerate();
    221239        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "^" MULTI_NAME "$");
    … …  
    231249        psFree(iter);
    232250        psFree(md);
    233     }
    234 
    235     {
    236         note("With regular expressions, backwards");
     251        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     252    }
     253
     254
     255    // With regular expressions, backwards");
     256    {
     257        psMemId id = psMemGetId();
    237258        psMetadata *md = mdGenerate();
    238259        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_TAIL, "^" MULTI_NAME "$");
    … …  
    248269        psFree(iter);
    249270        psFree(md);
    250     }
    251 
    252     {
    253         note("With regular expressions, jumping in halfway through (using allocator), forwards");
     271        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     272    }
     273
     274
     275    // With regular expressions, jumping in halfway through (using allocator), forwards");
     276    {
     277        psMemId id = psMemGetId();
    254278        psMetadata *md = mdGenerate();
    255279        psMetadataIterator *iter = psMetadataIteratorAlloc(md, 2, "^" MULTI_NAME "$");
    … …  
    263287        psFree(iter);
    264288        psFree(md);
    265     }
    266 
    267     {
    268         note("With regular expressions, jumping in halfway through (using allocator), backwards");
     289        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     290    }
     291
     292
     293    // With regular expressions, jumping in halfway through (using allocator), backwards");
     294    {
     295        psMemId id = psMemGetId();
    269296        psMetadata *md = mdGenerate();
    270297        psMetadataIterator *iter = psMetadataIteratorAlloc(md, -3, "^" MULTI_NAME "$");
    … …  
    278305        psFree(iter);
    279306        psFree(md);
    280     }
    281 
    282     {
    283         note("With regular expressions, jumping in halfway through (using set), forwards");
     307        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     308    }
     309
     310
     311    // With regular expressions, jumping in halfway through (using set), forwards");
     312    {
     313        psMemId id = psMemGetId();
    284314        psMetadata *md = mdGenerate();
    285315        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "^" MULTI_NAME "$");
    … …  
    294324        psFree(iter);
    295325        psFree(md);
    296     }
    297 
    298     {
    299         note("With regular expressions, jumping in halfway through (using set), backwards");
     326        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     327    }
     328
     329
     330    // With regular expressions, jumping in halfway through (using set), backwards");
     331    {
     332        psMemId id = psMemGetId();
    300333        psMetadata *md = mdGenerate();
    301334        psMetadataIterator *iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "^" MULTI_NAME "$");
    … …  
    310343        psFree(iter);
    311344        psFree(md);
    312     }
    313 
    314 
    315     return exit_status();
     345        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     346    }
    316347}

  • trunk/psLib/test/types/tap_psMetadataUpdate.c

    r12532 r12781  
    99*
    1010*/
    11 
    1211#include <pslib.h>
    1312#include <string.h>
    14 
    1513#include "tap.h"
    1614#include "pstap.h"
    … …  
    1816int main(void)
    1917{
     18    psLogSetFormat("HLNM");
     19    psLogSetLevel(PS_LOG_INFO);
    2020    plan_tests(16);
     21    // psMetadataUpdate Tests
    2122
    22     note("psMetadataUpdate Tests");
    2323
    2424    {
    2525        psMemId id = psMemGetId();
    26 
    2726        psMetadata *md = psMetadataAlloc();
    2827        psMetadataAddS32 (md, PS_LIST_TAIL, "TEST1", 0, "", 1);
    … …  
    3332    }
    3433
     34
    3535    {
    3636        psMemId id = psMemGetId();
    37 
    3837        psMetadata *md = psMetadataAlloc();
    3938        psMetadataAddS32 (md, PS_LIST_TAIL, "TEST1", 0, "", 1);
    … …  
    4443    }
    4544
     45
    4646    {
    4747        psMemId id = psMemGetId();
    48 
    4948        psMetadata *md = psMetadataAlloc();
    5049        psMetadataAddS32 (md, PS_LIST_TAIL, "TEST1", 0, "", 1);
    … …  
    5554    }
    5655
     56
    5757    {
    5858        psMemId id = psMemGetId();
    59 
    6059        psMetadata *md = psMetadataAlloc();
    6160        psMetadataAddS32 (md, PS_LIST_TAIL, "TEST1", 0, "", 1);
    … …  
    6665    }
    6766
     67
    6868    {
    6969        psMemId id = psMemGetId();
    70 
    7170        psMetadata *md = psMetadataAlloc();
    7271        psMetadataAddS32 (md, PS_LIST_TAIL, "TEST1", 0, "", 1);
    … …  
    7776    }
    7877
     78
    7979    {
    8080        psMemId id = psMemGetId();
    81 
    8281        psMetadata *input = psMetadataAlloc();
    8382        psMetadata *output = psMetadataAlloc();
    … …  
    8685        psMetadataAddS32 (input, PS_LIST_TAIL, "TEST2", 0, "", 2);
    8786        psMetadataAddS32 (input, PS_LIST_TAIL, "TEST3", 0, "", 2);
    88 
    8987        psMetadataAddS32 (output, PS_LIST_TAIL, "TEST1", 0, "", 1);
    9088        psMetadataAddS32 (output, PS_LIST_TAIL, "TEST2", 0, "", 1);
    … …  
    9896    }
    9997
     98
    10099    {
    101100        psMemId id = psMemGetId();
    102 
    103101        psMetadata *input = psMetadataAlloc();
    104102        psMetadata *output = psMetadataAlloc();
    … …  
    107105        psMetadataAddS32 (input, PS_LIST_TAIL, "TEST2", 0, "", 2);
    108106        psMetadataAddS32 (input, PS_LIST_TAIL, "TEST3", 0, "", 2);
    109 
    110107        psMetadataAddS32 (output, PS_LIST_TAIL, "TEST1", 0, "", 1);
    111108        psMetadataAddS32 (output, PS_LIST_TAIL, "TEST3", 0, "", 1);
    … …  
    118115    }
    119116
     117
    120118    {
    121119        psMemId id = psMemGetId();
    122 
    123120        psMetadata *input = psMetadataAlloc();
    124121        psMetadata *output = psMetadataAlloc();

  • trunk/psLib/test/types/tap_psMetadata_copying.c

    r12607 r12781  
    1010 *
    1111 */
    12 
    1312#include <pslib.h>
    1413#include <string.h>
    15 
    1614#include "tap.h"
    1715#include "pstap.h"
    1816
    19 void testMetadataCopy(void);
    20 void testMetadataItemCopy(void);
    21 void testMetadataItemTransfer(void);
    2217
    2318int main(void)
    2419{
    2520    psLogSetFormat("HLNM");
    26     plan_tests(39);
    27 
    28     testMetadataCopy();
    29     testMetadataItemCopy();
    30     testMetadataItemTransfer();
    31 
    32     done();
    33 }
    34 
    35 void testMetadataCopy(void)
    36 {
    37     psMetadata *in = NULL;
    38     psMetadata *out = NULL;
    39     psMetadataItem *tempItem = NULL;
    40     psMetadataItem *outItem = NULL;
    41     psMetadataItem *inItem = NULL;
    42     psMetadata *outTest = NULL;
    43 
    44     //Return NULL for NULL psMetadata input
     21    psLogSetLevel(PS_LOG_INFO);
     22    plan_tests(41);
     23
     24
     25    // testMetadataCopy()
    4526    {
    46         outTest = psMetadataCopy(out, NULL);
    47         ok( outTest == NULL,
    48             "psMetadataCopy:  return NULL for NULL input metadata.");
    49     }
    50     //Return allocated out for NULL psMetadata input (with allocated out)
    51     {
    52         out = psMetadataAlloc();
    53         outTest = psMetadataCopy(out, NULL);
    54         ok( outTest == NULL,
    55             "psMetadataCopy:  return out for NULL input metadata.");
     27        psMemId id = psMemGetId();
     28        psMetadata *in = NULL;
     29        psMetadata *out = NULL;
     30        psMetadataItem *tempItem = NULL;
     31        psMetadataItem *outItem = NULL;
     32        psMetadataItem *inItem = NULL;
     33        psMetadata *outTest = NULL;
     34   
     35        //Return NULL for NULL psMetadata input
     36        {
     37            outTest = psMetadataCopy(out, NULL);
     38            ok( outTest == NULL,
     39                "psMetadataCopy:  return NULL for NULL input metadata.");
     40        }
     41        //Return allocated out for NULL psMetadata input (with allocated out)
     42        {
     43            out = psMetadataAlloc();
     44            outTest = psMetadataCopy(out, NULL);
     45            ok( outTest == NULL,
     46                "psMetadataCopy:  return out for NULL input metadata.");
     47            psFree(out);
     48            out = NULL;
     49        }
     50        //Return NULL for attempt to copy item of unsupported data type - NULL out metadata
     51        psMetadataItem *notype = NULL;
     52        {
     53            in = psMetadataAlloc();
     54            psMetadataAddS32(in, PS_LIST_HEAD, "S32", 0, "", 1);
     55            notype = psMetadataGet(in, PS_LIST_HEAD);
     56            notype->type = -1;
     57            outTest = psMetadataCopy(out, in);
     58            ok( outTest == NULL,
     59                "psMetadataCopy:  return NULL for metadata with item of bad type.");
     60            psFree(out);
     61            out = NULL;
     62        }
     63        //Return NULL for attempt to copy item of unsupported data type - allocated out metadata
     64        {
     65            out = psMetadataAlloc();
     66            psMetadataAddS32(out, PS_LIST_TAIL, "S32", 0, "", 2);
     67            outTest = psMetadataCopy(out, in);
     68            ok( outTest == NULL,
     69                "psMetadataCopy:  return NULL for metadata with item of bad type.");
     70            notype->type = PS_DATA_S32;
     71            psFree(out);
     72            out = NULL;
     73            psFree(in);
     74            in = NULL;
     75        }
     76   
     77        //Return NULL for NULL psMetadata input->list
     78        in = psMetadataAlloc();
     79        if (in->list != NULL) {
     80            psFree(in->list);
     81            in->list = NULL;
     82        }
     83        {
     84            outTest = psMetadataCopy(out, in);
     85            ok( outTest == NULL,
     86                "psMetadataCopy:  return NULL for NULL metadata input->list.");
     87        }
     88        /*    //Return NULL for NULL psMetadata input->list (with allocated out)
     89            {
     90                out = psMetadataAlloc();
     91                out = psMetadataCopy(out, in);
     92                ok( out == NULL,
     93                    "psMetadataCopy:  return NULL for NULL metadata input->list.");
     94            }
     95        */
     96        //Return valid (but empty) metadata for NULL out input and empty input metadata.
     97        in->list = psListAlloc(NULL);
     98        psFree(in);
     99        in = psMetadataAlloc();
     100        if (out != NULL) {
     101            psFree(out);
     102            out = NULL;
     103        }
     104        outTest = psMetadataCopy(out, in);
     105        tempItem = psMetadataGet(in, PS_LIST_HEAD);
     106        {
     107            ok( outTest != NULL && tempItem == NULL,
     108                "psMetadataCopy:  return empty copy with no items for empty input metadata.");
     109            psFree(out);
     110            psFree(outTest);
     111            out = NULL;
     112            outTest = NULL;
     113        }
     114   
     115        //Test case: multiCheckItem->type == PS_DATA_METADATA_MULTI
     116        psMetadataAddS32(in, PS_LIST_HEAD, "S32", 0, "", 1);
     117        psMetadataAddS32(in, PS_LIST_TAIL, "S32", PS_META_DUPLICATE_OK, "", 1);
     118        outTest = psMetadataCopy(out, in);
     119        tempItem = psMetadataGet(outTest, PS_LIST_HEAD);
     120        {
     121            ok( tempItem->type == PS_DATA_S32 && tempItem->data.S32 == 1,
     122                "psMetadataCopy:  return valid copy for a PS_DATA_METADATA_MULTI entry.");
     123            psFree(outTest);
     124            outTest = NULL;
     125        }
     126   
     127        //Test case:  !psMetadataAddItem(out, newItem, PS_LIST_TAIL, flag)
     128        //XXX: doesn't seem to be easily reachable, certainly by the user...  Skipping.
     129   
     130        //Test case: simple valid test
     131        psFree(in);
    56132        psFree(out);
    57133        out = NULL;
    58     }
    59     //Return NULL for attempt to copy item of unsupported data type - NULL out metadata
    60     psMetadataItem *notype = NULL;
    61     {
    62134        in = psMetadataAlloc();
    63         psMetadataAddS32(in, PS_LIST_HEAD, "S32", 0, "", 1);
    64         notype = psMetadataGet(in, PS_LIST_HEAD);
    65         notype->type = -1;
     135        psMetadataAddS32(in, PS_LIST_HEAD, "S32", 0, "", 666);
    66136        outTest = psMetadataCopy(out, in);
    67         ok( outTest == NULL,
    68             "psMetadataCopy:  return NULL for metadata with item of bad type.");
    69         psFree(out);
    70         out = NULL;
    71     }
    72     //Return NULL for attempt to copy item of unsupported data type - allocated out metadata
    73     {
    74         out = psMetadataAlloc();
    75         psMetadataAddS32(out, PS_LIST_TAIL, "S32", 0, "", 2);
    76         outTest = psMetadataCopy(out, in);
    77         ok( outTest == NULL,
    78             "psMetadataCopy:  return NULL for metadata with item of bad type.");
    79         notype->type = PS_DATA_S32;
    80         psFree(out);
    81         out = NULL;
    82         psFree(in);
    83         in = NULL;
    84     }
    85 
    86     //Return NULL for NULL psMetadata input->list
    87     in = psMetadataAlloc();
    88     if (in->list != NULL) {
    89         psFree(in->list);
    90         in->list = NULL;
    91     }
    92     {
    93         outTest = psMetadataCopy(out, in);
    94         ok( outTest == NULL,
    95             "psMetadataCopy:  return NULL for NULL metadata input->list.");
    96     }
    97     /*    //Return NULL for NULL psMetadata input->list (with allocated out)
    98         {
    99             out = psMetadataAlloc();
    100             out = psMetadataCopy(out, in);
    101             ok( out == NULL,
    102                 "psMetadataCopy:  return NULL for NULL metadata input->list.");
    103         }
    104     */
    105     //Return valid (but empty) metadata for NULL out input and empty input metadata.
    106     in->list = psListAlloc(NULL);
    107     psFree(in);
    108     in = psMetadataAlloc();
    109     if (out != NULL) {
    110         psFree(out);
    111         out = NULL;
    112     }
    113     outTest = psMetadataCopy(out, in);
    114     tempItem = psMetadataGet(in, PS_LIST_HEAD);
    115     {
    116         ok( outTest != NULL && tempItem == NULL,
    117             "psMetadataCopy:  return empty copy with no items for empty input metadata.");
    118         psFree(out);
     137        outItem = psMetadataGet(outTest, PS_LIST_HEAD);
     138        inItem = psMetadataGet(in, PS_LIST_HEAD);
     139        {
     140            ok( outItem->type == PS_DATA_S32 && outItem->data.S32 == inItem->data.S32 &&
     141                (strncmp(inItem->name, outItem->name, 10) == 0),
     142                "psMetadataCopy:  return valid copy of metadata with 1 S32 entry.");
     143        }
    119144        psFree(outTest);
    120         out = NULL;
    121         outTest = NULL;
    122     }
    123 
    124     //Test case: multiCheckItem->type == PS_DATA_METADATA_MULTI
    125     psMetadataAddS32(in, PS_LIST_HEAD, "S32", 0, "", 1);
    126     psMetadataAddS32(in, PS_LIST_TAIL, "S32", PS_META_DUPLICATE_OK, "", 1);
    127     outTest = psMetadataCopy(out, in);
    128     tempItem = psMetadataGet(outTest, PS_LIST_HEAD);
    129     {
    130         ok( tempItem->type == PS_DATA_S32 && tempItem->data.S32 == 1,
    131             "psMetadataCopy:  return valid copy for a PS_DATA_METADATA_MULTI entry.");
    132         psFree(outTest);
    133         outTest = NULL;
    134     }
    135 
    136     //Test case:  !psMetadataAddItem(out, newItem, PS_LIST_TAIL, flag)
    137     //XXX: doesn't seem to be easily reachable, certainly by the user...  Skipping.
    138 
    139     //Test case: simple valid test
    140     psFree(in);
    141     psFree(out);
    142     out = NULL;
    143     in = psMetadataAlloc();
    144     psMetadataAddS32(in, PS_LIST_HEAD, "S32", 0, "", 666);
    145     outTest = psMetadataCopy(out, in);
    146     outItem = psMetadataGet(outTest, PS_LIST_HEAD);
    147     inItem = psMetadataGet(in, PS_LIST_HEAD);
    148     {
    149         ok( outItem->type == PS_DATA_S32 && outItem->data.S32 == inItem->data.S32 &&
    150             (strncmp(inItem->name, outItem->name, 10) == 0),
    151             "psMetadataCopy:  return valid copy of metadata with 1 S32 entry.");
    152     }
    153     psFree(outTest);
    154     //Check for Memory Leaks
    155     {
    156145        psFree(in);
    157146        psFree(out);
    158         checkMem();
     147        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    159148    }
    160149
    161 }
    162 
    163 void testMetadataItemCopy(void)
    164 {
    165     //Return NULL for NULL input psMetadataItem
     150
     151    // testMetadataItemCopy()
    166152    {
    167         ok( psMetadataItemCopy(NULL) == NULL,
    168             "psMetadataItemCopy:   return NULL for NULL input metadataItem.");
    169     }
    170 
    171     //Test Simple types:  Bool, S8, S16, S32, S64, U8, U16, U32, U64, F32, F64, STRING
    172     psMetadataItem *itemBool = psMetadataItemAlloc("itemBool", PS_DATA_BOOL, "", false);
    173     psMetadataItem *itemS8  =  psMetadataItemAlloc("itemS8", PS_DATA_S8, "", 1);
    174     psMetadataItem *itemS16 =  psMetadataItemAlloc("itemS16", PS_DATA_S16, "", 2);
    175     psMetadataItem *itemS32 =  psMetadataItemAlloc("itemS32", PS_DATA_S32, "", 3);
    176     psMetadataItem *itemS64 =  psMetadataItemAlloc("itemS64", PS_DATA_S64, "", (psS64)4);
    177     psMetadataItem *itemU8  =  psMetadataItemAlloc("itemU8", PS_DATA_U8, "", 1);
    178     psMetadataItem *itemU16 =  psMetadataItemAlloc("itemU16", PS_DATA_U16, "", 2);
    179     psMetadataItem *itemU32 =  psMetadataItemAlloc("itemU32", PS_DATA_U32, "", 3);
    180     psMetadataItem *itemU64 =  psMetadataItemAlloc("itemU64", PS_DATA_U64, "", 4);
    181     psMetadataItem *itemF32 =  psMetadataItemAlloc("itemF32", PS_DATA_F32, "", 3.0);
    182     psMetadataItem *itemF64 =  psMetadataItemAlloc("itemF64", PS_DATA_F64, "", 4.0);
    183     psMetadataItem *itemString = psMetadataItemAlloc("itemString", PS_DATA_STRING, "", "I M STRiNG");
    184     psMetadataItem *copy = NULL;
    185     //Bool case
    186     {
    187         copy = psMetadataItemCopy(itemBool);
    188         ok( (copy->type == PS_DATA_BOOL && (strncmp(copy->name, "itemBool", 10) == 0) &&
    189              !copy->data.B && strncmp(copy->comment, "", 2) == 0),
    190             "psMetadataItemCopy:  return valid copy of BOOL item.");
    191         psFree(copy);
    192     }
    193     //S8 case
    194     {
    195         copy = psMetadataItemCopy(itemS8);
    196         ok( (copy->type == PS_DATA_S8 && (strncmp(copy->name, "itemS8", 10) == 0) &&
    197              copy->data.S8 == 1 && strncmp(copy->comment, "", 2) == 0),
    198             "psMetadataItemCopy:  return valid copy of S8 item.");
    199         psFree(copy);
    200     }
    201     //S16 case
    202     {
    203         copy = psMetadataItemCopy(itemS16);
    204         ok( (copy->type == PS_DATA_S16 && (strncmp(copy->name, "itemS16", 10) == 0) &&
    205              copy->data.S16 == 2 && strncmp(copy->comment, "", 2) == 0),
    206             "psMetadataItemCopy:  return valid copy of S16 item.");
    207         psFree(copy);
    208     }
    209     //S32 case
    210     {
    211         copy = psMetadataItemCopy(itemS32);
    212         ok( (copy->type == PS_DATA_S32 && (strncmp(copy->name, "itemS32", 10) == 0) &&
    213              copy->data.S32 == 3 && strncmp(copy->comment, "", 2) == 0),
    214             "psMetadataItemCopy:  return valid copy of S32 item.");
    215         psFree(copy);
    216     }
    217 
    218     // S64 case
    219     {
    220         psMetadataItem *copy = psMetadataItemCopy(itemS64);
    221 
    222         ok(copy->type == PS_DATA_S64, "item type");
    223         is_str(copy->name, "itemS64", "item name");
    224         is_long(copy->data.S64, 4, "item data");
    225         is_str(copy->comment, "", "item comment");
    226 
    227         psFree(copy);
    228     }
    229 
    230     //U8 case
    231     {
    232         copy = psMetadataItemCopy(itemU8);
    233         ok( (copy->type == PS_DATA_U8 && (strncmp(copy->name, "itemU8", 10) == 0) &&
    234              copy->data.U8 == 1 && strncmp(copy->comment, "", 2) == 0),
    235             "psMetadataItemCopy:  return valid copy of U8 item.");
    236         psFree(copy);
    237     }
    238     //U16 case
    239     {
    240         copy = psMetadataItemCopy(itemU16);
    241         ok( (copy->type == PS_DATA_U16 && (strncmp(copy->name, "itemU16", 10) == 0) &&
    242              copy->data.U16 == 2 && strncmp(copy->comment, "", 2) == 0),
    243             "psMetadataItemCopy:  return valid copy of U16 item.");
    244         psFree(copy);
    245     }
    246     //U32 case
    247     {
    248         copy = psMetadataItemCopy(itemU32);
    249         ok( (copy->type == PS_DATA_U32 && (strncmp(copy->name, "itemU32", 10) == 0) &&
    250              copy->data.U32 == 3 && strncmp(copy->comment, "", 2) == 0),
    251             "psMetadataItemCopy:  return valid copy of U32 item.");
    252         psFree(copy);
    253     }
    254     //U64 case
    255     {
    256         copy = psMetadataItemCopy(itemU64);
    257         ok( (copy->type == PS_DATA_U64 && (strncmp(copy->name, "itemU64", 10) == 0) &&
    258              copy->data.U64 == 4 && strncmp(copy->comment, "", 2) == 0),
    259             "psMetadataItemCopy:  return valid copy of U64 item.");
    260         psFree(copy);
    261     }
    262     //F32 case
    263     {
    264         copy = psMetadataItemCopy(itemF32);
    265         ok( (copy->type == PS_DATA_F32 && (strncmp(copy->name, "itemF32", 10) == 0) &&
    266              abs(copy->data.F32-3.0) < FLT_EPSILON && strncmp(copy->comment, "", 2) == 0),
    267             "psMetadataItemCopy:  return valid copy of F32 item.");
    268         psFree(copy);
    269     }
    270     //F64 case
    271     {
    272         copy = psMetadataItemCopy(itemF64);
    273         ok( (copy->type == PS_DATA_F64 && (strncmp(copy->name, "itemF64", 10) == 0) &&
    274              abs(copy->data.F64-4.0) < DBL_EPSILON && strncmp(copy->comment, "", 2) == 0),
    275             "psMetadataItemCopy:  return valid copy of F64 item.");
    276         psFree(copy);
    277     }
    278     //STRING case
    279     {
    280         copy = psMetadataItemCopy(itemString);
    281         ok( (copy->type == PS_DATA_STRING && (strncmp(copy->name, "itemString", 12) == 0) &&
    282              strncmp(copy->data.str,"I M STRiNG",12) == 0 && strncmp(copy->comment,"",2) == 0),
    283             "psMetadataItemCopy:  return valid copy of STRING item.");
    284         psFree(copy);
    285     }
    286 
    287     //Test Remaining types:  Vector, Time, Metadata, Region
    288     psVector *inV = psVectorAlloc(2, PS_TYPE_S32);
    289     psVectorSet(inV, 0, 666);
    290     psVectorSet(inV, 1, 667);
    291     psMetadataItem *itemVector = psMetadataItemAlloc("itemVector", PS_DATA_VECTOR, "", inV);
    292     psTime *teaTime = psTimeAlloc(PS_TIME_TAI);
    293     teaTime->sec = 1;
    294     teaTime->nsec = 0;
    295     teaTime->leapsecond = true;
    296     psMetadataItem *itemTime = psMetadataItemAlloc("itemTime", PS_DATA_TIME, "", teaTime);
    297     psMetadata *md = psMetadataAlloc();
    298     psMetadataAddS32(md, PS_LIST_HEAD, "mdS32", 0, "", 666);
    299     psMetadataItem *itemMD = psMetadataItemAlloc("itemMD", PS_DATA_METADATA, "", md);
    300     psRegion *reg = psRegionAlloc(0.0, 2.0, 1.0, 3.0);
    301     psMetadataItem *itemRegion = psMetadataItemAlloc("itemRegion", PS_DATA_REGION, "", reg);
    302     //Vector case
    303     {
    304         copy = psMetadataItemCopy(itemVector);
    305         int int0 = ((psVector*)(copy->data.V))->data.S32[0];
    306         int int1 = ((psVector*)(copy->data.V))->data.S32[1];
    307         ok( (copy->type == PS_DATA_VECTOR && (strncmp(copy->name, "itemVector", 12) == 0)
    308              && int0 == 666 && int1 == 667 && strncmp(copy->comment,"",2) == 0),
    309             "psMetadataItemCopy:  return valid copy of Vector item.");
    310         psFree(copy);
    311     }
    312     //Vector case - invalid vector item
    313     {
    314         psFree(itemVector->data.V);
    315         itemVector->data.V = NULL;
    316         copy = psMetadataItemCopy(itemVector);
    317         ok( copy == NULL, "psMetadataItemCopy:  return NULL for invalid vector item");
    318         //        itemVector->data.V = psVectorAlloc(1, PS_TYPE_S32);
    319     }
    320     //Time case
    321     {
    322         copy = psMetadataItemCopy(itemTime);
    323         int int0 = (int)((psTime*)(copy->data.V))->sec;
    324         int int1 = (int)((psTime*)(copy->data.V))->nsec;
    325         bool leap = ((psTime*)(copy->data.V))->leapsecond;
    326         ok( (copy->type == PS_DATA_TIME && (strncmp(copy->name, "itemTime", 12) == 0)
    327              && int0 == 1 && int1 == 0 && strncmp(copy->comment,"",2) == 0) && leap,
    328             "psMetadataItemCopy:  return valid copy of Time item.");
    329         psFree(copy);
    330     }
    331     //Time case - invalid time item
    332     {
    333         psTime *t = psTimeAlloc(PS_TIME_TT);
    334         t->type += 1;
    335         psMetadataItem *itemTime2 = psMetadataItemAlloc("itemTime", PS_DATA_TIME, "", t);
    336         copy = psMetadataItemCopy(itemTime2);
    337         ok( copy != NULL && copy->data.V == NULL,
    338             "psMetadataItemCopy:  return non-NULL item for invalid input time item");
    339         psFree(t);
    340         psFree(copy);
    341         psFree(itemTime2);
    342     }
    343     //Time case - NULL time item
    344     {
    345         psFree(itemTime->data.V);
    346         itemTime->data.V = NULL;
    347         copy = psMetadataItemCopy(itemTime);
    348         ok( copy != NULL && copy->data.V == NULL,
    349             "psMetadataItemCopy:  return non-NULL item for NULL input time item");
    350         //        (itemTime->data.V) = psTimeAlloc(PS_TIME_TAI);
    351         psFree(copy);
    352     }
    353     //Metadata case
    354     {
    355         copy = psMetadataItemCopy(itemMD);
    356         psMetadataItem *testItem = NULL;
    357         testItem = psMetadataGet(((psMetadata*)(copy->data.V)), PS_LIST_HEAD);
    358         if (testItem == NULL)
    359             printf("\nError in psMetadataGet.\n");
    360         ok( copy->type == PS_DATA_METADATA && strncmp(copy->name, "itemMD", 8) == 0
    361             && (strncmp(copy->comment, "",2) == 0) && testItem->type == PS_DATA_S32
    362             && (strncmp(testItem->name, "mdS32", 10) == 0) && testItem->data.S32 == 666
    363             && (strncmp(testItem->comment,"",2) == 0),
    364             "psMetadataItemCopy:  return valid copy of Metadata item.");
    365         psFree(copy);
    366     }
    367     //Region case
    368     {
    369         copy = psMetadataItemCopy(itemRegion);
    370         float x0 = ((psRegion*)(copy->data.V))->x0;
    371         float x1 = ((psRegion*)(copy->data.V))->x1;
    372         float y0 = ((psRegion*)(copy->data.V))->y0;
    373         float y1 = ((psRegion*)(copy->data.V))->y1;
    374         ok( (copy->type == PS_DATA_REGION && (strncmp(copy->name, "itemRegion", 12) == 0)
    375              && abs(x0-0.0) < FLT_EPSILON && abs(x1-2.0) < FLT_EPSILON
    376              && abs(y0-1.0) < FLT_EPSILON && abs(y1-3.0) < FLT_EPSILON
    377              && strncmp(copy->comment,"",2) == 0),
    378             "psMetadataItemCopy:  return valid copy of Region item.");
    379         psFree(copy);
    380     }
    381 
    382     //Test Unsupported type - (sphere for example)
    383     psSphere *sphere = psSphereAlloc();
    384     sphere->r = 1.0;
    385     sphere->d = 6.66;
    386     psMetadataItem *itemSphere = psMetadataItemAlloc("itemSphere", PS_DATA_SPHERE, "", sphere);
    387     psFree(sphere);
    388     {
    389         copy = psMetadataItemCopy(itemSphere);
    390         float R = ((psSphere*)(copy->data.V))->r;
    391         float D = ((psSphere*)(copy->data.V))->d;
    392         ok( (copy->type == PS_DATA_SPHERE && (strncmp(copy->name, "itemSphere", 12) == 0) &&
    393              abs(R - 1.0) < FLT_EPSILON && abs(D - 6.66) < FLT_EPSILON &&
    394              strncmp(copy->comment,"",2) == 0),
    395             "psMetadataItemCopy:  return valid copy of SPHERE item.");
    396         psFree(copy);
    397     }
    398 
    399     //Check for Memory Leaks before exit
    400     {
     153        psMemId id = psMemGetId();
     154        //Return NULL for NULL input psMetadataItem
     155        {
     156            ok( psMetadataItemCopy(NULL) == NULL,
     157                "psMetadataItemCopy:   return NULL for NULL input metadataItem.");
     158        }
     159   
     160        //Test Simple types:  Bool, S8, S16, S32, S64, U8, U16, U32, U64, F32, F64, STRING
     161        psMetadataItem *itemBool = psMetadataItemAlloc("itemBool", PS_DATA_BOOL, "", false);
     162        psMetadataItem *itemS8  =  psMetadataItemAlloc("itemS8", PS_DATA_S8, "", 1);
     163        psMetadataItem *itemS16 =  psMetadataItemAlloc("itemS16", PS_DATA_S16, "", 2);
     164        psMetadataItem *itemS32 =  psMetadataItemAlloc("itemS32", PS_DATA_S32, "", 3);
     165        psMetadataItem *itemS64 =  psMetadataItemAlloc("itemS64", PS_DATA_S64, "", (psS64)4);
     166        psMetadataItem *itemU8  =  psMetadataItemAlloc("itemU8", PS_DATA_U8, "", 1);
     167        psMetadataItem *itemU16 =  psMetadataItemAlloc("itemU16", PS_DATA_U16, "", 2);
     168        psMetadataItem *itemU32 =  psMetadataItemAlloc("itemU32", PS_DATA_U32, "", 3);
     169        psMetadataItem *itemU64 =  psMetadataItemAlloc("itemU64", PS_DATA_U64, "", 4);
     170        psMetadataItem *itemF32 =  psMetadataItemAlloc("itemF32", PS_DATA_F32, "", 3.0);
     171        psMetadataItem *itemF64 =  psMetadataItemAlloc("itemF64", PS_DATA_F64, "", 4.0);
     172        psMetadataItem *itemString = psMetadataItemAlloc("itemString", PS_DATA_STRING, "", "I M STRiNG");
     173        psMetadataItem *copy = NULL;
     174        //Bool case
     175        {
     176            copy = psMetadataItemCopy(itemBool);
     177            ok( (copy->type == PS_DATA_BOOL && (strncmp(copy->name, "itemBool", 10) == 0) &&
     178                 !copy->data.B && strncmp(copy->comment, "", 2) == 0),
     179                "psMetadataItemCopy:  return valid copy of BOOL item.");
     180            psFree(copy);
     181        }
     182        //S8 case
     183        {
     184            copy = psMetadataItemCopy(itemS8);
     185            ok( (copy->type == PS_DATA_S8 && (strncmp(copy->name, "itemS8", 10) == 0) &&
     186                 copy->data.S8 == 1 && strncmp(copy->comment, "", 2) == 0),
     187                "psMetadataItemCopy:  return valid copy of S8 item.");
     188            psFree(copy);
     189        }
     190        //S16 case
     191        {
     192            copy = psMetadataItemCopy(itemS16);
     193            ok( (copy->type == PS_DATA_S16 && (strncmp(copy->name, "itemS16", 10) == 0) &&
     194                 copy->data.S16 == 2 && strncmp(copy->comment, "", 2) == 0),
     195                "psMetadataItemCopy:  return valid copy of S16 item.");
     196            psFree(copy);
     197        }
     198        //S32 case
     199        {
     200            copy = psMetadataItemCopy(itemS32);
     201            ok( (copy->type == PS_DATA_S32 && (strncmp(copy->name, "itemS32", 10) == 0) &&
     202                 copy->data.S32 == 3 && strncmp(copy->comment, "", 2) == 0),
     203                "psMetadataItemCopy:  return valid copy of S32 item.");
     204            psFree(copy);
     205        }
     206   
     207        // S64 case
     208        {
     209            psMetadataItem *copy = psMetadataItemCopy(itemS64);
     210   
     211            ok(copy->type == PS_DATA_S64, "item type");
     212            is_str(copy->name, "itemS64", "item name");
     213            is_long(copy->data.S64, 4, "item data");
     214            is_str(copy->comment, "", "item comment");
     215   
     216            psFree(copy);
     217        }
     218   
     219        //U8 case
     220        {
     221            copy = psMetadataItemCopy(itemU8);
     222            ok( (copy->type == PS_DATA_U8 && (strncmp(copy->name, "itemU8", 10) == 0) &&
     223                 copy->data.U8 == 1 && strncmp(copy->comment, "", 2) == 0),
     224                "psMetadataItemCopy:  return valid copy of U8 item.");
     225            psFree(copy);
     226        }
     227        //U16 case
     228        {
     229            copy = psMetadataItemCopy(itemU16);
     230            ok( (copy->type == PS_DATA_U16 && (strncmp(copy->name, "itemU16", 10) == 0) &&
     231                 copy->data.U16 == 2 && strncmp(copy->comment, "", 2) == 0),
     232                "psMetadataItemCopy:  return valid copy of U16 item.");
     233            psFree(copy);
     234        }
     235        //U32 case
     236        {
     237            copy = psMetadataItemCopy(itemU32);
     238            ok( (copy->type == PS_DATA_U32 && (strncmp(copy->name, "itemU32", 10) == 0) &&
     239                 copy->data.U32 == 3 && strncmp(copy->comment, "", 2) == 0),
     240                "psMetadataItemCopy:  return valid copy of U32 item.");
     241            psFree(copy);
     242        }
     243        //U64 case
     244        {
     245            copy = psMetadataItemCopy(itemU64);
     246            ok( (copy->type == PS_DATA_U64 && (strncmp(copy->name, "itemU64", 10) == 0) &&
     247                 copy->data.U64 == 4 && strncmp(copy->comment, "", 2) == 0),
     248                "psMetadataItemCopy:  return valid copy of U64 item.");
     249            psFree(copy);
     250        }
     251        //F32 case
     252        {
     253            copy = psMetadataItemCopy(itemF32);
     254            ok( (copy->type == PS_DATA_F32 && (strncmp(copy->name, "itemF32", 10) == 0) &&
     255                 abs(copy->data.F32-3.0) < FLT_EPSILON && strncmp(copy->comment, "", 2) == 0),
     256                "psMetadataItemCopy:  return valid copy of F32 item.");
     257            psFree(copy);
     258        }
     259        //F64 case
     260        {
     261            copy = psMetadataItemCopy(itemF64);
     262            ok( (copy->type == PS_DATA_F64 && (strncmp(copy->name, "itemF64", 10) == 0) &&
     263                 abs(copy->data.F64-4.0) < DBL_EPSILON && strncmp(copy->comment, "", 2) == 0),
     264                "psMetadataItemCopy:  return valid copy of F64 item.");
     265            psFree(copy);
     266        }
     267        //STRING case
     268        {
     269            copy = psMetadataItemCopy(itemString);
     270            ok( (copy->type == PS_DATA_STRING && (strncmp(copy->name, "itemString", 12) == 0) &&
     271                 strncmp(copy->data.str,"I M STRiNG",12) == 0 && strncmp(copy->comment,"",2) == 0),
     272                "psMetadataItemCopy:  return valid copy of STRING item.");
     273            psFree(copy);
     274        }
     275   
     276        //Test Remaining types:  Vector, Time, Metadata, Region
     277        psVector *inV = psVectorAlloc(2, PS_TYPE_S32);
     278        psVectorSet(inV, 0, 666);
     279        psVectorSet(inV, 1, 667);
     280        psMetadataItem *itemVector = psMetadataItemAlloc("itemVector", PS_DATA_VECTOR, "", inV);
     281        psTime *teaTime = psTimeAlloc(PS_TIME_TAI);
     282        teaTime->sec = 1;
     283        teaTime->nsec = 0;
     284        teaTime->leapsecond = true;
     285        psMetadataItem *itemTime = psMetadataItemAlloc("itemTime", PS_DATA_TIME, "", teaTime);
     286        psMetadata *md = psMetadataAlloc();
     287        psMetadataAddS32(md, PS_LIST_HEAD, "mdS32", 0, "", 666);
     288        psMetadataItem *itemMD = psMetadataItemAlloc("itemMD", PS_DATA_METADATA, "", md);
     289        psRegion *reg = psRegionAlloc(0.0, 2.0, 1.0, 3.0);
     290        psMetadataItem *itemRegion = psMetadataItemAlloc("itemRegion", PS_DATA_REGION, "", reg);
     291        //Vector case
     292        {
     293            copy = psMetadataItemCopy(itemVector);
     294            int int0 = ((psVector*)(copy->data.V))->data.S32[0];
     295            int int1 = ((psVector*)(copy->data.V))->data.S32[1];
     296            ok( (copy->type == PS_DATA_VECTOR && (strncmp(copy->name, "itemVector", 12) == 0)
     297                 && int0 == 666 && int1 == 667 && strncmp(copy->comment,"",2) == 0),
     298                "psMetadataItemCopy:  return valid copy of Vector item.");
     299            psFree(copy);
     300        }
     301        //Vector case - invalid vector item
     302        {
     303            psFree(itemVector->data.V);
     304            itemVector->data.V = NULL;
     305            copy = psMetadataItemCopy(itemVector);
     306            ok( copy == NULL, "psMetadataItemCopy:  return NULL for invalid vector item");
     307            //        itemVector->data.V = psVectorAlloc(1, PS_TYPE_S32);
     308        }
     309        //Time case
     310        {
     311            copy = psMetadataItemCopy(itemTime);
     312            int int0 = (int)((psTime*)(copy->data.V))->sec;
     313            int int1 = (int)((psTime*)(copy->data.V))->nsec;
     314            bool leap = ((psTime*)(copy->data.V))->leapsecond;
     315            ok( (copy->type == PS_DATA_TIME && (strncmp(copy->name, "itemTime", 12) == 0)
     316                 && int0 == 1 && int1 == 0 && strncmp(copy->comment,"",2) == 0) && leap,
     317                "psMetadataItemCopy:  return valid copy of Time item.");
     318            psFree(copy);
     319        }
     320        //Time case - invalid time item
     321        {
     322            psTime *t = psTimeAlloc(PS_TIME_TT);
     323            t->type += 1;
     324            psMetadataItem *itemTime2 = psMetadataItemAlloc("itemTime", PS_DATA_TIME, "", t);
     325            copy = psMetadataItemCopy(itemTime2);
     326            ok( copy != NULL && copy->data.V == NULL,
     327                "psMetadataItemCopy:  return non-NULL item for invalid input time item");
     328            psFree(t);
     329            psFree(copy);
     330            psFree(itemTime2);
     331        }
     332        //Time case - NULL time item
     333        {
     334            psFree(itemTime->data.V);
     335            itemTime->data.V = NULL;
     336            copy = psMetadataItemCopy(itemTime);
     337            ok( copy != NULL && copy->data.V == NULL,
     338                "psMetadataItemCopy:  return non-NULL item for NULL input time item");
     339            //        (itemTime->data.V) = psTimeAlloc(PS_TIME_TAI);
     340            psFree(copy);
     341        }
     342        //Metadata case
     343        {
     344            copy = psMetadataItemCopy(itemMD);
     345            psMetadataItem *testItem = NULL;
     346            testItem = psMetadataGet(((psMetadata*)(copy->data.V)), PS_LIST_HEAD);
     347            if (testItem == NULL)
     348                printf("\nError in psMetadataGet.\n");
     349            ok( copy->type == PS_DATA_METADATA && strncmp(copy->name, "itemMD", 8) == 0
     350                && (strncmp(copy->comment, "",2) == 0) && testItem->type == PS_DATA_S32
     351                && (strncmp(testItem->name, "mdS32", 10) == 0) && testItem->data.S32 == 666
     352                && (strncmp(testItem->comment,"",2) == 0),
     353                "psMetadataItemCopy:  return valid copy of Metadata item.");
     354            psFree(copy);
     355        }
     356        //Region case
     357        {
     358            copy = psMetadataItemCopy(itemRegion);
     359            float x0 = ((psRegion*)(copy->data.V))->x0;
     360            float x1 = ((psRegion*)(copy->data.V))->x1;
     361            float y0 = ((psRegion*)(copy->data.V))->y0;
     362            float y1 = ((psRegion*)(copy->data.V))->y1;
     363            ok( (copy->type == PS_DATA_REGION && (strncmp(copy->name, "itemRegion", 12) == 0)
     364                 && abs(x0-0.0) < FLT_EPSILON && abs(x1-2.0) < FLT_EPSILON
     365                 && abs(y0-1.0) < FLT_EPSILON && abs(y1-3.0) < FLT_EPSILON
     366                 && strncmp(copy->comment,"",2) == 0),
     367                "psMetadataItemCopy:  return valid copy of Region item.");
     368            psFree(copy);
     369        }
     370   
     371        //Test Unsupported type - (sphere for example)
     372        psSphere *sphere = psSphereAlloc();
     373        sphere->r = 1.0;
     374        sphere->d = 6.66;
     375        psMetadataItem *itemSphere = psMetadataItemAlloc("itemSphere", PS_DATA_SPHERE, "", sphere);
     376        psFree(sphere);
     377        {
     378            copy = psMetadataItemCopy(itemSphere);
     379            float R = ((psSphere*)(copy->data.V))->r;
     380            float D = ((psSphere*)(copy->data.V))->d;
     381            ok( (copy->type == PS_DATA_SPHERE && (strncmp(copy->name, "itemSphere", 12) == 0) &&
     382                 abs(R - 1.0) < FLT_EPSILON && abs(D - 6.66) < FLT_EPSILON &&
     383                 strncmp(copy->comment,"",2) == 0),
     384                "psMetadataItemCopy:  return valid copy of SPHERE item.");
     385            psFree(copy);
     386        }
     387   
    401388        psFree(itemSphere);
    402389        psFree(inV);
    … …  
    420407        psFree(itemMD);
    421408        psFree(itemRegion);
    422         checkMem();
     409        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    423410    }
    424411
    425 }
    426 
    427 void testMetadataItemTransfer(void)
    428 {
    429     psMetadata *out = psMetadataAlloc();
    430     psMetadata *in = psMetadataAlloc();
    431     psString key = psStringAlloc(30);
    432     strncpy(key, "key", 4);
    433 
    434     //Return false for NULL in input
     412
     413    // testMetadataItemTransfer()
    435414    {
    436         ok( !psMetadataItemSupplement(out, NULL, key),
    437             "psMetadataItemSupplement:  return false for NULL in metadata.");
    438     }
    439     //Return false for NULL out input
    440     {
    441         ok( !psMetadataItemSupplement(NULL, in, key),
    442             "psMetadataItemSupplement:  return false for NULL out metadata.");
    443     }
    444     //Return false for NULL key input
    445     {
    446         ok( !psMetadataItemSupplement(out, in, NULL),
    447             "psMetadataItemSupplement:  return false for NULL key string.");
    448     }
    449     psMetadataAddS32(in, PS_LIST_HEAD, "key", PS_META_NO_REPLACE, "", 666);
    450     psMetadataAddF32(out, PS_LIST_HEAD, "out", 0, "", 6.66);
    451 
    452     //Return true for valid inputs
    453     {
    454         bool transfered = psMetadataItemSupplement(out, in, key);
    455         psMetadataItem *item = NULL;
    456         if (transfered)
    457             item = psMetadataGet(out, PS_LIST_TAIL);
    458         ok(transfered && item->type == PS_DATA_S32 && strncmp(item->name, "key", 4) == 0
    459            && item->data.S32 == 666 && strncmp(item->comment, "", 2) == 0,
    460            "psMetadataItemSupplement:  return true for valid inputs.");
    461     }
    462     /*  Attempt here was to return false inside of ItemTransfer at psMetadataAddItem.
    463     //Return false for duplicate entry with PS_META_DEFAULT (no duplicates)
    464     {
    465         psMetadataRemoveKey(out, key);
    466         psMetadataItem *item = psMetadataGet(in, PS_LIST_HEAD);
    467         psMetadataAddItem(out, item, PS_LIST_TAIL, PS_META_NO_REPLACE);
    468         ok( !psMetadataItemSupplement(out, in, key),
    469             "psMetadataItemSupplement:  return false for duplicate metadataItem.");
    470     }
    471     */
    472     //Return false for invalid key
    473     {
    474         strncpy(key, "not MY key", 15);
    475         ok( !psMetadataItemSupplement(out, in, key),
    476             "psMetadataItemSupplement:  return false for invalid key.");
    477     }
    478     //Return false for invalid metadata
    479     psMetadata *invalid = psMetadataAlloc();
    480     psFree(invalid->hash);
    481     invalid->hash = NULL;
    482     {
    483         ok( !psMetadataItemSupplement(invalid, in, "key"),
    484             "psMetadataItemSupplement:  return false for invalid metadata.");
    485     }
    486     psFree(invalid);
    487 
    488     //Check for Memory Leaks
    489     {
     415        psMemId id = psMemGetId();
     416        psMetadata *out = psMetadataAlloc();
     417        psMetadata *in = psMetadataAlloc();
     418        psString key = psStringAlloc(30);
     419        strncpy(key, "key", 4);
     420   
     421        //Return false for NULL in input
     422        {
     423            ok( !psMetadataItemSupplement(out, NULL, key),
     424                "psMetadataItemSupplement:  return false for NULL in metadata.");
     425        }
     426        //Return false for NULL out input
     427        {
     428            ok( !psMetadataItemSupplement(NULL, in, key),
     429                "psMetadataItemSupplement:  return false for NULL out metadata.");
     430        }
     431        //Return false for NULL key input
     432        {
     433            ok( !psMetadataItemSupplement(out, in, NULL),
     434                "psMetadataItemSupplement:  return false for NULL key string.");
     435        }
     436        psMetadataAddS32(in, PS_LIST_HEAD, "key", PS_META_NO_REPLACE, "", 666);
     437        psMetadataAddF32(out, PS_LIST_HEAD, "out", 0, "", 6.66);
     438   
     439        //Return true for valid inputs
     440        {
     441            bool transfered = psMetadataItemSupplement(out, in, key);
     442            psMetadataItem *item = NULL;
     443            if (transfered)
     444                item = psMetadataGet(out, PS_LIST_TAIL);
     445            ok(transfered && item->type == PS_DATA_S32 && strncmp(item->name, "key", 4) == 0
     446               && item->data.S32 == 666 && strncmp(item->comment, "", 2) == 0,
     447               "psMetadataItemSupplement:  return true for valid inputs.");
     448        }
     449        /*  Attempt here was to return false inside of ItemTransfer at psMetadataAddItem.
     450        //Return false for duplicate entry with PS_META_DEFAULT (no duplicates)
     451        {
     452            psMetadataRemoveKey(out, key);
     453            psMetadataItem *item = psMetadataGet(in, PS_LIST_HEAD);
     454            psMetadataAddItem(out, item, PS_LIST_TAIL, PS_META_NO_REPLACE);
     455            ok( !psMetadataItemSupplement(out, in, key),
     456                "psMetadataItemSupplement:  return false for duplicate metadataItem.");
     457        }
     458        */
     459        //Return false for invalid key
     460        {
     461            strncpy(key, "not MY key", 15);
     462            ok( !psMetadataItemSupplement(out, in, key),
     463                "psMetadataItemSupplement:  return false for invalid key.");
     464        }
     465        //Return false for invalid metadata
     466        psMetadata *invalid = psMetadataAlloc();
     467        psFree(invalid->hash);
     468        invalid->hash = NULL;
     469        {
     470            ok( !psMetadataItemSupplement(invalid, in, "key"),
     471                "psMetadataItemSupplement:  return false for invalid metadata.");
     472        }
     473        psFree(invalid);
     474   
    490475        psFree(out);
    491476        psFree(in);
    492477        psFree(key);
    493         checkMem();
     478        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    494479    }
    495 
    496480}

  • trunk/psLib/test/types/tap_psMetadata_creating.c

    r10822 r12781  
    1212*
    1313*/
    14 
    1514#include <pslib.h>
    1615#include <string.h>
    17 
    1816#include "tap.h"
    1917#include "pstap.h"
    2018
    21 void testItemAllocs(void);
    22 void testMDAlloc_AddItem(void);
    23 void testIterAlloc(void);
    2419
    2520int main(void)
    2621{
    27     plan_tests(42);
    28 
    29     note("psMetadata & psMetadataItem Creation Functions");
    30 
    31     testItemAllocs();
    32     testMDAlloc_AddItem();
    33     testIterAlloc();
    34 
    35     done();
    36 }
    37 
    38 void testItemAllocs(void)
    39 {
    40     note("  >>>Test 1:  psMetadataItemAlloc Fxns");
    41     psMetadataItem *itemStr = psMetadataItemAllocStr("itemStr", "", "itemStr");
    42     psMetadataItem *itemF32 = psMetadataItemAllocF32("itemF32", "", 6.66);
    43     psMetadataItem *itemF64 = psMetadataItemAllocF64("itemF64", "", 0.666);
    44     psMetadataItem *itemS8 = psMetadataItemAllocS8("itemS8", "", 0);
    45     psMetadataItem *itemS16 = psMetadataItemAllocS16("itemS16", "", 1);
    46     psMetadataItem *itemS32 = psMetadataItemAllocS32("itemS32", "", 2);
    47     psMetadataItem *itemS64 = psMetadataItemAllocS64("itemS64", "", 3);
    48     psMetadataItem *itemU8 = psMetadataItemAllocU8("itemU8", "", 0);
    49     psMetadataItem *itemU16 = psMetadataItemAllocU16("itemU16", "", 1);
    50     psMetadataItem *itemU32 = psMetadataItemAllocU32("itemU32", "", 2);
    51     psMetadataItem *itemU64 = psMetadataItemAllocU64("itemU64", "", 3);
    52     psMetadataItem *itemBool = psMetadataItemAllocBool("itemBool", "", true);
    53 
    54     //First try to free a NULL item
    55     psMetadataItem *nullItem = NULL;
    56     psFree(nullItem);
    57     //Verify correct allocation
    58     //String
     22    psLogSetFormat("HLNM");
     23    psLogSetLevel(PS_LOG_INFO);
     24    plan_tests(44);
     25    // psMetadata & psMetadataItem Creation Functions
     26
     27
     28    // testItemAllocs(void)
     29    // psMetadataItemAlloc Fxns
    5930    {
    60         skip_start(itemStr == NULL, 1,
    61                    "Skipping 1 tests because psMetadataItemAllocStr() failed");
    62         ok(itemStr->type == PS_DATA_STRING
    63            && !strncmp(itemStr->name, "itemStr", 10)
    64            && !strncmp(itemStr->data.V, "itemStr", 10)
    65            && !strncmp(itemStr->comment, "", 2),
    66            "psMetadataItemAllocStr:    create valid string item.");
    67         skip_end();
    68     }
    69     //F32
    70     {
    71         skip_start(itemF32 == NULL, 1,
    72                    "Skipping 1 tests because psMetadataItemAllocF32() failed");
    73         ok(itemF32->type == PS_DATA_F32
    74            && !strncmp(itemF32->name, "itemF32", 10)
    75            && abs(itemF32->data.F32 - 6.66) < FLT_EPSILON
    76            && !strncmp(itemF32->comment, "", 2),
    77            "psMetadataItemAllocF32:    create valid F32 item.");
    78         skip_end();
    79     }
    80     //F64
    81     {
    82         skip_start(itemF64 == NULL, 1,
    83                    "Skipping 1 tests because psMetadataItemAllocF64() failed");
    84         ok(itemF64->type == PS_DATA_F64
    85            && !strncmp(itemF64->name, "itemF64", 10)
    86            && abs(itemF64->data.F64 - 0.666) < DBL_EPSILON
    87            && !strncmp(itemF64->comment, "", 2),
    88            "psMetadataItemAllocF64:    create valid F64 item.");
    89         skip_end();
    90     }
    91     //S8
    92     {
    93         skip_start(itemS8 == NULL, 1,
    94                    "Skipping 1 tests because psMetadataItemAllocS8() failed");
    95         ok(itemS8->type == PS_DATA_S8
    96            && !strncmp(itemS8->name, "itemS8", 10)
    97            && itemS8->data.S8 == 0
    98            && !strncmp(itemS8->comment, "", 2),
    99            "psMetadataItemAllocS8:     create valid S8 item.");
    100         skip_end();
    101     }
    102     //S16
    103     {
    104         skip_start(itemS16 == NULL, 1,
    105                    "Skipping 1 tests because psMetadataItemAllocS16() failed");
    106         ok(itemS16->type == PS_DATA_S16
    107            && !strncmp(itemS16->name, "itemS16", 10)
    108            && itemS16->data.S16 == 1
    109            && !strncmp(itemS16->comment, "", 2),
    110            "psMetadataItemAllocS16:    create valid S16 item.");
    111         skip_end();
    112     }
    113     //S32
    114     {
    115         skip_start(itemS32 == NULL, 1,
    116                    "Skipping 1 tests because psMetadataItemAllocS32() failed");
    117         ok(itemS32->type == PS_DATA_S32
    118            && !strncmp(itemS32->name, "itemS32", 10)
    119            && itemS32->data.S32 == 2
    120            && !strncmp(itemS32->comment, "", 2),
    121            "psMetadataItemAllocS32:    create valid S32 item.");
    122         skip_end();
    123     }
    124     //S64
    125     {
    126         skip_start(itemS64 == NULL, 1,
    127                    "Skipping 1 tests because psMetadataItemAllocS64() failed");
    128         ok(itemS64->type == PS_DATA_S64
    129            && !strncmp(itemS64->name, "itemS64", 10)
    130            && itemS64->data.S64 == 3
    131            && !strncmp(itemS64->comment, "", 2),
    132            "psMetadataItemAllocS64:    create valid S64 item.");
    133         skip_end();
    134     }
    135     //U8
    136     {
    137         skip_start(itemU8 == NULL, 1,
    138                    "Skipping 1 tests because psMetadataItemAllocU8() failed");
    139         ok(itemU8->type == PS_DATA_U8
    140            && !strncmp(itemU8->name, "itemU8", 10)
    141            && itemU8->data.U8 == 0
    142            && !strncmp(itemU8->comment, "", 2),
    143            "psMetadataItemAllocU8:     create valid U8 item.");
    144         skip_end();
    145     }
    146     //U16
    147     {
    148         skip_start(itemU16 == NULL, 1,
    149                    "Skipping 1 tests because psMetadataItemAllocU16() failed");
    150         ok(itemU16->type == PS_DATA_U16
    151            && !strncmp(itemU16->name, "itemU16", 10)
    152            && itemU16->data.U16 == 1
    153            && !strncmp(itemU16->comment, "", 2),
    154            "psMetadataItemAllocU16:    create valid U16 item.");
    155         skip_end();
    156     }
    157     //U32
    158     {
    159         skip_start(itemU32 == NULL, 1,
    160                    "Skipping 1 tests because psMetadataItemAllocU32() failed");
    161         ok(itemU32->type == PS_DATA_U32
    162            && !strncmp(itemU32->name, "itemU32", 10)
    163            && itemU32->data.U32 == 2
    164            && !strncmp(itemU32->comment, "", 2),
    165            "psMetadataItemAllocU32:   create valid U32 item.");
    166         skip_end();
    167     }
    168     //U64
    169     {
    170         skip_start(itemU64 == NULL, 1,
    171                    "Skipping 1 tests because psMetadataItemAllocU64() failed");
    172         ok(itemU64->type == PS_DATA_U64
    173            && !strncmp(itemU64->name, "itemU64", 10)
    174            && itemU64->data.U64 == 3
    175            && !strncmp(itemU64->comment, "", 2),
    176            "psMetadataItemAllocU64:   create valid U64 item.");
    177         skip_end();
    178     }
    179     //Bool
    180     {
    181         skip_start(itemBool == NULL, 1,
    182                    "Skipping 1 tests because psMetadataItemAllocBool() failed");
    183         ok(itemBool->type == PS_DATA_BOOL
    184            && !strncmp(itemBool->name, "itemBool", 10)
    185            && itemBool->data.B
    186            && !strncmp(itemBool->comment, "", 2),
    187            "psMetadataItemAllocBool:  create valid Bool item.");
    188         skip_end();
    189     }
    190 
    191     //Allocate a pointer.  Example= psSphere
    192     {
    193         psSphere *s = psSphereAlloc();
    194         s->r = 1.1;
    195         s->d = 2.1;
    196         psMetadataItem *itemPtr = psMetadataItemAllocPtr("itemPtr", PS_DATA_SPHERE, "", s);
    197         skip_start(itemPtr == NULL, 1,
    198                    "Skipping 1 tests because psMetadataItemAllocPtr() failed");
    199         float r = ((psSphere*)(itemPtr->data.V))->r;
    200         float d = ((psSphere*)(itemPtr->data.V))->d;
    201         ok( itemPtr->type == PS_DATA_SPHERE
    202             && !strncmp(itemPtr->name, "itemPtr", 10)
    203             && abs(r-1.1) < FLT_EPSILON && abs(d-2.1) < FLT_EPSILON
    204             && !strncmp(itemPtr->comment, "", 2),
    205             "psMetadataItemAllocPtr:   create valid ptr (psSphere) item.");
    206         skip_end();
    207         psFree(s);
    208         psFree(itemPtr);
    209     }
    210 
    211     //Try to Allocate an unsupported type with AllocV
    212     {
    213         psMetadataItem *itemNULL = NULL;
    214         psLine *line = psLineAlloc(2);
    215         itemNULL = psMetadataItemAlloc("itemNULL", PS_DATA_LINE, NULL, line);
    216         ok( itemNULL == NULL,
    217             "psMetadataItemAlloc:      return NULL for unsupported type.");
    218         psFree(line);
    219     }
    220 
    221     //Now Allocate the item with Alloc and test MemCheck for it's type.
    222     {
    223         psMetadataItem *itemAllocV = psMetadataItemAlloc("itemAllocV", PS_DATA_S32, NULL, 4);
    224         skip_start(itemAllocV == NULL, 2,
    225                    "Skipping 2 tests because psMetadataItemAllocV() failed");
    226         ok (itemAllocV->type == PS_DATA_S32
    227             && !strncmp(itemAllocV->name, "itemAllocV", 10)
    228             && itemAllocV->data.S32 == 4
    229             && !strncmp(itemAllocV->comment, "", 2),
    230             "psMetadataItemAlloc:      create valid S32 item.");
    231         ok ( psMemCheckMetadataItem(itemAllocV),
    232              "psMemCheckMetadataItem:   return true for valid MetadataItem.");
    233         skip_end();
    234         psFree(itemAllocV);
    235     }
    236 
    237     //Make sure MemCheckItem worked.  Try primitive type.  Expect false.
    238     {
    239         int j = 2;
    240         ok( !psMemCheckMetadataItem(&j),
    241             "psMemCheckMetadataItem:   return false for non-MetadataItem input.");
    242     }
    243 
    244     //Check for Memory Leaks
    245     {
     31        psMemId id = psMemGetId();
     32        psMetadataItem *itemStr = psMetadataItemAllocStr("itemStr", "", "itemStr");
     33        psMetadataItem *itemF32 = psMetadataItemAllocF32("itemF32", "", 6.66);
     34        psMetadataItem *itemF64 = psMetadataItemAllocF64("itemF64", "", 0.666);
     35        psMetadataItem *itemS8 = psMetadataItemAllocS8("itemS8", "", 0);
     36        psMetadataItem *itemS16 = psMetadataItemAllocS16("itemS16", "", 1);
     37        psMetadataItem *itemS32 = psMetadataItemAllocS32("itemS32", "", 2);
     38        psMetadataItem *itemS64 = psMetadataItemAllocS64("itemS64", "", 3);
     39        psMetadataItem *itemU8 = psMetadataItemAllocU8("itemU8", "", 0);
     40        psMetadataItem *itemU16 = psMetadataItemAllocU16("itemU16", "", 1);
     41        psMetadataItem *itemU32 = psMetadataItemAllocU32("itemU32", "", 2);
     42        psMetadataItem *itemU64 = psMetadataItemAllocU64("itemU64", "", 3);
     43        psMetadataItem *itemBool = psMetadataItemAllocBool("itemBool", "", true);
     44   
     45        //First try to free a NULL item
     46        psMetadataItem *nullItem = NULL;
     47        psFree(nullItem);
     48        //Verify correct allocation
     49        //String
     50        {
     51            skip_start(itemStr == NULL, 1,
     52                       "Skipping 1 tests because psMetadataItemAllocStr() failed");
     53            ok(itemStr->type == PS_DATA_STRING
     54               && !strncmp(itemStr->name, "itemStr", 10)
     55               && !strncmp(itemStr->data.V, "itemStr", 10)
     56               && !strncmp(itemStr->comment, "", 2),
     57               "psMetadataItemAllocStr:    create valid string item.");
     58            skip_end();
     59        }
     60        //F32
     61        {
     62            skip_start(itemF32 == NULL, 1,
     63                       "Skipping 1 tests because psMetadataItemAllocF32() failed");
     64            ok(itemF32->type == PS_DATA_F32
     65               && !strncmp(itemF32->name, "itemF32", 10)
     66               && abs(itemF32->data.F32 - 6.66) < FLT_EPSILON
     67               && !strncmp(itemF32->comment, "", 2),
     68               "psMetadataItemAllocF32:    create valid F32 item.");
     69            skip_end();
     70        }
     71        //F64
     72        {
     73            skip_start(itemF64 == NULL, 1,
     74                       "Skipping 1 tests because psMetadataItemAllocF64() failed");
     75            ok(itemF64->type == PS_DATA_F64
     76               && !strncmp(itemF64->name, "itemF64", 10)
     77               && abs(itemF64->data.F64 - 0.666) < DBL_EPSILON
     78               && !strncmp(itemF64->comment, "", 2),
     79               "psMetadataItemAllocF64:    create valid F64 item.");
     80            skip_end();
     81        }
     82        //S8
     83        {
     84            skip_start(itemS8 == NULL, 1,
     85                       "Skipping 1 tests because psMetadataItemAllocS8() failed");
     86            ok(itemS8->type == PS_DATA_S8
     87               && !strncmp(itemS8->name, "itemS8", 10)
     88               && itemS8->data.S8 == 0
     89               && !strncmp(itemS8->comment, "", 2),
     90               "psMetadataItemAllocS8:     create valid S8 item.");
     91            skip_end();
     92        }
     93        //S16
     94        {
     95            skip_start(itemS16 == NULL, 1,
     96                       "Skipping 1 tests because psMetadataItemAllocS16() failed");
     97            ok(itemS16->type == PS_DATA_S16
     98               && !strncmp(itemS16->name, "itemS16", 10)
     99               && itemS16->data.S16 == 1
     100               && !strncmp(itemS16->comment, "", 2),
     101               "psMetadataItemAllocS16:    create valid S16 item.");
     102            skip_end();
     103        }
     104        //S32
     105        {
     106            skip_start(itemS32 == NULL, 1,
     107                       "Skipping 1 tests because psMetadataItemAllocS32() failed");
     108            ok(itemS32->type == PS_DATA_S32
     109               && !strncmp(itemS32->name, "itemS32", 10)
     110               && itemS32->data.S32 == 2
     111               && !strncmp(itemS32->comment, "", 2),
     112               "psMetadataItemAllocS32:    create valid S32 item.");
     113            skip_end();
     114        }
     115        //S64
     116        {
     117            skip_start(itemS64 == NULL, 1,
     118                       "Skipping 1 tests because psMetadataItemAllocS64() failed");
     119            ok(itemS64->type == PS_DATA_S64
     120               && !strncmp(itemS64->name, "itemS64", 10)
     121               && itemS64->data.S64 == 3
     122               && !strncmp(itemS64->comment, "", 2),
     123               "psMetadataItemAllocS64:    create valid S64 item.");
     124            skip_end();
     125        }
     126        //U8
     127        {
     128            skip_start(itemU8 == NULL, 1,
     129                       "Skipping 1 tests because psMetadataItemAllocU8() failed");
     130            ok(itemU8->type == PS_DATA_U8
     131               && !strncmp(itemU8->name, "itemU8", 10)
     132               && itemU8->data.U8 == 0
     133               && !strncmp(itemU8->comment, "", 2),
     134               "psMetadataItemAllocU8:     create valid U8 item.");
     135            skip_end();
     136        }
     137        //U16
     138        {
     139            skip_start(itemU16 == NULL, 1,
     140                       "Skipping 1 tests because psMetadataItemAllocU16() failed");
     141            ok(itemU16->type == PS_DATA_U16
     142               && !strncmp(itemU16->name, "itemU16", 10)
     143               && itemU16->data.U16 == 1
     144               && !strncmp(itemU16->comment, "", 2),
     145               "psMetadataItemAllocU16:    create valid U16 item.");
     146            skip_end();
     147        }
     148        //U32
     149        {
     150            skip_start(itemU32 == NULL, 1,
     151                       "Skipping 1 tests because psMetadataItemAllocU32() failed");
     152            ok(itemU32->type == PS_DATA_U32
     153               && !strncmp(itemU32->name, "itemU32", 10)
     154               && itemU32->data.U32 == 2
     155               && !strncmp(itemU32->comment, "", 2),
     156               "psMetadataItemAllocU32:   create valid U32 item.");
     157            skip_end();
     158        }
     159        //U64
     160        {
     161            skip_start(itemU64 == NULL, 1,
     162                       "Skipping 1 tests because psMetadataItemAllocU64() failed");
     163            ok(itemU64->type == PS_DATA_U64
     164               && !strncmp(itemU64->name, "itemU64", 10)
     165               && itemU64->data.U64 == 3
     166               && !strncmp(itemU64->comment, "", 2),
     167               "psMetadataItemAllocU64:   create valid U64 item.");
     168            skip_end();
     169        }
     170        //Bool
     171        {
     172            skip_start(itemBool == NULL, 1,
     173                       "Skipping 1 tests because psMetadataItemAllocBool() failed");
     174            ok(itemBool->type == PS_DATA_BOOL
     175               && !strncmp(itemBool->name, "itemBool", 10)
     176               && itemBool->data.B
     177               && !strncmp(itemBool->comment, "", 2),
     178               "psMetadataItemAllocBool:  create valid Bool item.");
     179            skip_end();
     180        }
     181   
     182        //Allocate a pointer.  Example= psSphere
     183        {
     184            psSphere *s = psSphereAlloc();
     185            s->r = 1.1;
     186            s->d = 2.1;
     187            psMetadataItem *itemPtr = psMetadataItemAllocPtr("itemPtr", PS_DATA_SPHERE, "", s);
     188            skip_start(itemPtr == NULL, 1,
     189                       "Skipping 1 tests because psMetadataItemAllocPtr() failed");
     190            float r = ((psSphere*)(itemPtr->data.V))->r;
     191            float d = ((psSphere*)(itemPtr->data.V))->d;
     192            ok( itemPtr->type == PS_DATA_SPHERE
     193                && !strncmp(itemPtr->name, "itemPtr", 10)
     194                && abs(r-1.1) < FLT_EPSILON && abs(d-2.1) < FLT_EPSILON
     195                && !strncmp(itemPtr->comment, "", 2),
     196                "psMetadataItemAllocPtr:   create valid ptr (psSphere) item.");
     197            skip_end();
     198            psFree(s);
     199            psFree(itemPtr);
     200        }
     201   
     202        //Try to Allocate an unsupported type with AllocV
     203        {
     204            psMetadataItem *itemNULL = NULL;
     205            psLine *line = psLineAlloc(2);
     206            itemNULL = psMetadataItemAlloc("itemNULL", PS_DATA_LINE, NULL, line);
     207            ok( itemNULL == NULL,
     208                "psMetadataItemAlloc:      return NULL for unsupported type.");
     209            psFree(line);
     210        }
     211   
     212        //Now Allocate the item with Alloc and test MemCheck for it's type.
     213        {
     214            psMetadataItem *itemAllocV = psMetadataItemAlloc("itemAllocV", PS_DATA_S32, NULL, 4);
     215            skip_start(itemAllocV == NULL, 2,
     216                       "Skipping 2 tests because psMetadataItemAllocV() failed");
     217            ok (itemAllocV->type == PS_DATA_S32
     218                && !strncmp(itemAllocV->name, "itemAllocV", 10)
     219                && itemAllocV->data.S32 == 4
     220                && !strncmp(itemAllocV->comment, "", 2),
     221                "psMetadataItemAlloc:      create valid S32 item.");
     222            ok ( psMemCheckMetadataItem(itemAllocV),
     223                 "psMemCheckMetadataItem:   return true for valid MetadataItem.");
     224            skip_end();
     225            psFree(itemAllocV);
     226        }
     227   
     228        //Make sure MemCheckItem worked.  Try primitive type.  Expect false.
     229        {
     230            int j = 2;
     231            ok( !psMemCheckMetadataItem(&j),
     232                "psMemCheckMetadataItem:   return false for non-MetadataItem input.");
     233        }
     234   
    246235        psFree(itemStr);
    247236        psFree(itemF32);
    … …  
    256245        psFree(itemU64);
    257246        psFree(itemBool);
    258         checkMem();
     247        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    259248    }
    260249
    261 }
    262 
    263 void testMDAlloc_AddItem(void)
    264 {
    265     note("  >>>Test 2:  psMetadataAlloc & psMetadataAdd Fxns");
    266     psMetadata *md = NULL;
    267     md = psMetadataAlloc();
    268     psMetadata *md1 = psMetadataAlloc();
    269     psMetadata *md2 = psMetadataAlloc();
    270     //test MemCheck for a valid psMetadata
     250
     251    // psMetadataAlloc & psMetadataAdd Fxns");
    271252    {
    272         ok( psMemCheckMetadata(md),
    273             "psMemCheckMetadata:       return true for valid Metadata.");
    274     }
    275     //Make sure MemCheck worked.  Try primitive type.  Expect false.
    276     {
    277         int j = 2;
    278         ok( !psMemCheckMetadata(&j),
    279             "psMemCheckMetadata:       return false for non-Metadata input.");
    280     }
    281     //Return false for attempt to add a psMetadataItem with no name.
    282     {
    283         ok( !psMetadataAdd(md1, PS_LIST_HEAD, NULL, PS_DATA_S32, "", 1),
    284             "psMetadataAdd:            return false for adding item with no name.");
    285     }
    286     psFree(md1);
    287     md1 = psMetadataAlloc();
    288 
    289     //Return false for NULL metadata input
    290     psMetadataItem *item = psMetadataItemAllocBool("item", "", true);
    291     {
    292         ok( !psMetadataAddItem(NULL, item, PS_LIST_HEAD, PS_META_DEFAULT),
    293             "psMetadataAddItem:        return false for NULL metadata input.");
    294     }
    295     //Return false for metadata with NULL hash
    296     psFree(md1->hash);
    297     md1->hash = NULL;
    298     {
    299         ok( !psMetadataAddItem(md1, item, PS_LIST_HEAD, PS_META_DEFAULT),
    300             "psMetadataAddItem:        return false for metadata with no hash.");
    301     }
    302     psFree(md1);
    303     //Return false for metadata with NULL list
    304     psFree(md2->list);
    305     md2->list = NULL;
    306     {
    307         ok( !psMetadataAddItem(md2, item, PS_LIST_HEAD, PS_META_DEFAULT),
    308             "psMetadataAddItem:        return false for metadata with no list.");
    309     }
    310     psFree(md2);
    311     //Return false for NULL psMetadataItem input
    312     {
    313         ok( !psMetadataAddItem(md, NULL, PS_LIST_HEAD, PS_META_DEFAULT),
    314             "psMetadataAddItem:        return false for NULL item input.");
    315     }
    316     //Return false for psMetadataItem with NULL name
    317     psFree(item->name);
    318     item->name = NULL;
    319     {
    320         ok( !psMetadataAddItem(md, item, PS_LIST_HEAD, PS_META_DEFAULT),
    321             "psMetadataAddItem:        return false for item with no name.");
    322     }
    323     psFree(item);
    324 
    325     psMetadata *itemMD = psMetadataAlloc();
    326     psMetadataAddS32(itemMD, PS_LIST_HEAD, "s", PS_META_DUPLICATE_OK, "", 2);
    327     psMetadataItem *item2 = psMetadataItemAllocS32("s", "", 2);
    328 
    329     //Return true for addition of multi
    330     {
    331         ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
    332             "psMetadataAddItem:        return true for addition of PS_DATA_METADATA_MULTI.");
    333     }
    334     psFree(item2);
    335     psFree(itemMD);
    336 
    337     //Existing entry with duplicate key found.
    338     psMetadataAddS32(md, PS_LIST_HEAD, "S32", 0, "", 1);
    339     item2 = psMetadataItemAllocS32("S32", "", 1);
    340     //FLAG = PS_META_REPLACE
    341     {
    342         ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_REPLACE),
    343             "psMetadataAddItem:        return true for PS_META_REPLACE flag.");
    344     }
    345     //FLAG = PS_META_DUPLICATE_OK
    346     {
    347         ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
    348             "psMetadataAddItem:        return true for PS_META_DUPLICATE_OK flag.");
    349     }
    350     /*        SEE BELOW.  TEST CASE REDONE b/c item2 in md was already a MULTI
    351     //FLAG = PS_META_NO_REPLACE
    352     {
    353         ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_NO_REPLACE),
    354             "psMetadataAddItem:        return true for PS_META_NO_REPLACE flag.");
    355     }
    356     */
    357     //FLAG = PS_META_DEFAULT
    358     {
    359         ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DEFAULT),
    360             "psMetadataAddItem:        return false for PS_META_DEFAULT flag.");
    361     }
    362 
    363     //Return false for attempting to add an element twice with flag NO_REPLACE
    364     {
    365         psMetadata *norep = psMetadataAlloc();
    366         psMetadataAddS32(norep, PS_LIST_HEAD, "S32", 0, "", 1);
    367         psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1);
    368         ok( psMetadataAddItem(norep, item666, PS_LIST_TAIL, PS_META_NO_REPLACE),
    369             "psMetadataAddItem:        return true for PS_META_NO_REPLACE flag.");
    370         psFree(item666);
    371         psFree(norep);
    372     }
    373     //Return false for bad list location
    374     {
    375         psMetadata *emptymeta = psMetadataAlloc();
    376         psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1);
    377         ok( !psMetadataAddItem(emptymeta, item666, -100, PS_META_NO_REPLACE),
    378             "psMetadataAddItem:        return false for invalid list location.");
    379         psFree(item666);
    380         psFree(emptymeta);
    381     }
    382     //Return false for trying to add to MULTI with broken list element.
    383     {
    384         psMetadata *broken_list = psMetadataAlloc();
    385         psMetadataAddS32(broken_list, PS_LIST_HEAD, "S32", 0, "", 1);
    386         psMetadataAddS32(broken_list, PS_LIST_TAIL, "S32", PS_META_DUPLICATE_OK, "", 1);
    387         psMetadataItem *brokenptr = psMetadataLookup(broken_list, "S32");
    388         if (brokenptr->type != PS_DATA_METADATA_MULTI)
    389             printf("\nError, Error\n");
    390         else
    391         {
    392             psFree(brokenptr->data.list);
    393             brokenptr->data.list = NULL;
    394         }
    395         psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1);
    396         ok( !psMetadataAddItem(broken_list, item666, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
    397             "psMetadataAddItem:        return false for MULTI with NULL list.");
    398         psFree(item666);
    399         psFree(broken_list);
    400     }
    401 
    402     //Attempt to add a MULTI
    403     psFree(item2);
    404     item2 = NULL;
    405     psMetadata *xxx = psMetadataAlloc();
    406     psMetadataAddS32(xxx, PS_LIST_TAIL, "new S32", 0, "", 1);
    407     item2 = psMetadataItemAllocS32("new S32", "", 1);
    408     psMetadataAddItem(xxx, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK);
    409     psFree(item2);
    410     item2 = psMetadataLookup(xxx, "new S32");
    411     {
    412         ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
    413             "psMetadataAddItem:        return true for new MULTI item");
    414     }
    415     //Attempt to add a 2nd reference of a MULTI to the originating metadata container
    416     {
    417         ok( !psMetadataAddItem(xxx, item2, PS_LIST_TAIL, PS_META_NO_REPLACE),
    418             "psMetadataAddItem:        return false for attempt to add 2nd reference"
    419             " of a MULTI");
    420     }
    421     psFree(xxx);
    422 
    423     //No existing entries or duplicates found
    424     item2 = psMetadataItemAllocS32("new", "", 2);
    425     {
    426         ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
    427             "psMetadataAddItem:        return true for new item.");
    428     }
    429 
    430     //Check for Memory leaks
    431     {
     253        psMemId id = psMemGetId();
     254        psMetadata *md = NULL;
     255        md = psMetadataAlloc();
     256        psMetadata *md1 = psMetadataAlloc();
     257        psMetadata *md2 = psMetadataAlloc();
     258        //test MemCheck for a valid psMetadata
     259        {
     260            ok( psMemCheckMetadata(md),
     261                "psMemCheckMetadata:       return true for valid Metadata.");
     262        }
     263        //Make sure MemCheck worked.  Try primitive type.  Expect false.
     264        {
     265            int j = 2;
     266            ok( !psMemCheckMetadata(&j),
     267                "psMemCheckMetadata:       return false for non-Metadata input.");
     268        }
     269        //Return false for attempt to add a psMetadataItem with no name.
     270        {
     271            ok( !psMetadataAdd(md1, PS_LIST_HEAD, NULL, PS_DATA_S32, "", 1),
     272                "psMetadataAdd:            return false for adding item with no name.");
     273        }
     274        psFree(md1);
     275        md1 = psMetadataAlloc();
     276   
     277        //Return false for NULL metadata input
     278        psMetadataItem *item = psMetadataItemAllocBool("item", "", true);
     279        {
     280            ok( !psMetadataAddItem(NULL, item, PS_LIST_HEAD, PS_META_DEFAULT),
     281                "psMetadataAddItem:        return false for NULL metadata input.");
     282        }
     283        //Return false for metadata with NULL hash
     284        psFree(md1->hash);
     285        md1->hash = NULL;
     286        {
     287            ok( !psMetadataAddItem(md1, item, PS_LIST_HEAD, PS_META_DEFAULT),
     288                "psMetadataAddItem:        return false for metadata with no hash.");
     289        }
     290        psFree(md1);
     291        //Return false for metadata with NULL list
     292        psFree(md2->list);
     293        md2->list = NULL;
     294        {
     295            ok( !psMetadataAddItem(md2, item, PS_LIST_HEAD, PS_META_DEFAULT),
     296                "psMetadataAddItem:        return false for metadata with no list.");
     297        }
     298        psFree(md2);
     299        //Return false for NULL psMetadataItem input
     300        {
     301            ok( !psMetadataAddItem(md, NULL, PS_LIST_HEAD, PS_META_DEFAULT),
     302                "psMetadataAddItem:        return false for NULL item input.");
     303        }
     304        //Return false for psMetadataItem with NULL name
     305        psFree(item->name);
     306        item->name = NULL;
     307        {
     308            ok( !psMetadataAddItem(md, item, PS_LIST_HEAD, PS_META_DEFAULT),
     309                "psMetadataAddItem:        return false for item with no name.");
     310        }
     311        psFree(item);
     312   
     313        psMetadata *itemMD = psMetadataAlloc();
     314        psMetadataAddS32(itemMD, PS_LIST_HEAD, "s", PS_META_DUPLICATE_OK, "", 2);
     315        psMetadataItem *item2 = psMetadataItemAllocS32("s", "", 2);
     316   
     317        //Return true for addition of multi
     318        {
     319            ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
     320                "psMetadataAddItem:        return true for addition of PS_DATA_METADATA_MULTI.");
     321        }
     322        psFree(item2);
     323        psFree(itemMD);
     324   
     325        //Existing entry with duplicate key found.
     326        psMetadataAddS32(md, PS_LIST_HEAD, "S32", 0, "", 1);
     327        item2 = psMetadataItemAllocS32("S32", "", 1);
     328        //FLAG = PS_META_REPLACE
     329        {
     330            ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_REPLACE),
     331                "psMetadataAddItem:        return true for PS_META_REPLACE flag.");
     332        }
     333        //FLAG = PS_META_DUPLICATE_OK
     334        {
     335            ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
     336                "psMetadataAddItem:        return true for PS_META_DUPLICATE_OK flag.");
     337        }
     338        /*        SEE BELOW.  TEST CASE REDONE b/c item2 in md was already a MULTI
     339        //FLAG = PS_META_NO_REPLACE
     340        {
     341            ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_NO_REPLACE),
     342                "psMetadataAddItem:        return true for PS_META_NO_REPLACE flag.");
     343        }
     344        */
     345        //FLAG = PS_META_DEFAULT
     346        {
     347            ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DEFAULT),
     348                "psMetadataAddItem:        return false for PS_META_DEFAULT flag.");
     349        }
     350   
     351        //Return false for attempting to add an element twice with flag NO_REPLACE
     352        {
     353            psMetadata *norep = psMetadataAlloc();
     354            psMetadataAddS32(norep, PS_LIST_HEAD, "S32", 0, "", 1);
     355            psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1);
     356            ok( psMetadataAddItem(norep, item666, PS_LIST_TAIL, PS_META_NO_REPLACE),
     357                "psMetadataAddItem:        return true for PS_META_NO_REPLACE flag.");
     358            psFree(item666);
     359            psFree(norep);
     360        }
     361        //Return false for bad list location
     362        {
     363            psMetadata *emptymeta = psMetadataAlloc();
     364            psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1);
     365            ok( !psMetadataAddItem(emptymeta, item666, -100, PS_META_NO_REPLACE),
     366                "psMetadataAddItem:        return false for invalid list location.");
     367            psFree(item666);
     368            psFree(emptymeta);
     369        }
     370        //Return false for trying to add to MULTI with broken list element.
     371        {
     372            psMetadata *broken_list = psMetadataAlloc();
     373            psMetadataAddS32(broken_list, PS_LIST_HEAD, "S32", 0, "", 1);
     374            psMetadataAddS32(broken_list, PS_LIST_TAIL, "S32", PS_META_DUPLICATE_OK, "", 1);
     375            psMetadataItem *brokenptr = psMetadataLookup(broken_list, "S32");
     376            if (brokenptr->type != PS_DATA_METADATA_MULTI)
     377                printf("\nError, Error\n");
     378            else
     379            {
     380                psFree(brokenptr->data.list);
     381                brokenptr->data.list = NULL;
     382            }
     383            psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1);
     384            ok( !psMetadataAddItem(broken_list, item666, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
     385                "psMetadataAddItem:        return false for MULTI with NULL list.");
     386            psFree(item666);
     387            psFree(broken_list);
     388        }
     389   
     390        //Attempt to add a MULTI
     391        psFree(item2);
     392        item2 = NULL;
     393        psMetadata *xxx = psMetadataAlloc();
     394        psMetadataAddS32(xxx, PS_LIST_TAIL, "new S32", 0, "", 1);
     395        item2 = psMetadataItemAllocS32("new S32", "", 1);
     396        psMetadataAddItem(xxx, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK);
     397        psFree(item2);
     398        item2 = psMetadataLookup(xxx, "new S32");
     399        {
     400            ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
     401                "psMetadataAddItem:        return true for new MULTI item");
     402        }
     403        //Attempt to add a 2nd reference of a MULTI to the originating metadata container
     404        {
     405            ok( !psMetadataAddItem(xxx, item2, PS_LIST_TAIL, PS_META_NO_REPLACE),
     406                "psMetadataAddItem:        return false for attempt to add 2nd reference"
     407                " of a MULTI");
     408        }
     409        psFree(xxx);
     410   
     411        //No existing entries or duplicates found
     412        item2 = psMetadataItemAllocS32("new", "", 2);
     413        {
     414            ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
     415                "psMetadataAddItem:        return true for new item.");
     416        }
     417   
    432418        psFree(item2);
    433419        psFree(md);
    434         checkMem();
     420        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     421    }
     422   
     423
     424    // psMetadataIteratorAlloc
     425    {
     426        psMemId id = psMemGetId();
     427        psMetadata *md = psMetadataAlloc();
     428        psMetadata *md2 = NULL;
     429        psMetadataAddS32(md, PS_LIST_HEAD, "S32_1", PS_META_NO_REPLACE, "", 1);
     430        psMetadataAddS32(md, PS_LIST_TAIL, "S32_2", PS_META_DEFAULT, "", 2);
     431   
     432        psMetadataIterator *iter = NULL;
     433        //Return NULL for NULL metadata input
     434        {
     435            iter = psMetadataIteratorAlloc(md2, PS_LIST_HEAD, NULL);
     436            ok( iter == NULL,
     437                "psMetadataIteratorAlloc:  return NULL for NULL metadata input.");
     438        }
     439        //Return NULL for metadata with no List
     440        md2 = psMetadataAlloc();
     441        psFree(md2->list);
     442        md2->list = NULL;
     443        {
     444            iter = psMetadataIteratorAlloc(md2, PS_LIST_HEAD, NULL);
     445            ok( iter == NULL,
     446                "psMetadataIteratorAlloc:  return NULL for metadata with no list.");
     447        }
     448        psFree(md2);
     449   
     450        //Return newly allocated MetadataIterator, regex=NULL
     451        {
     452            iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
     453            ok( iter != NULL,
     454                "psMetadataIteratorAlloc:  return valid iterator for valid inputs, regex=NULL.");
     455        }
     456        //Return NULL for attempt to allocate an iterator with unfound regex.
     457        psFree(iter);
     458        iter = NULL;
     459        {
     460            iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "IPP.machines.sky");
     461            ok( iter == NULL,
     462                "psMetadataIteratorAlloc:  return NULL for not-found regex input");
     463        }
     464        //Return NULL for invalid regex input.
     465        {
     466            iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "IPP.machines.sky\\");
     467            ok( iter == NULL,
     468                "psMetadataIteratorAlloc:  return NULL for invalid regex input");
     469        }
     470        //Return properly allocated iterator for valid non-null regex input.
     471        {
     472            iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "S32_");
     473            ok( iter != NULL,
     474                "psMetadataIteratorAlloc:  return valid iterator for valid regex input");
     475        }
     476   
     477        //Check for Memory leaks
     478        {
     479            psFree(iter);
     480            psFree(md);
     481            checkMem();
     482        }
     483        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    435484    }
    436485}
    437 
    438 void testIterAlloc(void)
    439 {
    440     note("  >>>Test 3:  psMetadataIteratorAlloc");
    441     psMetadata *md = psMetadataAlloc();
    442     psMetadata *md2 = NULL;
    443     psMetadataAddS32(md, PS_LIST_HEAD, "S32_1", PS_META_NO_REPLACE, "", 1);
    444     psMetadataAddS32(md, PS_LIST_TAIL, "S32_2", PS_META_DEFAULT, "", 2);
    445 
    446     psMetadataIterator *iter = NULL;
    447     //Return NULL for NULL metadata input
    448     {
    449         iter = psMetadataIteratorAlloc(md2, PS_LIST_HEAD, NULL);
    450         ok( iter == NULL,
    451             "psMetadataIteratorAlloc:  return NULL for NULL metadata input.");
    452     }
    453     //Return NULL for metadata with no List
    454     md2 = psMetadataAlloc();
    455     psFree(md2->list);
    456     md2->list = NULL;
    457     {
    458         iter = psMetadataIteratorAlloc(md2, PS_LIST_HEAD, NULL);
    459         ok( iter == NULL,
    460             "psMetadataIteratorAlloc:  return NULL for metadata with no list.");
    461     }
    462     psFree(md2);
    463 
    464     //Return newly allocated MetadataIterator, regex=NULL
    465     {
    466         iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
    467         ok( iter != NULL,
    468             "psMetadataIteratorAlloc:  return valid iterator for valid inputs, regex=NULL.");
    469     }
    470     //Return NULL for attempt to allocate an iterator with unfound regex.
    471     psFree(iter);
    472     iter = NULL;
    473     {
    474         iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "IPP.machines.sky");
    475         ok( iter == NULL,
    476             "psMetadataIteratorAlloc:  return NULL for not-found regex input");
    477     }
    478     //Return NULL for invalid regex input.
    479     {
    480         iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "IPP.machines.sky\\");
    481         ok( iter == NULL,
    482             "psMetadataIteratorAlloc:  return NULL for invalid regex input");
    483     }
    484     //Return properly allocated iterator for valid non-null regex input.
    485     {
    486         iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "S32_");
    487         ok( iter != NULL,
    488             "psMetadataIteratorAlloc:  return valid iterator for valid regex input");
    489     }
    490 
    491     //Check for Memory leaks
    492     {
    493         psFree(iter);
    494         psFree(md);
    495         checkMem();
    496     }
    497 }
    498 

  • trunk/psLib/test/types/tap_psMetadata_manip.c

    r10822 r12781  
    1010 *
    1111 */
    12 
    1312#include <pslib.h>
    1413#include <string.h>
    15 
    1614#include "tap.h"
    1715#include "pstap.h"
    1816
    19 void testIter(void);
    20 void testLookups(void);
    21 void testRemoves(void);
    2217
    2318int main(void)
    2419{
    25     plan_tests(48);
    26 
    27     note("psMetadataLookup, Remove, and Iterator Fxns");
    28 
    29     testLookups();
    30     testRemoves();
    31     testIter();
    32 
    33     done();
    34 }
    35 
    36 void testLookups(void)
    37 {
    38     note("  >>>Test 1:  psMetadataLookup Functions");
    39     psMetadata *md = psMetadataAlloc();
    40     psMetadataAddStr(md, PS_LIST_TAIL, "itemStr", 0, "I am a string", "GNIRTS");
    41     psMetadataAddBool(md, PS_LIST_TAIL, "itemBool", 0, "I am a boolean", true);
    42     psMetadataAddS8(md, PS_LIST_TAIL, "itemS8", 0, "I am S8", 6);
    43     psMetadataAddS16(md, PS_LIST_TAIL, "itemS16", 0, "I am S16", -666);
    44     psMetadataAddS32(md, PS_LIST_TAIL, "itemS32", 0, "I am a integer", 55);
    45     psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", 0, "I am S64", 666);
    46     psMetadataAddU8(md, PS_LIST_TAIL, "itemU8", 0, "I am U8", 6);
    47     psMetadataAddU16(md, PS_LIST_TAIL, "itemU16", 0, "I am U16", 666);
    48     psMetadataAddU32(md, PS_LIST_TAIL, "itemU32", 0, "I am U32", 666);
    49     psMetadataAddU64(md, PS_LIST_TAIL, "itemU64", 0, "I am U64", 666);
    50     psMetadataAddF32(md, PS_LIST_TAIL, "itemF32", 0, NULL, 3.14);
    51     psMetadataAddF64(md, PS_LIST_TAIL, "itemF64", 0, "", 6.28);
    52     psSphere *sphere = psSphereAlloc();
    53     sphere->r = 6.66;
    54     sphere->d = 666.666;
    55     psMetadataAddPtr(md, PS_LIST_HEAD, "ptr", PS_DATA_SPHERE, "", sphere);
    56     //    psMetadataAddPtr(md, PS_LIST_TAIL, "ptr", PS_DATA_METADATA_MULTI, "", sphere);
    57     psTime *time;
    58     time = psTimeAlloc(PS_TIME_TAI);
    59     time->sec = 1000;
    60     time->nsec = 25;
    61     time->leapsecond = true;
    62     psMetadataAddTime(md, PS_LIST_TAIL, "time01", 0, "I am time", time);
    63     psMetadata *newMD = psMetadataAlloc();
    64     psMetadataAddS32(newMD, PS_LIST_TAIL, "1", 0, "", 666);
    65     psMetadataAddMetadata(md, PS_LIST_TAIL, "metadata7", 0, "I am a metadata", newMD);
    66 
    67     //Lookup Standard number-types (valid cases)
    68     //U8
     20    psLogSetFormat("HLNM");
     21    psLogSetLevel(PS_LOG_INFO);
     22    plan_tests(50);
     23    // psMetadataLookup, Remove, and Iterator Fxns
     24
     25
     26    // psMetadataLookup Functions
    6927    {
    70         bool status = false;
    71         psU8 u8 = 0;
    72         u8 = psMetadataLookupU8(&status, md, "itemU8");
    73         ok( status && u8 == 6,
    74             "psMetadataLookupU8:     return correct U8 value on lookup.");
    75     }
    76     //U16
    77     {
    78         bool status = false;
    79         psU16 u16 = 0;
    80         u16 = psMetadataLookupU16(&status, md, "itemU16");
    81         ok( status && u16 == 666,
    82             "psMetadataLookupU16:    return correct U16 value on lookup.");
    83     }
    84     //U32
    85     {
    86         bool status = false;
    87         psU32 u32 = 0;
    88         u32 = psMetadataLookupU32(&status, md, "itemU32");
    89         ok( status && u32 == 666,
    90             "psMetadataLookupU32:    return correct U32 value on lookup.");
    91     }
    92     //U64
    93     {
    94         bool status = false;
    95         psU64 u64 = 0;
    96         u64 = psMetadataLookupU64(&status, md, "itemU64");
    97         ok( status && u64 == 666,
    98             "psMetadataLookupU64:    return correct U64 value on lookup.");
    99     }
    100     //S8
    101     {
    102         bool status = false;
    103         psS8 s8 = 0;
    104         s8 = psMetadataLookupS8(&status, md, "itemS8");
    105         ok( status && s8 == 6,
    106             "psMetadataLookupS8:     return correct S8 value on lookup.");
    107     }
    108     //S16
    109     {
    110         bool status = false;
    111         psS16 s16 = 0;
    112         s16 = psMetadataLookupS16(&status, md, "itemS16");
    113         ok( status && s16 == -666,
    114             "psMetadataLookupS16:    return correct S16 value on lookup.");
    115     }
    116     //S32
    117     {
    118         bool status = false;
    119         psS32 s32 = 0;
    120         s32 = psMetadataLookupS32(&status, md, "itemS32");
    121         ok( status && s32 == 55,
    122             "psMetadataLookupS32:    return correct S32 value on lookup.");
    123     }
    124     //S64
    125     {
    126         bool status = false;
    127         psS64 s64 = 0;
    128         s64 = psMetadataLookupS64(&status, md, "itemS64");
    129         ok( status && s64 == 666,
    130             "psMetadataLookupS64:    return correct S64 value on lookup.");
    131     }
    132     //F32
    133     {
    134         bool status = false;
    135         psF32 f32 = 0;
    136         f32 = psMetadataLookupF32(&status, md, "itemF32");
    137         ok( status && abs(f32 - 3.14) < FLT_EPSILON,
    138             "psMetadataLookupF32:    return correct F32 value on lookup.");
    139     }
    140     //F64
    141     {
    142         bool status = false;
    143         psF64 f64 = 0;
    144         f64 = psMetadataLookupF64(&status, md, "itemF64");
    145         ok( status && abs(f64 - 6.28) < DBL_EPSILON,
    146             "psMetadataLookupF64:    return correct F64 value on lookup.");
    147     }
    148     //Bool
    149     {
    150         bool status = false;
    151         bool stat = false;
    152         stat = psMetadataLookupBool(&status, md, "itemBool");
    153         ok( status && stat,
    154             "psMetadataLookupBool:   return correct Bool value on lookup.");
    155     }
    156     //String
    157     {
    158         bool status = false;
    159         psString str = NULL;
    160         str = psMetadataLookupStr(&status, md, "itemStr");
    161         ok( status && !strncmp(str, "GNIRTS", 8),
    162             "psMetadataLookupStr:   return correct String value on lookup.");
    163     }
    164     //Pointer
    165     {
    166         bool status = false;
    167         psSphere *sph = NULL;
    168         sph = (psSphere*)(psMetadataLookupPtr(&status, md, "ptr"));
    169         ok( status && sph != NULL && abs(sph->r-6.66) < FLT_EPSILON,
    170             "psMetadataLookupPtr:   return correct pointer value on lookup.");
    171     }
    172     //Time
    173     {
    174         bool status = false;
    175         psTime *t = NULL;
    176         t = psMetadataLookupTime(&status, md, "time01");
    177         ok( status && t->sec == 1000,
    178             "psMetadataLookupTime:  return correct time value on lookup.");
    179     }
    180     //Metadata
    181     {
    182         bool status = false;
    183         psMetadata *mdtemp = NULL;
    184         mdtemp = psMetadataLookupMetadata(&status, md, "metadata7");
    185         psMetadataItem *itemtemp = psMetadataGet(mdtemp, PS_LIST_HEAD);
    186         ok( status && itemtemp->type == PS_DATA_S32 && itemtemp->data.S32 == 666,
    187             "psMetadataLookupMD:    return correct metadata value on lookup.");
    188     }
    189 
    190     //Try Negatives and non-standard lookup cases
    191     //String  - invalid key name
    192     {
    193         bool status = false;
    194         psString str = NULL;
    195         str = psMetadataLookupStr(&status, md, "item");
    196         ok( !status && str == NULL,
    197             "psMetadataLookupStr:   return NULL for incorrect key.");
    198         str = NULL;
    199         str = psMetadataLookupStr(NULL, md, "item");
    200         ok( str == NULL,
    201             "psMetadataLookupStr:   return NULL for incorrect key (& NULL status).");
    202     }
    203     //String - wrong key->  lookup s8 data
    204     {
    205         bool status = false;
    206         psString str = NULL;
    207         str = psMetadataLookupStr(&status, md, "itemS8");
    208         ok( !status && str == NULL,
    209             "psMetadataLookupStr:   return NULL for incorrect key .");
    210         str = NULL;
    211         str = psMetadataLookupStr(NULL, md, "itemS8");
    212         ok( str == NULL,
    213             "psMetadataLookupStr:   return NULL for incorrect key (& NULL status).");
    214     }
    215     //Pointer - invalid key name
    216     {
    217         bool status = false;
    218         psSphere *sph = NULL;
    219         sph = psMetadataLookupPtr(&status, md, "item");
    220         ok( !status && sph == NULL,
    221             "psMetadataLookupPtr:   return NULL for incorrect key.");
    222     }
    223     //Pointer - wrong key -> lookup s8 data
    224     {
    225         bool status = false;
    226         psSphere *sph = NULL;
    227         sph = psMetadataLookupPtr(&status, md, "itemS8");
    228         ok( !status && sph == NULL,
    229             "psMetadataLookupPtr:   return NULL for incorrect key.");
    230     }
    231 
    232     //Pointer**  - lookup a PS_DATA_METADATA_MULTI
    233     {
    234         psMetadata *metadata = psMetadataAlloc();
    235         psMetadataItem *multi = psMetadataItemAlloc("ptr", PS_DATA_METADATA_MULTI, "", NULL);
    236         psMetadataAddItem(metadata, multi, PS_LIST_HEAD, PS_META_DUPLICATE_OK);
    237         psMetadataAddPtr(metadata, PS_LIST_TAIL, "ptr",
    238                          PS_DATA_SPHERE | PS_META_DUPLICATE_OK, "", sphere);
    239         psSphere *s = psSphereAlloc();
    240         s->r = 0.666;
    241         psMetadataAddPtr(metadata, PS_LIST_TAIL, "ptr", PS_DATA_SPHERE | PS_META_DUPLICATE_OK, "", s);
    242         psFree(s);
    243         psMetadataItem *metadataItem = NULL;
    244         metadataItem = psMetadataLookup(metadata, "ptr");
    245         bool status = false;
    246         psSphere *sph = NULL;
    247         sph = (psSphere*)(psMetadataLookupPtr(&status, metadata, "ptr"));
    248         ok( status && sph != NULL && fabs(sph->r - 6.66) < FLT_EPSILON,
    249             "psMetadataLookupPtr:   return correct value on lookup of MULTI item.");
    250         psFree(metadata);
    251         psFree(multi);
    252     }
    253 
    254     //Metadata - invalid key name
    255     {
    256         bool status = false;
    257         psMetadata *met = NULL;
    258         met = psMetadataLookupMetadata(&status, md, "item");
    259         ok( !status && met == NULL,
    260             "psMetadataLookupMD:   return NULL for incorrect key.");
    261         met = NULL;
    262         met = psMetadataLookupMetadata(NULL, md, "item");
    263         ok( met == NULL,
    264             "psMetadataLookupMD:   return NULL for incorrect key (& NULL status).");
    265     }
    266     //Metadata - wrong key -> lookup s8 data
    267     {
    268         bool status = false;
    269         psMetadata *met = NULL;
    270         met = psMetadataLookupMetadata(&status, md, "itemS8");
    271         ok( !status && met == NULL,
    272             "psMetadataLookupMD:   return NULL for incorrect key (& NULL status).");
    273         met = NULL;
    274         met = psMetadataLookupMetadata(NULL, md, "itemS8");
    275         ok( met == NULL,
    276             "psMetadataLookupMD:   return NULL for incorrect key.");
    277     }
    278     //Time - invalid key name
    279     {
    280         bool status = false;
    281         psTime *time = NULL;
    282         time = psMetadataLookupTime(&status, md, "item");
    283         ok( !status && time == NULL,
    284             "psMetadataLookupTime:   return NULL for incorrect key.");
    285         time = NULL;
    286         time = psMetadataLookupTime(NULL, md, "item");
    287         ok( time == NULL,
    288             "psMetadataLookupTime:   return NULL for incorrect key (& NULL status).");
    289     }
    290     //Time - wrong key -> lookup s8 data
    291     {
    292         bool status = false;
    293         psTime *time = NULL;
    294         time = psMetadataLookupTime(&status, md, "itemS8");
    295         ok( !status && time == NULL,
    296             "psMetadataLookupTime:   return NULL for incorrect key.");
    297         time = NULL;
    298         time = psMetadataLookupTime(NULL, md, "itemS8");
    299         ok( time == NULL,
    300             "psMetadataLookupTime:   return NULL for incorrect key (& NULL status).");
    301     }
    302 
    303 
    304 
    305     //Check for Memory leaks
    306     {
     28        psMemId id = psMemGetId();
     29        psMetadata *md = psMetadataAlloc();
     30        psMetadataAddStr(md, PS_LIST_TAIL, "itemStr", 0, "I am a string", "GNIRTS");
     31        psMetadataAddBool(md, PS_LIST_TAIL, "itemBool", 0, "I am a boolean", true);
     32        psMetadataAddS8(md, PS_LIST_TAIL, "itemS8", 0, "I am S8", 6);
     33        psMetadataAddS16(md, PS_LIST_TAIL, "itemS16", 0, "I am S16", -666);
     34        psMetadataAddS32(md, PS_LIST_TAIL, "itemS32", 0, "I am a integer", 55);
     35        psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", 0, "I am S64", 666);
     36        psMetadataAddU8(md, PS_LIST_TAIL, "itemU8", 0, "I am U8", 6);
     37        psMetadataAddU16(md, PS_LIST_TAIL, "itemU16", 0, "I am U16", 666);
     38        psMetadataAddU32(md, PS_LIST_TAIL, "itemU32", 0, "I am U32", 666);
     39        psMetadataAddU64(md, PS_LIST_TAIL, "itemU64", 0, "I am U64", 666);
     40        psMetadataAddF32(md, PS_LIST_TAIL, "itemF32", 0, NULL, 3.14);
     41        psMetadataAddF64(md, PS_LIST_TAIL, "itemF64", 0, "", 6.28);
     42        psSphere *sphere = psSphereAlloc();
     43        sphere->r = 6.66;
     44        sphere->d = 666.666;
     45        psMetadataAddPtr(md, PS_LIST_HEAD, "ptr", PS_DATA_SPHERE, "", sphere);
     46        //    psMetadataAddPtr(md, PS_LIST_TAIL, "ptr", PS_DATA_METADATA_MULTI, "", sphere);
     47        psTime *time;
     48        time = psTimeAlloc(PS_TIME_TAI);
     49        time->sec = 1000;
     50        time->nsec = 25;
     51        time->leapsecond = true;
     52        psMetadataAddTime(md, PS_LIST_TAIL, "time01", 0, "I am time", time);
     53        psMetadata *newMD = psMetadataAlloc();
     54        psMetadataAddS32(newMD, PS_LIST_TAIL, "1", 0, "", 666);
     55        psMetadataAddMetadata(md, PS_LIST_TAIL, "metadata7", 0, "I am a metadata", newMD);
     56   
     57        //Lookup Standard number-types (valid cases)
     58        //U8
     59        {
     60            bool status = false;
     61            psU8 u8 = 0;
     62            u8 = psMetadataLookupU8(&status, md, "itemU8");
     63            ok( status && u8 == 6,
     64                "psMetadataLookupU8:     return correct U8 value on lookup.");
     65        }
     66        //U16
     67        {
     68            bool status = false;
     69            psU16 u16 = 0;
     70            u16 = psMetadataLookupU16(&status, md, "itemU16");
     71            ok( status && u16 == 666,
     72                "psMetadataLookupU16:    return correct U16 value on lookup.");
     73        }
     74        //U32
     75        {
     76            bool status = false;
     77            psU32 u32 = 0;
     78            u32 = psMetadataLookupU32(&status, md, "itemU32");
     79            ok( status && u32 == 666,
     80                "psMetadataLookupU32:    return correct U32 value on lookup.");
     81        }
     82        //U64
     83        {
     84            bool status = false;
     85            psU64 u64 = 0;
     86            u64 = psMetadataLookupU64(&status, md, "itemU64");
     87            ok( status && u64 == 666,
     88                "psMetadataLookupU64:    return correct U64 value on lookup.");
     89        }
     90        //S8
     91        {
     92            bool status = false;
     93            psS8 s8 = 0;
     94            s8 = psMetadataLookupS8(&status, md, "itemS8");
     95            ok( status && s8 == 6,
     96                "psMetadataLookupS8:     return correct S8 value on lookup.");
     97        }
     98        //S16
     99        {
     100            bool status = false;
     101            psS16 s16 = 0;
     102            s16 = psMetadataLookupS16(&status, md, "itemS16");
     103            ok( status && s16 == -666,
     104                "psMetadataLookupS16:    return correct S16 value on lookup.");
     105        }
     106        //S32
     107        {
     108            bool status = false;
     109            psS32 s32 = 0;
     110            s32 = psMetadataLookupS32(&status, md, "itemS32");
     111            ok( status && s32 == 55,
     112                "psMetadataLookupS32:    return correct S32 value on lookup.");
     113        }
     114        //S64
     115        {
     116            bool status = false;
     117            psS64 s64 = 0;
     118            s64 = psMetadataLookupS64(&status, md, "itemS64");
     119            ok( status && s64 == 666,
     120                "psMetadataLookupS64:    return correct S64 value on lookup.");
     121        }
     122        //F32
     123        {
     124            bool status = false;
     125            psF32 f32 = 0;
     126            f32 = psMetadataLookupF32(&status, md, "itemF32");
     127            ok( status && abs(f32 - 3.14) < FLT_EPSILON,
     128                "psMetadataLookupF32:    return correct F32 value on lookup.");
     129        }
     130        //F64
     131        {
     132            bool status = false;
     133            psF64 f64 = 0;
     134            f64 = psMetadataLookupF64(&status, md, "itemF64");
     135            ok( status && abs(f64 - 6.28) < DBL_EPSILON,
     136                "psMetadataLookupF64:    return correct F64 value on lookup.");
     137        }
     138        //Bool
     139        {
     140            bool status = false;
     141            bool stat = false;
     142            stat = psMetadataLookupBool(&status, md, "itemBool");
     143            ok( status && stat,
     144                "psMetadataLookupBool:   return correct Bool value on lookup.");
     145        }
     146        //String
     147        {
     148            bool status = false;
     149            psString str = NULL;
     150            str = psMetadataLookupStr(&status, md, "itemStr");
     151            ok( status && !strncmp(str, "GNIRTS", 8),
     152                "psMetadataLookupStr:   return correct String value on lookup.");
     153        }
     154        //Pointer
     155        {
     156            bool status = false;
     157            psSphere *sph = NULL;
     158            sph = (psSphere*)(psMetadataLookupPtr(&status, md, "ptr"));
     159            ok( status && sph != NULL && abs(sph->r-6.66) < FLT_EPSILON,
     160                "psMetadataLookupPtr:   return correct pointer value on lookup.");
     161        }
     162        //Time
     163        {
     164            bool status = false;
     165            psTime *t = NULL;
     166            t = psMetadataLookupTime(&status, md, "time01");
     167            ok( status && t->sec == 1000,
     168                "psMetadataLookupTime:  return correct time value on lookup.");
     169        }
     170        //Metadata
     171        {
     172            bool status = false;
     173            psMetadata *mdtemp = NULL;
     174            mdtemp = psMetadataLookupMetadata(&status, md, "metadata7");
     175            psMetadataItem *itemtemp = psMetadataGet(mdtemp, PS_LIST_HEAD);
     176            ok( status && itemtemp->type == PS_DATA_S32 && itemtemp->data.S32 == 666,
     177                "psMetadataLookupMD:    return correct metadata value on lookup.");
     178        }
     179   
     180        //Try Negatives and non-standard lookup cases
     181        //String  - invalid key name
     182        {
     183            bool status = false;
     184            psString str = NULL;
     185            str = psMetadataLookupStr(&status, md, "item");
     186            ok( !status && str == NULL,
     187                "psMetadataLookupStr:   return NULL for incorrect key.");
     188            str = NULL;
     189            str = psMetadataLookupStr(NULL, md, "item");
     190            ok( str == NULL,
     191                "psMetadataLookupStr:   return NULL for incorrect key (& NULL status).");
     192        }
     193        //String - wrong key->  lookup s8 data
     194        {
     195            bool status = false;
     196            psString str = NULL;
     197            str = psMetadataLookupStr(&status, md, "itemS8");
     198            ok( !status && str == NULL,
     199                "psMetadataLookupStr:   return NULL for incorrect key .");
     200            str = NULL;
     201            str = psMetadataLookupStr(NULL, md, "itemS8");
     202            ok( str == NULL,
     203                "psMetadataLookupStr:   return NULL for incorrect key (& NULL status).");
     204        }
     205        //Pointer - invalid key name
     206        {
     207            bool status = false;
     208            psSphere *sph = NULL;
     209            sph = psMetadataLookupPtr(&status, md, "item");
     210            ok( !status && sph == NULL,
     211                "psMetadataLookupPtr:   return NULL for incorrect key.");
     212        }
     213        //Pointer - wrong key -> lookup s8 data
     214        {
     215            bool status = false;
     216            psSphere *sph = NULL;
     217            sph = psMetadataLookupPtr(&status, md, "itemS8");
     218            ok( !status && sph == NULL,
     219                "psMetadataLookupPtr:   return NULL for incorrect key.");
     220        }
     221   
     222        //Pointer**  - lookup a PS_DATA_METADATA_MULTI
     223        {
     224            psMetadata *metadata = psMetadataAlloc();
     225            psMetadataItem *multi = psMetadataItemAlloc("ptr", PS_DATA_METADATA_MULTI, "", NULL);
     226            psMetadataAddItem(metadata, multi, PS_LIST_HEAD, PS_META_DUPLICATE_OK);
     227            psMetadataAddPtr(metadata, PS_LIST_TAIL, "ptr",
     228                             PS_DATA_SPHERE | PS_META_DUPLICATE_OK, "", sphere);
     229            psSphere *s = psSphereAlloc();
     230            s->r = 0.666;
     231            psMetadataAddPtr(metadata, PS_LIST_TAIL, "ptr", PS_DATA_SPHERE | PS_META_DUPLICATE_OK, "", s);
     232            psFree(s);
     233            psMetadataItem *metadataItem = NULL;
     234            metadataItem = psMetadataLookup(metadata, "ptr");
     235            bool status = false;
     236            psSphere *sph = NULL;
     237            sph = (psSphere*)(psMetadataLookupPtr(&status, metadata, "ptr"));
     238            ok( status && sph != NULL && fabs(sph->r - 6.66) < FLT_EPSILON,
     239                "psMetadataLookupPtr:   return correct value on lookup of MULTI item.");
     240            psFree(metadata);
     241            psFree(multi);
     242        }
     243   
     244        //Metadata - invalid key name
     245        {
     246            bool status = false;
     247            psMetadata *met = NULL;
     248            met = psMetadataLookupMetadata(&status, md, "item");
     249            ok( !status && met == NULL,
     250                "psMetadataLookupMD:   return NULL for incorrect key.");
     251            met = NULL;
     252            met = psMetadataLookupMetadata(NULL, md, "item");
     253            ok( met == NULL,
     254                "psMetadataLookupMD:   return NULL for incorrect key (& NULL status).");
     255        }
     256        //Metadata - wrong key -> lookup s8 data
     257        {
     258            bool status = false;
     259            psMetadata *met = NULL;
     260            met = psMetadataLookupMetadata(&status, md, "itemS8");
     261            ok( !status && met == NULL,
     262                "psMetadataLookupMD:   return NULL for incorrect key (& NULL status).");
     263            met = NULL;
     264            met = psMetadataLookupMetadata(NULL, md, "itemS8");
     265            ok( met == NULL,
     266                "psMetadataLookupMD:   return NULL for incorrect key.");
     267        }
     268        //Time - invalid key name
     269        {
     270            bool status = false;
     271            psTime *time = NULL;
     272            time = psMetadataLookupTime(&status, md, "item");
     273            ok( !status && time == NULL,
     274                "psMetadataLookupTime:   return NULL for incorrect key.");
     275            time = NULL;
     276            time = psMetadataLookupTime(NULL, md, "item");
     277            ok( time == NULL,
     278                "psMetadataLookupTime:   return NULL for incorrect key (& NULL status).");
     279        }
     280        //Time - wrong key -> lookup s8 data
     281        {
     282            bool status = false;
     283            psTime *time = NULL;
     284            time = psMetadataLookupTime(&status, md, "itemS8");
     285            ok( !status && time == NULL,
     286                "psMetadataLookupTime:   return NULL for incorrect key.");
     287            time = NULL;
     288            time = psMetadataLookupTime(NULL, md, "itemS8");
     289            ok( time == NULL,
     290                "psMetadataLookupTime:   return NULL for incorrect key (& NULL status).");
     291        }
     292   
    307293        psFree(sphere);
    308294        psFree(time);
    309295        psFree(newMD);
    310296        psFree(md);
    311         checkMem();
     297        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     298    }
     299
     300
     301    // psMetadataRemove Functions
     302    {
     303        psMemId id = psMemGetId();
     304        psMetadata *md = psMetadataAlloc();
     305        psMetadataAddStr(md, PS_LIST_TAIL, "itemStr", 0, "I am a string", "GNIRTS");
     306        psMetadataAddBool(md, PS_LIST_TAIL, "itemBool", 0, "I am a boolean", true);
     307        psMetadataAddS8(md, PS_LIST_TAIL, "itemS8", 0, "I am S8", 6);
     308        psMetadataAddS16(md, PS_LIST_TAIL, "itemS16", 0, "I am S16", -666);
     309        psMetadataAddS32(md, PS_LIST_TAIL, "itemS32", 0, "I am a integer", 55);
     310        psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 666);
     311        psMetadataAddU8(md, PS_LIST_TAIL, "itemU8", 0, "I am U8", 6);
     312   
     313        //psMetadataRemoveKey
     314        {
     315            bool status = psMetadataRemoveKey(md, "itemU8");
     316            psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL);
     317            ok( status && temp->type == PS_DATA_S64,
     318                "psMetadataRemoveKey:    return true for valid case.");
     319        }
     320        //psMetadataRemoveIndex
     321        {
     322            bool status = psMetadataRemoveIndex(md, PS_LIST_HEAD);
     323            psMetadataItem *temp = psMetadataGet(md, PS_LIST_HEAD);
     324            ok( status && temp->type == PS_DATA_BOOL,
     325                "psMetadataRemoveIndex:  return true for valid case.");
     326        }
     327        //Attempt to remove an incorrect key - Return false
     328        {
     329            ok( !psMetadataRemoveKey(md, "BigDog"),
     330                "psMetadataRemoveKey:    return false for incorrect key.");
     331        }
     332        //Attempt to remove an out-of-range index - Return false
     333        {
     334            ok( !psMetadataRemoveIndex(md, 20),
     335                "psMetadataRemoveIndex:  return false for incorrect index.");
     336        }
     337        //Attempt to remove an item with NULL name
     338        {
     339            psMetadataItem *temp = psMetadataGet(md, PS_LIST_HEAD);
     340            psFree(temp->name);
     341            temp->name = NULL;
     342            ok( !psMetadataRemoveIndex(md, PS_LIST_HEAD),
     343                "psMetadataRemoveIndex:  return false for item with no name.");
     344        }
     345        //Attempt to remove an item with wrong hash table
     346        {
     347            psMetadata *md2 = psMetadataAlloc();
     348            psMetadataAddBool(md2, PS_LIST_TAIL, "Bool", 0, "I am a boolean", true);
     349            psMetadataAddS8(md2, PS_LIST_TAIL, "S8", 0, "I am S8", 6);
     350            psMetadataAddS16(md2, PS_LIST_TAIL, "S16", 0, "I am S16", -666);
     351            psMetadataAddS32(md2, PS_LIST_TAIL, "S32", 0, "I am a integer", 55);
     352            psMetadataAddS64(md2, PS_LIST_TAIL, "S64", 0, "I am S64", 666);
     353   
     354            psFree(md2->hash);
     355            md2->hash = NULL;
     356            md2->hash = md->hash;
     357            ok( !psMetadataRemoveIndex(md2, PS_LIST_HEAD),
     358                "psMetadataRemoveIndex:  return false for item with bad table.");
     359            md2->hash = NULL;
     360            psFree(md2);
     361        }
     362        //Attempt to remove a METADATA_MULTI item by key
     363        {
     364            psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 667);
     365            psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 668);
     366            bool status = psMetadataRemoveKey(md, "itemS64");
     367            psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL);
     368            ok( status && temp->type == PS_DATA_S32,
     369                "psMetadataRemoveKey:    return true for valid METADATA_MULTI case.");
     370   
     371        }
     372        //Attempt to remove a METADATA_MULTI item by index
     373        {
     374            psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 667);
     375            psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 668);
     376            bool status = psMetadataRemoveIndex(md, PS_LIST_TAIL);
     377            psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL);
     378            ok( status && temp->type == PS_DATA_S64,
     379                "psMetadataRemoveIndex:  return true for valid METADATA_MULTI case.");
     380        }
     381   
     382        psFree(md);
     383        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     384    }
     385   
     386
     387    // psMetadataIterator Functions
     388    {
     389        psMemId id = psMemGetId();
     390        psMetadata *md = psMetadataAlloc();
     391        psMetadataAddS32(md, PS_LIST_HEAD, "S32_1", PS_META_NO_REPLACE, "", 1);
     392        psMetadataAddS32(md, PS_LIST_TAIL, "S32_2", PS_META_NO_REPLACE, "", 2);
     393        psMetadataAddS32(md, PS_LIST_TAIL, "S32_3", PS_META_NO_REPLACE, "", 3);
     394   
     395        psMetadataIterator *iter = NULL;
     396   
     397        //Return NULL in psMetadataGetAnd(In/De)crement for NULL iterator input
     398        {
     399            ok( psMetadataGetAndIncrement(NULL) == NULL,
     400                "psMetadataGetAndIncrement:  return NULL for NULL iterator input.");
     401            ok( psMetadataGetAndDecrement(NULL) == NULL,
     402                "psMetadataGetAndDecrement:  return NULL for NULL iterator input.");
     403        }
     404        //Return NULL in psMetadataGetAnd(In/De)crement for iterator with no list iterator
     405        psMetadataIterator *iter2 = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
     406        psFree(iter2->iter);
     407        iter2->iter = NULL;
     408        {
     409            ok( psMetadataGetAndIncrement(iter2) == NULL,
     410                "psMetadataGetAndIncrement:  return NULL for iterator with no list iterator.");
     411            ok( psMetadataGetAndDecrement(iter2) == NULL,
     412                "psMetadataGetAndDecrement:  return NULL for iterator with no list iterator.");
     413        }
     414        psFree(iter2);
     415   
     416        //Return valid iterator for valid inputs, regex= NULL
     417        psMetadataItem *item = NULL;
     418        {
     419            iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
     420            ok( iter != NULL,
     421                "psMetadataIteratorAlloc:    return valid iterator for valid inputs, regex=NULL.");
     422            skip_start(iter == NULL, 4,
     423                       "Skipping 4 tests because psMetadataIteratorAlloc failed");
     424   
     425            item = psMetadataGetAndIncrement(iter);
     426            ok( item != NULL,
     427                "psMetadataGetAndIncrement:  return valid item for valid iterator input.");
     428            skip_start(item == NULL, 1,
     429                       "Skipping 1 tests because psMetadataGetAndIncrement failed");
     430            ok(item->type == PS_DATA_S32
     431               && !strncmp(item->name, "S32_1", 7)
     432               && item->data.S32 == 1
     433               && !strncmp(item->comment, "", 2),
     434               "psMetadataGetAndIncrement:  retrieve correct item from valid iterator.");
     435            skip_end();
     436   
     437            item = psMetadataGetAndDecrement(iter);
     438            ok( item != NULL,
     439                "psMetadataGetAndDecrement:  return valid item for valid iterator input.");
     440            skip_start(item == NULL, 1,
     441                       "Skipping 1 tests because psMetadataGetAndDecrement failed");
     442            ok(item->type == PS_DATA_S32
     443               && !strncmp(item->name, "S32_2", 7)
     444               && item->data.S32 == 2
     445               && !strncmp(item->comment, "", 2),
     446               "psMetadataGetAndDecrement:  retrieve correct item from valid iterator.");
     447            skip_end();
     448   
     449            skip_end();
     450   
     451        }
     452   
     453        psFree(iter);
     454        psFree(md);
     455        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    312456    }
    313457}
    314 
    315 void testRemoves(void)
    316 {
    317     note("  >>>Test 2:  psMetadataRemove Functions");
    318     psMetadata *md = psMetadataAlloc();
    319     psMetadataAddStr(md, PS_LIST_TAIL, "itemStr", 0, "I am a string", "GNIRTS");
    320     psMetadataAddBool(md, PS_LIST_TAIL, "itemBool", 0, "I am a boolean", true);
    321     psMetadataAddS8(md, PS_LIST_TAIL, "itemS8", 0, "I am S8", 6);
    322     psMetadataAddS16(md, PS_LIST_TAIL, "itemS16", 0, "I am S16", -666);
    323     psMetadataAddS32(md, PS_LIST_TAIL, "itemS32", 0, "I am a integer", 55);
    324     psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 666);
    325     psMetadataAddU8(md, PS_LIST_TAIL, "itemU8", 0, "I am U8", 6);
    326 
    327     //psMetadataRemoveKey
    328     {
    329         bool status = psMetadataRemoveKey(md, "itemU8");
    330         psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL);
    331         ok( status && temp->type == PS_DATA_S64,
    332             "psMetadataRemoveKey:    return true for valid case.");
    333     }
    334     //psMetadataRemoveIndex
    335     {
    336         bool status = psMetadataRemoveIndex(md, PS_LIST_HEAD);
    337         psMetadataItem *temp = psMetadataGet(md, PS_LIST_HEAD);
    338         ok( status && temp->type == PS_DATA_BOOL,
    339             "psMetadataRemoveIndex:  return true for valid case.");
    340     }
    341     //Attempt to remove an incorrect key - Return false
    342     {
    343         ok( !psMetadataRemoveKey(md, "BigDog"),
    344             "psMetadataRemoveKey:    return false for incorrect key.");
    345     }
    346     //Attempt to remove an out-of-range index - Return false
    347     {
    348         ok( !psMetadataRemoveIndex(md, 20),
    349             "psMetadataRemoveIndex:  return false for incorrect index.");
    350     }
    351     //Attempt to remove an item with NULL name
    352     {
    353         psMetadataItem *temp = psMetadataGet(md, PS_LIST_HEAD);
    354         psFree(temp->name);
    355         temp->name = NULL;
    356         ok( !psMetadataRemoveIndex(md, PS_LIST_HEAD),
    357             "psMetadataRemoveIndex:  return false for item with no name.");
    358     }
    359     //Attempt to remove an item with wrong hash table
    360     {
    361         psMetadata *md2 = psMetadataAlloc();
    362         psMetadataAddBool(md2, PS_LIST_TAIL, "Bool", 0, "I am a boolean", true);
    363         psMetadataAddS8(md2, PS_LIST_TAIL, "S8", 0, "I am S8", 6);
    364         psMetadataAddS16(md2, PS_LIST_TAIL, "S16", 0, "I am S16", -666);
    365         psMetadataAddS32(md2, PS_LIST_TAIL, "S32", 0, "I am a integer", 55);
    366         psMetadataAddS64(md2, PS_LIST_TAIL, "S64", 0, "I am S64", 666);
    367 
    368         psFree(md2->hash);
    369         md2->hash = NULL;
    370         md2->hash = md->hash;
    371         ok( !psMetadataRemoveIndex(md2, PS_LIST_HEAD),
    372             "psMetadataRemoveIndex:  return false for item with bad table.");
    373         md2->hash = NULL;
    374         psFree(md2);
    375     }
    376     //Attempt to remove a METADATA_MULTI item by key
    377     {
    378         psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 667);
    379         psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 668);
    380         bool status = psMetadataRemoveKey(md, "itemS64");
    381         psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL);
    382         ok( status && temp->type == PS_DATA_S32,
    383             "psMetadataRemoveKey:    return true for valid METADATA_MULTI case.");
    384 
    385     }
    386     //Attempt to remove a METADATA_MULTI item by index
    387     {
    388         psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 667);
    389         psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 668);
    390         bool status = psMetadataRemoveIndex(md, PS_LIST_TAIL);
    391         psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL);
    392         ok( status && temp->type == PS_DATA_S64,
    393             "psMetadataRemoveIndex:  return true for valid METADATA_MULTI case.");
    394     }
    395 
    396     //Check for Memory leaks
    397     {
    398         psFree(md);
    399         checkMem();
    400     }
    401 }
    402 
    403 void testIter(void)
    404 {
    405     note("  >>>Test 3:  psMetadataIterator Functions");
    406     psMetadata *md = psMetadataAlloc();
    407     psMetadataAddS32(md, PS_LIST_HEAD, "S32_1", PS_META_NO_REPLACE, "", 1);
    408     psMetadataAddS32(md, PS_LIST_TAIL, "S32_2", PS_META_NO_REPLACE, "", 2);
    409     psMetadataAddS32(md, PS_LIST_TAIL, "S32_3", PS_META_NO_REPLACE, "", 3);
    410 
    411     psMetadataIterator *iter = NULL;
    412 
    413     //Return NULL in psMetadataGetAnd(In/De)crement for NULL iterator input
    414     {
    415         ok( psMetadataGetAndIncrement(NULL) == NULL,
    416             "psMetadataGetAndIncrement:  return NULL for NULL iterator input.");
    417         ok( psMetadataGetAndDecrement(NULL) == NULL,
    418             "psMetadataGetAndDecrement:  return NULL for NULL iterator input.");
    419     }
    420     //Return NULL in psMetadataGetAnd(In/De)crement for iterator with no list iterator
    421     psMetadataIterator *iter2 = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
    422     psFree(iter2->iter);
    423     iter2->iter = NULL;
    424     {
    425         ok( psMetadataGetAndIncrement(iter2) == NULL,
    426             "psMetadataGetAndIncrement:  return NULL for iterator with no list iterator.");
    427         ok( psMetadataGetAndDecrement(iter2) == NULL,
    428             "psMetadataGetAndDecrement:  return NULL for iterator with no list iterator.");
    429     }
    430     psFree(iter2);
    431 
    432     //Return valid iterator for valid inputs, regex= NULL
    433     psMetadataItem *item = NULL;
    434     {
    435         iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
    436         ok( iter != NULL,
    437             "psMetadataIteratorAlloc:    return valid iterator for valid inputs, regex=NULL.");
    438         skip_start(iter == NULL, 4,
    439                    "Skipping 4 tests because psMetadataIteratorAlloc failed");
    440 
    441         item = psMetadataGetAndIncrement(iter);
    442         ok( item != NULL,
    443             "psMetadataGetAndIncrement:  return valid item for valid iterator input.");
    444         skip_start(item == NULL, 1,
    445                    "Skipping 1 tests because psMetadataGetAndIncrement failed");
    446         ok(item->type == PS_DATA_S32
    447            && !strncmp(item->name, "S32_1", 7)
    448            && item->data.S32 == 1
    449            && !strncmp(item->comment, "", 2),
    450            "psMetadataGetAndIncrement:  retrieve correct item from valid iterator.");
    451         skip_end();
    452 
    453         item = psMetadataGetAndDecrement(iter);
    454         ok( item != NULL,
    455             "psMetadataGetAndDecrement:  return valid item for valid iterator input.");
    456         skip_start(item == NULL, 1,
    457                    "Skipping 1 tests because psMetadataGetAndDecrement failed");
    458         ok(item->type == PS_DATA_S32
    459            && !strncmp(item->name, "S32_2", 7)
    460            && item->data.S32 == 2
    461            && !strncmp(item->comment, "", 2),
    462            "psMetadataGetAndDecrement:  retrieve correct item from valid iterator.");
    463         skip_end();
    464 
    465         skip_end();
    466 
    467     }
    468 
    469     //Check for Memory leaks
    470     {
    471         psFree(iter);
    472         psFree(md);
    473         checkMem();
    474     }
    475 }
    476 
    477 
     458   
     459   
     460               

  • trunk/psLib/test/types/tap_psMetadata_polynomials.c

    r12607 r12781  
    1010 *
    1111 */
    12 
    1312#include <pslib.h>
    1413#include <string.h>
    15 
    1614#include "tap.h"
    1715#include "pstap.h"
    1816
    19 void test1Dcase(void);
    20 void test2Dcase(void);
    21 void test3Dcase(void);
    22 void test4Dcase(void);
    23 
    2417int main(void)
    2518{
    26     plan_tests(89);
    27 
    28     note("psPolynomial(1D, 2D, 3D, & 4D)(to/from)Metadata tests");
    29 
    30     test1Dcase();
    31     test2Dcase();
    32     test3Dcase();
    33     test4Dcase();
    34 
    35     done();
    36 }
    37 
    38 
    39 void test1Dcase(void)
    40 {
    41     note("  >>>Test 1:  psPolynomial1DtoMetadata & psPolynomial1DfromMetadata functions");
    42     psMetadata *md = psMetadataAlloc();
    43     psPolynomial1D *p1d = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 1);
    44     p1d->coeff[0] = 1.1;
    45     p1d->coeff[1] = 2.2;
    46     p1d->coeffErr[0] = 0.1;
    47     p1d->coeffErr[1] = 0.2;
    48 
    49     //psPolynomial1DtoMetadata
    50     //Return a valid metadata containing a polynomial-metadata structure
     19    psLogSetFormat("HLNM");
     20    psLogSetLevel(PS_LOG_INFO);
     21    plan_tests(92);
     22    // psPolynomial(1D, 2D, 3D, & 4D)(to/from)Metadata tests
     23
     24
     25    // psPolynomial1DtoMetadata & psPolynomial1DfromMetadata functions
    5126    {
    52         note ("example of 1DtoMD using the names not the sequence");
    53 
    54         ok( psPolynomial1DtoMetadata(md, p1d, "polyMD"),
    55             "psPolynomial1DtoMetadata:      return true for valid inputs.");
     27        psMemId id = psMemGetId();
     28        psMetadata *md = psMetadataAlloc();
     29        psPolynomial1D *p1d = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 1);
     30        p1d->coeff[0] = 1.1;
     31        p1d->coeff[1] = 2.2;
     32        p1d->coeffErr[0] = 0.1;
     33        p1d->coeffErr[1] = 0.2;
     34   
     35        //psPolynomial1DtoMetadata
     36        //Return a valid metadata containing a polynomial-metadata structure
     37        {
     38            note ("example of 1DtoMD using the names not the sequence");
     39   
     40            ok( psPolynomial1DtoMetadata(md, p1d, "polyMD"),
     41                "psPolynomial1DtoMetadata:      return true for valid inputs.");
     42            psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
     43            skip_start( polyMDtemp == NULL , 1,
     44                        "Skipping 1 tests because psPolynomial1DtoMetadata has errors");
     45   
     46            bool status;
     47            int nX = psMetadataLookupS32(&status, polyMDtemp, "NORDER_X");
     48            ok(status,
     49               "psPolynomial1DtoMetadata:      found NORDER_X");
     50            ok(nX == 1,
     51               "psPolynomial1DtoMetadata:      NORDER_X is 1");
     52   
     53            double val;
     54            val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X00");
     55            ok(status,
     56               "psPolynomial1DtoMetadata:      found VAL_X00");
     57            is_double(val, 1.1,
     58                      "psPolynomial1DtoMetadata:      VAL_X00 is %lf", val);
     59   
     60            val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X01");
     61            ok(status,
     62               "psPolynomial1DtoMetadata:      found VAL_X01");
     63            is_double(val, 2.2,
     64                      "psPolynomial1DtoMetadata:      VAL_X01 is %lf", val);
     65            skip_end();
     66        }
     67   
     68        //Return false for no-name polynomial
     69        {
     70            ok( !psPolynomial1DtoMetadata(md, p1d, ""),
     71                "psPolynomial1DtoMetadata:      return false for no-name.");
     72        }
     73        //Return false for NULL-name polynomial
     74        {
     75            ok( !psPolynomial1DtoMetadata(md, p1d, NULL),
     76                "psPolynomial1DtoMetadata:      return false for NULL name input.");
     77        }
     78        //Return false for NULL metadata input
     79        {
     80            ok( !psPolynomial1DtoMetadata(NULL, p1d, "polyMD"),
     81                "psPolynomial1DtoMetadata:     return false for NULL metadata input.");
     82        }
     83        //Return false for NULL polynomial input
     84        {
     85            ok( !psPolynomial1DtoMetadata(md, NULL, "polyMD"),
     86                "psPolynomial1DtoMetadata:     return false for NULL polynomial input.");
     87        }
     88        //Return true for polynomial with 1 element, a constant
     89        {
     90            psPolynomial1D *constPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 0);
     91            constPoly->coeff[0] = 6.66;
     92            ok( psPolynomial1DtoMetadata(md, constPoly, "polyMD"),
     93                "psPolynomial1DtoMetadata:     return true for constant polynomial (1 element != 0).");
     94            psFree(constPoly);
     95        }
     96        //Return false for non-ordinary polynomial
     97        {
     98            psPolynomial1D *p1d1 = psPolynomial1DAlloc(PS_POLYNOMIAL_CHEB, 1);
     99            p1d1->coeff[0] = 1.1;
     100            ok( !psPolynomial1DtoMetadata(md, p1d1, "polyMD"),
     101                "psPolynomial1DtoMetadata:     return false for chebyshev polynomial");
     102            psFree(p1d1);
     103        }
     104   
     105        //psPolynomial1DfromMetadata Tests
     106        //Return NULL for NULL metadata input.
     107        {
     108            psPolynomial1D *emptyPoly1D = NULL;
     109            emptyPoly1D = psPolynomial1DfromMetadata(NULL);
     110            ok( emptyPoly1D == NULL,
     111                "psPolynomial1DfromMetadata:   return NULL for NULL metadata input.");
     112        }
     113        //Get a polynomial from Metadata.
     114        psPolynomial1D *outPoly = NULL;
    56115        psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
    57         skip_start( polyMDtemp == NULL , 1,
    58                     "Skipping 1 tests because psPolynomial1DtoMetadata has errors");
    59 
    60         bool status;
    61         int nX = psMetadataLookupS32(&status, polyMDtemp, "NORDER_X");
    62         ok(status,
    63            "psPolynomial1DtoMetadata:      found NORDER_X");
    64         ok(nX == 1,
    65            "psPolynomial1DtoMetadata:      NORDER_X is 1");
    66 
    67         double val;
    68         val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X00");
    69         ok(status,
    70            "psPolynomial1DtoMetadata:      found VAL_X00");
    71         is_double(val, 1.1,
    72                   "psPolynomial1DtoMetadata:      VAL_X00 is %lf", val);
    73 
    74         val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X01");
    75         ok(status,
    76            "psPolynomial1DtoMetadata:      found VAL_X01");
    77         is_double(val, 2.2,
    78                   "psPolynomial1DtoMetadata:      VAL_X01 is %lf", val);
    79         skip_end();
    80     }
    81 
    82     //Return false for no-name polynomial
    83     {
    84         ok( !psPolynomial1DtoMetadata(md, p1d, ""),
    85             "psPolynomial1DtoMetadata:      return false for no-name.");
    86     }
    87     //Return false for NULL-name polynomial
    88     {
    89         ok( !psPolynomial1DtoMetadata(md, p1d, NULL),
    90             "psPolynomial1DtoMetadata:      return false for NULL name input.");
    91     }
    92     //Return false for NULL metadata input
    93     {
    94         ok( !psPolynomial1DtoMetadata(NULL, p1d, "polyMD"),
    95             "psPolynomial1DtoMetadata:     return false for NULL metadata input.");
    96     }
    97     //Return false for NULL polynomial input
    98     {
    99         ok( !psPolynomial1DtoMetadata(md, NULL, "polyMD"),
    100             "psPolynomial1DtoMetadata:     return false for NULL polynomial input.");
    101     }
    102     //Return true for polynomial with 1 element, a constant
    103     {
    104         psPolynomial1D *constPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 0);
    105         constPoly->coeff[0] = 6.66;
    106         ok( psPolynomial1DtoMetadata(md, constPoly, "polyMD"),
    107             "psPolynomial1DtoMetadata:     return true for constant polynomial (1 element != 0).");
    108         psFree(constPoly);
    109     }
    110     //Return false for non-ordinary polynomial
    111     {
    112         psPolynomial1D *p1d1 = psPolynomial1DAlloc(PS_POLYNOMIAL_CHEB, 1);
    113         p1d1->coeff[0] = 1.1;
    114         ok( !psPolynomial1DtoMetadata(md, p1d1, "polyMD"),
    115             "psPolynomial1DtoMetadata:     return false for chebyshev polynomial");
    116         psFree(p1d1);
    117     }
    118 
    119     //psPolynomial1DfromMetadata Tests
    120     //Return NULL for NULL metadata input.
    121     {
    122         psPolynomial1D *emptyPoly1D = NULL;
    123         emptyPoly1D = psPolynomial1DfromMetadata(NULL);
    124         ok( emptyPoly1D == NULL,
    125             "psPolynomial1DfromMetadata:   return NULL for NULL metadata input.");
    126     }
    127     //Get a polynomial from Metadata.
    128     psPolynomial1D *outPoly = NULL;
    129     psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
    130     outPoly = psPolynomial1DfromMetadata(polyMDtemp);
    131     {
    132         skip_start( outPoly == NULL, 1,
    133                     "Skipping 1 tests because psPolynomial1DfromMetadata has errors.");
    134         ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
    135             abs(outPoly->coeff[0] - 1.1) < DBL_EPSILON,
    136             "psPolynomial1DfromMetadata:   return correct polynomial from metadata");
    137         skip_end();
    138     }
    139     //Get a polynomial from Metadata with mask[0] == 1.
    140     psFree(outPoly);
    141     outPoly = NULL;
    142     psPolynomial1D *maskPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 0);
    143     maskPoly->coeff[0] = 6.66;
    144     maskPoly->mask[0] = 1;
    145     psMetadata *newmd = psMetadataAlloc();
    146     psPolynomial1DtoMetadata(newmd, maskPoly, "polyMD");
    147     psMetadata *polyMask = psMetadataLookupMetadata(NULL, newmd, "polyMD");
    148     outPoly = psPolynomial1DfromMetadata(polyMask);
    149     {
    150         ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 0 &&
    151             outPoly->mask[0] == 1,
    152             "psPolynomial1DfromMetadata:   return correct polynomial (w/mask) from metadata");
    153     }
    154     psFree(maskPoly);
    155     psFree(newmd);
    156     //Return NULL for wrong NELEMENTS
    157     psMetadataItem *nElementItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
    158     nElementItem->data.S32 -= 1;
    159     psFree(outPoly);
    160     outPoly = NULL;
    161     outPoly = psPolynomial1DfromMetadata(polyMDtemp);
    162     {
    163         ok( outPoly == NULL,
    164             "psPolynomial1DfromMetadata:   "
    165             "return NULL for metadata-polynomial with wrong NELEMENTS");
    166     }
    167     //Return NULL for missing NELEMENTS
    168     psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL);
    169     psFree(outPoly);
    170     outPoly = NULL;
    171     outPoly = psPolynomial1DfromMetadata(polyMDtemp);
    172     {
    173         ok( outPoly == NULL,
    174             "psPolynomial1DfromMetadata:   "
    175             "return NULL for metadata-polynomial with no NELEMENTS");
    176     }
    177 
    178     //Return NULL for polynomial in metadata with no x-order
    179     psMetadataRemoveKey(polyMDtemp, "NORDER_X");
    180     psFree(outPoly);
    181     outPoly = NULL;
    182     outPoly = psPolynomial1DfromMetadata(polyMDtemp);
    183     {
    184         ok( outPoly == NULL,
    185             "psPolynomial1DfromMetadata:   "
    186             "return NULL for metadata-polynomial with no x-order");
    187     }
    188 
    189     //Check for Memory leaks
    190     {
     116        outPoly = psPolynomial1DfromMetadata(polyMDtemp);
     117        {
     118            skip_start( outPoly == NULL, 1,
     119                        "Skipping 1 tests because psPolynomial1DfromMetadata has errors.");
     120            ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
     121                abs(outPoly->coeff[0] - 1.1) < DBL_EPSILON,
     122                "psPolynomial1DfromMetadata:   return correct polynomial from metadata");
     123            skip_end();
     124        }
     125        //Get a polynomial from Metadata with mask[0] == 1.
     126        psFree(outPoly);
     127        outPoly = NULL;
     128        psPolynomial1D *maskPoly = psPolynomial1DAlloc(PS_POLYNOMIAL_ORD, 0);
     129        maskPoly->coeff[0] = 6.66;
     130        maskPoly->mask[0] = 1;
     131        psMetadata *newmd = psMetadataAlloc();
     132        psPolynomial1DtoMetadata(newmd, maskPoly, "polyMD");
     133        psMetadata *polyMask = psMetadataLookupMetadata(NULL, newmd, "polyMD");
     134        outPoly = psPolynomial1DfromMetadata(polyMask);
     135        {
     136            ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 0 &&
     137                outPoly->mask[0] == 1,
     138                "psPolynomial1DfromMetadata:   return correct polynomial (w/mask) from metadata");
     139        }
     140        psFree(maskPoly);
     141        psFree(newmd);
     142        //Return NULL for wrong NELEMENTS
     143        psMetadataItem *nElementItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
     144        nElementItem->data.S32 -= 1;
     145        psFree(outPoly);
     146        outPoly = NULL;
     147        outPoly = psPolynomial1DfromMetadata(polyMDtemp);
     148        {
     149            ok( outPoly == NULL,
     150                "psPolynomial1DfromMetadata:   "
     151                "return NULL for metadata-polynomial with wrong NELEMENTS");
     152        }
     153        //Return NULL for missing NELEMENTS
     154        psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL);
     155        psFree(outPoly);
     156        outPoly = NULL;
     157        outPoly = psPolynomial1DfromMetadata(polyMDtemp);
     158        {
     159            ok( outPoly == NULL,
     160                "psPolynomial1DfromMetadata:   "
     161                "return NULL for metadata-polynomial with no NELEMENTS");
     162        }
     163   
     164        //Return NULL for polynomial in metadata with no x-order
     165        psMetadataRemoveKey(polyMDtemp, "NORDER_X");
     166        psFree(outPoly);
     167        outPoly = NULL;
     168        outPoly = psPolynomial1DfromMetadata(polyMDtemp);
     169        {
     170            ok( outPoly == NULL,
     171                "psPolynomial1DfromMetadata:   "
     172                "return NULL for metadata-polynomial with no x-order");
     173        }
     174   
    191175        psFree(outPoly);
    192176        psFree(p1d);
    193177        psFree(md);
    194         checkMem();
     178        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     179    }
     180
     181
     182    // psPolynomial2DtoMetadata & psPolynomial2DfromMetadata functions
     183    {
     184        psMemId id = psMemGetId();
     185        psMetadata *md = psMetadataAlloc();
     186        psPolynomial2D *p2d = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 1, 1);
     187        p2d->coeff[0][0] = 1.1;
     188        p2d->coeff[0][1] = 2.2;
     189        p2d->coeff[1][0] = 3.3;
     190        p2d->coeff[1][1] = 4.4;
     191        p2d->coeffErr[0][0] = 0.1;
     192        p2d->coeffErr[0][1] = 0.2;
     193        p2d->coeffErr[1][0] = 0.3;
     194        p2d->coeffErr[1][1] = 0.4;
     195   
     196        //psPolynomial2DtoMetadata
     197        //Return a valid metadata containing a polynomial-metadata structure
     198        {
     199            ok( psPolynomial2DtoMetadata(md, p2d, "polyMD"),
     200                "psPolynomial2DtoMetadata:     return true for valid inputs.");
     201   
     202            // psMetadataConfigWrite (md, "test.md");
     203   
     204            //XXX        ok (0, "these tests are relying on the ORDER of the MD components not the NAMES");
     205            //XXX        ok (0, "these seem like irrelevant tests");
     206            psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
     207            skip_start( polyMDtemp == NULL , 1,
     208                        "Skipping 1 tests because psPolynomial2DtoMetadata has errors");
     209            psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0);
     210            skip_start( polyItem == NULL, 2,
     211                        "Skipping 2 tests because psPolynomial2DtoMetadata has errors in order elements");
     212            ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1,
     213                "psPolynomial2DtoMetadata:     return correct number of x orders.");
     214            polyItem = psMetadataGet(polyMDtemp, 1);
     215            ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1,
     216                "psPolynomial2DtoMetadata:     return correct number of y orders.");
     217            skip_end();
     218            polyItem = psMetadataGet(polyMDtemp, 2);
     219            skip_start( polyItem == NULL, 2,
     220                        "Skipping 2 tests because psPolynomial2DtoMetadata has errors in coeff elements");
     221            ok( !strncmp(polyItem->name, "VAL_X00_Y00", 14) &&
     222                abs(polyItem->data.F64-1.1) < DBL_EPSILON,
     223                "psPolynomial2DtoMetadata:     return correct first element.");
     224            polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL-1);
     225            ok( !strncmp(polyItem->name, "ERR_X01_Y01", 14) &&
     226                abs(polyItem->data.F64-0.4) < DBL_EPSILON,
     227                "psPolynomial2DtoMetadata:     return correct last element.");
     228            skip_end();
     229            skip_end();
     230        }
     231   
     232        //psPolynomial2DtoMetadata
     233        //Return a valid metadata containing a polynomial-metadata structure
     234        {
     235            note ("example of 2DtoMD using the names not the sequence");
     236   
     237            ok( psPolynomial2DtoMetadata(md, p2d, "polyMD"),
     238                "psPolynomial2DtoMetadata:     return true for valid inputs.");
     239   
     240            // psMetadataConfigWrite (md, "test.md");
     241   
     242            // of the components.  these seem like irrelevant tests.
     243            psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
     244            skip_start( polyMDtemp == NULL , 1,
     245                        "Skipping 1 tests because psPolynomial2DtoMetadata has errors");
     246   
     247            bool status;
     248            int nX = psMetadataLookupS32(&status, polyMDtemp, "NORDER_X");
     249            ok(status,
     250               "psPolynomial2DtoMetadata:     found NORDER_X");
     251            ok(nX == 1,
     252               "psPolynomial2DtoMetadata:     NORDER_X is 1");
     253   
     254            int nY = psMetadataLookupS32(&status, polyMDtemp, "NORDER_Y");
     255            ok(status,
     256               "psPolynomial2DtoMetadata:     found NORDER_Y");
     257            ok(nY == 1,
     258               "psPolynomial2DtoMetadata:     NORDER_Y is 1");
     259   
     260            double val;
     261            val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X00_Y00");
     262            ok(status,
     263               "psPolynomial2DtoMetadata:     found VAL_X00_Y00");
     264            is_double(val, 1.1,
     265                      "psPolynomial2DtoMetadata:     VAL_X00_Y00 is %lf", val);
     266   
     267            val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X01_Y01");
     268            ok(status,
     269               "psPolynomial2DtoMetadata:     found VAL_X01_Y01");
     270            is_double(val, 4.4,
     271                      "psPolynomial2DtoMetadata:     VAL_X01_Y01 is %lf", val);
     272   
     273            skip_end();
     274        }
     275   
     276        //Return false for no-name polynomial
     277        {
     278            ok( !psPolynomial2DtoMetadata(md, p2d, ""),
     279                "psPolynomial2DtoMetadata:     return false for no-name.");
     280        }
     281        //Return false for NULL-name polynomial
     282        {
     283            ok( !psPolynomial2DtoMetadata(md, p2d, NULL),
     284                "psPolynomial2DtoMetadata:     return false for NULL name input.");
     285        }
     286        //Return false for NULL metadata input
     287        {
     288            ok( !psPolynomial2DtoMetadata(NULL, p2d, "polyMD"),
     289                "psPolynomial2DtoMetadata:     return false for NULL metadata input.");
     290        }
     291        //Return false for NULL polynomial input
     292        {
     293            ok( !psPolynomial2DtoMetadata(md, NULL, "polyMD"),
     294                "psPolynomial2DtoMetadata:     return false for NULL polynomial input.");
     295        }
     296        //Return true for polynomial with 1 element, a constant
     297        {
     298            psPolynomial2D *constPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0);
     299            constPoly->coeff[0][0] = 6.66;
     300            ok( psPolynomial2DtoMetadata(md, constPoly, "polyMD"),
     301                "psPolynomial2DtoMetadata:     return true for constant polynomial (1 element != 0).");
     302            psFree(constPoly);
     303        }
     304        //Return false for non-ordinary polynomial
     305        {
     306            psPolynomial2D *p2d2 = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, 1, 1);
     307            p2d2->coeff[0][0] = 1.1;
     308            ok( !psPolynomial2DtoMetadata(md, p2d2, "polyMD"),
     309                "psPolynomial2DtoMetadata:     return false for chebyshev polynomial");
     310            psFree(p2d2);
     311        }
     312   
     313        //psPolynomial2DfromMetadata Tests
     314        //Return NULL for NULL metadata input.
     315        {
     316            psPolynomial2D *emptyPoly2D = NULL;
     317            emptyPoly2D = psPolynomial2DfromMetadata(NULL);
     318            ok( emptyPoly2D == NULL,
     319                "psPolynomial2DfromMetadata:   return NULL for NULL metadata input.");
     320        }
     321        //Get a polynomial from Metadata.
     322        psPolynomial2D *outPoly = NULL;
     323        psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
     324        outPoly = psPolynomial2DfromMetadata(polyMDtemp);
     325        {
     326            skip_start( outPoly == NULL, 1,
     327                        "Skipping 1 tests because psPolynomial2DfromMetadata has errors.");
     328            ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
     329                outPoly->nY == 1 && abs(outPoly->coeff[0][0] - 1.1) < DBL_EPSILON,
     330                "psPolynomial2DfromMetadata:   return correct polynomial from metadata");
     331            skip_end();
     332        }
     333        //Get a polynomial from Metadata with mask[0][0] == 1.
     334        psFree(outPoly);
     335        outPoly = NULL;
     336        psPolynomial2D *maskPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0);
     337        maskPoly->coeff[0][0] = 6.66;
     338        maskPoly->mask[0][0] = 1;
     339        psMetadata *newmd = psMetadataAlloc();
     340        psPolynomial2DtoMetadata(newmd, maskPoly, "polyMD");
     341        psMetadata *polyMask = psMetadataLookupMetadata(NULL, newmd, "polyMD");
     342        outPoly = psPolynomial2DfromMetadata(polyMask);
     343        {
     344            ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 0 &&
     345                outPoly->nY == 0 && outPoly->mask[0][0] == 1,
     346                "psPolynomial2DfromMetadata:   return correct polynomial (w/mask) from metadata");
     347        }
     348        psFree(maskPoly);
     349        psFree(newmd);
     350        //Return NULL for wrong NELEMENTS
     351        psMetadataItem *nElementItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
     352        nElementItem->data.S32 -= 1;
     353        psFree(outPoly);
     354        outPoly = NULL;
     355        outPoly = psPolynomial2DfromMetadata(polyMDtemp);
     356        {
     357            ok( outPoly == NULL,
     358                "psPolynomial2DfromMetadata:   "
     359                "return NULL for metadata-polynomial with wrong NELEMENTS");
     360        }
     361        //Return NULL for missing NELEMENTS
     362        psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL);
     363        psFree(outPoly);
     364        outPoly = NULL;
     365        outPoly = psPolynomial2DfromMetadata(polyMDtemp);
     366        {
     367            ok( outPoly == NULL,
     368                "psPolynomial2DfromMetadata:   "
     369                "return NULL for metadata-polynomial with no NELEMENTS");
     370        }
     371   
     372        //Return NULL for polynomial in metadata with no y-order
     373        psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
     374        psFree(outPoly);
     375        outPoly = NULL;
     376        outPoly = psPolynomial2DfromMetadata(polyMDtemp);
     377        {
     378            ok( outPoly == NULL,
     379                "psPolynomial2DfromMetadata:   "
     380                "return NULL for metadata-polynomial with no y-order");
     381        }
     382        //Return NULL for polynomial in metadata with no x-order
     383        psMetadataRemoveKey(polyMDtemp, "NORDER_X");
     384        psFree(outPoly);
     385        outPoly = NULL;
     386        outPoly = psPolynomial2DfromMetadata(polyMDtemp);
     387        {
     388            ok( outPoly == NULL,
     389                "psPolynomial2DfromMetadata:   "
     390                "return NULL for metadata-polynomial with no x-order");
     391        }
     392
     393        psFree(outPoly);
     394        psFree(p2d);
     395        psFree(md);
     396        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     397    }
     398
     399
     400    // psPolynomial3DtoMetadata & psPolynomial3DfromMetadata functions
     401    {
     402        psMemId id = psMemGetId();
     403        psMetadata *md = psMetadataAlloc();
     404        psPolynomial3D *p3d = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1);
     405        p3d->coeff[0][0][0] = 1.1;
     406        p3d->coeff[1][0][0] = 2.2;
     407        p3d->coeff[0][1][0] = 3.3;
     408        p3d->coeff[0][0][1] = 4.4;
     409        p3d->coeff[1][1][0] = 5.5;
     410        p3d->coeff[1][0][1] = 6.6;
     411        p3d->coeff[0][1][1] = 7.7;
     412        p3d->coeff[1][1][1] = 8.8;
     413        p3d->coeffErr[0][0][0] = 0.1;
     414        p3d->coeffErr[1][0][0] = 0.2;
     415        p3d->coeffErr[0][1][0] = 0.3;
     416        p3d->coeffErr[0][0][1] = 0.4;
     417        p3d->coeffErr[1][1][0] = 0.5;
     418        p3d->coeffErr[1][0][1] = 0.6;
     419        p3d->coeffErr[0][1][1] = 0.7;
     420        p3d->coeffErr[1][1][1] = 0.8;
     421   
     422        //psPolynomial3DtoMetadata
     423        //Return a valid metadata containing a polynomial-metadata structure
     424        {
     425            ok( psPolynomial3DtoMetadata(md, p3d, "polyMD"),
     426                "psPolynomial3DtoMetadata:     return true for valid inputs.");
     427            psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
     428            skip_start( polyMDtemp == NULL , 1,
     429                        "Skipping 1 tests because psPolynomial3DtoMetadata has errors");
     430            psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0);
     431            skip_start( polyItem == NULL, 2,
     432                        "Skipping 3 tests because psPolynomial3DtoMetadata has errors in order elements");
     433            ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1,
     434                "psPolynomial3DtoMetadata:     return correct number of x orders.");
     435            polyItem = psMetadataGet(polyMDtemp, 1);
     436            ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1,
     437                "psPolynomial3DtoMetadata:     return correct number of y orders.");
     438            polyItem = psMetadataGet(polyMDtemp, 2);
     439            ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1,
     440                "psPolynomial3DtoMetadata:     return correct number of z orders.");
     441            skip_end();
     442            polyItem = psMetadataGet(polyMDtemp, 3);
     443            skip_start( polyItem == NULL, 2,
     444                        "Skipping 2 tests because psPolynomial3DtoMetadata has errors in coeff elements");
     445            ok( !strncmp(polyItem->name, "VAL_X00_Y00_Z00", 14) &&
     446                abs(polyItem->data.F64-1.1) < DBL_EPSILON,
     447                "psPolynomial3DtoMetadata:     return correct first element.");
     448            polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL-1);
     449            ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01", 14) &&
     450                abs(polyItem->data.F64-0.8) < DBL_EPSILON,
     451                "psPolynomial3DtoMetadata:     return correct last element.");
     452            skip_end();
     453            skip_end();
     454        }
     455        //Return false for no-name polynomial
     456        {
     457            ok( !psPolynomial3DtoMetadata(md, p3d, ""),
     458                "psPolynomial3DtoMetadata:     return false for no-name.");
     459        }
     460        //Return false for NULL-name polynomial
     461        {
     462            ok( !psPolynomial3DtoMetadata(md, p3d, NULL),
     463                "psPolynomial3DtoMetadata:     return false for NULL name input.");
     464        }
     465        //Return false for NULL metadata input
     466        {
     467            ok( !psPolynomial3DtoMetadata(NULL, p3d, "polyMD"),
     468                "psPolynomial3DtoMetadata:     return false for NULL metadata input.");
     469        }
     470        //Return false for NULL polynomial input
     471        {
     472            ok( !psPolynomial3DtoMetadata(md, NULL, "polyMD"),
     473                "psPolynomial3DtoMetadata:     return false for NULL polynomial input.");
     474        }
     475        /*    //Return false for empty polynomial
     476            {
     477                psPolynomial3D *emptyPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0);
     478                ok( !psPolynomial3DtoMetadata(md, emptyPoly, "polyMD"),
     479                    "psPolynomial3DtoMetadata:     return false for empty polynomial input.");
     480                psFree(emptyPoly);
     481            }
     482        */
     483        //Return true for polynomial with 1 element, a constant
     484        {
     485            psPolynomial3D *constPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0);
     486            constPoly->coeff[0][0][0] = 6.66;
     487            ok( psPolynomial3DtoMetadata(md, constPoly, "polyMD"),
     488                "psPolynomial3DtoMetadata:     return true for constant polynomial (1 element != 0).");
     489            psFree(constPoly);
     490        }
     491        //Return false for non-ordinary polynomial
     492        {
     493            psPolynomial3D *p3d2 = psPolynomial3DAlloc(PS_POLYNOMIAL_CHEB, 1, 1, 1);
     494            p3d2->coeff[0][0][0] = 1.1;
     495            ok( !psPolynomial3DtoMetadata(md, p3d2, "polyMD"),
     496                "psPolynomial3DtoMetadata:     return false for chebyshev polynomial");
     497            psFree(p3d2);
     498        }
     499   
     500        //psPolynomial3DfromMetadata Tests
     501        //Return NULL for NULL metadata input.
     502        {
     503            psPolynomial3D *emptyPoly2D = NULL;
     504            emptyPoly2D = psPolynomial3DfromMetadata(NULL);
     505            ok( emptyPoly2D == NULL,
     506                "psPolynomial3DfromMetadata:   return NULL for NULL metadata input.");
     507        }
     508        //Get a polynomial from Metadata.
     509        psPolynomial3D *outPoly = NULL;
     510        psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
     511        outPoly = psPolynomial3DfromMetadata(polyMDtemp);
     512        {
     513            skip_start( outPoly == NULL, 1,
     514                        "Skipping 1 tests because psPolynomial3DfromMetadata has errors.");
     515            ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
     516                outPoly->nY == 1 && outPoly->nZ == 1 &&
     517                abs(outPoly->coeff[0][0][0] - 1.1) < DBL_EPSILON,
     518                "psPolynomial3DfromMetadata:   return correct polynomial from metadata");
     519            skip_end();
     520        }
     521   
     522        //Get a polynomial from Metadata with mask[0][0][0] == 1.
     523        psFree(outPoly);
     524        outPoly = NULL;
     525        psPolynomial3D *maskPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0);
     526        maskPoly->coeff[0][0][0] = 6.66;
     527        maskPoly->mask[0][0][0] = 1;
     528        psMetadata *newmd = psMetadataAlloc();
     529        psPolynomial3DtoMetadata(newmd, maskPoly, "polyMD");
     530        psMetadata *polyMask = psMetadataLookupMetadata(NULL, newmd, "polyMD");
     531        outPoly = psPolynomial3DfromMetadata(polyMask);
     532        {
     533            ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 0 && outPoly->nY == 0
     534                && outPoly->nZ == 0 && outPoly->mask[0][0][0] == 1,
     535                "psPolynomial3DfromMetadata:   return correct polynomial (w/mask) from metadata");
     536        }
     537        psFree(maskPoly);
     538        psFree(newmd);
     539        //Return NULL for wrong NELEMENTS
     540        psMetadataItem *nElementItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
     541        nElementItem->data.S32 -= 1;
     542        psFree(outPoly);
     543        outPoly = NULL;
     544        outPoly = psPolynomial3DfromMetadata(polyMDtemp);
     545        {
     546            ok( outPoly == NULL,
     547                "psPolynomial3DfromMetadata:   "
     548                "return NULL for metadata-polynomial with wrong NELEMENTS");
     549        }
     550        //Return NULL for missing NELEMENTS
     551        psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL);
     552        psFree(outPoly);
     553        outPoly = NULL;
     554        outPoly = psPolynomial3DfromMetadata(polyMDtemp);
     555        {
     556            ok( outPoly == NULL,
     557                "psPolynomial3DfromMetadata:   "
     558                "return NULL for metadata-polynomial with no NELEMENTS");
     559        }
     560   
     561        //Return NULL for polynomial in metadata with no z-order
     562        psMetadataRemoveKey(polyMDtemp, "NORDER_Z");
     563        psFree(outPoly);
     564        outPoly = NULL;
     565        outPoly = psPolynomial3DfromMetadata(polyMDtemp);
     566        {
     567            ok( outPoly == NULL,
     568                "psPolynomial3DfromMetadata:   return NULL for metadata-polynomial with no z-order");
     569        }
     570        //Return NULL for polynomial in metadata with no y-order
     571        psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
     572        psFree(outPoly);
     573        outPoly = NULL;
     574        outPoly = psPolynomial3DfromMetadata(polyMDtemp);
     575        {
     576            ok( outPoly == NULL,
     577                "psPolynomial3DfromMetadata:   return NULL for metadata-polynomial with no y-order");
     578        }
     579        //Return NULL for polynomial in metadata with no x-order
     580        psMetadataRemoveKey(polyMDtemp, "NORDER_X");
     581        psFree(outPoly);
     582        outPoly = NULL;
     583        outPoly = psPolynomial3DfromMetadata(polyMDtemp);
     584        {
     585            ok( outPoly == NULL,
     586                "psPolynomial3DfromMetadata:   return NULL for metadata-polynomial with no x-order");
     587        }
     588   
     589        psFree(outPoly);
     590        psFree(p3d);
     591        psFree(md);
     592        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     593    }
     594
     595
     596    // psPolynomial4DtoMetadata & psPolynomial4DfromMetadata functions
     597    {
     598        psMemId id = psMemGetId();
     599        psMetadata *md = psMetadataAlloc();
     600        psPolynomial4D *p4d = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1, 1);
     601        p4d->coeff[0][0][0][0] = 1.1;
     602        p4d->coeff[0][0][0][1] = 2.2;
     603        p4d->coeff[0][0][1][0] = 3.3;
     604        p4d->coeff[0][1][0][0] = 4.4;
     605        p4d->coeff[1][0][0][0] = 5.5;
     606   
     607        p4d->coeff[0][0][1][1] = 6.6;
     608        p4d->coeff[0][1][0][1] = 7.7;
     609        p4d->coeff[1][0][0][1] = 8.8;
     610        p4d->coeff[0][1][1][0] = 9.9;
     611        p4d->coeff[1][0][1][0] = 10.10;
     612        p4d->coeff[1][1][0][0] = 11.11;
     613   
     614        p4d->coeff[0][1][1][1] = 12.12;
     615        p4d->coeff[1][0][1][1] = 13.13;
     616        p4d->coeff[1][1][0][1] = 14.14;
     617        p4d->coeff[1][1][1][0] = 15.15;
     618   
     619        p4d->coeff[1][1][1][1] = 16.16;
     620   
     621        p4d->coeffErr[0][0][0][0] = 0.1;
     622        p4d->coeffErr[0][0][0][1] = 0.2;
     623        p4d->coeffErr[0][0][1][0] = 0.3;
     624        p4d->coeffErr[0][1][0][0] = 0.4;
     625        p4d->coeffErr[1][0][0][0] = 0.5;
     626   
     627        p4d->coeffErr[0][0][1][1] = 0.6;
     628        p4d->coeffErr[0][1][0][1] = 0.7;
     629        p4d->coeffErr[1][0][0][1] = 0.8;
     630        p4d->coeffErr[0][1][1][0] = 0.9;
     631        p4d->coeffErr[1][0][1][0] = 0.10;
     632        p4d->coeffErr[1][1][0][0] = 0.11;
     633   
     634        p4d->coeffErr[0][1][1][1] = 0.12;
     635        p4d->coeffErr[1][0][1][1] = 0.13;
     636        p4d->coeffErr[1][1][0][1] = 0.14;
     637        p4d->coeffErr[1][1][1][0] = 0.15;
     638   
     639        p4d->coeffErr[1][1][1][1] = 0.16;
     640   
     641        //psPolynomial4DtoMetadata
     642        //Return a valid metadata containing a polynomial-metadata structure
     643        {
     644            ok( psPolynomial4DtoMetadata(md, p4d, "polyMD"),
     645                "psPolynomial4DtoMetadata:     return true for valid inputs.");
     646            psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
     647            skip_start( polyMDtemp == NULL , 1,
     648                        "Skipping 1 tests because psPolynomial4DtoMetadata has errors");
     649            psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0);
     650            skip_start( polyItem == NULL, 2,
     651                        "Skipping 4 tests because psPolynomial4DtoMetadata has errors in order elements");
     652            ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1,
     653                "psPolynomial4DtoMetadata:     return correct number of x orders.");
     654            polyItem = psMetadataGet(polyMDtemp, 1);
     655            ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1,
     656                "psPolynomial4DtoMetadata:     return correct number of y orders.");
     657            polyItem = psMetadataGet(polyMDtemp, 2);
     658            ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1,
     659                "psPolynomial4DtoMetadata:     return correct number of z orders.");
     660            polyItem = psMetadataGet(polyMDtemp, 3);
     661            ok( !strncmp(polyItem->name, "NORDER_T", 10) && polyItem->data.S32 == 1,
     662                "psPolynomial4DtoMetadata:     return correct number of t orders.");
     663            skip_end();
     664            polyItem = psMetadataGet(polyMDtemp, 4);
     665            skip_start( polyItem == NULL, 2,
     666                        "Skipping 2 tests because psPolynomial4DtoMetadata has errors in coeff elements");
     667            ok( !strncmp(polyItem->name, "VAL_X00_Y00_Z00_T00", 14) &&
     668                abs(polyItem->data.F64-1.1) < DBL_EPSILON,
     669                "psPolynomial4DtoMetadata:     return correct first element.");
     670            polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL-1);
     671            ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01_T01", 14) &&
     672                abs(polyItem->data.F64-0.16) < DBL_EPSILON,
     673                "psPolynomial4DtoMetadata:     return correct last element.");
     674            skip_end();
     675            skip_end();
     676        }
     677        //Return false for no-name polynomial
     678        {
     679            ok( !psPolynomial4DtoMetadata(md, p4d, ""),
     680                "psPolynomial4DtoMetadata:     return false for no-name.");
     681        }
     682        //Return false for NULL-name polynomial
     683        {
     684            ok( !psPolynomial4DtoMetadata(md, p4d, NULL),
     685                "psPolynomial4DtoMetadata:     return false for NULL name input.");
     686        }
     687        //Return false for NULL metadata input
     688        {
     689            ok( !psPolynomial4DtoMetadata(NULL, p4d, "polyMD"),
     690                "psPolynomial4DtoMetadata:     return false for NULL metadata input.");
     691        }
     692        //Return false for NULL polynomial input
     693        {
     694            ok( !psPolynomial4DtoMetadata(md, NULL, "polyMD"),
     695                "psPolynomial4DtoMetadata:     return false for NULL polynomial input.");
     696        }
     697        /*    //Return false for empty polynomial
     698            {
     699                psPolynomial4D *emptyPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0);
     700                ok( !psPolynomial4DtoMetadata(md, emptyPoly, "polyMD"),
     701                    "psPolynomial4DtoMetadata:     return false for empty polynomial input.");
     702                psFree(emptyPoly);
     703            }
     704        */
     705        //Return true for polynomial with 1 element, a constant
     706        {
     707            psPolynomial4D *constPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0);
     708            constPoly->coeff[0][0][0][0] = 6.66;
     709            ok( psPolynomial4DtoMetadata(md, constPoly, "polyMD"),
     710                "psPolynomial4DtoMetadata:     return true for constant polynomial (1 element != 0).");
     711            psFree(constPoly);
     712        }
     713        //Return false for non-ordinary polynomial
     714        {
     715            psPolynomial4D *p4d2 = psPolynomial4DAlloc(PS_POLYNOMIAL_CHEB, 1, 1, 1, 1);
     716            p4d2->coeff[0][0][0][0] = 1.1;
     717            ok( !psPolynomial4DtoMetadata(md, p4d2, "polyMD"),
     718                "psPolynomial4DtoMetadata:     return false for chebyshev polynomial");
     719            psFree(p4d2);
     720        }
     721   
     722        //psPolynomial4DfromMetadata Tests
     723        //Return NULL for NULL metadata input.
     724        {
     725            psPolynomial4D *emptyPoly2D = NULL;
     726            emptyPoly2D = psPolynomial4DfromMetadata(NULL);
     727            ok( emptyPoly2D == NULL,
     728                "psPolynomial4DfromMetadata:   return NULL for NULL metadata input.");
     729        }
     730        //Get a polynomial from Metadata.
     731        psPolynomial4D *outPoly = NULL;
     732        psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
     733        outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     734        {
     735            skip_start( outPoly == NULL, 1,
     736                        "Skipping 1 tests because psPolynomial4DfromMetadata has errors.");
     737            ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
     738                outPoly->nY == 1 && outPoly->nZ == 1 && outPoly->nT == 1 &&
     739                abs(outPoly->coeff[0][0][0][0] - 1.1) < DBL_EPSILON,
     740                "psPolynomial4DfromMetadata:   return correct polynomial from metadata");
     741            skip_end();
     742        }
     743        //Get a polynomial from Metadata with mask[0][0][0][0] == 1.
     744        psFree(outPoly);
     745        outPoly = NULL;
     746        psPolynomial4D *maskPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0);
     747        maskPoly->coeff[0][0][0][0] = 6.66;
     748        maskPoly->mask[0][0][0][0] = 1;
     749        psMetadata *newmd = psMetadataAlloc();
     750        psPolynomial4DtoMetadata(newmd, maskPoly, "polyMD");
     751        psMetadata *polyMask = psMetadataLookupMetadata(NULL, newmd, "polyMD");
     752        outPoly = psPolynomial4DfromMetadata(polyMask);
     753        {
     754            ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 0 && outPoly->nY == 0
     755                && outPoly->nZ == 0 && outPoly->nT == 0 && outPoly->mask[0][0][0][0] == 1,
     756                "psPolynomial4DfromMetadata:   return correct polynomial (w/mask) from metadata");
     757        }
     758        psFree(maskPoly);
     759        psFree(newmd);
     760        //Return NULL for wrong NELEMENTS
     761        psMetadataItem *nElementItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
     762        nElementItem->data.S32 -= 1;
     763        psFree(outPoly);
     764        outPoly = NULL;
     765        outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     766        {
     767            ok( outPoly == NULL,
     768                "psPolynomial4DfromMetadata:   "
     769                "return NULL for metadata-polynomial with wrong NELEMENTS");
     770        }
     771        //Return NULL for missing NELEMENTS
     772        psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL);
     773        psFree(outPoly);
     774        outPoly = NULL;
     775        outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     776        {
     777            ok( outPoly == NULL,
     778                "psPolynomial4DfromMetadata:   "
     779                "return NULL for metadata-polynomial with no NELEMENTS");
     780        }
     781   
     782        //Return NULL for polynomial in metadata with no t-order
     783        psMetadataRemoveKey(polyMDtemp, "NORDER_T");
     784        psFree(outPoly);
     785        outPoly = NULL;
     786        outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     787        {
     788            ok( outPoly == NULL,
     789                "psPolynomial4DfromMetadata:   return NULL for metadata-polynomial with no t-order");
     790        }
     791        //Return NULL for polynomial in metadata with no z-order
     792        psMetadataRemoveKey(polyMDtemp, "NORDER_Z");
     793        psFree(outPoly);
     794        outPoly = NULL;
     795        outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     796        {
     797            ok( outPoly == NULL,
     798                "psPolynomial4DfromMetadata:   return NULL for metadata-polynomial with no z-order");
     799        }
     800        //Return NULL for polynomial in metadata with no y-order
     801        psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
     802        psFree(outPoly);
     803        outPoly = NULL;
     804        outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     805        {
     806            ok( outPoly == NULL,
     807                "psPolynomial4DfromMetadata:   return NULL for metadata-polynomial with no y-order");
     808        }
     809        //Return NULL for polynomial in metadata with no x-order
     810        psMetadataRemoveKey(polyMDtemp, "NORDER_X");
     811        psFree(outPoly);
     812        outPoly = NULL;
     813        outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     814        {
     815            ok( outPoly == NULL,
     816                "psPolynomial4DfromMetadata:   return NULL for metadata-polynomial with no x-order");
     817        }
     818   
     819        psFree(outPoly);
     820        psFree(p4d);
     821        psFree(md);
     822        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    195823    }
    196824}
    197 
    198 void test2Dcase(void)
    199 {
    200     note("  >>>Test 2:  psPolynomial2DtoMetadata & psPolynomial2DfromMetadata functions");
    201     psMetadata *md = psMetadataAlloc();
    202     psPolynomial2D *p2d = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 1, 1);
    203     p2d->coeff[0][0] = 1.1;
    204     p2d->coeff[0][1] = 2.2;
    205     p2d->coeff[1][0] = 3.3;
    206     p2d->coeff[1][1] = 4.4;
    207     p2d->coeffErr[0][0] = 0.1;
    208     p2d->coeffErr[0][1] = 0.2;
    209     p2d->coeffErr[1][0] = 0.3;
    210     p2d->coeffErr[1][1] = 0.4;
    211 
    212     //psPolynomial2DtoMetadata
    213     //Return a valid metadata containing a polynomial-metadata structure
    214     {
    215         ok( psPolynomial2DtoMetadata(md, p2d, "polyMD"),
    216             "psPolynomial2DtoMetadata:     return true for valid inputs.");
    217 
    218         // psMetadataConfigWrite (md, "test.md");
    219 
    220         //XXX        ok (0, "these tests are relying on the ORDER of the MD components not the NAMES");
    221         //XXX        ok (0, "these seem like irrelevant tests");
    222         psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
    223         skip_start( polyMDtemp == NULL , 1,
    224                     "Skipping 1 tests because psPolynomial2DtoMetadata has errors");
    225         psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0);
    226         skip_start( polyItem == NULL, 2,
    227                     "Skipping 2 tests because psPolynomial2DtoMetadata has errors in order elements");
    228         ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1,
    229             "psPolynomial2DtoMetadata:     return correct number of x orders.");
    230         polyItem = psMetadataGet(polyMDtemp, 1);
    231         ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1,
    232             "psPolynomial2DtoMetadata:     return correct number of y orders.");
    233         skip_end();
    234         polyItem = psMetadataGet(polyMDtemp, 2);
    235         skip_start( polyItem == NULL, 2,
    236                     "Skipping 2 tests because psPolynomial2DtoMetadata has errors in coeff elements");
    237         ok( !strncmp(polyItem->name, "VAL_X00_Y00", 14) &&
    238             abs(polyItem->data.F64-1.1) < DBL_EPSILON,
    239             "psPolynomial2DtoMetadata:     return correct first element.");
    240         polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL-1);
    241         ok( !strncmp(polyItem->name, "ERR_X01_Y01", 14) &&
    242             abs(polyItem->data.F64-0.4) < DBL_EPSILON,
    243             "psPolynomial2DtoMetadata:     return correct last element.");
    244         skip_end();
    245         skip_end();
    246     }
    247 
    248     //psPolynomial2DtoMetadata
    249     //Return a valid metadata containing a polynomial-metadata structure
    250     {
    251         note ("example of 2DtoMD using the names not the sequence");
    252 
    253         ok( psPolynomial2DtoMetadata(md, p2d, "polyMD"),
    254             "psPolynomial2DtoMetadata:     return true for valid inputs.");
    255 
    256         // psMetadataConfigWrite (md, "test.md");
    257 
    258         // of the components.  these seem like irrelevant tests.
    259         psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
    260         skip_start( polyMDtemp == NULL , 1,
    261                     "Skipping 1 tests because psPolynomial2DtoMetadata has errors");
    262 
    263         bool status;
    264         int nX = psMetadataLookupS32(&status, polyMDtemp, "NORDER_X");
    265         ok(status,
    266            "psPolynomial2DtoMetadata:     found NORDER_X");
    267         ok(nX == 1,
    268            "psPolynomial2DtoMetadata:     NORDER_X is 1");
    269 
    270         int nY = psMetadataLookupS32(&status, polyMDtemp, "NORDER_Y");
    271         ok(status,
    272            "psPolynomial2DtoMetadata:     found NORDER_Y");
    273         ok(nY == 1,
    274            "psPolynomial2DtoMetadata:     NORDER_Y is 1");
    275 
    276         double val;
    277         val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X00_Y00");
    278         ok(status,
    279            "psPolynomial2DtoMetadata:     found VAL_X00_Y00");
    280         is_double(val, 1.1,
    281                   "psPolynomial2DtoMetadata:     VAL_X00_Y00 is %lf", val);
    282 
    283         val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X01_Y01");
    284         ok(status,
    285            "psPolynomial2DtoMetadata:     found VAL_X01_Y01");
    286         is_double(val, 4.4,
    287                   "psPolynomial2DtoMetadata:     VAL_X01_Y01 is %lf", val);
    288 
    289         skip_end();
    290     }
    291 
    292     //Return false for no-name polynomial
    293     {
    294         ok( !psPolynomial2DtoMetadata(md, p2d, ""),
    295             "psPolynomial2DtoMetadata:     return false for no-name.");
    296     }
    297     //Return false for NULL-name polynomial
    298     {
    299         ok( !psPolynomial2DtoMetadata(md, p2d, NULL),
    300             "psPolynomial2DtoMetadata:     return false for NULL name input.");
    301     }
    302     //Return false for NULL metadata input
    303     {
    304         ok( !psPolynomial2DtoMetadata(NULL, p2d, "polyMD"),
    305             "psPolynomial2DtoMetadata:     return false for NULL metadata input.");
    306     }
    307     //Return false for NULL polynomial input
    308     {
    309         ok( !psPolynomial2DtoMetadata(md, NULL, "polyMD"),
    310             "psPolynomial2DtoMetadata:     return false for NULL polynomial input.");
    311     }
    312     //Return true for polynomial with 1 element, a constant
    313     {
    314         psPolynomial2D *constPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0);
    315         constPoly->coeff[0][0] = 6.66;
    316         ok( psPolynomial2DtoMetadata(md, constPoly, "polyMD"),
    317             "psPolynomial2DtoMetadata:     return true for constant polynomial (1 element != 0).");
    318         psFree(constPoly);
    319     }
    320     //Return false for non-ordinary polynomial
    321     {
    322         psPolynomial2D *p2d2 = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, 1, 1);
    323         p2d2->coeff[0][0] = 1.1;
    324         ok( !psPolynomial2DtoMetadata(md, p2d2, "polyMD"),
    325             "psPolynomial2DtoMetadata:     return false for chebyshev polynomial");
    326         psFree(p2d2);
    327     }
    328 
    329     //psPolynomial2DfromMetadata Tests
    330     //Return NULL for NULL metadata input.
    331     {
    332         psPolynomial2D *emptyPoly2D = NULL;
    333         emptyPoly2D = psPolynomial2DfromMetadata(NULL);
    334         ok( emptyPoly2D == NULL,
    335             "psPolynomial2DfromMetadata:   return NULL for NULL metadata input.");
    336     }
    337     //Get a polynomial from Metadata.
    338     psPolynomial2D *outPoly = NULL;
    339     psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
    340     outPoly = psPolynomial2DfromMetadata(polyMDtemp);
    341     {
    342         skip_start( outPoly == NULL, 1,
    343                     "Skipping 1 tests because psPolynomial2DfromMetadata has errors.");
    344         ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
    345             outPoly->nY == 1 && abs(outPoly->coeff[0][0] - 1.1) < DBL_EPSILON,
    346             "psPolynomial2DfromMetadata:   return correct polynomial from metadata");
    347         skip_end();
    348     }
    349     //Get a polynomial from Metadata with mask[0][0] == 1.
    350     psFree(outPoly);
    351     outPoly = NULL;
    352     psPolynomial2D *maskPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0);
    353     maskPoly->coeff[0][0] = 6.66;
    354     maskPoly->mask[0][0] = 1;
    355     psMetadata *newmd = psMetadataAlloc();
    356     psPolynomial2DtoMetadata(newmd, maskPoly, "polyMD");
    357     psMetadata *polyMask = psMetadataLookupMetadata(NULL, newmd, "polyMD");
    358     outPoly = psPolynomial2DfromMetadata(polyMask);
    359     {
    360         ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 0 &&
    361             outPoly->nY == 0 && outPoly->mask[0][0] == 1,
    362             "psPolynomial2DfromMetadata:   return correct polynomial (w/mask) from metadata");
    363     }
    364     psFree(maskPoly);
    365     psFree(newmd);
    366     //Return NULL for wrong NELEMENTS
    367     psMetadataItem *nElementItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
    368     nElementItem->data.S32 -= 1;
    369     psFree(outPoly);
    370     outPoly = NULL;
    371     outPoly = psPolynomial2DfromMetadata(polyMDtemp);
    372     {
    373         ok( outPoly == NULL,
    374             "psPolynomial2DfromMetadata:   "
    375             "return NULL for metadata-polynomial with wrong NELEMENTS");
    376     }
    377     //Return NULL for missing NELEMENTS
    378     psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL);
    379     psFree(outPoly);
    380     outPoly = NULL;
    381     outPoly = psPolynomial2DfromMetadata(polyMDtemp);
    382     {
    383         ok( outPoly == NULL,
    384             "psPolynomial2DfromMetadata:   "
    385             "return NULL for metadata-polynomial with no NELEMENTS");
    386     }
    387 
    388     //Return NULL for polynomial in metadata with no y-order
    389     psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
    390     psFree(outPoly);
    391     outPoly = NULL;
    392     outPoly = psPolynomial2DfromMetadata(polyMDtemp);
    393     {
    394         ok( outPoly == NULL,
    395             "psPolynomial2DfromMetadata:   "
    396             "return NULL for metadata-polynomial with no y-order");
    397     }
    398     //Return NULL for polynomial in metadata with no x-order
    399     psMetadataRemoveKey(polyMDtemp, "NORDER_X");
    400     psFree(outPoly);
    401     outPoly = NULL;
    402     outPoly = psPolynomial2DfromMetadata(polyMDtemp);
    403     {
    404         ok( outPoly == NULL,
    405             "psPolynomial2DfromMetadata:   "
    406             "return NULL for metadata-polynomial with no x-order");
    407     }
    408 
    409     //Check for Memory leaks
    410     {
    411         psFree(outPoly);
    412         psFree(p2d);
    413         psFree(md);
    414         checkMem();
    415     }
    416 }
    417 
    418 void test3Dcase(void)
    419 {
    420     note("  >>>Test 3:  psPolynomial3DtoMetadata & psPolynomial3DfromMetadata functions");
    421     psMetadata *md = psMetadataAlloc();
    422     psPolynomial3D *p3d = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1);
    423     p3d->coeff[0][0][0] = 1.1;
    424     p3d->coeff[1][0][0] = 2.2;
    425     p3d->coeff[0][1][0] = 3.3;
    426     p3d->coeff[0][0][1] = 4.4;
    427     p3d->coeff[1][1][0] = 5.5;
    428     p3d->coeff[1][0][1] = 6.6;
    429     p3d->coeff[0][1][1] = 7.7;
    430     p3d->coeff[1][1][1] = 8.8;
    431     p3d->coeffErr[0][0][0] = 0.1;
    432     p3d->coeffErr[1][0][0] = 0.2;
    433     p3d->coeffErr[0][1][0] = 0.3;
    434     p3d->coeffErr[0][0][1] = 0.4;
    435     p3d->coeffErr[1][1][0] = 0.5;
    436     p3d->coeffErr[1][0][1] = 0.6;
    437     p3d->coeffErr[0][1][1] = 0.7;
    438     p3d->coeffErr[1][1][1] = 0.8;
    439 
    440     //psPolynomial3DtoMetadata
    441     //Return a valid metadata containing a polynomial-metadata structure
    442     {
    443         ok( psPolynomial3DtoMetadata(md, p3d, "polyMD"),
    444             "psPolynomial3DtoMetadata:     return true for valid inputs.");
    445         psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
    446         skip_start( polyMDtemp == NULL , 1,
    447                     "Skipping 1 tests because psPolynomial3DtoMetadata has errors");
    448         psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0);
    449         skip_start( polyItem == NULL, 2,
    450                     "Skipping 3 tests because psPolynomial3DtoMetadata has errors in order elements");
    451         ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1,
    452             "psPolynomial3DtoMetadata:     return correct number of x orders.");
    453         polyItem = psMetadataGet(polyMDtemp, 1);
    454         ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1,
    455             "psPolynomial3DtoMetadata:     return correct number of y orders.");
    456         polyItem = psMetadataGet(polyMDtemp, 2);
    457         ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1,
    458             "psPolynomial3DtoMetadata:     return correct number of z orders.");
    459         skip_end();
    460         polyItem = psMetadataGet(polyMDtemp, 3);
    461         skip_start( polyItem == NULL, 2,
    462                     "Skipping 2 tests because psPolynomial3DtoMetadata has errors in coeff elements");
    463         ok( !strncmp(polyItem->name, "VAL_X00_Y00_Z00", 14) &&
    464             abs(polyItem->data.F64-1.1) < DBL_EPSILON,
    465             "psPolynomial3DtoMetadata:     return correct first element.");
    466         polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL-1);
    467         ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01", 14) &&
    468             abs(polyItem->data.F64-0.8) < DBL_EPSILON,
    469             "psPolynomial3DtoMetadata:     return correct last element.");
    470         skip_end();
    471         skip_end();
    472     }
    473     //Return false for no-name polynomial
    474     {
    475         ok( !psPolynomial3DtoMetadata(md, p3d, ""),
    476             "psPolynomial3DtoMetadata:     return false for no-name.");
    477     }
    478     //Return false for NULL-name polynomial
    479     {
    480         ok( !psPolynomial3DtoMetadata(md, p3d, NULL),
    481             "psPolynomial3DtoMetadata:     return false for NULL name input.");
    482     }
    483     //Return false for NULL metadata input
    484     {
    485         ok( !psPolynomial3DtoMetadata(NULL, p3d, "polyMD"),
    486             "psPolynomial3DtoMetadata:     return false for NULL metadata input.");
    487     }
    488     //Return false for NULL polynomial input
    489     {
    490         ok( !psPolynomial3DtoMetadata(md, NULL, "polyMD"),
    491             "psPolynomial3DtoMetadata:     return false for NULL polynomial input.");
    492     }
    493     /*    //Return false for empty polynomial
    494         {
    495             psPolynomial3D *emptyPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0);
    496             ok( !psPolynomial3DtoMetadata(md, emptyPoly, "polyMD"),
    497                 "psPolynomial3DtoMetadata:     return false for empty polynomial input.");
    498             psFree(emptyPoly);
    499         }
    500     */
    501     //Return true for polynomial with 1 element, a constant
    502     {
    503         psPolynomial3D *constPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0);
    504         constPoly->coeff[0][0][0] = 6.66;
    505         ok( psPolynomial3DtoMetadata(md, constPoly, "polyMD"),
    506             "psPolynomial3DtoMetadata:     return true for constant polynomial (1 element != 0).");
    507         psFree(constPoly);
    508     }
    509     //Return false for non-ordinary polynomial
    510     {
    511         psPolynomial3D *p3d2 = psPolynomial3DAlloc(PS_POLYNOMIAL_CHEB, 1, 1, 1);
    512         p3d2->coeff[0][0][0] = 1.1;
    513         ok( !psPolynomial3DtoMetadata(md, p3d2, "polyMD"),
    514             "psPolynomial3DtoMetadata:     return false for chebyshev polynomial");
    515         psFree(p3d2);
    516     }
    517 
    518     //psPolynomial3DfromMetadata Tests
    519     //Return NULL for NULL metadata input.
    520     {
    521         psPolynomial3D *emptyPoly2D = NULL;
    522         emptyPoly2D = psPolynomial3DfromMetadata(NULL);
    523         ok( emptyPoly2D == NULL,
    524             "psPolynomial3DfromMetadata:   return NULL for NULL metadata input.");
    525     }
    526     //Get a polynomial from Metadata.
    527     psPolynomial3D *outPoly = NULL;
    528     psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
    529     outPoly = psPolynomial3DfromMetadata(polyMDtemp);
    530     {
    531         skip_start( outPoly == NULL, 1,
    532                     "Skipping 1 tests because psPolynomial3DfromMetadata has errors.");
    533         ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
    534             outPoly->nY == 1 && outPoly->nZ == 1 &&
    535             abs(outPoly->coeff[0][0][0] - 1.1) < DBL_EPSILON,
    536             "psPolynomial3DfromMetadata:   return correct polynomial from metadata");
    537         skip_end();
    538     }
    539 
    540     //Get a polynomial from Metadata with mask[0][0][0] == 1.
    541     psFree(outPoly);
    542     outPoly = NULL;
    543     psPolynomial3D *maskPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0);
    544     maskPoly->coeff[0][0][0] = 6.66;
    545     maskPoly->mask[0][0][0] = 1;
    546     psMetadata *newmd = psMetadataAlloc();
    547     psPolynomial3DtoMetadata(newmd, maskPoly, "polyMD");
    548     psMetadata *polyMask = psMetadataLookupMetadata(NULL, newmd, "polyMD");
    549     outPoly = psPolynomial3DfromMetadata(polyMask);
    550     {
    551         ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 0 && outPoly->nY == 0
    552             && outPoly->nZ == 0 && outPoly->mask[0][0][0] == 1,
    553             "psPolynomial3DfromMetadata:   return correct polynomial (w/mask) from metadata");
    554     }
    555     psFree(maskPoly);
    556     psFree(newmd);
    557     //Return NULL for wrong NELEMENTS
    558     psMetadataItem *nElementItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
    559     nElementItem->data.S32 -= 1;
    560     psFree(outPoly);
    561     outPoly = NULL;
    562     outPoly = psPolynomial3DfromMetadata(polyMDtemp);
    563     {
    564         ok( outPoly == NULL,
    565             "psPolynomial3DfromMetadata:   "
    566             "return NULL for metadata-polynomial with wrong NELEMENTS");
    567     }
    568     //Return NULL for missing NELEMENTS
    569     psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL);
    570     psFree(outPoly);
    571     outPoly = NULL;
    572     outPoly = psPolynomial3DfromMetadata(polyMDtemp);
    573     {
    574         ok( outPoly == NULL,
    575             "psPolynomial3DfromMetadata:   "
    576             "return NULL for metadata-polynomial with no NELEMENTS");
    577     }
    578 
    579     //Return NULL for polynomial in metadata with no z-order
    580     psMetadataRemoveKey(polyMDtemp, "NORDER_Z");
    581     psFree(outPoly);
    582     outPoly = NULL;
    583     outPoly = psPolynomial3DfromMetadata(polyMDtemp);
    584     {
    585         ok( outPoly == NULL,
    586             "psPolynomial3DfromMetadata:   return NULL for metadata-polynomial with no z-order");
    587     }
    588     //Return NULL for polynomial in metadata with no y-order
    589     psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
    590     psFree(outPoly);
    591     outPoly = NULL;
    592     outPoly = psPolynomial3DfromMetadata(polyMDtemp);
    593     {
    594         ok( outPoly == NULL,
    595             "psPolynomial3DfromMetadata:   return NULL for metadata-polynomial with no y-order");
    596     }
    597     //Return NULL for polynomial in metadata with no x-order
    598     psMetadataRemoveKey(polyMDtemp, "NORDER_X");
    599     psFree(outPoly);
    600     outPoly = NULL;
    601     outPoly = psPolynomial3DfromMetadata(polyMDtemp);
    602     {
    603         ok( outPoly == NULL,
    604             "psPolynomial3DfromMetadata:   return NULL for metadata-polynomial with no x-order");
    605     }
    606 
    607     //Check for Memory leaks
    608     {
    609         psFree(outPoly);
    610         psFree(p3d);
    611         psFree(md);
    612         checkMem();
    613     }
    614 }
    615 
    616 void test4Dcase(void)
    617 {
    618     note("  >>>Test 4:  psPolynomial4DtoMetadata & psPolynomial4DfromMetadata functions");
    619     psMetadata *md = psMetadataAlloc();
    620     psPolynomial4D *p4d = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1, 1);
    621     p4d->coeff[0][0][0][0] = 1.1;
    622     p4d->coeff[0][0][0][1] = 2.2;
    623     p4d->coeff[0][0][1][0] = 3.3;
    624     p4d->coeff[0][1][0][0] = 4.4;
    625     p4d->coeff[1][0][0][0] = 5.5;
    626 
    627     p4d->coeff[0][0][1][1] = 6.6;
    628     p4d->coeff[0][1][0][1] = 7.7;
    629     p4d->coeff[1][0][0][1] = 8.8;
    630     p4d->coeff[0][1][1][0] = 9.9;
    631     p4d->coeff[1][0][1][0] = 10.10;
    632     p4d->coeff[1][1][0][0] = 11.11;
    633 
    634     p4d->coeff[0][1][1][1] = 12.12;
    635     p4d->coeff[1][0][1][1] = 13.13;
    636     p4d->coeff[1][1][0][1] = 14.14;
    637     p4d->coeff[1][1][1][0] = 15.15;
    638 
    639     p4d->coeff[1][1][1][1] = 16.16;
    640 
    641     p4d->coeffErr[0][0][0][0] = 0.1;
    642     p4d->coeffErr[0][0][0][1] = 0.2;
    643     p4d->coeffErr[0][0][1][0] = 0.3;
    644     p4d->coeffErr[0][1][0][0] = 0.4;
    645     p4d->coeffErr[1][0][0][0] = 0.5;
    646 
    647     p4d->coeffErr[0][0][1][1] = 0.6;
    648     p4d->coeffErr[0][1][0][1] = 0.7;
    649     p4d->coeffErr[1][0][0][1] = 0.8;
    650     p4d->coeffErr[0][1][1][0] = 0.9;
    651     p4d->coeffErr[1][0][1][0] = 0.10;
    652     p4d->coeffErr[1][1][0][0] = 0.11;
    653 
    654     p4d->coeffErr[0][1][1][1] = 0.12;
    655     p4d->coeffErr[1][0][1][1] = 0.13;
    656     p4d->coeffErr[1][1][0][1] = 0.14;
    657     p4d->coeffErr[1][1][1][0] = 0.15;
    658 
    659     p4d->coeffErr[1][1][1][1] = 0.16;
    660 
    661     //psPolynomial4DtoMetadata
    662     //Return a valid metadata containing a polynomial-metadata structure
    663     {
    664         ok( psPolynomial4DtoMetadata(md, p4d, "polyMD"),
    665             "psPolynomial4DtoMetadata:     return true for valid inputs.");
    666         psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
    667         skip_start( polyMDtemp == NULL , 1,
    668                     "Skipping 1 tests because psPolynomial4DtoMetadata has errors");
    669         psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0);
    670         skip_start( polyItem == NULL, 2,
    671                     "Skipping 4 tests because psPolynomial4DtoMetadata has errors in order elements");
    672         ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1,
    673             "psPolynomial4DtoMetadata:     return correct number of x orders.");
    674         polyItem = psMetadataGet(polyMDtemp, 1);
    675         ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1,
    676             "psPolynomial4DtoMetadata:     return correct number of y orders.");
    677         polyItem = psMetadataGet(polyMDtemp, 2);
    678         ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1,
    679             "psPolynomial4DtoMetadata:     return correct number of z orders.");
    680         polyItem = psMetadataGet(polyMDtemp, 3);
    681         ok( !strncmp(polyItem->name, "NORDER_T", 10) && polyItem->data.S32 == 1,
    682             "psPolynomial4DtoMetadata:     return correct number of t orders.");
    683         skip_end();
    684         polyItem = psMetadataGet(polyMDtemp, 4);
    685         skip_start( polyItem == NULL, 2,
    686                     "Skipping 2 tests because psPolynomial4DtoMetadata has errors in coeff elements");
    687         ok( !strncmp(polyItem->name, "VAL_X00_Y00_Z00_T00", 14) &&
    688             abs(polyItem->data.F64-1.1) < DBL_EPSILON,
    689             "psPolynomial4DtoMetadata:     return correct first element.");
    690         polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL-1);
    691         ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01_T01", 14) &&
    692             abs(polyItem->data.F64-0.16) < DBL_EPSILON,
    693             "psPolynomial4DtoMetadata:     return correct last element.");
    694         skip_end();
    695         skip_end();
    696     }
    697     //Return false for no-name polynomial
    698     {
    699         ok( !psPolynomial4DtoMetadata(md, p4d, ""),
    700             "psPolynomial4DtoMetadata:     return false for no-name.");
    701     }
    702     //Return false for NULL-name polynomial
    703     {
    704         ok( !psPolynomial4DtoMetadata(md, p4d, NULL),
    705             "psPolynomial4DtoMetadata:     return false for NULL name input.");
    706     }
    707     //Return false for NULL metadata input
    708     {
    709         ok( !psPolynomial4DtoMetadata(NULL, p4d, "polyMD"),
    710             "psPolynomial4DtoMetadata:     return false for NULL metadata input.");
    711     }
    712     //Return false for NULL polynomial input
    713     {
    714         ok( !psPolynomial4DtoMetadata(md, NULL, "polyMD"),
    715             "psPolynomial4DtoMetadata:     return false for NULL polynomial input.");
    716     }
    717     /*    //Return false for empty polynomial
    718         {
    719             psPolynomial4D *emptyPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0);
    720             ok( !psPolynomial4DtoMetadata(md, emptyPoly, "polyMD"),
    721                 "psPolynomial4DtoMetadata:     return false for empty polynomial input.");
    722             psFree(emptyPoly);
    723         }
    724     */
    725     //Return true for polynomial with 1 element, a constant
    726     {
    727         psPolynomial4D *constPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0);
    728         constPoly->coeff[0][0][0][0] = 6.66;
    729         ok( psPolynomial4DtoMetadata(md, constPoly, "polyMD"),
    730             "psPolynomial4DtoMetadata:     return true for constant polynomial (1 element != 0).");
    731         psFree(constPoly);
    732     }
    733     //Return false for non-ordinary polynomial
    734     {
    735         psPolynomial4D *p4d2 = psPolynomial4DAlloc(PS_POLYNOMIAL_CHEB, 1, 1, 1, 1);
    736         p4d2->coeff[0][0][0][0] = 1.1;
    737         ok( !psPolynomial4DtoMetadata(md, p4d2, "polyMD"),
    738             "psPolynomial4DtoMetadata:     return false for chebyshev polynomial");
    739         psFree(p4d2);
    740     }
    741 
    742     //psPolynomial4DfromMetadata Tests
    743     //Return NULL for NULL metadata input.
    744     {
    745         psPolynomial4D *emptyPoly2D = NULL;
    746         emptyPoly2D = psPolynomial4DfromMetadata(NULL);
    747         ok( emptyPoly2D == NULL,
    748             "psPolynomial4DfromMetadata:   return NULL for NULL metadata input.");
    749     }
    750     //Get a polynomial from Metadata.
    751     psPolynomial4D *outPoly = NULL;
    752     psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
    753     outPoly = psPolynomial4DfromMetadata(polyMDtemp);
    754     {
    755         skip_start( outPoly == NULL, 1,
    756                     "Skipping 1 tests because psPolynomial4DfromMetadata has errors.");
    757         ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
    758             outPoly->nY == 1 && outPoly->nZ == 1 && outPoly->nT == 1 &&
    759             abs(outPoly->coeff[0][0][0][0] - 1.1) < DBL_EPSILON,
    760             "psPolynomial4DfromMetadata:   return correct polynomial from metadata");
    761         skip_end();
    762     }
    763     //Get a polynomial from Metadata with mask[0][0][0][0] == 1.
    764     psFree(outPoly);
    765     outPoly = NULL;
    766     psPolynomial4D *maskPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0);
    767     maskPoly->coeff[0][0][0][0] = 6.66;
    768     maskPoly->mask[0][0][0][0] = 1;
    769     psMetadata *newmd = psMetadataAlloc();
    770     psPolynomial4DtoMetadata(newmd, maskPoly, "polyMD");
    771     psMetadata *polyMask = psMetadataLookupMetadata(NULL, newmd, "polyMD");
    772     outPoly = psPolynomial4DfromMetadata(polyMask);
    773     {
    774         ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 0 && outPoly->nY == 0
    775             && outPoly->nZ == 0 && outPoly->nT == 0 && outPoly->mask[0][0][0][0] == 1,
    776             "psPolynomial4DfromMetadata:   return correct polynomial (w/mask) from metadata");
    777     }
    778     psFree(maskPoly);
    779     psFree(newmd);
    780     //Return NULL for wrong NELEMENTS
    781     psMetadataItem *nElementItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
    782     nElementItem->data.S32 -= 1;
    783     psFree(outPoly);
    784     outPoly = NULL;
    785     outPoly = psPolynomial4DfromMetadata(polyMDtemp);
    786     {
    787         ok( outPoly == NULL,
    788             "psPolynomial4DfromMetadata:   "
    789             "return NULL for metadata-polynomial with wrong NELEMENTS");
    790     }
    791     //Return NULL for missing NELEMENTS
    792     psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL);
    793     psFree(outPoly);
    794     outPoly = NULL;
    795     outPoly = psPolynomial4DfromMetadata(polyMDtemp);
    796     {
    797         ok( outPoly == NULL,
    798             "psPolynomial4DfromMetadata:   "
    799             "return NULL for metadata-polynomial with no NELEMENTS");
    800     }
    801 
    802     //Return NULL for polynomial in metadata with no t-order
    803     psMetadataRemoveKey(polyMDtemp, "NORDER_T");
    804     psFree(outPoly);
    805     outPoly = NULL;
    806     outPoly = psPolynomial4DfromMetadata(polyMDtemp);
    807     {
    808         ok( outPoly == NULL,
    809             "psPolynomial4DfromMetadata:   return NULL for metadata-polynomial with no t-order");
    810     }
    811     //Return NULL for polynomial in metadata with no z-order
    812     psMetadataRemoveKey(polyMDtemp, "NORDER_Z");
    813     psFree(outPoly);
    814     outPoly = NULL;
    815     outPoly = psPolynomial4DfromMetadata(polyMDtemp);
    816     {
    817         ok( outPoly == NULL,
    818             "psPolynomial4DfromMetadata:   return NULL for metadata-polynomial with no z-order");
    819     }
    820     //Return NULL for polynomial in metadata with no y-order
    821     psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
    822     psFree(outPoly);
    823     outPoly = NULL;
    824     outPoly = psPolynomial4DfromMetadata(polyMDtemp);
    825     {
    826         ok( outPoly == NULL,
    827             "psPolynomial4DfromMetadata:   return NULL for metadata-polynomial with no y-order");
    828     }
    829     //Return NULL for polynomial in metadata with no x-order
    830     psMetadataRemoveKey(polyMDtemp, "NORDER_X");
    831     psFree(outPoly);
    832     outPoly = NULL;
    833     outPoly = psPolynomial4DfromMetadata(polyMDtemp);
    834     {
    835         ok( outPoly == NULL,
    836             "psPolynomial4DfromMetadata:   return NULL for metadata-polynomial with no x-order");
    837     }
    838 
    839     //Check for Memory leaks
    840     {
    841         psFree(outPoly);
    842         psFree(p4d);
    843         psFree(md);
    844         checkMem();
    845     }
    846 }
    847 
    848 
    849 
    850 
     825   
     826
     827
     828

  • trunk/psLib/test/types/tap_psMetadata_printing.c

    r12440 r12781  
    1010 *
    1111 */
    12 
    1312#include <fcntl.h>
    1413#include <unistd.h>
    1514#include <pslib.h>
    16 
    1715#include "tap.h"
    1816#include "pstap.h"
    19 
    20 static psMetadata *setupMeta(void);
    21 void testMetaPrint(void);
    22 void testMetaItemPrint(void);
    23 
    24 int main(void)
    25 {
    26     plan_tests(29);
    27 
    28     note("psMetadataPrint and psMetadataItemPrint tests");
    29 
    30     testMetaPrint();
    31     testMetaItemPrint();
    32 
    33     done();
    34 }
    3517
    3618static psMetadata *setupMeta(void)
    … …  
    179161}
    180162
    181 void testMetaPrint(void)
     163
     164int main(void)
    182165{
    183     note("  >>Test 1:  psMetadataPrint");
    184     FILE *fd = fopen("psMetadataPrint.out", "w+");
    185     FILE *fd_read = fopen("Makefile", "r");
    186     psMetadata *md = NULL;
    187     psMetadata *md2 = NULL;
    188     md = setupMeta();
    189     md2 = psMetadataAlloc();
    190     psSphere *sphere = psSphereAlloc();
    191     psMetadataAddPtr(md2, PS_LIST_HEAD, "ptr", PS_DATA_SPHERE, "", sphere);
    192     psMetadataAddUnknown(md2, PS_LIST_TAIL, "unknown", 0, "", sphere);
    193 
    194     psImage *image = psImageAlloc(1, 1, PS_TYPE_S32);
    195     psImageSet(image, 0, 0, 1);
    196     psMetadataAddImage(md2, PS_LIST_TAIL, "image1", 0, "I am an Image", image);
    197 
    198     psHash *hash = psHashAlloc(1);
    199     psHashAdd(hash, "hash", image);
    200     psMetadataAddHash(md2, PS_LIST_TAIL, "hash1", 0, "I am a Hash", hash);
    201 
    202     psLookupTable *lookup = psLookupTableAlloc("table2.dat", "%s", 0);
    203     psMetadataAddLookupTable(md2, PS_LIST_TAIL, "lookup", 0, "I am a LookupTable", lookup);
    204 
    205     psArray *array = psArrayAlloc(1);
    206     psArraySet(array, 0, image);
    207     psMetadataAddArray(md2, PS_LIST_TAIL, "array", 0, "I am an Array", array);
    208 
    209     psFree(array);
    210     psFree(lookup);
    211     psFree(image);
    212     psFree(hash);
    213 
    214     //Return false for NULL psMetadata input
     166    psLogSetFormat("HLNM");
     167    psLogSetLevel(PS_LOG_INFO);
     168    plan_tests(30);
     169
     170
     171    // psMetadataPrint
    215172    {
    216         ok( !psMetadataPrint(NULL, NULL, 0),
    217             "psMetadataPrint:            return false for NULL psMetadata input.");
    218     }
    219     //Return false for read-only file descriptor
    220     {
    221         ok ( !psMetadataPrint(fd_read, md, 0),
    222              "psMetadataPrint:            return false for read-only file descriptor.");
    223     }
    224     fclose(fd_read);
    225     //Error and then return true for unprintable datatype (sphere) and DATA_UNKNOWN
    226     {
    227         ok ( !psMetadataPrint(NULL, md2, 0),
    228              "psMetadataPrint:            return false for metadata with unknown datatype.");
    229     }
    230     psFree(md2);
    231 
    232     //Valid case where fd is NULL -> stdout
    233     md2 = psMetadataAlloc();
    234     psMetadataAddStr(md2, PS_LIST_HEAD,
    235                      "  >>Hello Wally", 0, "My name is Bubbles", "Pet Me");
    236     {
    237         ok ( psMetadataPrint(NULL, md2, 0),
    238              "psMetadataPrint:            return true for NULL file pointer.");
    239     }
    240     psFree(md2);
    241     //Valid case where fd is "psMetadataPrint.out"
    242     {
    243         ok ( psMetadataPrint(fd, md, 0),
    244              "psMetadataPrint:            return true for file='psMetadataPrint.out'.");
    245     }
    246 
    247     //Check for Memory Leaks before exit
    248     {
     173        psMemId id = psMemGetId();
     174        FILE *fd = fopen("psMetadataPrint.out", "w+");
     175        FILE *fd_read = fopen("Makefile", "r");
     176        psMetadata *md = NULL;
     177        psMetadata *md2 = NULL;
     178        md = setupMeta();
     179        md2 = psMetadataAlloc();
     180        psSphere *sphere = psSphereAlloc();
     181        psMetadataAddPtr(md2, PS_LIST_HEAD, "ptr", PS_DATA_SPHERE, "", sphere);
     182        psMetadataAddUnknown(md2, PS_LIST_TAIL, "unknown", 0, "", sphere);
     183   
     184        psImage *image = psImageAlloc(1, 1, PS_TYPE_S32);
     185        psImageSet(image, 0, 0, 1);
     186        psMetadataAddImage(md2, PS_LIST_TAIL, "image1", 0, "I am an Image", image);
     187   
     188        psHash *hash = psHashAlloc(1);
     189        psHashAdd(hash, "hash", image);
     190        psMetadataAddHash(md2, PS_LIST_TAIL, "hash1", 0, "I am a Hash", hash);
     191   
     192        psLookupTable *lookup = psLookupTableAlloc("table2.dat", "%s", 0);
     193        psMetadataAddLookupTable(md2, PS_LIST_TAIL, "lookup", 0, "I am a LookupTable", lookup);
     194   
     195        psArray *array = psArrayAlloc(1);
     196        psArraySet(array, 0, image);
     197        psMetadataAddArray(md2, PS_LIST_TAIL, "array", 0, "I am an Array", array);
     198   
     199        psFree(array);
     200        psFree(lookup);
     201        psFree(image);
     202        psFree(hash);
     203   
     204        //Return false for NULL psMetadata input
     205        {
     206            ok( !psMetadataPrint(NULL, NULL, 0),
     207                "psMetadataPrint:            return false for NULL psMetadata input.");
     208        }
     209        //Return false for read-only file descriptor
     210        {
     211            ok ( !psMetadataPrint(fd_read, md, 0),
     212                 "psMetadataPrint:            return false for read-only file descriptor.");
     213        }
     214        fclose(fd_read);
     215        //Error and then return true for unprintable datatype (sphere) and DATA_UNKNOWN
     216        {
     217            ok ( !psMetadataPrint(NULL, md2, 0),
     218                 "psMetadataPrint:            return false for metadata with unknown datatype.");
     219        }
     220        psFree(md2);
     221   
     222        //Valid case where fd is NULL -> stdout
     223        md2 = psMetadataAlloc();
     224        psMetadataAddStr(md2, PS_LIST_HEAD,
     225                         "  >>Hello Wally", 0, "My name is Bubbles", "Pet Me");
     226        {
     227            ok ( psMetadataPrint(NULL, md2, 0),
     228                 "psMetadataPrint:            return true for NULL file pointer.");
     229        }
     230        psFree(md2);
     231        //Valid case where fd is "psMetadataPrint.out"
     232        {
     233            ok ( psMetadataPrint(fd, md, 0),
     234                 "psMetadataPrint:            return true for file='psMetadataPrint.out'.");
     235        }
     236   
     237        //Check for Memory Leaks before exit
    249238        fclose(fd);
    250         remove
    251             ("psMetadataPrint.out");
     239        remove("psMetadataPrint.out");
    252240        psFree(sphere);
    253241        psFree(md);
    254         checkMem();
    255     }
    256 }
    257 
    258 void testMetaItemPrint(void)
    259 {
    260     note("  >>Test2:  psMetadataItemPrint");
    261     FILE *fd;
    262     //bool psMetadataItemPrint(FILE * fd, const char *format, const psMetadataItem* item)
    263     fd = fopen("psMetadataItemPrint.out", "w");
    264     psMetadataItem *item1 = psMetadataItemAlloc("bool", PS_DATA_BOOL, "No Comment", true);
    265     psMetadataItem *item2 = psMetadataItemAlloc("f32", PS_DATA_F32, "No Comment", 0.66601);
    266     psMetadataItem *item3 = psMetadataItemAlloc("string", PS_DATA_STRING, "", "Can't touch this");
    267     psMetadataItem *item4 = psMetadataItemAlloc("U16", PS_DATA_U16, "", 1);
    268     psMetadataItem *item5 = psMetadataItemAlloc("string", PS_DATA_U8, "", "a");
    269 
    270     //Return false for NULL file-pointer
     242        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
     243    }
     244
     245
     246    // psMetadataItemPrint
    271247    {
    272         ok( !psMetadataItemPrint(NULL, "%s", item1),
    273             "psMetadataItemPrint:        return false for NULL FILE*.");
    274     }
    275     //Return false for NULL format paramter
    276     {
    277         ok( !psMetadataItemPrint(fd, NULL, item1),
    278             "psMetadataItemPrint:        return false for NULL format.");
    279     }
    280     //Return false for NULL metadataItem
    281     {
    282         ok( !psMetadataItemPrint(fd, "%s", NULL),
    283             "psMetadataItemPrint:        return false for NULL psMetadataItem.");
    284     }
    285     //Return false for incorrect format parameter
    286     {
    287         ok( !psMetadataItemPrint(fd, "sos \n", item1),
    288             "psMetadataItemPrint:       return false for incorrect format.");
    289     }
    290     //Return false for type that doesn't match format (ie, %s for f32 value)
    291     {
    292         ok( !psMetadataItemPrint(fd, "%s", item2),
    293             "psMetadataItemPrint:       return false for item that doesn't match format.");
    294     }
    295 
    296     //Return false for incorrect format parameter
    297     {
    298         ok( !psMetadataItemPrint(fd, "%z", item1),
    299             "psMetadataItemPrint:       return false for incorrect format.");
    300     }
    301 
    302 
    303     //Return true for format parameter containing additional modifiers (F32)
    304     {
    305         ok( psMetadataItemPrint(fd, "%.3f\n", item2),
    306             "psMetadataItemPrint:       return true for format with .3 modifier.");
    307     }
    308     //Return true for valid string input
    309     {
    310         ok( psMetadataItemPrint(fd, "%s\n", item3),
    311             "psMetadataItemPrint:       return true for valid string case w/s.");
    312     }
    313     //Return true for valid ptr input
    314     {
    315         ok( psMetadataItemPrint(fd, "%p\n", item3),
    316             "psMetadataItemPrint:       return true for valid ptr case w/p.");
    317     }
    318 
    319     //Return true for format = %d, type = int
    320     {
    321         ok( psMetadataItemPrint(fd, "%d\n", item4),
    322             "psMetadataItemPrint:       return true for valid case w/d.");
    323     }
    324     //Return true for format = %i, type = int
    325     {
    326         ok( psMetadataItemPrint(fd, "%i\n", item4),
    327             "psMetadataItemPrint:       return true for valid case w/i.");
    328     }
    329     //Return true for format = %c, type = int
    330     {
    331         ok( psMetadataItemPrint(fd, "%c\n", item5),
    332             "psMetadataItemPrint:       return true for valid case w/c.");
    333     }
    334     //Return true for format = %o, type = int
    335     {
    336         ok( psMetadataItemPrint(fd, "%o\n", item4),
    337             "psMetadataItemPrint:       return true for valid case w/d.");
    338     }
    339     //Return true for format = %u, type = int
    340     {
    341         ok( psMetadataItemPrint(fd, "%u\n", item4),
    342             "psMetadataItemPrint:       return true for valid case w/i.");
    343     }
    344     //Return true for format = %x, type = int
    345     {
    346         ok( psMetadataItemPrint(fd, "%x\n", item5),
    347             "psMetadataItemPrint:       return true for valid case w/c.");
    348     }
    349     //Return true for format = %X, type = int
    350     {
    351         ok( psMetadataItemPrint(fd, "%X\n", item5),
    352             "psMetadataItemPrint:       return true for valid case w/c.");
    353     }
    354 
    355     //Return true for format = %e, type = int
    356     {
    357         ok( psMetadataItemPrint(fd, "%.1e\n", item2),
    358             "psMetadataItemPrint:       return true for valid case w/e.");
    359     }
    360     //Return true for format = %E, type = int
    361     {
    362         ok( psMetadataItemPrint(fd, "%.2E\n", item2),
    363             "psMetadataItemPrint:       return true for valid case w/E.");
    364     }
    365     //Return true for format = %F, type = int
    366     {
    367         ok( psMetadataItemPrint(fd, "%.3F\n", item2),
    368             "psMetadataItemPrint:       return true for valid case w/F.");
    369     }
    370     //Return true for format = %g, type = int
    371     {
    372         ok( psMetadataItemPrint(fd, "%.3g\n", item2),
    373             "psMetadataItemPrint:       return true for valid case w/g.");
    374     }
    375     //Return true for format = %G, type = int
    376     {
    377         ok( psMetadataItemPrint(fd, "%.4G\n", item2),
    378             "psMetadataItemPrint:       return true for valid case w/G.");
    379     }
    380     //Return true for format = %a, type = int
    381     {
    382         ok( psMetadataItemPrint(fd, "%.4a\n", item2),
    383             "psMetadataItemPrint:       return true for valid case w/a.");
    384     }
    385     //Return true for format = %A, type = int
    386     {
    387         ok( psMetadataItemPrint(fd, "%A\n", item2),
    388             "psMetadataItemPrint:       return true for valid case w/A.");
    389     }
    390 
    391     //Check for Memory Leaks before exit
    392     {
     248        psMemId id = psMemGetId();
     249        FILE *fd;
     250        fd = fopen("psMetadataItemPrint.out", "w");
     251        psMetadataItem *item1 = psMetadataItemAlloc("bool", PS_DATA_BOOL, "No Comment", true);
     252        psMetadataItem *item2 = psMetadataItemAlloc("f32", PS_DATA_F32, "No Comment", 0.66601);
     253        psMetadataItem *item3 = psMetadataItemAlloc("string", PS_DATA_STRING, "", "Can't touch this");
     254        psMetadataItem *item4 = psMetadataItemAlloc("U16", PS_DATA_U16, "", 1);
     255        psMetadataItem *item5 = psMetadataItemAlloc("string", PS_DATA_U8, "", "a");
     256   
     257        //Return false for NULL file-pointer
     258        {
     259            ok( !psMetadataItemPrint(NULL, "%s", item1),
     260                "psMetadataItemPrint:        return false for NULL FILE*.");
     261        }
     262        //Return false for NULL format paramter
     263        {
     264            ok( !psMetadataItemPrint(fd, NULL, item1),
     265                "psMetadataItemPrint:        return false for NULL format.");
     266        }
     267        //Return false for NULL metadataItem
     268        {
     269            ok( !psMetadataItemPrint(fd, "%s", NULL),
     270                "psMetadataItemPrint:        return false for NULL psMetadataItem.");
     271        }
     272        //Return false for incorrect format parameter
     273        {
     274            ok( !psMetadataItemPrint(fd, "sos \n", item1),
     275                "psMetadataItemPrint:       return false for incorrect format.");
     276        }
     277        //Return false for type that doesn't match format (ie, %s for f32 value)
     278        {
     279            ok( !psMetadataItemPrint(fd, "%s", item2),
     280                "psMetadataItemPrint:       return false for item that doesn't match format.");
     281        }
     282   
     283        //Return false for incorrect format parameter
     284        {
     285            ok( !psMetadataItemPrint(fd, "%z", item1),
     286                "psMetadataItemPrint:       return false for incorrect format.");
     287        }
     288   
     289   
     290        //Return true for format parameter containing additional modifiers (F32)
     291        {
     292            ok( psMetadataItemPrint(fd, "%.3f\n", item2),
     293                "psMetadataItemPrint:       return true for format with .3 modifier.");
     294        }
     295        //Return true for valid string input
     296        {
     297            ok( psMetadataItemPrint(fd, "%s\n", item3),
     298                "psMetadataItemPrint:       return true for valid string case w/s.");
     299        }
     300        //Return true for valid ptr input
     301        {
     302            ok( psMetadataItemPrint(fd, "%p\n", item3),
     303                "psMetadataItemPrint:       return true for valid ptr case w/p.");
     304        }
     305   
     306        //Return true for format = %d, type = int
     307        {
     308            ok( psMetadataItemPrint(fd, "%d\n", item4),
     309                "psMetadataItemPrint:       return true for valid case w/d.");
     310        }
     311        //Return true for format = %i, type = int
     312        {
     313            ok( psMetadataItemPrint(fd, "%i\n", item4),
     314                "psMetadataItemPrint:       return true for valid case w/i.");
     315        }
     316        //Return true for format = %c, type = int
     317        {
     318            ok( psMetadataItemPrint(fd, "%c\n", item5),
     319                "psMetadataItemPrint:       return true for valid case w/c.");
     320        }
     321        //Return true for format = %o, type = int
     322        {
     323            ok( psMetadataItemPrint(fd, "%o\n", item4),
     324                "psMetadataItemPrint:       return true for valid case w/d.");
     325        }
     326        //Return true for format = %u, type = int
     327        {
     328            ok( psMetadataItemPrint(fd, "%u\n", item4),
     329                "psMetadataItemPrint:       return true for valid case w/i.");
     330        }
     331        //Return true for format = %x, type = int
     332        {
     333            ok( psMetadataItemPrint(fd, "%x\n", item5),
     334                "psMetadataItemPrint:       return true for valid case w/c.");
     335        }
     336        //Return true for format = %X, type = int
     337        {
     338            ok( psMetadataItemPrint(fd, "%X\n", item5),
     339                "psMetadataItemPrint:       return true for valid case w/c.");
     340        }
     341   
     342        //Return true for format = %e, type = int
     343        {
     344            ok( psMetadataItemPrint(fd, "%.1e\n", item2),
     345                "psMetadataItemPrint:       return true for valid case w/e.");
     346        }
     347        //Return true for format = %E, type = int
     348        {
     349            ok( psMetadataItemPrint(fd, "%.2E\n", item2),
     350                "psMetadataItemPrint:       return true for valid case w/E.");
     351        }
     352        //Return true for format = %F, type = int
     353        {
     354            ok( psMetadataItemPrint(fd, "%.3F\n", item2),
     355                "psMetadataItemPrint:       return true for valid case w/F.");
     356        }
     357        //Return true for format = %g, type = int
     358        {
     359            ok( psMetadataItemPrint(fd, "%.3g\n", item2),
     360                "psMetadataItemPrint:       return true for valid case w/g.");
     361        }
     362        //Return true for format = %G, type = int
     363        {
     364            ok( psMetadataItemPrint(fd, "%.4G\n", item2),
     365                "psMetadataItemPrint:       return true for valid case w/G.");
     366        }
     367        //Return true for format = %a, type = int
     368        {
     369            ok( psMetadataItemPrint(fd, "%.4a\n", item2),
     370                "psMetadataItemPrint:       return true for valid case w/a.");
     371        }
     372        //Return true for format = %A, type = int
     373        {
     374            ok( psMetadataItemPrint(fd, "%A\n", item2),
     375                "psMetadataItemPrint:       return true for valid case w/A.");
     376        }
     377   
    393378        fclose(fd);
    394379        unlink ("psMetadataItemPrint.out");
    … …  
    398383        psFree(item4);
    399384        psFree(item5);
    400         checkMem();
     385        ok(!psMemCheckLeaks(id, NULL, NULL, false), "no memory leaks");
    401386    }
    402387}

  • trunk/psLib/test/types/tap_psPixels_all.c

    r12512 r12781  
    1212 *
    1313 */
    14 
    1514#include <pslib.h>
    16 
    1715#include "tap.h"
    1816#include "pstap.h"
Note: See TracChangeset for help on using the changeset viewer.