IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

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

Legend:

Unmodified
Added
Removed

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