IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 9582


Ignore:
Timestamp:
Oct 16, 2006, 1:32:53 PM (20 years ago)
Author:
drobbin
Message:

Updated tests to reflect changes made to source. Log/TraceArguments removed from psArguments. ArrayRemove & ArrayRemoveByPos changed to ArrayRemoveData & ArrayRemoveIndex. MetadataLookupMD changed to MetadataLookupMetadata and PolynomialXDto/fromMD changed to PolynomialXDto/fromMetadata.

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

Legend:

Unmodified
Added
Removed

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

    r8805 r9582  
    1919void testArgumentGetParse(void);
    2020void testArgumentVerbosity(void);
    21 void testLogTraceArguments(void);
     21//void testLogTraceArguments(void);
    2222
    2323int main(void)
    … …  
    2929    testArgumentGetParse();
    3030    testArgumentVerbosity();
    31     testLogTraceArguments();
     31    //    testLogTraceArguments();
    3232
    3333    done();
    … …  
    314314}
    315315
     316/*
    316317void testLogTraceArguments(void)
    317318{
    318319    diag("  >>>Test 3:  psLogArguments & psTraceArguments Fxns");
    319 
     320 
    320321    //Return 2 (default) for NULL arguments input
    321322    {
    … …  
    377378            "psLogArguments:       return 2 for '-logfmt H' argument inputs.");
    378379    }
    379 
    380 
     380 
     381 
    381382    //psTraceArguments Tests
    382383    //Return 0 (default) for NULL arguments input
    … …  
    422423            "psTraceArguments:     return 2 for '-trace-levels' argument input.");
    423424    }
    424 
     425 
    425426    //Check for Memory leaks
    426427    {
    … …  
    428429    }
    429430}
     431*/

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

    r9143 r9582  
    149149    }
    150150
    151     //Tests for psArrayRemove
     151    //Tests for psArrayRemoveData
    152152    //Setup array with 3 elements to test remove function
    153153    //Return false for attempting to remove from a NULL array
    154154    {
    155155        psArray *temp = NULL;
    156         ok( !psArrayRemove(temp, s2),
    157             "psArrayRemove:         return false for NULL input psArray.");
     156        ok( !psArrayRemoveData(temp, s2),
     157            "psArrayRemoveData:         return false for NULL input psArray.");
    158158    }
    159159    //Return true for successful removal
    160160    {
    161         ok( psArrayRemove(a, s2) && a->n == 2,
    162             "psArrayRemove:         return true for successful removal.");
    163     }
    164 
    165     //Tests for psArrayRemoveByPos
     161        ok( psArrayRemoveData(a, s2) && a->n == 2,
     162            "psArrayRemoveData:         return true for successful removal.");
     163    }
     164
     165    //Tests for psArrayRemoveIndex
    166166    //Return false for NULL array input
    167167    {
    168         ok( !psArrayRemoveByPos(NULL, 0),
    169             "psArrayRemoveByPos:    return false for NULL input psArray.");
     168        ok( !psArrayRemoveIndex(NULL, 0),
     169            "psArrayRemoveIndex:    return false for NULL input psArray.");
    170170    }
    171171    //Return false for out-of-range index
    172172    {
    173         ok( !psArrayRemoveByPos(a, 5),
    174             "psArrayRemoveByPos:    return false for out-of-range location.");
     173        ok( !psArrayRemoveIndex(a, 5),
     174            "psArrayRemoveIndex:    return false for out-of-range location.");
    175175    }
    176176    //Return true for successful removal
    177177    {
    178         ok( psArrayRemoveByPos(a, 1) && a->n == 1,
    179             "psArrayRemoveByPos:    return true for successful removal.");
     178        ok( psArrayRemoveIndex(a, 1) && a->n == 1,
     179            "psArrayRemoveIndex:    return true for successful removal.");
    180180    }
    181181

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

    r8995 r9582  
    182182        bool status = false;
    183183        psMetadata *mdtemp = NULL;
    184         mdtemp = psMetadataLookupMD(&status, md, "metadata7");
     184        mdtemp = psMetadataLookupMetadata(&status, md, "metadata7");
    185185        psMetadataItem *itemtemp = psMetadataGet(mdtemp, PS_LIST_HEAD);
    186186        ok( status && itemtemp->type == PS_DATA_S32 && itemtemp->data.S32 == 666,
    … …  
    256256        bool status = false;
    257257        psMetadata *met = NULL;
    258         met = psMetadataLookupMD(&status, md, "item");
     258        met = psMetadataLookupMetadata(&status, md, "item");
    259259        ok( !status && met == NULL,
    260260            "psMetadataLookupMD:   return NULL for incorrect key.");
    261261        met = NULL;
    262         met = psMetadataLookupMD(NULL, md, "item");
     262        met = psMetadataLookupMetadata(NULL, md, "item");
    263263        ok( met == NULL,
    264264            "psMetadataLookupMD:   return NULL for incorrect key (& NULL status).");
    … …  
    268268        bool status = false;
    269269        psMetadata *met = NULL;
    270         met = psMetadataLookupMD(&status, md, "itemS8");
     270        met = psMetadataLookupMetadata(&status, md, "itemS8");
    271271        ok( !status && met == NULL,
    272272            "psMetadataLookupMD:   return NULL for incorrect key (& NULL status).");
    273273        met = NULL;
    274         met = psMetadataLookupMD(NULL, md, "itemS8");
     274        met = psMetadataLookupMetadata(NULL, md, "itemS8");
    275275        ok( met == NULL,
    276276            "psMetadataLookupMD:   return NULL for incorrect key.");

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

    r9536 r9582  
    3636void test2Dcase(void)
    3737{
    38     diag("  >>>Test 1:  psPolynomial2DtoMD & psPolynomial2DfromMD functions");
     38    diag("  >>>Test 1:  psPolynomial2DtoMetadata & psPolynomial2DfromMetadata functions");
    3939    psMetadata *md = psMetadataAlloc();
    4040    psPolynomial2D *p2d = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 1, 1);
    … …  
    4848    p2d->coeffErr[1][1] = 0.4;
    4949
    50     //psPolynomial2DtoMD
     50    //psPolynomial2DtoMetadata
    5151    //Return a valid metadata containing a polynomial-metadata structure
    5252    {
    53         ok( psPolynomial2DtoMD(md, p2d, "polyMD"),
    54             "psPolynomial2DtoMD:      return true for valid inputs.");
     53        ok( psPolynomial2DtoMetadata(md, p2d, "polyMD"),
     54            "psPolynomial2DtoMetadata:      return true for valid inputs.");
    5555
    5656        psMetadataConfigWrite (md, "test.md");
    … …  
    5858        ok (0, "these tests are relying on the ORDER of the MD components not the NAMES");
    5959        ok (0, "these seem like irrelevant tests");
    60         psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD");
     60        psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
    6161        skip_start( polyMDtemp == NULL , 1,
    62                     "Skipping 1 tests because psPolynomial2DtoMD has errors");
     62                    "Skipping 1 tests because psPolynomial2DtoMetadata has errors");
    6363        psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0);
    6464        skip_start( polyItem == NULL, 2,
    65                     "Skipping 2 tests because psPolynomial2DtoMD has errors in order elements");
     65                    "Skipping 2 tests because psPolynomial2DtoMetadata has errors in order elements");
    6666        ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1,
    67             "psPolynomial2DtoMD:      return correct number of x orders.");
     67            "psPolynomial2DtoMetadata:      return correct number of x orders.");
    6868        polyItem = psMetadataGet(polyMDtemp, 1);
    6969        ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1,
    70             "psPolynomial2DtoMD:      return correct number of y orders.");
     70            "psPolynomial2DtoMetadata:      return correct number of y orders.");
    7171        skip_end();
    7272        polyItem = psMetadataGet(polyMDtemp, 2);
    7373        skip_start( polyItem == NULL, 2,
    74                     "Skipping 2 tests because psPolynomial2DtoMD has errors in coeff elements");
     74                    "Skipping 2 tests because psPolynomial2DtoMetadata has errors in coeff elements");
    7575        ok( !strncmp(polyItem->name, "VAL_X00_Y00", 14) &&
    7676            abs(polyItem->data.F64-1.1) < DBL_EPSILON,
    77             "psPolynomial2DtoMD:      return correct first element.");
     77            "psPolynomial2DtoMetadata:      return correct first element.");
    7878        polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
    7979        ok( !strncmp(polyItem->name, "ERR_X01_Y01", 14) &&
    8080            abs(polyItem->data.F64-0.4) < DBL_EPSILON,
    81             "psPolynomial2DtoMD:      return correct last element.");
    82         skip_end();
    83         skip_end();
    84     }
    85 
    86     //psPolynomial2DtoMD
     81            "psPolynomial2DtoMetadata:      return correct last element.");
     82        skip_end();
     83        skip_end();
     84    }
     85
     86    //psPolynomial2DtoMetadata
    8787    //Return a valid metadata containing a polynomial-metadata structure
    8888    {
    8989        diag ("example of 2DtoMD using the names not the sequence");
    9090
    91         ok( psPolynomial2DtoMD(md, p2d, "polyMD"),
    92             "psPolynomial2DtoMD:      return true for valid inputs.");
     91        ok( psPolynomial2DtoMetadata(md, p2d, "polyMD"),
     92            "psPolynomial2DtoMetadata:      return true for valid inputs.");
    9393
    9494        psMetadataConfigWrite (md, "test.md");
    9595
    9696        // of the components.  these seem like irrelevant tests.
    97         psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD");
     97        psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
    9898        skip_start( polyMDtemp == NULL , 1,
    99                     "Skipping 1 tests because psPolynomial2DtoMD has errors");
     99                    "Skipping 1 tests because psPolynomial2DtoMetadata has errors");
    100100
    101101        bool status;
    102102        int nX = psMetadataLookupS32(&status, polyMDtemp, "NORDER_X");
    103         ok(status, "psPolynomial2DtoMD: found NORDER_X");
    104         ok(nX == 1, "psPolynomial2DtoMD: NORDER_X is 1");
     103        ok(status, "psPolynomial2DtoMetadata: found NORDER_X");
     104        ok(nX == 1, "psPolynomial2DtoMetadata: NORDER_X is 1");
    105105
    106106        int nY = psMetadataLookupS32(&status, polyMDtemp, "NORDER_Y");
    107         ok(status, "psPolynomial2DtoMD: found NORDER_Y");
    108         ok(nY == 1, "psPolynomial2DtoMD: NORDER_Y is 1");
     107        ok(status, "psPolynomial2DtoMetadata: found NORDER_Y");
     108        ok(nY == 1, "psPolynomial2DtoMetadata: NORDER_Y is 1");
    109109
    110110        double val;
    111111        val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X00_Y00");
    112         ok(status, "psPolynomial2DtoMD: found VAL_X00_Y00");
    113         ok_double(val, 1.1, "psPolynomial2DtoMD: VAL_X00_Y00 is %lf", val);
     112        ok(status, "psPolynomial2DtoMetadata: found VAL_X00_Y00");
     113        ok_double(val, 1.1, "psPolynomial2DtoMetadata: VAL_X00_Y00 is %lf", val);
    114114
    115115        val = psMetadataLookupF64(&status, polyMDtemp, "VAL_X01_Y01");
    116         ok(status, "psPolynomial2DtoMD: found VAL_X01_Y01");
    117         ok_double(val, 4.4, "psPolynomial2DtoMD: VAL_X01_Y01 is %lf", val);
     116        ok(status, "psPolynomial2DtoMetadata: found VAL_X01_Y01");
     117        ok_double(val, 4.4, "psPolynomial2DtoMetadata: VAL_X01_Y01 is %lf", val);
    118118
    119119        skip_end();
    … …  
    122122    //Return false for no-name polynomial
    123123    {
    124         ok( !psPolynomial2DtoMD(md, p2d, ""),
    125             "psPolynomial2DtoMD:      return false for no-name.");
     124        ok( !psPolynomial2DtoMetadata(md, p2d, ""),
     125            "psPolynomial2DtoMetadata:      return false for no-name.");
    126126    }
    127127    //Return false for NULL-name polynomial
    128128    {
    129         ok( !psPolynomial2DtoMD(md, p2d, NULL),
    130             "psPolynomial2DtoMD:      return false for NULL name input.");
     129        ok( !psPolynomial2DtoMetadata(md, p2d, NULL),
     130            "psPolynomial2DtoMetadata:      return false for NULL name input.");
    131131    }
    132132    //Return false for NULL metadata input
    133133    {
    134         ok( !psPolynomial2DtoMD(NULL, p2d, "polyMD"),
    135             "psPolynomial2DtoMD:      return false for NULL metadata input.");
     134        ok( !psPolynomial2DtoMetadata(NULL, p2d, "polyMD"),
     135            "psPolynomial2DtoMetadata:      return false for NULL metadata input.");
    136136    }
    137137    //Return false for NULL polynomial input
    138138    {
    139         ok( !psPolynomial2DtoMD(md, NULL, "polyMD"),
    140             "psPolynomial2DtoMD:      return false for NULL polynomial input.");
     139        ok( !psPolynomial2DtoMetadata(md, NULL, "polyMD"),
     140            "psPolynomial2DtoMetadata:      return false for NULL polynomial input.");
    141141    }
    142142    //Return false for empty polynomial
    143143    {
    144144        psPolynomial2D *emptyPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0);
    145         ok( !psPolynomial2DtoMD(md, emptyPoly, "polyMD"),
    146             "psPolynomial2DtoMD:     return false for empty polynomial input.");
     145        ok( !psPolynomial2DtoMetadata(md, emptyPoly, "polyMD"),
     146            "psPolynomial2DtoMetadata:     return false for empty polynomial input.");
    147147        psFree(emptyPoly);
    148148    }
    … …  
    151151        psPolynomial2D *constPoly = psPolynomial2DAlloc(PS_POLYNOMIAL_ORD, 0, 0);
    152152        constPoly->coeff[0][0] = 6.66;
    153         ok( psPolynomial2DtoMD(md, constPoly, "polyMD"),
    154             "psPolynomial2DtoMD:     return true for constant polynomial (1 element != 0).");
     153        ok( psPolynomial2DtoMetadata(md, constPoly, "polyMD"),
     154            "psPolynomial2DtoMetadata:     return true for constant polynomial (1 element != 0).");
    155155        psFree(constPoly);
    156156    }
    … …  
    159159        psPolynomial2D *p2d2 = psPolynomial2DAlloc(PS_POLYNOMIAL_CHEB, 1, 1);
    160160        p2d2->coeff[0][0] = 1.1;
    161         ok( !psPolynomial2DtoMD(md, p2d2, "polyMD"),
    162             "psPolynomial2DtoMD:     return false for chebyshev polynomial");
     161        ok( !psPolynomial2DtoMetadata(md, p2d2, "polyMD"),
     162            "psPolynomial2DtoMetadata:     return false for chebyshev polynomial");
    163163        psFree(p2d2);
    164164    }
    165165
    166     //psPolynomial2DfromMD Tests
     166    //psPolynomial2DfromMetadata Tests
    167167    //Return NULL for NULL metadata input.
    168168    {
    169169        psPolynomial2D *emptyPoly2D = NULL;
    170         emptyPoly2D = psPolynomial2DfromMD(NULL);
     170        emptyPoly2D = psPolynomial2DfromMetadata(NULL);
    171171        ok( emptyPoly2D == NULL,
    172             "psPolynomial2DfromMD:   return NULL for NULL metadata input.");
     172            "psPolynomial2DfromMetadata:   return NULL for NULL metadata input.");
    173173    }
    174174    //Get a polynomial from Metadata.
    175175    psPolynomial2D *outPoly = NULL;
    176     psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD");
    177     outPoly = psPolynomial2DfromMD(polyMDtemp);
     176    psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
     177    outPoly = psPolynomial2DfromMetadata(polyMDtemp);
    178178    {
    179179        skip_start( outPoly == NULL, 1,
    180                     "Skipping 1 tests because psPolynomial2DfromMD has errors.");
     180                    "Skipping 1 tests because psPolynomial2DfromMetadata has errors.");
    181181        ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
    182182            outPoly->nY == 1 && abs(outPoly->coeff[0][0] - 1.1) < DBL_EPSILON,
    183             "psPolynomial2DfromMD:   return correct polynomial from metadata");
     183            "psPolynomial2DfromMetadata:   return correct polynomial from metadata");
    184184        skip_end();
    185185    }
    … …  
    188188    psFree(outPoly);
    189189    outPoly = NULL;
    190     outPoly = psPolynomial2DfromMD(polyMDtemp);
     190    outPoly = psPolynomial2DfromMetadata(polyMDtemp);
    191191    {
    192192        //        ok( outPoly->mask[1][1] == 1,
    193         //            "psPolynomial2DfromMD:   return mask[1][1] == 1 for metadata-polynomial",
     193        //            "psPolynomial2DfromMetadata:   return mask[1][1] == 1 for metadata-polynomial",
    194194        //            " with missing element");
    195195        ok( outPoly == NULL,
    196             "psPolynomial2DfromMD:   return NULL for polynomial with missing coeff");
     196            "psPolynomial2DfromMetadata:   return NULL for polynomial with missing coeff");
    197197    }
    198198    //Return NULL for polynomial in metadata with no y-order
    199199    psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
    200     outPoly = psPolynomial2DfromMD(polyMDtemp);
    201     {
    202         ok( outPoly == NULL,
    203             "psPolynomial2DfromMD:   return NULL for metadata-polynomial with no y-order");
     200    outPoly = psPolynomial2DfromMetadata(polyMDtemp);
     201    {
     202        ok( outPoly == NULL,
     203            "psPolynomial2DfromMetadata:   return NULL for metadata-polynomial with no y-order");
    204204    }
    205205    //Return NULL for polynomial in metadata with no x-order
    206206    psMetadataRemoveKey(polyMDtemp, "NORDER_X");
    207     outPoly = psPolynomial2DfromMD(polyMDtemp);
    208     {
    209         ok( outPoly == NULL,
    210             "psPolynomial2DfromMD:   return NULL for metadata-polynomial with no x-order");
     207    outPoly = psPolynomial2DfromMetadata(polyMDtemp);
     208    {
     209        ok( outPoly == NULL,
     210            "psPolynomial2DfromMetadata:   return NULL for metadata-polynomial with no x-order");
    211211    }
    212212
    … …  
    222222void test3Dcase(void)
    223223{
    224     diag("  >>>Test 2:  psPolynomial3DtoMD & psPolynomial3DfromMD functions");
     224    diag("  >>>Test 2:  psPolynomial3DtoMetadata & psPolynomial3DfromMetadata functions");
    225225    psMetadata *md = psMetadataAlloc();
    226226    psPolynomial3D *p3d = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1);
    … …  
    242242    p3d->coeffErr[1][1][1] = 0.8;
    243243
    244     //psPolynomial3DtoMD
     244    //psPolynomial3DtoMetadata
    245245    //Return a valid metadata containing a polynomial-metadata structure
    246246    {
    247         ok( psPolynomial3DtoMD(md, p3d, "polyMD"),
    248             "psPolynomial3DtoMD:     return true for valid inputs.");
    249         psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD");
     247        ok( psPolynomial3DtoMetadata(md, p3d, "polyMD"),
     248            "psPolynomial3DtoMetadata:     return true for valid inputs.");
     249        psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
    250250        skip_start( polyMDtemp == NULL , 1,
    251                     "Skipping 1 tests because psPolynomial3DtoMD has errors");
     251                    "Skipping 1 tests because psPolynomial3DtoMetadata has errors");
    252252        psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0);
    253253        skip_start( polyItem == NULL, 2,
    254                     "Skipping 3 tests because psPolynomial3DtoMD has errors in order elements");
     254                    "Skipping 3 tests because psPolynomial3DtoMetadata has errors in order elements");
    255255        ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1,
    256             "psPolynomial3DtoMD:     return correct number of x orders.");
     256            "psPolynomial3DtoMetadata:     return correct number of x orders.");
    257257        polyItem = psMetadataGet(polyMDtemp, 1);
    258258        ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1,
    259             "psPolynomial3DtoMD:     return correct number of y orders.");
     259            "psPolynomial3DtoMetadata:     return correct number of y orders.");
    260260        polyItem = psMetadataGet(polyMDtemp, 2);
    261261        ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1,
    262             "psPolynomial3DtoMD:     return correct number of z orders.");
     262            "psPolynomial3DtoMetadata:     return correct number of z orders.");
    263263        skip_end();
    264264        polyItem = psMetadataGet(polyMDtemp, 3);
    265265        skip_start( polyItem == NULL, 2,
    266                     "Skipping 2 tests because psPolynomial3DtoMD has errors in coeff elements");
     266                    "Skipping 2 tests because psPolynomial3DtoMetadata has errors in coeff elements");
    267267        ok( !strncmp(polyItem->name, "VAL_X00_Y00_Z00", 14) &&
    268268            abs(polyItem->data.F64-1.1) < DBL_EPSILON,
    269             "psPolynomial3DtoMD:     return correct first element.");
     269            "psPolynomial3DtoMetadata:     return correct first element.");
    270270        polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
    271271        ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01", 14) &&
    272272            abs(polyItem->data.F64-0.8) < DBL_EPSILON,
    273             "psPolynomial3DtoMD:     return correct last element.");
     273            "psPolynomial3DtoMetadata:     return correct last element.");
    274274        skip_end();
    275275        skip_end();
    … …  
    277277    //Return false for no-name polynomial
    278278    {
    279         ok( !psPolynomial3DtoMD(md, p3d, ""),
    280             "psPolynomial3DtoMD:     return false for no-name.");
     279        ok( !psPolynomial3DtoMetadata(md, p3d, ""),
     280            "psPolynomial3DtoMetadata:     return false for no-name.");
    281281    }
    282282    //Return false for NULL-name polynomial
    283283    {
    284         ok( !psPolynomial3DtoMD(md, p3d, NULL),
    285             "psPolynomial3DtoMD:     return false for NULL name input.");
     284        ok( !psPolynomial3DtoMetadata(md, p3d, NULL),
     285            "psPolynomial3DtoMetadata:     return false for NULL name input.");
    286286    }
    287287    //Return false for NULL metadata input
    288288    {
    289         ok( !psPolynomial3DtoMD(NULL, p3d, "polyMD"),
    290             "psPolynomial3DtoMD:     return false for NULL metadata input.");
     289        ok( !psPolynomial3DtoMetadata(NULL, p3d, "polyMD"),
     290            "psPolynomial3DtoMetadata:     return false for NULL metadata input.");
    291291    }
    292292    //Return false for NULL polynomial input
    293293    {
    294         ok( !psPolynomial3DtoMD(md, NULL, "polyMD"),
    295             "psPolynomial3DtoMD:     return false for NULL polynomial input.");
     294        ok( !psPolynomial3DtoMetadata(md, NULL, "polyMD"),
     295            "psPolynomial3DtoMetadata:     return false for NULL polynomial input.");
    296296    }
    297297    //Return false for empty polynomial
    298298    {
    299299        psPolynomial3D *emptyPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0);
    300         ok( !psPolynomial3DtoMD(md, emptyPoly, "polyMD"),
    301             "psPolynomial3DtoMD:     return false for empty polynomial input.");
     300        ok( !psPolynomial3DtoMetadata(md, emptyPoly, "polyMD"),
     301            "psPolynomial3DtoMetadata:     return false for empty polynomial input.");
    302302        psFree(emptyPoly);
    303303    }
    … …  
    306306        psPolynomial3D *constPoly = psPolynomial3DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0);
    307307        constPoly->coeff[0][0][0] = 6.66;
    308         ok( psPolynomial3DtoMD(md, constPoly, "polyMD"),
    309             "psPolynomial3DtoMD:     return true for constant polynomial (1 element != 0).");
     308        ok( psPolynomial3DtoMetadata(md, constPoly, "polyMD"),
     309            "psPolynomial3DtoMetadata:     return true for constant polynomial (1 element != 0).");
    310310        psFree(constPoly);
    311311    }
    … …  
    314314        psPolynomial3D *p3d2 = psPolynomial3DAlloc(PS_POLYNOMIAL_CHEB, 1, 1, 1);
    315315        p3d2->coeff[0][0][0] = 1.1;
    316         ok( !psPolynomial3DtoMD(md, p3d2, "polyMD"),
    317             "psPolynomial3DtoMD:     return false for chebyshev polynomial");
     316        ok( !psPolynomial3DtoMetadata(md, p3d2, "polyMD"),
     317            "psPolynomial3DtoMetadata:     return false for chebyshev polynomial");
    318318        psFree(p3d2);
    319319    }
    320320
    321     //psPolynomial3DfromMD Tests
     321    //psPolynomial3DfromMetadata Tests
    322322    //Return NULL for NULL metadata input.
    323323    {
    324324        psPolynomial3D *emptyPoly2D = NULL;
    325         emptyPoly2D = psPolynomial3DfromMD(NULL);
     325        emptyPoly2D = psPolynomial3DfromMetadata(NULL);
    326326        ok( emptyPoly2D == NULL,
    327             "psPolynomial3DfromMD:   return NULL for NULL metadata input.");
     327            "psPolynomial3DfromMetadata:   return NULL for NULL metadata input.");
    328328    }
    329329    //Get a polynomial from Metadata.
    330330    psPolynomial3D *outPoly = NULL;
    331     psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD");
    332     outPoly = psPolynomial3DfromMD(polyMDtemp);
     331    psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
     332    outPoly = psPolynomial3DfromMetadata(polyMDtemp);
    333333    {
    334334        skip_start( outPoly == NULL, 1,
    335                     "Skipping 1 tests because psPolynomial3DfromMD has errors.");
     335                    "Skipping 1 tests because psPolynomial3DfromMetadata has errors.");
    336336        ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
    337337            outPoly->nY == 1 && outPoly->nZ == 1 &&
    338338            abs(outPoly->coeff[0][0][0] - 1.1) < DBL_EPSILON,
    339             "psPolynomial3DfromMD:   return correct polynomial from metadata");
     339            "psPolynomial3DfromMetadata:   return correct polynomial from metadata");
    340340        skip_end();
    341341    }
    … …  
    344344    psFree(outPoly);
    345345    outPoly = NULL;
    346     outPoly = psPolynomial3DfromMD(polyMDtemp);
     346    outPoly = psPolynomial3DfromMetadata(polyMDtemp);
    347347    {
    348348        //        ok( outPoly->mask[1][1][1] == 1,
    349         //            "psPolynomial3DfromMD:   return mask[1][1][1] == 1 for metadata-polynomial"
     349        //            "psPolynomial3DfromMetadata:   return mask[1][1][1] == 1 for metadata-polynomial"
    350350        //            " with missing element");
    351351        ok( outPoly == NULL,
    352             "psPolynomial3DfromMD:   return NULL for polynomial with missing coeff");
     352            "psPolynomial3DfromMetadata:   return NULL for polynomial with missing coeff");
    353353    }
    354354    //Return NULL for polynomial in metadata with no z-order
    355355    psMetadataRemoveKey(polyMDtemp, "NORDER_Z");
    356     outPoly = psPolynomial3DfromMD(polyMDtemp);
    357     {
    358         ok( outPoly == NULL,
    359             "psPolynomial3DfromMD:   return NULL for metadata-polynomial with no z-order");
     356    outPoly = psPolynomial3DfromMetadata(polyMDtemp);
     357    {
     358        ok( outPoly == NULL,
     359            "psPolynomial3DfromMetadata:   return NULL for metadata-polynomial with no z-order");
    360360    }
    361361    //Return NULL for polynomial in metadata with no y-order
    362362    psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
    363     outPoly = psPolynomial3DfromMD(polyMDtemp);
    364     {
    365         ok( outPoly == NULL,
    366             "psPolynomial3DfromMD:   return NULL for metadata-polynomial with no y-order");
     363    outPoly = psPolynomial3DfromMetadata(polyMDtemp);
     364    {
     365        ok( outPoly == NULL,
     366            "psPolynomial3DfromMetadata:   return NULL for metadata-polynomial with no y-order");
    367367    }
    368368    //Return NULL for polynomial in metadata with no x-order
    369369    psMetadataRemoveKey(polyMDtemp, "NORDER_X");
    370     outPoly = psPolynomial3DfromMD(polyMDtemp);
    371     {
    372         ok( outPoly == NULL,
    373             "psPolynomial3DfromMD:   return NULL for metadata-polynomial with no x-order");
     370    outPoly = psPolynomial3DfromMetadata(polyMDtemp);
     371    {
     372        ok( outPoly == NULL,
     373            "psPolynomial3DfromMetadata:   return NULL for metadata-polynomial with no x-order");
    374374    }
    375375
    … …  
    385385void test4Dcase(void)
    386386{
    387     diag("  >>>Test 3:  psPolynomial4DtoMD & psPolynomial4DfromMD functions");
     387    diag("  >>>Test 3:  psPolynomial4DtoMetadata & psPolynomial4DfromMetadata functions");
    388388    psMetadata *md = psMetadataAlloc();
    389389    psPolynomial4D *p4d = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 1, 1, 1, 1);
    … …  
    428428    p4d->coeffErr[1][1][1][1] = 0.16;
    429429
    430     //psPolynomial4DtoMD
     430    //psPolynomial4DtoMetadata
    431431    //Return a valid metadata containing a polynomial-metadata structure
    432432    {
    433         ok( psPolynomial4DtoMD(md, p4d, "polyMD"),
    434             "psPolynomial4DtoMD:     return true for valid inputs.");
    435         psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD");
     433        ok( psPolynomial4DtoMetadata(md, p4d, "polyMD"),
     434            "psPolynomial4DtoMetadata:     return true for valid inputs.");
     435        psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
    436436        skip_start( polyMDtemp == NULL , 1,
    437                     "Skipping 1 tests because psPolynomial4DtoMD has errors");
     437                    "Skipping 1 tests because psPolynomial4DtoMetadata has errors");
    438438        psMetadataItem *polyItem = psMetadataGet(polyMDtemp, 0);
    439439        skip_start( polyItem == NULL, 2,
    440                     "Skipping 4 tests because psPolynomial4DtoMD has errors in order elements");
     440                    "Skipping 4 tests because psPolynomial4DtoMetadata has errors in order elements");
    441441        ok( !strncmp(polyItem->name, "NORDER_X", 10) && polyItem->data.S32 == 1,
    442             "psPolynomial4DtoMD:     return correct number of x orders.");
     442            "psPolynomial4DtoMetadata:     return correct number of x orders.");
    443443        polyItem = psMetadataGet(polyMDtemp, 1);
    444444        ok( !strncmp(polyItem->name, "NORDER_Y", 10) && polyItem->data.S32 == 1,
    445             "psPolynomial4DtoMD:     return correct number of y orders.");
     445            "psPolynomial4DtoMetadata:     return correct number of y orders.");
    446446        polyItem = psMetadataGet(polyMDtemp, 2);
    447447        ok( !strncmp(polyItem->name, "NORDER_Z", 10) && polyItem->data.S32 == 1,
    448             "psPolynomial4DtoMD:     return correct number of z orders.");
     448            "psPolynomial4DtoMetadata:     return correct number of z orders.");
    449449        polyItem = psMetadataGet(polyMDtemp, 3);
    450450        ok( !strncmp(polyItem->name, "NORDER_T", 10) && polyItem->data.S32 == 1,
    451             "psPolynomial4DtoMD:     return correct number of t orders.");
     451            "psPolynomial4DtoMetadata:     return correct number of t orders.");
    452452        skip_end();
    453453        polyItem = psMetadataGet(polyMDtemp, 4);
    454454        skip_start( polyItem == NULL, 2,
    455                     "Skipping 2 tests because psPolynomial4DtoMD has errors in coeff elements");
     455                    "Skipping 2 tests because psPolynomial4DtoMetadata has errors in coeff elements");
    456456        ok( !strncmp(polyItem->name, "VAL_X00_Y00_Z00_T00", 14) &&
    457457            abs(polyItem->data.F64-1.1) < DBL_EPSILON,
    458             "psPolynomial4DtoMD:     return correct first element.");
     458            "psPolynomial4DtoMetadata:     return correct first element.");
    459459        polyItem = psMetadataGet(polyMDtemp, PS_LIST_TAIL);
    460460        ok( !strncmp(polyItem->name, "ERR_X01_Y01_Z01_T01", 14) &&
    461461            abs(polyItem->data.F64-0.16) < DBL_EPSILON,
    462             "psPolynomial4DtoMD:     return correct last element.");
     462            "psPolynomial4DtoMetadata:     return correct last element.");
    463463        skip_end();
    464464        skip_end();
    … …  
    466466    //Return false for no-name polynomial
    467467    {
    468         ok( !psPolynomial4DtoMD(md, p4d, ""),
    469             "psPolynomial4DtoMD:     return false for no-name.");
     468        ok( !psPolynomial4DtoMetadata(md, p4d, ""),
     469            "psPolynomial4DtoMetadata:     return false for no-name.");
    470470    }
    471471    //Return false for NULL-name polynomial
    472472    {
    473         ok( !psPolynomial4DtoMD(md, p4d, NULL),
    474             "psPolynomial4DtoMD:     return false for NULL name input.");
     473        ok( !psPolynomial4DtoMetadata(md, p4d, NULL),
     474            "psPolynomial4DtoMetadata:     return false for NULL name input.");
    475475    }
    476476    //Return false for NULL metadata input
    477477    {
    478         ok( !psPolynomial4DtoMD(NULL, p4d, "polyMD"),
    479             "psPolynomial4DtoMD:     return false for NULL metadata input.");
     478        ok( !psPolynomial4DtoMetadata(NULL, p4d, "polyMD"),
     479            "psPolynomial4DtoMetadata:     return false for NULL metadata input.");
    480480    }
    481481    //Return false for NULL polynomial input
    482482    {
    483         ok( !psPolynomial4DtoMD(md, NULL, "polyMD"),
    484             "psPolynomial4DtoMD:     return false for NULL polynomial input.");
     483        ok( !psPolynomial4DtoMetadata(md, NULL, "polyMD"),
     484            "psPolynomial4DtoMetadata:     return false for NULL polynomial input.");
    485485    }
    486486    //Return false for empty polynomial
    487487    {
    488488        psPolynomial4D *emptyPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0);
    489         ok( !psPolynomial4DtoMD(md, emptyPoly, "polyMD"),
    490             "psPolynomial4DtoMD:     return false for empty polynomial input.");
     489        ok( !psPolynomial4DtoMetadata(md, emptyPoly, "polyMD"),
     490            "psPolynomial4DtoMetadata:     return false for empty polynomial input.");
    491491        psFree(emptyPoly);
    492492    }
    … …  
    495495        psPolynomial4D *constPoly = psPolynomial4DAlloc(PS_POLYNOMIAL_ORD, 0, 0, 0, 0);
    496496        constPoly->coeff[0][0][0][0] = 6.66;
    497         ok( psPolynomial4DtoMD(md, constPoly, "polyMD"),
    498             "psPolynomial4DtoMD:     return true for constant polynomial (1 element != 0).");
     497        ok( psPolynomial4DtoMetadata(md, constPoly, "polyMD"),
     498            "psPolynomial4DtoMetadata:     return true for constant polynomial (1 element != 0).");
    499499        psFree(constPoly);
    500500    }
    … …  
    503503        psPolynomial4D *p4d2 = psPolynomial4DAlloc(PS_POLYNOMIAL_CHEB, 1, 1, 1, 1);
    504504        p4d2->coeff[0][0][0][0] = 1.1;
    505         ok( !psPolynomial4DtoMD(md, p4d2, "polyMD"),
    506             "psPolynomial4DtoMD:     return false for chebyshev polynomial");
     505        ok( !psPolynomial4DtoMetadata(md, p4d2, "polyMD"),
     506            "psPolynomial4DtoMetadata:     return false for chebyshev polynomial");
    507507        psFree(p4d2);
    508508    }
    509509
    510     //psPolynomial4DfromMD Tests
     510    //psPolynomial4DfromMetadata Tests
    511511    //Return NULL for NULL metadata input.
    512512    {
    513513        psPolynomial4D *emptyPoly2D = NULL;
    514         emptyPoly2D = psPolynomial4DfromMD(NULL);
     514        emptyPoly2D = psPolynomial4DfromMetadata(NULL);
    515515        ok( emptyPoly2D == NULL,
    516             "psPolynomial4DfromMD:   return NULL for NULL metadata input.");
     516            "psPolynomial4DfromMetadata:   return NULL for NULL metadata input.");
    517517    }
    518518    //Get a polynomial from Metadata.
    519519    psPolynomial4D *outPoly = NULL;
    520     psMetadata *polyMDtemp = psMetadataLookupMD(NULL, md, "polyMD");
    521     outPoly = psPolynomial4DfromMD(polyMDtemp);
     520    psMetadata *polyMDtemp = psMetadataLookupMetadata(NULL, md, "polyMD");
     521    outPoly = psPolynomial4DfromMetadata(polyMDtemp);
    522522    {
    523523        skip_start( outPoly == NULL, 1,
    524                     "Skipping 1 tests because psPolynomial4DfromMD has errors.");
     524                    "Skipping 1 tests because psPolynomial4DfromMetadata has errors.");
    525525        ok( outPoly->type == PS_POLYNOMIAL_ORD && outPoly->nX == 1 &&
    526526            outPoly->nY == 1 && outPoly->nZ == 1 && outPoly->nT == 1 &&
    527527            abs(outPoly->coeff[0][0][0][0] - 1.1) < DBL_EPSILON,
    528             "psPolynomial4DfromMD:   return correct polynomial from metadata");
     528            "psPolynomial4DfromMetadata:   return correct polynomial from metadata");
    529529        skip_end();
    530530    }
    … …  
    533533    psFree(outPoly);
    534534    outPoly = NULL;
    535     outPoly = psPolynomial4DfromMD(polyMDtemp);
     535    outPoly = psPolynomial4DfromMetadata(polyMDtemp);
    536536    {
    537537        //        ok( outPoly->mask[1][1][1] == 1,
    538         //            "psPolynomial4DfromMD:   return mask[1][1][1] == 1 for metadata-polynomial"
     538        //            "psPolynomial4DfromMetadata:   return mask[1][1][1] == 1 for metadata-polynomial"
    539539        //            " with missing element");
    540540        ok( outPoly == NULL,
    541             "psPolynomial4DfromMD:   return NULL for polynomial with missing coeff");
     541            "psPolynomial4DfromMetadata:   return NULL for polynomial with missing coeff");
    542542    }
    543543    //Return NULL for polynomial in metadata with no t-order
    544544    psMetadataRemoveKey(polyMDtemp, "NORDER_T");
    545     outPoly = psPolynomial4DfromMD(polyMDtemp);
    546     {
    547         ok( outPoly == NULL,
    548             "psPolynomial4DfromMD:   return NULL for metadata-polynomial with no t-order");
     545    outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     546    {
     547        ok( outPoly == NULL,
     548            "psPolynomial4DfromMetadata:   return NULL for metadata-polynomial with no t-order");
    549549    }
    550550    //Return NULL for polynomial in metadata with no z-order
    551551    psMetadataRemoveKey(polyMDtemp, "NORDER_Z");
    552     outPoly = psPolynomial4DfromMD(polyMDtemp);
    553     {
    554         ok( outPoly == NULL,
    555             "psPolynomial4DfromMD:   return NULL for metadata-polynomial with no z-order");
     552    outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     553    {
     554        ok( outPoly == NULL,
     555            "psPolynomial4DfromMetadata:   return NULL for metadata-polynomial with no z-order");
    556556    }
    557557    //Return NULL for polynomial in metadata with no y-order
    558558    psMetadataRemoveKey(polyMDtemp, "NORDER_Y");
    559     outPoly = psPolynomial4DfromMD(polyMDtemp);
    560     {
    561         ok( outPoly == NULL,
    562             "psPolynomial4DfromMD:   return NULL for metadata-polynomial with no y-order");
     559    outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     560    {
     561        ok( outPoly == NULL,
     562            "psPolynomial4DfromMetadata:   return NULL for metadata-polynomial with no y-order");
    563563    }
    564564    //Return NULL for polynomial in metadata with no x-order
    565565    psMetadataRemoveKey(polyMDtemp, "NORDER_X");
    566     outPoly = psPolynomial4DfromMD(polyMDtemp);
    567     {
    568         ok( outPoly == NULL,
    569             "psPolynomial4DfromMD:   return NULL for metadata-polynomial with no x-order");
     566    outPoly = psPolynomial4DfromMetadata(polyMDtemp);
     567    {
     568        ok( outPoly == NULL,
     569            "psPolynomial4DfromMetadata:   return NULL for metadata-polynomial with no x-order");
    570570    }
    571571
Note: See TracChangeset for help on using the changeset viewer.