IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jan 2, 2008, 10:53:30 AM (19 years ago)
Author:
gusciora
Message:

Modified file reads to look for dataFiles and then ../dataFiles.
Other additions as well.
First version: tap_pmReadoutFake.c
First version: tap_pmReadoutStack.c

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psModules/test/camera/tap_pmHDUUtils.c

    r14882 r15987  
    55#include "tap.h"
    66#include "pstap.h"
    7 // XXX: Use better name for the temporary FITS file
    8 // XXX: The code to generate and free the FPA hierarchy was copied from
    9 // tap-pmFPA.c.  EIther include it directly, or library, or something.
    10 // Also, get rid of the manual free functions and use psFree() once
    11 // it correctly frees child members
    12 // XXX: This simpleFPA() requires that the HDUs be allocated.
    13 
     7/* STATUS:
     8    All functions are tested.
     9*/
    1410
    1511#define CHIP_ALLOC_NAME        "ChipName"
    … …  
    8076    cell->hdu = pmHDUAlloc("cellExtName");
    8177    for (int i = 0 ; i < NUM_READOUTS ; i++) {
    82         cell->readouts->data[i] = generateSimpleReadout(cell);
    83     }
    84 
    85     bool rc = pmConfigFileRead(&cell->hdu->format, "data/camera0/format0.config", "Camera format 0");
     78        cell->readouts->data[i] = psMemDecrRefCounter((psPtr) generateSimpleReadout(cell));
     79    }
     80
     81    // First try to read data from ../dataFiles, then try dataFiles.
     82    bool rc = pmConfigFileRead(&cell->hdu->format, "../dataFiles/camera0/format0.config", "Camera format 0");
    8683    if (!rc) {
    87         diag("pmConfigFileRead() was unsuccessful (from generateSimpleCell())");
     84        rc = pmConfigFileRead(&cell->hdu->format, "dataFiles/camera0/format0.config", "Camera format 0");
     85        if (!rc) {
     86            diag("pmConfigFileRead() was unsuccessful (from generateSimpleCell())");
     87        }
    8888    }
    8989
    … …  
    101101
    102102    //XXX: Should the region be set some other way?  Like through the various config files?
    103 //    psRegion *region = psRegionAlloc(0.0, TEST_NUM_COLS-1, 0.0, TEST_NUM_ROWS-1);
    104103    psRegion *region = psRegionAlloc(0.0, 0.0, 0.0, 0.0);
    105104    // You shouldn't have to remove the key from the metadata.  Find out how to simply change the key value.
    … …  
    123122    chip->hdu = pmHDUAlloc("chipExtName");
    124123
    125     bool rc = pmConfigFileRead(&chip->hdu->format, "data/camera0/format0.config", "Camera format 0");
     124    bool rc = pmConfigFileRead(&chip->hdu->format, "dataFiles/camera0/format0.config", "Camera format 0");
    126125    if (!rc) {
    127         diag("pmConfigFileRead() was unsuccessful (from generateSimpleChip())");
     126        rc = pmConfigFileRead(&chip->hdu->format, "../dataFiles/camera0/format0.config", "Camera format 0");
     127        if (!rc) {
     128            diag("pmConfigFileRead() was unsuccessful (from generateSimpleChip())");
     129        }
    128130    }
    129131
    130132    psArrayRealloc(chip->cells, NUM_CELLS);
    131133    for (int i = 0 ; i < NUM_CELLS ; i++) {
    132         chip->cells->data[i] = generateSimpleCell(chip);
    133     }
    134 
    135     // XXX: Add code to initialize chip pmConcepts
    136 
    137 
     134        chip->cells->data[i] = psMemDecrRefCounter((psPtr) generateSimpleCell(chip));
     135    }
    138136    return(chip);
    139137}
    … …  
    153151    psMetadataAddS32(fpa->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM);
    154152    fpa->hdu = pmHDUAlloc("fpaExtName");
    155 
    156     bool rc = pmConfigFileRead(&fpa->hdu->format, "data/camera0/format0.config", "Camera format 0");
     153    bool rc = pmConfigFileRead(&fpa->hdu->format, "dataFiles/camera0/format0.config", "Camera format 0");
    157154    if (!rc) {
    158         diag("pmConfigFileRead() was unsuccessful (from generateSimpleFPA())");
     155        rc = pmConfigFileRead(&fpa->hdu->format, "../dataFiles/camera0/format0.config", "Camera format 0");
     156        if (!rc) {
     157            diag("pmConfigFileRead() was unsuccessful (from generateSimpleFPA())");
     158        }
    159159    }
    160160
    161161    psArrayRealloc(fpa->chips, NUM_CHIPS);
    162162    for (int i = 0 ; i < NUM_CHIPS ; i++) {
    163         fpa->chips->data[i] = generateSimpleChip(fpa);
    164     }
    165 
    166     // XXX: Eventually, when you finish the pmConcepts tests, add full concept
    167     // reading code from wherever.
     163        fpa->chips->data[i] = psMemDecrRefCounter((psPtr) generateSimpleChip(fpa));
     164    }
    168165    pmConceptsBlankFPA(fpa);
    169 //    bool mdok;
    170 //    psMetadata *fileData = psMetadataLookupMetadata(&mdok, fpa->hdu->format, "FILE");
    171 //    char *fpaNameHdr = psMetadataLookupStr(&mdok, fileData, "FPA.NAME");
    172 //    psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.NAME", PS_META_REPLACE, NULL, fpaNameHdr);
    173 
    174166    return(fpa);
    175 }
    176 
    177 // XXX: This should only be necessary until the psFree() functions for
    178 // FPA/chip/cell/readout correctly free all child chips/cells/readouts
    179 void myFreeCell(pmCell *cell)
    180 {
    181     for (int k = 0 ; k < cell->readouts->n ; k++) {
    182         psFree(cell->readouts->data[k]);
    183     }
    184     psFree(cell);
    185 }
    186 
    187 void myFreeChip(pmChip *chip) {
    188     for (int j = 0 ; j < chip->cells->n ; j++) {
    189         myFreeCell(chip->cells->data[j]);
    190     }
    191     psFree(chip);
    192 }
    193 
    194 void myFreeFPA(pmFPA *fpa)
    195 {
    196     for (int i = 0 ; i < fpa->chips->n ; i++) {
    197         myFreeChip(fpa->chips->data[i]);
    198     }
    199     psFree(fpa);
    200167}
    201168
    … …  
    208175    plan_tests(73);
    209176
    210     // ----------------------------------------------------------------------
    211     // pmHDU *pmHDUFromFPA(const pmFPA *fpa)
     177
     178    // ----------------------------------------------------------------------
    212179    // pmHDUFromFPA() tests
    213     // pmHDUFromFPA() verify with NULL input params
     180    // Call pmHDUFromFPA() with NULL input params
    214181    {
    215182        psMemId id = psMemGetId();
    … …  
    219186    }
    220187
    221     //pmHDUFromFPA() verify with acceptable input params
     188
     189    // Call pmHDUFromFPA() with acceptable input params
    222190    {
    223191        psMemId id = psMemGetId();
    … …  
    232200        pmHDU *hdu = pmHDUFromFPA(fpa);
    233201        ok(hdu == fpa->hdu, "pmHDUFromFPA(NULL) returned the correct pmHDU of an pmFPA struct");
    234         myFreeFPA(fpa);
    235         psFree(camera);
    236         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    237     }
    238 
    239 
    240     // ----------------------------------------------------------------------
    241     // pmHDU *pmHDUFromChip(const pmChip *chip)
     202        psFree(fpa);
     203        psFree(camera);
     204        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     205    }
     206
     207
     208    // ----------------------------------------------------------------------
    242209    // pmHDUFromChip() tests
    243     // pmHDUFromChip() verify with NULL input params
     210    // Call pmHDUFromChip() with NULL input params
    244211    {
    245212        psMemId id = psMemGetId();
    … …  
    249216    }
    250217
    251     //pmHDUFromChip() verify with acceptable input params
     218
     219    // Call pmHDUFromChip() with acceptable input params
    252220    {
    253221        psMemId id = psMemGetId();
    … …  
    262230        pmHDU *hdu = pmHDUFromChip(chip);
    263231        ok(hdu == chip->hdu, "pmHDUFromChip() returned the correct pmHDU of an pmChip struct");
    264         myFreeFPA(fpa);
    265         psFree(camera);
    266         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    267     }
    268 
    269     //pmHDUFromChip() verify with acceptable input params
     232        psFree(fpa);
     233        psFree(camera);
     234        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     235    }
     236
     237
     238    // Call pmHDUFromChip() with acceptable input params
    270239    // Set chip->hdu to NULL, verify chip->parent->hdu is returned
    271240    {
    … …  
    283252        pmHDU *hdu = pmHDUFromChip(chip);
    284253        ok(hdu == chip->parent->hdu, "pmHDUFromChip() returned the correct pmHDU of an pmChip struct");
    285         myFreeFPA(fpa);
    286         psFree(camera);
    287         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    288     }
    289 
    290 
    291     // ----------------------------------------------------------------------
    292     // pmHDU *pmHDUFromCell(const pmCell *cell)
     254        psFree(fpa);
     255        psFree(camera);
     256        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     257    }
     258
     259
     260    // ----------------------------------------------------------------------
    293261    // pmHDUFromCell() tests
    294     // pmHDUFromCell() verify with NULL input params
     262    // Call pmHDUFromCell() with NULL input params
    295263    {
    296264        psMemId id = psMemGetId();
    … …  
    300268    }
    301269
    302     //pmHDUFromCell() verify with acceptable input params
     270
     271    // Call pmHDUFromCell() with acceptable input params
    303272    {
    304273        psMemId id = psMemGetId();
    … …  
    313282        pmHDU *hdu = pmHDUFromCell(cell);
    314283        ok(hdu == cell->hdu, "pmHDUFromCell() returned the correct pmHDU of an pmCell struct");
    315         myFreeFPA(fpa);
    316         psFree(camera);
    317         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    318     }
    319 
    320     //pmHDUFromCell() verify with acceptable input params
     284        psFree(fpa);
     285        psFree(camera);
     286        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     287    }
     288
     289
     290    // Call pmHDUFromCell() with acceptable input params
    321291    // Set cell->hdu to NULL, verify cell->parent->hdu is returned
    322292    {
    … …  
    334304        pmHDU *hdu = pmHDUFromCell(cell);
    335305        ok(hdu == cell->parent->hdu, "pmHDUFromCell() returned the correct pmHDU of an pmCell struct");
    336         myFreeFPA(fpa);
    337         psFree(camera);
    338         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    339     }
    340 
    341 
    342     // ----------------------------------------------------------------------
    343     // pmHDU *pmHDUFromReadout(const pmCell *cell)
     306        psFree(fpa);
     307        psFree(camera);
     308        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     309    }
     310
     311
     312    // ----------------------------------------------------------------------
    344313    // pmHDUFromReadout() tests
    345     // pmHDUFromReadout() verify with NULL input params
     314    // Call pmHDUFromReadout() with NULL input params
    346315    {
    347316        psMemId id = psMemGetId();
    … …  
    351320    }
    352321
    353     //pmHDUFromReadout() verify with acceptable input params
     322
     323    // Call pmHDUFromReadout() with acceptable input params
    354324    {
    355325        psMemId id = psMemGetId();
    … …  
    366336        pmHDU *hdu = pmHDUFromReadout(readout);
    367337        ok(hdu == readout->parent->hdu, "pmHDUFromReadout() returned the correct pmHDU of an pmReadout struct");
    368         myFreeFPA(fpa);
    369         psFree(camera);
    370         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    371     }
    372 
    373 
    374     // ----------------------------------------------------------------------
    375     //pmHDUGetLowest() tests
    376     //pmHDU *pmHDUGetLowest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell)
    377     //pmHDUGetLowest(): verify with all NULL inputs
     338        psFree(fpa);
     339        psFree(camera);
     340        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     341    }
     342
     343
     344    // ----------------------------------------------------------------------
     345    // pmHDUGetLowest() tests
     346    // Call pmHDUGetLowest() with all NULL inputs
    378347    {
    379348        psMemId id = psMemGetId();
    … …  
    384353
    385354
    386     //pmHDUGetLowest() tests
    387     //pmHDU *pmHDUGetLowest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell)
    388     //pmHDUGetLowest(): verify with all acceptable inputs
     355    // Call pmHDUGetLowest() with all acceptable inputs
    389356    {
    390357        psMemId id = psMemGetId();
    … …  
    399366        pmHDU *hdu = pmHDUGetLowest(fpa, chip, cell);
    400367        ok(hdu == cell->hdu, "pmHDUGetLowest(fpa, chip, cell)");
    401         myFreeFPA(fpa);
    402         psFree(camera);
    403         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    404     }
    405 
    406 
    407     //pmHDUGetLowest() tests
    408     //pmHDU *pmHDUGetLowest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell)
    409     //pmHDUGetLowest(): verify with all (fpa, chip, NULL) inputs
     368        psFree(fpa);
     369        psFree(camera);
     370        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     371    }
     372
     373
     374    // Call pmHDUGetLowest() with all (fpa, chip, NULL) inputs
    410375    {
    411376        psMemId id = psMemGetId();
    … …  
    420385        pmHDU *hdu = pmHDUGetLowest(fpa, chip, NULL);
    421386        ok(hdu == chip->hdu, "pmHDUGetLowest(fpa, chip, NULL)");
    422         myFreeFPA(fpa);
    423         psFree(camera);
    424         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    425     }
    426 
    427 
    428     //pmHDUGetLowest() tests
    429     //pmHDU *pmHDUGetLowest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell)
    430     //pmHDUGetLowest(): verify with all (fpa, NULL, NULL) inputs
     387        psFree(fpa);
     388        psFree(camera);
     389        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     390    }
     391
     392
     393    // Call pmHDUGetLowest() with all (fpa, NULL, NULL) inputs
    431394    {
    432395        psMemId id = psMemGetId();
    … …  
    441404        pmHDU *hdu = pmHDUGetLowest(fpa, NULL, NULL);
    442405        ok(hdu == fpa->hdu, "pmHDUGetLowest(fpa, NULL, NULL)");
    443         myFreeFPA(fpa);
    444         psFree(camera);
    445         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    446     }
    447 
     406        psFree(fpa);
     407        psFree(camera);
     408        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     409    }
    448410
    449411
    450412    // ----------------------------------------------------------------------
    451413    //pmHDUGetHighest() tests
    452     //pmHDU *pmHDUGetHighest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell)
    453     //pmHDUGetHighest(): verify with all NULL inputs
     414    // Call pmHDUGetHighest() with all NULL inputs
    454415    {
    455416        psMemId id = psMemGetId();
    … …  
    460421
    461422
    462     //pmHDUGetHighest() tests
    463     //pmHDU *pmHDUGetHighest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell)
    464     //pmHDUGetHighest(): verify with all acceptable inputs
     423    // Call pmHDUGetHighest() with all acceptable inputs
    465424    {
    466425        psMemId id = psMemGetId();
    … …  
    475434        pmHDU *hdu = pmHDUGetHighest(fpa, chip, cell);
    476435        ok(hdu == fpa->hdu, "pmHDUGetHighest(fpa, chip, cell)");
    477         myFreeFPA(fpa);
    478         psFree(camera);
    479         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    480     }
    481 
    482 
    483     //pmHDUGetHighest() tests
    484     //pmHDU *pmHDUGetHighest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell)
    485     //pmHDUGetHighest(): verify with (NULL, chip, cell) inputs
     436        psFree(fpa);
     437        psFree(camera);
     438        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     439    }
     440
     441
     442    // Call pmHDUGetHighest() with (NULL, chip, cell) inputs
    486443    {
    487444        psMemId id = psMemGetId();
    … …  
    496453        pmHDU *hdu = pmHDUGetHighest(NULL, chip, cell);
    497454        ok(hdu == chip->hdu, "pmHDUGetHighest(NULL, chip, cell)");
    498         myFreeFPA(fpa);
    499         psFree(camera);
    500         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    501     }
    502 
    503 
    504     //pmHDUGetHighest() tests
    505     //pmHDU *pmHDUGetHighest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell)
    506     //pmHDUGetHighest(): verify with (NULL, NULL, cell) inputs
     455        psFree(fpa);
     456        psFree(camera);
     457        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     458    }
     459
     460
     461    // Call pmHDUGetHighest() with (NULL, NULL, cell) inputs
    507462    {
    508463        psMemId id = psMemGetId();
    … …  
    517472        pmHDU *hdu = pmHDUGetHighest(NULL, NULL, cell);
    518473        ok(hdu == cell->hdu, "pmHDUGetHighest(NULL, NULL, cell)");
    519         myFreeFPA(fpa);
    520         psFree(camera);
    521         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    522     }
    523 
    524 
    525 }
     474        psFree(fpa);
     475        psFree(camera);
     476        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     477    }
     478}
Note: See TracChangeset for help on using the changeset viewer.