IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

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/types
Files:
24 edited

Legend:

Unmodified
Added
Removed

  • 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.