Index: /trunk/psModules/test/camera/tap_pmFPACellSquish.c =================================================================== --- /trunk/psModules/test/camera/tap_pmFPACellSquish.c (revision 14882) +++ /trunk/psModules/test/camera/tap_pmFPACellSquish.c (revision 14882) @@ -0,0 +1,237 @@ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" + +// XXX: Use better name for the temporary FITS file +// XXX: The code to generate and free the FPA hierarchy was copied from +// tap-pmFPA.c. EIther include it directly, or library, or something. +// Also, get rid of the manual free functions and use psFree() once +// it correctly frees child members +// XXX: For the genSimpleFPA() code, add IDs to each function so that +// the values set in each chip-?cell-?hdu-?image are unique +// XXX: For the genSimpleFPA() code, write masks and weights as well + +#define CHIP_ALLOC_NAME "ChipName" +#define CELL_ALLOC_NAME "CellName" +#define MISC_NUM 32 +#define MISC_NAME "META00" +#define MISC_NAME2 "META01" +#define NUM_BIAS_DATA 10 +#define TEST_NUM_ROWS 4 +#define TEST_NUM_COLS 4 +#define NUM_READOUTS 3 +#define NUM_CELLS 10 +#define NUM_CHIPS 8 +#define NUM_HDUS 5 +#define BASE_IMAGE 10 +#define BASE_MASK 40 +#define BASE_WEIGHT 70 +#define VERBOSE 0 +#define ERR_TRACE_LEVEL 0 + +psPlaneTransform *PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM() +{ + psPlaneTransform *pt = psPlaneTransformAlloc(1, 1); + pt->x->coeff[1][0] = 1.0; + pt->y->coeff[0][1] = 1.0; + return(pt); +} + +psPlaneDistort *PS_CREATE_4D_IDENTITY_PLANE_DISTORT() +{ + psPlaneDistort *pd = psPlaneDistortAlloc(1, 1, 1, 1); + pd->x->coeff[1][0][0][0] = 1.0; + pd->y->coeff[0][1][0][0] = 1.0; + return(pd); +} + +/****************************************************************************** +generateSimpleReadout(): This function generates a pmReadout data structure and then +populates its members with real data. + *****************************************************************************/ +pmReadout *generateSimpleReadout(pmCell *cell) +{ + pmReadout *readout = pmReadoutAlloc(cell); + readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8); + readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) { + psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(tmpImage, (double) i); + psListAdd(readout->bias, PS_LIST_HEAD, tmpImage); + psFree(tmpImage); + } + psMetadataAddS32(readout->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + return(readout); +} + +/****************************************************************************** +generateSimpleCell(): This function generates a pmCell data structure and then +populates its members with real data. + *****************************************************************************/ +pmCell *generateSimpleCell(pmChip *chip) +{ + pmCell *cell = pmCellAlloc(chip, CELL_ALLOC_NAME); + + psMetadataAddS32(cell->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(cell->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psArrayRealloc(cell->readouts, NUM_READOUTS); + cell->hdu = pmHDUAlloc("cellExtName"); + for (int i = 0 ; i < NUM_READOUTS ; i++) { + cell->readouts->data[i] = generateSimpleReadout(cell); + } + + bool rc = pmConfigFileRead(&cell->hdu->format, "data/camera0/format0.config", "Camera format 0"); + if (!rc) { + diag("pmConfigFileRead() was unsuccessful (from generateSimpleCell())"); + } + + cell->hdu->images = psArrayAlloc(NUM_HDUS); + cell->hdu->masks = psArrayAlloc(NUM_HDUS); + cell->hdu->weights = psArrayAlloc(NUM_HDUS); + for (int k = 0 ; k < NUM_HDUS ; k++) { + cell->hdu->images->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + cell->hdu->masks->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK); + cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k)); + psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k)); + psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k)); + } + + //XXX: Should the region be set some other way? Like through the various config files? +// psRegion *region = psRegionAlloc(0.0, TEST_NUM_COLS-1, 0.0, TEST_NUM_ROWS-1); + psRegion *region = psRegionAlloc(0.0, 0.0, 0.0, 0.0); + // You shouldn't have to remove the key from the metadata. Find out how to simply change the key value. + psMetadataRemoveKey(cell->concepts, "CELL.TRIMSEC"); + psMetadataAddPtr(cell->concepts, PS_LIST_TAIL|PS_META_REPLACE, "CELL.TRIMSEC", PS_DATA_REGION, "I am a region", region); + psFree(region); + return(cell); +} + +/****************************************************************************** +generateSimpleChip(): This function generates a pmChip data structure and then +populates its members with real data. + *****************************************************************************/ +pmChip *generateSimpleChip(pmFPA *fpa) +{ + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + chip->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + chip->fromFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + psMetadataAddS32(chip->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(chip->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// chip->hdu = pmHDUAlloc("chipExtName"); +// +// bool rc = pmConfigFileRead(&chip->hdu->format, "data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleChip())"); +// } +// + psArrayRealloc(chip->cells, NUM_CELLS); + for (int i = 0 ; i < NUM_CELLS ; i++) { + chip->cells->data[i] = generateSimpleCell(chip); + } + + // XXX: Add code to initialize chip pmConcepts + + + return(chip); +} + +/****************************************************************************** +generateSimpleFPA(): This function generates a pmFPA data structure and then +populates its members with real data. + *****************************************************************************/ +pmFPA* generateSimpleFPA(psMetadata *camera) +{ + pmFPA* fpa = pmFPAAlloc(camera); + fpa->fromTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toSky = psProjectionAlloc(0.0,0.0,10.0,10.0,PS_PROJ_TAN); + psMetadataAddS32(fpa->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32((psMetadata *) fpa->camera, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(fpa->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// fpa->hdu = pmHDUAlloc("fpaExtName"); +// +// bool rc = pmConfigFileRead(&fpa->hdu->format, "data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleFPA())"); +// } + + psArrayRealloc(fpa->chips, NUM_CHIPS); + for (int i = 0 ; i < NUM_CHIPS ; i++) { + fpa->chips->data[i] = generateSimpleChip(fpa); + } + + // XXX: Eventually, when you finish the pmConcepts tests, add full concept + // reading code from wherever. + pmConceptsBlankFPA(fpa); +// bool mdok; +// psMetadata *fileData = psMetadataLookupMetadata(&mdok, fpa->hdu->format, "FILE"); +// char *fpaNameHdr = psMetadataLookupStr(&mdok, fileData, "FPA.NAME"); +// psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.NAME", PS_META_REPLACE, NULL, fpaNameHdr); + + return(fpa); +} + +// XXX: This should only be necessary until the psFree() functions for +// FPA/chip/cell/readout correctly free all child chips/cells/readouts +void myFreeCell(pmCell *cell) +{ + for (int k = 0 ; k < cell->readouts->n ; k++) { + psFree(cell->readouts->data[k]); + } + psFree(cell); +} + +void myFreeChip(pmChip *chip) { + for (int j = 0 ; j < chip->cells->n ; j++) { + myFreeCell(chip->cells->data[j]); + } + psFree(chip); +} + +void myFreeFPA(pmFPA *fpa) +{ + for (int i = 0 ; i < fpa->chips->n ; i++) { + myFreeChip(fpa->chips->data[i]); + } + psFree(fpa); +} + + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(25); + + + // ---------------------------------------------------------------------- + // pmCellSquish() tests + // bool pmCellSquish(pmCell *cell, psMaskType maskVal, bool useShifts) + { + psMemId id = psMemGetId(); + ok(!pmCellSquish(NULL, 0, false), "pmCellSquish(NULL) returned NULL"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // ---------------------------------------------------------------------- + // pmCellSquish() tests + // bool pmCellSquish(pmCell *cell, psMaskType maskVal, bool useShifts) + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(pmCellSquish(cell, 0, false), "pmCellSquish(NULL) returned NULL"); + myFreeFPA(fpa); + psFree(camera); + if (0) psFree(cell); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } +} Index: /trunk/psModules/test/camera/tap_pmFPAConstruct.c =================================================================== --- /trunk/psModules/test/camera/tap_pmFPAConstruct.c (revision 14882) +++ /trunk/psModules/test/camera/tap_pmFPAConstruct.c (revision 14882) @@ -0,0 +1,68 @@ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" + +#define VERBOSE 0 +#define ERR_TRACE_LEVEL 0 + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(72); + + // ---------------------------------------------------------------------- + // pmFPAConstruct() tests + // pmFPA *pmFPAConstruct(const psMetadata *camera) + // test will NULL camera input param + { + psMemId id = psMemGetId(); + pmFPA* fpa = pmFPAConstruct(NULL); + ok(fpa == NULL, "pmFPAConstruct() NULL will NULL camera input param"); + psFree(fpa); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // pmFPA *pmFPAConstruct(const psMetadata *camera) + // test will acceptable data + // XXX: The memory leak code is put outside the call to pmConfigFileRead() because of + // a memory leak in pmConfigFileRead(). + { + psMetadata *camera = psMetadataAlloc(); + bool rc = pmConfigFileRead(&camera, "data/camera0/camera.config", "CAMERA 0 config file"); + // Generate the pmFPA heirarchy + psMemId id = psMemGetId(); + ok(rc, "Succesfully read camera format file"); + pmFPA* fpa = pmFPAConstruct(camera); + ok(fpa != NULL, "pmFPAConstruct() returned non-NULL"); + if (VERBOSE) { + pmFPAPrint(stdout, fpa, true, true); + } + bool errorFlag = false; + ok(fpa->chips->n == 4, "pmFPAConstruct() set fpa->chips->n (%d)", fpa->chips->n); + for (int chipID = 0 ; chipID < fpa->chips->n ; chipID++) { + pmChip *chip = fpa->chips->data[chipID]; + ok(chip->cells->n == 2, "pmFPAConstruct() set chip->cells->n (%d)", chip->cells->n); + for (int cellID = 0 ; cellID < chip->cells->n ; cellID++) { + pmCell *cell = chip->cells->data[cellID]; + for (int readoutID = 0 ; readoutID < cell->readouts->n ; readoutID++) { + pmReadout *readout = cell->readouts->data[readoutID]; + readout = readout; + } + } + } + ok(!errorFlag, "pmFPAConstruct() read the pmFPA structure correctly"); + + + + + psFree(fpa); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + + psFree(camera); + } +} Index: /trunk/psModules/test/camera/tap_pmFPAExtent.c =================================================================== --- /trunk/psModules/test/camera/tap_pmFPAExtent.c (revision 14882) +++ /trunk/psModules/test/camera/tap_pmFPAExtent.c (revision 14882) @@ -0,0 +1,474 @@ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" +// XXX: Use better name for the temporary FITS file +// XXX: The code to generate and free the FPA hierarchy was copied from +// tap-pmFPA.c. EIther include it directly, or library, or something. +// Also, get rid of the manual free functions and use psFree() once +// it correctly frees child members +// XXX: For the genSimpleFPA() code, add IDs to each function so that +// the values set in each chip-?cell-?hdu-?image are unique +// XXX: For the genSimpleFPA() code, write masks and weights as well + +#define CHIP_ALLOC_NAME "ChipName" +#define CELL_ALLOC_NAME "CellName" +#define MISC_NUM 32 +#define MISC_NAME "META00" +#define MISC_NAME2 "META01" +#define NUM_BIAS_DATA 10 +#define TEST_NUM_ROWS 4 +#define TEST_NUM_COLS 4 +#define NUM_READOUTS 3 +#define NUM_CELLS 10 +#define NUM_CHIPS 8 +#define NUM_HDUS 5 +#define BASE_IMAGE 10 +#define BASE_MASK 40 +#define BASE_WEIGHT 70 +#define VERBOSE 0 +#define ERR_TRACE_LEVEL 0 + +psPlaneTransform *PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM() +{ + psPlaneTransform *pt = psPlaneTransformAlloc(1, 1); + pt->x->coeff[1][0] = 1.0; + pt->y->coeff[0][1] = 1.0; + return(pt); +} + +psPlaneDistort *PS_CREATE_4D_IDENTITY_PLANE_DISTORT() +{ + psPlaneDistort *pd = psPlaneDistortAlloc(1, 1, 1, 1); + pd->x->coeff[1][0][0][0] = 1.0; + pd->y->coeff[0][1][0][0] = 1.0; + return(pd); +} + +/****************************************************************************** +generateSimpleReadout(): This function generates a pmReadout data structure and then +populates its members with real data. + *****************************************************************************/ +pmReadout *generateSimpleReadout(pmCell *cell) +{ + pmReadout *readout = pmReadoutAlloc(cell); + readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8); + readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) { + psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(tmpImage, (double) i); + psListAdd(readout->bias, PS_LIST_HEAD, tmpImage); + psFree(tmpImage); + } + psMetadataAddS32(readout->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + return(readout); +} + +/****************************************************************************** +generateSimpleCell(): This function generates a pmCell data structure and then +populates its members with real data. + *****************************************************************************/ +pmCell *generateSimpleCell(pmChip *chip) +{ + pmCell *cell = pmCellAlloc(chip, CELL_ALLOC_NAME); + + psMetadataAddS32(cell->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(cell->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psArrayRealloc(cell->readouts, NUM_READOUTS); + cell->hdu = pmHDUAlloc("cellExtName"); + for (int i = 0 ; i < NUM_READOUTS ; i++) { + cell->readouts->data[i] = generateSimpleReadout(cell); + } + + bool rc = pmConfigFileRead(&cell->hdu->format, "data/camera0/format0.config", "Camera format 0"); + if (!rc) { + diag("pmConfigFileRead() was unsuccessful (from generateSimpleCell())"); + } + + cell->hdu->images = psArrayAlloc(NUM_HDUS); + cell->hdu->masks = psArrayAlloc(NUM_HDUS); + cell->hdu->weights = psArrayAlloc(NUM_HDUS); + for (int k = 0 ; k < NUM_HDUS ; k++) { + cell->hdu->images->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + cell->hdu->masks->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK); + cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k)); + psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k)); + psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k)); + } + + //XXX: Should the region be set some other way? Like through the various config files? +// psRegion *region = psRegionAlloc(0.0, TEST_NUM_COLS-1, 0.0, TEST_NUM_ROWS-1); + psRegion *region = psRegionAlloc(0.0, 0.0, 0.0, 0.0); + // You shouldn't have to remove the key from the metadata. Find out how to simply change the key value. + psMetadataRemoveKey(cell->concepts, "CELL.TRIMSEC"); + psMetadataAddPtr(cell->concepts, PS_LIST_TAIL|PS_META_REPLACE, "CELL.TRIMSEC", PS_DATA_REGION, "I am a region", region); + psFree(region); + return(cell); +} + +/****************************************************************************** +generateSimpleChip(): This function generates a pmChip data structure and then +populates its members with real data. + *****************************************************************************/ +pmChip *generateSimpleChip(pmFPA *fpa) +{ + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + chip->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + chip->fromFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + psMetadataAddS32(chip->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(chip->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// chip->hdu = pmHDUAlloc("chipExtName"); +// +// bool rc = pmConfigFileRead(&chip->hdu->format, "data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleChip())"); +// } +// + psArrayRealloc(chip->cells, NUM_CELLS); + for (int i = 0 ; i < NUM_CELLS ; i++) { + chip->cells->data[i] = generateSimpleCell(chip); + } + + // XXX: Add code to initialize chip pmConcepts + + + return(chip); +} + +/****************************************************************************** +generateSimpleFPA(): This function generates a pmFPA data structure and then +populates its members with real data. + *****************************************************************************/ +pmFPA* generateSimpleFPA(psMetadata *camera) +{ + pmFPA* fpa = pmFPAAlloc(camera); + fpa->fromTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toSky = psProjectionAlloc(0.0,0.0,10.0,10.0,PS_PROJ_TAN); + psMetadataAddS32(fpa->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32((psMetadata *) fpa->camera, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(fpa->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// fpa->hdu = pmHDUAlloc("fpaExtName"); +// +// bool rc = pmConfigFileRead(&fpa->hdu->format, "data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleFPA())"); +// } + + psArrayRealloc(fpa->chips, NUM_CHIPS); + for (int i = 0 ; i < NUM_CHIPS ; i++) { + fpa->chips->data[i] = generateSimpleChip(fpa); + } + + // XXX: Eventually, when you finish the pmConcepts tests, add full concept + // reading code from wherever. + pmConceptsBlankFPA(fpa); +// bool mdok; +// psMetadata *fileData = psMetadataLookupMetadata(&mdok, fpa->hdu->format, "FILE"); +// char *fpaNameHdr = psMetadataLookupStr(&mdok, fileData, "FPA.NAME"); +// psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.NAME", PS_META_REPLACE, NULL, fpaNameHdr); + + return(fpa); +} + +// XXX: This should only be necessary until the psFree() functions for +// FPA/chip/cell/readout correctly free all child chips/cells/readouts +void myFreeCell(pmCell *cell) +{ + for (int k = 0 ; k < cell->readouts->n ; k++) { + psFree(cell->readouts->data[k]); + } + psFree(cell); +} + +void myFreeChip(pmChip *chip) { + for (int j = 0 ; j < chip->cells->n ; j++) { + myFreeCell(chip->cells->data[j]); + } + psFree(chip); +} + +void myFreeFPA(pmFPA *fpa) +{ + for (int i = 0 ; i < fpa->chips->n ; i++) { + myFreeChip(fpa->chips->data[i]); + } + psFree(fpa); +} + + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(25); + + + // ---------------------------------------------------------------------- + // pmReadoutExtent() tests: NULL input + { + psMemId id = psMemGetId(); + ok(NULL == pmReadoutExtent(NULL), "pmReadoutExtent(NULL) returned NULL"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // pmReadoutExtent() tests: acceptable inputs + // XXX: We should probably test when the images are NULL, and use different size + // images in each readout. + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + ok(fpa != NULL, "Allocated a pmFPA successfully"); + bool errorFlag = false; + for (int chipID = 0 ; chipID < fpa->chips->n ; chipID++) { + pmChip *chip = fpa->chips->data[chipID]; + for (int cellID = 0 ; cellID < chip->cells->n ; cellID++) { + pmCell *cell = chip->cells->data[cellID]; + for (int readoutID = 0 ; readoutID < cell->readouts->n ; readoutID++) { + pmReadout *readout = cell->readouts->data[readoutID]; + psRegion *region = pmReadoutExtent(readout); + int xWindow = psMetadataLookupS32(NULL, readout->parent->concepts, "CELL.XWINDOW"); + int yWindow = psMetadataLookupS32(NULL, readout->parent->concepts, "CELL.YWINDOW"); + if (!region || + region->x0 != xWindow || + region->x1 != xWindow + readout->image->numCols || + region->y0 != yWindow || + region->y1 != yWindow + readout->image->numRows) { + diag("ERROR: pmReadoutExtent() did not set the psRegion correctly for chip/cell/readout (%d/%d/%d)\n", chipID, cellID, readoutID); + errorFlag = true; + } + psFree(region); + } + } + } + ok(!errorFlag, "pmReadoutExtent() passed all tests"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmCellExtent() tests: NULL input + // psRegion *pmCellExtent(const pmCell *cell) + { + psMemId id = psMemGetId(); + ok(NULL == pmCellExtent(NULL), "pmCellExtent(NULL) returned NULL"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmCellExtent() tests: acceptable inputs + // XX: We should probably set different region sizes to better test the min/max code + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + ok(fpa != NULL, "Allocated a pmFPA successfully"); + bool errorFlag = false; + for (int chipID = 0 ; chipID < fpa->chips->n ; chipID++) { + pmChip *chip = fpa->chips->data[chipID]; + for (int cellID = 0 ; cellID < chip->cells->n ; cellID++) { + pmCell *cell = chip->cells->data[cellID]; + // Determine the actual extent + psRegion *cellExtent = psRegionAlloc(INFINITY, 0, INFINITY, 0); // Extent of cell + for (int readoutID = 0 ; readoutID < cell->readouts->n ; readoutID++) { + pmReadout *readout = cell->readouts->data[readoutID]; + psRegion *roExtent = pmReadoutExtent(readout); // Extent of readout + cellExtent->x0 = PS_MIN(cellExtent->x0, roExtent->x0); + cellExtent->x1 = PS_MAX(cellExtent->x1, roExtent->x1); + cellExtent->y0 = PS_MIN(cellExtent->y0, roExtent->y0); + cellExtent->y1 = PS_MAX(cellExtent->y1, roExtent->y1); + psFree(roExtent); + } + bool mdok; + int x0 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.X0"); // Cell x offset + int y0 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.Y0"); // Cell y offset + cellExtent->x0 += x0; + cellExtent->x1 += x0; + cellExtent->y0 += y0; + cellExtent->y1 += y0; + + psRegion *tstExtent = pmCellExtent(cell); + if (!cell || + tstExtent->x0 != cellExtent->x0 || + tstExtent->x1 != cellExtent->x1 || + tstExtent->y0 != cellExtent->y0 || + tstExtent->y1 != cellExtent->y1) { + diag("ERROR: psRegion set incorrectly for chip/cell (%d/%d)", chipID, cellID); + errorFlag = true; + } + psFree(tstExtent); + psFree(cellExtent); + } + } + ok(!errorFlag, "pmCellExtent() passed all tests"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + // ---------------------------------------------------------------------- + // pmChipExtent() tests: NULL input + // psRegion *pmChipExtent(const pmChip *chip) + { + psMemId id = psMemGetId(); + ok(NULL == pmChipExtent(NULL), "pmChipExtent(NULL) returned NULL"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmChipExtent() tests: acceptable inputs + // XX: We should probably set different region sizes to better test the min/max code + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + ok(fpa != NULL, "Allocated a pmFPA successfully"); + bool errorFlag = false; + for (int chipID = 0 ; chipID < fpa->chips->n ; chipID++) { + pmChip *chip = fpa->chips->data[chipID]; + psRegion *chipExtent = pmChipPixels(chip); + bool rc; + int x0 = psMetadataLookupS32(&rc, chip->concepts, "CHIP.X0"); // Chip x offset + int y0 = psMetadataLookupS32(&rc, chip->concepts, "CHIP.Y0"); // Chip y offset + chipExtent->x0 += x0; + chipExtent->x1 += x0; + chipExtent->y0 += y0; + chipExtent->y1 += y0; + psRegion *tstExtent = pmChipExtent(chip); + if (!chip || + tstExtent->x0 != chipExtent->x0 || + tstExtent->x1 != chipExtent->x1 || + tstExtent->y0 != chipExtent->y0 || + tstExtent->y1 != chipExtent->y1) { + diag("ERROR: psRegion set incorrectly for chip (%d)", chipID); + errorFlag = true; + } + psFree(tstExtent); + psFree(chipExtent); + } + ok(!errorFlag, "pmChipExtent() passed all tests"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmChipPixels() tests: NULL input + // psRegion *pmChipPixels(const pmChip *chip) + { + psMemId id = psMemGetId(); + ok(NULL == pmChipPixels(NULL), "pmChipPixels(NULL) returned NULL"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmChipPixels() tests: acceptable inputs + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + ok(fpa != NULL, "Allocated a pmFPA successfully"); + + bool errorFlag = false; + for (int chipID = 0 ; chipID < fpa->chips->n ; chipID++) { + pmChip *chip = fpa->chips->data[chipID]; + // Determine the actual pixels + psRegion *actualExtent = psRegionAlloc(INFINITY, 0, INFINITY, 0); + for (int cellID = 0 ; cellID < chip->cells->n ; cellID++) { + pmCell *cell = chip->cells->data[cellID]; + psRegion *cellExtent = pmCellExtent(cell); + actualExtent->x0 = PS_MIN(actualExtent->x0, cellExtent->x0); + actualExtent->x1 = PS_MAX(actualExtent->x1, cellExtent->x1); + actualExtent->y0 = PS_MIN(actualExtent->y0, cellExtent->y0); + actualExtent->y1 = PS_MAX(actualExtent->y1, cellExtent->y1); + psFree(cellExtent); + } + + // Now test if pmChipPixels() determines the same pixels + psRegion *tstExtent = pmChipPixels(chip); + if (!tstExtent || + tstExtent->x0 != actualExtent->x0 || + tstExtent->x1 != actualExtent->x1 || + tstExtent->y0 != actualExtent->y0 || + tstExtent->y1 != actualExtent->y1) { + diag("ERROR: pixels set incorrectly for chip %d", chipID); + errorFlag = true; + } + + // Free temp memory + psFree(tstExtent); + psFree(actualExtent); + } + ok(!errorFlag, "pmChipPixels() passed all tests"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmFPAPixels() tests: NULL input + // psRegion *pmFPAPixels(const pmFPA *fpa) + { + psMemId id = psMemGetId(); + ok(NULL == pmFPAPixels(NULL), "pmFPAPixels(NULL) returned NULL"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAPixels() tests: acceptable inputs + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + ok(fpa != NULL, "Allocated a pmFPA successfully"); + + psRegion *actualExtent = psRegionAlloc(INFINITY, 0, INFINITY, 0); // Extent of fpa + for (int chipID = 0 ; chipID < fpa->chips->n ; chipID++) { + pmChip *chip = fpa->chips->data[chipID]; + psRegion *chipExtent = pmChipExtent(chip); // Extent of chip + actualExtent->x0 = PS_MIN(actualExtent->x0, chipExtent->x0); + actualExtent->x1 = PS_MAX(actualExtent->x1, chipExtent->x1); + actualExtent->y0 = PS_MIN(actualExtent->y0, chipExtent->y0); + actualExtent->y1 = PS_MAX(actualExtent->y1, chipExtent->y1); + psFree(chipExtent); + } + + bool errorFlag = false; + psRegion *tstExtent = pmFPAPixels(fpa); + if (!tstExtent || + tstExtent->x0 != actualExtent->x0 || + tstExtent->x1 != actualExtent->x1 || + tstExtent->y0 != actualExtent->y0 || + tstExtent->y1 != actualExtent->y1) { + diag("ERROR: pmFPAPixels() set the pixels incorrectly"); + errorFlag = true; + } + ok(!errorFlag, "pmFPAPixels() set the pixels psRegion correctly"); + + psFree(tstExtent); + psFree(actualExtent); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + +} Index: /trunk/psModules/test/camera/tap_pmFPAFlags.c =================================================================== --- /trunk/psModules/test/camera/tap_pmFPAFlags.c (revision 14882) +++ /trunk/psModules/test/camera/tap_pmFPAFlags.c (revision 14882) @@ -0,0 +1,813 @@ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" +// XXX: Use better name for the temporary FITS file +// XXX: The code to generate and free the FPA hierarchy was copied from +// tap-pmFPA.c. EIther include it directly, or library, or something. +// Also, get rid of the manual free functions and use psFree() once +// it correctly frees child members +// XXX: For the genSimpleFPA() code, add IDs to each function so that +// the values set in each chip-?cell-?hdu-?image are unique +// XXX: For the genSimpleFPA() code, write masks and weights as well +// XXX: Add in the associated CheckStatus tests + +#define CHIP_ALLOC_NAME "ChipName" +#define CELL_ALLOC_NAME "CellName" +#define MISC_NUM 32 +#define MISC_NAME "META00" +#define MISC_NAME2 "META01" +#define NUM_BIAS_DATA 10 +#define TEST_NUM_ROWS 4 +#define TEST_NUM_COLS 4 +#define NUM_READOUTS 3 +#define NUM_CELLS 10 +#define NUM_CHIPS 8 +#define NUM_HDUS 5 +#define BASE_IMAGE 10 +#define BASE_MASK 40 +#define BASE_WEIGHT 70 +#define VERBOSE 0 +#define ERR_TRACE_LEVEL 0 + +psPlaneTransform *PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM() +{ + psPlaneTransform *pt = psPlaneTransformAlloc(1, 1); + pt->x->coeff[1][0] = 1.0; + pt->y->coeff[0][1] = 1.0; + return(pt); +} + +psPlaneDistort *PS_CREATE_4D_IDENTITY_PLANE_DISTORT() +{ + psPlaneDistort *pd = psPlaneDistortAlloc(1, 1, 1, 1); + pd->x->coeff[1][0][0][0] = 1.0; + pd->y->coeff[0][1][0][0] = 1.0; + return(pd); +} + +/****************************************************************************** +generateSimpleReadout(): This function generates a pmReadout data structure and then +populates its members with real data. + *****************************************************************************/ +pmReadout *generateSimpleReadout(pmCell *cell) +{ + pmReadout *readout = pmReadoutAlloc(cell); + readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8); + readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) { + psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(tmpImage, (double) i); + psListAdd(readout->bias, PS_LIST_HEAD, tmpImage); + psFree(tmpImage); + } + psMetadataAddS32(readout->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + return(readout); +} + +/****************************************************************************** +generateSimpleCell(): This function generates a pmCell data structure and then +populates its members with real data. + *****************************************************************************/ +pmCell *generateSimpleCell(pmChip *chip) +{ + pmCell *cell = pmCellAlloc(chip, CELL_ALLOC_NAME); + + psMetadataAddS32(cell->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(cell->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psArrayRealloc(cell->readouts, NUM_READOUTS); + cell->hdu = pmHDUAlloc("cellExtName"); + for (int i = 0 ; i < NUM_READOUTS ; i++) { + cell->readouts->data[i] = generateSimpleReadout(cell); + } + + bool rc = pmConfigFileRead(&cell->hdu->format, "data/camera0/format0.config", "Camera format 0"); + if (!rc) { + diag("pmConfigFileRead() was unsuccessful (from generateSimpleCell())"); + } + + cell->hdu->images = psArrayAlloc(NUM_HDUS); + cell->hdu->masks = psArrayAlloc(NUM_HDUS); + cell->hdu->weights = psArrayAlloc(NUM_HDUS); + for (int k = 0 ; k < NUM_HDUS ; k++) { + cell->hdu->images->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + cell->hdu->masks->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK); + cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k)); + psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k)); + psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k)); + } + + //XXX: Should the region be set some other way? Like through the various config files? +// psRegion *region = psRegionAlloc(0.0, TEST_NUM_COLS-1, 0.0, TEST_NUM_ROWS-1); + psRegion *region = psRegionAlloc(0.0, 0.0, 0.0, 0.0); + // You shouldn't have to remove the key from the metadata. Find out how to simply change the key value. + psMetadataRemoveKey(cell->concepts, "CELL.TRIMSEC"); + psMetadataAddPtr(cell->concepts, PS_LIST_TAIL|PS_META_REPLACE, "CELL.TRIMSEC", PS_DATA_REGION, "I am a region", region); + psFree(region); + return(cell); +} + +/****************************************************************************** +generateSimpleChip(): This function generates a pmChip data structure and then +populates its members with real data. + *****************************************************************************/ +pmChip *generateSimpleChip(pmFPA *fpa) +{ + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + chip->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + chip->fromFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + psMetadataAddS32(chip->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(chip->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// chip->hdu = pmHDUAlloc("chipExtName"); +// +// bool rc = pmConfigFileRead(&chip->hdu->format, "data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleChip())"); +// } +// + psArrayRealloc(chip->cells, NUM_CELLS); + for (int i = 0 ; i < NUM_CELLS ; i++) { + chip->cells->data[i] = generateSimpleCell(chip); + } + + // XXX: Add code to initialize chip pmConcepts + + + return(chip); +} + +/****************************************************************************** +generateSimpleFPA(): This function generates a pmFPA data structure and then +populates its members with real data. + *****************************************************************************/ +pmFPA* generateSimpleFPA(psMetadata *camera) +{ + pmFPA* fpa = pmFPAAlloc(camera); + fpa->fromTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toSky = psProjectionAlloc(0.0,0.0,10.0,10.0,PS_PROJ_TAN); + psMetadataAddS32(fpa->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32((psMetadata *) fpa->camera, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(fpa->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// fpa->hdu = pmHDUAlloc("fpaExtName"); +// +// bool rc = pmConfigFileRead(&fpa->hdu->format, "data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleFPA())"); +// } + + psArrayRealloc(fpa->chips, NUM_CHIPS); + for (int i = 0 ; i < NUM_CHIPS ; i++) { + fpa->chips->data[i] = generateSimpleChip(fpa); + } + + // XXX: Eventually, when you finish the pmConcepts tests, add full concept + // reading code from wherever. + pmConceptsBlankFPA(fpa); +// bool mdok; +// psMetadata *fileData = psMetadataLookupMetadata(&mdok, fpa->hdu->format, "FILE"); +// char *fpaNameHdr = psMetadataLookupStr(&mdok, fileData, "FPA.NAME"); +// psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.NAME", PS_META_REPLACE, NULL, fpaNameHdr); + + return(fpa); +} + +// XXX: This should only be necessary until the psFree() functions for +// FPA/chip/cell/readout correctly free all child chips/cells/readouts +void myFreeCell(pmCell *cell) +{ + for (int k = 0 ; k < cell->readouts->n ; k++) { + psFree(cell->readouts->data[k]); + } + psFree(cell); +} + +void myFreeChip(pmChip *chip) { + for (int j = 0 ; j < chip->cells->n ; j++) { + myFreeCell(chip->cells->data[j]); + } + psFree(chip); +} + +void myFreeFPA(pmFPA *fpa) +{ + for (int i = 0 ; i < fpa->chips->n ; i++) { + myFreeChip(fpa->chips->data[i]); + } + psFree(fpa); +} + + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(72); + + // ---------------------------------------------------------------------- + // ---------------------------------------------------------------------- + // pmCellSetFileStatus() tests: verify with NULL pmCell param + // bool pmCellSetFileStatus(pmCell *cell, bool status) + { + psMemId id = psMemGetId(); + bool rc = pmCellSetFileStatus(NULL, false); + ok(!rc, "pmCellSetFileStatus() returned FALSE with NULL pmCell param"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmCellSetFileStatus() tests: verify with acceptable data + // bool pmCellSetFileStatus(pmCell *cell, bool status) + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + + // First, set all flags to FALSE + bool correctStatus = false; + bool rc = pmCellSetFileStatus(cell, correctStatus); + ok(rc, "pmCellSetFileStatus() returned successfully with acceptable input params"); + bool errorFlag = false; + if (cell->file_exists != correctStatus) { + diag("TEST ERROR: pmCellSetFileStatus() failed to set file status for cell param\n"); + errorFlag = true; + } + for (int i = 0; i < cell->readouts->n; i++) { + + pmReadout *readout = cell->readouts->data[i]; + if (readout->file_exists != correctStatus) { + diag("TEST ERROR: pmCellSetFileStatus() failed to set file status for cell %d\n", i); + errorFlag = true; + } + } + ok(!errorFlag, "pmCellSetFileStatus() set file status in all cells to FALSE"); + + // Second, set all flags to TRUE + correctStatus = true; + rc = pmCellSetFileStatus(cell, correctStatus); + ok(rc, "pmCellSetFileStatus() returned successfully with acceptable input params"); + errorFlag = false; + if (cell->file_exists != correctStatus) { + diag("TEST ERROR: pmCellSetFileStatus() failed to set file status for cell param\n"); + errorFlag = true; + } + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->file_exists != correctStatus) { + diag("TEST ERROR: pmCellSetFileStatus() failed to set file status for cell %d\n", i); + errorFlag = true; + } + } + ok(!errorFlag, "pmCellSetFileStatus() set file status in all cells to TRUE"); + + // Third, set all flags to FALSE + correctStatus = false; + rc = pmCellSetFileStatus(cell, correctStatus); + ok(rc, "pmCellSetFileStatus() returned successfully with acceptable input params"); + errorFlag = false; + if (cell->file_exists != correctStatus) { + diag("TEST ERROR: pmCellSetFileStatus() failed to set file status for cell param\n"); + errorFlag = true; + } + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->file_exists != correctStatus) { + diag("TEST ERROR: pmCellSetFileStatus() failed to set file status for readout %d\n", i); + errorFlag = true; + } + } + ok(!errorFlag, "pmCellSetFileStatus() set file status in all cells to FALSE"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // ---------------------------------------------------------------------- + // pmChipSetFileStatus() tests: verify with NULL pmChip param + // bool pmChipSetFileStatus(pmChip *chip, bool status) + { + psMemId id = psMemGetId(); + bool rc = pmChipSetFileStatus(NULL, false); + ok(!rc, "pmChipSetFileStatus() returned FALSE with NULL pmChip param"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmChipSetFileStatus() tests: verify with acceptable data + // bool pmChipSetFileStatus(pmChip *chip, bool status) + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + + // First, set all flags to FALSE + bool correctStatus = false; + bool rc = pmChipSetFileStatus(chip, correctStatus); + ok(rc, "pmChipSetFileStatus() returned successfully with acceptable input params"); + bool errorFlag = false; + if (chip->file_exists != correctStatus) { + diag("TEST ERROR: pmChipSetFileStatus() failed to set file status for chip param"); + errorFlag = true; + } + for (int j = 0 ; j < chip->cells->n ; j++) { + pmCell *cell = chip->cells->data[j]; + if (cell->file_exists != correctStatus) { + diag("TEST ERROR: pmChipSetFileStatus() failed to set file status for cell %d\n", j); + errorFlag = true; + } + + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->file_exists != correctStatus) { + diag("TEST ERROR: pmChipSetFileStatus() failed to set file status for cell %d readout %d\n", j, i); + errorFlag = true; + } + } + } + ok(!errorFlag, "pmChipSetFileStatus() set file status in all cells to FALSE"); + + // Second, set all flags to TRUE + correctStatus = true; + rc = pmChipSetFileStatus(chip, correctStatus); + ok(rc, "pmChipSetFileStatus() returned successfully with acceptable input params"); + errorFlag = false; + if (chip->file_exists != correctStatus) { + diag("TEST ERROR: pmChipSetFileStatus() failed to set file status for chip param"); + errorFlag = true; + } + for (int j = 0 ; j < chip->cells->n ; j++) { + pmCell *cell = chip->cells->data[j]; + if (cell->file_exists != correctStatus) { + diag("TEST ERROR: pmChipSetFileStatus() failed to set file status for cell %d\n", j); + errorFlag = true; + } + + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->file_exists != correctStatus) { + diag("TEST ERROR: pmChipSetFileStatus() failed to set file status for cell %d readout %d\n", j, i); + errorFlag = true; + } + } + } + ok(!errorFlag, "pmChipSetFileStatus() set file status in all cells to TRUE"); + + // Third, set all flags to FALSE + correctStatus = false; + rc = pmChipSetFileStatus(chip, correctStatus); + ok(rc, "pmChipSetFileStatus() returned successfully with acceptable input params"); + errorFlag = false; + if (chip->file_exists != correctStatus) { + diag("TEST ERROR: pmChipSetFileStatus() failed to set file status for chip param"); + errorFlag = true; + } + for (int j = 0 ; j < chip->cells->n ; j++) { + pmCell *cell = chip->cells->data[j]; + if (cell->file_exists != correctStatus) { + diag("TEST ERROR: pmChipSetFileStatus() failed to set file status for cell %d\n", j); + errorFlag = true; + } + + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->file_exists != correctStatus) { + diag("TEST ERROR: pmChipSetFileStatus() failed to set file status for cell %d readout %d\n", j, i); + errorFlag = true; + } + } + } + ok(!errorFlag, "pmChipSetFileStatus() set file status in all cells to FALSE"); + + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // ---------------------------------------------------------------------- + // ---------------------------------------------------------------------- + // pmFPASetFileStatus() tests: verify with NULL pmFPA param + // bool pmFPASetFileStatus(pmFPA *fpa, bool status) + { + psMemId id = psMemGetId(); + bool rc = pmFPASetFileStatus(NULL, false); + ok(!rc, "pmFPASetFileStatus() returned FALSE with NULL pmFPA param"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPASetFileStatus() tests: verify with acceptable data + // bool pmFPASetFileStatus(pmFPA *fpa, bool status) + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + + // First, set all flags to FALSE + bool correctStatus = false; + bool rc = pmFPASetFileStatus(fpa, correctStatus); + ok(rc, "pmFPASetFileStatus() returned successfully with acceptable input params"); + bool errorFlag = false; + for (int k = 0 ; k < fpa->chips->n ; k++) { + pmChip *chip = fpa->chips->data[k]; + for (int j = 0 ; j < chip->cells->n ; j++) { + pmCell *cell = chip->cells->data[j]; + if (cell->file_exists != correctStatus) { + diag("TEST ERROR: pmFPASetFileStatus() failed to set file status for chip %d cell %d\n", k, j); + errorFlag = true; + } + + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->file_exists != correctStatus) { + diag("TEST ERROR: pmFPASetFileStatus() failed to set file status for chip %d cell %d readout %d\n", k, j, i); + errorFlag = true; + } + } + } + } + ok(!errorFlag, "pmFPASetFileStatus() set file status in all cells to FALSE"); + + // Second, set all flags to TRUE + correctStatus = true; + rc = pmFPASetFileStatus(fpa, correctStatus); + ok(rc, "pmFPASetFileStatus() returned successfully with acceptable input params"); + errorFlag = false; + for (int k = 0 ; k < fpa->chips->n ; k++) { + pmChip *chip = fpa->chips->data[k]; + for (int j = 0 ; j < chip->cells->n ; j++) { + pmCell *cell = chip->cells->data[j]; + if (cell->file_exists != correctStatus) { + diag("TEST ERROR: pmFPASetFileStatus() failed to set file status for chip %d cell %d\n", k, j); + errorFlag = true; + } + + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->file_exists != correctStatus) { + diag("TEST ERROR: pmFPASetFileStatus() failed to set file status for chip %d cell %d readout %d\n", k, j, i); + errorFlag = true; + } + } + } + } + ok(!errorFlag, "pmFPASetFileStatus() set file status in all cells to TRUE"); + + // Third, set all flags to FALSE + correctStatus = false; + rc = pmFPASetFileStatus(fpa, correctStatus); + ok(rc, "pmFPASetFileStatus() returned successfully with acceptable input params"); + errorFlag = false; + for (int k = 0 ; k < fpa->chips->n ; k++) { + pmChip *chip = fpa->chips->data[k]; + for (int j = 0 ; j < chip->cells->n ; j++) { + pmCell *cell = chip->cells->data[j]; + if (cell->file_exists != correctStatus) { + diag("TEST ERROR: pmFPASetFileStatus() failed to set file status for chip %d cell %d\n", k, j); + errorFlag = true; + } + + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->file_exists != correctStatus) { + diag("TEST ERROR: pmFPASetFileStatus() failed to set file status for chip %d cell %d readout %d\n", k, j, i); + errorFlag = true; + } + } + } + } + ok(!errorFlag, "pmFPASetFileStatus() set file status in all cells to FALSE"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // ---------------------------------------------------------------------- + // ---------------------------------------------------------------------- + // pmCellSetDataStatus() tests: verify with NULL pmCell param + // bool pmCellSetDataStatus(pmCell *cell, bool status) + { + psMemId id = psMemGetId(); + bool rc = pmCellSetDataStatus(NULL, false); + ok(!rc, "pmCellSetDataStatus() returned FALSE with NULL pmCell param"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmCellSetDataStatus() tests: verify with acceptable data + // bool pmCellSetDataStatus(pmCell *cell, bool status) + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + + // First, set all flags to FALSE + bool correctStatus = false; + bool rc = pmCellSetDataStatus(cell, correctStatus); + ok(rc, "pmCellSetDataStatus() returned successfully with acceptable input params"); + bool errorFlag = false; + if (cell->data_exists != correctStatus) { + diag("TEST ERROR: pmCellSetDataStatus() failed to set file status for cell param\n"); + errorFlag = true; + } + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->data_exists != correctStatus) { + diag("TEST ERROR: pmCellSetDataStatus() failed to set file status for cell %d\n", i); + errorFlag = true; + } + } + ok(!errorFlag, "pmCellSetDataStatus() set data status in all cells to FALSE"); + + // Second, set all flags to TRUE + correctStatus = true; + rc = pmCellSetDataStatus(cell, correctStatus); + ok(rc, "pmCellSetDataStatus() returned successfully with acceptable input params"); + errorFlag = false; + if (cell->data_exists != correctStatus) { + diag("TEST ERROR: pmCellSetDataStatus() failed to set file status for cell param\n"); + errorFlag = true; + } + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->data_exists != correctStatus) { + diag("TEST ERROR: pmCellSetDataStatus() failed to set file status for cell %d\n", i); + errorFlag = true; + } + } + ok(!errorFlag, "pmCellSetDataStatus() set data status in all cells to TRUE"); + + // Third, set all flags to FALSE + correctStatus = false; + rc = pmCellSetDataStatus(cell, correctStatus); + ok(rc, "pmCellSetDataStatus() returned successfully with acceptable input params"); + errorFlag = false; + if (cell->data_exists != correctStatus) { + diag("TEST ERROR: pmCellSetDataStatus() failed to set file status for cell param\n"); + errorFlag = true; + } + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->data_exists != correctStatus) { + diag("TEST ERROR: pmCellSetDataStatus() failed to set file status for readout %d\n", i); + errorFlag = true; + } + } + ok(!errorFlag, "pmCellSetDataStatus() set data status in all cells to FALSE"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // ---------------------------------------------------------------------- + // pmChipSetDataStatus() tests: verify with NULL pmChip param + // bool pmChipSetDataStatus(pmChip *chip, bool status) + { + psMemId id = psMemGetId(); + bool rc = pmChipSetDataStatus(NULL, false); + ok(!rc, "pmChipSetDataStatus() returned FALSE with NULL pmChip param"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmChipSetDataStatus() tests: verify with acceptable data + // bool pmChipSetDataStatus(pmChip *chip, bool status) + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + + // First, set all flags to FALSE + bool correctStatus = false; + bool rc = pmChipSetDataStatus(chip, correctStatus); + ok(rc, "pmChipSetDataStatus() returned successfully with acceptable input params"); + bool errorFlag = false; + if (chip->data_exists != correctStatus) { + diag("TEST ERROR (a): pmChipSetDataStatus() failed to set file status for chip param\n"); + errorFlag = true; + } + for (int j = 0 ; j < chip->cells->n ; j++) { + pmCell *cell = chip->cells->data[j]; + if (cell->data_exists != correctStatus) { + diag("TEST ERROR (b): pmChipSetDataStatus() failed to set file status for cell %d\n", j); + errorFlag = true; + } + + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->data_exists != correctStatus) { + diag("TEST ERROR (c): pmChipSetDataStatus() failed to set file status for cell %d readout %d\n", j, i); + errorFlag = true; + } + } + } + ok(!errorFlag, "pmChipSetDataStatus() set data status in all cells to FALSE"); + + // Second, set all flags to TRUE + correctStatus = true; + rc = pmChipSetDataStatus(chip, correctStatus); + ok(rc, "pmChipSetDataStatus() returned successfully with acceptable input params"); + errorFlag = false; + if (chip->data_exists != correctStatus) { + diag("TEST ERROR (a): pmChipSetDataStatus() failed to set file status for chip param\n"); + errorFlag = true; + } + for (int j = 0 ; j < chip->cells->n ; j++) { + pmCell *cell = chip->cells->data[j]; + if (cell->data_exists != correctStatus) { + diag("TEST ERROR (b): pmChipSetDataStatus() failed to set file status for cell %d\n", j); + errorFlag = true; + } + + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->data_exists != correctStatus) { + diag("TEST ERROR (c): pmChipSetDataStatus() failed to set file status for cell %d readout %d\n", j, i); + errorFlag = true; + } + } + } + ok(!errorFlag, "pmChipSetDataStatus() set data status in all cells to TRUE"); + + // ThirdSecond, set all flags to FALSE + correctStatus = false; + rc = pmChipSetDataStatus(chip, correctStatus); + ok(rc, "pmChipSetDataStatus() returned successfully with acceptable input params"); + errorFlag = false; + if (chip->data_exists != correctStatus) { + diag("TEST ERROR (a): pmChipSetDataStatus() failed to set file status for chip param\n"); + errorFlag = true; + } + for (int j = 0 ; j < chip->cells->n ; j++) { + pmCell *cell = chip->cells->data[j]; + if (cell->data_exists != correctStatus) { + diag("TEST ERROR (b): pmChipSetDataStatus() failed to set file status for cell %d\n", j); + errorFlag = true; + } + + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->data_exists != correctStatus) { + diag("TEST ERROR (c): pmChipSetDataStatus() failed to set file status for cell %d readout %d\n", j, i); + errorFlag = true; + } + } + } + ok(!errorFlag, "pmChipSetDataStatus() set data status in all cells to FALSE"); + + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // ---------------------------------------------------------------------- + // ---------------------------------------------------------------------- + // pmFPASetFileStatus() tests: verify with NULL pmFPA param + // bool pmFPASetFileStatus(pmFPA *fpa, bool status) + { + psMemId id = psMemGetId(); + bool rc = pmFPASetFileStatus(NULL, false); + ok(!rc, "pmFPASetFileStatus() returned FALSE with NULL pmFPA param"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + + // pmFPASetDataStatus() tests: verify with acceptable data + // bool pmFPASetDataStatus(pmFPA *fpa, bool status) + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + + // First, set all flags to FALSE + bool correctStatus = false; + bool rc = pmFPASetDataStatus(fpa, correctStatus); + ok(rc, "pmFPASetDataStatus() returned successfully with acceptable input params"); + bool errorFlag = false; + for (int k = 0 ; k < fpa->chips->n ; k++) { + pmChip *chip = fpa->chips->data[k]; + for (int j = 0 ; j < chip->cells->n ; j++) { + pmCell *cell = chip->cells->data[j]; + if (cell->data_exists != correctStatus) { + diag("TEST ERROR: pmFPASetDataStatus() failed to set file status for chip %d cell %d\n", k, j); + errorFlag = true; + } + + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->data_exists != correctStatus) { + diag("TEST ERROR: pmFPASetDataStatus() failed to set file status for chip %d cell %d readout %d\n", k, j, i); + errorFlag = true; + } + } + } + } + ok(!errorFlag, "pmFPASetDataStatus() set file status in all cells to FALSE"); + + // Second, set all flags to TRUE + correctStatus = true; + rc = pmFPASetDataStatus(fpa, correctStatus); + ok(rc, "pmFPASetDataStatus() returned successfully with acceptable input params"); + errorFlag = false; + for (int k = 0 ; k < fpa->chips->n ; k++) { + pmChip *chip = fpa->chips->data[k]; + for (int j = 0 ; j < chip->cells->n ; j++) { + pmCell *cell = chip->cells->data[j]; + if (cell->data_exists != correctStatus) { + diag("TEST ERROR: pmFPASetDataStatus() failed to set file status for chip %d cell %d\n", k, j); + errorFlag = true; + } + + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->data_exists != correctStatus) { + diag("TEST ERROR: pmFPASetDataStatus() failed to set file status for chip %d cell %d readout %d\n", k, j, i); + errorFlag = true; + } + } + } + } + ok(!errorFlag, "pmFPASetDataStatus() set file status in all cells to TRUE"); + + // Third, set all flags to FALSE + correctStatus = false; + rc = pmFPASetDataStatus(fpa, correctStatus); + ok(rc, "pmFPASetDataStatus() returned successfully with acceptable input params"); + errorFlag = false; + for (int k = 0 ; k < fpa->chips->n ; k++) { + pmChip *chip = fpa->chips->data[k]; + for (int j = 0 ; j < chip->cells->n ; j++) { + pmCell *cell = chip->cells->data[j]; + if (cell->data_exists != correctStatus) { + diag("TEST ERROR: pmFPASetDataStatus() failed to set file status for chip %d cell %d\n", k, j); + errorFlag = true; + } + + for (int i = 0; i < cell->readouts->n; i++) { + pmReadout *readout = cell->readouts->data[i]; + if (readout->data_exists != correctStatus) { + diag("TEST ERROR: pmFPASetDataStatus() failed to set file status for chip %d cell %d readout %d\n", k, j, i); + errorFlag = true; + } + } + } + } + ok(!errorFlag, "pmFPASetDataStatus() set file status in all cells to FALSE"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + +} Index: /trunk/psModules/test/camera/tap_pmFPAHeader.c =================================================================== --- /trunk/psModules/test/camera/tap_pmFPAHeader.c (revision 14882) +++ /trunk/psModules/test/camera/tap_pmFPAHeader.c (revision 14882) @@ -0,0 +1,488 @@ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" +// XXX: Use better name for the temporary FITS file +// XXX: The code to generate and free the FPA hierarchy was copied from +// tap-pmFPA.c. EIther include it directly, or library, or something. +// Also, get rid of the manual free functions and use psFree() once +// it correctly frees child members +// XXX: For the genSimpleFPA() code, add IDs to each function so that +// the values set in each chip-?cell-?hdu-?image are unique +// XXX: For the genSimpleFPA() code, write masks and weights as well + +#define CHIP_ALLOC_NAME "ChipName" +#define CELL_ALLOC_NAME "CellName" +#define MISC_NUM 32 +#define MISC_NAME "META00" +#define MISC_NAME2 "META01" +#define NUM_BIAS_DATA 10 +#define TEST_NUM_ROWS 4 +#define TEST_NUM_COLS 4 +#define NUM_READOUTS 3 +#define NUM_CELLS 10 +#define NUM_CHIPS 8 +#define NUM_HDUS 5 +#define BASE_IMAGE 10 +#define BASE_MASK 40 +#define BASE_WEIGHT 70 +#define VERBOSE 0 +#define ERR_TRACE_LEVEL 0 +char *fitsFilename = "tmp.fits"; + +psPlaneTransform *PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM() +{ + psPlaneTransform *pt = psPlaneTransformAlloc(1, 1); + pt->x->coeff[1][0] = 1.0; + pt->y->coeff[0][1] = 1.0; + return(pt); +} + +psPlaneDistort *PS_CREATE_4D_IDENTITY_PLANE_DISTORT() +{ + psPlaneDistort *pd = psPlaneDistortAlloc(1, 1, 1, 1); + pd->x->coeff[1][0][0][0] = 1.0; + pd->y->coeff[0][1][0][0] = 1.0; + return(pd); +} + +/****************************************************************************** +generateSimpleReadout(): This function generates a pmReadout data structure and then +populates its members with real data. + *****************************************************************************/ +pmReadout *generateSimpleReadout(pmCell *cell) +{ + pmReadout *readout = pmReadoutAlloc(cell); + readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8); + readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) { + psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(tmpImage, (double) i); + psListAdd(readout->bias, PS_LIST_HEAD, tmpImage); + psFree(tmpImage); + } + psMetadataAddS32(readout->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + return(readout); +} + +/****************************************************************************** +generateSimpleCell(): This function generates a pmCell data structure and then +populates its members with real data. + *****************************************************************************/ +pmCell *generateSimpleCell(pmChip *chip, int cellID) +{ + pmCell *cell = pmCellAlloc(chip, CELL_ALLOC_NAME); + + psMetadataAddS32(cell->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(cell->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psArrayRealloc(cell->readouts, NUM_READOUTS); + char extname[80]; + snprintf(extname,80, "ext-%d", cellID); + cell->hdu = pmHDUAlloc(extname); + for (int i = 0 ; i < NUM_READOUTS ; i++) { + cell->readouts->data[i] = generateSimpleReadout(cell); + } + + bool rc = pmConfigFileRead(&cell->hdu->format, "data/camera0/format0.config", "Camera format 0"); + if (!rc) { + diag("pmConfigFileRead() was unsuccessful (from generateSimpleCell())"); + } + + cell->hdu->images = psArrayAlloc(NUM_HDUS); + cell->hdu->masks = psArrayAlloc(NUM_HDUS); + cell->hdu->weights = psArrayAlloc(NUM_HDUS); + for (int k = 0 ; k < NUM_HDUS ; k++) { + cell->hdu->images->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + cell->hdu->masks->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK); + cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k)); + psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k)); + psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k)); + } + + //XXX: Should the region be set some other way? Like through the various config files? +// psRegion *region = psRegionAlloc(0.0, TEST_NUM_COLS-1, 0.0, TEST_NUM_ROWS-1); + psRegion *region = psRegionAlloc(0.0, 0.0, 0.0, 0.0); + // You shouldn't have to remove the key from the metadata. Find out how to simply change the key value. + psMetadataRemoveKey(cell->concepts, "CELL.TRIMSEC"); + psMetadataAddPtr(cell->concepts, PS_LIST_TAIL|PS_META_REPLACE, "CELL.TRIMSEC", PS_DATA_REGION, "I am a region", region); + psFree(region); + return(cell); +} + +/****************************************************************************** +generateSimpleChip(): This function generates a pmChip data structure and then +populates its members with real data. + *****************************************************************************/ +pmChip *generateSimpleChip(pmFPA *fpa, int chipID) +{ + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + chip->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + chip->fromFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + psMetadataAddS32(chip->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(chip->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + + if (0) { + char extname[80]; + snprintf(extname,80, "ext-%d", chipID); + chip->hdu = pmHDUAlloc(extname); + } + + psArrayRealloc(chip->cells, NUM_CELLS); + for (int i = 0 ; i < NUM_CELLS ; i++) { + chip->cells->data[i] = generateSimpleCell(chip, i); + } + + // XXX: Add code to initialize chip pmConcepts + + + return(chip); +} + +/****************************************************************************** +generateSimpleFPA(): This function generates a pmFPA data structure and then +populates its members with real data. + *****************************************************************************/ +pmFPA* generateSimpleFPA(psMetadata *camera) +{ + pmFPA* fpa = pmFPAAlloc(camera); + fpa->fromTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toSky = psProjectionAlloc(0.0,0.0,10.0,10.0,PS_PROJ_TAN); + psMetadataAddS32(fpa->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32((psMetadata *) fpa->camera, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(fpa->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// fpa->hdu = pmHDUAlloc("fpaExtName"); +// +// bool rc = pmConfigFileRead(&fpa->hdu->format, "data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleFPA())"); +// } + + psArrayRealloc(fpa->chips, NUM_CHIPS); + for (int i = 0 ; i < NUM_CHIPS ; i++) { + fpa->chips->data[i] = generateSimpleChip(fpa, i); + } + + // XXX: Eventually, when you finish the pmConcepts tests, add full concept + // reading code from wherever. + pmConceptsBlankFPA(fpa); +// bool mdok; +// psMetadata *fileData = psMetadataLookupMetadata(&mdok, fpa->hdu->format, "FILE"); +// char *fpaNameHdr = psMetadataLookupStr(&mdok, fileData, "FPA.NAME"); +// psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.NAME", PS_META_REPLACE, NULL, fpaNameHdr); + + return(fpa); +} + +// XXX: This should only be necessary until the psFree() functions for +// FPA/chip/cell/readout correctly free all child chips/cells/readouts +void myFreeCell(pmCell *cell) +{ + for (int k = 0 ; k < cell->readouts->n ; k++) { + psFree(cell->readouts->data[k]); + } + psFree(cell); +} + +void myFreeChip(pmChip *chip) { + for (int j = 0 ; j < chip->cells->n ; j++) { + myFreeCell(chip->cells->data[j]); + } + psFree(chip); +} + +void myFreeFPA(pmFPA *fpa) +{ + for (int i = 0 ; i < fpa->chips->n ; i++) { + myFreeChip(fpa->chips->data[i]); + } + psFree(fpa); +} + + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(25); + + + // ---------------------------------------------------------------------- + // pmCellReadHeader() tests: NULL input fits file + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA *fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + ok(!pmCellReadHeader(cell, NULL), "pmCellReadHeader(cell, NULL) returned FALSE"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmCellReadHeader() tests: NULL input pmCell + { + psMemId id = psMemGetId(); + psFits* fitsFileW = psFitsOpen(fitsFilename, "w"); + ok(fitsFileW != NULL, "psFitsOpen() opened the FITS file"); + ok(!pmCellReadHeader(NULL, fitsFileW), "pmCellReadHeader(NULL, fitsFile) returned FALSE"); + psFree(fitsFileW); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmCellReadHeader() tests: acceptable data + { + psMemId id = psMemGetId(); + + // Create a FITS file for this test + psFits* fitsFileW = psFitsOpen(fitsFilename, "w"); + ok(fitsFileW != NULL, "psFitsOpen() opened the FITS file"); + char extname[80]; + for (int lcv = 0; lcv < NUM_HDUS; lcv++) { + snprintf(extname, 80, "ext-%d", lcv); + pmHDU *hdu = pmHDUAlloc(extname); + hdu->header = psMetadataAlloc(); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYINT", PS_DATA_S32, + "psS32 Item", (psS32)lcv); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYFLT", PS_DATA_F32, + "psF32 Item", (float)(1.0f/(float)(1+lcv))); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYDBL", PS_DATA_F64, + "psF64 Item", (double)(1.0/(double)(1+lcv))); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYBOOL", PS_DATA_BOOL, + "psBool Item", (lcv%2 == 0)); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYSTR", PS_DATA_STRING, + "String Item", extname); + bool rc = pmConfigFileRead(&hdu->format, "data/camera0/format0.config", "Camera 0 Config Format"); + ok(rc == true, "pmConfigFileRead() was successful"); + rc = pmHDUWrite(hdu, fitsFileW); + ok(rc == true, "pmHDUWrite() successfully wrote the header"); + psFree(hdu); + } + psFitsClose(fitsFileW); + + // Now, open that FITS file, and create an pmFPA hierarchy + psFits* fitsFileR = psFitsOpen(fitsFilename, "r"); + ok(fitsFileR != NULL, "psFitsOpen returned non-NULL on existing file"); + psMetadata *camera = psMetadataAlloc(); + pmFPA *fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + + ok(pmCellReadHeader(cell, fitsFileR), "pmCellReadHeader() returned TRUE with acceptable data"); + + // XXX: It's not clear if we should test if the HDU and pmConcepts actually + // get rid, since pmCellReadHeader() simply calls functions that are tested + // elsewhere. However, if we should test it, test it here. + + myFreeFPA(fpa); + psFree(camera); + psFree(fitsFileR); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmChipReadHeader() tests: NULL input fits file + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA *fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + ok(!pmChipReadHeader(chip, NULL), "pmChipReadHeader(chip, NULL) returned FALSE"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmChipReadHeader() tests: NULL input pmCell + { + psMemId id = psMemGetId(); + psFits* fitsFileW = psFitsOpen(fitsFilename, "w"); + ok(fitsFileW != NULL, "psFitsOpen() opened the FITS file"); + ok(!pmChipReadHeader(NULL, fitsFileW), "pmChipReadHeader(NULL, fitsFile) returned FALSE"); + psFree(fitsFileW); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmChipReadHeader() tests: acceptable data + { + psMemId id = psMemGetId(); + + // Create a FITS file for this test + psFits* fitsFileW = psFitsOpen(fitsFilename, "w"); + ok(fitsFileW != NULL, "psFitsOpen() opened the FITS file"); + char extname[80]; + for (int lcv = 0; lcv < NUM_HDUS; lcv++) { + snprintf(extname, 80, "ext-%d", lcv); + pmHDU *hdu = pmHDUAlloc(extname); + hdu->header = psMetadataAlloc(); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYINT", PS_DATA_S32, + "psS32 Item", (psS32)lcv); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYFLT", PS_DATA_F32, + "psF32 Item", (float)(1.0f/(float)(1+lcv))); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYDBL", PS_DATA_F64, + "psF64 Item", (double)(1.0/(double)(1+lcv))); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYBOOL", PS_DATA_BOOL, + "psBool Item", (lcv%2 == 0)); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYSTR", PS_DATA_STRING, + "String Item", extname); + bool rc = pmConfigFileRead(&hdu->format, "data/camera0/format0.config", "Camera 0 Config Format"); + ok(rc == true, "pmConfigFileRead() was successful"); + rc = pmHDUWrite(hdu, fitsFileW); + ok(rc == true, "pmHDUWrite() successfully wrote the header"); + psFree(hdu); + } + psFitsClose(fitsFileW); + + // Now, open that FITS file, and create an pmFPA hierarchy + psFits* fitsFileR = psFitsOpen(fitsFilename, "r"); + ok(fitsFileR != NULL, "psFitsOpen returned non-NULL on existing file"); + psMetadata *camera = psMetadataAlloc(); + pmFPA *fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + + // Set the correct extension names for the chips (if we put this in the + // generateChip() code, then psMOdules aborts. + for (int chipID = 0 ; chipID < fpa->chips->n ; chipID++) { + pmChip *chip = fpa->chips->data[chipID]; + char extname[80]; + snprintf(extname,80, "ext-%d", chipID); + chip->hdu = pmHDUAlloc(extname); + } + + ok(pmChipReadHeader(chip, fitsFileR), "pmChipReadHeader() returned TRUE with acceptable data"); + + + // XXX: It's not clear if we should test if the HDU and pmConcepts actually + // get rid, since pmCellReadHeader() simply calls functions that are tested + // elsewhere. However, if we should test it, test it here. + + myFreeFPA(fpa); + psFree(camera); + psFree(fitsFileR); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmFPAReadHeader() tests: NULL input fits file + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA *fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + ok(!pmFPAReadHeader(fpa, NULL), "pmFPAReadHeader(fpa, NULL) returned FALSE"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAReadHeader() tests: NULL input pmCell + { + psMemId id = psMemGetId(); + psFits* fitsFileW = psFitsOpen(fitsFilename, "w"); + ok(fitsFileW != NULL, "psFitsOpen() opened the FITS file"); + ok(!pmFPAReadHeader(NULL, fitsFileW), "pmFPAReadHeader(NULL, fitsFile) returned FALSE"); + psFree(fitsFileW); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAReadHeader() tests: acceptable data + { + psMemId id = psMemGetId(); + + // Create a FITS file for this test + psFits* fitsFileW = psFitsOpen(fitsFilename, "w"); + ok(fitsFileW != NULL, "psFitsOpen() opened the FITS file"); + char extname[80]; + for (int lcv = 0; lcv < NUM_HDUS; lcv++) { + snprintf(extname, 80, "ext-%d", lcv); + pmHDU *hdu = pmHDUAlloc(extname); + hdu->header = psMetadataAlloc(); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYINT", PS_DATA_S32, + "psS32 Item", (psS32)lcv); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYFLT", PS_DATA_F32, + "psF32 Item", (float)(1.0f/(float)(1+lcv))); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYDBL", PS_DATA_F64, + "psF64 Item", (double)(1.0/(double)(1+lcv))); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYBOOL", PS_DATA_BOOL, + "psBool Item", (lcv%2 == 0)); + psMetadataAdd(hdu->header, PS_LIST_TAIL, "MYSTR", PS_DATA_STRING, + "String Item", extname); + bool rc = pmConfigFileRead(&hdu->format, "data/camera0/format0.config", "Camera 0 Config Format"); + ok(rc == true, "pmConfigFileRead() was successful"); + rc = pmHDUWrite(hdu, fitsFileW); + ok(rc == true, "pmHDUWrite() successfully wrote the header"); + psFree(hdu); + } + psFitsClose(fitsFileW); + + // Now, open that FITS file, and create an pmFPA hierarchy + psFits* fitsFileR = psFitsOpen(fitsFilename, "r"); + ok(fitsFileR != NULL, "psFitsOpen returned non-NULL on existing file"); + psMetadata *camera = psMetadataAlloc(); + pmFPA *fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + + // Set the correct extension names for the chips (if we put this in the + // generateChip() code, then psMOdules aborts. + for (int chipID = 0 ; chipID < fpa->chips->n ; chipID++) { + pmChip *chip = fpa->chips->data[chipID]; + char extname[80]; + snprintf(extname,80, "ext-%d", chipID); + chip->hdu = pmHDUAlloc(extname); + } + snprintf(extname,80, "ext-%d", 0); + fpa->hdu = pmHDUAlloc(extname); + + ok(pmFPAReadHeader(fpa, fitsFileR), "pmFPAReadHeader() returned TRUE with acceptable data"); + + // XXX: It's not clear if we should test if the HDU and pmConcepts actually + // get rid, since pmCellReadHeader() simply calls functions that are tested + // elsewhere. However, if we should test it, test it here. + + myFreeFPA(fpa); + psFree(camera); + psFree(fitsFileR); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + +} + Index: /trunk/psModules/test/camera/tap_pmFPALevel.c =================================================================== --- /trunk/psModules/test/camera/tap_pmFPALevel.c (revision 14882) +++ /trunk/psModules/test/camera/tap_pmFPALevel.c (revision 14882) @@ -0,0 +1,76 @@ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" + +#define ERR_TRACE_LEVEL 0 + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(15); + + // ---------------------------------------------------------------------- + // ---------------------------------------------------------------------- + // pmFPALevelToName(): tests + // const char *pmFPALevelToName(pmFPALevel level) + { + psMemId id = psMemGetId(); + char *str = (char *) pmFPALevelToName(PM_FPA_LEVEL_NONE); + ok(!strcmp(str, "NONE"), "pmFPALevelToName(PM_FPA_LEVEL_NONE)"); + + str = (char *) pmFPALevelToName(PM_FPA_LEVEL_FPA); + ok(!strcmp(str, "FPA"), "pmFPALevelToName(PM_FPA_LEVEL_FPA)"); + + str = (char *) pmFPALevelToName(PM_FPA_LEVEL_CHIP); + ok(!strcmp(str, "CHIP"), "pmFPALevelToName(PM_FPA_LEVEL_CHIP)"); + + str = (char *) pmFPALevelToName(PM_FPA_LEVEL_CELL); + ok(!strcmp(str, "CELL"), "pmFPALevelToName(PM_FPA_LEVEL_CELL)"); + + str = (char *) pmFPALevelToName(PM_FPA_LEVEL_READOUT); + ok(!strcmp(str, "READOUT"), "pmFPALevelToName(PM_FPA_LEVEL_READOUT)"); + + // XXX: We avoid this because pmFPALevelToName() aborts + if (0) { + str = (char *) pmFPALevelToName(-1); + ok(str == NULL, "pmFPALevelToName(-1)"); + } + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // ---------------------------------------------------------------------- + // pmFPALevelFromName(): tests + // pmFPALevel pmFPALevelFromName(const char *name) + { + psMemId id = psMemGetId(); + pmFPALevel lev = pmFPALevelFromName("NONE"); + ok(lev == PM_FPA_LEVEL_NONE, "pmFPALevelToName(NONE)"); + + lev = pmFPALevelFromName("FPA"); + ok(lev == PM_FPA_LEVEL_FPA, "pmFPALevelToName(FPA)"); + + lev = pmFPALevelFromName("CHIP"); + ok(lev == PM_FPA_LEVEL_CHIP, "pmFPALevelToName(CHIP)"); + + lev = pmFPALevelFromName("CELL"); + ok(lev == PM_FPA_LEVEL_CELL, "pmFPALevelToName(CELL)"); + + lev = pmFPALevelFromName("READOUT"); + ok(lev == PM_FPA_LEVEL_READOUT, "pmFPALevelToName(READOUT)"); + + lev = pmFPALevelFromName("BOGUS"); + ok(lev == PM_FPA_LEVEL_NONE, "pmFPALevelToName(BOGUS)"); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } +} Index: /trunk/psModules/test/camera/tap_pmFPAMaskW.c =================================================================== --- /trunk/psModules/test/camera/tap_pmFPAMaskW.c (revision 14882) +++ /trunk/psModules/test/camera/tap_pmFPAMaskW.c (revision 14882) @@ -0,0 +1,477 @@ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" +// XXX: Use better name for the temporary FITS file +// XXX: The code to generate and free the FPA hierarchy was copied from +// tap-pmFPA.c. EIther include it directly, or library, or something. +// Also, get rid of the manual free functions and use psFree() once +// it correctly frees child members +// XXX: For the genSimpleFPA() code, add IDs to each function so that +// the values set in each chip-?cell-?hdu-?image are unique +// XXX: For the genSimpleFPA() code, write masks and weights as well +// XXX: Must add tests for pmReadoutGenerateWeight() +// XXX: We don't test pmReadoutGenerateMaskWeight() and pmCellGenerateMaskWeight() +// because they are simply calls to the above tested functions + +#define CHIP_ALLOC_NAME "ChipName" +#define CELL_ALLOC_NAME "CellName" +#define MISC_NUM 32 +#define MISC_NAME "META00" +#define MISC_NAME2 "META01" +#define NUM_BIAS_DATA 10 +#define TEST_NUM_ROWS 4 +#define TEST_NUM_COLS 4 +#define NUM_READOUTS 3 +#define NUM_CELLS 10 +#define NUM_CHIPS 8 +#define NUM_HDUS 5 +#define BASE_IMAGE 10 +#define BASE_MASK 40 +#define BASE_WEIGHT 70 +#define SATURATION_LEVEL 10000.0 +#define BAD_LEVEL 100.0 +#define SATURATION_MASK 1 +#define BAD_MASK 2 +#define CELL_GAIN 1.0 +#define CELL_READNOISE 2.0 +#define VERBOSE 0 +#define ERR_TRACE_LEVEL 0 + +psPlaneTransform *PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM() +{ + psPlaneTransform *pt = psPlaneTransformAlloc(1, 1); + pt->x->coeff[1][0] = 1.0; + pt->y->coeff[0][1] = 1.0; + return(pt); +} + +psPlaneDistort *PS_CREATE_4D_IDENTITY_PLANE_DISTORT() +{ + psPlaneDistort *pd = psPlaneDistortAlloc(1, 1, 1, 1); + pd->x->coeff[1][0][0][0] = 1.0; + pd->y->coeff[0][1][0][0] = 1.0; + return(pd); +} + +/****************************************************************************** +generateSimpleReadout(): This function generates a pmReadout data structure and then +populates its members with real data. + *****************************************************************************/ +pmReadout *generateSimpleReadout(pmCell *cell) +{ + pmReadout *readout = pmReadoutAlloc(cell); + readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8); + readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (int i = 0 ; i < TEST_NUM_ROWS ; i++) { + for (int j = 0 ; j < TEST_NUM_COLS ; j++) { + readout->image->data.F32[i][j] = 32.0; + readout->mask->data.U8[i][j] = 0; + readout->weight->data.F32[i][j] = 1.0; + } + } + + for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) { + psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(tmpImage, (double) i); + psListAdd(readout->bias, PS_LIST_HEAD, tmpImage); + psFree(tmpImage); + } + psMetadataAddS32(readout->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + return(readout); +} + +/****************************************************************************** +generateSimpleCell(): This function generates a pmCell data structure and then +populates its members with real data. + *****************************************************************************/ +pmCell *generateSimpleCell(pmChip *chip) +{ + pmCell *cell = pmCellAlloc(chip, CELL_ALLOC_NAME); + + psMetadataAddS32(cell->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(cell->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psArrayRealloc(cell->readouts, NUM_READOUTS); + cell->hdu = pmHDUAlloc("cellExtName"); + for (int i = 0 ; i < NUM_READOUTS ; i++) { + cell->readouts->data[i] = generateSimpleReadout(cell); + } + + bool rc = pmConfigFileRead(&cell->hdu->format, "data/camera0/format0.config", "Camera format 0"); + if (!rc) { + diag("pmConfigFileRead() was unsuccessful (from generateSimpleCell())"); + } + + cell->hdu->images = psArrayAlloc(NUM_HDUS); + cell->hdu->masks = psArrayAlloc(NUM_HDUS); + cell->hdu->weights = psArrayAlloc(NUM_HDUS); + for (int k = 0 ; k < NUM_HDUS ; k++) { + cell->hdu->images->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + cell->hdu->masks->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK); + cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k)); + psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k)); + psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k)); + } + + //XXX: Should the region be set some other way? Like through the various config files? +// psRegion *region = psRegionAlloc(0.0, TEST_NUM_COLS-1, 0.0, TEST_NUM_ROWS-1); + psRegion *region = psRegionAlloc(0.0, 0.0, 0.0, 0.0); + // You shouldn't have to remove the key from the metadata. Find out how to simply change the key value. + psMetadataRemoveKey(cell->concepts, "CELL.TRIMSEC"); + psMetadataAddPtr(cell->concepts, PS_LIST_TAIL|PS_META_REPLACE, "CELL.TRIMSEC", PS_DATA_REGION, "I am a region", region); + psFree(region); + return(cell); +} + +/****************************************************************************** +generateSimpleChip(): This function generates a pmChip data structure and then +populates its members with real data. + *****************************************************************************/ +pmChip *generateSimpleChip(pmFPA *fpa) +{ + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + chip->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + chip->fromFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + psMetadataAddS32(chip->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(chip->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// chip->hdu = pmHDUAlloc("chipExtName"); +// +// bool rc = pmConfigFileRead(&chip->hdu->format, "data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleChip())"); +// } +// + psArrayRealloc(chip->cells, NUM_CELLS); + for (int i = 0 ; i < NUM_CELLS ; i++) { + chip->cells->data[i] = generateSimpleCell(chip); + } + + // XXX: Add code to initialize chip pmConcepts + + + return(chip); +} + +/****************************************************************************** +generateSimpleFPA(): This function generates a pmFPA data structure and then +populates its members with real data. + *****************************************************************************/ +pmFPA* generateSimpleFPA(psMetadata *camera) +{ + pmFPA* fpa = pmFPAAlloc(camera); + fpa->fromTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toSky = psProjectionAlloc(0.0,0.0,10.0,10.0,PS_PROJ_TAN); + psMetadataAddS32(fpa->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32((psMetadata *) fpa->camera, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(fpa->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// fpa->hdu = pmHDUAlloc("fpaExtName"); +// +// bool rc = pmConfigFileRead(&fpa->hdu->format, "data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleFPA())"); +// } + + psArrayRealloc(fpa->chips, NUM_CHIPS); + for (int i = 0 ; i < NUM_CHIPS ; i++) { + fpa->chips->data[i] = generateSimpleChip(fpa); + } + + // XXX: Eventually, when you finish the pmConcepts tests, add full concept + // reading code from wherever. + pmConceptsBlankFPA(fpa); +// bool mdok; +// psMetadata *fileData = psMetadataLookupMetadata(&mdok, fpa->hdu->format, "FILE"); +// char *fpaNameHdr = psMetadataLookupStr(&mdok, fileData, "FPA.NAME"); +// psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.NAME", PS_META_REPLACE, NULL, fpaNameHdr); + + return(fpa); +} + +// XXX: This should only be necessary until the psFree() functions for +// FPA/chip/cell/readout correctly free all child chips/cells/readouts +void myFreeCell(pmCell *cell) +{ + for (int k = 0 ; k < cell->readouts->n ; k++) { + psFree(cell->readouts->data[k]); + } + psFree(cell); +} + +void myFreeChip(pmChip *chip) { + for (int j = 0 ; j < chip->cells->n ; j++) { + myFreeCell(chip->cells->data[j]); + } + psFree(chip); +} + +void myFreeFPA(pmFPA *fpa) +{ + for (int i = 0 ; i < fpa->chips->n ; i++) { + myFreeChip(fpa->chips->data[i]); + } + psFree(fpa); +} + + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(18); + + // ---------------------------------------------------------------------- + // pmReadoutSetMask() tests: NULL inputs + // bool pmReadoutSetMask(pmReadout *readout, psMaskType satMask, psMaskType badMask) + if (1) { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + pmReadout *readout = cell->readouts->data[0]; + bool rc; + + // Set readout == NULL, ensure pmReadoutSetMask() returnes FALSE, with no seg faults, memory leaks + rc = pmReadoutSetMask(NULL, SATURATION_MASK, BAD_MASK); + ok(!rc, "pmReadoutSetMask(NULL, SATURATION_MASK, BAD_MASK) returned FALSE with null pmReadout input"); + + // Set readout->image, ensure pmReadoutSetMask() returnes FALSE, with no seg faults, memory leaks + psImage *saveImg = readout->image; + readout->image = NULL; + rc = pmReadoutSetMask(readout, SATURATION_MASK, BAD_MASK); + ok(!rc, "pmReadoutSetMask(readout, SATURATION_MASK, BAD_MASK) returned FALSE with null pmReadout->image input"); + readout->image = saveImg; + + // Set pixels in the upper-left quadrant to values [10000:11000] range + // Set pixels in the upper-right quadrant to values [0:1000] range + // Set pixels in the lower-left quadrant to values [100000:1000000] range + // Set pixels in the lower-right quadrant to values [100000:1000000] range + + for (int i = 0 ; i < readout->image->numRows ; i++) { + for (int j = 0 ; j < readout->image->numCols ; j++) { + if (i < readout->image->numRows/2) { + if (j < readout->image->numCols/2) { + readout->image->data.F32[i][j] = 10000.0 + (float) (i + j); + } else { + readout->image->data.F32[i][j] = (float) (i + j); + } + } else { + readout->image->data.F32[i][j] = 100000.0 + (float) (i + j); + } + } + } + + // Set the acceptable pixel range to [100.0 : 20000.0] + rc = psMetadataAddF32(readout->parent->concepts, PS_LIST_HEAD, "CELL.SATURATION", PS_META_REPLACE, NULL, 20000.0); + rc|= psMetadataAddF32(readout->parent->concepts, PS_LIST_HEAD, "CELL.BAD", PS_META_REPLACE, NULL, 100.0); + ok(rc, "Set pixel range in cell->concepts successfully"); + + // Call pmReadoutSetMask() and then verify that the mask data was set correctly + rc = pmReadoutSetMask(readout, SATURATION_MASK, BAD_MASK); + ok(rc, "pmReadoutSetMask(readout, SATURATION_MASK, BAD_MASK) returned TRUE with acceptable input data"); + bool errorFlag = false; + for (int i = 0 ; i < readout->image->numRows ; i++) { + for (int j = 0 ; j < readout->image->numCols ; j++) { + if (i < readout->image->numRows/2) { + if (j < readout->image->numCols/2) { + if(readout->mask->data.U8[i][j] != 0) { + if (VERBOSE) { + diag("TEST ERROR: mask[%d][%d] is %d, should be 0\n", + i, j, readout->mask->data.U8[i][j]); + } + errorFlag = true; + } + } else { + if(readout->mask->data.U8[i][j] != BAD_MASK) { + if (VERBOSE) { + diag("TEST ERROR: mask[%d][%d] is %d, should be %d\n", + i, j, readout->mask->data.U8[i][j], BAD_MASK); + } + errorFlag = true; + } + } + } else { + if(readout->mask->data.U8[i][j] != SATURATION_MASK) { + if (VERBOSE) { + diag("TEST ERROR: mask[%d][%d] is %d, should be %d\n", + i, j, readout->mask->data.U8[i][j], SATURATION_MASK); + } + errorFlag = true; + } + } + } + } + ok(!errorFlag, "pmReadoutSetMask() set the mask values correctly"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + // ---------------------------------------------------------------------- + // pmReadoutGenerateMask() tests: NULL inputs + // bool pmReadoutGenerateMask(pmReadout *readout, psMaskType satMask, psMaskType badMask) + // XXX: This test is a duplicate of the above pmReadoutSetMask() test since the actual + // code is almost the same. Must test with the readout->mask == NULL. + if (1) { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + pmReadout *readout = cell->readouts->data[0]; + bool rc; + + // Set readout == NULL, ensure pmReadoutGenerateMask() returnes FALSE, with no seg faults, memory leaks + rc = pmReadoutGenerateMask(NULL, SATURATION_MASK, BAD_MASK); + ok(!rc, "pmReadoutGenerateMask(NULL, SATURATION_MASK, BAD_MASK) returned FALSE with null pmReadout input"); + + // Set pixels in the upper-left quadrant to values [10000:11000] range + // Set pixels in the upper-right quadrant to values [0:1000] range + // Set pixels in the lower-left quadrant to values [100000:1000000] range + // Set pixels in the lower-right quadrant to values [100000:1000000] range + + for (int i = 0 ; i < readout->image->numRows ; i++) { + for (int j = 0 ; j < readout->image->numCols ; j++) { + if (i < readout->image->numRows/2) { + if (j < readout->image->numCols/2) { + readout->image->data.F32[i][j] = 10000.0 + (float) (i + j); + } else { + readout->image->data.F32[i][j] = (float) (i + j); + } + } else { + readout->image->data.F32[i][j] = 100000.0 + (float) (i + j); + } + } + } + + // Set the acceptable pixel range to [100.0 : 20000.0] + rc = psMetadataAddF32(readout->parent->concepts, PS_LIST_HEAD, "CELL.SATURATION", PS_META_REPLACE, NULL, 20000.0); + rc|= psMetadataAddF32(readout->parent->concepts, PS_LIST_HEAD, "CELL.BAD", PS_META_REPLACE, NULL, 100.0); + ok(rc, "Set pixel range in cell->concepts successfully"); + + // Call pmReadoutGenerateMask() and then verify that the mask data was set correctly + rc = pmReadoutGenerateMask(readout, SATURATION_MASK, BAD_MASK); + ok(rc, "pmReadoutGenerateMask(readout, SATURATION_MASK, BAD_MASK) returned TRUE with acceptable input data"); + bool errorFlag = false; + for (int i = 0 ; i < readout->image->numRows ; i++) { + for (int j = 0 ; j < readout->image->numCols ; j++) { + if (i < readout->image->numRows/2) { + if (j < readout->image->numCols/2) { + if(readout->mask->data.U8[i][j] != 0) { + if (VERBOSE) { + diag("TEST ERROR: mask[%d][%d] is %d, should be 0\n", + i, j, readout->mask->data.U8[i][j]); + } + errorFlag = true; + } + } else { + if(readout->mask->data.U8[i][j] != BAD_MASK) { + if (VERBOSE) { + diag("TEST ERROR: mask[%d][%d] is %d, should be %d\n", + i, j, readout->mask->data.U8[i][j], BAD_MASK); + errorFlag = true; + } + } + } + } else { + if(readout->mask->data.U8[i][j] != SATURATION_MASK) { + if (VERBOSE) { + diag("TEST ERROR: mask[%d][%d] is %d, should be %d\n", + i, j, readout->mask->data.U8[i][j], SATURATION_MASK); + } + errorFlag = true; + } + } + } + } + ok(!errorFlag, "pmReadoutGenerateMask() set the mask values correctly"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + // ---------------------------------------------------------------------- + // pmReadoutSetWeight() tests: NULL inputs + // bool pmReadoutSetWeight(pmReadout *readout, bool poisson) + if (1) { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + pmReadout *readout = cell->readouts->data[0]; + bool rc; + + // Set readout == NULL, ensure pmReadoutSetWeight() returnes FALSE, with no seg faults, memory leaks + rc = pmReadoutSetWeight(NULL, false); + ok(!rc, "pmReadoutSetWeight(NULL, false) returned FALSE with null pmReadout input"); + + + // Set the acceptable pixel range to [100.0 : 20000.0] + rc = psMetadataAddF32(readout->parent->concepts, PS_LIST_HEAD, "CELL.GAIN", PS_META_REPLACE, NULL, CELL_GAIN); + rc|= psMetadataAddF32(readout->parent->concepts, PS_LIST_HEAD, "CELL.READNOISE", PS_META_REPLACE, NULL, CELL_READNOISE); + ok(rc, "Set GAIN and READNOISE in cell->concepts successfully"); + + // Call pmReadoutSetWeight() and then verify that the mask data was set correctly + rc = pmReadoutSetWeight(readout, false); + ok(rc, "pmReadoutSetWeight(readout, false) returned TRUE with acceptable input data"); + bool errorFlag = false; + for (int i = 0 ; i < readout->weight->numRows ; i++) { + for (int j = 0 ; j < readout->weight->numCols ; j++) { + psF32 exp = CELL_READNOISE * CELL_READNOISE / CELL_GAIN / CELL_GAIN; + if(abs(readout->weight->data.F32[i][j] - exp) > 1e-4) { + if (VERBOSE) { + diag("TEST ERROR: weight[%d][%d] is %.2f, should be %.2f\n", + i, j, readout->weight->data.F32[i][j], exp); + } + errorFlag = true; + } + } + } + ok(!errorFlag, "pmReadoutSetWeight() set the weight values correctly (non-Poisson)"); + + for (int i = 0 ; i < readout->image->numRows ; i++) { + for (int j = 0 ; j < readout->image->numCols ; j++) { + readout->image->data.F32[i][j] = 100.0 + (float) (i + j); + } + } + // Call pmReadoutSetWeight() and then verify that the mask data was set correctly + rc = pmReadoutSetWeight(readout, true); + ok(rc, "pmReadoutSetWeight(readout, true) returned TRUE with acceptable input data"); + errorFlag = false; + for (int i = 0 ; i < readout->weight->numRows ; i++) { + for (int j = 0 ; j < readout->weight->numCols ; j++) { + psF32 exp = abs(readout->image->data.F32[i][j] / CELL_GAIN); + if (exp < 1.0) exp = 1.0; + exp+= CELL_READNOISE * CELL_READNOISE / CELL_GAIN / CELL_GAIN; + if(abs(readout->weight->data.F32[i][j] - exp) > 1e-4) { + if (VERBOSE) { + diag("TEST ERROR: weight[%d][%d] is %.2f, should be %.2f\n", + i, j, readout->weight->data.F32[i][j], exp); + } + errorFlag = true; + } + } + } + + ok(!errorFlag, "pmReadoutSetWeight() set the weight values correctly (Poisson)"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + +} + Index: /trunk/psModules/test/camera/tap_pmFPAReadWrite.c =================================================================== --- /trunk/psModules/test/camera/tap_pmFPAReadWrite.c (revision 14881) +++ /trunk/psModules/test/camera/tap_pmFPAReadWrite.c (revision 14882) @@ -12,5 +12,4 @@ // XXX: For the genSimpleFPA() code, add IDs to each function so that // the values set in each chip-?cell-?hdu-?image are unique -// XXX: For the genSimpleFPA() code, write masks and weights as well #define CHIP_ALLOC_NAME "ChipName" @@ -674,8 +673,8 @@ // XXX: chipID should be cellID for (int chipID = 0 ; chipID < chip->cells->n ; chipID++) { - if (VERBOSE) printf("Reading cell %d\n", chipID); + if (VERBOSE) diag("Reading cell %d\n", chipID); pmCell *cell = (pmCell *) chip->cells->data[chipID]; for (int k = 0 ; k < cell->hdu->images->n ; k++) { - if (VERBOSE) printf("Cool: image %d\n", k); + if (VERBOSE) diag("Cool: image %d\n", k); psImage *img = cell->hdu->images->data[k]; for (int i = 0 ; i < img->numRows ; i++) { @@ -794,8 +793,8 @@ // XXX: chipID should be cellID for (int chipID = 0 ; chipID < chip->cells->n ; chipID++) { - if (VERBOSE) printf("Reading cell %d\n", chipID); + if (VERBOSE) diag("Reading cell %d\n", chipID); pmCell *cell = (pmCell *) chip->cells->data[chipID]; for (int k = 0 ; k < cell->hdu->weights->n ; k++) { - if (VERBOSE) printf("Cool: image %d\n", k); + if (VERBOSE) diag("Cool: image %d\n", k); psImage *wgt = cell->hdu->weights->data[k]; for (int i = 0 ; i < wgt->numRows ; i++) { @@ -865,8 +864,8 @@ // XXX: chipID should be cellID for (int chipID = 0 ; chipID < chip->cells->n ; chipID++) { - if (VERBOSE) printf("Reading cell %d\n", chipID); + if (VERBOSE) diag("Reading cell %d\n", chipID); pmCell *cell = (pmCell *) chip->cells->data[chipID]; for (int k = 0 ; k < cell->hdu->masks->n ; k++) { - if (VERBOSE) printf("Cool: image %d\n", k); + if (VERBOSE) diag("Cool: image %d\n", k); psImage *msk = cell->hdu->masks->data[k]; for (int i = 0 ; i < msk->numRows ; i++) { @@ -986,8 +985,8 @@ pmChip *chip = fpa->chips->data[fpaID]; for (int chipID = 0 ; chipID < chip->cells->n ; chipID++) { - if (VERBOSE) printf("Reading cell %d\n", chipID); + if (VERBOSE) diag("Reading cell %d\n", chipID); pmCell *cell = (pmCell *) chip->cells->data[chipID]; for (int k = 0 ; k < cell->hdu->images->n ; k++) { - if (VERBOSE) printf("Cool: image %d\n", k); + if (VERBOSE) diag("Cool: image %d\n", k); psImage *img = cell->hdu->images->data[k]; for (int i = 0 ; i < img->numRows ; i++) { @@ -1108,8 +1107,8 @@ pmChip *chip = fpa->chips->data[fpaID]; for (int chipID = 0 ; chipID < chip->cells->n ; chipID++) { - if (VERBOSE) printf("Reading cell %d\n", chipID); + if (VERBOSE) diag("Reading cell %d\n", chipID); pmCell *cell = (pmCell *) chip->cells->data[chipID]; for (int k = 0 ; k < cell->hdu->weights->n ; k++) { - if (VERBOSE) printf("Cool: image %d\n", k); + if (VERBOSE) diag("Cool: image %d\n", k); psImage *wgt = cell->hdu->weights->data[k]; for (int i = 0 ; i < wgt->numRows ; i++) { @@ -1230,8 +1229,8 @@ pmChip *chip = fpa->chips->data[fpaID]; for (int chipID = 0 ; chipID < chip->cells->n ; chipID++) { - if (VERBOSE) printf("Reading cell %d\n", chipID); + if (VERBOSE) diag("Reading cell %d\n", chipID); pmCell *cell = (pmCell *) chip->cells->data[chipID]; for (int k = 0 ; k < cell->hdu->masks->n ; k++) { - if (VERBOSE) printf("Cool: image %d\n", k); + if (VERBOSE) diag("Cool: image %d\n", k); psImage *msk = cell->hdu->masks->data[k]; for (int i = 0 ; i < msk->numRows ; i++) { @@ -1256,4 +1255,2 @@ } - -//HERE Index: /trunk/psModules/test/camera/tap_pmFPAUtils.c =================================================================== --- /trunk/psModules/test/camera/tap_pmFPAUtils.c (revision 14882) +++ /trunk/psModules/test/camera/tap_pmFPAUtils.c (revision 14882) @@ -0,0 +1,339 @@ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" +// XXX: Use better name for the temporary FITS file +// XXX: The code to generate and free the FPA hierarchy was copied from +// tap-pmFPA.c. EIther include it directly, or library, or something. +// Also, get rid of the manual free functions and use psFree() once +// it correctly frees child members +// XXX: For the genSimpleFPA() code, add IDs to each function so that +// the values set in each chip-?cell-?hdu-?image are unique +// XXX: For the genSimpleFPA() code, write masks and weights as well + +#define CHIP_ALLOC_NAME "ChipName" +#define CELL_ALLOC_NAME "CellName" +#define MISC_NUM 32 +#define MISC_NAME "META00" +#define MISC_NAME2 "META01" +#define NUM_BIAS_DATA 10 +#define TEST_NUM_ROWS 4 +#define TEST_NUM_COLS 4 +#define NUM_READOUTS 3 +#define NUM_CELLS 10 +#define NUM_CHIPS 8 +#define NUM_HDUS 5 +#define BASE_IMAGE 10 +#define BASE_MASK 40 +#define BASE_WEIGHT 70 +#define VERBOSE 0 +#define ERR_TRACE_LEVEL 0 + +psPlaneTransform *PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM() +{ + psPlaneTransform *pt = psPlaneTransformAlloc(1, 1); + pt->x->coeff[1][0] = 1.0; + pt->y->coeff[0][1] = 1.0; + return(pt); +} + +psPlaneDistort *PS_CREATE_4D_IDENTITY_PLANE_DISTORT() +{ + psPlaneDistort *pd = psPlaneDistortAlloc(1, 1, 1, 1); + pd->x->coeff[1][0][0][0] = 1.0; + pd->y->coeff[0][1][0][0] = 1.0; + return(pd); +} + +/****************************************************************************** +generateSimpleReadout(): This function generates a pmReadout data structure and then +populates its members with real data. + *****************************************************************************/ +pmReadout *generateSimpleReadout(pmCell *cell) +{ + pmReadout *readout = pmReadoutAlloc(cell); + readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8); + readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) { + psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(tmpImage, (double) i); + psListAdd(readout->bias, PS_LIST_HEAD, tmpImage); + psFree(tmpImage); + } + psMetadataAddS32(readout->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + return(readout); +} + +/****************************************************************************** +generateSimpleCell(): This function generates a pmCell data structure and then +populates its members with real data. + *****************************************************************************/ +pmCell *generateSimpleCell(pmChip *chip) +{ + pmCell *cell = pmCellAlloc(chip, CELL_ALLOC_NAME); + + psMetadataAddS32(cell->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(cell->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psArrayRealloc(cell->readouts, NUM_READOUTS); + cell->hdu = pmHDUAlloc("cellExtName"); + for (int i = 0 ; i < NUM_READOUTS ; i++) { + cell->readouts->data[i] = generateSimpleReadout(cell); + } + + bool rc = pmConfigFileRead(&cell->hdu->format, "data/camera0/format0.config", "Camera format 0"); + if (!rc) { + diag("pmConfigFileRead() was unsuccessful (from generateSimpleCell())"); + } + + cell->hdu->images = psArrayAlloc(NUM_HDUS); + cell->hdu->masks = psArrayAlloc(NUM_HDUS); + cell->hdu->weights = psArrayAlloc(NUM_HDUS); + for (int k = 0 ; k < NUM_HDUS ; k++) { + cell->hdu->images->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + cell->hdu->masks->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK); + cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k)); + psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k)); + psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k)); + } + + //XXX: Should the region be set some other way? Like through the various config files? +// psRegion *region = psRegionAlloc(0.0, TEST_NUM_COLS-1, 0.0, TEST_NUM_ROWS-1); + psRegion *region = psRegionAlloc(0.0, 0.0, 0.0, 0.0); + // You shouldn't have to remove the key from the metadata. Find out how to simply change the key value. + psMetadataRemoveKey(cell->concepts, "CELL.TRIMSEC"); + psMetadataAddPtr(cell->concepts, PS_LIST_TAIL|PS_META_REPLACE, "CELL.TRIMSEC", PS_DATA_REGION, "I am a region", region); + psFree(region); + return(cell); +} + +/****************************************************************************** +generateSimpleChip(): This function generates a pmChip data structure and then +populates its members with real data. + *****************************************************************************/ +pmChip *generateSimpleChip(pmFPA *fpa) +{ + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + chip->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + chip->fromFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + psMetadataAddS32(chip->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(chip->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// chip->hdu = pmHDUAlloc("chipExtName"); +// +// bool rc = pmConfigFileRead(&chip->hdu->format, "data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleChip())"); +// } +// + psArrayRealloc(chip->cells, NUM_CELLS); + for (int i = 0 ; i < NUM_CELLS ; i++) { + chip->cells->data[i] = generateSimpleCell(chip); + } + + // XXX: Add code to initialize chip pmConcepts + + + return(chip); +} + +/****************************************************************************** +generateSimpleFPA(): This function generates a pmFPA data structure and then +populates its members with real data. + *****************************************************************************/ +pmFPA* generateSimpleFPA(psMetadata *camera) +{ + pmFPA* fpa = pmFPAAlloc(camera); + fpa->fromTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toSky = psProjectionAlloc(0.0,0.0,10.0,10.0,PS_PROJ_TAN); + psMetadataAddS32(fpa->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32((psMetadata *) fpa->camera, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(fpa->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// fpa->hdu = pmHDUAlloc("fpaExtName"); +// +// bool rc = pmConfigFileRead(&fpa->hdu->format, "data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleFPA())"); +// } + + psArrayRealloc(fpa->chips, NUM_CHIPS); + for (int i = 0 ; i < NUM_CHIPS ; i++) { + fpa->chips->data[i] = generateSimpleChip(fpa); + } + + // XXX: Eventually, when you finish the pmConcepts tests, add full concept + // reading code from wherever. + pmConceptsBlankFPA(fpa); +// bool mdok; +// psMetadata *fileData = psMetadataLookupMetadata(&mdok, fpa->hdu->format, "FILE"); +// char *fpaNameHdr = psMetadataLookupStr(&mdok, fileData, "FPA.NAME"); +// psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.NAME", PS_META_REPLACE, NULL, fpaNameHdr); + + return(fpa); +} + +// XXX: This should only be necessary until the psFree() functions for +// FPA/chip/cell/readout correctly free all child chips/cells/readouts +void myFreeCell(pmCell *cell) +{ + for (int k = 0 ; k < cell->readouts->n ; k++) { + psFree(cell->readouts->data[k]); + } + psFree(cell); +} + +void myFreeChip(pmChip *chip) { + for (int j = 0 ; j < chip->cells->n ; j++) { + myFreeCell(chip->cells->data[j]); + } + psFree(chip); +} + +void myFreeFPA(pmFPA *fpa) +{ + for (int i = 0 ; i < fpa->chips->n ; i++) { + myFreeChip(fpa->chips->data[i]); + } + psFree(fpa); +} + + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(72); + + // ---------------------------------------------------------------------- + // int pmFPAFindChip(const pmFPA *fpa, const char *name) + { + psMemId id = psMemGetId(); + int rc = pmFPAFindChip(NULL, "bogus"); + ok(-1 == rc, "pmFPAFindChip() returns -1 with NULL pmFPA input param"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // int pmFPAFindChip(const pmFPA *fpa, const char *name) + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + int rc = pmFPAFindChip(fpa, NULL); + ok(-1 == rc, "pmFPAFindChip() returns -1 with NULL name input param"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // int pmFPAFindChip(const pmFPA *fpa, const char *name) + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + // Set unique chip names + for (int chipID = 0 ; chipID < fpa->chips->n ; chipID++) { + pmChip *chip = fpa->chips->data[chipID]; + char tmpName[100]; + sprintf(tmpName, "chip-%d", chipID); + psMetadataAddStr(chip->concepts, PS_LIST_TAIL, "CHIP.NAME", PS_META_REPLACE, NULL, tmpName); + } + + // Verify that pmFPAFindChip() finds those chips correctly + for (int chipID = 0 ; chipID < fpa->chips->n ; chipID++) { + char tmpName[100]; + sprintf(tmpName, "chip-%d", chipID); + int rc = pmFPAFindChip(fpa, tmpName); + ok(rc == chipID, "pmFPAFindChip() correctly found chip %s (%d)", tmpName, rc); + } + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + // ---------------------------------------------------------------------- + // int pmChipFindCell(const pmChip *chip, const char *name) + { + psMemId id = psMemGetId(); + int rc = pmChipFindCell(NULL, "bogus"); + ok(-1 == rc, "pmChipFindCell() returns -1 with NULL pmChip input param"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // int pmChipFindCell(const pmChip *chip, const char *name) + { + psMemId id = psMemGetId(); + // Generate the pmChip heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + int rc = pmChipFindCell(chip, NULL); + ok(-1 == rc, "pmChipFindCell() returns -1 with NULL name input param"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // int pmChipFindCell(const pmChip *chip, const char *name) + { + psMemId id = psMemGetId(); + // Generate the pmChip heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + // Set unique cell names + for (int cellID = 0 ; cellID < chip->cells->n ; cellID++) { + pmCell *cell = chip->cells->data[cellID]; + char tmpName[100]; + sprintf(tmpName, "cell-%d", cellID); + psMetadataAddStr(cell->concepts, PS_LIST_TAIL, "CELL.NAME", PS_META_REPLACE, NULL, tmpName); + } + + // Verify that pmChipFindCell() finds those cells correctly + for (int cellID = 0 ; cellID < chip->cells->n ; cellID++) { + char tmpName[100]; + sprintf(tmpName, "cell-%d", cellID); + int rc = pmChipFindCell(chip, tmpName); + ok(rc == cellID, "pmChipFindCell() correctly found cell %s (%d)", tmpName, rc); + } + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + +} Index: /trunk/psModules/test/camera/tap_pmFPAView.c =================================================================== --- /trunk/psModules/test/camera/tap_pmFPAView.c (revision 14882) +++ /trunk/psModules/test/camera/tap_pmFPAView.c (revision 14882) @@ -0,0 +1,989 @@ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" +// XXX: pmFPAviewThisHDU(): some problems with NULL pmHDUs +// XXX: must test: pmFPAviewThisHDU(), pmFPAviewThisPHU() +// XXX: must test: pmFPAviewThisPHU() + +#define ERR_TRACE_LEVEL 0 +#define CHIP_ALLOC_NAME "ChipName" +#define CELL_ALLOC_NAME "CellName" +#define MISC_NUM 32 +#define MISC_NAME "META00" +#define MISC_NAME2 "META01" +#define NUM_BIAS_DATA 10 +#define TEST_NUM_ROWS 4 +#define TEST_NUM_COLS 4 +#define NUM_READOUTS 3 +#define NUM_CELLS 10 +#define NUM_CHIPS 8 +#define NUM_HDUS 5 +#define BASE_IMAGE 10 +#define BASE_MASK 40 +#define BASE_WEIGHT 70 +#define VERBOSE 0 +#define ERR_TRACE_LEVEL 0 + +psPlaneTransform *PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM() +{ + psPlaneTransform *pt = psPlaneTransformAlloc(1, 1); + pt->x->coeff[1][0] = 1.0; + pt->y->coeff[0][1] = 1.0; + return(pt); +} + +psPlaneDistort *PS_CREATE_4D_IDENTITY_PLANE_DISTORT() +{ + psPlaneDistort *pd = psPlaneDistortAlloc(1, 1, 1, 1); + pd->x->coeff[1][0][0][0] = 1.0; + pd->y->coeff[0][1][0][0] = 1.0; + return(pd); +} + +/****************************************************************************** +generateSimpleReadout(): This function generates a pmReadout data structure and then +populates its members with real data. + *****************************************************************************/ +pmReadout *generateSimpleReadout(pmCell *cell) +{ + pmReadout *readout = pmReadoutAlloc(cell); + readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8); + readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) { + psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(tmpImage, (double) i); + psListAdd(readout->bias, PS_LIST_HEAD, tmpImage); + psFree(tmpImage); + } + psMetadataAddS32(readout->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + return(readout); +} + +/****************************************************************************** +generateSimpleCell(): This function generates a pmCell data structure and then +populates its members with real data. + *****************************************************************************/ +pmCell *generateSimpleCell(pmChip *chip) +{ + pmCell *cell = pmCellAlloc(chip, CELL_ALLOC_NAME); + + psMetadataAddS32(cell->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(cell->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psArrayRealloc(cell->readouts, NUM_READOUTS); + cell->hdu = pmHDUAlloc("cellExtName"); + for (int i = 0 ; i < NUM_READOUTS ; i++) { + cell->readouts->data[i] = generateSimpleReadout(cell); + } + + bool rc = pmConfigFileRead(&cell->hdu->format, "data/camera0/format0.config", "Camera format 0"); + if (!rc) { + diag("pmConfigFileRead() was unsuccessful (from generateSimpleCell())"); + } + + cell->hdu->images = psArrayAlloc(NUM_HDUS); + cell->hdu->masks = psArrayAlloc(NUM_HDUS); + cell->hdu->weights = psArrayAlloc(NUM_HDUS); + for (int k = 0 ; k < NUM_HDUS ; k++) { + cell->hdu->images->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + cell->hdu->masks->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK); + cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k)); + psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k)); + psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k)); + } + + //XXX: Should the region be set some other way? Like through the various config files? +// psRegion *region = psRegionAlloc(0.0, TEST_NUM_COLS-1, 0.0, TEST_NUM_ROWS-1); + psRegion *region = psRegionAlloc(0.0, 0.0, 0.0, 0.0); + // You shouldn't have to remove the key from the metadata. Find out how to simply change the key value. + psMetadataRemoveKey(cell->concepts, "CELL.TRIMSEC"); + psMetadataAddPtr(cell->concepts, PS_LIST_TAIL|PS_META_REPLACE, "CELL.TRIMSEC", PS_DATA_REGION, "I am a region", region); + psFree(region); + return(cell); +} + +/****************************************************************************** +generateSimpleChip(): This function generates a pmChip data structure and then +populates its members with real data. + *****************************************************************************/ +pmChip *generateSimpleChip(pmFPA *fpa) +{ + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + chip->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + chip->fromFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + psMetadataAddS32(chip->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(chip->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + + if (1) { + chip->hdu = pmHDUAlloc("chipExtName"); +// bool rc = pmConfigFileRead(&chip->hdu->format, "data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleChip())"); +// } + } + + psArrayRealloc(chip->cells, NUM_CELLS); + for (int i = 0 ; i < NUM_CELLS ; i++) { + chip->cells->data[i] = generateSimpleCell(chip); + } + + // XXX: Add code to initialize chip pmConcepts + + + return(chip); +} + +/****************************************************************************** +generateSimpleFPA(): This function generates a pmFPA data structure and then +populates its members with real data. + *****************************************************************************/ +pmFPA* generateSimpleFPA(psMetadata *camera) +{ + pmFPA* fpa = pmFPAAlloc(camera); + fpa->fromTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toSky = psProjectionAlloc(0.0,0.0,10.0,10.0,PS_PROJ_TAN); + psMetadataAddS32(fpa->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32((psMetadata *) fpa->camera, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(fpa->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + + if (1) { + fpa->hdu = pmHDUAlloc("fpaExtName"); + bool rc = pmConfigFileRead(&fpa->hdu->format, "data/camera0/format0.config", "Camera format 0"); + if (!rc) { + diag("pmConfigFileRead() was unsuccessful (from generateSimpleFPA())"); + } + } + + psArrayRealloc(fpa->chips, NUM_CHIPS); + for (int i = 0 ; i < NUM_CHIPS ; i++) { + fpa->chips->data[i] = generateSimpleChip(fpa); + } + + // XXX: Eventually, when you finish the pmConcepts tests, add full concept + // reading code from wherever. + pmConceptsBlankFPA(fpa); +// bool mdok; +// psMetadata *fileData = psMetadataLookupMetadata(&mdok, fpa->hdu->format, "FILE"); +// char *fpaNameHdr = psMetadataLookupStr(&mdok, fileData, "FPA.NAME"); +// psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.NAME", PS_META_REPLACE, NULL, fpaNameHdr); + + return(fpa); +} + +// XXX: This should only be necessary until the psFree() functions for +// FPA/chip/cell/readout correctly free all child chips/cells/readouts +void myFreeCell(pmCell *cell) +{ + for (int k = 0 ; k < cell->readouts->n ; k++) { + psFree(cell->readouts->data[k]); + } + psFree(cell); +} + +void myFreeChip(pmChip *chip) { + for (int j = 0 ; j < chip->cells->n ; j++) { + myFreeCell(chip->cells->data[j]); + } + psFree(chip); +} + +void myFreeFPA(pmFPA *fpa) +{ + for (int i = 0 ; i < fpa->chips->n ; i++) { + myFreeChip(fpa->chips->data[i]); + } + psFree(fpa); +} + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(137); + + // ---------------------------------------------------------------------- + // pmFPAViewAlloc() tests + // XXX: Add memCheckPtr() tests + { + psMemId id = psMemGetId(); + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(tmpView != NULL, "pmFPAviewAlloc() returned non-NULL"); + ok(tmpView->nRows == 32, "pmFPAviewAlloc() set ->nRows properly"); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmFPAViewReset() tests: NULL input + { + psMemId id = psMemGetId(); + ok(!pmFPAviewReset(NULL), "pmFPAviewReset() returned FALSE with NULL input"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // pmFPAViewReset() tests: acceptable input + { + psMemId id = psMemGetId(); + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(tmpView != NULL, "pmFPAviewAlloc() returned non-NULL"); + tmpView->chip = 16; + tmpView->cell = 16; + tmpView->readout = 16; + tmpView->iRows = 16; + ok(pmFPAviewReset(tmpView), "pmFPAviewReset() returned TRUE"); + ok(tmpView->chip == -1, "pmFPAviewReset() set tmpView->chip to -1"); + ok(tmpView->cell == -1, "pmFPAviewReset() set tmpView->cell to -1"); + ok(tmpView->readout == -1, "pmFPAviewReset() set tmpView->readout to 0"); + ok(tmpView->iRows == 0, "pmFPAviewReset() set tmpView->iRows to 0"); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmFPAViewForLevel() tests: NULL input + // pmFPAview *pmFPAviewForLevel(pmFPALevel level, const pmFPAview *input) + + { + psMemId id = psMemGetId(); + ok(!pmFPAviewForLevel(PM_FPA_LEVEL_FPA, NULL), "pmFPAviewForLevel() returned FALSE with NULL input"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAViewForLevel() tests: acceptable input + { + psMemId id = psMemGetId(); + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(tmpView != NULL, "pmFPAviewAlloc() returned non-NULL"); + tmpView->chip = 16; + tmpView->cell = 16; + tmpView->readout = 16; + tmpView->iRows = 16; + + pmFPAview *newView = pmFPAviewForLevel(PM_FPA_LEVEL_FPA, tmpView); + ok(newView, "pmFPAviewReset(PM_FPA_LEVEL_FPA) returned non-NULL"); + ok(newView->chip == -1, "pmFPAviewReset() set tmpView->chip to -1"); + psFree(newView); + + newView = pmFPAviewForLevel(PM_FPA_LEVEL_CHIP, tmpView); + ok(newView, "pmFPAviewReset(PM_FPA_LEVEL_CHIP) returned non-NULL"); + ok(newView->cell == -1, "pmFPAviewReset() set tmpView->cell to -1"); + psFree(newView); + + newView = pmFPAviewForLevel(PM_FPA_LEVEL_CELL, tmpView); + ok(newView, "pmFPAviewReset(PM_FPA_LEVEL_CELL) returned non-NULL"); + ok(newView->readout == -1, "pmFPAviewReset() set tmpView->readout to 0"); + psFree(newView); + + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmFPAViewLevel() tests: NULL input + // pmFPALevel pmFPAviewLevel(const pmFPAview *view) + { + psMemId id = psMemGetId(); + ok(!pmFPAviewLevel(NULL), "pmFPAviewLevel() returned NULL with NULL input"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAViewLevel() tests: acceptable input + { + psMemId id = psMemGetId(); + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(tmpView != NULL, "pmFPAviewAlloc() returned non-NULL"); + tmpView->chip = 16; + tmpView->cell = 16; + tmpView->readout = 16; + tmpView->iRows = 16; + + tmpView->chip = -1; + ok(PM_FPA_LEVEL_FPA == pmFPAviewLevel(tmpView), "pmFPAviewReset() returned PM_FPA_LEVEL_FPA"); + tmpView->chip = 16; + + tmpView->cell = -1; + ok(PM_FPA_LEVEL_CHIP == pmFPAviewLevel(tmpView), "pmFPAviewReset() returned PM_FPA_LEVEL_CHIP"); + tmpView->cell = 16; + + tmpView->readout = -1; + ok(PM_FPA_LEVEL_CELL == pmFPAviewLevel(tmpView), "pmFPAviewReset() returned PM_FPA_LEVEL_CELL"); + tmpView->readout = 16; + + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + // ---------------------------------------------------------------------- + // pmFPAviewThisChip() tests: NULL view input + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + ok(NULL == pmFPAviewThisChip(NULL, fpa), "pmFPAviewThisChip(NULL, fpa) returned NULL"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAviewThisChip() tests: NULL pmFPA input + { + psMemId id = psMemGetId(); + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(NULL == pmFPAviewThisChip(tmpView, NULL), "pmFPAviewThisChip(pmFPAView, NULL) returned NULL"); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAviewThisChip() tests: NULL fpa->chips input + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + psArray *chips = fpa->chips; + fpa->chips = NULL; + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(NULL == pmFPAviewThisChip(tmpView, fpa), "pmFPAviewThisChip(pmFPAView, fpa) returned NULL view input"); + fpa->chips = chips; + myFreeFPA(fpa); + psFree(camera); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // pmFPAviewThisChip() tests: acceptable input + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmFPAview *tmpView = pmFPAviewAlloc(32); + + // Test with tmpView->chip too low + tmpView->chip = -1; + ok(NULL == pmFPAviewThisChip(tmpView, fpa), "pmFPAviewThisChip(pmFPAView, fpa) returned NULL with pmFPAView->chip == -1"); + + // Test with tmpView->chip too high + tmpView->chip = fpa->chips->n; + ok(NULL == pmFPAviewThisChip(tmpView, fpa), "pmFPAviewThisChip(pmFPAView, fpa) returned NULL with pmFPAView->chip larger than the number of chips"); + + // Test with various tmpView->chip + bool errorFlag = false; + for (int i = 0 ; i < NUM_CHIPS ; i++) { + tmpView->chip = i; + pmChip *tmpChip = pmFPAviewThisChip(tmpView, fpa); + if (!tmpChip || tmpChip != fpa->chips->data[i]) { + diag("ERROR: pmFPAviewThisChip() returned the incorrect chip (%d)", i); + errorFlag = true; + } + } + ok(!errorFlag, "pmFPAviewThisChip() returned the correct pmChip for all tests"); + myFreeFPA(fpa); + psFree(camera); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + // ---------------------------------------------------------------------- + // pmFPAviewNextChip() tests: NULL view input + // pmChip *pmFPAviewNextChip(pmFPAview *view, const pmFPA *fpa, int nStep) + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + ok(NULL == pmFPAviewNextChip(NULL, fpa, 0), "pmFPAviewNextChip(NULL, fpa, 0) returned NULL"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAviewNextChip() tests: NULL pmFPA input + { + psMemId id = psMemGetId(); + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(NULL == pmFPAviewNextChip(tmpView, NULL, 0), "pmFPAviewNextChip(pmFPAView, NULL, 0) returned NULL"); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAviewNextChip() tests: acceptable input + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmFPAview *tmpView = pmFPAviewAlloc(32); + + // Test with tmpView->chip too low + // XXX: Source code is wrong: must guard against input tmpView->chip = -1 + tmpView->chip = -1; + ok(NULL == pmFPAviewNextChip(tmpView, fpa, 0), "pmFPAviewNextChip(pmFPAView, fpa, 0) returned NULL with pmFPAView->chip == -1"); + + // Test with tmpView->chip too high + tmpView->chip = fpa->chips->n; + ok(NULL == pmFPAviewNextChip(tmpView, fpa, 0), "pmFPAviewNextChip(pmFPAView, fpa, 0) returned NULL with pmFPAView->chip larger than the number of chips"); + + // Test with various tmpView->chip, step = 0 + bool errorFlag = false; + for (int i = 0 ; i < NUM_CHIPS ; i++) { + tmpView->chip = i; + pmChip *tmpChip = pmFPAviewNextChip(tmpView, fpa, 0); + if (!tmpChip || tmpChip != fpa->chips->data[i]) { + diag("ERROR: pmFPAviewNextChip() returned the incorrect chip (%d)", i); + errorFlag = true; + } + } + ok(!errorFlag, "pmFPAviewNextChip() returned the correct pmChip for all tests (step = 0)"); + + // Test with various tmpView->chip, step = 1 + errorFlag = false; + for (int i = 0 ; i < NUM_CHIPS-1 ; i++) { + tmpView->chip = i; + pmChip *tmpChip = pmFPAviewNextChip(tmpView, fpa, 1); + if (!tmpChip || tmpChip != fpa->chips->data[i+1]) { + diag("ERROR: pmFPAviewNextChip() returned the incorrect chip (%d)", i); + errorFlag = true; + } + } + ok(!errorFlag, "pmFPAviewNextChip() returned the correct pmChip for all tests (step = 1)"); + + myFreeFPA(fpa); + psFree(camera); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmFPAviewThisCell() tests: NULL view input + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + ok(NULL == pmFPAviewThisCell(NULL, fpa), "pmFPAviewThisCell(NULL, fpa) returned NULL"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAviewThisCell() tests: NULL pmFPA input + { + psMemId id = psMemGetId(); + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(NULL == pmFPAviewThisCell(tmpView, NULL), "pmFPAviewThisCell(pmFPAView, NULL) returned NULL"); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAviewThisCell() tests: NULL fpa->chips input + // XXX: Skipping because the source code does not guard against this + if (0) { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + psArray *chips = fpa->chips; + fpa->chips = NULL; + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(NULL == pmFPAviewThisCell(tmpView, fpa), "pmFPAviewThisCell(pmFPAView, fpa) returned NULL view input"); + fpa->chips = chips; + myFreeFPA(fpa); + psFree(camera); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // pmFPAviewThisCell() tests: acceptable input + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmFPAview *tmpView = pmFPAviewAlloc(32); + + // Test with tmpView->chip too low + tmpView->chip = -1; + ok(NULL == pmFPAviewThisCell(tmpView, fpa), "pmFPAviewThisCell(pmFPAView, fpa) returned NULL with pmFPAView->chip == -1"); + + // Test with tmpView->chip too high + tmpView->chip = fpa->chips->n; + ok(NULL == pmFPAviewThisCell(tmpView, fpa), "pmFPAviewThisCell(pmFPAView, fpa) returned NULL with pmFPAView->chip larger than the number of chips"); + + // Test with various tmpView->chip + bool errorFlag = false; + for (int i = 0 ; i < NUM_CHIPS ; i++) { + pmChip *chip = fpa->chips->data[i]; + for (int j = 0 ; j < NUM_CELLS ; j++) { + tmpView->chip = i; + tmpView->cell = j; + pmCell *tmpCell = pmFPAviewThisCell(tmpView, fpa); + if (!tmpCell || tmpCell != chip->cells->data[j]) { + diag("ERROR: pmFPAviewThisCell() returned the incorrect chip/cell (%d, %d)", i, j); + errorFlag = true; + } + + } + } + ok(!errorFlag, "pmFPAviewThisCell() returned the correct pmCell for all tests"); + myFreeFPA(fpa); + psFree(camera); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + // ---------------------------------------------------------------------- + // pmFPAviewNextCell() tests: NULL view input + // pmChip *pmFPAviewNextCell(pmFPAview *view, const pmFPA *fpa, int nStep) + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + ok(NULL == pmFPAviewNextCell(NULL, fpa, 0), "pmFPAviewNextCell(NULL, fpa, 0) returned NULL"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAviewNextCell() tests: NULL pmFPA input + { + psMemId id = psMemGetId(); + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(NULL == pmFPAviewNextCell(tmpView, NULL, 0), "pmFPAviewNextCell(pmFPAView, NULL, 0) returned NULL"); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAviewNextCell() tests: acceptable input + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmFPAview *tmpView = pmFPAviewAlloc(32); + + // Test with tmpView->chip too low + tmpView->chip = -1; + ok(NULL == pmFPAviewNextCell(tmpView, fpa, 0), "pmFPAviewNextCell(pmFPAView, fpa) returned NULL with pmFPAView->chip == -1"); + + // Test with tmpView->chip too high + tmpView->chip = fpa->chips->n; + ok(NULL == pmFPAviewNextCell(tmpView, fpa, 0), "pmFPAviewNextCell(pmFPAView, fpa) returned NULL with pmFPAView->chip larger than the number of chips"); + + // Test with various tmpView->chip (step = 0) + bool errorFlag = false; + for (int i = 0 ; i < NUM_CHIPS ; i++) { + pmChip *chip = fpa->chips->data[i]; + for (int j = 0 ; j < NUM_CELLS ; j++) { + tmpView->chip = i; + tmpView->cell = j; + pmCell *tmpCell = pmFPAviewNextCell(tmpView, fpa, 0); + if (!tmpCell || tmpCell != chip->cells->data[j]) { + diag("ERROR: pmFPAviewNextCell() returned the incorrect chip/cell (%d, %d)", i, j); + errorFlag = true; + } + + } + } + ok(!errorFlag, "pmFPAviewNextCell() returned the correct pmCell for all tests (step = 0)"); + + // Test with various tmpView->chip (step = 1) + errorFlag = false; + for (int i = 0 ; i < NUM_CHIPS ; i++) { + pmChip *chip = fpa->chips->data[i]; + for (int j = 0 ; j < NUM_CELLS-1 ; j++) { + tmpView->chip = i; + tmpView->cell = j; + pmCell *tmpCell = pmFPAviewNextCell(tmpView, fpa, 1); + if (!tmpCell || tmpCell != chip->cells->data[j+1]) { + diag("ERROR: pmFPAviewNextCell() returned the incorrect chip/cell (%d, %d)", i, j); + errorFlag = true; + } + + } + } + ok(!errorFlag, "pmFPAviewNextCell() returned the correct pmCell for all tests (step = 1)"); + + myFreeFPA(fpa); + psFree(camera); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + // ---------------------------------------------------------------------- + // pmFPAviewThisReadout() tests: NULL view input + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + ok(NULL == pmFPAviewThisReadout(NULL, fpa), "pmFPAviewThisReadout(NULL, fpa) returned NULL"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAviewThisReadout() tests: NULL pmFPA input + { + psMemId id = psMemGetId(); + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(NULL == pmFPAviewThisReadout(tmpView, NULL), "pmFPAviewThisReadout(pmFPAView, NULL) returned NULL"); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAviewThisReadout() tests: NULL fpa->chips input + // XXX: Skipping because the source code does not guard against this + if (0) { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + psArray *chips = fpa->chips; + fpa->chips = NULL; + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(NULL == pmFPAviewThisReadout(tmpView, fpa), "pmFPAviewThisReadout(pmFPAView, fpa) returned NULL view input"); + fpa->chips = chips; + myFreeFPA(fpa); + psFree(camera); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // pmFPAviewThisReadout() tests: acceptable input + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmFPAview *tmpView = pmFPAviewAlloc(32); + + // Test with tmpView->chip too low + tmpView->chip = -1; + ok(NULL == pmFPAviewThisReadout(tmpView, fpa), "pmFPAviewThisReadout(pmFPAView, fpa) returned NULL with pmFPAView->chip == -1"); + + // Test with tmpView->chip too high + tmpView->chip = fpa->chips->n; + ok(NULL == pmFPAviewThisReadout(tmpView, fpa), "pmFPAviewThisReadout(pmFPAView, fpa) returned NULL with pmFPAView->chip larger than the number of chips"); + + // Test with various tmpView->chip + bool errorFlag = false; + for (int i = 0 ; i < NUM_CHIPS ; i++) { + pmChip *chip = fpa->chips->data[i]; + for (int j = 0 ; j < NUM_CELLS ; j++) { + pmCell *cell = chip->cells->data[j]; + for (int k = 0 ; k < NUM_READOUTS ; k++) { + tmpView->chip = i; + tmpView->cell = j; + tmpView->readout = k; + pmReadout *tmpReadout = pmFPAviewThisReadout(tmpView, fpa); + if (!tmpReadout || tmpReadout != cell->readouts->data[k]) { + diag("ERROR: pmFPAviewThisReadout() returned the incorrect chip/cell/readout (%d, %d, %d)", i, j, k); + errorFlag = true; + } + } + } + } + ok(!errorFlag, "pmFPAviewThisReadout() returned the correct pmCell for all tests"); + + myFreeFPA(fpa); + psFree(camera); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmFPAviewNextReadout() tests: NULL view input + // pmChip *pmFPAviewNextReadout(pmFPAview *view, const pmFPA *fpa, int nStep) + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + ok(NULL == pmFPAviewNextReadout(NULL, fpa, 0), "pmFPAviewNextReadout(NULL, fpa, 0) returned NULL"); + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmFPAviewNextReadout() tests: NULL pmFPA input + { + psMemId id = psMemGetId(); + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(NULL == pmFPAviewNextReadout(tmpView, NULL, 0), "pmFPAviewNextReadout(pmFPAView, NULL, 0) returned NULL"); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // pmFPAviewNextReadout() tests: acceptable input + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmFPAview *tmpView = pmFPAviewAlloc(32); + + // Test with tmpView->chip too low + tmpView->chip = -1; + ok(NULL == pmFPAviewNextReadout(tmpView, fpa, 0), "pmFPAviewNextReadout(pmFPAView, fpa) returned NULL with pmFPAView->chip == -1"); + + // Test with tmpView->chip too high + tmpView->chip = fpa->chips->n; + ok(NULL == pmFPAviewNextReadout(tmpView, fpa, 0), "pmFPAviewNextReadout(pmFPAView, fpa) returned NULL with pmFPAView->chip larger than the number of chips"); + + // Test with various tmpView->chip (step = 0) + bool errorFlag = false; + for (int i = 0 ; i < NUM_CHIPS ; i++) { + pmChip *chip = fpa->chips->data[i]; + for (int j = 0 ; j < NUM_CELLS ; j++) { + pmCell *cell = chip->cells->data[j]; + for (int k = 0 ; k < NUM_READOUTS ; k++) { + tmpView->chip = i; + tmpView->cell = j; + tmpView->readout = k; + pmReadout *tmpReadout = pmFPAviewNextReadout(tmpView, fpa, 0); + if (!tmpReadout || tmpReadout != cell->readouts->data[k]) { + diag("ERROR: pmFPAviewNextReadout() returned the incorrect chip/cell/readout (%d, %d, %d)", i, j, k); + errorFlag = true; + } + } + } + } + ok(!errorFlag, "pmFPAviewNextReadout() returned the correct pmCell for all tests (step = 0)"); + + // Test with various tmpView->chip (step = 1) + errorFlag = false; + for (int i = 0 ; i < NUM_CHIPS ; i++) { + pmChip *chip = fpa->chips->data[i]; + for (int j = 0 ; j < NUM_CELLS ; j++) { + pmCell *cell = chip->cells->data[j]; + for (int k = 0 ; k < NUM_READOUTS-1 ; k++) { + tmpView->chip = i; + tmpView->cell = j; + tmpView->readout = k; + pmReadout *tmpReadout = pmFPAviewNextReadout(tmpView, fpa, 1); + if (!tmpReadout || tmpReadout != cell->readouts->data[k+1]) { + diag("ERROR: pmFPAviewNextReadout() returned the incorrect chip/cell/readout (%d, %d, %d)", i, j, k); + errorFlag = true; + } + } + } + } + ok(!errorFlag, "pmFPAviewNextReadout() returned the correct pmCell for all tests (step = 1)"); + + myFreeFPA(fpa); + psFree(camera); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmFPAviewThisHDU() tests: NULL view input + // pmHDU *pmFPAviewThisHDU(const pmFPAview *view, const pmFPA *fpa) + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + ok(NULL == pmFPAviewThisHDU(NULL, fpa), "pmFPAviewThisHDU(NULL, fpa) returned NULL"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // pmFPAviewThisHDU() tests: NULL pmFPA input + // pmHDU *pmFPAviewThisHDU(const pmFPAview *view, const pmFPA *fpa) + { + psMemId id = psMemGetId(); + pmFPAview *tmpView = pmFPAviewAlloc(32); + ok(NULL == pmFPAviewThisHDU(tmpView, NULL), "pmFPAviewThisHDU(pmFPAView, NULL) returned NULL"); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + // pmFPAviewThisHDU() tests: acceptable input + // pmHDU *pmFPAviewThisHDU(const pmFPAview *view, const pmFPA *fpa) + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmFPAview *tmpView = pmFPAviewAlloc(32); + + tmpView->chip = -1; + pmHDU *hdu = pmFPAviewThisHDU(tmpView, fpa); + ok(hdu, "pmFPAviewThisHDU() returned non-NULL with tmpView->chip = -1"); + ok(hdu == pmHDUFromFPA(fpa), "pmFPAviewThisHDU() returned the correct HDU"); + tmpView->chip = 16; + + // XXX: These tests fail because the pmHDU functions are returning NULL. Why? + tmpView->cell = -1; + hdu = pmFPAviewThisHDU(tmpView, fpa); + ok(hdu, "pmFPAviewThisHDU() returned non-NULL with tmpView->cell = -1"); + ok(hdu == pmHDUFromChip(pmFPAviewThisChip(tmpView, fpa)), "pmFPAviewThisHDU() returned the correct HDU"); + tmpView->cell = 16; + + tmpView->readout = -1; + hdu = pmFPAviewThisHDU(tmpView, fpa); + ok(hdu, "pmFPAviewThisHDU() returned non-NULL with tmpView->readout = -1"); + ok(hdu == pmHDUFromCell(pmFPAviewThisCell(tmpView, fpa)), "pmFPAviewThisHDU() returned the correct HDU"); + tmpView->readout = 16; + + hdu = pmFPAviewThisHDU(tmpView, fpa); + ok(hdu, "pmFPAviewThisHDU() returned non-NULL"); + ok(hdu == pmHDUFromReadout(pmFPAviewThisReadout(tmpView, fpa)), "pmFPAviewThisHDU() returned the correct HDU"); + + myFreeFPA(fpa); + psFree(camera); + psFree(tmpView); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } +} Index: /trunk/psModules/test/camera/tap_pmHDUUtils.c =================================================================== --- /trunk/psModules/test/camera/tap_pmHDUUtils.c (revision 14882) +++ /trunk/psModules/test/camera/tap_pmHDUUtils.c (revision 14882) @@ -0,0 +1,525 @@ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" +// XXX: Use better name for the temporary FITS file +// XXX: The code to generate and free the FPA hierarchy was copied from +// tap-pmFPA.c. EIther include it directly, or library, or something. +// Also, get rid of the manual free functions and use psFree() once +// it correctly frees child members +// XXX: This simpleFPA() requires that the HDUs be allocated. + + +#define CHIP_ALLOC_NAME "ChipName" +#define CELL_ALLOC_NAME "CellName" +#define MISC_NUM 32 +#define MISC_NAME "META00" +#define MISC_NAME2 "META01" +#define NUM_BIAS_DATA 10 +#define TEST_NUM_ROWS 4 +#define TEST_NUM_COLS 4 +#define NUM_READOUTS 3 +#define NUM_CELLS 10 +#define NUM_CHIPS 8 +#define NUM_HDUS 5 +#define BASE_IMAGE 10 +#define BASE_MASK 40 +#define BASE_WEIGHT 70 +#define VERBOSE 0 +#define ERR_TRACE_LEVEL 0 + +psPlaneTransform *PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM() +{ + psPlaneTransform *pt = psPlaneTransformAlloc(1, 1); + pt->x->coeff[1][0] = 1.0; + pt->y->coeff[0][1] = 1.0; + return(pt); +} + +psPlaneDistort *PS_CREATE_4D_IDENTITY_PLANE_DISTORT() +{ + psPlaneDistort *pd = psPlaneDistortAlloc(1, 1, 1, 1); + pd->x->coeff[1][0][0][0] = 1.0; + pd->y->coeff[0][1][0][0] = 1.0; + return(pd); +} + +/****************************************************************************** +generateSimpleReadout(): This function generates a pmReadout data structure and then +populates its members with real data. + *****************************************************************************/ +pmReadout *generateSimpleReadout(pmCell *cell) +{ + pmReadout *readout = pmReadoutAlloc(cell); + readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8); + readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) { + psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(tmpImage, (double) i); + psListAdd(readout->bias, PS_LIST_HEAD, tmpImage); + psFree(tmpImage); + } + psMetadataAddS32(readout->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + return(readout); +} + +/****************************************************************************** +generateSimpleCell(): This function generates a pmCell data structure and then +populates its members with real data. + *****************************************************************************/ +pmCell *generateSimpleCell(pmChip *chip) +{ + pmCell *cell = pmCellAlloc(chip, CELL_ALLOC_NAME); + + psMetadataAddS32(cell->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(cell->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psArrayRealloc(cell->readouts, NUM_READOUTS); + cell->hdu = pmHDUAlloc("cellExtName"); + for (int i = 0 ; i < NUM_READOUTS ; i++) { + cell->readouts->data[i] = generateSimpleReadout(cell); + } + + bool rc = pmConfigFileRead(&cell->hdu->format, "data/camera0/format0.config", "Camera format 0"); + if (!rc) { + diag("pmConfigFileRead() was unsuccessful (from generateSimpleCell())"); + } + + cell->hdu->images = psArrayAlloc(NUM_HDUS); + cell->hdu->masks = psArrayAlloc(NUM_HDUS); + cell->hdu->weights = psArrayAlloc(NUM_HDUS); + for (int k = 0 ; k < NUM_HDUS ; k++) { + cell->hdu->images->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + cell->hdu->masks->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK); + cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k)); + psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k)); + psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k)); + } + + //XXX: Should the region be set some other way? Like through the various config files? +// psRegion *region = psRegionAlloc(0.0, TEST_NUM_COLS-1, 0.0, TEST_NUM_ROWS-1); + psRegion *region = psRegionAlloc(0.0, 0.0, 0.0, 0.0); + // You shouldn't have to remove the key from the metadata. Find out how to simply change the key value. + psMetadataRemoveKey(cell->concepts, "CELL.TRIMSEC"); + psMetadataAddPtr(cell->concepts, PS_LIST_TAIL|PS_META_REPLACE, "CELL.TRIMSEC", PS_DATA_REGION, "I am a region", region); + psFree(region); + return(cell); +} + +/****************************************************************************** +generateSimpleChip(): This function generates a pmChip data structure and then +populates its members with real data. + *****************************************************************************/ +pmChip *generateSimpleChip(pmFPA *fpa) +{ + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + chip->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + chip->fromFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + psMetadataAddS32(chip->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(chip->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + chip->hdu = pmHDUAlloc("chipExtName"); + + bool rc = pmConfigFileRead(&chip->hdu->format, "data/camera0/format0.config", "Camera format 0"); + if (!rc) { + diag("pmConfigFileRead() was unsuccessful (from generateSimpleChip())"); + } + + psArrayRealloc(chip->cells, NUM_CELLS); + for (int i = 0 ; i < NUM_CELLS ; i++) { + chip->cells->data[i] = generateSimpleCell(chip); + } + + // XXX: Add code to initialize chip pmConcepts + + + return(chip); +} + +/****************************************************************************** +generateSimpleFPA(): This function generates a pmFPA data structure and then +populates its members with real data. + *****************************************************************************/ +pmFPA* generateSimpleFPA(psMetadata *camera) +{ + pmFPA* fpa = pmFPAAlloc(camera); + fpa->fromTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toSky = psProjectionAlloc(0.0,0.0,10.0,10.0,PS_PROJ_TAN); + psMetadataAddS32(fpa->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32((psMetadata *) fpa->camera, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(fpa->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + fpa->hdu = pmHDUAlloc("fpaExtName"); + + bool rc = pmConfigFileRead(&fpa->hdu->format, "data/camera0/format0.config", "Camera format 0"); + if (!rc) { + diag("pmConfigFileRead() was unsuccessful (from generateSimpleFPA())"); + } + + psArrayRealloc(fpa->chips, NUM_CHIPS); + for (int i = 0 ; i < NUM_CHIPS ; i++) { + fpa->chips->data[i] = generateSimpleChip(fpa); + } + + // XXX: Eventually, when you finish the pmConcepts tests, add full concept + // reading code from wherever. + pmConceptsBlankFPA(fpa); +// bool mdok; +// psMetadata *fileData = psMetadataLookupMetadata(&mdok, fpa->hdu->format, "FILE"); +// char *fpaNameHdr = psMetadataLookupStr(&mdok, fileData, "FPA.NAME"); +// psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.NAME", PS_META_REPLACE, NULL, fpaNameHdr); + + return(fpa); +} + +// XXX: This should only be necessary until the psFree() functions for +// FPA/chip/cell/readout correctly free all child chips/cells/readouts +void myFreeCell(pmCell *cell) +{ + for (int k = 0 ; k < cell->readouts->n ; k++) { + psFree(cell->readouts->data[k]); + } + psFree(cell); +} + +void myFreeChip(pmChip *chip) { + for (int j = 0 ; j < chip->cells->n ; j++) { + myFreeCell(chip->cells->data[j]); + } + psFree(chip); +} + +void myFreeFPA(pmFPA *fpa) +{ + for (int i = 0 ; i < fpa->chips->n ; i++) { + myFreeChip(fpa->chips->data[i]); + } + psFree(fpa); +} + + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(73); + + // ---------------------------------------------------------------------- + // pmHDU *pmHDUFromFPA(const pmFPA *fpa) + // pmHDUFromFPA() tests + // pmHDUFromFPA() verify with NULL input params + { + psMemId id = psMemGetId(); + pmHDU *hdu = pmHDUFromFPA(NULL); + ok(hdu == NULL, "pmHDUFromFPA(NULL) returned NULL"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + //pmHDUFromFPA() verify with acceptable input params + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmHDU *hdu = pmHDUFromFPA(fpa); + ok(hdu == fpa->hdu, "pmHDUFromFPA(NULL) returned the correct pmHDU of an pmFPA struct"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmHDU *pmHDUFromChip(const pmChip *chip) + // pmHDUFromChip() tests + // pmHDUFromChip() verify with NULL input params + { + psMemId id = psMemGetId(); + pmHDU *hdu = pmHDUFromChip(NULL); + ok(hdu == NULL, "pmHDUFromChip(NULL) returned NULL"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + //pmHDUFromChip() verify with acceptable input params + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmHDU *hdu = pmHDUFromChip(chip); + ok(hdu == chip->hdu, "pmHDUFromChip() returned the correct pmHDU of an pmChip struct"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + //pmHDUFromChip() verify with acceptable input params + // Set chip->hdu to NULL, verify chip->parent->hdu is returned + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + psFree(chip->hdu); + chip->hdu = NULL; + pmHDU *hdu = pmHDUFromChip(chip); + ok(hdu == chip->parent->hdu, "pmHDUFromChip() returned the correct pmHDU of an pmChip struct"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmHDU *pmHDUFromCell(const pmCell *cell) + // pmHDUFromCell() tests + // pmHDUFromCell() verify with NULL input params + { + psMemId id = psMemGetId(); + pmHDU *hdu = pmHDUFromCell(NULL); + ok(hdu == NULL, "pmHDUFromCell(NULL) returned NULL"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + //pmHDUFromCell() verify with acceptable input params + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmHDU *hdu = pmHDUFromCell(cell); + ok(hdu == cell->hdu, "pmHDUFromCell() returned the correct pmHDU of an pmCell struct"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + //pmHDUFromCell() verify with acceptable input params + // Set cell->hdu to NULL, verify cell->parent->hdu is returned + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + psFree(cell->hdu); + cell->hdu = NULL; + pmHDU *hdu = pmHDUFromCell(cell); + ok(hdu == cell->parent->hdu, "pmHDUFromCell() returned the correct pmHDU of an pmCell struct"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + // pmHDU *pmHDUFromReadout(const pmCell *cell) + // pmHDUFromReadout() tests + // pmHDUFromReadout() verify with NULL input params + { + psMemId id = psMemGetId(); + pmHDU *hdu = pmHDUFromReadout(NULL); + ok(hdu == NULL, "pmHDUFromReadout(NULL) returned NULL"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + //pmHDUFromReadout() verify with acceptable input params + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + pmReadout *readout = cell->readouts->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + ok(readout != NULL, "Allocated a pmReadout successfully"); + pmHDU *hdu = pmHDUFromReadout(readout); + ok(hdu == readout->parent->hdu, "pmHDUFromReadout() returned the correct pmHDU of an pmReadout struct"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ---------------------------------------------------------------------- + //pmHDUGetLowest() tests + //pmHDU *pmHDUGetLowest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell) + //pmHDUGetLowest(): verify with all NULL inputs + { + psMemId id = psMemGetId(); + pmHDU *hdu = pmHDUGetLowest(NULL, NULL, NULL); + ok(hdu == NULL, "pmHDUFromReadout(NULL, NULL, NULL)"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + //pmHDUGetLowest() tests + //pmHDU *pmHDUGetLowest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell) + //pmHDUGetLowest(): verify with all acceptable inputs + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmHDU *hdu = pmHDUGetLowest(fpa, chip, cell); + ok(hdu == cell->hdu, "pmHDUGetLowest(fpa, chip, cell)"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + //pmHDUGetLowest() tests + //pmHDU *pmHDUGetLowest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell) + //pmHDUGetLowest(): verify with all (fpa, chip, NULL) inputs + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmHDU *hdu = pmHDUGetLowest(fpa, chip, NULL); + ok(hdu == chip->hdu, "pmHDUGetLowest(fpa, chip, NULL)"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + //pmHDUGetLowest() tests + //pmHDU *pmHDUGetLowest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell) + //pmHDUGetLowest(): verify with all (fpa, NULL, NULL) inputs + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmHDU *hdu = pmHDUGetLowest(fpa, NULL, NULL); + ok(hdu == fpa->hdu, "pmHDUGetLowest(fpa, NULL, NULL)"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + // ---------------------------------------------------------------------- + //pmHDUGetHighest() tests + //pmHDU *pmHDUGetHighest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell) + //pmHDUGetHighest(): verify with all NULL inputs + { + psMemId id = psMemGetId(); + pmHDU *hdu = pmHDUGetHighest(NULL, NULL, NULL); + ok(hdu == NULL, "pmHDUFromReadout(NULL, NULL, NULL)"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + //pmHDUGetHighest() tests + //pmHDU *pmHDUGetHighest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell) + //pmHDUGetHighest(): verify with all acceptable inputs + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmHDU *hdu = pmHDUGetHighest(fpa, chip, cell); + ok(hdu == fpa->hdu, "pmHDUGetHighest(fpa, chip, cell)"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + //pmHDUGetHighest() tests + //pmHDU *pmHDUGetHighest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell) + //pmHDUGetHighest(): verify with (NULL, chip, cell) inputs + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmHDU *hdu = pmHDUGetHighest(NULL, chip, cell); + ok(hdu == chip->hdu, "pmHDUGetHighest(NULL, chip, cell)"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + //pmHDUGetHighest() tests + //pmHDU *pmHDUGetHighest(const pmFPA *fpa, const pmChip *chip, const pmCell *cell) + //pmHDUGetHighest(): verify with (NULL, NULL, cell) inputs + { + psMemId id = psMemGetId(); + // Generate the pmFPA heirarchy + psMetadata *camera = psMetadataAlloc(); + pmFPA* fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + ok(fpa != NULL, "Allocated a pmFPA successfully"); + ok(chip != NULL, "Allocated a pmChip successfully"); + ok(cell != NULL, "Allocated a pmCell successfully"); + pmHDU *hdu = pmHDUGetHighest(NULL, NULL, cell); + ok(hdu == cell->hdu, "pmHDUGetHighest(NULL, NULL, cell)"); + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + +} Index: /trunk/psModules/test/concepts/tap_pmConcepts.c =================================================================== --- /trunk/psModules/test/concepts/tap_pmConcepts.c (revision 14882) +++ /trunk/psModules/test/concepts/tap_pmConcepts.c (revision 14882) @@ -0,0 +1,499 @@ + /** @file tst_pmConcepts.c + * + * @brief Contains the tests for pmConcepts.c: + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-09-18 18:59:30 $ +* pmConceptSpecAlloc() + pmConceptsList() +* pmConceptGetRequired() +* pmConceptSetRequired() + pmConceptRegister() + pmConceptsRead() +* pmConceptsBlankFPA() + pmConceptsReadFPA() + pmConceptsWriteFPA() +* pmConceptsBlankChip() + pmConceptsReadChip() + pmConceptsWriteChip() +* pmConceptsBlankCell() + pmConceptsReadCell() + pmConceptsWriteCell() +* pmConceptsInit() +* pmConceptsDone() + pmFPACopyConcepts() + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" + +#define VERBOSE 0 +#define ERR_TRACE_LEVEL 0 + +psMetadataItem *dummyConceptParser( + const psMetadataItem *concept, + const psMetadataItem *pattern, + pmConceptSource source, + const psMetadata *cameraFormat, + const pmFPA *fpa, + const pmChip *chip, + const pmCell *cell) +{ + if (concept == NULL || + pattern == NULL || + source == PM_CONCEPT_SOURCE_NONE || + cameraFormat == NULL || + fpa == NULL || + chip == NULL || + cell == NULL) { + printf("dummyConceptParser() args are NULL\n"); + } + return(NULL); +} + +// FPA.RA and FPA.DEC +psMetadataItem *dummyConceptFormatter( + const psMetadataItem *concept, + pmConceptSource source, + const psMetadata *cameraFormat, + const pmFPA *fpa, + const pmChip *chip, + const pmCell *cell) +{ + if (concept == NULL || + source == PM_CONCEPT_SOURCE_NONE || + cameraFormat == NULL || + fpa == NULL || + chip == NULL || + cell == NULL) { + printf("dummyConceptFormatter() args are NULL\n"); + } + return(NULL); +} + + +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel(".", ERR_TRACE_LEVEL); + plan_tests(10); + + // -------------------------------------------------------------------- + // Tests for pmConceptSpecAlloc() + // Acceptable input parameters. + { + psMemId id = psMemGetId(); + psMetadataItem *blank = psMetadataItemAlloc("myItem1", PS_DATA_BOOL, "I am a boolean", true); + pmConceptSpec *tmp = pmConceptSpecAlloc(blank, dummyConceptParser, + dummyConceptFormatter, true); + ok(tmp != NULL, "pmConceptSpecAlloc() returned non-NULL"); + skip_start(tmp == NULL, 4, "Skipping tests because pmConceptSpecAlloc() returned NULL"); + ok(tmp->blank == blank, "pmConceptSpecAlloc() set the ->blank member correctly"); + ok(tmp->parse == dummyConceptParser, "pmConceptSpecAlloc() set the ->parse member correctly"); + ok(tmp->format == dummyConceptFormatter, "pmConceptSpecAlloc() set the ->format member correctly"); + ok(tmp->required == true, "pmConceptSpecAlloc() set the ->required member correctly"); + skip_end(); + psFree(tmp); + psFree(blank); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // NULL input parameters. + { + psMemId id = psMemGetId(); + pmConceptSpec *tmp = pmConceptSpecAlloc(NULL, NULL, NULL, false); + ok(tmp != NULL, "pmConceptSpecAlloc() returned non-NULL with NULL inputs"); + psFree(tmp); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // -------------------------------------------------------------------- + // Tests for pmConceptGetRequired() and pmConceptSetRequired() + // Acceptable input parameters. + // We get the "required" for FPA.TELESCOPE, ensure that it is false + // then set it to true, then ensure that it is true. + { + psMemId id = psMemGetId(); + bool tmpBool = pmConceptGetRequired("FPA.TELESCOPE", PM_FPA_LEVEL_FPA); + ok (tmpBool == false, "pmConceptGetRequired() returned true for FPA.TELESCOPE"); + tmpBool = pmConceptSetRequired("FPA.TELESCOPE", PM_FPA_LEVEL_FPA, true); + ok (tmpBool == true, "pmConceptSetRequired() returned true for FPA.TELESCOPE"); + tmpBool = pmConceptGetRequired("FPA.TELESCOPE", PM_FPA_LEVEL_FPA); + ok (tmpBool == true, "pmConceptGetRequired() returned true for FPA.TELESCOPE"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // Test pmConceptGetRequired() with a few incorrect concept names + // and/or levels. + { + psMemId id = psMemGetId(); + bool tmpBool = pmConceptGetRequired("FPA.TELESCOPE", PM_FPA_LEVEL_CHIP); + ok (tmpBool == false, "pmConceptGetRequired() returned false for FPA.TELESCOPE with wrong level (CHIP)"); + tmpBool = pmConceptGetRequired("FPA.TELESCOPE", PM_FPA_LEVEL_CELL); + ok (tmpBool == false, "pmConceptGetRequired() returned false for FPA.TELESCOPE with wrong level (CELL)"); + tmpBool = pmConceptGetRequired("FPA.BADCONCEPTNAME", PM_FPA_LEVEL_FPA); + ok (tmpBool == false, "pmConceptGetRequired() returned false for FPA.BADCONCEPTNAME"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // -------------------------------------------------------------------- + // Tests for pmConceptsInit(), pmConceptsDone() + // We determine if pmConceptsInit() was successful by looking at the + // "required" for the CHIP.XPARITY concept at level PM_FPA_LEVEL_CHIP + { + psMemId id = psMemGetId(); + pmConceptsDone(); + // pmConceptsInit() should return TRUE after pmConceptsDone() is called + ok(true == pmConceptsInit(), "pmConceptsInit() returned TRUE"); + + // FPA concepts + ok(false == pmConceptGetRequired("FPA.TELESCOPE", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.TELESCOPE at level: FPA"); + ok(false == pmConceptGetRequired("FPA.INSTRUMENT", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.INSTRUMENT at level: FPA"); + ok(false == pmConceptGetRequired("FPA.DETECTOR", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.DETECTOR at level: FPA"); + ok(false == pmConceptGetRequired("FPA.CAMERA", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.CAMERA at level: FPA"); + ok(false == pmConceptGetRequired("FPA.FOCUS", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.FOCUS at level: FPA"); + ok(false == pmConceptGetRequired("FPA.AIRMASS", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.AIRMASS at level: FPA"); + ok(false == pmConceptGetRequired("FPA.FILTERID", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.FILTERID at level: FPA"); + ok(false == pmConceptGetRequired("FPA.FILTER", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.FILTER at level: FPA"); + ok(false == pmConceptGetRequired("FPA.POSANGLE", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.POSANGLE at level: FPA"); + ok(false == pmConceptGetRequired("FPA.RADECSYS", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.RADECSYS at level: FPA"); + ok(false == pmConceptGetRequired("FPA.RA", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.RA at level: FPA"); + ok(false == pmConceptGetRequired("FPA.DEC", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.DEC at level: FPA"); + ok(false == pmConceptGetRequired("FPA.OBSTYPE", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.OBSTYPE at level: FPA"); + ok(false == pmConceptGetRequired("FPA.OBJECT", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.OBJECT at level: FPA"); + ok(false == pmConceptGetRequired("FPA.ALT", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.ALT at level: FPA"); + ok(false == pmConceptGetRequired("FPA.AZ", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.AZ at level: FPA"); + ok(false == pmConceptGetRequired("FPA.TIMESYS", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.TIMESYS at level: FPA"); + ok(false == pmConceptGetRequired("FPA.TIME", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.TIME at level: FPA"); + ok(false == pmConceptGetRequired("FPA.TEMP", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.TEMP at level: FPA"); + ok(false == pmConceptGetRequired("FPA.EXPOSURE", PM_FPA_LEVEL_FPA), + "pmConceptGetRequired() returned false for FPA.EXPOSURE at level: FPA"); + + // Chip concepts + ok(true == pmConceptGetRequired("CHIP.XPARITY", PM_FPA_LEVEL_CHIP), + "pmConceptGetRequired() returned true for CHIP.XPARITY at level: CHIP"); + ok(true == pmConceptGetRequired("CHIP.YPARITY", PM_FPA_LEVEL_CHIP), + "pmConceptGetRequired() returned true for CHIP.YPARITY at level: CHIP"); + ok(true == pmConceptGetRequired("CHIP.X0", PM_FPA_LEVEL_CHIP), + "pmConceptGetRequired() returned true for CHIP.X0 at level: CHIP"); + ok(true == pmConceptGetRequired("CHIP.Y0", PM_FPA_LEVEL_CHIP), + "pmConceptGetRequired() returned true for CHIP.Y0 at level: CHIP"); + ok(true == pmConceptGetRequired("CHIP.XSIZE", PM_FPA_LEVEL_CHIP), + "pmConceptGetRequired() returned true for CHIP.XSIZE at level: CHIP"); + ok(true == pmConceptGetRequired("CHIP.YSIZE", PM_FPA_LEVEL_CHIP), + "pmConceptGetRequired() returned true for CHIP.YSIZE at level: CHIP"); + ok(false == pmConceptGetRequired("CHIP.TEMP", PM_FPA_LEVEL_CHIP), + "pmConceptGetRequired() returned true for CHIP.TEMP at level: CHIP"); + + // Cell concepts + ok(true == pmConceptGetRequired("CELL.GAIN", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.GAIN at level: CELL"); + ok(true == pmConceptGetRequired("CELL.READNOISE", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.READNOISE at level: CELL"); + ok(true == pmConceptGetRequired("CELL.SATURATION", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.SATURATION at level: CELL"); + ok(true == pmConceptGetRequired("CELL.BAD", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.BAD at level: CELL"); + ok(true == pmConceptGetRequired("CELL.XPARITY", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.XPARITY at level: CELL"); + ok(true == pmConceptGetRequired("CELL.YPARITY", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.YPARITY at level: CELL"); + ok(true == pmConceptGetRequired("CELL.READDIR", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.READDIR at level: CELL"); + ok(false == pmConceptGetRequired("CELL.EXPOSURE", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned false for CELL.EXPOSURE at level: CELL"); + ok(false == pmConceptGetRequired("CELL.DARKTIME", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned false for CELL.DARKTIME at level: CELL"); + ok(true == pmConceptGetRequired("CELL.TRIMSEC", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.TRIMSEC at level: CELL"); + ok(true == pmConceptGetRequired("CELL.BIASSEC", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.BIASSEC at level: CELL"); + ok(true == pmConceptGetRequired("CELL.XBIN", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.XBIN at level: CELL"); + ok(true == pmConceptGetRequired("CELL.YBIN", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.YBIN at level: CELL"); + ok(false == pmConceptGetRequired("CELL.TIMESYS", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned false for CELL.TIMESYS at level: CELL"); + ok(false == pmConceptGetRequired("CELL.TIME", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned false for CELL.TIME at level: CELL"); + ok(true == pmConceptGetRequired("CELL.X0", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.X0 at level: CELL"); + ok(true == pmConceptGetRequired("CELL.Y0", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.Y0 at level: CELL"); + ok(true == pmConceptGetRequired("CELL.XSIZE", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.XSIZE at level: CELL"); + ok(true == pmConceptGetRequired("CELL.YSIZE", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.YSIZE at level: CELL"); + ok(true == pmConceptGetRequired("CELL.XWINDOW", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.XWINDOW at level: CELL"); + ok(true == pmConceptGetRequired("CELL.YWINDOW", PM_FPA_LEVEL_CELL), + "pmConceptGetRequired() returned true for CELL.YWINDOW at level: CELL"); + + // The 2nd pmConceptsInit() should return FALSE after pmConceptsInit() is called + ok(false == pmConceptsInit(), "pmConceptsInit() returned FALSE"); + + pmConceptsDone(); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + // -------------------------------------------------------------------- + // Tests for pmConceptsBlankFPA() + // Verify error with NULL input. + { + psMemId id = psMemGetId(); + bool rc = pmConceptsBlankFPA(NULL); + ok(rc == false, "pmConceptsBlankFPA() returned FALSE with NULL input"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // ----------------------------------------------------------------------------- + // Tests for pmConceptsBlankFPA() + // Call with valid data. We test by ensuring the first 5 metadata items were + // added to fpa->concepts. + { + psMemId id = psMemGetId(); + bool mdok; + char *tmpStr; + psF32 tmpF32; + psF64 tmpF64; + psS32 tmpS32; + pmFPA *fpa = pmFPAAlloc(NULL); + bool rc = false; + + // First junk items to fpa->concepts so that we know they are later blanked. + rc|= psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.TELESCOPE", PS_META_REPLACE, "", "JUNK"); + rc|= psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.INSTRUMENT", PS_META_REPLACE, "", "JUNK"); + rc|= psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.DETECTOR", PS_META_REPLACE, "", "JUNK"); + rc|= psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.CAMERA", PS_META_REPLACE, "", "JUNK"); + rc|= psMetadataAddF32(fpa->concepts, PS_LIST_TAIL, "FPA.FOCUS", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddF32(fpa->concepts, PS_LIST_TAIL, "FPA.AIRMASS", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.FILTERID", PS_META_REPLACE, "", "JUNK"); + rc|= psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.FILTER", PS_META_REPLACE, "", "JUNK"); + rc|= psMetadataAddF32(fpa->concepts, PS_LIST_TAIL, "FPA.POSANGLE", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.RADECSYS", PS_META_REPLACE, "", "JUNK"); + rc|= psMetadataAddF64(fpa->concepts, PS_LIST_TAIL, "FPA.RA", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddF64(fpa->concepts, PS_LIST_TAIL, "FPA.DEC", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.OBSTYPE", PS_META_REPLACE, "", "JUNK"); + rc|= psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.OBJECT", PS_META_REPLACE, "", "JUNK"); + rc|= psMetadataAddF64(fpa->concepts, PS_LIST_TAIL, "FPA.ALT", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddF64(fpa->concepts, PS_LIST_TAIL, "FPA.AZ", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddS32(fpa->concepts, PS_LIST_TAIL, "FPA.TIMESYS", PS_META_REPLACE, "", 22); + rc|= psMetadataAddF32(fpa->concepts, PS_LIST_TAIL, "FPA.TEMP", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddF32(fpa->concepts, PS_LIST_TAIL, "FPA.EXPOSURE", PS_META_REPLACE, "", 22.0); + ok(rc, "Set dummy data in fpa->concepts"); + + rc = pmConceptsBlankFPA(fpa); + ok(rc == true, "pmConceptsBlankFPA() returned TRUE with valid input data"); + tmpStr = psMetadataLookupStr(&mdok, fpa->concepts, "FPA.TELESCOPE"); + ok(mdok && !strcmp(tmpStr, ""), "FPA.TELESCOPE was cleared (%s)", tmpStr); + tmpStr = psMetadataLookupStr(&mdok, fpa->concepts, "FPA.INSTRUMENT"); + ok(mdok && !strcmp(tmpStr, ""), "FPA.INSTRUMENT was cleared (%s)", tmpStr); + tmpStr = psMetadataLookupStr(&mdok, fpa->concepts, "FPA.DETECTOR"); + ok(mdok && !strcmp(tmpStr, ""), "FPA.DETECTOR was cleared (%s)", tmpStr); + tmpStr = psMetadataLookupStr(&mdok, fpa->concepts, "FPA.CAMERA"); + ok(mdok && !strcmp(tmpStr, ""), "FPA.CAMERA was cleared (%s)", tmpStr); + tmpF32 = psMetadataLookupF32(&mdok, fpa->concepts, "FPA.FOCUS"); + ok(mdok && isnan(tmpF32), "FPA.FOCUS was cleared (%f)", tmpF32); + tmpF32 = psMetadataLookupF32(&mdok, fpa->concepts, "FPA.AIRMASS"); + ok(mdok && isnan(tmpF32), "FPA.AIRMASS was cleared (%f)", tmpF32); + tmpStr = psMetadataLookupStr(&mdok, fpa->concepts, "FPA.FILTERID"); + ok(mdok && !strcmp(tmpStr, ""), "FPA.FILTERID was cleared (%s)", tmpStr); + tmpStr = psMetadataLookupStr(&mdok, fpa->concepts, "FPA.FILTER"); + ok(mdok && !strcmp(tmpStr, ""), "FPA.FILTER was cleared (%s)", tmpStr); + tmpF32 = psMetadataLookupF32(&mdok, fpa->concepts, "FPA.POSANGLE"); + ok(mdok && isnan(tmpF32), "FPA.POSANGLE was cleared (%f)", tmpF32); + tmpStr = psMetadataLookupStr(&mdok, fpa->concepts, "FPA.RADECSYS"); + ok(mdok && !strcmp(tmpStr, ""), "FPA.RADECSYS was cleared (%s)", tmpStr); + tmpF64 = psMetadataLookupF64(&mdok, fpa->concepts, "FPA.RA"); + ok(mdok && isnan(tmpF64), "FPA.RA was cleared (%f)", tmpF64); + tmpF64 = psMetadataLookupF64(&mdok, fpa->concepts, "FPA.DEC"); + ok(mdok && isnan(tmpF64), "FPA.DEC was cleared (%f)", tmpF64); + tmpStr = psMetadataLookupStr(&mdok, fpa->concepts, "FPA.OBSTYPE"); + ok(mdok && !strcmp(tmpStr, ""), "FPA.OBSTYPE was cleared (%s)", tmpStr); + tmpStr = psMetadataLookupStr(&mdok, fpa->concepts, "FPA.OBJECT"); + ok(mdok && !strcmp(tmpStr, ""), "FPA.OBJECT was cleared (%s)", tmpStr); + tmpF64 = psMetadataLookupF64(&mdok, fpa->concepts, "FPA.ALT"); + ok(mdok && isnan(tmpF64), "FPA.ALT was cleared (%f)", tmpF64); + tmpF64 = psMetadataLookupF64(&mdok, fpa->concepts, "FPA.AZ"); + ok(mdok && isnan(tmpF64), "FPA.AZ was cleared (%f)", tmpF64); + tmpS32 = psMetadataLookupS32(&mdok, fpa->concepts, "FPA.TIMESYS"); + ok(mdok && -1 == tmpS32, "FPA.TIMESYS was cleared (%d)", tmpS32); + // XXX: Add code to make sure it was cleared. + psMetadataItem *tmpMI = psMetadataLookup(fpa->concepts, "FPA.TIME"); + ok(tmpMI != NULL, "FPA.TIME was cleared"); + tmpF32 = psMetadataLookupF32(&mdok, fpa->concepts, "FPA.TEMP"); + ok(mdok && isnan(tmpF32), "FPA.TEMP was cleared (%f)", tmpF32); + tmpF32 = psMetadataLookupF32(&mdok, fpa->concepts, "FPA.TEMP"); + ok(mdok && isnan(tmpF32), "FPA.TEMP was cleared (%f)", tmpF32); + + psFree(fpa); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // ----------------------------------------------------------------------------- + // Tests for pmConceptsBlankChip() + // Call with valid data. We test by ensuring the first 5 metadata items were + // added to chip->concepts. + { + psMemId id = psMemGetId(); + bool mdok; + psF32 tmpF32; + psS32 tmpS32; + pmChip *chip = pmChipAlloc(NULL, NULL); + bool rc = false; + + // First junk items to chip->concepts so that we know they are later blanked. + rc|= psMetadataAddS32(chip->concepts, PS_LIST_TAIL, "CHIP.XPARITY", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(chip->concepts, PS_LIST_TAIL, "CHIP.YPARITY", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(chip->concepts, PS_LIST_TAIL, "CHIP.X0", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(chip->concepts, PS_LIST_TAIL, "CHIP.Y0", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(chip->concepts, PS_LIST_TAIL, "CHIP.XSIZE", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(chip->concepts, PS_LIST_TAIL, "CHIP.YSIZE", PS_META_REPLACE, "", 22); + rc|= psMetadataAddF32(chip->concepts, PS_LIST_TAIL, "CHIP.TEMP", PS_META_REPLACE, "", 22.0); + ok(rc, "Set dummy data in chip->concepts"); + + rc = pmConceptsBlankChip(chip); + tmpS32 = psMetadataLookupS32(&mdok, chip->concepts, "CHIP.XPARITY"); + ok(mdok && 0 == tmpS32, "CHIP.XPARITY was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, chip->concepts, "CHIP.YPARITY"); + ok(mdok && 0 == tmpS32, "CHIP.YPARITY was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, chip->concepts, "CHIP.X0"); + ok(mdok && 0 == tmpS32, "CHIP.X0 was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, chip->concepts, "CHIP.Y0"); + ok(mdok && 0 == tmpS32, "CHIP.Y0 was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, chip->concepts, "CHIP.XSIZE"); + ok(mdok && 0 == tmpS32, "CHIP.XSIZE was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, chip->concepts, "CHIP.YSIZE"); + ok(mdok && 0 == tmpS32, "CHIP.YSIZE was cleared (%d)", tmpS32); + tmpF32 = psMetadataLookupF32(&mdok, chip->concepts, "CHIP.TEMP"); + ok(mdok && isnan(tmpF32), "CHIP.TEMP was cleared (%d)", tmpF32); + + psFree(chip); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + // ----------------------------------------------------------------------------- + // Tests for pmConceptsBlankCell() + // Call with valid data. We test by ensuring the first 5 metadata items were + // added to cell->concepts. + { + psMemId id = psMemGetId(); + bool mdok; + psF32 tmpF32; + psS32 tmpS32; + pmCell *cell = pmCellAlloc(NULL, NULL); + bool rc = false; + + // First junk items to cell->concepts so that we know they are later blanked. + rc|= psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.GAIN", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.READNOISE", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.XPARITY", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.YPARITY", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.READDIR", PS_META_REPLACE, "", 22); + rc|= psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.SATURATION", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.BAD", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.EXPOSURE", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddF32(cell->concepts, PS_LIST_TAIL, "CELL.DARKTIME", PS_META_REPLACE, "", 22.0); + rc|= psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.XBIN", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.YBIN", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.TIMESYS", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.X0", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.Y0", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.XSIZE", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.YSIZE", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.XWINDOW", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.YWINDOW", PS_META_REPLACE, "", 22); + rc|= psMetadataAddS32(cell->concepts, PS_LIST_TAIL, "CELL.", PS_META_REPLACE, "", 22); + + + ok(rc, "Set dummy data in cell->concepts"); + + rc = pmConceptsBlankCell(cell); + ok(rc == true, "pmConceptsBlankCELL() returned TRUE with valid input data"); + + tmpF32 = psMetadataLookupF32(&mdok, cell->concepts, "CELL.GAIN"); + ok(mdok && isnan(tmpF32), "CELL.GAIN was cleared (%f)", tmpF32); + tmpF32 = psMetadataLookupF32(&mdok, cell->concepts, "CELL.READNOISE"); + ok(mdok && isnan(tmpF32), "CELL.READNOISE was cleared (%f)", tmpF32); + tmpF32 = psMetadataLookupF32(&mdok, cell->concepts, "CELL.SATURATION"); + ok(mdok && isnan(tmpF32), "CELL.SATURATION was cleared (%f)", tmpF32); + tmpF32 = psMetadataLookupF32(&mdok, cell->concepts, "CELL.BAD"); + ok(mdok && isnan(tmpF32), "CELL.BAD was cleared (%f)", tmpF32); + + tmpS32 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.XPARITY"); + ok(mdok && 0 == tmpS32, "CELL.XPARITY was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.YPARITY"); + ok(mdok && 0 == tmpS32, "CELL.YPARITY was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.READDIR"); + ok(mdok && 0 == tmpS32, "CELL.READDIR was cleared (%d)", tmpS32); + tmpF32 = psMetadataLookupF32(&mdok, cell->concepts, "CELL.EXPOSURE"); + ok(mdok && isnan(tmpF32), "CELL.EXPOSURE was cleared (%f)", tmpF32); + tmpF32 = psMetadataLookupF32(&mdok, cell->concepts, "CELL.DARKTIME"); + ok(mdok && isnan(tmpF32), "CELL.DARKTIME was cleared (%f)", tmpF32); + // XXX: Add code to make sure it was cleared. + psMetadataItem *tmpMI = psMetadataLookup(cell->concepts, "CELL.TRIMSEC"); + ok(tmpMI != NULL, "CELL.TRIMSEC was cleared"); + tmpMI = psMetadataLookup(cell->concepts, "CELL.BIASSEC"); + ok(tmpMI != NULL, "CELL.BIASSEC was cleared"); + tmpS32 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.XBIN"); + ok(mdok && 0 == tmpS32, "CELL.XBIN was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.YBIN"); + ok(mdok && 0 == tmpS32, "CELL.YBIN was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.TIMESYS"); + ok(mdok && -1 == tmpS32, "CELL.TIMESYS was cleared (%d)", tmpS32); + // XXX: Add code to make sure it was cleared. + tmpMI = psMetadataLookup(cell->concepts, "CELL.TIME"); + ok(tmpMI != NULL, "CELL.TIME was cleared"); + tmpS32 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.X0"); + ok(mdok && 0 == tmpS32, "CELL.X0 was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.Y0"); + ok(mdok && 0 == tmpS32, "CELL.Y0 was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.XSIZE"); + ok(mdok && 0 == tmpS32, "CELL.XSIZE was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.YSIZE"); + ok(mdok && 0 == tmpS32, "CELL.YSIZE was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.XWINDOW"); + ok(mdok && 0 == tmpS32, "CELL.XWINDOW was cleared (%d)", tmpS32); + tmpS32 = psMetadataLookupS32(&mdok, cell->concepts, "CELL.YWINDOW"); + ok(mdok && 0 == tmpS32, "CELL.YWINDOW was cleared (%d)", tmpS32); + + psFree(cell); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + +} Index: /trunk/psModules/test/concepts/tap_pmConceptsAverage.c =================================================================== --- /trunk/psModules/test/concepts/tap_pmConceptsAverage.c (revision 14882) +++ /trunk/psModules/test/concepts/tap_pmConceptsAverage.c (revision 14882) @@ -0,0 +1,486 @@ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" +// XXX: Use better name for the temporary FITS file +// XXX: The code to generate and free the FPA hierarchy was copied from +// tap-pmFPA.c. EIther include it directly, or library, or something. +// Also, get rid of the manual free functions and use psFree() once +// it correctly frees child members +// XXX: For the genSimpleFPA() code, add IDs to each function so that +// the values set in each chip-?cell-?hdu-?image are unique +// XXX: For the genSimpleFPA() code, write masks and weights as well + +#define CHIP_ALLOC_NAME "ChipName" +#define CELL_ALLOC_NAME "CellName" +#define MISC_NUM 32 +#define MISC_NAME "META00" +#define MISC_NAME2 "META01" +#define NUM_BIAS_DATA 10 +#define TEST_NUM_ROWS 4 +#define TEST_NUM_COLS 4 +#define NUM_READOUTS 3 +#define NUM_CELLS 10 +#define NUM_CHIPS 8 +#define NUM_FPAS 4 +#define NUM_HDUS 5 +#define BASE_IMAGE 10 +#define BASE_MASK 40 +#define BASE_WEIGHT 70 +#define VERBOSE 0 +#define ERR_TRACE_LEVEL 0 + +psPlaneTransform *PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM() +{ + psPlaneTransform *pt = psPlaneTransformAlloc(1, 1); + pt->x->coeff[1][0] = 1.0; + pt->y->coeff[0][1] = 1.0; + return(pt); +} + +psPlaneDistort *PS_CREATE_4D_IDENTITY_PLANE_DISTORT() +{ + psPlaneDistort *pd = psPlaneDistortAlloc(1, 1, 1, 1); + pd->x->coeff[1][0][0][0] = 1.0; + pd->y->coeff[0][1][0][0] = 1.0; + return(pd); +} + +/****************************************************************************** +generateSimpleReadout(): This function generates a pmReadout data structure and then +populates its members with real data. + *****************************************************************************/ +pmReadout *generateSimpleReadout(pmCell *cell) +{ + pmReadout *readout = pmReadoutAlloc(cell); + readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8); + readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) { + psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(tmpImage, (double) i); + psListAdd(readout->bias, PS_LIST_HEAD, tmpImage); + psFree(tmpImage); + } + psMetadataAddS32(readout->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + return(readout); +} + +/****************************************************************************** +generateSimpleCell(): This function generates a pmCell data structure and then +populates its members with real data. + *****************************************************************************/ +pmCell *generateSimpleCell(pmChip *chip) +{ + pmCell *cell = pmCellAlloc(chip, CELL_ALLOC_NAME); + + psMetadataAddS32(cell->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(cell->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psArrayRealloc(cell->readouts, NUM_READOUTS); + cell->hdu = pmHDUAlloc("cellExtName"); + for (int i = 0 ; i < NUM_READOUTS ; i++) { + cell->readouts->data[i] = generateSimpleReadout(cell); + } + + bool rc = pmConfigFileRead(&cell->hdu->format, "../camera/data/camera0/format0.config", "Camera format 0"); + if (!rc) { + diag("pmConfigFileRead() was unsuccessful (from generateSimpleCell())"); + } + + cell->hdu->images = psArrayAlloc(NUM_HDUS); + cell->hdu->masks = psArrayAlloc(NUM_HDUS); + cell->hdu->weights = psArrayAlloc(NUM_HDUS); + for (int k = 0 ; k < NUM_HDUS ; k++) { + cell->hdu->images->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + cell->hdu->masks->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK); + cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k)); + psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k)); + psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k)); + } + + //XXX: Should the region be set some other way? Like through the various config files? +// psRegion *region = psRegionAlloc(0.0, TEST_NUM_COLS-1, 0.0, TEST_NUM_ROWS-1); + psRegion *region = psRegionAlloc(0.0, 0.0, 0.0, 0.0); + // You shouldn't have to remove the key from the metadata. Find out how to simply change the key value. + psMetadataRemoveKey(cell->concepts, "CELL.TRIMSEC"); + psMetadataAddPtr(cell->concepts, PS_LIST_TAIL|PS_META_REPLACE, "CELL.TRIMSEC", PS_DATA_REGION, "I am a region", region); + psFree(region); + return(cell); +} + +/****************************************************************************** +generateSimpleChip(): This function generates a pmChip data structure and then +populates its members with real data. + *****************************************************************************/ +pmChip *generateSimpleChip(pmFPA *fpa) +{ + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + chip->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + chip->fromFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + psMetadataAddS32(chip->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(chip->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// chip->hdu = pmHDUAlloc("chipExtName"); +// +// bool rc = pmConfigFileRead(&chip->hdu->format, "../camera/data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleChip())"); +// } +// + psArrayRealloc(chip->cells, NUM_CELLS); + for (int i = 0 ; i < NUM_CELLS ; i++) { + chip->cells->data[i] = generateSimpleCell(chip); + } + + // XXX: Add code to initialize chip pmConcepts + + + return(chip); +} + +/****************************************************************************** +generateSimpleFPA(): This function generates a pmFPA data structure and then +populates its members with real data. + *****************************************************************************/ +pmFPA* generateSimpleFPA(psMetadata *camera) +{ + pmFPA* fpa = pmFPAAlloc(camera); + fpa->fromTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toSky = psProjectionAlloc(0.0,0.0,10.0,10.0,PS_PROJ_TAN); + psMetadataAddS32(fpa->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32((psMetadata *) fpa->camera, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(fpa->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// fpa->hdu = pmHDUAlloc("fpaExtName"); +// +// bool rc = pmConfigFileRead(&fpa->hdu->format, "../camera/data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleFPA())"); +// } + + psArrayRealloc(fpa->chips, NUM_CHIPS); + for (int i = 0 ; i < NUM_CHIPS ; i++) { + fpa->chips->data[i] = generateSimpleChip(fpa); + } + + // XXX: Eventually, when you finish the pmConcepts tests, add full concept + // reading code from wherever. + pmConceptsBlankFPA(fpa); +// bool mdok; +// psMetadata *fileData = psMetadataLookupMetadata(&mdok, fpa->hdu->format, "FILE"); +// char *fpaNameHdr = psMetadataLookupStr(&mdok, fileData, "FPA.NAME"); +// psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.NAME", PS_META_REPLACE, NULL, fpaNameHdr); + + return(fpa); +} + +// XXX: This should only be necessary until the psFree() functions for +// FPA/chip/cell/readout correctly free all child chips/cells/readouts +void myFreeCell(pmCell *cell) +{ + for (int k = 0 ; k < cell->readouts->n ; k++) { + psFree(cell->readouts->data[k]); + } + psFree(cell); +} + +void myFreeChip(pmChip *chip) { + for (int j = 0 ; j < chip->cells->n ; j++) { + myFreeCell(chip->cells->data[j]); + } + psFree(chip); +} + +void myFreeFPA(pmFPA *fpa) +{ + for (int i = 0 ; i < fpa->chips->n ; i++) { + myFreeChip(fpa->chips->data[i]); + } + psFree(fpa); +} + + + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(50); + + // ---------------------------------------------------------------------- + // pmConceptsAverageFPAs() tests: NULL input pmFPA *target + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA *targetFPA = generateSimpleFPA(camera); + pmFPA *sourceFPA[NUM_FPAS]; + + sourceFPA[0] = generateSimpleFPA(camera); + psList *sources = psListAlloc(sourceFPA[0]); + for (int fpaID = 1 ; fpaID < NUM_FPAS ; fpaID++) { + sourceFPA[fpaID] = generateSimpleFPA(camera); + bool rc = psListAdd(sources, PS_LIST_HEAD, sourceFPA[fpaID]); + ok(rc, "Successfully added FPA %d to list", fpaID); + } + ok(!pmConceptsAverageFPAs(NULL, sources), "pmConceptsAverage(NULL, sources) returned FALSE"); + + for (int fpaID = 0 ; fpaID < NUM_FPAS ; fpaID++) { + myFreeFPA(sourceFPA[fpaID]); + } + psFree(sources); + myFreeFPA(targetFPA); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmConceptsAverageFPAs() tests: NULL input psList *sources + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA *targetFPA = generateSimpleFPA(camera); + pmFPA *sourceFPA[NUM_FPAS]; + + sourceFPA[0] = generateSimpleFPA(camera); + psList *sources = psListAlloc(sourceFPA[0]); + for (int fpaID = 1 ; fpaID < NUM_FPAS ; fpaID++) { + sourceFPA[fpaID] = generateSimpleFPA(camera); + bool rc = psListAdd(sources, PS_LIST_HEAD, sourceFPA[fpaID]); + ok(rc, "Successfully added FPA %d to list", fpaID); + } + ok(!pmConceptsAverageFPAs(targetFPA, NULL), "pmConceptsAverage(NULL, sources) returned FALSE"); + + for (int fpaID = 0 ; fpaID < NUM_FPAS ; fpaID++) { + myFreeFPA(sourceFPA[fpaID]); + } + psFree(sources); + myFreeFPA(targetFPA); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmConceptsAverageFPAs() tests: acceptable inputs + // XXX: There's a memory leak somewhere in this test, not sure where. + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA *targetFPA = generateSimpleFPA(camera); + pmFPA *sourceFPA[NUM_FPAS]; + + // Ensure that the FPA.TIME average is computed correctly + psList *sources = NULL; + psF64 actualTime = 0.0; + for (int fpaID = 0 ; fpaID < NUM_FPAS ; fpaID++) { + sourceFPA[fpaID] = generateSimpleFPA(camera); + psTime *fpaTime = psMetadataLookupPtr(NULL, (sourceFPA[fpaID])->concepts, "FPA.TIME"); + // Add a small value to the psTime so that we can test/ensure that pmConceptsAverageFPAs() + // is actually calculating an average. + fpaTime->sec += (double) (fpaID * 1000); + actualTime+= psTimeToMJD(fpaTime); + if (0 == fpaID) { + sources = psListAlloc(sourceFPA[fpaID]); + } else { + bool rc = psListAdd(sources, PS_LIST_HEAD, sourceFPA[fpaID]); + ok(rc, "Successfully added FPA %d to list", fpaID); + } + } + ok(pmConceptsAverageFPAs(targetFPA, sources), "pmConceptsAverage(NULL, sources) returned FALSE"); + actualTime/= (float) NUM_FPAS; + psTime *fpaTime = psMetadataLookupPtr(NULL, targetFPA->concepts, "FPA.TIME"); + ok(abs(actualTime - psTimeToMJD(fpaTime)) < 1e-4, "pmConceptsAverageFPAs() calculated the average time correctly"); + + + // Replace the FPA.TIMESYS with a non-conforming value, verify that pmConceptsAverageFPAs() returnes an error + psTimeType timeSys = psMetadataLookupS32(NULL, sourceFPA[0]->concepts, "FPA.TIMESYS"); + psMetadataAddS32(sourceFPA[NUM_FPAS-1]->concepts, PS_LIST_HEAD, "FPA.TIMESYS", PS_META_REPLACE, NULL, timeSys+10); + ok(!pmConceptsAverageFPAs(targetFPA, sources), "pmConceptsAverage(NULL, sources) returned FALSE with nonequal FPA.TIMESYS metadata"); + psMetadataAddS32(sourceFPA[NUM_FPAS-1]->concepts, PS_LIST_HEAD, "FPA.TIMESYS", PS_META_REPLACE, NULL, timeSys); + ok(pmConceptsAverageFPAs(targetFPA, sources), "pmConceptsAverage(NULL, sources) returned TRUE with equal FPA.TIMESYS metadata"); + + + // Replace the FPA.TIMESYS with a non-conforming value, verify that pmConceptsAverageFPAs() returnes an error + psString filter = psMetadataLookupStr(NULL, sourceFPA[0]->concepts, "FPA.FILTER"); + psMetadataAddStr(sourceFPA[NUM_FPAS-1]->concepts, PS_LIST_HEAD, "FPA.FILTER", PS_META_REPLACE, NULL, "BOGUS STRING"); + ok(!pmConceptsAverageFPAs(targetFPA, sources), "pmConceptsAverage(NULL, sources) returned FALSE with nonequal FPA.FILTER metadata"); + psMetadataAddStr(sourceFPA[NUM_FPAS-1]->concepts, PS_LIST_HEAD, "FPA.FILTER", PS_META_REPLACE, NULL, filter); + ok(pmConceptsAverageFPAs(targetFPA, sources), "pmConceptsAverage(NULL, sources) returned TRUE with equal FPA.FILTER metadata"); + + // Free data, check for memory leaks + for (int fpaID = 0 ; fpaID < NUM_FPAS ; fpaID++) { + myFreeFPA(sourceFPA[fpaID]); + } + psFree(sources); + myFreeFPA(targetFPA); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + // ---------------------------------------------------------------------- + // pmConceptsAverageCells() tests: NULL input pmFPA *target + // bool pmConceptsAverageCells(pmCell *target, psList *sources, psRegion *trimsec, psRegion *biassec, bool same) + { + psMemId id = psMemGetId(); + psMetadata *tgtCamera = psMetadataAlloc(); + pmFPA *tgtFPA = generateSimpleFPA(tgtCamera); + pmChip *tgtChip = tgtFPA->chips->data[0]; + pmCell *tgtCell = tgtChip->cells->data[0]; + psMetadata *srcCamera = psMetadataAlloc(); + pmFPA *srcFPA = generateSimpleFPA(srcCamera); + pmChip *srcChip = srcFPA->chips->data[0]; + + psList *sources = NULL; + psF32 tstGain = 0.0; + psF32 tstReadnoise = 0.0; + psF32 tstExposure = 0.0; + psF32 tstDarktime = 0.0; + psF32 tstSaturation = 0.0; + psF32 tstBad = 0.0; + + for (int cellID = 0 ; cellID < srcChip->cells->n ; cellID++) { + pmCell *cell = srcChip->cells->data[cellID]; + // Set the various concepts which we will test later + psMetadataAddF32(cell->concepts, PS_LIST_HEAD, "CELL.GAIN", PS_META_REPLACE, NULL, 0.0 + (float) cellID); + tstGain+= 0.0 + (float) cellID; + psMetadataAddF32(cell->concepts, PS_LIST_HEAD, "CELL.READNOISE", PS_META_REPLACE, NULL, 10.0 + (float) cellID); + tstReadnoise+= 10.0 + (float) cellID; + psMetadataAddF32(cell->concepts, PS_LIST_HEAD, "CELL.EXPOSURE", PS_META_REPLACE, NULL, 20.0 + (float) cellID); + tstExposure+= 20.0 + (float) cellID; + psMetadataAddF32(cell->concepts, PS_LIST_HEAD, "CELL.DARKTIME", PS_META_REPLACE, NULL, 30.0 + (float) cellID); + tstDarktime+= 30.0 + (float) cellID; + psMetadataAddF32(cell->concepts, PS_LIST_HEAD, "CELL.SATURATION", PS_META_REPLACE, NULL, 40.0 + (float) cellID); + if (cellID == 0) + tstSaturation = 40.0 + (float) cellID; + psMetadataAddF32(cell->concepts, PS_LIST_HEAD, "CELL.BAD", PS_META_REPLACE, NULL, 50.0 + (float) cellID); + if (cellID == (srcChip->cells->n - 1)) + tstBad = 50.0 + (float) cellID; + if (cellID == 0) { + sources = psListAlloc(srcChip->cells->data[cellID]); + } else { + bool rc = psListAdd(sources, PS_LIST_HEAD, srcChip->cells->data[cellID]); + ok(rc, "Successfully added cell %d to list", cellID); + } + } + tstGain /= (psF64) srcChip->cells->n; + tstReadnoise /= (psF64) srcChip->cells->n; + tstExposure /= (psF64) srcChip->cells->n; + tstDarktime /= (psF64) srcChip->cells->n; + + psRegion *trimsec = psRegionAlloc(0, 1, 2, 3); + psRegion *biassec = psRegionAlloc(4, 5, 6, 7); + + // Ensure pmConceptsAverageCells() returns NULL with NULL tgtCell input + bool rc = pmConceptsAverageCells(NULL, sources, trimsec, biassec, false); + ok(!rc, "pmConceptsAverageCells() returned FALSE with NULL sources input"); + + // Ensure pmConceptsAverageCells() returns NULL with NULL sources input + rc = pmConceptsAverageCells(tgtCell, NULL, trimsec, biassec, false); + ok(!rc, "pmConceptsAverageCells() returned FALSE with NULL targetCell input"); + + // Ensure pmConceptsAverageCells() returns NULL with sources->n = 0 + sources->n = 0; + rc = pmConceptsAverageCells(tgtCell, sources, trimsec, biassec, false); + ok(!rc, "pmConceptsAverageCells() returned FALSE with NULL sources->n = 0"); + sources->n = NUM_CELLS; + + // Call pmConceptsAverageCells() with acceptable input data + rc = pmConceptsAverageCells(tgtCell, sources, trimsec, biassec, false); + ok(rc, "pmConceptsAverageCells() returned TRUE with acceptable input data"); + psF32 tmpF32; + tmpF32 = psMetadataLookupF32(NULL, tgtCell->concepts, "CELL.GAIN"); + ok(abs(tmpF32 - tstGain) < 1e-4, "pmConceptsAverageCells() calculated the average CELL.GAIN correctly"); + tmpF32 = psMetadataLookupF32(NULL, tgtCell->concepts, "CELL.READNOISE"); + ok(abs(tmpF32 - tstReadnoise) < 1e-4, "pmConceptsAverageCells() calculated the average CELL.READNOISE correctly"); + tmpF32 = psMetadataLookupF32(NULL, tgtCell->concepts, "CELL.EXPOSURE"); + ok(abs(tmpF32 - tstExposure) < 1e-4, "pmConceptsAverageCells() calculated the average CELL.EXPOSURE correctly"); + tmpF32 = psMetadataLookupF32(NULL, tgtCell->concepts, "CELL.DARKTIME"); + ok(abs(tmpF32 - tstDarktime) < 1e-4, "pmConceptsAverageCells() calculated the average CELL.DARKTIME correctly"); + tmpF32 = psMetadataLookupF32(NULL, tgtCell->concepts, "CELL.SATURATION"); + ok(abs(tmpF32 - tstSaturation) < 1e-4, "pmConceptsAverageCells() calculated the average CELL.SATURATION correctly (%f %f)", tmpF32, tstSaturation); + tmpF32 = psMetadataLookupF32(NULL, tgtCell->concepts, "CELL.BAD"); + ok(abs(tmpF32 - tstBad) < 1e-4, "pmConceptsAverageCells() calculated the average CELL.BAD correctly"); + psRegion *tstTrimsec = psMetadataLookupPtr(NULL, tgtCell->concepts, "CELL.TRIMSEC"); + ok(tstTrimsec->x0 == 0.0 && tstTrimsec->x1 == 1.0 && tstTrimsec->y0 == 2.0 && tstTrimsec->y1 == 3.0, + "pmConceptsAverageCells() set the CELL>TRIMSEC region correctly"); + psRegion *tstBiassec = psMetadataLookupPtr(NULL, tgtCell->concepts, "CELL.BIASSEC"); + ok(tstBiassec->x0 == 4.0 && tstBiassec->x1 == 5.0 && tstBiassec->y0 == 6.0 && tstBiassec->y1 == 7.0, + "pmConceptsAverageCells() set the CELL>TRIMSEC region correctly"); + + psS32 tmpS32; + pmCell *srcCell = srcChip->cells->data[NUM_CELLS - 1]; + + // Set the CELL.TIMESYS metadata unequal, verify that error occurs + rc = psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.TIMESYS", PS_META_REPLACE, NULL, 232); + tmpS32 = psMetadataLookupS32(&rc, srcCell->concepts, "CELL.TIMESYS"); + rc = pmConceptsAverageCells(tgtCell, sources, trimsec, biassec, false); + ok(!rc, "pmConceptsAverageCells() returned FALSE with non equal CELL.TIMESYS metadata"); + psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.TIMESYS", PS_META_REPLACE, NULL, tmpS32); + + // Set the CELL.READDIR metadata unequal, verify that error occurs + rc = psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.READDIR", PS_META_REPLACE, NULL, 232); + tmpS32 = psMetadataLookupS32(&rc, srcCell->concepts, "CELL.READDIR"); + rc = pmConceptsAverageCells(tgtCell, sources, trimsec, biassec, false); + ok(!rc, "pmConceptsAverageCells() returned FALSE with non equal CELL.READDIR metadata"); + psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.READDIR", PS_META_REPLACE, NULL, tmpS32); + + // Set the CELL.XBIN metadata unequal, verify that error occurs + rc = psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.XBIN", PS_META_REPLACE, NULL, 232); + tmpS32 = psMetadataLookupS32(&rc, srcCell->concepts, "CELL.XBIN"); + rc = pmConceptsAverageCells(tgtCell, sources, trimsec, biassec, false); + ok(!rc, "pmConceptsAverageCells() returned FALSE with non equal CELL.XBIN metadata"); + psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.XBIN", PS_META_REPLACE, NULL, tmpS32); + + // Set the CELL.YBIN metadata unequal, verify that error occurs + rc = psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.YBIN", PS_META_REPLACE, NULL, 232); + tmpS32 = psMetadataLookupS32(&rc, srcCell->concepts, "CELL.YBIN"); + rc = pmConceptsAverageCells(tgtCell, sources, trimsec, biassec, false); + ok(!rc, "pmConceptsAverageCells() returned FALSE with non equal CELL.YBIN metadata"); + psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.YBIN", PS_META_REPLACE, NULL, tmpS32); + + // Set the CELL.X0 metadata unequal, verify that error occurs + rc = psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.X0", PS_META_REPLACE, NULL, 232); + tmpS32 = psMetadataLookupS32(&rc, srcCell->concepts, "CELL.X0"); + rc = pmConceptsAverageCells(tgtCell, sources, trimsec, biassec, true); + ok(!rc, "pmConceptsAverageCells() returned FALSE with non equal CELL.X0 metadata (same = true)"); + psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.X0", PS_META_REPLACE, NULL, tmpS32); + + // Set the CELL.Y0 metadata unequal, verify that error occurs + rc = psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.Y0", PS_META_REPLACE, NULL, 232); + tmpS32 = psMetadataLookupS32(&rc, srcCell->concepts, "CELL.Y0"); + rc = pmConceptsAverageCells(tgtCell, sources, trimsec, biassec, true); + ok(!rc, "pmConceptsAverageCells() returned FALSE with non equal CELL.Y0 metadata (same = true)"); + psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.Y0", PS_META_REPLACE, NULL, tmpS32); + + // Set the CELL.X0 metadata unequal, verify that no error occurs with same==false + rc = psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.X0", PS_META_REPLACE, NULL, 232); + tmpS32 = psMetadataLookupS32(&rc, srcCell->concepts, "CELL.X0"); + rc = pmConceptsAverageCells(tgtCell, sources, trimsec, biassec, false); + ok(!rc, "pmConceptsAverageCells() returned FALSE with non equal CELL.X0 metadata (same = false)"); + psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.X0", PS_META_REPLACE, NULL, tmpS32); + + // Set the CELL.Y0 metadata unequal, verify that no error occurs with same==false + rc = psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.Y0", PS_META_REPLACE, NULL, 232); + tmpS32 = psMetadataLookupS32(&rc, srcCell->concepts, "CELL.Y0"); + rc = pmConceptsAverageCells(tgtCell, sources, trimsec, biassec, false); + ok(!rc, "pmConceptsAverageCells() returned FALSE with non equal CELL.Y0 metadata (same = false)"); + psMetadataAddS32(srcCell->concepts, PS_LIST_HEAD, "CELL.Y0", PS_META_REPLACE, NULL, tmpS32); + + myFreeFPA(tgtFPA); + myFreeFPA(srcFPA); + psFree(tgtCamera); + psFree(srcCamera); + psFree(biassec); + psFree(trimsec); + psFree(sources); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + +} + + Index: /trunk/psModules/test/concepts/tap_pmConceptsPhotcode.c =================================================================== --- /trunk/psModules/test/concepts/tap_pmConceptsPhotcode.c (revision 14882) +++ /trunk/psModules/test/concepts/tap_pmConceptsPhotcode.c (revision 14882) @@ -0,0 +1,114 @@ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" + +#define VERBOSE 0 +#define ERR_TRACE_LEVEL 0 + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(25); + + + // ---------------------------------------------------------------------- + // pmConceptsPhotcodeForView() tests: NULL pmConfig input + // psString pmConceptsPhotcodeForView(pmConfig *config, pmFPAfile *file, const pmFPAview *view) + { + psMemId id = psMemGetId(); + pmConfig *config =pmConfigAlloc(); + pmFPAfile *file = pmFPAfileAlloc(); + pmFPAview *view = pmFPAviewAlloc(32); + ok(NULL == pmConceptsPhotcodeForView(NULL, file, view), + "pmConceptsPhotcodeForView(NULL, file, view) returned NULL"); + psFree(config); + psFree(file); + psFree(view); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmConceptsPhotcodeForView() tests: NULL pmConfig input + // psString pmConceptsPhotcodeForView(pmConfig *config, pmFPAfile *file, const pmFPAview *view) + { + psMemId id = psMemGetId(); + pmConfig *config =pmConfigAlloc(); + pmFPAfile *file = pmFPAfileAlloc(); + pmFPAview *view = pmFPAviewAlloc(32); + ok(NULL == pmConceptsPhotcodeForView(NULL, file, view), + "pmConceptsPhotcodeForView(NULL, file, view) returned NULL"); + psFree(config); + psFree(file); + psFree(view); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmConceptsPhotcodeForView() tests: NULL pmFPAfile input + // psString pmConceptsPhotcodeForView(pmConfig *config, pmFPAfile *file, const pmFPAview *view) + { + psMemId id = psMemGetId(); + pmConfig *config =pmConfigAlloc(); + pmFPAfile *file = pmFPAfileAlloc(); + pmFPAview *view = pmFPAviewAlloc(32); + ok(NULL == pmConceptsPhotcodeForView(config, NULL, view), + "pmConceptsPhotcodeForView(config, NULL, view) returned NULL"); + psFree(config); + psFree(file); + psFree(view); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmConceptsPhotcodeForView() tests: NULL pmFPAview input + // psString pmConceptsPhotcodeForView(pmConfig *config, pmFPAfile *file, const pmFPAview *view) + { + psMemId id = psMemGetId(); + pmConfig *config =pmConfigAlloc(); + pmFPAfile *file = pmFPAfileAlloc(); + pmFPAview *view = pmFPAviewAlloc(32); + ok(NULL == pmConceptsPhotcodeForView(config, file, NULL), + "pmConceptsPhotcodeForView(config, file, NULL) returned NULL"); + psFree(config); + psFree(file); + psFree(view); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // pmConceptsPhotcodeForView() tests: acceptable inputs + // psString pmConceptsPhotcodeForView(pmConfig *config, pmFPAfile *file, const pmFPAview *view) + { + psMemId id = psMemGetId(); + psString str[3]; + str[0] = "ARGS:"; + str[1] = "-site"; + str[2] = "../config/data/SampleIPPConfig"; + psS32 argc = 3; + pmConfig *config = pmConfigRead(&argc, str, "RecipeName"); + ok(config, "pmConfigRead() returned non-NULL"); + pmFPAfile *file = pmFPAfileAlloc(); + // XXX: Insert code to read a pmFPAfile correctly + pmFPAview *view = pmFPAviewAlloc(0); + + bool rc; + psMetadata *recipe = psMetadataLookupPtr(&rc, config->recipes, "PPIMAGE"); + char *rule = psMetadataLookupStr(&rc, recipe, "PHOTCODE.RULE"); + psString goodPhotcode = pmFPAfileNameFromRule(rule, file, view); + + psString testPhotcode = pmConceptsPhotcodeForView(config, file, view); + ok(testPhotcode, "pmConceptsPhotcodeForView(config, file, view) returned non-NULL"); + ok(!strcmp(goodPhotcode, testPhotcode), "pmConceptsPhotcodeForView() produced the correct string"); + psFree(config); + psFree(file); + psFree(view); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } +} + +//HERE Index: /trunk/psModules/test/concepts/tap_pmConceptsUpdate.c =================================================================== --- /trunk/psModules/test/concepts/tap_pmConceptsUpdate.c (revision 14882) +++ /trunk/psModules/test/concepts/tap_pmConceptsUpdate.c (revision 14882) @@ -0,0 +1,290 @@ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" +// XXX: Use better name for the temporary FITS file +// XXX: The code to generate and free the FPA hierarchy was copied from +// tap-pmFPA.c. EIther include it directly, or library, or something. +// Also, get rid of the manual free functions and use psFree() once +// it correctly frees child members +// XXX: For the genSimpleFPA() code, add IDs to each function so that +// the values set in each chip-?cell-?hdu-?image are unique +// XXX: For the genSimpleFPA() code, write masks and weights as well + +#define CHIP_ALLOC_NAME "ChipName" +#define CELL_ALLOC_NAME "CellName" +#define MISC_NUM 32 +#define MISC_NAME "META00" +#define MISC_NAME2 "META01" +#define NUM_BIAS_DATA 10 +#define TEST_NUM_ROWS 4 +#define TEST_NUM_COLS 4 +#define NUM_READOUTS 3 +#define NUM_CELLS 10 +#define NUM_CHIPS 8 +#define NUM_HDUS 5 +#define BASE_IMAGE 10 +#define BASE_MASK 40 +#define BASE_WEIGHT 70 +#define VERBOSE 0 +#define ERR_TRACE_LEVEL 0 + +psPlaneTransform *PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM() +{ + psPlaneTransform *pt = psPlaneTransformAlloc(1, 1); + pt->x->coeff[1][0] = 1.0; + pt->y->coeff[0][1] = 1.0; + return(pt); +} + +psPlaneDistort *PS_CREATE_4D_IDENTITY_PLANE_DISTORT() +{ + psPlaneDistort *pd = psPlaneDistortAlloc(1, 1, 1, 1); + pd->x->coeff[1][0][0][0] = 1.0; + pd->y->coeff[0][1][0][0] = 1.0; + return(pd); +} + +/****************************************************************************** +generateSimpleReadout(): This function generates a pmReadout data structure and then +populates its members with real data. + *****************************************************************************/ +pmReadout *generateSimpleReadout(pmCell *cell) +{ + pmReadout *readout = pmReadoutAlloc(cell); + readout->image = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + readout->mask = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_U8); + readout->weight = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + for (psS32 i = 0 ; i < NUM_BIAS_DATA ; i++) { + psImage *tmpImage = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(tmpImage, (double) i); + psListAdd(readout->bias, PS_LIST_HEAD, tmpImage); + psFree(tmpImage); + } + psMetadataAddS32(readout->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + return(readout); +} + +/****************************************************************************** +generateSimpleCell(): This function generates a pmCell data structure and then +populates its members with real data. + *****************************************************************************/ +pmCell *generateSimpleCell(pmChip *chip) +{ + pmCell *cell = pmCellAlloc(chip, CELL_ALLOC_NAME); + + psMetadataAddS32(cell->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(cell->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psArrayRealloc(cell->readouts, NUM_READOUTS); + cell->hdu = pmHDUAlloc("cellExtName"); + for (int i = 0 ; i < NUM_READOUTS ; i++) { + cell->readouts->data[i] = generateSimpleReadout(cell); + } + + bool rc = pmConfigFileRead(&cell->hdu->format, "../camera/data/camera0/format0.config", "Camera format 0"); + if (!rc) { + diag("pmConfigFileRead() was unsuccessful (from generateSimpleCell())"); + } + + cell->hdu->images = psArrayAlloc(NUM_HDUS); + cell->hdu->masks = psArrayAlloc(NUM_HDUS); + cell->hdu->weights = psArrayAlloc(NUM_HDUS); + for (int k = 0 ; k < NUM_HDUS ; k++) { + cell->hdu->images->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + cell->hdu->masks->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_MASK); + cell->hdu->weights->data[k] = psImageAlloc(TEST_NUM_COLS, TEST_NUM_ROWS, PS_TYPE_F32); + psImageInit(cell->hdu->images->data[k], (float) (BASE_IMAGE+k)); + psImageInit(cell->hdu->masks->data[k], (psU8) (BASE_MASK+k)); + psImageInit(cell->hdu->weights->data[k], (float) (BASE_WEIGHT+k)); + } + + //XXX: Should the region be set some other way? Like through the various config files? +// psRegion *region = psRegionAlloc(0.0, TEST_NUM_COLS-1, 0.0, TEST_NUM_ROWS-1); + psRegion *region = psRegionAlloc(0.0, 0.0, 0.0, 0.0); + // You shouldn't have to remove the key from the metadata. Find out how to simply change the key value. + psMetadataRemoveKey(cell->concepts, "CELL.TRIMSEC"); + psMetadataAddPtr(cell->concepts, PS_LIST_TAIL|PS_META_REPLACE, "CELL.TRIMSEC", PS_DATA_REGION, "I am a region", region); + psFree(region); + return(cell); +} + +/****************************************************************************** +generateSimpleChip(): This function generates a pmChip data structure and then +populates its members with real data. + *****************************************************************************/ +pmChip *generateSimpleChip(pmFPA *fpa) +{ + pmChip *chip = pmChipAlloc(fpa, CHIP_ALLOC_NAME); + chip->toFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + chip->fromFPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + psMetadataAddS32(chip->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(chip->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// chip->hdu = pmHDUAlloc("chipExtName"); +// +// bool rc = pmConfigFileRead(&chip->hdu->format, "../camera/data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleChip())"); +// } +// + psArrayRealloc(chip->cells, NUM_CELLS); + for (int i = 0 ; i < NUM_CELLS ; i++) { + chip->cells->data[i] = generateSimpleCell(chip); + } + + // XXX: Add code to initialize chip pmConcepts + + + return(chip); +} + +/****************************************************************************** +generateSimpleFPA(): This function generates a pmFPA data structure and then +populates its members with real data. + *****************************************************************************/ +pmFPA* generateSimpleFPA(psMetadata *camera) +{ + pmFPA* fpa = pmFPAAlloc(camera); + fpa->fromTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toTPA = PS_CREATE_2D_IDENTITY_PLANE_TRANSFORM(); + fpa->toSky = psProjectionAlloc(0.0,0.0,10.0,10.0,PS_PROJ_TAN); + psMetadataAddS32(fpa->analysis, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32((psMetadata *) fpa->camera, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); + psMetadataAddS32(fpa->concepts, PS_LIST_HEAD, MISC_NAME, 0, NULL, MISC_NUM); +// fpa->hdu = pmHDUAlloc("fpaExtName"); +// +// bool rc = pmConfigFileRead(&fpa->hdu->format, "../camera/data/camera0/format0.config", "Camera format 0"); +// if (!rc) { +// diag("pmConfigFileRead() was unsuccessful (from generateSimpleFPA())"); +// } + + psArrayRealloc(fpa->chips, NUM_CHIPS); + for (int i = 0 ; i < NUM_CHIPS ; i++) { + fpa->chips->data[i] = generateSimpleChip(fpa); + } + + // XXX: Eventually, when you finish the pmConcepts tests, add full concept + // reading code from wherever. + pmConceptsBlankFPA(fpa); +// bool mdok; +// psMetadata *fileData = psMetadataLookupMetadata(&mdok, fpa->hdu->format, "FILE"); +// char *fpaNameHdr = psMetadataLookupStr(&mdok, fileData, "FPA.NAME"); +// psMetadataAddStr(fpa->concepts, PS_LIST_TAIL, "FPA.NAME", PS_META_REPLACE, NULL, fpaNameHdr); + + return(fpa); +} + +// XXX: This should only be necessary until the psFree() functions for +// FPA/chip/cell/readout correctly free all child chips/cells/readouts +void myFreeCell(pmCell *cell) +{ + for (int k = 0 ; k < cell->readouts->n ; k++) { + psFree(cell->readouts->data[k]); + } + psFree(cell); +} + +void myFreeChip(pmChip *chip) { + for (int j = 0 ; j < chip->cells->n ; j++) { + myFreeCell(chip->cells->data[j]); + } + psFree(chip); +} + +void myFreeFPA(pmFPA *fpa) +{ + for (int i = 0 ; i < fpa->chips->n ; i++) { + myFreeChip(fpa->chips->data[i]); + } + psFree(fpa); +} + + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(7); + + + // ---------------------------------------------------------------------- + // pmConceptsUpdate() tests: NULL inputs + // bool pmConceptsUpdate(const pmFPA *fpa, const pmChip *chip, const pmCell *cell) + { + psMemId id = psMemGetId(); + ok(pmConceptsUpdate(NULL, NULL, NULL), "pmConceptsUpdate(NULL, NULL, NULL) returned TRUE"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // pmConceptsUpdate() tests: acceptable inputs + // XXX: Must add tests for the BIASSEC concepts + { + psMemId id = psMemGetId(); + psMetadata *camera = psMetadataAlloc(); + pmFPA *fpa = generateSimpleFPA(camera); + pmChip *chip = fpa->chips->data[0]; + pmCell *cell = chip->cells->data[0]; + bool rc = pmConceptsUpdate(NULL, NULL, cell); + + // Calculate expected myTrimsec + bool xStatus, yStatus; // Status of MD lookups + psImageBinning *binning = psImageBinningAlloc(); + binning->nXbin = psMetadataLookupS32(&xStatus, cell->concepts, "CELL.XBIN"); + binning->nYbin = psMetadataLookupS32(&yStatus, cell->concepts, "CELL.YBIN"); + psRegion *goodTrimsec = psMetadataLookupPtr(NULL, cell->concepts, "CELL.TRIMSEC"); + double goodTrimsecX0 = goodTrimsec->x0; + double goodTrimsecX1 = goodTrimsec->x1; + double goodTrimsecY0 = goodTrimsec->y0; + double goodTrimsecY1 = goodTrimsec->y1; + goodTrimsecX0/= binning->nXbin; + goodTrimsecX1/= binning->nXbin; + goodTrimsecY0/= binning->nYbin; + goodTrimsecY1/= binning->nYbin; + goodTrimsecX0 = (int) goodTrimsec->x0; + if (goodTrimsec->x1 > (int)goodTrimsec->x1) { + goodTrimsecX1 = (int)goodTrimsec->x1 + 1; + } else { + goodTrimsecX1 = (int)goodTrimsec->x1; + } + goodTrimsecY0 = (int)goodTrimsec->y0; + if (goodTrimsec->y1 > (int)goodTrimsec->y1) { + goodTrimsecY1 = (int)goodTrimsec->y1 + 1; + } else { + goodTrimsecY1 = (int)goodTrimsec->y1; + } + psFree(binning); + + // Add CELL.TRIMSEC.UPDATE concept to cell->concepts + psMetadataAddS32(cell->concepts, PS_LIST_HEAD, "CELL.TRIMSEC.UPDATE", 0, NULL, 32); + psS32 num = psMetadataLookupS32(&rc, cell->concepts, "CELL.TRIMSEC.UPDATE"); + ok(rc, "Successfully added CELL.TRIMSEC.UPDATE to cell->concepts (%d)", num); + + // Add CELL.BIASSEC.UPDATE concept to cell->concepts + psMetadataAddS32(cell->concepts, PS_LIST_HEAD, "CELL.BIASSEC.UPDATE", 0, NULL, 32); + num = psMetadataLookupS32(&rc, cell->concepts, "CELL.BIASSEC.UPDATE"); + ok(rc, "Successfully added CELL.BIASSEC.UPDATE to cell->concepts (%d)", num); + + // Call pmConceptsUpdate to update the CELL.TRIMSEC concept + ok(rc, "pmConceptsUpdate(NULL, NULL, pmCell) returned TRUE"); + + psRegion *testTrimsec = psMetadataLookupPtr(NULL, cell->concepts, "CELL.TRIMSEC"); // Trim section + ok(testTrimsec->x1 == goodTrimsecX1 && testTrimsec->y1 == goodTrimsecY1 && + testTrimsec->x0 == goodTrimsecX0 && testTrimsec->y0 == goodTrimsecY0, + "pmConceptsUpdate() updated CELL.TRIMSEC correctly (%f %f)", + testTrimsec->x1, testTrimsec->y1); + + // XXX: This fails but the problem might be with the test code + if (0) { + num = psMetadataLookupS32(&rc, cell->concepts, "CELL.TRIMSEC.UPDATE"); + ok(!rc, "pmConceptsUpdate() removed CELL.TRIMSEC.UPDATE to cell->concepts (%d)", num); + } + + myFreeFPA(fpa); + psFree(camera); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + +} + Index: /trunk/psModules/test/config/tap_pmConfigMask.c =================================================================== --- /trunk/psModules/test/config/tap_pmConfigMask.c (revision 14882) +++ /trunk/psModules/test/config/tap_pmConfigMask.c (revision 14882) @@ -0,0 +1,79 @@ +/** @file tst_pmConfigMask.c + * + * @brief Contains the tests for pmConfigMask.c: + * + * This code will test the pmConfigMask() routine. + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-09-18 18:58:56 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" +#define ERR_TRACE_LEVEL 0 +#define VERBOSE 0 + +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel(".", 0); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(9); + + + // -------------------------------------------------------------------- + // pmConfigMask() tests + // Test pmConfigMask() with NULL masks input param + // XXX: I think the memory leak is in pmConfigRead() + { + psMemId id = psMemGetId(); + psString str[3]; + str[0] = "ARGS:"; + str[1] = "-site"; + str[2] = "data/SampleIPPConfig"; + psS32 argc = 3; + pmConfig *config = pmConfigRead(&argc, str, "RecipeName"); + ok(config != NULL, "pmConfigRead() successful"); + ok(!pmConfigMask(NULL, config), "pmConfigMask() returned NULL with NULL masks input param"); + psFree(config); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // Test pmConfigMask() with NULL pmConfig input param + // XXX: This fails on current CVS code because there is no assert in pmConfigMask() for a null pmConfig param + { + psMemId id = psMemGetId(); + char *masks = "Mask0 Mask1 Mask2"; + ok(!pmConfigMask(masks, NULL), "pmConfigMask() returned NULL with NULL pmConfig input param"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // Test pmConfigMask() with acceptable input params + // XXX: I think the memory leak is in pmConfigRead() + { + psMemId id = psMemGetId(); + // See file TESTDIR/config/data/recipes_masks.config ( + char *masks = "DETECTOR RANGE"; + psMaskType correctMask = 0x02 | 0x04; + psString str[3]; + str[0] = "ARGS:"; + str[1] = "-site"; + str[2] = "data/SampleIPPConfig"; + psS32 argc = 3; + pmConfig *config = pmConfigRead(&argc, str, "RecipeName"); + ok(config != NULL, "pmConfigRead() successful"); + psMaskType mask = pmConfigMask(masks, config); + ok(mask, "pmConfigMask non-zero with acceptable input params"); + ok(mask == correctMask, "pmConfigMask() generated the correct output mask (%x). Should be (%x)", mask, correctMask); + psFree(config); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } +} Index: /trunk/psModules/test/config/tap_pmErrorCodes.c =================================================================== --- /trunk/psModules/test/config/tap_pmErrorCodes.c (revision 14882) +++ /trunk/psModules/test/config/tap_pmErrorCodes.c (revision 14882) @@ -0,0 +1,98 @@ +/** @file tst_pmErrorCodes.c + * + * @brief Contains the tests for pmErrorCodes.c: + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-09-18 18:58:58 $ + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" +#define ERR_TRACE_LEVEL 0 +#define VERBOSE 0 + +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel(".", 0); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(16); + + + // -------------------------------------------------------------------- + // pmErrorRegister() tests + // Test pmErrorRegister() with currently coded error types + { + psMemId id = psMemGetId(); + pmErrorRegister(); + char *errStr; + errStr = (char *) psErrorCodeString(PM_ERR_BASE); + ok(!strcmp("First value we use; lower values belong to psLib", errStr), + "psErrorCodeString(PM_ERR_BASE)"); + + errStr = (char *) psErrorCodeString(PM_ERR_UNKNOWN); + ok(!strcmp("Unknown psModules error code", errStr), + "psErrorCodeString(PM_ERR_UNKNOWN)"); + + errStr = (char *) psErrorCodeString(PM_ERR_PHOTOM); + ok(!strcmp("Problem in photometry", errStr), + "psErrorCodeString(PM_ERR_PHOTOM)"); + + errStr = (char *) psErrorCodeString(PM_ERR_PSF); + ok(!strcmp("Problem in PSF", errStr), + "psErrorCodeString(PM_ERR_PSF)"); + + errStr = (char *) psErrorCodeString(PM_ERR_ASTROM); + ok(!strcmp("Problem in astrometry", errStr), + "psErrorCodeString(PM_ERR_ASTROM)"); + + errStr = (char *) psErrorCodeString(PM_ERR_CAMERA); + ok(!strcmp("Problem in camera", errStr), + "psErrorCodeString(PM_ERR_CAMERA)"); + + errStr = (char *) psErrorCodeString(PM_ERR_CONCEPTS); + ok(!strcmp("Problem in concepts", errStr), + "psErrorCodeString(PM_ERR_CONCEPTS)"); + + errStr = (char *) psErrorCodeString(PM_ERR_IMCOMBINE); + ok(!strcmp("Problem in imcombine", errStr), + "psErrorCodeString(PM_ERR_IMCOMBINE)"); + + errStr = (char *) psErrorCodeString(PM_ERR_OBJECTS); + ok(!strcmp("Problem in objects", errStr), + "psErrorCodeString(PM_ERR_OBJECTS)"); + + errStr = (char *) psErrorCodeString(PM_ERR_SKY); + ok(!strcmp("Problem in sky", errStr), + "psErrorCodeString(PM_ERR_SKY)"); + + errStr = (char *) psErrorCodeString(PM_ERR_ARGUMENTS); + ok(!strcmp("Incorrect arguments", errStr), + "psErrorCodeString(PM_ERR_ARGUMENTS)"); + + errStr = (char *) psErrorCodeString(PM_ERR_SYS); + ok(!strcmp("System error", errStr), + "psErrorCodeString(PM_ERR_SYS)"); + + errStr = (char *) psErrorCodeString(PM_ERR_CONFIG); + ok(!strcmp("Problem in configure files", errStr), + "psErrorCodeString(PM_ERR_CONFIG)"); + + errStr = (char *) psErrorCodeString(PM_ERR_PROG); + ok(!strcmp("Programming error", errStr), + "psErrorCodeString(PM_ERR_PROG)"); + + errStr = (char *) psErrorCodeString(PM_ERR_DATA); + ok(!strcmp("invalid data", errStr), + "psErrorCodeString(PM_ERR_DATA)"); + + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } +} + Index: /trunk/psModules/test/config/tap_pmVersion.c =================================================================== --- /trunk/psModules/test/config/tap_pmVersion.c (revision 14882) +++ /trunk/psModules/test/config/tap_pmVersion.c (revision 14882) @@ -0,0 +1,58 @@ +/** @file tst_pmVersion.c + * + * @brief Contains the tests for pmVersion.c: + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-09-18 18:59:00 $ + * + * XX: The output version string for psModulesVersionLong() is not verified. + * Not sure how to do this since this psModulesVersionLong() produces the + * time that the source code, not the test code, was compiled. + * + * Copyright 2004 Maui High Performance Computing Center, University of Hawaii + */ +#include +#include +#include +#include +#include "tap.h" +#include "pstap.h" +#include "config.h" +#define ERR_TRACE_LEVEL 0 +#define VERBOSE 0 + +int main(int argc, char* argv[]) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + psTraceSetLevel(".", 0); + psTraceSetLevel("err", ERR_TRACE_LEVEL); + plan_tests(4); + + + // -------------------------------------------------------------------- + // psModulesVersion() tests + // XX: The output string is not verified + { + psMemId id = psMemGetId(); + psString tstStr = NULL; + psStringAppend(&tstStr, "%s-%s",PACKAGE_NAME,PACKAGE_VERSION); + psString str = psModulesVersion(); + ok(!strcmp(str, tstStr), "psModulesVersion()"); + psFree(str); + psFree(tstStr); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // -------------------------------------------------------------------- + // psModulesVersionLong() tests + // XX: The output string is not verified + { + psMemId id = psMemGetId(); + psString str = psModulesVersionLong(); + ok(str, "psModulesVersionLong()"); + psFree(str); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } +}