IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Sep 9, 2006, 10:53:07 PM (20 years ago)
Author:
drobbin
Message:

ted several files. Added error handling and removed unreachable spots from psMetadata.c. Added doxygen for psPolynomial(to/from)MD functions in psMetadata.h. Updated makefiles to restore certain functionality lost recently, (ie, ability to 'make tests' in types/ folder). Updated tests and source in tap_psMetadata_creating- namely psMetadataIteratorAlloc and psMetadataAddItem. Finished testing in tap_psMetadata_polynomials. psMetadata.c now reads 100% coverage (lines executed) by tap tests!

Location:
trunk/psLib/test/types
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/types/Makefile.am

    r8775 r8786  
    2626        tap_psArray_all
    2727
    28 check_PROGRAMS = $(TESTS)
    29 
    3028check_DATA = \
    3129        test.config \
    … …  
    4442        tableU8.dat \
    4543    mdcfgwrt.verified
     44
     45check_PROGRAMS = $(TESTS)
    4646
    4747EXTRA_DIST = \

  • trunk/psLib/test/types/execute_tap

    r8694 r8786  
    1010./tap_psMetadata_manip
    1111./tap_psMetadata_printing
     12./tap_psMetadata_polynomials

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

    r8731 r8786  
    7171int main (void)
    7272{
    73     plan_tests(158);
     73    plan_tests(66);
    7474
    7575    diag("psListIterator tests");

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

    r8731 r8786  
    2424int main(void)
    2525{
    26     plan_tests(35);
     26    plan_tests(42);
    2727
    2828    diag("psMetadata & psMetadataItem Creation Functions");
    … …  
    3737void testItemAllocs(void)
    3838{
    39     diag("  >>>Test 1:  psMetadataItemAlloc & Free Fxns");
     39    diag("  >>>Test 1:  psMetadataItemAlloc Fxns");
    4040    psMetadataItem *itemStr = psMetadataItemAllocStr("itemStr", "", "itemStr");
    4141    psMetadataItem *itemF32 = psMetadataItemAllocF32("itemF32", "", 6.66);
    … …  
    262262void testMDAlloc_AddItem(void)
    263263{
    264     diag("  >>>Test 2:  psMetadataAlloc, psMemCheckMetadata, & psMetadataAdd Fxns");
     264    diag("  >>>Test 2:  psMetadataAlloc & psMetadataAdd Fxns");
    265265    psMetadata *md = NULL;
    266     //Attempt to free a null metadata
    267266    md = psMetadataAlloc();
    268267    psMetadata *md1 = psMetadataAlloc();
    … …  
    271270    {
    272271        ok( psMemCheckMetadata(md),
    273             "psMemCheckMetadata:  return true for valid Metadata.");
     272            "psMemCheckMetadata:       return true for valid Metadata.");
    274273    }
    275274    //Make sure MemCheck worked.  Try primitive type.  Expect false.
    … …  
    277276        int j = 2;
    278277        ok( !psMemCheckMetadata(&j),
    279             "psMemCheckMetadata:  return false for non-Metadata input.");
     278            "psMemCheckMetadata:       return false for non-Metadata input.");
    280279    }
    281280    //Return false for attempt to add a psMetadataItem with no name.
    282281    {
    283282        ok( !psMetadataAdd(md1, PS_LIST_HEAD, NULL, PS_DATA_S32, "", 1),
    284             "psMetadataAdd:       return false for adding item with no name.");
     283            "psMetadataAdd:            return false for adding item with no name.");
    285284    }
    286285    psFree(md1);
    287286    md1 = psMetadataAlloc();
    288287
    289     diag("  >>>Test 3:  psMetadataAddItem");
    290288    //Return false for NULL metadata input
    291289    psMetadataItem *item = psMetadataItemAllocBool("item", "", true);
    292290    {
    293291        ok( !psMetadataAddItem(NULL, item, PS_LIST_HEAD, PS_META_DEFAULT),
    294             "psMetadataAddItem:   return false for NULL metadata input.");
     292            "psMetadataAddItem:        return false for NULL metadata input.");
    295293    }
    296294    //Return false for metadata with NULL hash
    … …  
    299297    {
    300298        ok( !psMetadataAddItem(md1, item, PS_LIST_HEAD, PS_META_DEFAULT),
    301             "psMetadataAddItem:   return false for metadata with no hash.");
     299            "psMetadataAddItem:        return false for metadata with no hash.");
    302300    }
    303301    psFree(md1);
    … …  
    307305    {
    308306        ok( !psMetadataAddItem(md2, item, PS_LIST_HEAD, PS_META_DEFAULT),
    309             "psMetadataAddItem:   return false for metadata with no list.");
     307            "psMetadataAddItem:        return false for metadata with no list.");
    310308    }
    311309    psFree(md2);
    … …  
    313311    {
    314312        ok( !psMetadataAddItem(md, NULL, PS_LIST_HEAD, PS_META_DEFAULT),
    315             "psMetadataAddItem:   return false for NULL item input.");
     313            "psMetadataAddItem:        return false for NULL item input.");
    316314    }
    317315    //Return false for psMetadataItem with NULL name
    … …  
    320318    {
    321319        ok( !psMetadataAddItem(md, item, PS_LIST_HEAD, PS_META_DEFAULT),
    322             "psMetadataAddItem:   return false for item with no name.");
     320            "psMetadataAddItem:        return false for item with no name.");
    323321    }
    324322    psFree(item);
    325323
    326     //item type=PS_DATA_METADATA_MULTI
    327     //    psMetadataAddS32(md, PS_LIST_TAIL, "S32", PS_META_DUPLICATE_OK, "", 1);
    328324    psMetadata *itemMD = psMetadataAlloc();
    329325    psMetadataAddS32(itemMD, PS_LIST_HEAD, "s", PS_META_DUPLICATE_OK, "", 2);
    330     //    psMetadataItem *item2 = psMetadataItemAlloc("multi", PS_DATA_METADATA_MULTI, "", itemMD);
    331326    psMetadataItem *item2 = psMetadataItemAllocS32("s", "", 2);
    332327
    … …  
    334329    {
    335330        ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
    336             "psMetadataAddItem:   return true for addition of PS_DATA_METADATA_MULTI.");
    337     }
    338     //    printf("\n  >>Memory leakage coming from above test for METADATA_MULTI\n\n");
     331            "psMetadataAddItem:        return true for addition of PS_DATA_METADATA_MULTI.");
     332    }
    339333    psFree(item2);
    340334    psFree(itemMD);
    … …  
    343337    psMetadataAddS32(md, PS_LIST_HEAD, "S32", 0, "", 1);
    344338    item2 = psMetadataItemAllocS32("S32", "", 1);
     339    //FLAG = PS_META_REPLACE
     340    {
     341        ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_REPLACE),
     342            "psMetadataAddItem:        return true for PS_META_REPLACE flag.");
     343    }
    345344    //FLAG = PS_META_DUPLICATE_OK
    346345    {
    347346        ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
    348             "psMetadataAddItem:   return true for PS_META_DUPLICATE_OK flag.");
    349     }
    350     //FLAG = PS_META_REPLACE
    351     {
    352         ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_REPLACE),
    353             "psMetadataAddItem:   return true for PS_META_REPLACE flag.");
    354     }
     347            "psMetadataAddItem:        return true for PS_META_DUPLICATE_OK flag.");
     348    }
     349    /*        SEE BELOW.  TEST CASE REDONE b/c item2 in md was already a MULTI
    355350    //FLAG = PS_META_NO_REPLACE
    356351    {
    357352        ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_NO_REPLACE),
    358             "psMetadataAddItem:   return true for PS_META_NO_REPLACE flag.");
    359     }
     353            "psMetadataAddItem:        return true for PS_META_NO_REPLACE flag.");
     354    }
     355    */
    360356    //FLAG = PS_META_DEFAULT
    361357    {
    362358        ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DEFAULT),
    363             "psMetadataAddItem:   return false for PS_META_DEFAULT flag.");
    364     }
     359            "psMetadataAddItem:        return false for PS_META_DEFAULT flag.");
     360    }
     361
     362    //Return false for attempting to add an element twice with flag NO_REPLACE
     363    {
     364        psMetadata *norep = psMetadataAlloc();
     365        psMetadataAddS32(norep, PS_LIST_HEAD, "S32", 0, "", 1);
     366        psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1);
     367        ok( psMetadataAddItem(norep, item666, PS_LIST_TAIL, PS_META_NO_REPLACE),
     368            "psMetadataAddItem:        return true for PS_META_NO_REPLACE flag.");
     369        psFree(item666);
     370        psFree(norep);
     371    }
     372    //Return false for bad list location
     373    {
     374        psMetadata *emptymeta = psMetadataAlloc();
     375        psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1);
     376        ok( !psMetadataAddItem(emptymeta, item666, -100, PS_META_NO_REPLACE),
     377            "psMetadataAddItem:        return false for invalid list location.");
     378        psFree(item666);
     379        psFree(emptymeta);
     380    }
     381    //Return false for trying to add to MULTI with broken list element.
     382    {
     383        psMetadata *broken_list = psMetadataAlloc();
     384        psMetadataAddS32(broken_list, PS_LIST_HEAD, "S32", 0, "", 1);
     385        psMetadataAddS32(broken_list, PS_LIST_TAIL, "S32", PS_META_DUPLICATE_OK, "", 1);
     386        psMetadataItem *brokenptr = psMetadataLookup(broken_list, "S32");
     387        if (brokenptr->type != PS_DATA_METADATA_MULTI)
     388            printf("\nError, Error\n");
     389        else
     390        {
     391            psFree(brokenptr->data.list);
     392            brokenptr->data.list = NULL;
     393        }
     394        psMetadataItem *item666 = psMetadataItemAllocS32("S32", "", 1);
     395        ok( !psMetadataAddItem(broken_list, item666, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
     396            "psMetadataAddItem:        return false for MULTI with NULL list.");
     397        psFree(item666);
     398        psFree(broken_list);
     399    }
     400
     401    //Attempt to add a MULTI
     402    psFree(item2);
     403    item2 = NULL;
     404    psMetadata *xxx = psMetadataAlloc();
     405    psMetadataAddS32(xxx, PS_LIST_TAIL, "new S32", 0, "", 1);
     406    item2 = psMetadataItemAllocS32("new S32", "", 1);
     407    psMetadataAddItem(xxx, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK);
     408    psFree(item2);
     409    item2 = psMetadataLookup(xxx, "new S32");
     410    {
     411        ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
     412            "psMetadataAddItem:        return true for new MULTI item");
     413    }
     414    //Attempt to add a 2nd reference of a MULTI to the originating metadata container
     415    {
     416        ok( !psMetadataAddItem(xxx, item2, PS_LIST_TAIL, PS_META_NO_REPLACE),
     417            "psMetadataAddItem:        return false for attempt to add 2nd reference"
     418            " of a MULTI");
     419    }
     420    psFree(xxx);
    365421
    366422    //No existing entries or duplicates found
    367     psFree(item2);
    368423    item2 = psMetadataItemAllocS32("new", "", 2);
    369424    {
    370425        ok( psMetadataAddItem(md, item2, PS_LIST_TAIL, PS_META_DUPLICATE_OK),
    371             "psMetadataAddItem:   return true for new item.");
     426            "psMetadataAddItem:        return true for new item.");
    372427    }
    373428
    … …  
    382437void testIterAlloc(void)
    383438{
    384     diag("  >>>Test 4:  psMetadataIteratorAlloc");
     439    diag("  >>>Test 3:  psMetadataIteratorAlloc");
    385440    psMetadata *md = psMetadataAlloc();
    386441    psMetadata *md2 = NULL;
    … …  
    412467            "psMetadataIteratorAlloc:  return valid iterator for valid inputs, regex=NULL.");
    413468    }
    414 
     469    //Return NULL for attempt to allocate an iterator with unfound regex.
     470    psFree(iter);
     471    iter = NULL;
     472    {
     473        iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "IPP.machines.sky");
     474        ok( iter == NULL,
     475            "psMetadataIteratorAlloc:  return NULL for not-found regex input");
     476    }
     477    //Return NULL for invalid regex input.
     478    {
     479        iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "IPP.machines.sky\\");
     480        ok( iter == NULL,
     481            "psMetadataIteratorAlloc:  return NULL for invalid regex input");
     482    }
     483    //Return properly allocated iterator for valid non-null regex input.
     484    {
     485        iter = psMetadataIteratorAlloc(md, PS_LIST_HEAD, "S32_");
     486        ok( iter != NULL,
     487            "psMetadataIteratorAlloc:  return valid iterator for valid regex input");
     488    }
    415489
    416490    //Check for Memory leaks

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

    r8731 r8786  
    2222int main(void)
    2323{
    24     plan_tests(1);
     24    plan_tests(58);
    2525
    2626    diag("psPolynomial(2D, 3D, & 4D)(to/from)MD tests");
    … …  
    3737    diag("  >>>Test 1:  psPolynomial2DtoMD & psPolynomial2DfromMD functions");
    3838    psMetadata *md = psMetadataAlloc();
    39     psMetadata *out = NULL;
    4039    psPolynomial2D *p2d = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 1, 1);
    41     psPolynomial2D *polly = NULL;
    42 
    4340    p2d->coeff[0][0] = 1.1;
    4441    p2d->coeff[0][1] = 2.2;
    45     p2d->coeff[1][0] = 2.1;
    46     p2d->coeff[1][1] = 1.2;
    47 
    48     if (!psPolynomial2DtoMD(md, p2d, "polyMD") )
    49         printf("\nnot true\n");
    50     else
    51         psMetadataPrint(NULL, md, 2);
    52 
    53 
    54 
    55     //Return true for valid case
    56     {
    57         //        ok( psPolynomial2DtoMD(md, p2d, "%f", ...);
    58     }
    59 
    60 
    61 
     42    p2d->coeff[1][0] = 3.3;
     43    p2d->coeff[1][1] = 4.4;
     44    p2d->coeffErr[0][0] = 0.1;
     45    p2d->coeffErr[0][1] = 0.2;
     46    p2d->coeffErr[1][0] = 0.3;
     47    p2d->coeffErr[1][1] = 0.4;
     48
     49    //psPolynomial2DtoMD
     50    //Return a valid metadata containing a polynomial-metadata structure
     51    {
     52        ok( psPolynomial2DtoMD(md, p2d, "polyMD"),
     53            "psPolynomial2DtoMD:      return true for valid inputs.");
     54        psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD");
     55        skip_start( polyMDtemp == NULL , 1,
     56                    "Skipping 1 tests because psPolynomial2DtoMD has errors");
     57        psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0);
     58        skip_start( polyItem == NULL, 2,
     59                    "Skipping 2 tests because psPolynomial2DtoMD has errors in order elements");
     60        ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1,
     61            "psPolynomial2DtoMD:      return correct number of x orders.");
     62        polyItem = psMetadataGet(polyMDtemp, 1);
     63        ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1,
     64            "psPolynomial2DtoMD:      return correct number of y orders.");
     65        skip_end();
     66        polyItem = psMetadataGet(polyMDtemp, 2);
     67        skip_start( polyItem == NULL, 2,
     68                    "Skipping 2 tests because psPolynomial2DtoMD has errors in coeff elements");
     69        ok( !strncmp(polyItem->name, "VAL_X00_Y00", 14) &&
     70            abs(polyItem->data.F64-1.1) < DBL_EPSILON,
     71            "psPolynomial2DtoMD:      return correct first element.");
     72        polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
     73        ok( !strncmp(polyItem->name, "ERR_X01_Y01", 14) &&
     74            abs(polyItem->data.F64-0.4) < DBL_EPSILON,
     75            "psPolynomial2DtoMD:      return correct last element.");
     76        skip_end();
     77        skip_end();
     78    }
     79
     80    //Return false for no-name polynomial
     81    {
     82        ok( !psPolynomial2DtoMD(md, p2d, ""),
     83            "psPolynomial2DtoMD:      return false for no-name.");
     84    }
     85    //Return false for NULL-name polynomial
     86    {
     87        ok( !psPolynomial2DtoMD(md, p2d, NULL),
     88            "psPolynomial2DtoMD:      return false for NULL name input.");
     89    }
     90    //Return false for NULL metadata input
     91    {
     92        ok( !psPolynomial2DtoMD(NULL, p2d, "polyMD"),
     93            "psPolynomial2DtoMD:      return false for NULL metadata input.");
     94    }
     95    //Return false for NULL polynomial input
     96    {
     97        ok( !psPolynomial2DtoMD(md, NULL, "polyMD"),
     98            "psPolynomial2DtoMD:      return false for NULL polynomial input.");
     99    }
     100    //Return false for empty polynomial
     101    {
     102        psPolynomial2D *emptyPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0);
     103        ok( !psPolynomial2DtoMD(md, emptyPoly, "polyMD"),
     104            "psPolynomial2DtoMD:     return false for empty polynomial input.");
     105        psFree(emptyPoly);
     106    }
     107    //Return true for polynomial with 1 element, a constant
     108    {
     109        psPolynomial2D *constPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0);
     110        constPoly->coeff[0][0] = 6.66;
     111        ok( psPolynomial2DtoMD(md, constPoly, "polyMD"),
     112            "psPolynomial2DtoMD:     return true for constant polynomial (1 element != 0).");
     113        psFree(constPoly);
     114    }
     115    //Return false for non-ordinary polynomial
     116    {
     117        psPolynomial2D *p2d2 = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, 1, 1);
     118        p2d2->coeff[0][0] = 1.1;
     119        ok( !psPolynomial2DtoMD(md, p2d2, "polyMD"),
     120            "psPolynomial2DtoMD:     return false for chebyshev polynomial");
     121        psFree(p2d2);
     122    }
     123
     124    //psPolynomial2DfromMD Tests
     125    //Return NULL for NULL metadata input.
     126    {
     127        psPolynomial2D *emptyPoly2D = NULL;
     128        emptyPoly2D = psPolynomial2DfromMD(NULL);
     129        ok( emptyPoly2D == NULL,
     130            "psPolynomial2DfromMD:   return NULL for NULL metadata input.");
     131    }
     132    //Get a polynomial from Metadata.
     133    psPolynomial2D *outPoly = NULL;
     134    psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD");
     135    outPoly = psPolynomial2DfromMD(polyMDtemp);
     136    {
     137        skip_start( outPoly == NULL, 1,
     138                    "Skipping 1 tests because psPolynomial2DfromMD has errors.");
     139        ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
     140            outPoly->nY == 1 && abs(outPoly->coeff[0][0] - 1.1) < DBL_EPSILON,
     141            "psPolynomial2DfromMD:   return correct polynomial from metadata");
     142        skip_end();
     143    }
     144    //Set poly->mask[1][1] = 1 for missing [1][1] element in metadata
     145    psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL-1);
     146    psFree(outPoly);
     147    outPoly = NULL;
     148    outPoly = psPolynomial2DfromMD(polyMDtemp);
     149    {
     150        //        ok( outPoly->mask[1][1] == 1,
     151        //            "psPolynomial2DfromMD:   return mask[1][1] == 1 for metadata-polynomial",
     152        //            " with missing element");
     153        ok( outPoly == NULL,
     154            "psPolynomial2DfromMD:   return NULL for polynomial with missing coeff");
     155    }
     156    //Return NULL for polynomial in metadata with no y-order
     157    psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
     158    outPoly = psPolynomial2DfromMD(polyMDtemp);
     159    {
     160        ok( outPoly == NULL,
     161            "psPolynomial2DfromMD:   return NULL for metadata-polynomial with no y-order");
     162    }
     163    //Return NULL for polynomial in metadata with no x-order
     164    psMetadataRemoveKey(polyMDtemp, "NORDER_X");
     165    outPoly = psPolynomial2DfromMD(polyMDtemp);
     166    {
     167        ok( outPoly == NULL,
     168            "psPolynomial2DfromMD:   return NULL for metadata-polynomial with no x-order");
     169    }
    62170
    63171    //Check for Memory leaks
    64172    {
     173        psFree(outPoly);
    65174        psFree(p2d);
    66         psFree(polly);
    67         psFree(out);
    68175        psFree(md);
    69176        checkMem();
    … …  
    75182    diag("  >>>Test 2:  psPolynomial3DtoMD & psPolynomial3DfromMD functions");
    76183    psMetadata *md = psMetadataAlloc();
    77     psMetadata *out = NULL;
    78 
    79 
    80 
     184    psPolynomial3D *p3d = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1);
     185    p3d->coeff[0][0][0] = 1.1;
     186    p3d->coeff[1][0][0] = 2.2;
     187    p3d->coeff[0][1][0] = 3.3;
     188    p3d->coeff[0][0][1] = 4.4;
     189    p3d->coeff[1][1][0] = 5.5;
     190    p3d->coeff[1][0][1] = 6.6;
     191    p3d->coeff[0][1][1] = 7.7;
     192    p3d->coeff[1][1][1] = 8.8;
     193    p3d->coeffErr[0][0][0] = 0.1;
     194    p3d->coeffErr[1][0][0] = 0.2;
     195    p3d->coeffErr[0][1][0] = 0.3;
     196    p3d->coeffErr[0][0][1] = 0.4;
     197    p3d->coeffErr[1][1][0] = 0.5;
     198    p3d->coeffErr[1][0][1] = 0.6;
     199    p3d->coeffErr[0][1][1] = 0.7;
     200    p3d->coeffErr[1][1][1] = 0.8;
     201
     202    //psPolynomial3DtoMD
     203    //Return a valid metadata containing a polynomial-metadata structure
     204    {
     205        ok( psPolynomial3DtoMD(md, p3d, "polyMD"),
     206            "psPolynomial3DtoMD:     return true for valid inputs.");
     207        psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD");
     208        skip_start( polyMDtemp == NULL , 1,
     209                    "Skipping 1 tests because psPolynomial3DtoMD has errors");
     210        psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0);
     211        skip_start( polyItem == NULL, 2,
     212                    "Skipping 3 tests because psPolynomial3DtoMD has errors in order elements");
     213        ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1,
     214            "psPolynomial3DtoMD:     return correct number of x orders.");
     215        polyItem = psMetadataGet(polyMDtemp, 1);
     216        ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1,
     217            "psPolynomial3DtoMD:     return correct number of y orders.");
     218        polyItem = psMetadataGet(polyMDtemp, 2);
     219        ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1,
     220            "psPolynomial3DtoMD:     return correct number of z orders.");
     221        skip_end();
     222        polyItem = psMetadataGet(polyMDtemp, 3);
     223        skip_start( polyItem == NULL, 2,
     224                    "Skipping 2 tests because psPolynomial3DtoMD has errors in coeff elements");
     225        ok( !strncmp(polyItem->name, "VAL_X00_Y00_Z00", 14) &&
     226            abs(polyItem->data.F64-1.1) < DBL_EPSILON,
     227            "psPolynomial3DtoMD:     return correct first element.");
     228        polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
     229        ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01", 14) &&
     230            abs(polyItem->data.F64-0.8) < DBL_EPSILON,
     231            "psPolynomial3DtoMD:     return correct last element.");
     232        skip_end();
     233        skip_end();
     234    }
     235    //Return false for no-name polynomial
     236    {
     237        ok( !psPolynomial3DtoMD(md, p3d, ""),
     238            "psPolynomial3DtoMD:     return false for no-name.");
     239    }
     240    //Return false for NULL-name polynomial
     241    {
     242        ok( !psPolynomial3DtoMD(md, p3d, NULL),
     243            "psPolynomial3DtoMD:     return false for NULL name input.");
     244    }
     245    //Return false for NULL metadata input
     246    {
     247        ok( !psPolynomial3DtoMD(NULL, p3d, "polyMD"),
     248            "psPolynomial3DtoMD:     return false for NULL metadata input.");
     249    }
     250    //Return false for NULL polynomial input
     251    {
     252        ok( !psPolynomial3DtoMD(md, NULL, "polyMD"),
     253            "psPolynomial3DtoMD:     return false for NULL polynomial input.");
     254    }
     255    //Return false for empty polynomial
     256    {
     257        psPolynomial3D *emptyPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0);
     258        ok( !psPolynomial3DtoMD(md, emptyPoly, "polyMD"),
     259            "psPolynomial3DtoMD:     return false for empty polynomial input.");
     260        psFree(emptyPoly);
     261    }
     262    //Return true for polynomial with 1 element, a constant
     263    {
     264        psPolynomial3D *constPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0);
     265        constPoly->coeff[0][0][0] = 6.66;
     266        ok( psPolynomial3DtoMD(md, constPoly, "polyMD"),
     267            "psPolynomial3DtoMD:     return true for constant polynomial (1 element != 0).");
     268        psFree(constPoly);
     269    }
     270    //Return false for non-ordinary polynomial
     271    {
     272        psPolynomial3D *p3d2 = psPolynomial3DAlloc(PS_POLYNOMIAL_CHEB, 1, 1, 1);
     273        p3d2->coeff[0][0][0] = 1.1;
     274        ok( !psPolynomial3DtoMD(md, p3d2, "polyMD"),
     275            "psPolynomial3DtoMD:     return false for chebyshev polynomial");
     276        psFree(p3d2);
     277    }
     278
     279    //psPolynomial3DfromMD Tests
     280    //Return NULL for NULL metadata input.
     281    {
     282        psPolynomial3D *emptyPoly2D = NULL;
     283        emptyPoly2D = psPolynomial3DfromMD(NULL);
     284        ok( emptyPoly2D == NULL,
     285            "psPolynomial3DfromMD:   return NULL for NULL metadata input.");
     286    }
     287    //Get a polynomial from Metadata.
     288    psPolynomial3D *outPoly = NULL;
     289    psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD");
     290    outPoly = psPolynomial3DfromMD(polyMDtemp);
     291    {
     292        skip_start( outPoly == NULL, 1,
     293                    "Skipping 1 tests because psPolynomial3DfromMD has errors.");
     294        ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
     295            outPoly->nY == 1 && outPoly->nZ == 1 &&
     296            abs(outPoly->coeff[0][0][0] - 1.1) < DBL_EPSILON,
     297            "psPolynomial3DfromMD:   return correct polynomial from metadata");
     298        skip_end();
     299    }
     300    //Return NULL for polynomial with missing coefficient
     301    psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL-1);
     302    psFree(outPoly);
     303    outPoly = NULL;
     304    outPoly = psPolynomial3DfromMD(polyMDtemp);
     305    {
     306        //        ok( outPoly->mask[1][1][1] == 1,
     307        //            "psPolynomial3DfromMD:   return mask[1][1][1] == 1 for metadata-polynomial"
     308        //            " with missing element");
     309        ok( outPoly == NULL,
     310            "psPolynomial3DfromMD:   return NULL for polynomial with missing coeff");
     311    }
     312    //Return NULL for polynomial in metadata with no z-order
     313    psMetadataRemoveKey(polyMDtemp, "NORDER_Z");
     314    outPoly = psPolynomial3DfromMD(polyMDtemp);
     315    {
     316        ok( outPoly == NULL,
     317            "psPolynomial3DfromMD:   return NULL for metadata-polynomial with no z-order");
     318    }
     319    //Return NULL for polynomial in metadata with no y-order
     320    psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
     321    outPoly = psPolynomial3DfromMD(polyMDtemp);
     322    {
     323        ok( outPoly == NULL,
     324            "psPolynomial3DfromMD:   return NULL for metadata-polynomial with no y-order");
     325    }
     326    //Return NULL for polynomial in metadata with no x-order
     327    psMetadataRemoveKey(polyMDtemp, "NORDER_X");
     328    outPoly = psPolynomial3DfromMD(polyMDtemp);
     329    {
     330        ok( outPoly == NULL,
     331            "psPolynomial3DfromMD:   return NULL for metadata-polynomial with no x-order");
     332    }
    81333
    82334    //Check for Memory leaks
    83335    {
    84         psFree(out);
     336        psFree(outPoly);
     337        psFree(p3d);
    85338        psFree(md);
    86339        checkMem();
    … …  
    92345    diag("  >>>Test 3:  psPolynomial4DtoMD & psPolynomial4DfromMD functions");
    93346    psMetadata *md = psMetadataAlloc();
    94     psMetadata *out = NULL;
    95 
    96 
    97 
     347    psPolynomial4D *p4d = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1, 1);
     348    p4d->coeff[0][0][0][0] = 1.1;
     349    p4d->coeff[0][0][0][1] = 2.2;
     350    p4d->coeff[0][0][1][0] = 3.3;
     351    p4d->coeff[0][1][0][0] = 4.4;
     352    p4d->coeff[1][0][0][0] = 5.5;
     353
     354    p4d->coeff[0][0][1][1] = 6.6;
     355    p4d->coeff[0][1][0][1] = 7.7;
     356    p4d->coeff[1][0][0][1] = 8.8;
     357    p4d->coeff[0][1][1][0] = 9.9;
     358    p4d->coeff[1][0][1][0] = 10.10;
     359    p4d->coeff[1][1][0][0] = 11.11;
     360
     361    p4d->coeff[0][1][1][1] = 12.12;
     362    p4d->coeff[1][0][1][1] = 13.13;
     363    p4d->coeff[1][1][0][1] = 14.14;
     364    p4d->coeff[1][1][1][0] = 15.15;
     365
     366    p4d->coeff[1][1][1][1] = 16.16;
     367
     368    p4d->coeffErr[0][0][0][0] = 0.1;
     369    p4d->coeffErr[0][0][0][1] = 0.2;
     370    p4d->coeffErr[0][0][1][0] = 0.3;
     371    p4d->coeffErr[0][1][0][0] = 0.4;
     372    p4d->coeffErr[1][0][0][0] = 0.5;
     373
     374    p4d->coeffErr[0][0][1][1] = 0.6;
     375    p4d->coeffErr[0][1][0][1] = 0.7;
     376    p4d->coeffErr[1][0][0][1] = 0.8;
     377    p4d->coeffErr[0][1][1][0] = 0.9;
     378    p4d->coeffErr[1][0][1][0] = 0.10;
     379    p4d->coeffErr[1][1][0][0] = 0.11;
     380
     381    p4d->coeffErr[0][1][1][1] = 0.12;
     382    p4d->coeffErr[1][0][1][1] = 0.13;
     383    p4d->coeffErr[1][1][0][1] = 0.14;
     384    p4d->coeffErr[1][1][1][0] = 0.15;
     385
     386    p4d->coeffErr[1][1][1][1] = 0.16;
     387
     388    //psPolynomial4DtoMD
     389    //Return a valid metadata containing a polynomial-metadata structure
     390    {
     391        ok( psPolynomial4DtoMD(md, p4d, "polyMD"),
     392            "psPolynomial4DtoMD:     return true for valid inputs.");
     393        psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD");
     394        skip_start( polyMDtemp == NULL , 1,
     395                    "Skipping 1 tests because psPolynomial4DtoMD has errors");
     396        psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0);
     397        skip_start( polyItem == NULL, 2,
     398                    "Skipping 4 tests because psPolynomial4DtoMD has errors in order elements");
     399        ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1,
     400            "psPolynomial4DtoMD:     return correct number of x orders.");
     401        polyItem = psMetadataGet(polyMDtemp, 1);
     402        ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1,
     403            "psPolynomial4DtoMD:     return correct number of y orders.");
     404        polyItem = psMetadataGet(polyMDtemp, 2);
     405        ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1,
     406            "psPolynomial4DtoMD:     return correct number of z orders.");
     407        polyItem = psMetadataGet(polyMDtemp, 3);
     408        ok( !strncmp(polyItem->name, "NORDER_T", 10) && polyItem->data.S32 == 1,
     409            "psPolynomial4DtoMD:     return correct number of t orders.");
     410        skip_end();
     411        polyItem = psMetadataGet(polyMDtemp, 4);
     412        skip_start( polyItem == NULL, 2,
     413                    "Skipping 2 tests because psPolynomial4DtoMD has errors in coeff elements");
     414        ok( !strncmp(polyItem->name, "VAL_X00_Y00_Z00_T00", 14) &&
     415            abs(polyItem->data.F64-1.1) < DBL_EPSILON,
     416            "psPolynomial4DtoMD:     return correct first element.");
     417        polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
     418        ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01_T01", 14) &&
     419            abs(polyItem->data.F64-0.16) < DBL_EPSILON,
     420            "psPolynomial4DtoMD:     return correct last element.");
     421        skip_end();
     422        skip_end();
     423    }
     424    //Return false for no-name polynomial
     425    {
     426        ok( !psPolynomial4DtoMD(md, p4d, ""),
     427            "psPolynomial4DtoMD:     return false for no-name.");
     428    }
     429    //Return false for NULL-name polynomial
     430    {
     431        ok( !psPolynomial4DtoMD(md, p4d, NULL),
     432            "psPolynomial4DtoMD:     return false for NULL name input.");
     433    }
     434    //Return false for NULL metadata input
     435    {
     436        ok( !psPolynomial4DtoMD(NULL, p4d, "polyMD"),
     437            "psPolynomial4DtoMD:     return false for NULL metadata input.");
     438    }
     439    //Return false for NULL polynomial input
     440    {
     441        ok( !psPolynomial4DtoMD(md, NULL, "polyMD"),
     442            "psPolynomial4DtoMD:     return false for NULL polynomial input.");
     443    }
     444    //Return false for empty polynomial
     445    {
     446        psPolynomial4D *emptyPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0);
     447        ok( !psPolynomial4DtoMD(md, emptyPoly, "polyMD"),
     448            "psPolynomial4DtoMD:     return false for empty polynomial input.");
     449        psFree(emptyPoly);
     450    }
     451    //Return true for polynomial with 1 element, a constant
     452    {
     453        psPolynomial4D *constPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0);
     454        constPoly->coeff[0][0][0][0] = 6.66;
     455        ok( psPolynomial4DtoMD(md, constPoly, "polyMD"),
     456            "psPolynomial4DtoMD:     return true for constant polynomial (1 element != 0).");
     457        psFree(constPoly);
     458    }
     459    //Return false for non-ordinary polynomial
     460    {
     461        psPolynomial4D *p4d2 = psPolynomial4DAlloc(PS_POLYNOMIAL_CHEB, 1, 1, 1, 1);
     462        p4d2->coeff[0][0][0][0] = 1.1;
     463        ok( !psPolynomial4DtoMD(md, p4d2, "polyMD"),
     464            "psPolynomial4DtoMD:     return false for chebyshev polynomial");
     465        psFree(p4d2);
     466    }
     467
     468    //psPolynomial4DfromMD Tests
     469    //Return NULL for NULL metadata input.
     470    {
     471        psPolynomial4D *emptyPoly2D = NULL;
     472        emptyPoly2D = psPolynomial4DfromMD(NULL);
     473        ok( emptyPoly2D == NULL,
     474            "psPolynomial4DfromMD:   return NULL for NULL metadata input.");
     475    }
     476    //Get a polynomial from Metadata.
     477    psPolynomial4D *outPoly = NULL;
     478    psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD");
     479    outPoly = psPolynomial4DfromMD(polyMDtemp);
     480    {
     481        skip_start( outPoly == NULL, 1,
     482                    "Skipping 1 tests because psPolynomial4DfromMD has errors.");
     483        ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
     484            outPoly->nY == 1 && outPoly->nZ == 1 && outPoly->nT == 1 &&
     485            abs(outPoly->coeff[0][0][0][0] - 1.1) < DBL_EPSILON,
     486            "psPolynomial4DfromMD:   return correct polynomial from metadata");
     487        skip_end();
     488    }
     489    //Return NULL for polynomial with missing coefficient
     490    psMetadataRemoveIndex(polyMDtemp, PS_LIST_TAIL-1);
     491    psFree(outPoly);
     492    outPoly = NULL;
     493    outPoly = psPolynomial4DfromMD(polyMDtemp);
     494    {
     495        //        ok( outPoly->mask[1][1][1] == 1,
     496        //            "psPolynomial4DfromMD:   return mask[1][1][1] == 1 for metadata-polynomial"
     497        //            " with missing element");
     498        ok( outPoly == NULL,
     499            "psPolynomial4DfromMD:   return NULL for polynomial with missing coeff");
     500    }
     501    //Return NULL for polynomial in metadata with no t-order
     502    psMetadataRemoveKey(polyMDtemp, "NORDER_T");
     503    outPoly = psPolynomial4DfromMD(polyMDtemp);
     504    {
     505        ok( outPoly == NULL,
     506            "psPolynomial4DfromMD:   return NULL for metadata-polynomial with no t-order");
     507    }
     508    //Return NULL for polynomial in metadata with no z-order
     509    psMetadataRemoveKey(polyMDtemp, "NORDER_Z");
     510    outPoly = psPolynomial4DfromMD(polyMDtemp);
     511    {
     512        ok( outPoly == NULL,
     513            "psPolynomial4DfromMD:   return NULL for metadata-polynomial with no z-order");
     514    }
     515    //Return NULL for polynomial in metadata with no y-order
     516    psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
     517    outPoly = psPolynomial4DfromMD(polyMDtemp);
     518    {
     519        ok( outPoly == NULL,
     520            "psPolynomial4DfromMD:   return NULL for metadata-polynomial with no y-order");
     521    }
     522    //Return NULL for polynomial in metadata with no x-order
     523    psMetadataRemoveKey(polyMDtemp, "NORDER_X");
     524    outPoly = psPolynomial4DfromMD(polyMDtemp);
     525    {
     526        ok( outPoly == NULL,
     527            "psPolynomial4DfromMD:   return NULL for metadata-polynomial with no x-order");
     528    }
    98529
    99530    //Check for Memory leaks
    100531    {
    101         psFree(out);
     532        psFree(outPoly);
     533        psFree(p4d);
    102534        psFree(md);
    103535        checkMem();
Note: See TracChangeset for help on using the changeset viewer.