IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 8545


Ignore:
Timestamp:
Aug 23, 2006, 5:17:03 PM (20 years ago)
Author:
drobbin
Message:

Edited many functions and files to complete code-coverage for psMetadata.c. AddItem and IteratorAlloc not finished and am currently working on the psPolynomial?Dto/fromMD functions

Location:
trunk/psLib
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/types/psMetadata.c

    r8414 r8545  
    1212 *  @author Ross Harman, MHPCC
    1313 *
    14  *  @version $Revision: 1.125 $ $Name: not supported by cvs2svn $
    15  *  @date $Date: 2006-08-18 00:21:59 $
     14 *  @version $Revision: 1.126 $ $Name: not supported by cvs2svn $
     15 *  @date $Date: 2006-08-24 03:17:03 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    102102static void metadataItemFree(psMetadataItem* metadataItem)
    103103{
    104     if (metadataItem == NULL) {
    105         return;
    106     }
    107104    psDataType type;
    108105
    … …  
    120117static void metadataIteratorFree(psMetadataIterator* iter)
    121118{
    122     if (iter == NULL) {
    123         return;
    124     }
    125119    psFree(iter->iter);
    126120
    … …  
    133127static void metadataFree(psMetadata* metadata)
    134128{
    135     if (metadata == NULL) {
    136         return;
    137     }
    138129    psFree(metadata->list);
    139130    psFree(metadata->hash);
    140 
    141131}
    142132
    … …  
    458448            psErrorStackPrint(stderr, "Error copying %s (%s) in the metadata\n", inItem->name,
    459449                              inItem->comment);
    460             printf("\nok we're here\n");
    461450        }
    462451        psFree(newItem);                // Drop reference
    … …  
    721710        psMetadataItem* entry = psHashLookup(mdTable,key);
    722711        if (entry == NULL) {
    723             psError(PS_ERR_UNKNOWN, false, _("Failed to remove metadata item, %s, from metadata table."), key);
     712            psError(PS_ERR_UNKNOWN, false,
     713                    _("Failed to remove metadata item, %s, from metadata table."), key);
    724714            return false;
    725715        }
    … …  
    743733        psMetadataItem* entry = psListGet(mdList, where);
    744734        if (entry == NULL) {
    745             psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Could not find metadata item at index %d."), where);
     735            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     736                    _("Could not find metadata item at index %d."), where);
    746737            return false;
    747738        }
    … …  
    749740
    750741        if (key == NULL) {
    751             psError(PS_ERR_BAD_PARAMETER_VALUE, true, _("Failed to remove metadata item, at index %d, from metadata list."), where);
     742            psError(PS_ERR_BAD_PARAMETER_VALUE, true,
     743                    _("Failed to remove metadata item, at index %d, from metadata list."),
     744                    where);
    752745            return false;
    753746        }
    … …  
    755748        psMetadataItem* tableItem = psHashLookup(mdTable, key);
    756749        if (tableItem == NULL) {
    757             psError(PS_ERR_UNKNOWN, false, _("Failed to remove metadata item, %s, from metadata table."), key);
     750            psError(PS_ERR_UNKNOWN, false,
     751                    _("Failed to remove metadata item, %s, from metadata table."), key);
    758752            return false;
    759753        }
    … …  
    763757            psListRemoveData(tableItem->data.list, entry);
    764758        } else {
    765             if (!psHashRemove(mdTable, key)) {
    766                 psError(PS_ERR_UNKNOWN, false, _("Failed to remove metadata item, %s, from metadata table."), key);
    767                 return false;
    768             }
     759            //Tested below.  psHashRemove can't return false here.
     760            psHashRemove(mdTable, key);
    769761        }
    770762        psListRemove(mdList, where);
    … …  
    824816    if (metadataItem->type == PS_DATA_METADATA_MULTI) {
    825817        // if multiple keys found, use the first.
    826         metadataItem = (psMetadataItem*)((metadataItem->data.list)->head);
     818        //        metadataItem = (psMetadataItem*)((metadataItem->data.list)->head);
     819        metadataItem = (psMetadataItem*)(metadataItem->data.list->head->data);
     820        if (status) {
     821            *status = true;
     822        }
    827823    }
    828824
    … …  
    846842    ps##TYPE value = 0; \
    847843    \
    848     if (status) { \
     844    if (status) {  \
    849845        *status = true; \
    850846    } \
    … …  
    852848    metadataItem = psMetadataLookup(md, key); \
    853849    if(metadataItem == NULL) { \
    854         if (status) { \
     850        if (status) {  \
    855851            *status = false; \
    856852        } \
    … …  
    900896    default: \
    901897        /* if you get to this point, the value is not a number. */ \
    902         if (status) { \
     898        if (status) {  \
    903899            *status = false; \
    904         } \
     900        }  \
    905901        break; \
    906902    } \
    … …  
    10971093            psLogMsg(__func__, PS_LOG_WARN, "%s isn't of type PS_DATA_META, as expected.\n", key);
    10981094        }
    1099         value = NULL;
     1095        //        value = NULL;
    11001096    } else {
    11011097        // We have the requested metadata
    … …  
    11681164            psLogMsg(__func__, PS_LOG_WARN, "%s isn't of type PS_DATA_STRING, as expected.\n", key);
    11691165        }
    1170         value = NULL;
     1166        //        value = NULL;
    11711167    } else {
    11721168        // We have the requested metadata

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

    r8425 r8545  
    1919int main(void)
    2020{
    21     plan_tests(31);
     21    plan_tests(32);
    2222
    2323    diag("psMetadataCopy and psMetadataItemCopy tests");
    … …  
    398398            "psMetadataItemTransfer:  return false for invalid key.");
    399399    }
     400    //Return false for invalid metadata
     401    psMetadata *invalid = psMetadataAlloc();
     402    psFree(invalid->hash);
     403    invalid->hash = NULL;
     404    {
     405        ok( !psMetadataItemTransfer(invalid, in, "key"),
     406            "psMetadataItemTransfer:  return false for invalid metadata.");
     407    }
     408    psFree(invalid);
    400409
    401410    //Check for Memory Leaks

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

    r8425 r8545  
    4848    psMetadataItem *itemBool = psMetadataItemAllocBool("itemBool", "", true);
    4949
     50    //First try to free a NULL item
     51    psMetadataItem *nullItem = NULL;
     52    psFree(nullItem);
    5053    //Verify correct allocation
    5154    //String
    … …  
    262265    psMetadata *md = NULL;
    263266    //Attempt to free a null metadata
     267    psMetadata *dummy = psMetadataAlloc();
     268    md = dummy;
     269    dummy = NULL;
     270    psFree(dummy);
    264271    psFree(md);
    265272    md = psMetadataAlloc();

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

    r8425 r8545  
    1414
    1515void testIter(void);
     16void testLookups(void);
     17void testRemoves(void);
    1618
    1719int main(void)
    1820{
    19     plan_tests(2);
     21    plan_tests(48);
    2022
    2123    diag("psMetadataLookup, Remove, and Iterator Fxns");
    2224
    23 
     25    testLookups();
     26    testRemoves();
     27    testIter();
    2428
    2529    done();
    2630}
    2731
     32void testLookups(void)
     33{
     34    diag("\n  >>>Test 1:  psMetadataLookup Functions");
     35    psMetadata *md = psMetadataAlloc();
     36    psMetadataAddStr(md, PS_LIST_TAIL, "itemStr", 0, "I am a string", "GNIRTS");
     37    psMetadataAddBool(md, PS_LIST_TAIL, "itemBool", 0, "I am a boolean", true);
     38    psMetadataAddS8(md, PS_LIST_TAIL, "itemS8", 0, "I am S8", 6);
     39    psMetadataAddS16(md, PS_LIST_TAIL, "itemS16", 0, "I am S16", -666);
     40    psMetadataAddS32(md, PS_LIST_TAIL, "itemS32", 0, "I am a integer", 55);
     41    psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", 0, "I am S64", 666);
     42    psMetadataAddU8(md, PS_LIST_TAIL, "itemU8", 0, "I am U8", 6);
     43    psMetadataAddU16(md, PS_LIST_TAIL, "itemU16", 0, "I am U16", 666);
     44    psMetadataAddU32(md, PS_LIST_TAIL, "itemU32", 0, "I am U32", 666);
     45    psMetadataAddU64(md, PS_LIST_TAIL, "itemU64", 0, "I am U64", 666);
     46    psMetadataAddF32(md, PS_LIST_TAIL, "itemF32", 0, NULL, 3.14);
     47    psMetadataAddF64(md, PS_LIST_TAIL, "itemF64", 0, "", 6.28);
     48    psSphere *sphere = psSphereAlloc();
     49    sphere->r = 6.66;
     50    sphere->d = 666.666;
     51    psMetadataAddPtr(md, PS_LIST_HEAD, "ptr", PS_DATA_SPHERE, "", sphere);
     52    //    psMetadataAddPtr(md, PS_LIST_TAIL, "ptr", PS_DATA_METADATA_MULTI, "", sphere);
     53    psTime *time;
     54    time = psTimeAlloc(PS_TIME_TAI);
     55    time->sec = 1000;
     56    time->nsec = 25;
     57    time->leapsecond = true;
     58    psMetadataAddTime(md, PS_LIST_TAIL, "time01", 0, "I am time", time);
     59    psMetadata *newMD = psMetadataAlloc();
     60    psMetadataAddS32(newMD, PS_LIST_TAIL, "1", 0, "", 666);
     61    psMetadataAddMetadata(md, PS_LIST_TAIL, "metadata7", 0, "I am a metadata", newMD);
     62
     63    //Lookup Standard number-types (valid cases)
     64    //U8
     65    {
     66        bool status = false;
     67        psU8 u8 = 0;
     68        u8 = psMetadataLookupU8(&status, md, "itemU8");
     69        ok( status && u8 == 6,
     70            "psMetadataLookupU8:     return correct U8 value on lookup.");
     71    }
     72    //U16
     73    {
     74        bool status = false;
     75        psU16 u16 = 0;
     76        u16 = psMetadataLookupU16(&status, md, "itemU16");
     77        ok( status && u16 == 666,
     78            "psMetadataLookupU16:    return correct U16 value on lookup.");
     79    }
     80    //U32
     81    {
     82        bool status = false;
     83        psU32 u32 = 0;
     84        u32 = psMetadataLookupU32(&status, md, "itemU32");
     85        ok( status && u32 == 666,
     86            "psMetadataLookupU32:    return correct U32 value on lookup.");
     87    }
     88    //U64
     89    {
     90        bool status = false;
     91        psU64 u64 = 0;
     92        u64 = psMetadataLookupU64(&status, md, "itemU64");
     93        ok( status && u64 == 666,
     94            "psMetadataLookupU64:    return correct U64 value on lookup.");
     95    }
     96    //S8
     97    {
     98        bool status = false;
     99        psS8 s8 = 0;
     100        s8 = psMetadataLookupS8(&status, md, "itemS8");
     101        ok( status && s8 == 6,
     102            "psMetadataLookupS8:     return correct S8 value on lookup.");
     103    }
     104    //S16
     105    {
     106        bool status = false;
     107        psS16 s16 = 0;
     108        s16 = psMetadataLookupS16(&status, md, "itemS16");
     109        ok( status && s16 == -666,
     110            "psMetadataLookupS16:    return correct S16 value on lookup.");
     111    }
     112    //S32
     113    {
     114        bool status = false;
     115        psS32 s32 = 0;
     116        s32 = psMetadataLookupS32(&status, md, "itemS32");
     117        ok( status && s32 == 55,
     118            "psMetadataLookupS32:    return correct S32 value on lookup.");
     119    }
     120    //S64
     121    {
     122        bool status = false;
     123        psS64 s64 = 0;
     124        s64 = psMetadataLookupS64(&status, md, "itemS64");
     125        ok( status && s64 == 666,
     126            "psMetadataLookupS64:    return correct S64 value on lookup.");
     127    }
     128    //F32
     129    {
     130        bool status = false;
     131        psF32 f32 = 0;
     132        f32 = psMetadataLookupF32(&status, md, "itemF32");
     133        ok( status && abs(f32 - 3.14) < FLT_EPSILON,
     134            "psMetadataLookupF32:    return correct F32 value on lookup.");
     135    }
     136    //F64
     137    {
     138        bool status = false;
     139        psF64 f64 = 0;
     140        f64 = psMetadataLookupF64(&status, md, "itemF64");
     141        ok( status && abs(f64 - 6.28) < DBL_EPSILON,
     142            "psMetadataLookupF64:    return correct F64 value on lookup.");
     143    }
     144    //Bool
     145    {
     146        bool status = false;
     147        bool stat = false;
     148        stat = psMetadataLookupBool(&status, md, "itemBool");
     149        ok( status && stat,
     150            "psMetadataLookupBool:   return correct Bool value on lookup.");
     151    }
     152    //String
     153    {
     154        bool status = false;
     155        psString str = NULL;
     156        str = psMetadataLookupStr(&status, md, "itemStr");
     157        ok( status && !strncmp(str, "GNIRTS", 8),
     158            "psMetadataLookupStr:   return correct String value on lookup.");
     159    }
     160    //Pointer
     161    {
     162        bool status = false;
     163        psSphere *sph = NULL;
     164        sph = (psSphere*)(psMetadataLookupPtr(&status, md, "ptr"));
     165        ok( status && sph != NULL && abs(sph->r-6.66) < FLT_EPSILON,
     166            "psMetadataLookupPtr:   return correct pointer value on lookup.");
     167    }
     168    //Time
     169    {
     170        bool status = false;
     171        psTime *t = NULL;
     172        t = psMetadataLookupTime(&status, md, "time01");
     173        ok( status && t->sec == 1000,
     174            "psMetadataLookupTime:  return correct time value on lookup.");
     175    }
     176    //Metadata
     177    {
     178        bool status = false;
     179        psMetadata *mdtemp = NULL;
     180        mdtemp = psMetadataLookupMD(&status, md, "metadata7");
     181        psMetadataItem *itemtemp = psMetadataGet(mdtemp, PS_LIST_HEAD);
     182        ok( status && itemtemp->type == PS_DATA_S32 && itemtemp->data.S32 == 666,
     183            "psMetadataLookupMD:    return correct metadata value on lookup.");
     184    }
     185
     186    //Try Negatives and non-standard lookup cases
     187    //String  - invalid key name
     188    {
     189        bool status = false;
     190        psString str = NULL;
     191        str = psMetadataLookupStr(&status, md, "item");
     192        ok( !status && str == NULL,
     193            "psMetadataLookupStr:   return NULL for incorrect key.");
     194        str = NULL;
     195        str = psMetadataLookupStr(NULL, md, "item");
     196        ok( str == NULL,
     197            "psMetadataLookupStr:   return NULL for incorrect key (& NULL status).");
     198    }
     199    //String - wrong key->  lookup s8 data
     200    {
     201        bool status = false;
     202        psString str = NULL;
     203        str = psMetadataLookupStr(&status, md, "itemS8");
     204        ok( !status && str == NULL,
     205            "psMetadataLookupStr:   return NULL for incorrect key .");
     206        str = NULL;
     207        str = psMetadataLookupStr(NULL, md, "itemS8");
     208        ok( str == NULL,
     209            "psMetadataLookupStr:   return NULL for incorrect key (& NULL status).");
     210    }
     211    //Pointer - invalid key name
     212    {
     213        bool status = false;
     214        psSphere *sph = NULL;
     215        sph = psMetadataLookupPtr(&status, md, "item");
     216        ok( !status && sph == NULL,
     217            "psMetadataLookupPtr:   return NULL for incorrect key.");
     218    }
     219    //Pointer - wrong key -> lookup s8 data
     220    {
     221        bool status = false;
     222        psSphere *sph = NULL;
     223        sph = psMetadataLookupPtr(&status, md, "itemS8");
     224        ok( !status && sph == NULL,
     225            "psMetadataLookupPtr:   return NULL for incorrect key.");
     226    }
     227
     228    //Pointer**  - lookup a PS_DATA_METADATA_MULTI
     229    {
     230        psMetadata *metadata = psMetadataAlloc();
     231        psMetadataItem *multi = psMetadataItemAlloc("ptr", PS_DATA_METADATA_MULTI, "", NULL);
     232        psMetadataAddItem(metadata, multi, PS_LIST_HEAD, PS_META_DUPLICATE_OK);
     233        psMetadataAddPtr(metadata, PS_LIST_TAIL, "ptr",
     234                         PS_DATA_SPHERE | PS_META_DUPLICATE_OK, "", sphere);
     235        psSphere *s = psSphereAlloc();
     236        s->r = 0.666;
     237        psMetadataAddPtr(metadata, PS_LIST_TAIL, "ptr", PS_DATA_SPHERE | PS_META_DUPLICATE_OK, "", s);
     238        psFree(s);
     239        psMetadataItem *metadataItem = NULL;
     240        metadataItem = psMetadataLookup(metadata, "ptr");
     241        bool status = false;
     242        psSphere *sph = NULL;
     243        sph = (psSphere*)(psMetadataLookupPtr(&status, metadata, "ptr"));
     244        ok( status && sph != NULL && fabs(sph->r - 6.66) < FLT_EPSILON,
     245            "psMetadataLookupPtr:   return correct value on lookup of MULTI item.");
     246        psFree(metadata);
     247        psFree(multi);
     248    }
     249
     250    //Metadata - invalid key name
     251    {
     252        bool status = false;
     253        psMetadata *met = NULL;
     254        met = psMetadataLookupMD(&status, md, "item");
     255        ok( !status && met == NULL,
     256            "psMetadataLookupMD:   return NULL for incorrect key.");
     257        met = NULL;
     258        met = psMetadataLookupMD(NULL, md, "item");
     259        ok( met == NULL,
     260            "psMetadataLookupMD:   return NULL for incorrect key (& NULL status).");
     261    }
     262    //Metadata - wrong key -> lookup s8 data
     263    {
     264        bool status = false;
     265        psMetadata *met = NULL;
     266        met = psMetadataLookupMD(&status, md, "itemS8");
     267        ok( !status && met == NULL,
     268            "psMetadataLookupMD:   return NULL for incorrect key (& NULL status).");
     269        met = NULL;
     270        met = psMetadataLookupMD(NULL, md, "itemS8");
     271        ok( met == NULL,
     272            "psMetadataLookupMD:   return NULL for incorrect key.");
     273    }
     274    //Time - invalid key name
     275    {
     276        bool status = false;
     277        psTime *time = NULL;
     278        time = psMetadataLookupTime(&status, md, "item");
     279        ok( !status && time == NULL,
     280            "psMetadataLookupTime:   return NULL for incorrect key.");
     281        time = NULL;
     282        time = psMetadataLookupTime(NULL, md, "item");
     283        ok( time == NULL,
     284            "psMetadataLookupTime:   return NULL for incorrect key (& NULL status).");
     285    }
     286    //Time - wrong key -> lookup s8 data
     287    {
     288        bool status = false;
     289        psTime *time = NULL;
     290        time = psMetadataLookupTime(&status, md, "itemS8");
     291        ok( !status && time == NULL,
     292            "psMetadataLookupTime:   return NULL for incorrect key.");
     293        time = NULL;
     294        time = psMetadataLookupTime(NULL, md, "itemS8");
     295        ok( time == NULL,
     296            "psMetadataLookupTime:   return NULL for incorrect key (& NULL status).");
     297    }
     298
     299
     300
     301    //Check for Memory leaks
     302    {
     303        psFree(sphere);
     304        psFree(time);
     305        psFree(newMD);
     306        psFree(md);
     307        checkMem();
     308    }
     309}
     310
     311void testRemoves(void)
     312{
     313    diag("\n  >>>Test 2:  psMetadataRemove Functions");
     314    psMetadata *md = psMetadataAlloc();
     315    psMetadataAddStr(md, PS_LIST_TAIL, "itemStr", 0, "I am a string", "GNIRTS");
     316    psMetadataAddBool(md, PS_LIST_TAIL, "itemBool", 0, "I am a boolean", true);
     317    psMetadataAddS8(md, PS_LIST_TAIL, "itemS8", 0, "I am S8", 6);
     318    psMetadataAddS16(md, PS_LIST_TAIL, "itemS16", 0, "I am S16", -666);
     319    psMetadataAddS32(md, PS_LIST_TAIL, "itemS32", 0, "I am a integer", 55);
     320    psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 666);
     321    psMetadataAddU8(md, PS_LIST_TAIL, "itemU8", 0, "I am U8", 6);
     322
     323    //psMetadataRemoveKey
     324    {
     325        bool status = psMetadataRemoveKey(md, "itemU8");
     326        psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL);
     327        ok( status && temp->type == PS_DATA_S64,
     328            "psMetadataRemoveKey:    return true for valid case.");
     329    }
     330    //psMetadataRemoveIndex
     331    {
     332        bool status = psMetadataRemoveIndex(md, PS_LIST_HEAD);
     333        psMetadataItem *temp = psMetadataGet(md, PS_LIST_HEAD);
     334        ok( status && temp->type == PS_DATA_BOOL,
     335            "psMetadataRemoveIndex:  return true for valid case.");
     336    }
     337    //Attempt to remove an incorrect key - Return false
     338    {
     339        ok( !psMetadataRemoveKey(md, "BigDog"),
     340            "psMetadataRemoveKey:    return false for incorrect key.");
     341    }
     342    //Attempt to remove an out-of-range index - Return false
     343    {
     344        ok( !psMetadataRemoveIndex(md, 20),
     345            "psMetadataRemoveIndex:  return false for incorrect index.");
     346    }
     347    //Attempt to remove an item with NULL name
     348    {
     349        psMetadataItem *temp = psMetadataGet(md, PS_LIST_HEAD);
     350        psFree(temp->name);
     351        temp->name = NULL;
     352        ok( !psMetadataRemoveIndex(md, PS_LIST_HEAD),
     353            "psMetadataRemoveIndex:  return false for item with no name.");
     354    }
     355    //Attempt to remove an item with wrong hash table
     356    {
     357        psMetadata *md2 = psMetadataAlloc();
     358        psMetadataAddBool(md2, PS_LIST_TAIL, "Bool", 0, "I am a boolean", true);
     359        psMetadataAddS8(md2, PS_LIST_TAIL, "S8", 0, "I am S8", 6);
     360        psMetadataAddS16(md2, PS_LIST_TAIL, "S16", 0, "I am S16", -666);
     361        psMetadataAddS32(md2, PS_LIST_TAIL, "S32", 0, "I am a integer", 55);
     362        psMetadataAddS64(md2, PS_LIST_TAIL, "S64", 0, "I am S64", 666);
     363
     364        psFree(md2->hash);
     365        md2->hash = NULL;
     366        md2->hash = md->hash;
     367        ok( !psMetadataRemoveIndex(md2, PS_LIST_HEAD),
     368            "psMetadataRemoveIndex:  return false for item with bad table.");
     369        md2->hash = NULL;
     370        psFree(md2);
     371    }
     372    //Attempt to remove a METADATA_MULTI item by key
     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 = psMetadataRemoveKey(md, "itemS64");
     377        psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL);
     378        ok( status && temp->type == PS_DATA_S32,
     379            "psMetadataRemoveKey:    return true for valid METADATA_MULTI case.");
     380
     381    }
     382    //Attempt to remove a METADATA_MULTI item by index
     383    {
     384        psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 667);
     385        psMetadataAddS64(md, PS_LIST_TAIL, "itemS64", PS_META_DUPLICATE_OK, "I am S64", 668);
     386        bool status = psMetadataRemoveIndex(md, PS_LIST_TAIL);
     387        psMetadataItem *temp = psMetadataGet(md, PS_LIST_TAIL);
     388        ok( status && temp->type == PS_DATA_S64,
     389            "psMetadataRemoveIndex:  return true for valid METADATA_MULTI case.");
     390    }
     391
     392    //Check for Memory leaks
     393    {
     394        psFree(md);
     395        checkMem();
     396    }
     397}
     398
    28399void testIter(void)
    29400{
    30     diag("\n  >>>Test 4:  psMetadataIterator Functions");
     401    diag("\n  >>>Test 3:  psMetadataIterator Functions");
    31402    psMetadata *md = psMetadataAlloc();
    32403    psMetadataAddS32(md, PS_LIST_HEAD, "S32_1", PS_META_NO_REPLACE, "", 1);
    … …  
    60431        iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, NULL);
    61432        ok( iter != NULL,
    62             "psMetadataIteratorAlloc:  return valid iterator for valid inputs, regex=NULL.");
     433            "psMetadataIteratorAlloc:    return valid iterator for valid inputs, regex=NULL.");
    63434        skip_start(iter == NULL, 4,
    64435                   "Skipping 4 tests because psMetadataIteratorAlloc failed");

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

    r8425 r8545  
    4444    psMetadataAddS16(md, PS_LIST_TAIL, "item7", 0, "I am S16", -666);
    4545    psMetadataAddS32(md, PS_LIST_TAIL, "item2", 0, "I am a integer", 55);
    46     psMetadataAddS64(md, PS_LIST_TAIL, "item11", 0, "I am S64", 666);
     46    psMetadataAddS64(md, PS_LIST_TAIL, "helloS64", 0, "I am S64", 666);
    4747    psMetadataAddU8(md, PS_LIST_TAIL, "item8", 0, "I am U8", 6);
    4848    psMetadataAddU16(md, PS_LIST_TAIL, "item9", 0, "I am U16", 666);
    … …  
    6666    psMetadataAddF32(newMD, PS_LIST_TAIL, "ITEM02", 0, "I AM FLOAT", 666.6);
    6767    psMetadataAddF64(newMD, PS_LIST_TAIL, "ITEM03", 0, "I AM DOUBLE", 666.666);
     68    psMetadataAddS64(newMD, PS_LIST_TAIL, "item666", 0, "I am S64", 666);
    6869
    6970    psMetadataAddMetadata(md, PS_LIST_TAIL, "metadata7", 0, "I am a metadata", newMD);
Note: See TracChangeset for help on using the changeset viewer.