Index: trunk/psLib/test/fft/Makefile.am =================================================================== --- trunk/psLib/test/fft/Makefile.am (revision 11438) +++ trunk/psLib/test/fft/Makefile.am (revision 11439) @@ -1,9 +1,17 @@ -AM_CPPFLAGS = $(SRCINC) -I$(top_srcdir)/test/tap/src $(PSLIB_CFLAGS) +AM_CPPFLAGS = \ + $(SRCINC) \ + -I$(top_srcdir)/test/tap/src \ + -I$(top_srcdir)/test/pstap/src \ + $(PSLIB_CFLAGS) + AM_LDFLAGS = \ - $(top_builddir)/src/libpslib.la \ - $(top_builddir)/test/tap/src/libtap.la \ - $(PSLIB_LIBS) + $(top_builddir)/src/libpslib.la \ + $(top_builddir)/test/tap/src/libtap.la \ + $(top_builddir)/test/pstap/src/libpstap.la \ + $(PSLIB_LIBS) -TEST_PROGS = +TEST_PROGS = \ + tap_psImageFFT \ + tap_psVectorFFT if BUILD_TESTS Index: trunk/psLib/test/fft/tap_psImageFFT.c =================================================================== --- trunk/psLib/test/fft/tap_psImageFFT.c (revision 11439) +++ trunk/psLib/test/fft/tap_psImageFFT.c (revision 11439) @@ -0,0 +1,566 @@ +/** @file tst_psImageFFT.c + * + * @brief Contains the tests for psFFT.[ch] + * + * + * @author Robert DeSonia, MHPCC + * + * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ + * @date $Date: 2007-01-30 21:32:56 $ + * + * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii + */ +#include +#include +#include +#include "tap.h" +#include "pstap.h" + +#define GENIMAGE(img,c,r,TYP, valueFcn) \ +img = psImageAlloc(c,r,PS_TYPE_##TYP); \ +for (psU32 row=0;rowdata.TYP[row]; \ + for (psU32 col=0;coltype.type == PS_TYPE_C32, "FFT produced complex values"); + ok(img2->numCols == m && img2->numRows == n, "FFT produced proper size result (%dx%d vs. expected %dx%d).", + img2->numCols,img2->numRows,m,n); + + // 3. verify that the only significant component cooresponds to the freqency of the input in step 1. + bool errorFlag = false; + for (psU32 row=0;rowdata.C32[row]; + for (psU32 col=0;col 0.1f) { + // must be (0,1) or (0,n-1) or (1,0) or (m-1,0) + if (! (col == 0 && (row == 1 || row == n-1)) + && ! (row == 0 && (col==1 || col == m-1)) ) { + diag("Result incorrect at %d,%d (%.2f)",col,row,mag); + errorFlag = true; + } + } else { + if ( (col == 0 && (row == 1 || row == n-1)) + || (row == 0 && (col==1 || col == m-1)) ) { + diag("Result incorrect at %d,%d (%.2f)",col,row,mag); + errorFlag = true; + } + } + } + } + ok(!errorFlag, "FFT produced correct data values"); + + + + // 4. perform reverse transform + img3 = psImageFFT(img3,img2,PS_FFT_REVERSE); + ok(img3 != NULL, "psImageFFT() returned non-NULL"); + skip_start(img3 == NULL, 1, "Skipping tests because psImageFFT() returned NULL"); + ok(img3->type.type == PS_TYPE_C32, "FFT produced complex values"); + + ok(img3->numCols == m && img3->numRows == n, "FFT didt produce proper size result (%dx%d vs. expected %dx%d).", + img3->numCols,img3->numRows,m,n); + + + + + + + + + + + + + + + + + errorFlag = false; + for (psU32 row=0;rowdata.C32[row]; + psF32* imgRow = img->data.F32[row]; + for (psU32 col=0;col 0.1) { + diag("Reverse FFT gave original image back (%d,%d %.2f vs %.2f)", + col,row,pixel,imgRow[col]); + errorFlag = true; + } + } + } + ok(!errorFlag, "FFT produced correct data values"); + ok(!errorFlag, "FFT produced correct data values"); + + + + // 4. perform reverse transform to real result + img3 = psImageFFT(img3,img2,PS_FFT_REVERSE|PS_FFT_REAL_RESULT); + ok(img3 != NULL, "psImageFFT() returned non-NULL"); + skip_start(img3 == NULL, 1, "Skipping tests because psImageFFT() returned NULL"); + ok(img3->type.type == PS_TYPE_F32, "FFT asked to make real result"); + ok(img3->numCols == m && img3->numRows == n, "FFT produced proper size result (%dx%d vs. expected %dx%d).", + img3->numCols,img3->numRows,m,n); + + errorFlag = false; + for (psU32 row=0;rowdata.F32[row]; + psF32* imgRow = img->data.F32[row]; + for (psU32 col=0;col 0.1) { + diag("Reverse FFT gave original image back (%d,%d %.2f vs %.2f)", + col,row,pixel,imgRow[col]); + errorFlag = true; + } + } + } + ok(!errorFlag, "FFT produced correct data values"); + ok(!errorFlag, "FFT produced correct data values"); + + + + // check if error occurs if FORWARD and REVERSE are both given. + // Following should be an error + // XXX: werify error + ok(psImageFFT(NULL,img2,PS_FFT_REVERSE|PS_FFT_FORWARD) == NULL, + "PS_FFT_REVERSE|PS_FFT_FORWARD returned NULL"); + + // Following should be an error + // XXX: werify error + ok(psImageFFT(NULL,img2,PS_FFT_FORWARD|PS_FFT_REAL_RESULT) == NULL, + "PS_FFT_FORWARD|PS_FFT_REAL_RESULT returned NULL"); + + // Verify return null and program execution doesn't stop if input image is null + img4 = psImageFFT(NULL,NULL,PS_FFT_FORWARD); + ok(img4 == NULL, "psImageFFT should return null for a null input image"); + + // Verify return null and program execution doesn't stop if input image is incorrect direction + // Following should generate error for incorrect direction + // XXX: werify error + GENIMAGE(img4,8,8,S8,row+col); + img5 = psImageFFT(NULL,img4,PS_FFT_REAL_RESULT); + ok(img5 == NULL, "psImageFFT should return null for an incorrect FFT direction"); + + psFree(img4); + psFree(img); + psFree(img2); + psFree(img3); + skip_end(); + skip_end(); + skip_end(); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // 1. create a C64 complex vector with distinctly different real and imaginary parts. + // 2. call psImageReal and psImageImaginary + // 3. compare results to the real/imaginary components of input + { + psMemId id = psMemGetId(); + psImage* c64Img = NULL; + psImage* c64Img2 = NULL; + psImage* c64Img3 = NULL; + psU32 m = 128; + psU32 n = 64; + + // XXX: What is I? + GENIMAGE(c64Img,m,n,C64, row + I * col); + c64Img2 = psImageReal(c64Img2,c64Img); + ok(c64Img2 != NULL, "psImageReal() returned non-NULL"); + ok(c64Img2->type.type == PS_TYPE_F64, "psImageReal() returned the correct type"); + c64Img3 = psImageImaginary(c64Img3,c64Img); + ok(c64Img3 != NULL, "psImageImaginary() returned non-NULL"); + ok(c64Img3->type.type == PS_TYPE_F64, "psImageImaginary() returned the correct type"); + + bool errorFlag = false; + for (psU32 row=0;rowdata.F64[row]; + psF64* img3Row = c64Img3->data.F64[row]; + for (psU32 col=0;col FLT_EPSILON) { + diag("psImageReal didn't return the real portion at n=%d", n); + errorFlag = true; + } + if (fabsf(img3Row[col] - col) > FLT_EPSILON) { + diag("psImageImaginary didn't return the imag portion at n=%d", n); + errorFlag = true; + } + } + } + ok(!errorFlag, "psImageReal() and psImageImaginary() returned the correct data"); + psFree(c64Img); + psFree(c64Img2); + psFree(c64Img3); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + { + psMemId id = psMemGetId(); + psImage* ncImg = NULL; + psImage* ncImg2 = NULL; + psImage* ncImg3 = NULL; + psU32 m = 128; + psU32 n = 64; + + GENIMAGE(ncImg,m,n,F32,row+col); + ncImg2 = psImageReal(ncImg2,ncImg); + ncImg3 = psImageImaginary(ncImg3,ncImg); + ok(ncImg2 != NULL, "psImageReal() returned non-NULL"); + ok(ncImg2->type.type == PS_TYPE_F32, "psImageReal() returned the correct type"); + ok(ncImg3 != NULL, "psImageImaginary() returned non-NULL"); + ok(ncImg3->type.type == PS_TYPE_F32, "psImageImaginary() returned the correct type"); + + bool errorFlag = false; + for(psU32 row=0; rowdata.F32[row]; + psF32* ncImg3Row = ncImg3->data.F32[row]; + for(psU32 col=0; col FLT_EPSILON) { + diag("psImageReal didn't return the real portion"); + errorFlag = true; + } + if(fabsf(ncImg3Row[col] - 0) > FLT_EPSILON) { + diag("psImageImaginary didn't return the imaginary portion"); + errorFlag = true; + } + } + } + ok(!errorFlag, "psImageReal() and psImageImaginary() returned the correct data"); + psFree(ncImg); + psFree(ncImg2); + psFree(ncImg3); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + + // Perform psImageReal with null input + { + psMemId id = psMemGetId(); + ok(psImageReal(NULL,NULL) == NULL, "psImageReal() returned NULL with NULL inputs"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // Perform psImageImaginary with null input + { + psMemId id = psMemGetId(); + ok(psImageImaginary(NULL,NULL) == NULL, "psImageImaginary() returned NULL with NULL inputs"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testImageComplex() + // 1. create two unique psF32 vectors of the same size + // 2. call psImageComplex + // 3. verify that the result is a psC32 + // 4. use crealf and cimagf on step 2 results + // 5. compare step 4 results to input. + // 6. create a psF32 and a psF64 vector of the same size + // 7. call psImageComplex + // 8. verify that an appropriate error occurred. + // 9. create two psf32 vectors of different sizes + // 10. call psImageComplex + // 11. verify thet an appropriate error occurred. + { + psMemId id = psMemGetId(); + psImage* img = NULL; + psImage* img2 = NULL; + psImage* img3 = NULL; + psImage* c64Img = NULL; + psImage* c64Img2 = NULL; + psImage* c64Img3 = NULL; + psImage* pImg = NULL; + psImage* pImg2 = NULL; + psImage* pImg3 = NULL; + psU32 m = 128; + psU32 n = 64; + GENIMAGE(img,m,n,F32,row); + GENIMAGE(img2,m,n,F32,col); + GENIMAGE(c64Img,m,n,F64,row); + GENIMAGE(c64Img2,m,n,F64,col); + GENIMAGE(pImg,m,n,S16,row); + GENIMAGE(pImg2,m,n,S16,col); + img3 = psImageComplex(img3,img,img2); + ok(img3 != NULL, "psImageComplex() returned non-NULL"); + ok(img3->type.type == PS_TYPE_C32, "psImageComplex() returned the correct type"); + c64Img3 = psImageComplex(c64Img3,c64Img,c64Img2); + ok(c64Img3 != NULL, "psImageComplex() returned non-NULL"); + ok(c64Img3->type.type == PS_TYPE_C64, "psImageComplex() returned the correct type"); + bool errorFlag = false; + for (psU32 row=0;rowdata.C32[row]; + psC64* c64Img3Row = c64Img3->data.C64[row]; + for (psU32 col=0;col FLT_EPSILON || + fabsf(cimagf(img3Row[col]) - col) > FLT_EPSILON) { + diag("psImageComplex result is incorrect (%d,%d, %.2f+%.2fi)", + col,row,crealf(img3Row[col]),cimagf(img3Row[col])); + errorFlag = true; + } + if (fabsf(crealf(c64Img3Row[col]) - row) > FLT_EPSILON || + fabsf(cimagf(c64Img3Row[col]) - col) > FLT_EPSILON) { + diag("psImageComplex result is incorrect"); + errorFlag = true; + + } + } + } + ok(!errorFlag, "psImageComplex() returned correct results"); + + img2 = psImageRecycle(img2,m,n,PS_TYPE_F64); + + // Following should be an error (type mismatch) + // Verify that an appropriate error occurred + img3 = psImageComplex(img3,img,img2); + ok(img3 == NULL, "psImageComplex() returned NULL when input types mismatched."); + + // Following should be an error (size mismatch) + img2 = psImageRecycle(img2,m/2,n,PS_TYPE_F32); + img3 = psImageComplex(img3,img,img2); + ok(img3 == NULL, "psImageComplex() returned a NULL when input sizes mismatched"); + + // Perform psImageComplex with incorrect type + // Following should generate an error message."); + pImg3 = psImageComplex(pImg3,pImg,pImg2); + ok(pImg3 == NULL, "psImageComplex returned NULL with incorrect type input"); + + psFree(img); + psFree(img2); + psFree(img3); + psFree(c64Img); + psFree(c64Img2); + psFree(c64Img3); + psFree(pImg); + psFree(pImg2); + + // Perform psImageComplex with null input + ok(psImageComplex(NULL,NULL,NULL) == NULL, "psImageComplex() returned NULL with null input"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // 1. create a psC32 with unique real and imaginary values. + // 2. call psImageConjugate + // 3. verify result is psC32 + // 4. verify each value is conjugate of input (a+bi -> a-bi) + // testImageConjugate() + { + psMemId id = psMemGetId(); + psImage* img = NULL; + psImage* img2 = NULL; + psImage* c64Img = NULL; + psImage* c64Img2 = NULL; + psImage* pImg = NULL; + psImage* pImg2 = NULL; + psU32 m = 128; + psU32 n = 64; + GENIMAGE(img,m,n,C32, row + I * col); + GENIMAGE(c64Img,m,n,C64,row + I*col); + GENIMAGE(pImg,m,n,F32,row+col); + + + img2 = psImageConjugate(img2,img); + ok(img2 != NULL, "psImageConjugate() returned non-NULL"); + c64Img2 = psImageConjugate(c64Img2,c64Img); + ok(c64Img2 != NULL, "psImageConjugate() returned non-NULL"); + pImg2 = psImageConjugate(pImg2,pImg); + ok(pImg2 != NULL, "psImageConjugate() returned non-NULL"); + + ok(img2->type.type == PS_TYPE_C32, "psImageConjugate() returned the correct type"); + ok(c64Img2->type.type == PS_TYPE_C64, "psImageConjugate() returned the correct type"); + ok(pImg2->type.type == PS_TYPE_F32, "psImageConjugate() returned the correct type"); + + bool errorFlag = false; + for (psU32 row=0;rowdata.C32[row]; + psC64* c64Img2Row = c64Img2->data.C64[row]; + psF32* pImg2Row = pImg2->data.F32[row]; + for (psU32 col=0;col FLT_EPSILON || + fabsf(cimagf(img2Row[col]) + col) > FLT_EPSILON) { + diag("psImageComplex result is incorrect (%d,%d, %.2f+%.2fi)", + col,row,crealf(img2Row[col]),cimagf(img2Row[col])); + errorFlag = true; + } + if (fabsf(crealf(c64Img2Row[col]) - row) > FLT_EPSILON || + fabsf(cimagf(c64Img2Row[col]) + col) > FLT_EPSILON) { + diag("psImageComplex result is incorrect"); + errorFlag = true; + } + if (fabsf(pImg2Row[col] - (row+col)) > FLT_EPSILON) { + diag("psImageComplex result is incorrect"); + errorFlag = true; + } + } + } + ok(!errorFlag, "psImageConjugate() generated the correct data values"); + psFree(img); + psFree(img2); + psFree(c64Img); + psFree(c64Img2); + psFree(pImg); + psFree(pImg2); + + // Perform psImageConjugate with null input + ok(psImageConjugate(NULL,NULL) == NULL, "psImageConjugate() returned NULL with NULL input"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + // testImagePowerSpectrum() + // 1. create a psC32 vector with unique real and imaginary components + // 2. call psImagePowerSpectrum + // 3. verify result is psF32 + // 4. verify the values are the square of the absolute values of the original + { + psMemId id = psMemGetId(); + psImage* img = NULL; + psImage* img2 = NULL; + psImage* c64Img = NULL; + psImage* c64Img2 = NULL; + psImage* pImg = NULL; + psU32 m = 128; + psU32 n = 64; + + GENIMAGE(img,m,n,C32, row + I * col); + GENIMAGE(c64Img,m,n,C64,row+I*col); + GENIMAGE(pImg,m,n,F32,row+col); + + img2 = psImagePowerSpectrum(img2,img); + c64Img2 = psImagePowerSpectrum(c64Img2, c64Img); + ok(img2 != NULL, "psImagePowerSpectrum() returned non-NULL"); + ok(c64Img2 != NULL, "psImagePowerSpectrum() returned non-NULL"); + ok(img2->type.type == PS_TYPE_F32, "psImagePowerSpectrum() returned the correct type"); + ok(c64Img2->type.type == PS_TYPE_F64, "psImagePowerSpectrum() returned the correct type"); + + bool errorFlag = false; + for (psU32 row=0;rowdata.C32[row]; + psF32* img2Row = img2->data.F32[row]; + psC64* c64ImgRow = c64Img->data.C64[row]; + psF64* c64Img2Row = c64Img2->data.F64[row]; + for (psU32 col=0;col 2.0f*FLT_EPSILON) { + diag("psImagePowerSpectrum result is incorrect (%d,%d, %.2f vs %.2f)", + col,row,img2Row[col],power); + errorFlag = true; + } + if (fabsf(c64Img2Row[col] - power64) > 2.0f*FLT_EPSILON) { + diag("psImagePowerSpectrum result is incorrect"); + errorFlag = true; + } + } + } + ok(!errorFlag, "psImagePowerSPectrum() generated the correct data values"); + psFree(img); + psFree(img2); + psFree(c64Img); + psFree(c64Img2); + + // Perform psImagePowerSpectrum with incorrect input + // Following should generate error message + // XXX: Verify error + ok(psImagePowerSpectrum(NULL,pImg) == NULL, "psImagePowerSpectrum() returned NULL with incorrect type"); + psFree(pImg); + + // Perform psImagePowerSpectrum with NULL input + ok(psImagePowerSpectrum(NULL,NULL) == NULL, "psImagePowerSpectrum() returned NULL with NULL input"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testImageRealImaginary() + // 1. create a C32 complex image with distinctly different real and imaginary parts + // 2. call psImageReal and psImageImaginary + // 3. compare results to the real/imaginary components of input + // XXX: If we put this block above the previous 2 blocks, then we get memory errors + { + psMemId id = psMemGetId(); + psImage* img = NULL; + psImage* img3 = NULL; + psU32 m = 128; + psU32 n = 64; + GENIMAGE(img,m,n,C32, row + I * col); + psImage* img2 = psImageReal(img2,img); + ok(img2 != NULL, "psImageReal returned non-NULL"); + skip_start(img2 == NULL, 4, "Skipping tests because psImageReal() returned NULL"); + ok(img2->type.type == PS_TYPE_F32, "psImageReal returned the correct type"); + img3 = psImageImaginary(img3,img); + ok(img3 != NULL, "psImageImaginary() returned non-NULL"); + skip_start(img3 == NULL, 2, "Skipping tests because psImageImaginary() returned NULL"); + ok(img3->type.type == PS_TYPE_F32, "psImageImaginary() returned the correct type"); + + bool errorFlag = false; + for (psU32 row=0;rowdata.F32[row]; + psF32* img3Row = img3->data.F32[row]; + for (psU32 col=0;col FLT_EPSILON) { + diag("psImageReal didn't return the real portion at n=%d", n); + errorFlag = true; + } + if (fabsf(img3Row[col] - col) > FLT_EPSILON) { + diag("psImageImaginary didn't return the imag portion at n=%d", n); + errorFlag = true; + } + } + } + ok(!errorFlag, "psImageReal(), psImageImaginary() returned the correct data"); + skip_end(); + skip_end(); + psFree(img); + psFree(img2); + psFree(img3); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + +} Index: trunk/psLib/test/fft/tap_psVectorFFT.c =================================================================== --- trunk/psLib/test/fft/tap_psVectorFFT.c (revision 11439) +++ trunk/psLib/test/fft/tap_psVectorFFT.c (revision 11439) @@ -0,0 +1,502 @@ +/** @file tst_psVectorFFT.c +* +* @brief Contains the tests for psFFT.[ch] +* +* +* @author Robert DeSonia, MHPCC +* +* @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ +* @date $Date: 2007-01-30 21:32:56 $ +* +* XXX: Must add skip_start() macros +* +* +* +* +* +* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii +*/ +#include +#include +#include +#include "tap.h" +#include "pstap.h" + +#define GENIMAGE(img,c,r,TYP, valueFcn) \ +img = psImageAlloc(c,r,PS_TYPE_##TYP); \ +for (psU32 row=0;rowdata.TYP[row]; \ + for (psU32 col=0;coln = vec->nalloc; + for ( psU32 n = 0; n < 100; n++ ) + { + vec->data.F32[ n ] = sinf( ( psF32 ) n / 50.0f * M_PI ); + } + + vec2 = psVectorFFT(NULL, vec, PS_FFT_FORWARD); + ok(vec2 != NULL, "psVectorFFT() returned non-NULL"); + ok(vec2->type.type == PS_TYPE_C32, "psVectorFFT() returned the correct type"); + ok(vec2->n == vec->n, "psVectorFFT() returned the correct size vector"); + + bool errorFlag = false; + for ( psU32 n = 0; n < 100; n++ ) + { + if ( n == 1 || n == 99 ) { + if ( fabsf( cabsf( vec2->data.C32[ n ] ) - 50.0f ) > 0.1f ) { + diag("FFT didn't work for vector (n=%d)", n ); + errorFlag = true; + } + } else { + if ( fabsf( cabsf( vec2->data.C32[ n ] ) ) > 0.1f ) { + diag("FFT didn't work for vector (n=%d)", n ); + errorFlag = true; + } + } + } + ok(!errorFlag, "psVectorFFT() returned the correct data values"); + + vec3 = psVectorFFT( NULL, vec2, PS_FFT_REVERSE ); + ok(vec3 != NULL, "psVectorFFT() returned non-NULL"); + ok(vec3->type.type == PS_TYPE_C32, "psVectorFFT() returned the correct type"); + ok(vec3->n != vec2->n, "psVectorFFT() returned the correct size vectors"); + + errorFlag = false; + for ( psU32 n = 0; n < 100; n++ ) + { + psF32 val = sinf( ( psF32 ) n / 50.0f * M_PI ); + psF32 vecVal = crealf( vec3->data.C32[ n ] ) / 100; + if ( fabsf( vecVal - val ) > 0.1f ) { + diag("Reverse FFT didn't give me the original vector back (n=%d) (%.2f vs %.2f)", + n, vecVal, val ); + errorFlag = true; + } + } + ok(!errorFlag, "psVectorFFT() returned the correct data values"); + + // Perform reverse transform with real flag set + vec4 = psVectorFFT(NULL,vec2, (PS_FFT_REVERSE | PS_FFT_REAL_RESULT)); + ok(vec4->type.type == PS_TYPE_F32, "FFT with real result did produce real values"); + + // Perform vector FFT with incorrect direction flags + // Following should generate an error message + // XXX: Verify error + ok(psVectorFFT(NULL,vec2,(psFFTFlags)0) == NULL, "psVectorFFT() returned NULL with incorrect direction"); + psFree(vec); + psFree(vec2); + psFree(vec3); + psFree(vec4); + + // Perform vector FFT with null input + ok(psVectorFFT(NULL,NULL,PS_FFT_FORWARD) == NULL, "psVectorFFT() returned NULL with null input vector"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testVectorRealImaginary() + // 1. create a C32 complex vector with distinctly different real and imaginary parts. + // 2. call psVectorReal and psVectorImaginary + // 3. compare results to the real/imaginary components of input + { + psMemId id = psMemGetId(); + psVector * vec = NULL; + psVector* vec2 = NULL; + psVector* vec3 = NULL; + psVector* vec4 = NULL; + psVector* vec5 = NULL; + psVector* vec6 = NULL; + psVector* vec7 = NULL; + psVector* vec8 = NULL; + psVector* vec9 = NULL; + psVector* vec10 = NULL; + psVector* vec11 = NULL; + + vec = psVectorAlloc( 100, PS_TYPE_C32 ); + vec8 = psVectorAlloc( 100, PS_TYPE_C64 ); + vec10 = psVectorAlloc( 100, PS_TYPE_C64 ); + vec->n = vec->nalloc; + vec8->n = vec8->nalloc; + vec10->n = vec10->nalloc; + for ( psU32 n = 0; n < 100; n++ ) + { + vec->data.C32[ n ] = n + I * ( n * 2 ); + vec8->data.C64[n] = n + I * ( n * 2 ); + vec10->data.C64[n] = n + I * ( n * 2 ); + } + vec4 = psVectorAlloc( 100, PS_TYPE_F32); + vec4->n = vec4->nalloc; + vec6 = psVectorAlloc( 100, PS_TYPE_F32); + vec6->n = vec6->nalloc; + for ( psU32 n = 0; n < 100; n++ ) + { + vec4->data.F32[n] = n; + vec6->data.F32[n] = n; + } + + vec2 = psVectorReal( vec2, vec ); + ok(vec2 != NULL, "psVectorReal() returned non-NULL"); + ok(vec2->type.type == PS_TYPE_F32, "psVectorReal() returned the correct type"); + + // Following should generate a warning + // XXX: Verify warning + vec5 = psVectorReal(vec5, vec4); + ok(vec5 != NULL, "psVectorReal() returned non-NULL"); + ok(vec5->type.type == PS_TYPE_F32, "psVectorReal() returned the correct type"); + + vec9 = psVectorReal(vec9,vec8); + ok(vec9 != NULL, "psVectorReal() returned non-NULL"); + ok(vec9->type.type == PS_TYPE_F64, "psVectorReal() returned the correct type"); + + // Following should generate a warning + // XXX: Verify warning + vec3 = psVectorImaginary( vec3, vec ); + ok(vec3 != NULL, "psVectorImaginary() returned non-NULL"); + ok(vec3->type.type == PS_TYPE_F32, "psVectorImaginary() returned the correct type"); + + vec7 = psVectorImaginary(vec7, vec6); + ok(vec7 != NULL, "psVectorImaginary() returned non-NULL"); + ok(vec7->type.type == PS_TYPE_F32, "psVectorImaginary() returned the correct type"); + + vec11 = psVectorImaginary(vec11, vec10); + ok(vec11 != NULL, "psVectorImaginary() returned non-NULL"); + ok(vec11->type.type == PS_TYPE_F64, "psVectorImaginary() returned the correct type"); + + + // 3. compare results to the real/imaginary components of input + bool errorFlag = false; + for ( psU32 n = 0; n < 100; n++ ) + { + psF32 r = n; + psF32 i = ( n * 2 ); + psF64 rr = n; + psF64 ii = ( n * 2 ); + if ( fabsf( vec2->data.F32[ n ] - r ) > FLT_EPSILON ) { + diag("psVectorReal didn't return the real portion at n=%d", n); + errorFlag = true; + } + if ( fabsf( vec3->data.F32[ n ] - i ) > FLT_EPSILON ) { + diag("psVectorImaginary didn't return the real portion at n=%d", n); + errorFlag = true; + } + if ( fabsf( vec5->data.F32[n] - r) > FLT_EPSILON) { + diag("psVectorReal didn't return the real portion at n=%d",n); + errorFlag = true; + } + if ( fabsf( vec7->data.F32[n] - 0) > FLT_EPSILON) { + diag("psVectorImaginary did not return the imaginary portion at n=%d",n); + errorFlag = true; + } + if ( fabsf(vec9->data.F64[n] - rr) > FLT_EPSILON ) { + diag("psVectorReal did not return the real portion at n=%d",n); + errorFlag = true; + } + if ( fabsf(vec11->data.F64[n] - ii) > FLT_EPSILON) { + diag("psVectorImaginary did not return the imaginary portion at n=%d",n); + errorFlag = true; + } + } + ok(!errorFlag, "psVectorImaginary() returned the correct data values"); + + psFree( vec ); + psFree( vec2 ); + psFree( vec3 ); + psFree( vec4 ); + psFree( vec5 ); + psFree( vec6 ); + psFree( vec7 ); + psFree( vec8 ); + psFree( vec9 ); + psFree( vec10 ); + psFree( vec11 ); + + // Perform vector Real with null input + ok(psVectorReal(NULL,NULL) == NULL, "psVectorReal returned NULL with NULL input"); + ok(psVectorImaginary(NULL,NULL) == NULL, "psVectorImaginary returned NULL with NULL input"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testVectorComplex() + // 1. create two unique psF32 vectors of the same size + // 2. call psVectorComplex + // 3. verify that the result is a psC32 + // 4. call psVectorReal and psVectorImaginary on step 2 results + // 5. compare step 4 results to input. + // 6. create a psF32 and a psF64 vector of the same size + // 7. call psVectorComplex + // 8. verify that an appropriate error occurred. + // 9. create two psf32 vectors of different sizes + // 10. call psVectorComplex + // 11. verify thet an appropriate error occurred. + { + psMemId id = psMemGetId(); + psVector * vec = NULL; + psVector* vec2 = NULL; + psVector* vec3 = NULL; + psVector* vec4 = NULL; + psVector* vec5 = NULL; + psVector* vec6 = NULL; + + // 1. create two unique psF32 vectors of the same size + vec = psVectorAlloc( 100, PS_TYPE_F32 ); + vec2 = psVectorAlloc( 100, PS_TYPE_F32 ); + vec4 = psVectorAlloc( 100, PS_TYPE_F64 ); + vec5 = psVectorAlloc( 100, PS_TYPE_F64 ); + vec->n = vec->nalloc; + vec2->n = vec2->nalloc; + vec4->n = vec4->nalloc; + vec5->n = vec5->nalloc; + for ( psU32 n = 0; n < 100; n++ ) + { + vec->data.F32[ n ] = n; + vec2->data.F32[ n ] = ( n * 2 ); + vec4->data.F64[ n ] = n; + vec5->data.F64[ n ] = ( n * 2 ); + } + + vec3 = psVectorComplex( vec3, vec, vec2 ); + ok(vec3 != NULL, "psVectorComplex() returned non-NULL"); + ok(vec3->type.type == PS_TYPE_C32, "psVectorComplex() returned the correct type"); + bool errorFlag = false; + for ( psU32 n = 0; n < 100; n++ ) + { + if ( fabsf( crealf( vec3->data.C32[ n ] ) - n ) > FLT_EPSILON || + fabsf( cimagf( vec3->data.C32[ n ] ) - ( n * 2 ) ) > FLT_EPSILON ) { + diag("psVectorComplex result is incorrect (n=%d, %.2f+%.2fi)", + n, crealf( vec3->data.C32[ n ] ), cimagf( vec3->data.C32[ n ] ) ); + errorFlag = true; + }; + } + ok(!errorFlag, "psVectorComplex() returned the correct data values"); + + + vec2 = psVectorRecycle( vec2, 100, PS_TYPE_F64 ); + // Following should be an error (type mismatch) + // Verify error + vec3 = psVectorComplex( vec3, vec, vec2 ); + ok(vec3 == NULL, "psVectorComplex() returned NULL when input types mismatched." ); + + vec2 = psVectorRecycle( vec2, 200, PS_TYPE_F32 ); + vec3 = psVectorComplex( vec3, vec, vec2 ); + ok(vec3->n == 100, "psVectorComplex() returned the correct size vector"); + + // Verify the function works with psF64 type + vec6 = psVectorComplex(vec6, vec4, vec5); + ok(vec6->type.type == PS_TYPE_C64, "psVectorComplex() returned the correct type (C64)"); + + // Verify error message generated with input of incorrect type + // Following should generate an error message + vec4->type.type = PS_TYPE_S8; + vec5->type.type = PS_TYPE_S8; + vec6 = psVectorComplex(vec6, vec4, vec5); + ok(vec6 == NULL, "psVectorComplex() returned NULL for incorrect type"); + vec4->type.type = PS_TYPE_F64; + vec5->type.type = PS_TYPE_F64; + psFree(vec); + psFree(vec2); + psFree(vec3); + psFree(vec4); + psFree(vec5); + + // Perform vector complex with null input + ok(psVectorComplex(NULL,NULL,NULL) == NULL, "psVectorComplex() returned NULL with null input vector"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testVectorConjugate() + // 1. create a psC32 with unique real and imaginary values. + // 2. call psVectorConjugate + // 3. verify result is psC32 + // 4. verify each value is conjugate of input (a+bi -> a-bi) + { + psMemId id = psMemGetId(); + psVector * vec = NULL; + psVector* vec2 = NULL; + + vec = psVectorAlloc( 100, PS_TYPE_C32 ); + vec->n = vec->nalloc; + for ( psU32 n = 0; n < 100; n++ ) + { + vec->data.C32[ n ] = n + I * ( n * 2 ); + } + + vec2 = psVectorConjugate(vec2, vec); + ok(vec2 != NULL, "psVectorConjugate() returned non-NULL"); + ok(vec2->type.type == PS_TYPE_C32, "psVectorConjugate() returned the correct type"); + + bool errorFlag = false; + for ( psU32 n = 0; n < 100; n++ ) + { + if ( fabsf( crealf( vec->data.C32[ n ] ) - crealf( vec2->data.C32[ n ] ) ) > FLT_EPSILON || + fabsf( cimagf( vec->data.C32[ n ] ) + cimagf( vec2->data.C32[ n ] ) ) > FLT_EPSILON ) { + diag("psVectorConjugate result is incorrect (n=%d, %.2f+%.2fi)", + n, crealf( vec2->data.C32[ n ] ), cimagf( vec2->data.C32[ n ] ) ); + errorFlag = true; + }; + } + ok(!errorFlag, "psVectorConjugate() returned the correct data values"); + psFree(vec); + + // Perform conjugate for non-complex number + vec = psVectorAlloc( 100, PS_TYPE_F32 ); + vec->n = vec->nalloc; + for ( psU32 n = 0; n < 100; n++ ) + { + vec->data.F32[ n ] = n; + } + // Following should generate a warning message + // XXX: verify warning + vec2 = psVectorConjugate(vec2,vec); + ok(vec2->type.type == PS_TYPE_F32, "psVectorConjugate did return a F32 vector"); + + errorFlag = false; + for ( psU32 n = 0; n < 100; n++ ) + { + if( vec->data.F32[n] != vec2->data.F32[n] ) { + diag("psVectorConjugate result is incorrect (n=%d)",n); + errorFlag = true; + } + } + ok(!errorFlag, "psVectorConjugate() returned the correct data values"); + psFree(vec); + + // Perform vector conjugate with C64 type + vec = psVectorAlloc( 100, PS_TYPE_C64 ); + vec->n = vec->nalloc; + for ( psU32 n = 0; n < 100; n++ ) + { + vec->data.C64[n] = n + I * ( n * 2 ); + } + vec2 = psVectorConjugate(vec2,vec); + ok(vec2 != NULL, "psVectorConjugate() returned non-NULL"); + ok(vec2->type.type == PS_TYPE_C64, "psVectorConjugate() returned the correct type"); + errorFlag = false; + for ( psU32 n = 0; n < 100; n++ ) + { + if ( fabsf( crealf(vec->data.C64[n]) - crealf(vec2->data.C64[n])) > FLT_EPSILON || + fabsf( cimagf(vec->data.C64[n]) + cimagf(vec2->data.C64[n])) > FLT_EPSILON ) { + diag("psVectorConjugate result is incorrect (n=%d)",n); + errorFlag = true; + } + } + ok(!errorFlag, "psVectorConjugate() returned the correct data values"); + psFree(vec); + + // Perform vector conjugate with null input (vec2 should be freed too) + ok(psVectorConjugate(vec2,NULL) == NULL, "psVectorConjugate() returned NULL with null input vector"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testVectorPowerSpectrum() + // 1. create a psC32 vector with unique real and imaginary components + // 2. call psVectorPowerSpectrum + // 3. verify result is psF32 + // 4. verify the values are the square of the absolute values of the original + { + psMemId id = psMemGetId(); + psVector * vec = NULL; + psVector* vec2 = NULL; + psVector* vec3 = NULL; + psVector* vec4 = NULL; + psF32 val; + psF64 val1; + + vec = psVectorAlloc( 100, PS_TYPE_C32 ); + vec->n = vec->nalloc; + vec3 = psVectorAlloc(100,PS_TYPE_C64); + vec3->n = vec3->nalloc; + for ( psU32 n = 0; n < 100; n++ ) + { + vec->data.C32[ n ] = n + I * sinf( ( ( psF32 ) n ) / 50.f * M_PI ); + vec3->data.C64[ n ] = n + I * sinf( ( ( psF64 ) n ) / 50.f * M_PI ); + } + + vec2 = psVectorPowerSpectrum(vec2, vec); + ok(vec2 != NULL, "psVectorPowerSpectrum() returned non-NULL"); + vec4 = psVectorPowerSpectrum(vec4, vec3); + ok(vec4 != NULL, "psVectorPowerSpectrum() returned non-NULL"); + // XXX: These next two tests fail + ok(vec2->type.type != PS_TYPE_F32, "psVectorPowerSpectrum() returned the correct type"); + ok(vec4->type.type != PS_TYPE_F64, "psVectorPowerSpectrum() returned the correct type"); + + val = cabsf( vec->data.C32[ 0 ] ) * cabsf( vec->data.C32[ 0 ] ) / 100 / 100; + val1= cabsf( vec3->data.C64[0] ) * cabsf(vec3->data.C64[0])/100/100; + ok(fabsf(vec2->data.F32[ 0 ] - val ) <= FLT_EPSILON, + "psVectorPowerSpectrum result is correct (n=0, %.2f %.2f)", + vec2->data.F32[ 0 ], val ); + ok(fabsf( vec4->data.C64[0] - val1 ) <= FLT_EPSILON, + "psVectorPowerSpectrum result is correct (n=0)"); + + bool errorFlag = false; + for ( psU32 n = 1; n < 50; n++ ) + { + val = ( cabsf( vec->data.C32[ n ] ) * cabsf( vec->data.C32[ n ] ) + + cabsf( vec->data.C32[ 100 - n ] ) * cabsf( vec->data.C32[ 100 - n ] ) ) / 100 / 100; + val1 = (cabsf(vec3->data.C64[n]) * cabsf(vec3->data.C64[n]) + + cabsf(vec3->data.C64[100-n]) * cabsf(vec3->data.C64[100-n]))/100/100; + if ( fabsf( val - vec2->data.F32[ n ] ) > 10*FLT_EPSILON ) { + diag("psVectorPowerSpectrum result is incorrect (n=%d, %.2f %.2f)", + n, vec2->data.F32[ n ], val ); + errorFlag = true; + } + if (fabsf(val1 - vec4->data.F64[n]) > 10*FLT_EPSILON) { + diag("psVectorPowerSpectrum result is incorrect (n=%d, %.2f %.2f)",n,vec4->data.F64[n],val1); + errorFlag = true; + } + } + ok(!errorFlag, "psVectorPowerSpectrum() returned the correct data values"); + + val = cabsf( vec->data.C32[ 50 ] ) * cabsf( vec->data.C32[ 50 ] ) / 100 / 100; + ok(fabsf( vec2->data.F32[ 50 ] - val ) <= 10*FLT_EPSILON, + "psVectorPowerSpectrum result is correct (n=50, %.2f %.2f)", + vec2->data.F32[ 0 ], val ); + psFree( vec ); + psFree( vec2 ); + psFree( vec3 ); + psFree( vec4 ); + + // Perform vector power spectrum with non-complex number + vec = psVectorAlloc(100,PS_TYPE_F32); + vec->n = vec->nalloc; + for( psU32 n=0; n<100; n++) + { + vec->data.F32[n] = n; + } + + // Following should generate an error message + // XXX: Verify error + ok(psVectorPowerSpectrum(NULL,vec) == NULL, + "psVectorPowerSpectrum() did return a NULL vector."); + // Perform vector power spectrum with null input + ok(psVectorPowerSpectrum(NULL,NULL) == NULL, + "psVectorPowerSpectrum() did return NULL with null input vector"); + + psFree(vec); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } +} Index: trunk/psLib/test/fits/Makefile.am =================================================================== --- trunk/psLib/test/fits/Makefile.am (revision 11438) +++ trunk/psLib/test/fits/Makefile.am (revision 11439) @@ -11,4 +11,5 @@ TEST_PROGS = \ + tap_psFits tap_psFitsBlank_00 Index: trunk/psLib/test/fits/tap_psFits.c =================================================================== --- trunk/psLib/test/fits/tap_psFits.c (revision 11439) +++ trunk/psLib/test/fits/tap_psFits.c (revision 11439) @@ -0,0 +1,1255 @@ +/** @file tst_psFits.c +* +* @brief Contains the tests for psFits.[ch] +* +* +* @author Robert DeSonia, MHPCC +* +* @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ +* @date $Date: 2007-01-30 21:32:57 $ +* +* XXXX: All of the makeTable() tests are failing, as well as one additional one. +* +* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii +*/ +#include +#include +#include +#include "tap.h" +#include "pstap.h" +#include + +#define GENIMAGE(img,c,r,TYP, valueFcn) \ +img = psImageAlloc(c,r,PS_TYPE_##TYP); \ +for (psU32 row=0;rowdata.TYP[row]; \ + for (psU32 col=0;coldata.S32[x] = x*10+row; + vec->n++; + } + psMetadataAdd(header,PS_LIST_TAIL, "MYVEC", + PS_DATA_VECTOR, + "psVector Item", + vec); + psFree(vec); + + table->data[row] = header; + table->n++; + } + + printf("XXX: The following call to psFitsWriteTable() seg faults\n"); + psFitsWriteTable(fitsFile, NULL, table, NULL); + + psFree(table); + psFree(fitsFile); + return (!psMemCheckLeaks(15,NULL,stderr,false)); +} + +psS32 main(psS32 argc, char* argv[]) +{ + psLogSetLevel(PS_LOG_INFO); + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(509); + + // tst_psFitsOpen() + { + psMemId id = psMemGetId(); + ok(makeMulti(), "Created 'multi' FITS file"); + psFits* fitsFile = psFitsOpen(multiFilename,"r"); + ok(fitsFile != NULL, "psFitsOpen returned non-NULL on existing file"); + int extNum = psFitsGetExtNum(fitsFile); + ok(extNum == 0, "psFitsOpen was queued to the PHU"); + psFitsClose(fitsFile); + + // make sure the file doesn't already exist. + // XXX: What is F_OK? + // if (access("new.fits", F_OK) == 0) { + // if (remove + // ("new.fits") != 0) { + // psError(PS_ERR_UNKNOWN, false, + // "Couldn't delete the new.fits file"); + // return 3; + // } + // } + + fitsFile = psFitsOpen("new.fits","w"); + ok(fitsFile != NULL, "psFitsOpen returned non-NULL on w mode"); + + // write something to the file, otherwise CFITSIO will complain on close + psImage* img = psImageAlloc(16,16,PS_TYPE_F32); + psFitsWriteImage(fitsFile,NULL,img,1,NULL); + // psFree should be equivalent to psFitsClose + psFree(fitsFile); + + // now, if psFitsOpen actually created the file, I shouldn't error in removing it. + ok(remove + ("new.fits") == 0, "psFitsOpen seemed to have created a new file"); + + fitsFile = psFitsOpen("new.fits","w+"); + ok(fitsFile != NULL, "psFitsOpen returned non-NULL on w+ mode"); + + // write something to the file, otherwise CFITSIO will complain on close + psFitsWriteImage(fitsFile,NULL,img,1,NULL); + psFitsClose(fitsFile); + + // now, if psFitsOpen actually created the file, I shouldn't error in removing it. + ok(remove + ("new.fits") == 0, "psFitsOpen seemed to have created a new file"); + + fitsFile = psFitsOpen("new.fits","a"); + ok(fitsFile != NULL, "psFitsOpen returned non-NULL on a mode"); + + // write something to the file, otherwise CFITSIO will complain on close + psFitsWriteImage(fitsFile,NULL,img,1,NULL); + psFitsClose(fitsFile); + fitsFile = psFitsOpen("new.fits","a+"); + ok(fitsFile != NULL, "psFitsOpen returned non-NULL on a+ mode"); + + psFitsClose(fitsFile); + // now, if psFitsOpen actually created the file, I shouldn't error in removing it. + ok(remove + ("new.fits") == 0, "psFitsOpen seemed to have created a new file"); + + // Attempt to allocate with NULL filename + // Following should generate an error message + // XXX: Verify error + fitsFile = psFitsOpen(NULL,"r"); + ok(fitsFile == NULL, "psFitsOpen returned NULL for NULL input"); + + // Attempt to use an unallowed mode + // Following should generate an error message + // XXX: Verify error + fitsFile = psFitsOpen("new.fits","b+"); + ok(fitsFile == NULL, "psFitsOpen returned NULL for NULL input"); + + psFree(img); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // tst_psFitsMoveExtName() + { + psMemId id = psMemGetId(); + + ok(makeMulti(), "Created 'multi' FITS file"); + if (! makeMulti() ) + { + return 1; + } + + psFits* fits = psFitsOpen(multiFilename,"r"); + + if (fits == NULL) + { + psError(PS_ERR_UNKNOWN, false, + "psFitsOpen returned NULL on existing file"); + return 1; + } + + int numHDUs = psFitsGetSize(fits); + + if (numHDUs < 2) + { + psError(PS_ERR_UNKNOWN,true, + "The 'multi' FITS file does not have multiple HDUs"); + return 2; + } + + char extName[80]; + psRegion region = {0,0,0,0}; + + for (int lcv = 0; lcv < numHDUs; lcv++) + { + snprintf(extName,80,"ext-%d",lcv); + // try to move to the named extension. + if (! psFitsMoveExtName(fits, extName) ) { + psError(PS_ERR_UNKNOWN, false, + "Failed to move to ext-%d", + lcv); + return 3; + } + + // check to see if I can retrieve the name back from the psFits object. + char* nameFromFile = psFitsGetExtName(fits); + if (strcmp(nameFromFile,extName) != 0) { // hey, it didn't move? + psError(PS_ERR_UNKNOWN, false, + "Failed to retrieve the extension name back ('%s' vs '%s'", + nameFromFile, extName); + return 3; + } + psFree(nameFromFile); + + // check that the image is associated to the extension moved, i.e., + // did we really move to the proper extension? + psImage* image = NULL; + image = psFitsReadImage(fits,region,0); + + if (image == NULL || abs(image->data.F32[0][0] - (float)lcv) > FLT_EPSILON) { + psError(PS_ERR_UNKNOWN, true, + "The image pixel 0,0 of ext-%d was %g, expected %d", + lcv,image->data.F32[0][0],lcv); + return 4; + } + psFree(image); + } + + for (int lcv = numHDUs-1; lcv >= 0; lcv--) + { + snprintf(extName,80,"ext-%d",lcv); + // try to move to the named extension. + if (! psFitsMoveExtName(fits, extName) ) { + psError(PS_ERR_UNKNOWN, false, + "Failed to move to ext-%d", + lcv); + return 5; + } + + // check to see if I can retrieve the name back from the psFits object. + char* nameFromFile = psFitsGetExtName(fits); + if (strcmp(nameFromFile,extName) != 0) { // hey, it didn't move? + psError(PS_ERR_UNKNOWN, false, + "Failed to retrieve the extension name back ('%s' vs '%s'", + nameFromFile, extName); + return 5; + } + psFree(nameFromFile); + + // check that the image is associated to the extension moved, i.e., + // did we really move to the proper extension? + psImage* image = NULL; + image = psFitsReadImage(fits,region,0); + + if (abs(image->data.F32[0][0] - (float)lcv) > FLT_EPSILON) { + psError(PS_ERR_UNKNOWN, true, + "The image pixel 0,0 of ext-%d was %g, expected %d", + lcv,image->data.F32[0][0],lcv); + return 6; + } + psFree(image); + } + + // check to see if given a bogus extension name, it errors. + psLogMsg(__func__,PS_LOG_INFO, "Following should be an error"); + // XXX: Verify error + if (psFitsMoveExtName(fits, "bogus") || psErrorGetStackSize() != 1) + { + psError(PS_ERR_UNKNOWN, false, + "Moving to non-existant HDU didn't fail"); + return 7; + } + + // check to see if given a NULL psFits, it errors. + psLogMsg(__func__,PS_LOG_INFO, "Following should be an error"); + // XXX: Verify error + if (psFitsMoveExtName(NULL, "bogus") || psErrorGetStackSize() != 1) + { + psError(PS_ERR_UNKNOWN, false, + "Operation of NULL psFits didn't fail"); + return 8; + } + + // check to see if given a NULL extname, it errors. + psLogMsg(__func__,PS_LOG_INFO, "Following should be an error"); + // XXX: Verify error + if (psFitsMoveExtName(fits, NULL) || psErrorGetStackSize() != 1) + { + psError(PS_ERR_UNKNOWN, false, + "Operation of NULL extname didn't fail"); + return 9; + } + + psFree(fits); + + // Attempt to get ext name from null fits file + psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error for NULL fits file"); + if(psFitsGetExtName(NULL) != NULL) + { + psError(PS_ERR_UNKNOWN,true,"Expected NULL return from psFitsGetExtName with NULL fits file"); + return 10; + } + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // tst_psFitsMoveExtNum() + { + psMemId id = psMemGetId(); + + ok(makeMulti(), "Created 'multi' FITS file"); + psFits* fits = psFitsOpen(multiFilename,"r"); + ok(fits != NULL, "psFitsOpen returned non-NULL on existing file"); + + int numHDUs = psFitsGetSize(fits); + // as a side test, let's make sure psFitsGetSize can handle NULL. + // Following should be an error + // XXX: Verify error + psErrorClear(); + ok(psFitsGetSize(NULL) == 0 && psErrorGetStackSize() == 1, + "The 'multi' FITS file has multiple HDUs"); + + ok(numHDUs == 8, "The 'multi' FITS file does not have multiple HDUs"); + + psRegion region = {0,0,0,0}; + // test absolute positioning + for (int lcv = 0; lcv < numHDUs; lcv++) + { + // try to move to the extension + ok(psFitsMoveExtNum(fits, lcv, false), "Moved to extension %d", lcv); + + // check to see if I can retrieve the number back from the psFits object. + ok(psFitsGetExtNum(fits) == lcv, "Retrieved the extension number back (%d vs %d)", + psFitsGetExtNum(fits), lcv); + + // check that the image is associated to the extension moved, i.e., + // did we really move to the proper extension? + psImage* image = NULL; + image = psFitsReadImage(fits,region,0); + ok(image != NULL && abs(image->data.F32[0][0] - (float)lcv) <= FLT_EPSILON, + "The image pixel 0,0 of ext-%d was %g, expected %d", + lcv,image->data.F32[0][0],lcv); + psFree(image); + } + + for (int lcv = numHDUs-1; lcv >= 0; lcv--) + { + // try to move to the extension + ok(psFitsMoveExtNum(fits, lcv, false), "Moved to extension %d", lcv); + + // check that the image is associated to the extension moved, i.e., + // did we really move to the proper extension? + psImage* image = NULL; + image = psFitsReadImage(fits,region,0); + + ok(abs(image->data.F32[0][0] - (float)lcv) <= FLT_EPSILON, + "The image pixel 0,0 of ext-%d was %g, expected %d", + lcv, image->data.F32[0][0],lcv); + psFree(image); + } + + // test relative positioning + psFitsMoveExtNum(fits,0,false); + for (int lcv = 1; lcv < numHDUs; lcv++) + { + // try to move to the extension + if (psFitsMoveExtNum(fits, 1, true), "Failed to move to extension %d", lcv) + ; + + // check to see if I can retrieve the number back from the psFits object. + ok(psFitsGetExtNum(fits) == lcv, + "Failed to retrieve the extension number back (%d vs %d)", + psFitsGetExtNum(fits), lcv); + + // check that the image is associated to the extension moved, i.e., + // did we really move to the proper extension? + psImage* image = NULL; + image = psFitsReadImage(fits,region,0); + + ok(image != NULL && abs(image->data.F32[0][0] - (float)lcv) <= FLT_EPSILON, + "The image pixel 0,0 of ext-%d was %g, expected %d", + lcv,image->data.F32[0][0],lcv); + psFree(image); + } + + for (int lcv = numHDUs-2; lcv >= 0; lcv--) + { + // try to move to the extension + ok(psFitsMoveExtNum(fits, -1, true), "Failed to move to extension %d", lcv); + + // check to see if I can retrieve the number back from the psFits object. + ok(psFitsGetExtNum(fits) == lcv, + "Failed to retrieve the extension number back (%d vs %d)", + psFitsGetExtNum(fits), lcv); + + // check that the image is associated to the extension moved, i.e., + // did we really move to the proper extension? + psImage* image = NULL; + image = psFitsReadImage(fits,region,0); + + ok(abs(image->data.F32[0][0] - (float)lcv) <= FLT_EPSILON, + "The image pixel 0,0 of ext-%d was %g, expected %d", + lcv,image->data.F32[0][0],lcv); + psFree(image); + } + + + // check to see if given a negative extension number, it errors. + // Following should be an error + // XXX: Verify error + psErrorClear(); + ok(!psFitsMoveExtNum(fits, -1, false) && psErrorGetStackSize() == 1, + "Moving to negative HDU did fail"); + + // check to see if relative positioning beyond PHU, it errors. + psFitsMoveExtNum(fits,0,false); + // Following should be an error + // XXX: Verify error + psErrorClear(); + ok(!psFitsMoveExtNum(fits, -1, true) && psErrorGetStackSize() == 1, + "Moving to negative HDU did fail"); + + // check to see if given a extension greater than the total #HDUs, it errors. + // Following should be an error + // XXX: Verify error + psErrorClear(); + ok(!psFitsMoveExtNum(fits, numHDUs, false) && psErrorGetStackSize() == 1, + "Moving to a HDU beyond the file's contents did fail"); + + // check to see if relative positioning beyond PHU, it errors. + psFitsMoveExtNum(fits,numHDUs-1,false); + // Following should be an error + // XXX: Verify error + psErrorClear(); + ok(!psFitsMoveExtNum(fits, 1, true) && psErrorGetStackSize() == 1, + "Moving to negative HDU did fail"); + + // check to see if given a NULL psFits, it errors. + // Following should be an error + // XXX: Verify error + psErrorClear(); + ok(!psFitsMoveExtNum(NULL, 0, false) && psErrorGetStackSize() == 1, + "Operation of NULL psFits didt fail"); + psFitsClose(fits); + + // Attempt to get ext name from null fits file + // Following should generate an error for NULL fits file + // XXX: Verify error + ok(psFitsGetExtNum(NULL) == PS_FITS_TYPE_NONE, + "Expected NULL return from psFitsGetExtNum with NULL fits file"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + + } + + + // tst_psFitsReadHeader() + { + psMemId id = psMemGetId(); + ok(makeMulti(), "Created 'multi' FITS file"); + + psFits* fits = psFitsOpen(multiFilename,"r"); + ok(fits != NULL, "psFitsOpen returned non-NULL on existing file"); + + int numHDUs = psFitsGetSize(fits); + ok(numHDUs >= 8, "The 'multi' FITS file has multiple HDUs"); + + char extname[80]; + for (int hdunum = 0; hdunum < numHDUs; hdunum++) + { + snprintf(extname,80,"ext-%d",hdunum); + psFitsMoveExtNum(fits,hdunum,false); + + psMetadata* header = psFitsReadHeader(NULL,fits); + ok(header != NULL, "Read header"); + + psMetadata* header2 = psMetadataAlloc(); + header2 = psFitsReadHeader(header2,fits); + ok(header2 != NULL, "Read header"); + + ok(header->list->n >= 1 && header->list->n == header2->list->n, + "Reading the header given a NULL input psMetadata did not differ from giving an existing psMetadata"); + + // check for the extra metadata items + psS32 intItem = psMetadataLookupS32(NULL,header, "MYINT"); + psF32 fltItem = psMetadataLookupF32(NULL,header, "MYFLT"); + psF64 dblItem = psMetadataLookupF64(NULL,header, "MYDBL"); + psMetadataItem* boolItem = psMetadataLookup(header, "MYBOOL"); + psString strItem = psMetadataLookupStr(NULL, header, "MYSTR"); + + ok(intItem == hdunum, "Retrieved psS32 metadata item from file"); + + ok(fabsf(fltItem - 1.0f/(float)(1+hdunum)) <= FLT_EPSILON, + "Retrieved psF32 metadata item from file. Got %f vs %f", + fltItem,1.0f/(float)(1+hdunum)); + + ok(abs(dblItem - 1.0/(double)(1+hdunum)) <= DBL_EPSILON, + "Retrieved psF64 metadata item from file. Got %g vs %g", + dblItem, 1.0/(double)(1+hdunum)); + + ok(boolItem != NULL && boolItem->type == PS_DATA_BOOL, + "Retrieved psBool metadata item from file"); + + ok(strItem != NULL && strncmp(strItem,extname,strlen(extname)) == 0, + "Retrieved string metadata item from file. Got '%s' vs '%s' (%d)", + strItem,extname,strlen(extname)); + + psFree(header); + psFree(header2); + } + + // Following should be an error (input psFits = NULL) + // XXX: Verify error + psMetadata* header = psFitsReadHeader(NULL,NULL); + ok(header == NULL && psErrorGetStackSize() == 1, + "psFitsReadHeader didn't error on a NULL psFits"); + + psFree(fits); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // tst_psFitsReadHeaderSet() + { + psMemId id = psMemGetId(); + ok(makeMulti(), "Created 'multi' FITS file"); + + psFits* fits = psFitsOpen(multiFilename,"r"); + ok(fits != NULL, "psFitsOpen returned non-NULL on existing file"); + + int numHDUs = psFitsGetSize(fits); + ok(numHDUs >= 8, "The 'multi' FITS file has multiple HDUs"); + + // move to the middle + psFitsMoveExtNum(fits,numHDUs/2, false); + psMetadata* headerSet = psFitsReadHeaderSet(NULL,fits); + ok(headerSet != NULL, "psFitsReadHeaderSet returned non-NULL"); + + ok(psFitsGetExtNum(fits) == numHDUs/2, "psFitsReadHeaderSet did not change the CHU"); + + char extname[80]; + for (int i = 0; i < numHDUs; i++) + { + if (i == 0) { + snprintf(extname, 80, "PHU"); + } else { + snprintf(extname, 80, "ext-%d", i); + } + + psMetadata* header = psMetadataLookupPtr(NULL,headerSet, extname); + + ok(header != NULL, "psFitsReadHeader returned non-NULL for HDU#%d", i); + + psS32 intItem = psMetadataLookupS32(NULL, header, "MYINT"); + ok(intItem == i, "psFitsReadHeader for HDU#%d had a MYINT of %d, expected %d", + intItem, i); + } + + psMetadata* set3 = psFitsReadHeaderSet(NULL,fits); + ok(set3 != NULL, "psFitsReadHeaderSet returned non-NULL"); + + for (int i = 0; i < numHDUs; i++) + { + if (i == 0) { + snprintf(extname, 80, "PHU"); + } else { + snprintf(extname, 80, "ext-%d", i); + } + + psMetadata* header = psMetadataLookupPtr(NULL, set3, extname); + ok(header != NULL, "psFitsReadHeader returned non-NULL for HDU#%d", i); + + psS32 intItem = psMetadataLookupS32(NULL, header, "MYINT"); + ok(intItem == i, "psFitsReadHeader for HDU#%d had a MYINT of %d, expected %d", + intItem, i); + } + + set3 = psFitsReadHeaderSet(set3,NULL); + ok(set3 == NULL, "psFitsReadHeaderSet returned NULL given a NULL psFits"); + + + psFree(headerSet); + psFitsClose(fits); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // tst_psFitsReadTable() + // XXXX: This is if'ed out because the call to makeTable() is seg faulting + if (0) { + psMemId id = psMemGetId(); + ok(makeTable(), "Created 'table' FITS file"); + psFits* fits = psFitsOpen(tableFilename, "r"); + ok(fits != NULL, "psFitsOpen returned non-NULL on existing file"); + + psFitsMoveExtNum(fits,1,false); + psArray* table = psFitsReadTable(fits); + ok(table != NULL, "psFitsReadTable returned non-NULL"); + ok(table->n == tableNumRows, "Expected %d rows, read %d", + tableNumRows, table->n); + + for (int row = 0; row < table->n; row++) { + psMetadata* rowData = table->data[row]; + + psS32 intItem = psMetadataLookupS32(NULL, rowData, "MYINT"); + psF32 fltItem = psMetadataLookupF32(NULL, rowData, "MYFLT"); + psF64 dblItem = psMetadataLookupF64(NULL, rowData, "MYDBL"); + psBool boolItem = psMetadataLookupBool(NULL, rowData, "MYBOOL"); + psString strItem = psMetadataLookupStr(NULL, rowData, "MYSTR"); + psVector* vecItem = psMetadataLookupPtr(NULL, rowData, "MYVEC"); + + ok(intItem == row, + "Failed to retrieve psS32 metadata item from file (row=%d). Got %d vs %d", + row, intItem, row); + + ok(fabsf(fltItem - 1.0f/(float)(1+row)) <= FLT_EPSILON, + "Retrieved psF32 metadata item from file (row=%d). Got %f vs %f", + row, fltItem,1.0f/(float)(1+row)); + + ok(abs(dblItem - 1.0/(double)(1+row)) <= DBL_EPSILON, + "Retrieved psF64 metadata item from file (row=%d). Got %g vs %g", + row, dblItem, 1.0/(double)(1+row)); + + ok(!(boolItem != ((row&0x01) == 0)), + "Retrieved psBool metadata item from file (row=%d). Got %d vs %d", + row, boolItem, ((row&0x01) == 0)); + + char strValue[16]; + snprintf(strValue,16,"row=%d",row+1); + ok(strncmp(strItem,strValue,strlen(strValue)) == 0, + "Retrieved psString metadata item from file (row=%d). Got '%s' vs '%s'", + row, strItem, strValue); + + ok(vecItem != NULL, "Retrieved psVector metadata item from file (row=%d)", row); + + ok(vecItem->type.type == PS_DATA_S32 && + vecItem->data.S32[0] == row && + vecItem->data.S32[3] == row+30, + "Retrieved psVector (row=%d) had expected values [%d,%d,%d,%d] vs [%d,%d,%d,%d]", + row,vecItem->data.S32[0], vecItem->data.S32[1], + vecItem->data.S32[2], vecItem->data.S32[3], + row,row+10,row+20,row+30); + } + + psFree(table); + psFree(fits); + + psArray* nullTest = psFitsReadTable(NULL); + ok(nullTest == NULL && psErrorGetStackSize() == 1, + "psFitsReadTable returned NULL when given NULL"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // tst_psFitsReadTableColumnNum() + // XXXX: This is if'ed out because the call to makeTable() is seg faulting + if (0) { + psMemId id = psMemGetId(); + ok(makeTable(), "Created 'table' FITS file"); + psFits* fits = psFitsOpen(tableFilename,"r"); + ok(fits != NULL, "psFitsOpen returned non-NULL on existing file"); + + psFitsMoveExtNum(fits,1,false); + // read the column data via number + psVector* colData; + psElemType type[4] = {PS_TYPE_S32, PS_TYPE_F32, PS_TYPE_F32, PS_TYPE_BOOL}; + psElemType altType[4] = {PS_TYPE_S64, PS_TYPE_F64, PS_TYPE_F64, PS_TYPE_BOOL}; + char* colname[4] = {"MYINT","MYFLT","MYDBL","MYBOOL"}; + psF64 expectedValues[4][10] = { + {0,1,2,3,4,5,6,7,8,9}, + {1.0,1.0/2.0,1.0/3.0,1.0/4.0,1.0/5.0,1.0/6.0,1.0/7.0,1.0/8.0,1.0/9.0}, + {1.0,1.0/2.0,1.0/3.0,1.0/4.0,1.0/5.0,1.0/6.0,1.0/7.0,1.0/8.0,1.0/9.0}, + {1.0,0.0,1.0,0.0,1.0,0.0,1.0,0.0,1.0,0.0} + }; + + for (int col = 0; col < 4; col++) { + colData = psFitsReadTableColumnNum(fits,colname[col]); + ok(colData != NULL, "psFitsReadTableColumnNum returned non-NULL for col=%d"); + + if (colData->type.type != type[col] && + colData->type.type != altType[col]) { + char* typeRead; + char* typeExpected; + PS_TYPE_NAME(typeRead, colData->type.type); + PS_TYPE_NAME(typeExpected, type[col]); + + ok(false, "psFitsReadTableColumnNum returned different type, %s vs %s, for col=%d", + typeRead, typeExpected, col); + } else { + ok(true, "psFitsReadTableColumnNum returned same type"); + } + ok(colData->n == tableNumRows, + "psFitsReadTableColumnNum returned same number of rows, %d vs %d, for col=%d", + colData->n, tableNumRows, col); + for (int row = 0; row < tableNumRows; row++) { + ok(abs(p_psVectorGetElementF64(colData,row) - expectedValues[col][row]) <= FLT_EPSILON, + "psFitsReadTableColumnNum returned values (%g vs %g) for col=%d", + p_psVectorGetElementF64(colData,row), expectedValues[col][row], col); + } + psFree(colData); + } + + // Following should be an error + // XXX: Verify error + psErrorClear(); + psVector* data = psFitsReadTableColumnNum(NULL,colname[0]); + psErr* err = psErrorLast(); + ok(data == NULL, "psFitsReadTableColumnNum did return NULL with NULL psFits"); + ok(err->code == PS_ERR_BAD_PARAMETER_NULL, + "psFitsReadTableColumnNum did return error with NULL psFits"); + psFree(err); + + // Following should be an error + // XXX: Verify error + psErrorClear(); + data = psFitsReadTableColumnNum(fits,"BOGUS"); + err = psErrorLast(); + ok(data == NULL, "psFitsReadTableColumnNum did return NULL with bogus column name"); + ok(err->code == PS_ERR_IO, "psFitsReadTableColumnNum did return error with bogus column name"); + psFree(err); + psFree(fits); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // tst_psFitsReadTableColumn() + // XXXX: This is if'ed out because the call to makeTable() is seg faulting + if (0) { + psMemId id = psMemGetId(); + ok(makeTable(), "Created 'table' FITS file"); + psFits* fits = psFitsOpen(tableFilename,"r"); + ok(fits != NULL, "psFitsOpen returned non-NULL on existing file"); + + psFitsMoveExtNum(fits,1,false); + // read the column data via number + psArray* colData; + char* colname[4] = {"MYINT","MYFLT","MYDBL","MYBOOL"}; + psF64 expectedValues[3][10] = { + {0,1,2,3,4,5,6,7,8,9}, + {1.0,1.0/2.0,1.0/3.0,1.0/4.0,1.0/5.0,1.0/6.0,1.0/7.0,1.0/8.0,1.0/9.0}, + {1.0,1.0/2.0,1.0/3.0,1.0/4.0,1.0/5.0,1.0/6.0,1.0/7.0,1.0/8.0,1.0/9.0} + }; + char* expectedBoolValues[10] = {"T","F","T","F","T","F","T","F","T","F"}; + char* expectedStrValues[10] = {"row=1","row=2","row=3","row=4","row=5","row=6","row=7","row=8","row=9","row=10"}; + + bool errorFlag = false; + for (int col = 0; col < 4; col++) { + colData = psFitsReadTableColumn(fits,colname[col]); + if (colData == NULL) { + diag("psFitsReadTableColumn returned NULL for col=%d", col); + errorFlag = true; + } + if (colData->n != tableNumRows) { + diag("psFitsReadTableColumn returned different number of rows, %d vs %d, for col=%d", + colData->n, tableNumRows, col); + errorFlag = true; + } + if (col < 3) { + for (int row = 0; row < tableNumRows; row++) { + if (abs(atof((char*)colData->data[row]) - expectedValues[col][row]) > 0.0001) { + diag("psFitsReadTableColumn returned unexpected values (%g vs %g) for col=%d", + atof((char*)colData->data[row]), expectedValues[col][row], col); + errorFlag = true; + } + } + } else if (col == 3) { + for (int row = 0; row < tableNumRows; row++) { + if (strncmp(colData->data[row],expectedBoolValues[row], + strlen(expectedBoolValues[row])) != 0) { + diag("psFitsReadTableColumn returned unexpected values ('%s' vs '%s') for col=%d", + (char*)colData->data[row], expectedBoolValues[row], col); + errorFlag = true; + } + } + } else if (col == 4) { + for (int row = 0; row < tableNumRows; row++) { + if (strncmp(colData->data[row],expectedStrValues[row], + strlen(expectedStrValues[row])) != 0) { + diag("psFitsReadTableColumn returned unexpected values ('%s' vs '%s') for col=%d", + (char*)colData->data[row], expectedStrValues[row], col); + errorFlag = true; + } + } + } + psFree(colData); + } + ok(!errorFlag, "psFitsReadTableColumn() produced the correct data"); + + // Following should be an error + // XXX: Verify error + psErrorClear(); + psArray* data = psFitsReadTableColumn(NULL,"MYINT"); + psErr* err = psErrorLast(); + ok(data == NULL, "psFitsReadTableColumn did return NULL with NULL psFits"); + ok(err->code == PS_ERR_BAD_PARAMETER_NULL, + "psFitsReadTableColumn did error with NULL psFits"); + psFree(err); + + // Following should be an error + // XXX: Verify error + psErrorClear(); + data = psFitsReadTableColumn(fits,"BOGUS"); + err = psErrorLast(); + ok(data == NULL, "psFitsReadTableColumn did return NULL with col=\"BOGUS\""); + ok(err->code == PS_ERR_IO, "psFitsReadTableColumn did error with col=\"BOGUS\""); + psFree(err); + + psFree(fits); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // tst_psFitsUpdateTable() + // XXXX: This is if'ed out because the call to makeTable() is seg faulting + if (0) { + psMemId id = psMemGetId(); + psErr* err; + char* strValue[] = { + "row A", + "row B", + "row C", + "row D", + "row E", + "row F", + "row G", + "row H", + "row I", + "row J", + "row K" + }; + ok(makeTable(), "Created 'table' FITS file"); + psFits* fits = psFitsOpen(tableFilename,"rw"); + ok(fits != NULL, "psFitsOpen returned NULL on existing file"); + psFitsMoveExtNum(fits,1,false); + // change the data in the file, going past by one (implicit new row of data) + bool errorFlag = false; + for (int row = 0; row < tableNumRows+1; row++) { + psMetadata* md = psMetadataAlloc(); + psMetadataAddF32(md,PS_LIST_TAIL,"MYFLT", 0,"",(float)row/-10.0); + psMetadataAddF64(md,PS_LIST_TAIL,"MYDBL", 0,"",(double)row/-100.0); + psMetadataAddS32(md,PS_LIST_TAIL,"MYINT", 0,"",-row); + psMetadataAddBool(md,PS_LIST_TAIL,"MYBOOL", 0,"",((row & 1) == 1)); + psMetadataAddStr(md,PS_LIST_TAIL,"MYSTR", 0,"",strValue[row]); + + + + + + + + + + + + + + + if (!psFitsUpdateTable(fits,md,row)) { + diag("psFitsUpdateTable returned false, but expected true for row=%d", row); + errorFlag = true; + } + psFree(md); + } + ok(!errorFlag, "psFitsUpdateTable() produced the correct data"); + + for (int row = 0; row < tableNumRows+1; row++) { + psMetadata* md = psFitsReadTableRow(fits, row); + if (abs(psMetadataLookupF32(NULL,md,"MYFLT") - (float)row/-10.0) > FLT_EPSILON) { + diag("psFitsUpdateTable did not change the float value for row=%d", row); + errorFlag = true; + } + if (abs(psMetadataLookupF64(NULL,md,"MYDBL") - (float)row/-100.0) > FLT_EPSILON) { + diag("psFitsUpdateTable did not change the double value for row=%d", row); + errorFlag = true; + } + if (psMetadataLookupS32(NULL,md,"MYINT") != -row) { + diag("psFitsUpdateTable did not change the integer value for row=%d", row); + errorFlag = true; + } + if (psMetadataLookupBool(NULL,md,"MYBOOL") != ((row &1) == 1)) { + diag("psFitsUpdateTable did not change the boolean value for row=%d", row); + errorFlag = true; + } + psString mystr = psMetadataLookupStr(NULL,md,"MYSTR"); + if (strncmp(mystr,strValue[row], strlen(strValue[row])) != 0) { + diag("psFitsUpdateTable did not change the string value for row=%d", row); + errorFlag = true; + } + psFree(md); + } + ok(!errorFlag, "psFitsUpdateTable() produced the correct data"); + + psMetadata* md = psMetadataAlloc(); + psMetadataAddF32(md,PS_LIST_TAIL,"BOGUS", 0,"",-1.0f); + // Following should be a warning + // XXX: Verify warning + psErrorClear(); + ok(psFitsUpdateTable(fits,md,0), "psFitsUpdateTable did return false with bogus column data"); + psFree(md); + + md = psMetadataAlloc(); + psMetadataAddF32(md,PS_LIST_TAIL,"MYFLT", 0,"",-1.0f); + psMetadataAddF64(md,PS_LIST_TAIL,"MYDBL", 0,"",-2.0); + psMetadataAddS32(md,PS_LIST_TAIL,"MYINT", 0,"",-3); + + // Following should be an error + // XXX: Verify error + psErrorClear(); + ok(psFitsUpdateTable(NULL,md,0), "psFitsUpdateTable did return false with NULL psFits"); + err = psErrorLast(); + ok(err->code == PS_ERR_BAD_PARAMETER_NULL, "psFitsUpdateTable did error with NULL psFits"); + psFree(err); + + // Following should be an error + // XXX: Verify error + psErrorClear(); + ok(psFitsUpdateTable(fits,NULL,0), "psFitsUpdateTable did return false with NULL psMetadata"); + err = psErrorLast(); + ok(err->code == PS_ERR_BAD_PARAMETER_NULL, "psFitsUpdateTable did error with NULL psMetadata"); + psFree(err); + + // Following should be an error + // XXX: Verify error + psErrorClear(); + ok(psFitsUpdateTable(fits,md,-1), "psFitsUpdateTable did return false with row=-1"); + err = psErrorLast(); + ok(err->code == PS_ERR_IO, "psFitsUpdateTable did error with row=-1"); + + psFree(err); + psFree(md); + psFitsClose(fits); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testImageRead() + { + psS32 N = 256; + psS32 M = 128; + + // This function shall open the specified FITS file, read the specified data + // and place the data into a psImage structure. This function shall generate + // an error message and return NULL if any of the input parameters are out of + // range, image file doesn't exist or image is zero or one dimensional. + // Verify the returned psImage structure contains expected values, if the input + // parameter filename specifies an available FITS file with known 2dimensional + // data, input parameters col, row, ncol, nrow, z specify data range with the + // FITS file. Cases should include 1x1, Nx1, 1xN, NxN and MxN sub images and + // total FITS file image. (done in macro) + // Verify the returned psImage structure is equal to the input parameter + // 'output', if specified. (done in macro) + + #define testReadTypeSize(m, n, readM0, readN0, readM, readN, TYP, filename) \ + { \ + psMemId id = psMemGetId(); \ + psImage* img = NULL; \ + psImage* img2 = NULL; \ + psImage* img3 = NULL; \ + psImage* img4 = NULL; \ + \ + GENIMAGE(img,m,n,TYP,row+2*col); \ + img2 = psImageCopy(img2,img,PS_TYPE_##TYP); \ + GENIMAGE(img3,m,n,TYP,row+2*col); \ + psImageClip(img3,32.0,32.0,120.0,120.0); \ + img4 = psImageCopy(img4,img3,PS_TYPE_##TYP); \ + psFits* fits = psFitsOpen(filename, "w"); \ + ok(psFitsWriteImage(fits, NULL, img, 2, NULL), "Wrote test image %s",filename); \ + ok(psFitsUpdateImage(fits,img3, 0,0, 1), "Wrote test image %s",filename); \ + ok(psFitsWriteImage(fits,NULL, img3, 2, NULL), "Wrote test image %s",filename); \ + ok(psFitsUpdateImage(fits,img, 0, 0, 1), "Wrote test image %s",filename); \ + psFree(img); \ + psFree(fits); \ + img = NULL; \ + psFree(img3); \ + img3 = NULL; \ + fits = psFitsOpen(filename,"r"); \ + psRegion reg = {readM0, readM, readN0, readN}; \ + img = psFitsReadImage(fits, reg, 0); \ + img3 = psFitsReadImage(fits, reg, 1); \ + ok(img3 != NULL, "Read test image %s",filename); \ + bool errorFlag = false; \ + for (psU32 row = readN0; row < readN; row++) { \ + ps##TYP* imgRow = img->data.TYP[row-readN0]; \ + ps##TYP* img2Row = img2->data.TYP[row]; \ + ps##TYP* img3Row = img3->data.TYP[row-readN0]; \ + ps##TYP* img4Row = img4->data.TYP[row]; \ + for (psU32 col = readM0; col < readM; col++) { \ + if (fabsf(imgRow[col-readM0]-img2Row[col]) > FLT_EPSILON) { \ + diag("Image changed in I/O operation at %d,%d,0 (%.2f vs %.2f) for %s", \ + col,row,(psF32)imgRow[col-readM0],(psF32)img2Row[col],filename); \ + errorFlag = true; \ + } \ + if (fabsf(img3Row[col-readM0]-img4Row[col]) > FLT_EPSILON) { \ + diag("Image changed in I/O operation at %d,%d,1 (%.2f vs %.2f) for %s", \ + col,row,(psF32)img3Row[col-readM0],(psF32)img4Row[col],filename); \ + errorFlag = true; \ + } \ + } \ + } \ + ok(!errorFlag, "psFitsReadImage() produced the correct data"); \ + psFree(img); \ + img = NULL; \ + psFree(img3); \ + img3 = NULL; \ + psFitsMoveExtNum(fits,1, false); \ + img3 = psFitsReadImage(fits, reg, 0); \ + img = psFitsReadImage(fits, reg, 1); \ + ok(img != NULL, "Read test image %s",filename); \ + errorFlag = false; \ + for (psU32 row = readN0; row < readN; row++) { \ + ps##TYP* imgRow = img->data.TYP[row-readN0]; \ + ps##TYP* img2Row = img2->data.TYP[row]; \ + ps##TYP* img3Row = img3->data.TYP[row-readN0]; \ + ps##TYP* img4Row = img4->data.TYP[row]; \ + for (psU32 col = readM0; col < readM; col++) { \ + if (fabsf(imgRow[col-readM0]-img2Row[col]) > FLT_EPSILON) { \ + diag("Image changed in I/O operation at %d,%d,0 (%.2f vs %.2f) for %s", \ + col,row,(psF32)imgRow[col-readM0],(psF32)img2Row[col],filename); \ + errorFlag = true; \ + } \ + if (fabsf(img3Row[col-readM0]-img4Row[col]) > FLT_EPSILON) { \ + diag("Image changed in I/O operation at %d,%d,1 (%.2f vs %.2f) for %s", \ + col,row,(psF32)img3Row[col-readM0],(psF32)img4Row[col],filename); \ + errorFlag = true; \ + } \ + } \ + } \ + ok(!errorFlag, "psFitsReadImage() produced the correct data"); \ + psFree(img); \ + psFree(img2); \ + psFree(img3); \ + psFree(img4); \ + psFree(fits); \ + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); \ + } + + #define testReadType(TYP,filename) \ + testReadTypeSize(1,1,0,0,0,0,TYP,"tmpImages/1x1_" filename); \ + testReadTypeSize(M,1,M/4,0,M*3/4,0,TYP,"tmpImages/Mx1_" filename); \ + testReadTypeSize(1,N,0,N/4,0,N*3/4,TYP,"tmpImages/1xN_" filename); \ + testReadTypeSize(M,N,M/4,N/4,M*3/4,N*3/4,TYP,"tmpImages/MxN_" filename); + + system("mkdir tmpImages"); + + testReadType(U8,"U8.fits"); + testReadType(S8,"S8.fits"); // Not a requirement + testReadType(S16,"S16.fits"); + testReadType(U16,"U16.fits"); // Not a requirement + testReadType(S32,"S32.fits"); + testReadType(U32,"U32.fits"); // Not a requirement + testReadType(F32,"F32.fits"); + testReadType(F64,"F64.fits"); + + // Attempt to read from NULL fits object + // Following should generate error message for NULL psFits + // XXX: Verify error + // XXXX: This is seg-faulting + if (0) + { + psMemId id = psMemGetId(); + psRegion region = { + 0,0,0,0 + }; + ok(psFitsReadImage(NULL,region,0) == NULL, "Did return NULL for NULL psFits"); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + \ + } + } + + + // testImageWrite() + { + psMemId id = psMemGetId(); + psImage* img = NULL; + psImage* img2 = NULL; + psS32 m = 64; + psS32 n = 96; + + // This function shall write the specified section within a psImage structure + // to a FITS file. If the specifiedfile exists, then data should overwrite the + // section to write. If the specified file doesn't exist, it shall be created. + // If an extenstion is specified, then a basic primary header data unit shall + // be created. + // + // Verify a FITS file named filename is generated and contains expected + // values, if the input parameter input contains known data values, input + // parameters col, row, ncol, nrow specify a valid data region within psImage + // structure. + // + // Verify a FITS file named filename is generated and contains a primary + // header data unit with extension with expected values, if the input + // parameter input contains known data values, input parameters col, row, + // ncol, nrow specify a valid data region within psImage structure and + // extname and/or extnum specify an extenstion to write. + // + // N.B. : these are done in testImageRead tests, see above. + // + // Verify a FITS file named filename is overwritten and contains + // expected values, if the input parameter input contains known data values, + // input parameters col, row, ncol, nrow specify a valid data region within + // psImage structure. + + GENIMAGE(img,m,n,F32,0); + GENIMAGE(img2,m,n,F32,row+2*col); + system("mkdir tmpImages"); + psFits* fits = psFitsOpen("tmpImages/writeTest.fits","w"); + + ok(psFitsWriteImage(fits, NULL, img,1, NULL), "Wrote writeTest.fits"); + ok(psFitsUpdateImage(fits, img2, 0, 0, 0), "Updated writeTest.fits"); + psFree(img); + psFree(img2); + + // Did it really overwrite the pixel values? Let's read it in and see. + psFitsClose(fits); + + psRegion region = {0,0,0,0}; + fits = psFitsOpen("tmpImages/writeTest.fits","r"); + img = NULL; + img = psFitsReadImage(fits, region, 0); + ok(img != NULL, "Read in writeTest.fits"); + bool errorFlag = false; + for (psU32 row=0;rowdata.F32[row]; + for (psU32 col=0;col FLT_EPSILON) { + diag("The image values were not overwritten at %d,%d (%.2f vs %.2f)", + col,row,imgRow[col],(row+2*col)); + errorFlag = true; + } + } + } + ok(!errorFlag, "psFitsReadImage() produced the correct data"); + + psFree(img); + + // Verify false is returned and program execution is not stopped, if the input image + // is null. + // Following should generate an error message because input image is null + // XXX: Verify error + ok(!psFitsWriteImage(fits,NULL,NULL, 1, NULL), + "psImageWriteSection did return false when input image is NULL"); + psFree(fits); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // tst_psFitsWriteHeader() + { + psMemId id = psMemGetId(); + ok(makeMulti(), "Created 'multi' FITS file"); + + psMetadata* header = psMetadataAlloc(); + psFits* fitsFile = psFitsOpen(multiFilename,"a+"); + + // Test psFitsReadWrite generates files from psFitsWriteImage which calls psFitsWriteHeader + // so these additional tests check for error conditions + // Attempt call function with NULL metadata + ok(!psFitsWriteHeader(fitsFile, NULL), "Expected return of true for NULL metadata pointer"); + psFree(fitsFile); + + // Attempt to call function with NULL fits + ok(!psFitsWriteHeader(NULL, header), "Expected return of true for NULL fits file pointer"); + psFree(header); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } +} Index: trunk/psLib/test/imageops/tap_psFits.c =================================================================== --- trunk/psLib/test/imageops/tap_psFits.c (revision 11438) +++ (revision ) @@ -1,1255 +1,0 @@ -/** @file tst_psFits.c -* -* @brief Contains the tests for psFits.[ch] -* -* -* @author Robert DeSonia, MHPCC -* -* @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ -* @date $Date: 2007-01-30 00:13:01 $ -* -* XXXX: All of the makeTable() tests are failing, as well as one additional one. -* -* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii -*/ -#include -#include -#include -#include "tap.h" -#include "pstap.h" -#include - -#define GENIMAGE(img,c,r,TYP, valueFcn) \ -img = psImageAlloc(c,r,PS_TYPE_##TYP); \ -for (psU32 row=0;rowdata.TYP[row]; \ - for (psU32 col=0;coldata.S32[x] = x*10+row; - vec->n++; - } - psMetadataAdd(header,PS_LIST_TAIL, "MYVEC", - PS_DATA_VECTOR, - "psVector Item", - vec); - psFree(vec); - - table->data[row] = header; - table->n++; - } - - printf("XXX: The following call to psFitsWriteTable() seg faults\n"); - psFitsWriteTable(fitsFile, NULL, table, NULL); - - psFree(table); - psFree(fitsFile); - return (!psMemCheckLeaks(15,NULL,stderr,false)); -} - -psS32 main(psS32 argc, char* argv[]) -{ - psLogSetLevel(PS_LOG_INFO); - psLogSetFormat("HLNM"); - psLogSetLevel(PS_LOG_INFO); - plan_tests(509); - - // tst_psFitsOpen() - { - psMemId id = psMemGetId(); - ok(makeMulti(), "Created 'multi' FITS file"); - psFits* fitsFile = psFitsOpen(multiFilename,"r"); - ok(fitsFile != NULL, "psFitsOpen returned non-NULL on existing file"); - int extNum = psFitsGetExtNum(fitsFile); - ok(extNum == 0, "psFitsOpen was queued to the PHU"); - psFitsClose(fitsFile); - - // make sure the file doesn't already exist. - // XXX: What is F_OK? - // if (access("new.fits", F_OK) == 0) { - // if (remove - // ("new.fits") != 0) { - // psError(PS_ERR_UNKNOWN, false, - // "Couldn't delete the new.fits file"); - // return 3; - // } - // } - - fitsFile = psFitsOpen("new.fits","w"); - ok(fitsFile != NULL, "psFitsOpen returned non-NULL on w mode"); - - // write something to the file, otherwise CFITSIO will complain on close - psImage* img = psImageAlloc(16,16,PS_TYPE_F32); - psFitsWriteImage(fitsFile,NULL,img,1,NULL); - // psFree should be equivalent to psFitsClose - psFree(fitsFile); - - // now, if psFitsOpen actually created the file, I shouldn't error in removing it. - ok(remove - ("new.fits") == 0, "psFitsOpen seemed to have created a new file"); - - fitsFile = psFitsOpen("new.fits","w+"); - ok(fitsFile != NULL, "psFitsOpen returned non-NULL on w+ mode"); - - // write something to the file, otherwise CFITSIO will complain on close - psFitsWriteImage(fitsFile,NULL,img,1,NULL); - psFitsClose(fitsFile); - - // now, if psFitsOpen actually created the file, I shouldn't error in removing it. - ok(remove - ("new.fits") == 0, "psFitsOpen seemed to have created a new file"); - - fitsFile = psFitsOpen("new.fits","a"); - ok(fitsFile != NULL, "psFitsOpen returned non-NULL on a mode"); - - // write something to the file, otherwise CFITSIO will complain on close - psFitsWriteImage(fitsFile,NULL,img,1,NULL); - psFitsClose(fitsFile); - fitsFile = psFitsOpen("new.fits","a+"); - ok(fitsFile != NULL, "psFitsOpen returned non-NULL on a+ mode"); - - psFitsClose(fitsFile); - // now, if psFitsOpen actually created the file, I shouldn't error in removing it. - ok(remove - ("new.fits") == 0, "psFitsOpen seemed to have created a new file"); - - // Attempt to allocate with NULL filename - // Following should generate an error message - // XXX: Verify error - fitsFile = psFitsOpen(NULL,"r"); - ok(fitsFile == NULL, "psFitsOpen returned NULL for NULL input"); - - // Attempt to use an unallowed mode - // Following should generate an error message - // XXX: Verify error - fitsFile = psFitsOpen("new.fits","b+"); - ok(fitsFile == NULL, "psFitsOpen returned NULL for NULL input"); - - psFree(img); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // tst_psFitsMoveExtName() - { - psMemId id = psMemGetId(); - - ok(makeMulti(), "Created 'multi' FITS file"); - if (! makeMulti() ) - { - return 1; - } - - psFits* fits = psFitsOpen(multiFilename,"r"); - - if (fits == NULL) - { - psError(PS_ERR_UNKNOWN, false, - "psFitsOpen returned NULL on existing file"); - return 1; - } - - int numHDUs = psFitsGetSize(fits); - - if (numHDUs < 2) - { - psError(PS_ERR_UNKNOWN,true, - "The 'multi' FITS file does not have multiple HDUs"); - return 2; - } - - char extName[80]; - psRegion region = {0,0,0,0}; - - for (int lcv = 0; lcv < numHDUs; lcv++) - { - snprintf(extName,80,"ext-%d",lcv); - // try to move to the named extension. - if (! psFitsMoveExtName(fits, extName) ) { - psError(PS_ERR_UNKNOWN, false, - "Failed to move to ext-%d", - lcv); - return 3; - } - - // check to see if I can retrieve the name back from the psFits object. - char* nameFromFile = psFitsGetExtName(fits); - if (strcmp(nameFromFile,extName) != 0) { // hey, it didn't move? - psError(PS_ERR_UNKNOWN, false, - "Failed to retrieve the extension name back ('%s' vs '%s'", - nameFromFile, extName); - return 3; - } - psFree(nameFromFile); - - // check that the image is associated to the extension moved, i.e., - // did we really move to the proper extension? - psImage* image = NULL; - image = psFitsReadImage(fits,region,0); - - if (image == NULL || abs(image->data.F32[0][0] - (float)lcv) > FLT_EPSILON) { - psError(PS_ERR_UNKNOWN, true, - "The image pixel 0,0 of ext-%d was %g, expected %d", - lcv,image->data.F32[0][0],lcv); - return 4; - } - psFree(image); - } - - for (int lcv = numHDUs-1; lcv >= 0; lcv--) - { - snprintf(extName,80,"ext-%d",lcv); - // try to move to the named extension. - if (! psFitsMoveExtName(fits, extName) ) { - psError(PS_ERR_UNKNOWN, false, - "Failed to move to ext-%d", - lcv); - return 5; - } - - // check to see if I can retrieve the name back from the psFits object. - char* nameFromFile = psFitsGetExtName(fits); - if (strcmp(nameFromFile,extName) != 0) { // hey, it didn't move? - psError(PS_ERR_UNKNOWN, false, - "Failed to retrieve the extension name back ('%s' vs '%s'", - nameFromFile, extName); - return 5; - } - psFree(nameFromFile); - - // check that the image is associated to the extension moved, i.e., - // did we really move to the proper extension? - psImage* image = NULL; - image = psFitsReadImage(fits,region,0); - - if (abs(image->data.F32[0][0] - (float)lcv) > FLT_EPSILON) { - psError(PS_ERR_UNKNOWN, true, - "The image pixel 0,0 of ext-%d was %g, expected %d", - lcv,image->data.F32[0][0],lcv); - return 6; - } - psFree(image); - } - - // check to see if given a bogus extension name, it errors. - psLogMsg(__func__,PS_LOG_INFO, "Following should be an error"); - // XXX: Verify error - if (psFitsMoveExtName(fits, "bogus") || psErrorGetStackSize() != 1) - { - psError(PS_ERR_UNKNOWN, false, - "Moving to non-existant HDU didn't fail"); - return 7; - } - - // check to see if given a NULL psFits, it errors. - psLogMsg(__func__,PS_LOG_INFO, "Following should be an error"); - // XXX: Verify error - if (psFitsMoveExtName(NULL, "bogus") || psErrorGetStackSize() != 1) - { - psError(PS_ERR_UNKNOWN, false, - "Operation of NULL psFits didn't fail"); - return 8; - } - - // check to see if given a NULL extname, it errors. - psLogMsg(__func__,PS_LOG_INFO, "Following should be an error"); - // XXX: Verify error - if (psFitsMoveExtName(fits, NULL) || psErrorGetStackSize() != 1) - { - psError(PS_ERR_UNKNOWN, false, - "Operation of NULL extname didn't fail"); - return 9; - } - - psFree(fits); - - // Attempt to get ext name from null fits file - psLogMsg(__func__,PS_LOG_INFO,"Following should generate an error for NULL fits file"); - if(psFitsGetExtName(NULL) != NULL) - { - psError(PS_ERR_UNKNOWN,true,"Expected NULL return from psFitsGetExtName with NULL fits file"); - return 10; - } - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // tst_psFitsMoveExtNum() - { - psMemId id = psMemGetId(); - - ok(makeMulti(), "Created 'multi' FITS file"); - psFits* fits = psFitsOpen(multiFilename,"r"); - ok(fits != NULL, "psFitsOpen returned non-NULL on existing file"); - - int numHDUs = psFitsGetSize(fits); - // as a side test, let's make sure psFitsGetSize can handle NULL. - // Following should be an error - // XXX: Verify error - psErrorClear(); - ok(psFitsGetSize(NULL) == 0 && psErrorGetStackSize() == 1, - "The 'multi' FITS file has multiple HDUs"); - - ok(numHDUs == 8, "The 'multi' FITS file does not have multiple HDUs"); - - psRegion region = {0,0,0,0}; - // test absolute positioning - for (int lcv = 0; lcv < numHDUs; lcv++) - { - // try to move to the extension - ok(psFitsMoveExtNum(fits, lcv, false), "Moved to extension %d", lcv); - - // check to see if I can retrieve the number back from the psFits object. - ok(psFitsGetExtNum(fits) == lcv, "Retrieved the extension number back (%d vs %d)", - psFitsGetExtNum(fits), lcv); - - // check that the image is associated to the extension moved, i.e., - // did we really move to the proper extension? - psImage* image = NULL; - image = psFitsReadImage(fits,region,0); - ok(image != NULL && abs(image->data.F32[0][0] - (float)lcv) <= FLT_EPSILON, - "The image pixel 0,0 of ext-%d was %g, expected %d", - lcv,image->data.F32[0][0],lcv); - psFree(image); - } - - for (int lcv = numHDUs-1; lcv >= 0; lcv--) - { - // try to move to the extension - ok(psFitsMoveExtNum(fits, lcv, false), "Moved to extension %d", lcv); - - // check that the image is associated to the extension moved, i.e., - // did we really move to the proper extension? - psImage* image = NULL; - image = psFitsReadImage(fits,region,0); - - ok(abs(image->data.F32[0][0] - (float)lcv) <= FLT_EPSILON, - "The image pixel 0,0 of ext-%d was %g, expected %d", - lcv, image->data.F32[0][0],lcv); - psFree(image); - } - - // test relative positioning - psFitsMoveExtNum(fits,0,false); - for (int lcv = 1; lcv < numHDUs; lcv++) - { - // try to move to the extension - if (psFitsMoveExtNum(fits, 1, true), "Failed to move to extension %d", lcv) - ; - - // check to see if I can retrieve the number back from the psFits object. - ok(psFitsGetExtNum(fits) == lcv, - "Failed to retrieve the extension number back (%d vs %d)", - psFitsGetExtNum(fits), lcv); - - // check that the image is associated to the extension moved, i.e., - // did we really move to the proper extension? - psImage* image = NULL; - image = psFitsReadImage(fits,region,0); - - ok(image != NULL && abs(image->data.F32[0][0] - (float)lcv) <= FLT_EPSILON, - "The image pixel 0,0 of ext-%d was %g, expected %d", - lcv,image->data.F32[0][0],lcv); - psFree(image); - } - - for (int lcv = numHDUs-2; lcv >= 0; lcv--) - { - // try to move to the extension - ok(psFitsMoveExtNum(fits, -1, true), "Failed to move to extension %d", lcv); - - // check to see if I can retrieve the number back from the psFits object. - ok(psFitsGetExtNum(fits) == lcv, - "Failed to retrieve the extension number back (%d vs %d)", - psFitsGetExtNum(fits), lcv); - - // check that the image is associated to the extension moved, i.e., - // did we really move to the proper extension? - psImage* image = NULL; - image = psFitsReadImage(fits,region,0); - - ok(abs(image->data.F32[0][0] - (float)lcv) <= FLT_EPSILON, - "The image pixel 0,0 of ext-%d was %g, expected %d", - lcv,image->data.F32[0][0],lcv); - psFree(image); - } - - - // check to see if given a negative extension number, it errors. - // Following should be an error - // XXX: Verify error - psErrorClear(); - ok(!psFitsMoveExtNum(fits, -1, false) && psErrorGetStackSize() == 1, - "Moving to negative HDU did fail"); - - // check to see if relative positioning beyond PHU, it errors. - psFitsMoveExtNum(fits,0,false); - // Following should be an error - // XXX: Verify error - psErrorClear(); - ok(!psFitsMoveExtNum(fits, -1, true) && psErrorGetStackSize() == 1, - "Moving to negative HDU did fail"); - - // check to see if given a extension greater than the total #HDUs, it errors. - // Following should be an error - // XXX: Verify error - psErrorClear(); - ok(!psFitsMoveExtNum(fits, numHDUs, false) && psErrorGetStackSize() == 1, - "Moving to a HDU beyond the file's contents did fail"); - - // check to see if relative positioning beyond PHU, it errors. - psFitsMoveExtNum(fits,numHDUs-1,false); - // Following should be an error - // XXX: Verify error - psErrorClear(); - ok(!psFitsMoveExtNum(fits, 1, true) && psErrorGetStackSize() == 1, - "Moving to negative HDU did fail"); - - // check to see if given a NULL psFits, it errors. - // Following should be an error - // XXX: Verify error - psErrorClear(); - ok(!psFitsMoveExtNum(NULL, 0, false) && psErrorGetStackSize() == 1, - "Operation of NULL psFits didt fail"); - psFitsClose(fits); - - // Attempt to get ext name from null fits file - // Following should generate an error for NULL fits file - // XXX: Verify error - ok(psFitsGetExtNum(NULL) == PS_FITS_TYPE_NONE, - "Expected NULL return from psFitsGetExtNum with NULL fits file"); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - - } - - - // tst_psFitsReadHeader() - { - psMemId id = psMemGetId(); - ok(makeMulti(), "Created 'multi' FITS file"); - - psFits* fits = psFitsOpen(multiFilename,"r"); - ok(fits != NULL, "psFitsOpen returned non-NULL on existing file"); - - int numHDUs = psFitsGetSize(fits); - ok(numHDUs >= 8, "The 'multi' FITS file has multiple HDUs"); - - char extname[80]; - for (int hdunum = 0; hdunum < numHDUs; hdunum++) - { - snprintf(extname,80,"ext-%d",hdunum); - psFitsMoveExtNum(fits,hdunum,false); - - psMetadata* header = psFitsReadHeader(NULL,fits); - ok(header != NULL, "Read header"); - - psMetadata* header2 = psMetadataAlloc(); - header2 = psFitsReadHeader(header2,fits); - ok(header2 != NULL, "Read header"); - - ok(header->list->n >= 1 && header->list->n == header2->list->n, - "Reading the header given a NULL input psMetadata did not differ from giving an existing psMetadata"); - - // check for the extra metadata items - psS32 intItem = psMetadataLookupS32(NULL,header, "MYINT"); - psF32 fltItem = psMetadataLookupF32(NULL,header, "MYFLT"); - psF64 dblItem = psMetadataLookupF64(NULL,header, "MYDBL"); - psMetadataItem* boolItem = psMetadataLookup(header, "MYBOOL"); - psString strItem = psMetadataLookupStr(NULL, header, "MYSTR"); - - ok(intItem == hdunum, "Retrieved psS32 metadata item from file"); - - ok(fabsf(fltItem - 1.0f/(float)(1+hdunum)) <= FLT_EPSILON, - "Retrieved psF32 metadata item from file. Got %f vs %f", - fltItem,1.0f/(float)(1+hdunum)); - - ok(abs(dblItem - 1.0/(double)(1+hdunum)) <= DBL_EPSILON, - "Retrieved psF64 metadata item from file. Got %g vs %g", - dblItem, 1.0/(double)(1+hdunum)); - - ok(boolItem != NULL && boolItem->type == PS_DATA_BOOL, - "Retrieved psBool metadata item from file"); - - ok(strItem != NULL && strncmp(strItem,extname,strlen(extname)) == 0, - "Retrieved string metadata item from file. Got '%s' vs '%s' (%d)", - strItem,extname,strlen(extname)); - - psFree(header); - psFree(header2); - } - - // Following should be an error (input psFits = NULL) - // XXX: Verify error - psMetadata* header = psFitsReadHeader(NULL,NULL); - ok(header == NULL && psErrorGetStackSize() == 1, - "psFitsReadHeader didn't error on a NULL psFits"); - - psFree(fits); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // tst_psFitsReadHeaderSet() - { - psMemId id = psMemGetId(); - ok(makeMulti(), "Created 'multi' FITS file"); - - psFits* fits = psFitsOpen(multiFilename,"r"); - ok(fits != NULL, "psFitsOpen returned non-NULL on existing file"); - - int numHDUs = psFitsGetSize(fits); - ok(numHDUs >= 8, "The 'multi' FITS file has multiple HDUs"); - - // move to the middle - psFitsMoveExtNum(fits,numHDUs/2, false); - psMetadata* headerSet = psFitsReadHeaderSet(NULL,fits); - ok(headerSet != NULL, "psFitsReadHeaderSet returned non-NULL"); - - ok(psFitsGetExtNum(fits) == numHDUs/2, "psFitsReadHeaderSet did not change the CHU"); - - char extname[80]; - for (int i = 0; i < numHDUs; i++) - { - if (i == 0) { - snprintf(extname, 80, "PHU"); - } else { - snprintf(extname, 80, "ext-%d", i); - } - - psMetadata* header = psMetadataLookupPtr(NULL,headerSet, extname); - - ok(header != NULL, "psFitsReadHeader returned non-NULL for HDU#%d", i); - - psS32 intItem = psMetadataLookupS32(NULL, header, "MYINT"); - ok(intItem == i, "psFitsReadHeader for HDU#%d had a MYINT of %d, expected %d", - intItem, i); - } - - psMetadata* set3 = psFitsReadHeaderSet(NULL,fits); - ok(set3 != NULL, "psFitsReadHeaderSet returned non-NULL"); - - for (int i = 0; i < numHDUs; i++) - { - if (i == 0) { - snprintf(extname, 80, "PHU"); - } else { - snprintf(extname, 80, "ext-%d", i); - } - - psMetadata* header = psMetadataLookupPtr(NULL, set3, extname); - ok(header != NULL, "psFitsReadHeader returned non-NULL for HDU#%d", i); - - psS32 intItem = psMetadataLookupS32(NULL, header, "MYINT"); - ok(intItem == i, "psFitsReadHeader for HDU#%d had a MYINT of %d, expected %d", - intItem, i); - } - - set3 = psFitsReadHeaderSet(set3,NULL); - ok(set3 == NULL, "psFitsReadHeaderSet returned NULL given a NULL psFits"); - - - psFree(headerSet); - psFitsClose(fits); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // tst_psFitsReadTable() - // XXXX: This is if'ed out because the call to makeTable() is seg faulting - if (0) { - psMemId id = psMemGetId(); - ok(makeTable(), "Created 'table' FITS file"); - psFits* fits = psFitsOpen(tableFilename, "r"); - ok(fits != NULL, "psFitsOpen returned non-NULL on existing file"); - - psFitsMoveExtNum(fits,1,false); - psArray* table = psFitsReadTable(fits); - ok(table != NULL, "psFitsReadTable returned non-NULL"); - ok(table->n == tableNumRows, "Expected %d rows, read %d", - tableNumRows, table->n); - - for (int row = 0; row < table->n; row++) { - psMetadata* rowData = table->data[row]; - - psS32 intItem = psMetadataLookupS32(NULL, rowData, "MYINT"); - psF32 fltItem = psMetadataLookupF32(NULL, rowData, "MYFLT"); - psF64 dblItem = psMetadataLookupF64(NULL, rowData, "MYDBL"); - psBool boolItem = psMetadataLookupBool(NULL, rowData, "MYBOOL"); - psString strItem = psMetadataLookupStr(NULL, rowData, "MYSTR"); - psVector* vecItem = psMetadataLookupPtr(NULL, rowData, "MYVEC"); - - ok(intItem == row, - "Failed to retrieve psS32 metadata item from file (row=%d). Got %d vs %d", - row, intItem, row); - - ok(fabsf(fltItem - 1.0f/(float)(1+row)) <= FLT_EPSILON, - "Retrieved psF32 metadata item from file (row=%d). Got %f vs %f", - row, fltItem,1.0f/(float)(1+row)); - - ok(abs(dblItem - 1.0/(double)(1+row)) <= DBL_EPSILON, - "Retrieved psF64 metadata item from file (row=%d). Got %g vs %g", - row, dblItem, 1.0/(double)(1+row)); - - ok(!(boolItem != ((row&0x01) == 0)), - "Retrieved psBool metadata item from file (row=%d). Got %d vs %d", - row, boolItem, ((row&0x01) == 0)); - - char strValue[16]; - snprintf(strValue,16,"row=%d",row+1); - ok(strncmp(strItem,strValue,strlen(strValue)) == 0, - "Retrieved psString metadata item from file (row=%d). Got '%s' vs '%s'", - row, strItem, strValue); - - ok(vecItem != NULL, "Retrieved psVector metadata item from file (row=%d)", row); - - ok(vecItem->type.type == PS_DATA_S32 && - vecItem->data.S32[0] == row && - vecItem->data.S32[3] == row+30, - "Retrieved psVector (row=%d) had expected values [%d,%d,%d,%d] vs [%d,%d,%d,%d]", - row,vecItem->data.S32[0], vecItem->data.S32[1], - vecItem->data.S32[2], vecItem->data.S32[3], - row,row+10,row+20,row+30); - } - - psFree(table); - psFree(fits); - - psArray* nullTest = psFitsReadTable(NULL); - ok(nullTest == NULL && psErrorGetStackSize() == 1, - "psFitsReadTable returned NULL when given NULL"); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // tst_psFitsReadTableColumnNum() - // XXXX: This is if'ed out because the call to makeTable() is seg faulting - if (0) { - psMemId id = psMemGetId(); - ok(makeTable(), "Created 'table' FITS file"); - psFits* fits = psFitsOpen(tableFilename,"r"); - ok(fits != NULL, "psFitsOpen returned non-NULL on existing file"); - - psFitsMoveExtNum(fits,1,false); - // read the column data via number - psVector* colData; - psElemType type[4] = {PS_TYPE_S32, PS_TYPE_F32, PS_TYPE_F32, PS_TYPE_BOOL}; - psElemType altType[4] = {PS_TYPE_S64, PS_TYPE_F64, PS_TYPE_F64, PS_TYPE_BOOL}; - char* colname[4] = {"MYINT","MYFLT","MYDBL","MYBOOL"}; - psF64 expectedValues[4][10] = { - {0,1,2,3,4,5,6,7,8,9}, - {1.0,1.0/2.0,1.0/3.0,1.0/4.0,1.0/5.0,1.0/6.0,1.0/7.0,1.0/8.0,1.0/9.0}, - {1.0,1.0/2.0,1.0/3.0,1.0/4.0,1.0/5.0,1.0/6.0,1.0/7.0,1.0/8.0,1.0/9.0}, - {1.0,0.0,1.0,0.0,1.0,0.0,1.0,0.0,1.0,0.0} - }; - - for (int col = 0; col < 4; col++) { - colData = psFitsReadTableColumnNum(fits,colname[col]); - ok(colData != NULL, "psFitsReadTableColumnNum returned non-NULL for col=%d"); - - if (colData->type.type != type[col] && - colData->type.type != altType[col]) { - char* typeRead; - char* typeExpected; - PS_TYPE_NAME(typeRead, colData->type.type); - PS_TYPE_NAME(typeExpected, type[col]); - - ok(false, "psFitsReadTableColumnNum returned different type, %s vs %s, for col=%d", - typeRead, typeExpected, col); - } else { - ok(true, "psFitsReadTableColumnNum returned same type"); - } - ok(colData->n == tableNumRows, - "psFitsReadTableColumnNum returned same number of rows, %d vs %d, for col=%d", - colData->n, tableNumRows, col); - for (int row = 0; row < tableNumRows; row++) { - ok(abs(p_psVectorGetElementF64(colData,row) - expectedValues[col][row]) <= FLT_EPSILON, - "psFitsReadTableColumnNum returned values (%g vs %g) for col=%d", - p_psVectorGetElementF64(colData,row), expectedValues[col][row], col); - } - psFree(colData); - } - - // Following should be an error - // XXX: Verify error - psErrorClear(); - psVector* data = psFitsReadTableColumnNum(NULL,colname[0]); - psErr* err = psErrorLast(); - ok(data == NULL, "psFitsReadTableColumnNum did return NULL with NULL psFits"); - ok(err->code == PS_ERR_BAD_PARAMETER_NULL, - "psFitsReadTableColumnNum did return error with NULL psFits"); - psFree(err); - - // Following should be an error - // XXX: Verify error - psErrorClear(); - data = psFitsReadTableColumnNum(fits,"BOGUS"); - err = psErrorLast(); - ok(data == NULL, "psFitsReadTableColumnNum did return NULL with bogus column name"); - ok(err->code == PS_ERR_IO, "psFitsReadTableColumnNum did return error with bogus column name"); - psFree(err); - psFree(fits); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // tst_psFitsReadTableColumn() - // XXXX: This is if'ed out because the call to makeTable() is seg faulting - if (0) { - psMemId id = psMemGetId(); - ok(makeTable(), "Created 'table' FITS file"); - psFits* fits = psFitsOpen(tableFilename,"r"); - ok(fits != NULL, "psFitsOpen returned non-NULL on existing file"); - - psFitsMoveExtNum(fits,1,false); - // read the column data via number - psArray* colData; - char* colname[4] = {"MYINT","MYFLT","MYDBL","MYBOOL"}; - psF64 expectedValues[3][10] = { - {0,1,2,3,4,5,6,7,8,9}, - {1.0,1.0/2.0,1.0/3.0,1.0/4.0,1.0/5.0,1.0/6.0,1.0/7.0,1.0/8.0,1.0/9.0}, - {1.0,1.0/2.0,1.0/3.0,1.0/4.0,1.0/5.0,1.0/6.0,1.0/7.0,1.0/8.0,1.0/9.0} - }; - char* expectedBoolValues[10] = {"T","F","T","F","T","F","T","F","T","F"}; - char* expectedStrValues[10] = {"row=1","row=2","row=3","row=4","row=5","row=6","row=7","row=8","row=9","row=10"}; - - bool errorFlag = false; - for (int col = 0; col < 4; col++) { - colData = psFitsReadTableColumn(fits,colname[col]); - if (colData == NULL) { - diag("psFitsReadTableColumn returned NULL for col=%d", col); - errorFlag = true; - } - if (colData->n != tableNumRows) { - diag("psFitsReadTableColumn returned different number of rows, %d vs %d, for col=%d", - colData->n, tableNumRows, col); - errorFlag = true; - } - if (col < 3) { - for (int row = 0; row < tableNumRows; row++) { - if (abs(atof((char*)colData->data[row]) - expectedValues[col][row]) > 0.0001) { - diag("psFitsReadTableColumn returned unexpected values (%g vs %g) for col=%d", - atof((char*)colData->data[row]), expectedValues[col][row], col); - errorFlag = true; - } - } - } else if (col == 3) { - for (int row = 0; row < tableNumRows; row++) { - if (strncmp(colData->data[row],expectedBoolValues[row], - strlen(expectedBoolValues[row])) != 0) { - diag("psFitsReadTableColumn returned unexpected values ('%s' vs '%s') for col=%d", - (char*)colData->data[row], expectedBoolValues[row], col); - errorFlag = true; - } - } - } else if (col == 4) { - for (int row = 0; row < tableNumRows; row++) { - if (strncmp(colData->data[row],expectedStrValues[row], - strlen(expectedStrValues[row])) != 0) { - diag("psFitsReadTableColumn returned unexpected values ('%s' vs '%s') for col=%d", - (char*)colData->data[row], expectedStrValues[row], col); - errorFlag = true; - } - } - } - psFree(colData); - } - ok(!errorFlag, "psFitsReadTableColumn() produced the correct data"); - - // Following should be an error - // XXX: Verify error - psErrorClear(); - psArray* data = psFitsReadTableColumn(NULL,"MYINT"); - psErr* err = psErrorLast(); - ok(data == NULL, "psFitsReadTableColumn did return NULL with NULL psFits"); - ok(err->code == PS_ERR_BAD_PARAMETER_NULL, - "psFitsReadTableColumn did error with NULL psFits"); - psFree(err); - - // Following should be an error - // XXX: Verify error - psErrorClear(); - data = psFitsReadTableColumn(fits,"BOGUS"); - err = psErrorLast(); - ok(data == NULL, "psFitsReadTableColumn did return NULL with col=\"BOGUS\""); - ok(err->code == PS_ERR_IO, "psFitsReadTableColumn did error with col=\"BOGUS\""); - psFree(err); - - psFree(fits); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // tst_psFitsUpdateTable() - // XXXX: This is if'ed out because the call to makeTable() is seg faulting - if (0) { - psMemId id = psMemGetId(); - psErr* err; - char* strValue[] = { - "row A", - "row B", - "row C", - "row D", - "row E", - "row F", - "row G", - "row H", - "row I", - "row J", - "row K" - }; - ok(makeTable(), "Created 'table' FITS file"); - psFits* fits = psFitsOpen(tableFilename,"rw"); - ok(fits != NULL, "psFitsOpen returned NULL on existing file"); - psFitsMoveExtNum(fits,1,false); - // change the data in the file, going past by one (implicit new row of data) - bool errorFlag = false; - for (int row = 0; row < tableNumRows+1; row++) { - psMetadata* md = psMetadataAlloc(); - psMetadataAddF32(md,PS_LIST_TAIL,"MYFLT", 0,"",(float)row/-10.0); - psMetadataAddF64(md,PS_LIST_TAIL,"MYDBL", 0,"",(double)row/-100.0); - psMetadataAddS32(md,PS_LIST_TAIL,"MYINT", 0,"",-row); - psMetadataAddBool(md,PS_LIST_TAIL,"MYBOOL", 0,"",((row & 1) == 1)); - psMetadataAddStr(md,PS_LIST_TAIL,"MYSTR", 0,"",strValue[row]); - - - - - - - - - - - - - - - if (!psFitsUpdateTable(fits,md,row)) { - diag("psFitsUpdateTable returned false, but expected true for row=%d", row); - errorFlag = true; - } - psFree(md); - } - ok(!errorFlag, "psFitsUpdateTable() produced the correct data"); - - for (int row = 0; row < tableNumRows+1; row++) { - psMetadata* md = psFitsReadTableRow(fits, row); - if (abs(psMetadataLookupF32(NULL,md,"MYFLT") - (float)row/-10.0) > FLT_EPSILON) { - diag("psFitsUpdateTable did not change the float value for row=%d", row); - errorFlag = true; - } - if (abs(psMetadataLookupF64(NULL,md,"MYDBL") - (float)row/-100.0) > FLT_EPSILON) { - diag("psFitsUpdateTable did not change the double value for row=%d", row); - errorFlag = true; - } - if (psMetadataLookupS32(NULL,md,"MYINT") != -row) { - diag("psFitsUpdateTable did not change the integer value for row=%d", row); - errorFlag = true; - } - if (psMetadataLookupBool(NULL,md,"MYBOOL") != ((row &1) == 1)) { - diag("psFitsUpdateTable did not change the boolean value for row=%d", row); - errorFlag = true; - } - psString mystr = psMetadataLookupStr(NULL,md,"MYSTR"); - if (strncmp(mystr,strValue[row], strlen(strValue[row])) != 0) { - diag("psFitsUpdateTable did not change the string value for row=%d", row); - errorFlag = true; - } - psFree(md); - } - ok(!errorFlag, "psFitsUpdateTable() produced the correct data"); - - psMetadata* md = psMetadataAlloc(); - psMetadataAddF32(md,PS_LIST_TAIL,"BOGUS", 0,"",-1.0f); - // Following should be a warning - // XXX: Verify warning - psErrorClear(); - ok(psFitsUpdateTable(fits,md,0), "psFitsUpdateTable did return false with bogus column data"); - psFree(md); - - md = psMetadataAlloc(); - psMetadataAddF32(md,PS_LIST_TAIL,"MYFLT", 0,"",-1.0f); - psMetadataAddF64(md,PS_LIST_TAIL,"MYDBL", 0,"",-2.0); - psMetadataAddS32(md,PS_LIST_TAIL,"MYINT", 0,"",-3); - - // Following should be an error - // XXX: Verify error - psErrorClear(); - ok(psFitsUpdateTable(NULL,md,0), "psFitsUpdateTable did return false with NULL psFits"); - err = psErrorLast(); - ok(err->code == PS_ERR_BAD_PARAMETER_NULL, "psFitsUpdateTable did error with NULL psFits"); - psFree(err); - - // Following should be an error - // XXX: Verify error - psErrorClear(); - ok(psFitsUpdateTable(fits,NULL,0), "psFitsUpdateTable did return false with NULL psMetadata"); - err = psErrorLast(); - ok(err->code == PS_ERR_BAD_PARAMETER_NULL, "psFitsUpdateTable did error with NULL psMetadata"); - psFree(err); - - // Following should be an error - // XXX: Verify error - psErrorClear(); - ok(psFitsUpdateTable(fits,md,-1), "psFitsUpdateTable did return false with row=-1"); - err = psErrorLast(); - ok(err->code == PS_ERR_IO, "psFitsUpdateTable did error with row=-1"); - - psFree(err); - psFree(md); - psFitsClose(fits); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // testImageRead() - { - psS32 N = 256; - psS32 M = 128; - - // This function shall open the specified FITS file, read the specified data - // and place the data into a psImage structure. This function shall generate - // an error message and return NULL if any of the input parameters are out of - // range, image file doesn't exist or image is zero or one dimensional. - // Verify the returned psImage structure contains expected values, if the input - // parameter filename specifies an available FITS file with known 2dimensional - // data, input parameters col, row, ncol, nrow, z specify data range with the - // FITS file. Cases should include 1x1, Nx1, 1xN, NxN and MxN sub images and - // total FITS file image. (done in macro) - // Verify the returned psImage structure is equal to the input parameter - // 'output', if specified. (done in macro) - - #define testReadTypeSize(m, n, readM0, readN0, readM, readN, TYP, filename) \ - { \ - psMemId id = psMemGetId(); \ - psImage* img = NULL; \ - psImage* img2 = NULL; \ - psImage* img3 = NULL; \ - psImage* img4 = NULL; \ - \ - GENIMAGE(img,m,n,TYP,row+2*col); \ - img2 = psImageCopy(img2,img,PS_TYPE_##TYP); \ - GENIMAGE(img3,m,n,TYP,row+2*col); \ - psImageClip(img3,32.0,32.0,120.0,120.0); \ - img4 = psImageCopy(img4,img3,PS_TYPE_##TYP); \ - psFits* fits = psFitsOpen(filename, "w"); \ - ok(psFitsWriteImage(fits, NULL, img, 2, NULL), "Wrote test image %s",filename); \ - ok(psFitsUpdateImage(fits,img3, 0,0, 1), "Wrote test image %s",filename); \ - ok(psFitsWriteImage(fits,NULL, img3, 2, NULL), "Wrote test image %s",filename); \ - ok(psFitsUpdateImage(fits,img, 0, 0, 1), "Wrote test image %s",filename); \ - psFree(img); \ - psFree(fits); \ - img = NULL; \ - psFree(img3); \ - img3 = NULL; \ - fits = psFitsOpen(filename,"r"); \ - psRegion reg = {readM0, readM, readN0, readN}; \ - img = psFitsReadImage(fits, reg, 0); \ - img3 = psFitsReadImage(fits, reg, 1); \ - ok(img3 != NULL, "Read test image %s",filename); \ - bool errorFlag = false; \ - for (psU32 row = readN0; row < readN; row++) { \ - ps##TYP* imgRow = img->data.TYP[row-readN0]; \ - ps##TYP* img2Row = img2->data.TYP[row]; \ - ps##TYP* img3Row = img3->data.TYP[row-readN0]; \ - ps##TYP* img4Row = img4->data.TYP[row]; \ - for (psU32 col = readM0; col < readM; col++) { \ - if (fabsf(imgRow[col-readM0]-img2Row[col]) > FLT_EPSILON) { \ - diag("Image changed in I/O operation at %d,%d,0 (%.2f vs %.2f) for %s", \ - col,row,(psF32)imgRow[col-readM0],(psF32)img2Row[col],filename); \ - errorFlag = true; \ - } \ - if (fabsf(img3Row[col-readM0]-img4Row[col]) > FLT_EPSILON) { \ - diag("Image changed in I/O operation at %d,%d,1 (%.2f vs %.2f) for %s", \ - col,row,(psF32)img3Row[col-readM0],(psF32)img4Row[col],filename); \ - errorFlag = true; \ - } \ - } \ - } \ - ok(!errorFlag, "psFitsReadImage() produced the correct data"); \ - psFree(img); \ - img = NULL; \ - psFree(img3); \ - img3 = NULL; \ - psFitsMoveExtNum(fits,1, false); \ - img3 = psFitsReadImage(fits, reg, 0); \ - img = psFitsReadImage(fits, reg, 1); \ - ok(img != NULL, "Read test image %s",filename); \ - errorFlag = false; \ - for (psU32 row = readN0; row < readN; row++) { \ - ps##TYP* imgRow = img->data.TYP[row-readN0]; \ - ps##TYP* img2Row = img2->data.TYP[row]; \ - ps##TYP* img3Row = img3->data.TYP[row-readN0]; \ - ps##TYP* img4Row = img4->data.TYP[row]; \ - for (psU32 col = readM0; col < readM; col++) { \ - if (fabsf(imgRow[col-readM0]-img2Row[col]) > FLT_EPSILON) { \ - diag("Image changed in I/O operation at %d,%d,0 (%.2f vs %.2f) for %s", \ - col,row,(psF32)imgRow[col-readM0],(psF32)img2Row[col],filename); \ - errorFlag = true; \ - } \ - if (fabsf(img3Row[col-readM0]-img4Row[col]) > FLT_EPSILON) { \ - diag("Image changed in I/O operation at %d,%d,1 (%.2f vs %.2f) for %s", \ - col,row,(psF32)img3Row[col-readM0],(psF32)img4Row[col],filename); \ - errorFlag = true; \ - } \ - } \ - } \ - ok(!errorFlag, "psFitsReadImage() produced the correct data"); \ - psFree(img); \ - psFree(img2); \ - psFree(img3); \ - psFree(img4); \ - psFree(fits); \ - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); \ - } - - #define testReadType(TYP,filename) \ - testReadTypeSize(1,1,0,0,0,0,TYP,"tmpImages/1x1_" filename); \ - testReadTypeSize(M,1,M/4,0,M*3/4,0,TYP,"tmpImages/Mx1_" filename); \ - testReadTypeSize(1,N,0,N/4,0,N*3/4,TYP,"tmpImages/1xN_" filename); \ - testReadTypeSize(M,N,M/4,N/4,M*3/4,N*3/4,TYP,"tmpImages/MxN_" filename); - - system("mkdir tmpImages"); - - testReadType(U8,"U8.fits"); - testReadType(S8,"S8.fits"); // Not a requirement - testReadType(S16,"S16.fits"); - testReadType(U16,"U16.fits"); // Not a requirement - testReadType(S32,"S32.fits"); - testReadType(U32,"U32.fits"); // Not a requirement - testReadType(F32,"F32.fits"); - testReadType(F64,"F64.fits"); - - // Attempt to read from NULL fits object - // Following should generate error message for NULL psFits - // XXX: Verify error - // XXXX: This is seg-faulting - if (0) - { - psMemId id = psMemGetId(); - psRegion region = { - 0,0,0,0 - }; - ok(psFitsReadImage(NULL,region,0) == NULL, "Did return NULL for NULL psFits"); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - \ - } - } - - - // testImageWrite() - { - psMemId id = psMemGetId(); - psImage* img = NULL; - psImage* img2 = NULL; - psS32 m = 64; - psS32 n = 96; - - // This function shall write the specified section within a psImage structure - // to a FITS file. If the specifiedfile exists, then data should overwrite the - // section to write. If the specified file doesn't exist, it shall be created. - // If an extenstion is specified, then a basic primary header data unit shall - // be created. - // - // Verify a FITS file named filename is generated and contains expected - // values, if the input parameter input contains known data values, input - // parameters col, row, ncol, nrow specify a valid data region within psImage - // structure. - // - // Verify a FITS file named filename is generated and contains a primary - // header data unit with extension with expected values, if the input - // parameter input contains known data values, input parameters col, row, - // ncol, nrow specify a valid data region within psImage structure and - // extname and/or extnum specify an extenstion to write. - // - // N.B. : these are done in testImageRead tests, see above. - // - // Verify a FITS file named filename is overwritten and contains - // expected values, if the input parameter input contains known data values, - // input parameters col, row, ncol, nrow specify a valid data region within - // psImage structure. - - GENIMAGE(img,m,n,F32,0); - GENIMAGE(img2,m,n,F32,row+2*col); - system("mkdir tmpImages"); - psFits* fits = psFitsOpen("tmpImages/writeTest.fits","w"); - - ok(psFitsWriteImage(fits, NULL, img,1, NULL), "Wrote writeTest.fits"); - ok(psFitsUpdateImage(fits, img2, 0, 0, 0), "Updated writeTest.fits"); - psFree(img); - psFree(img2); - - // Did it really overwrite the pixel values? Let's read it in and see. - psFitsClose(fits); - - psRegion region = {0,0,0,0}; - fits = psFitsOpen("tmpImages/writeTest.fits","r"); - img = NULL; - img = psFitsReadImage(fits, region, 0); - ok(img != NULL, "Read in writeTest.fits"); - bool errorFlag = false; - for (psU32 row=0;rowdata.F32[row]; - for (psU32 col=0;col FLT_EPSILON) { - diag("The image values were not overwritten at %d,%d (%.2f vs %.2f)", - col,row,imgRow[col],(row+2*col)); - errorFlag = true; - } - } - } - ok(!errorFlag, "psFitsReadImage() produced the correct data"); - - psFree(img); - - // Verify false is returned and program execution is not stopped, if the input image - // is null. - // Following should generate an error message because input image is null - // XXX: Verify error - ok(!psFitsWriteImage(fits,NULL,NULL, 1, NULL), - "psImageWriteSection did return false when input image is NULL"); - psFree(fits); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // tst_psFitsWriteHeader() - { - psMemId id = psMemGetId(); - ok(makeMulti(), "Created 'multi' FITS file"); - - psMetadata* header = psMetadataAlloc(); - psFits* fitsFile = psFitsOpen(multiFilename,"a+"); - - // Test psFitsReadWrite generates files from psFitsWriteImage which calls psFitsWriteHeader - // so these additional tests check for error conditions - // Attempt call function with NULL metadata - ok(!psFitsWriteHeader(fitsFile, NULL), "Expected return of true for NULL metadata pointer"); - psFree(fitsFile); - - // Attempt to call function with NULL fits - ok(!psFitsWriteHeader(NULL, header), "Expected return of true for NULL fits file pointer"); - psFree(header); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } -} Index: trunk/psLib/test/imageops/tap_psImageFFT.c =================================================================== --- trunk/psLib/test/imageops/tap_psImageFFT.c (revision 11438) +++ (revision ) @@ -1,566 +1,0 @@ -/** @file tst_psImageFFT.c - * - * @brief Contains the tests for psFFT.[ch] - * - * - * @author Robert DeSonia, MHPCC - * - * @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ - * @date $Date: 2007-01-30 00:13:01 $ - * - * Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii - */ -#include -#include -#include -#include "tap.h" -#include "pstap.h" - -#define GENIMAGE(img,c,r,TYP, valueFcn) \ -img = psImageAlloc(c,r,PS_TYPE_##TYP); \ -for (psU32 row=0;rowdata.TYP[row]; \ - for (psU32 col=0;coltype.type == PS_TYPE_C32, "FFT produced complex values"); - ok(img2->numCols == m && img2->numRows == n, "FFT produced proper size result (%dx%d vs. expected %dx%d).", - img2->numCols,img2->numRows,m,n); - - // 3. verify that the only significant component cooresponds to the freqency of the input in step 1. - bool errorFlag = false; - for (psU32 row=0;rowdata.C32[row]; - for (psU32 col=0;col 0.1f) { - // must be (0,1) or (0,n-1) or (1,0) or (m-1,0) - if (! (col == 0 && (row == 1 || row == n-1)) - && ! (row == 0 && (col==1 || col == m-1)) ) { - diag("Result incorrect at %d,%d (%.2f)",col,row,mag); - errorFlag = true; - } - } else { - if ( (col == 0 && (row == 1 || row == n-1)) - || (row == 0 && (col==1 || col == m-1)) ) { - diag("Result incorrect at %d,%d (%.2f)",col,row,mag); - errorFlag = true; - } - } - } - } - ok(!errorFlag, "FFT produced correct data values"); - - - - // 4. perform reverse transform - img3 = psImageFFT(img3,img2,PS_FFT_REVERSE); - ok(img3 != NULL, "psImageFFT() returned non-NULL"); - skip_start(img3 == NULL, 1, "Skipping tests because psImageFFT() returned NULL"); - ok(img3->type.type == PS_TYPE_C32, "FFT produced complex values"); - - ok(img3->numCols == m && img3->numRows == n, "FFT didt produce proper size result (%dx%d vs. expected %dx%d).", - img3->numCols,img3->numRows,m,n); - - - - - - - - - - - - - - - - - errorFlag = false; - for (psU32 row=0;rowdata.C32[row]; - psF32* imgRow = img->data.F32[row]; - for (psU32 col=0;col 0.1) { - diag("Reverse FFT gave original image back (%d,%d %.2f vs %.2f)", - col,row,pixel,imgRow[col]); - errorFlag = true; - } - } - } - ok(!errorFlag, "FFT produced correct data values"); - ok(!errorFlag, "FFT produced correct data values"); - - - - // 4. perform reverse transform to real result - img3 = psImageFFT(img3,img2,PS_FFT_REVERSE|PS_FFT_REAL_RESULT); - ok(img3 != NULL, "psImageFFT() returned non-NULL"); - skip_start(img3 == NULL, 1, "Skipping tests because psImageFFT() returned NULL"); - ok(img3->type.type == PS_TYPE_F32, "FFT asked to make real result"); - ok(img3->numCols == m && img3->numRows == n, "FFT produced proper size result (%dx%d vs. expected %dx%d).", - img3->numCols,img3->numRows,m,n); - - errorFlag = false; - for (psU32 row=0;rowdata.F32[row]; - psF32* imgRow = img->data.F32[row]; - for (psU32 col=0;col 0.1) { - diag("Reverse FFT gave original image back (%d,%d %.2f vs %.2f)", - col,row,pixel,imgRow[col]); - errorFlag = true; - } - } - } - ok(!errorFlag, "FFT produced correct data values"); - ok(!errorFlag, "FFT produced correct data values"); - - - - // check if error occurs if FORWARD and REVERSE are both given. - // Following should be an error - // XXX: werify error - ok(psImageFFT(NULL,img2,PS_FFT_REVERSE|PS_FFT_FORWARD) == NULL, - "PS_FFT_REVERSE|PS_FFT_FORWARD returned NULL"); - - // Following should be an error - // XXX: werify error - ok(psImageFFT(NULL,img2,PS_FFT_FORWARD|PS_FFT_REAL_RESULT) == NULL, - "PS_FFT_FORWARD|PS_FFT_REAL_RESULT returned NULL"); - - // Verify return null and program execution doesn't stop if input image is null - img4 = psImageFFT(NULL,NULL,PS_FFT_FORWARD); - ok(img4 == NULL, "psImageFFT should return null for a null input image"); - - // Verify return null and program execution doesn't stop if input image is incorrect direction - // Following should generate error for incorrect direction - // XXX: werify error - GENIMAGE(img4,8,8,S8,row+col); - img5 = psImageFFT(NULL,img4,PS_FFT_REAL_RESULT); - ok(img5 == NULL, "psImageFFT should return null for an incorrect FFT direction"); - - psFree(img4); - psFree(img); - psFree(img2); - psFree(img3); - skip_end(); - skip_end(); - skip_end(); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - // 1. create a C64 complex vector with distinctly different real and imaginary parts. - // 2. call psImageReal and psImageImaginary - // 3. compare results to the real/imaginary components of input - { - psMemId id = psMemGetId(); - psImage* c64Img = NULL; - psImage* c64Img2 = NULL; - psImage* c64Img3 = NULL; - psU32 m = 128; - psU32 n = 64; - - // XXX: What is I? - GENIMAGE(c64Img,m,n,C64, row + I * col); - c64Img2 = psImageReal(c64Img2,c64Img); - ok(c64Img2 != NULL, "psImageReal() returned non-NULL"); - ok(c64Img2->type.type == PS_TYPE_F64, "psImageReal() returned the correct type"); - c64Img3 = psImageImaginary(c64Img3,c64Img); - ok(c64Img3 != NULL, "psImageImaginary() returned non-NULL"); - ok(c64Img3->type.type == PS_TYPE_F64, "psImageImaginary() returned the correct type"); - - bool errorFlag = false; - for (psU32 row=0;rowdata.F64[row]; - psF64* img3Row = c64Img3->data.F64[row]; - for (psU32 col=0;col FLT_EPSILON) { - diag("psImageReal didn't return the real portion at n=%d", n); - errorFlag = true; - } - if (fabsf(img3Row[col] - col) > FLT_EPSILON) { - diag("psImageImaginary didn't return the imag portion at n=%d", n); - errorFlag = true; - } - } - } - ok(!errorFlag, "psImageReal() and psImageImaginary() returned the correct data"); - psFree(c64Img); - psFree(c64Img2); - psFree(c64Img3); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - - { - psMemId id = psMemGetId(); - psImage* ncImg = NULL; - psImage* ncImg2 = NULL; - psImage* ncImg3 = NULL; - psU32 m = 128; - psU32 n = 64; - - GENIMAGE(ncImg,m,n,F32,row+col); - ncImg2 = psImageReal(ncImg2,ncImg); - ncImg3 = psImageImaginary(ncImg3,ncImg); - ok(ncImg2 != NULL, "psImageReal() returned non-NULL"); - ok(ncImg2->type.type == PS_TYPE_F32, "psImageReal() returned the correct type"); - ok(ncImg3 != NULL, "psImageImaginary() returned non-NULL"); - ok(ncImg3->type.type == PS_TYPE_F32, "psImageImaginary() returned the correct type"); - - bool errorFlag = false; - for(psU32 row=0; rowdata.F32[row]; - psF32* ncImg3Row = ncImg3->data.F32[row]; - for(psU32 col=0; col FLT_EPSILON) { - diag("psImageReal didn't return the real portion"); - errorFlag = true; - } - if(fabsf(ncImg3Row[col] - 0) > FLT_EPSILON) { - diag("psImageImaginary didn't return the imaginary portion"); - errorFlag = true; - } - } - } - ok(!errorFlag, "psImageReal() and psImageImaginary() returned the correct data"); - psFree(ncImg); - psFree(ncImg2); - psFree(ncImg3); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - - // Perform psImageReal with null input - { - psMemId id = psMemGetId(); - ok(psImageReal(NULL,NULL) == NULL, "psImageReal() returned NULL with NULL inputs"); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // Perform psImageImaginary with null input - { - psMemId id = psMemGetId(); - ok(psImageImaginary(NULL,NULL) == NULL, "psImageImaginary() returned NULL with NULL inputs"); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // testImageComplex() - // 1. create two unique psF32 vectors of the same size - // 2. call psImageComplex - // 3. verify that the result is a psC32 - // 4. use crealf and cimagf on step 2 results - // 5. compare step 4 results to input. - // 6. create a psF32 and a psF64 vector of the same size - // 7. call psImageComplex - // 8. verify that an appropriate error occurred. - // 9. create two psf32 vectors of different sizes - // 10. call psImageComplex - // 11. verify thet an appropriate error occurred. - { - psMemId id = psMemGetId(); - psImage* img = NULL; - psImage* img2 = NULL; - psImage* img3 = NULL; - psImage* c64Img = NULL; - psImage* c64Img2 = NULL; - psImage* c64Img3 = NULL; - psImage* pImg = NULL; - psImage* pImg2 = NULL; - psImage* pImg3 = NULL; - psU32 m = 128; - psU32 n = 64; - GENIMAGE(img,m,n,F32,row); - GENIMAGE(img2,m,n,F32,col); - GENIMAGE(c64Img,m,n,F64,row); - GENIMAGE(c64Img2,m,n,F64,col); - GENIMAGE(pImg,m,n,S16,row); - GENIMAGE(pImg2,m,n,S16,col); - img3 = psImageComplex(img3,img,img2); - ok(img3 != NULL, "psImageComplex() returned non-NULL"); - ok(img3->type.type == PS_TYPE_C32, "psImageComplex() returned the correct type"); - c64Img3 = psImageComplex(c64Img3,c64Img,c64Img2); - ok(c64Img3 != NULL, "psImageComplex() returned non-NULL"); - ok(c64Img3->type.type == PS_TYPE_C64, "psImageComplex() returned the correct type"); - bool errorFlag = false; - for (psU32 row=0;rowdata.C32[row]; - psC64* c64Img3Row = c64Img3->data.C64[row]; - for (psU32 col=0;col FLT_EPSILON || - fabsf(cimagf(img3Row[col]) - col) > FLT_EPSILON) { - diag("psImageComplex result is incorrect (%d,%d, %.2f+%.2fi)", - col,row,crealf(img3Row[col]),cimagf(img3Row[col])); - errorFlag = true; - } - if (fabsf(crealf(c64Img3Row[col]) - row) > FLT_EPSILON || - fabsf(cimagf(c64Img3Row[col]) - col) > FLT_EPSILON) { - diag("psImageComplex result is incorrect"); - errorFlag = true; - - } - } - } - ok(!errorFlag, "psImageComplex() returned correct results"); - - img2 = psImageRecycle(img2,m,n,PS_TYPE_F64); - - // Following should be an error (type mismatch) - // Verify that an appropriate error occurred - img3 = psImageComplex(img3,img,img2); - ok(img3 == NULL, "psImageComplex() returned NULL when input types mismatched."); - - // Following should be an error (size mismatch) - img2 = psImageRecycle(img2,m/2,n,PS_TYPE_F32); - img3 = psImageComplex(img3,img,img2); - ok(img3 == NULL, "psImageComplex() returned a NULL when input sizes mismatched"); - - // Perform psImageComplex with incorrect type - // Following should generate an error message."); - pImg3 = psImageComplex(pImg3,pImg,pImg2); - ok(pImg3 == NULL, "psImageComplex returned NULL with incorrect type input"); - - psFree(img); - psFree(img2); - psFree(img3); - psFree(c64Img); - psFree(c64Img2); - psFree(c64Img3); - psFree(pImg); - psFree(pImg2); - - // Perform psImageComplex with null input - ok(psImageComplex(NULL,NULL,NULL) == NULL, "psImageComplex() returned NULL with null input"); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - // 1. create a psC32 with unique real and imaginary values. - // 2. call psImageConjugate - // 3. verify result is psC32 - // 4. verify each value is conjugate of input (a+bi -> a-bi) - // testImageConjugate() - { - psMemId id = psMemGetId(); - psImage* img = NULL; - psImage* img2 = NULL; - psImage* c64Img = NULL; - psImage* c64Img2 = NULL; - psImage* pImg = NULL; - psImage* pImg2 = NULL; - psU32 m = 128; - psU32 n = 64; - GENIMAGE(img,m,n,C32, row + I * col); - GENIMAGE(c64Img,m,n,C64,row + I*col); - GENIMAGE(pImg,m,n,F32,row+col); - - - img2 = psImageConjugate(img2,img); - ok(img2 != NULL, "psImageConjugate() returned non-NULL"); - c64Img2 = psImageConjugate(c64Img2,c64Img); - ok(c64Img2 != NULL, "psImageConjugate() returned non-NULL"); - pImg2 = psImageConjugate(pImg2,pImg); - ok(pImg2 != NULL, "psImageConjugate() returned non-NULL"); - - ok(img2->type.type == PS_TYPE_C32, "psImageConjugate() returned the correct type"); - ok(c64Img2->type.type == PS_TYPE_C64, "psImageConjugate() returned the correct type"); - ok(pImg2->type.type == PS_TYPE_F32, "psImageConjugate() returned the correct type"); - - bool errorFlag = false; - for (psU32 row=0;rowdata.C32[row]; - psC64* c64Img2Row = c64Img2->data.C64[row]; - psF32* pImg2Row = pImg2->data.F32[row]; - for (psU32 col=0;col FLT_EPSILON || - fabsf(cimagf(img2Row[col]) + col) > FLT_EPSILON) { - diag("psImageComplex result is incorrect (%d,%d, %.2f+%.2fi)", - col,row,crealf(img2Row[col]),cimagf(img2Row[col])); - errorFlag = true; - } - if (fabsf(crealf(c64Img2Row[col]) - row) > FLT_EPSILON || - fabsf(cimagf(c64Img2Row[col]) + col) > FLT_EPSILON) { - diag("psImageComplex result is incorrect"); - errorFlag = true; - } - if (fabsf(pImg2Row[col] - (row+col)) > FLT_EPSILON) { - diag("psImageComplex result is incorrect"); - errorFlag = true; - } - } - } - ok(!errorFlag, "psImageConjugate() generated the correct data values"); - psFree(img); - psFree(img2); - psFree(c64Img); - psFree(c64Img2); - psFree(pImg); - psFree(pImg2); - - // Perform psImageConjugate with null input - ok(psImageConjugate(NULL,NULL) == NULL, "psImageConjugate() returned NULL with NULL input"); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - // testImagePowerSpectrum() - // 1. create a psC32 vector with unique real and imaginary components - // 2. call psImagePowerSpectrum - // 3. verify result is psF32 - // 4. verify the values are the square of the absolute values of the original - { - psMemId id = psMemGetId(); - psImage* img = NULL; - psImage* img2 = NULL; - psImage* c64Img = NULL; - psImage* c64Img2 = NULL; - psImage* pImg = NULL; - psU32 m = 128; - psU32 n = 64; - - GENIMAGE(img,m,n,C32, row + I * col); - GENIMAGE(c64Img,m,n,C64,row+I*col); - GENIMAGE(pImg,m,n,F32,row+col); - - img2 = psImagePowerSpectrum(img2,img); - c64Img2 = psImagePowerSpectrum(c64Img2, c64Img); - ok(img2 != NULL, "psImagePowerSpectrum() returned non-NULL"); - ok(c64Img2 != NULL, "psImagePowerSpectrum() returned non-NULL"); - ok(img2->type.type == PS_TYPE_F32, "psImagePowerSpectrum() returned the correct type"); - ok(c64Img2->type.type == PS_TYPE_F64, "psImagePowerSpectrum() returned the correct type"); - - bool errorFlag = false; - for (psU32 row=0;rowdata.C32[row]; - psF32* img2Row = img2->data.F32[row]; - psC64* c64ImgRow = c64Img->data.C64[row]; - psF64* c64Img2Row = c64Img2->data.F64[row]; - for (psU32 col=0;col 2.0f*FLT_EPSILON) { - diag("psImagePowerSpectrum result is incorrect (%d,%d, %.2f vs %.2f)", - col,row,img2Row[col],power); - errorFlag = true; - } - if (fabsf(c64Img2Row[col] - power64) > 2.0f*FLT_EPSILON) { - diag("psImagePowerSpectrum result is incorrect"); - errorFlag = true; - } - } - } - ok(!errorFlag, "psImagePowerSPectrum() generated the correct data values"); - psFree(img); - psFree(img2); - psFree(c64Img); - psFree(c64Img2); - - // Perform psImagePowerSpectrum with incorrect input - // Following should generate error message - // XXX: Verify error - ok(psImagePowerSpectrum(NULL,pImg) == NULL, "psImagePowerSpectrum() returned NULL with incorrect type"); - psFree(pImg); - - // Perform psImagePowerSpectrum with NULL input - ok(psImagePowerSpectrum(NULL,NULL) == NULL, "psImagePowerSpectrum() returned NULL with NULL input"); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // testImageRealImaginary() - // 1. create a C32 complex image with distinctly different real and imaginary parts - // 2. call psImageReal and psImageImaginary - // 3. compare results to the real/imaginary components of input - // XXX: If we put this block above the previous 2 blocks, then we get memory errors - { - psMemId id = psMemGetId(); - psImage* img = NULL; - psImage* img3 = NULL; - psU32 m = 128; - psU32 n = 64; - GENIMAGE(img,m,n,C32, row + I * col); - psImage* img2 = psImageReal(img2,img); - ok(img2 != NULL, "psImageReal returned non-NULL"); - skip_start(img2 == NULL, 4, "Skipping tests because psImageReal() returned NULL"); - ok(img2->type.type == PS_TYPE_F32, "psImageReal returned the correct type"); - img3 = psImageImaginary(img3,img); - ok(img3 != NULL, "psImageImaginary() returned non-NULL"); - skip_start(img3 == NULL, 2, "Skipping tests because psImageImaginary() returned NULL"); - ok(img3->type.type == PS_TYPE_F32, "psImageImaginary() returned the correct type"); - - bool errorFlag = false; - for (psU32 row=0;rowdata.F32[row]; - psF32* img3Row = img3->data.F32[row]; - for (psU32 col=0;col FLT_EPSILON) { - diag("psImageReal didn't return the real portion at n=%d", n); - errorFlag = true; - } - if (fabsf(img3Row[col] - col) > FLT_EPSILON) { - diag("psImageImaginary didn't return the imag portion at n=%d", n); - errorFlag = true; - } - } - } - ok(!errorFlag, "psImageReal(), psImageImaginary() returned the correct data"); - skip_end(); - skip_end(); - psFree(img); - psFree(img2); - psFree(img3); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - -} Index: trunk/psLib/test/imageops/tap_psVectorFFT.c =================================================================== --- trunk/psLib/test/imageops/tap_psVectorFFT.c (revision 11438) +++ (revision ) @@ -1,502 +1,0 @@ -/** @file tst_psVectorFFT.c -* -* @brief Contains the tests for psFFT.[ch] -* -* -* @author Robert DeSonia, MHPCC -* -* @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ -* @date $Date: 2007-01-30 00:13:01 $ -* -* XXX: Must add skip_start() macros -* -* -* -* -* -* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii -*/ -#include -#include -#include -#include "tap.h" -#include "pstap.h" - -#define GENIMAGE(img,c,r,TYP, valueFcn) \ -img = psImageAlloc(c,r,PS_TYPE_##TYP); \ -for (psU32 row=0;rowdata.TYP[row]; \ - for (psU32 col=0;coln = vec->nalloc; - for ( psU32 n = 0; n < 100; n++ ) - { - vec->data.F32[ n ] = sinf( ( psF32 ) n / 50.0f * M_PI ); - } - - vec2 = psVectorFFT(NULL, vec, PS_FFT_FORWARD); - ok(vec2 != NULL, "psVectorFFT() returned non-NULL"); - ok(vec2->type.type == PS_TYPE_C32, "psVectorFFT() returned the correct type"); - ok(vec2->n == vec->n, "psVectorFFT() returned the correct size vector"); - - bool errorFlag = false; - for ( psU32 n = 0; n < 100; n++ ) - { - if ( n == 1 || n == 99 ) { - if ( fabsf( cabsf( vec2->data.C32[ n ] ) - 50.0f ) > 0.1f ) { - diag("FFT didn't work for vector (n=%d)", n ); - errorFlag = true; - } - } else { - if ( fabsf( cabsf( vec2->data.C32[ n ] ) ) > 0.1f ) { - diag("FFT didn't work for vector (n=%d)", n ); - errorFlag = true; - } - } - } - ok(!errorFlag, "psVectorFFT() returned the correct data values"); - - vec3 = psVectorFFT( NULL, vec2, PS_FFT_REVERSE ); - ok(vec3 != NULL, "psVectorFFT() returned non-NULL"); - ok(vec3->type.type == PS_TYPE_C32, "psVectorFFT() returned the correct type"); - ok(vec3->n != vec2->n, "psVectorFFT() returned the correct size vectors"); - - errorFlag = false; - for ( psU32 n = 0; n < 100; n++ ) - { - psF32 val = sinf( ( psF32 ) n / 50.0f * M_PI ); - psF32 vecVal = crealf( vec3->data.C32[ n ] ) / 100; - if ( fabsf( vecVal - val ) > 0.1f ) { - diag("Reverse FFT didn't give me the original vector back (n=%d) (%.2f vs %.2f)", - n, vecVal, val ); - errorFlag = true; - } - } - ok(!errorFlag, "psVectorFFT() returned the correct data values"); - - // Perform reverse transform with real flag set - vec4 = psVectorFFT(NULL,vec2, (PS_FFT_REVERSE | PS_FFT_REAL_RESULT)); - ok(vec4->type.type == PS_TYPE_F32, "FFT with real result did produce real values"); - - // Perform vector FFT with incorrect direction flags - // Following should generate an error message - // XXX: Verify error - ok(psVectorFFT(NULL,vec2,(psFFTFlags)0) == NULL, "psVectorFFT() returned NULL with incorrect direction"); - psFree(vec); - psFree(vec2); - psFree(vec3); - psFree(vec4); - - // Perform vector FFT with null input - ok(psVectorFFT(NULL,NULL,PS_FFT_FORWARD) == NULL, "psVectorFFT() returned NULL with null input vector"); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // testVectorRealImaginary() - // 1. create a C32 complex vector with distinctly different real and imaginary parts. - // 2. call psVectorReal and psVectorImaginary - // 3. compare results to the real/imaginary components of input - { - psMemId id = psMemGetId(); - psVector * vec = NULL; - psVector* vec2 = NULL; - psVector* vec3 = NULL; - psVector* vec4 = NULL; - psVector* vec5 = NULL; - psVector* vec6 = NULL; - psVector* vec7 = NULL; - psVector* vec8 = NULL; - psVector* vec9 = NULL; - psVector* vec10 = NULL; - psVector* vec11 = NULL; - - vec = psVectorAlloc( 100, PS_TYPE_C32 ); - vec8 = psVectorAlloc( 100, PS_TYPE_C64 ); - vec10 = psVectorAlloc( 100, PS_TYPE_C64 ); - vec->n = vec->nalloc; - vec8->n = vec8->nalloc; - vec10->n = vec10->nalloc; - for ( psU32 n = 0; n < 100; n++ ) - { - vec->data.C32[ n ] = n + I * ( n * 2 ); - vec8->data.C64[n] = n + I * ( n * 2 ); - vec10->data.C64[n] = n + I * ( n * 2 ); - } - vec4 = psVectorAlloc( 100, PS_TYPE_F32); - vec4->n = vec4->nalloc; - vec6 = psVectorAlloc( 100, PS_TYPE_F32); - vec6->n = vec6->nalloc; - for ( psU32 n = 0; n < 100; n++ ) - { - vec4->data.F32[n] = n; - vec6->data.F32[n] = n; - } - - vec2 = psVectorReal( vec2, vec ); - ok(vec2 != NULL, "psVectorReal() returned non-NULL"); - ok(vec2->type.type == PS_TYPE_F32, "psVectorReal() returned the correct type"); - - // Following should generate a warning - // XXX: Verify warning - vec5 = psVectorReal(vec5, vec4); - ok(vec5 != NULL, "psVectorReal() returned non-NULL"); - ok(vec5->type.type == PS_TYPE_F32, "psVectorReal() returned the correct type"); - - vec9 = psVectorReal(vec9,vec8); - ok(vec9 != NULL, "psVectorReal() returned non-NULL"); - ok(vec9->type.type == PS_TYPE_F64, "psVectorReal() returned the correct type"); - - // Following should generate a warning - // XXX: Verify warning - vec3 = psVectorImaginary( vec3, vec ); - ok(vec3 != NULL, "psVectorImaginary() returned non-NULL"); - ok(vec3->type.type == PS_TYPE_F32, "psVectorImaginary() returned the correct type"); - - vec7 = psVectorImaginary(vec7, vec6); - ok(vec7 != NULL, "psVectorImaginary() returned non-NULL"); - ok(vec7->type.type == PS_TYPE_F32, "psVectorImaginary() returned the correct type"); - - vec11 = psVectorImaginary(vec11, vec10); - ok(vec11 != NULL, "psVectorImaginary() returned non-NULL"); - ok(vec11->type.type == PS_TYPE_F64, "psVectorImaginary() returned the correct type"); - - - // 3. compare results to the real/imaginary components of input - bool errorFlag = false; - for ( psU32 n = 0; n < 100; n++ ) - { - psF32 r = n; - psF32 i = ( n * 2 ); - psF64 rr = n; - psF64 ii = ( n * 2 ); - if ( fabsf( vec2->data.F32[ n ] - r ) > FLT_EPSILON ) { - diag("psVectorReal didn't return the real portion at n=%d", n); - errorFlag = true; - } - if ( fabsf( vec3->data.F32[ n ] - i ) > FLT_EPSILON ) { - diag("psVectorImaginary didn't return the real portion at n=%d", n); - errorFlag = true; - } - if ( fabsf( vec5->data.F32[n] - r) > FLT_EPSILON) { - diag("psVectorReal didn't return the real portion at n=%d",n); - errorFlag = true; - } - if ( fabsf( vec7->data.F32[n] - 0) > FLT_EPSILON) { - diag("psVectorImaginary did not return the imaginary portion at n=%d",n); - errorFlag = true; - } - if ( fabsf(vec9->data.F64[n] - rr) > FLT_EPSILON ) { - diag("psVectorReal did not return the real portion at n=%d",n); - errorFlag = true; - } - if ( fabsf(vec11->data.F64[n] - ii) > FLT_EPSILON) { - diag("psVectorImaginary did not return the imaginary portion at n=%d",n); - errorFlag = true; - } - } - ok(!errorFlag, "psVectorImaginary() returned the correct data values"); - - psFree( vec ); - psFree( vec2 ); - psFree( vec3 ); - psFree( vec4 ); - psFree( vec5 ); - psFree( vec6 ); - psFree( vec7 ); - psFree( vec8 ); - psFree( vec9 ); - psFree( vec10 ); - psFree( vec11 ); - - // Perform vector Real with null input - ok(psVectorReal(NULL,NULL) == NULL, "psVectorReal returned NULL with NULL input"); - ok(psVectorImaginary(NULL,NULL) == NULL, "psVectorImaginary returned NULL with NULL input"); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // testVectorComplex() - // 1. create two unique psF32 vectors of the same size - // 2. call psVectorComplex - // 3. verify that the result is a psC32 - // 4. call psVectorReal and psVectorImaginary on step 2 results - // 5. compare step 4 results to input. - // 6. create a psF32 and a psF64 vector of the same size - // 7. call psVectorComplex - // 8. verify that an appropriate error occurred. - // 9. create two psf32 vectors of different sizes - // 10. call psVectorComplex - // 11. verify thet an appropriate error occurred. - { - psMemId id = psMemGetId(); - psVector * vec = NULL; - psVector* vec2 = NULL; - psVector* vec3 = NULL; - psVector* vec4 = NULL; - psVector* vec5 = NULL; - psVector* vec6 = NULL; - - // 1. create two unique psF32 vectors of the same size - vec = psVectorAlloc( 100, PS_TYPE_F32 ); - vec2 = psVectorAlloc( 100, PS_TYPE_F32 ); - vec4 = psVectorAlloc( 100, PS_TYPE_F64 ); - vec5 = psVectorAlloc( 100, PS_TYPE_F64 ); - vec->n = vec->nalloc; - vec2->n = vec2->nalloc; - vec4->n = vec4->nalloc; - vec5->n = vec5->nalloc; - for ( psU32 n = 0; n < 100; n++ ) - { - vec->data.F32[ n ] = n; - vec2->data.F32[ n ] = ( n * 2 ); - vec4->data.F64[ n ] = n; - vec5->data.F64[ n ] = ( n * 2 ); - } - - vec3 = psVectorComplex( vec3, vec, vec2 ); - ok(vec3 != NULL, "psVectorComplex() returned non-NULL"); - ok(vec3->type.type == PS_TYPE_C32, "psVectorComplex() returned the correct type"); - bool errorFlag = false; - for ( psU32 n = 0; n < 100; n++ ) - { - if ( fabsf( crealf( vec3->data.C32[ n ] ) - n ) > FLT_EPSILON || - fabsf( cimagf( vec3->data.C32[ n ] ) - ( n * 2 ) ) > FLT_EPSILON ) { - diag("psVectorComplex result is incorrect (n=%d, %.2f+%.2fi)", - n, crealf( vec3->data.C32[ n ] ), cimagf( vec3->data.C32[ n ] ) ); - errorFlag = true; - }; - } - ok(!errorFlag, "psVectorComplex() returned the correct data values"); - - - vec2 = psVectorRecycle( vec2, 100, PS_TYPE_F64 ); - // Following should be an error (type mismatch) - // Verify error - vec3 = psVectorComplex( vec3, vec, vec2 ); - ok(vec3 == NULL, "psVectorComplex() returned NULL when input types mismatched." ); - - vec2 = psVectorRecycle( vec2, 200, PS_TYPE_F32 ); - vec3 = psVectorComplex( vec3, vec, vec2 ); - ok(vec3->n == 100, "psVectorComplex() returned the correct size vector"); - - // Verify the function works with psF64 type - vec6 = psVectorComplex(vec6, vec4, vec5); - ok(vec6->type.type == PS_TYPE_C64, "psVectorComplex() returned the correct type (C64)"); - - // Verify error message generated with input of incorrect type - // Following should generate an error message - vec4->type.type = PS_TYPE_S8; - vec5->type.type = PS_TYPE_S8; - vec6 = psVectorComplex(vec6, vec4, vec5); - ok(vec6 == NULL, "psVectorComplex() returned NULL for incorrect type"); - vec4->type.type = PS_TYPE_F64; - vec5->type.type = PS_TYPE_F64; - psFree(vec); - psFree(vec2); - psFree(vec3); - psFree(vec4); - psFree(vec5); - - // Perform vector complex with null input - ok(psVectorComplex(NULL,NULL,NULL) == NULL, "psVectorComplex() returned NULL with null input vector"); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // testVectorConjugate() - // 1. create a psC32 with unique real and imaginary values. - // 2. call psVectorConjugate - // 3. verify result is psC32 - // 4. verify each value is conjugate of input (a+bi -> a-bi) - { - psMemId id = psMemGetId(); - psVector * vec = NULL; - psVector* vec2 = NULL; - - vec = psVectorAlloc( 100, PS_TYPE_C32 ); - vec->n = vec->nalloc; - for ( psU32 n = 0; n < 100; n++ ) - { - vec->data.C32[ n ] = n + I * ( n * 2 ); - } - - vec2 = psVectorConjugate(vec2, vec); - ok(vec2 != NULL, "psVectorConjugate() returned non-NULL"); - ok(vec2->type.type == PS_TYPE_C32, "psVectorConjugate() returned the correct type"); - - bool errorFlag = false; - for ( psU32 n = 0; n < 100; n++ ) - { - if ( fabsf( crealf( vec->data.C32[ n ] ) - crealf( vec2->data.C32[ n ] ) ) > FLT_EPSILON || - fabsf( cimagf( vec->data.C32[ n ] ) + cimagf( vec2->data.C32[ n ] ) ) > FLT_EPSILON ) { - diag("psVectorConjugate result is incorrect (n=%d, %.2f+%.2fi)", - n, crealf( vec2->data.C32[ n ] ), cimagf( vec2->data.C32[ n ] ) ); - errorFlag = true; - }; - } - ok(!errorFlag, "psVectorConjugate() returned the correct data values"); - psFree(vec); - - // Perform conjugate for non-complex number - vec = psVectorAlloc( 100, PS_TYPE_F32 ); - vec->n = vec->nalloc; - for ( psU32 n = 0; n < 100; n++ ) - { - vec->data.F32[ n ] = n; - } - // Following should generate a warning message - // XXX: verify warning - vec2 = psVectorConjugate(vec2,vec); - ok(vec2->type.type == PS_TYPE_F32, "psVectorConjugate did return a F32 vector"); - - errorFlag = false; - for ( psU32 n = 0; n < 100; n++ ) - { - if( vec->data.F32[n] != vec2->data.F32[n] ) { - diag("psVectorConjugate result is incorrect (n=%d)",n); - errorFlag = true; - } - } - ok(!errorFlag, "psVectorConjugate() returned the correct data values"); - psFree(vec); - - // Perform vector conjugate with C64 type - vec = psVectorAlloc( 100, PS_TYPE_C64 ); - vec->n = vec->nalloc; - for ( psU32 n = 0; n < 100; n++ ) - { - vec->data.C64[n] = n + I * ( n * 2 ); - } - vec2 = psVectorConjugate(vec2,vec); - ok(vec2 != NULL, "psVectorConjugate() returned non-NULL"); - ok(vec2->type.type == PS_TYPE_C64, "psVectorConjugate() returned the correct type"); - errorFlag = false; - for ( psU32 n = 0; n < 100; n++ ) - { - if ( fabsf( crealf(vec->data.C64[n]) - crealf(vec2->data.C64[n])) > FLT_EPSILON || - fabsf( cimagf(vec->data.C64[n]) + cimagf(vec2->data.C64[n])) > FLT_EPSILON ) { - diag("psVectorConjugate result is incorrect (n=%d)",n); - errorFlag = true; - } - } - ok(!errorFlag, "psVectorConjugate() returned the correct data values"); - psFree(vec); - - // Perform vector conjugate with null input (vec2 should be freed too) - ok(psVectorConjugate(vec2,NULL) == NULL, "psVectorConjugate() returned NULL with null input vector"); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // testVectorPowerSpectrum() - // 1. create a psC32 vector with unique real and imaginary components - // 2. call psVectorPowerSpectrum - // 3. verify result is psF32 - // 4. verify the values are the square of the absolute values of the original - { - psMemId id = psMemGetId(); - psVector * vec = NULL; - psVector* vec2 = NULL; - psVector* vec3 = NULL; - psVector* vec4 = NULL; - psF32 val; - psF64 val1; - - vec = psVectorAlloc( 100, PS_TYPE_C32 ); - vec->n = vec->nalloc; - vec3 = psVectorAlloc(100,PS_TYPE_C64); - vec3->n = vec3->nalloc; - for ( psU32 n = 0; n < 100; n++ ) - { - vec->data.C32[ n ] = n + I * sinf( ( ( psF32 ) n ) / 50.f * M_PI ); - vec3->data.C64[ n ] = n + I * sinf( ( ( psF64 ) n ) / 50.f * M_PI ); - } - - vec2 = psVectorPowerSpectrum(vec2, vec); - ok(vec2 != NULL, "psVectorPowerSpectrum() returned non-NULL"); - vec4 = psVectorPowerSpectrum(vec4, vec3); - ok(vec4 != NULL, "psVectorPowerSpectrum() returned non-NULL"); - // XXX: These next two tests fail - ok(vec2->type.type != PS_TYPE_F32, "psVectorPowerSpectrum() returned the correct type"); - ok(vec4->type.type != PS_TYPE_F64, "psVectorPowerSpectrum() returned the correct type"); - - val = cabsf( vec->data.C32[ 0 ] ) * cabsf( vec->data.C32[ 0 ] ) / 100 / 100; - val1= cabsf( vec3->data.C64[0] ) * cabsf(vec3->data.C64[0])/100/100; - ok(fabsf(vec2->data.F32[ 0 ] - val ) <= FLT_EPSILON, - "psVectorPowerSpectrum result is correct (n=0, %.2f %.2f)", - vec2->data.F32[ 0 ], val ); - ok(fabsf( vec4->data.C64[0] - val1 ) <= FLT_EPSILON, - "psVectorPowerSpectrum result is correct (n=0)"); - - bool errorFlag = false; - for ( psU32 n = 1; n < 50; n++ ) - { - val = ( cabsf( vec->data.C32[ n ] ) * cabsf( vec->data.C32[ n ] ) + - cabsf( vec->data.C32[ 100 - n ] ) * cabsf( vec->data.C32[ 100 - n ] ) ) / 100 / 100; - val1 = (cabsf(vec3->data.C64[n]) * cabsf(vec3->data.C64[n]) + - cabsf(vec3->data.C64[100-n]) * cabsf(vec3->data.C64[100-n]))/100/100; - if ( fabsf( val - vec2->data.F32[ n ] ) > 10*FLT_EPSILON ) { - diag("psVectorPowerSpectrum result is incorrect (n=%d, %.2f %.2f)", - n, vec2->data.F32[ n ], val ); - errorFlag = true; - } - if (fabsf(val1 - vec4->data.F64[n]) > 10*FLT_EPSILON) { - diag("psVectorPowerSpectrum result is incorrect (n=%d, %.2f %.2f)",n,vec4->data.F64[n],val1); - errorFlag = true; - } - } - ok(!errorFlag, "psVectorPowerSpectrum() returned the correct data values"); - - val = cabsf( vec->data.C32[ 50 ] ) * cabsf( vec->data.C32[ 50 ] ) / 100 / 100; - ok(fabsf( vec2->data.F32[ 50 ] - val ) <= 10*FLT_EPSILON, - "psVectorPowerSpectrum result is correct (n=50, %.2f %.2f)", - vec2->data.F32[ 0 ], val ); - psFree( vec ); - psFree( vec2 ); - psFree( vec3 ); - psFree( vec4 ); - - // Perform vector power spectrum with non-complex number - vec = psVectorAlloc(100,PS_TYPE_F32); - vec->n = vec->nalloc; - for( psU32 n=0; n<100; n++) - { - vec->data.F32[n] = n; - } - - // Following should generate an error message - // XXX: Verify error - ok(psVectorPowerSpectrum(NULL,vec) == NULL, - "psVectorPowerSpectrum() did return a NULL vector."); - // Perform vector power spectrum with null input - ok(psVectorPowerSpectrum(NULL,NULL) == NULL, - "psVectorPowerSpectrum() did return NULL with null input vector"); - - psFree(vec); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } -} Index: trunk/psLib/test/imageops/tap_psXML.c =================================================================== --- trunk/psLib/test/imageops/tap_psXML.c (revision 11438) +++ (revision ) @@ -1,317 +1,0 @@ -/** @file tst_psXML.c -* -* @brief Test driver for psXML functions -* -* This test driver contains the following tests for psXML: -* Test 1 - Parse an XML file -* Test 2 - Parse an XML memory block -* Test 3 - Parse an XML file descriptor -* Test 4 - Convert an XML doc to Metadata -* Test 5 - Convert Metadata to an XML doc -* Test 6 - Write an XML doc to file -* Test 7 - Write an XML doc to memory block -* Test 8 - Write an XML doc to file descriptor -* -* @author Dave Robbins, MHPCC -* -* XXXX: This doesn't even compile -* XXXX: There are no data tests, he simple prints data to STDOUT -* -* @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ -* @date $Date: 2007-01-30 00:13:01 $ -* -* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii -* -*/ -#include -#include -#include -#include "tap.h" -#include "pstap.h" - -//static void writeMetadata(psMetadata* metadata, char* indentStr); - -// XXX: What should SRCDIR be? -#define SRCDIR -const char testFile1[] = SRCDIR "/psTime.xml"; -const char testFile2[] = SRCDIR "/psTime2.xml"; -const char testFile3[] = SRCDIR "/psTime3.xml"; -const char testFile4[] = SRCDIR "/psTime4.xml"; -//static void printMetadata(psMetadata *in); -static void printMetadataItem(psMetadataItem *metadataItem, char *spaces); -static void printMetadata(psMetadata *metadata); -static void printMetadataList(psList *metadataItemList, char* spaces); -static void printMetadataTable(psHash *mdTable); - -static void printMetadata(psMetadata *metadata) -{ - printf("Contents of metadata list:\n"); - printMetadataList(metadata->list, " "); - printf("\nContents of metadata table:\n"); - printMetadataTable(metadata->hash); -} - -static void printMetadataList(psList *metadataItemList, char* spaces) -{ - psMetadataItem *entryChild = NULL; - - psListIterator* iter = psListIteratorAlloc(metadataItemList, PS_LIST_HEAD, true); - - while ( (entryChild=psListGetAndIncrement(iter)) != NULL) { - printMetadataItem(entryChild, spaces); - } - - psFree(iter); -} - -static void printMetadataTable(psHash *mdTable) -{ - psS32 i; - psHashBucket* ptr = NULL; - for(i=0; in; i++) { - ptr = mdTable->buckets[i]; - while (ptr != NULL) { - printMetadataItem(ptr->data, " "); - ptr = ptr->next; - } - } -} - -static void printMetadataItem(psMetadataItem *metadataItem, char *spaces) -{ - int i = 0; - printf("%sKey Name: %25s ", spaces, metadataItem->name); - // printf("Key mdType: %d ", (int)metadataItem->type); - // printf("Key mdType: 0x%08x ", metadataItem->type); - // if ( metadataItem->type == PS_DATA_S32 ) - // printf("Key mdType: S32 " ); - - switch (metadataItem->type) { - case PS_DATA_BOOL: - printf("Key Type: BOOL Key Value: %15d ", metadataItem->data.B); - break; - case PS_DATA_S32: - printf("Key Type: S32 Key Value: %15d ", metadataItem->data.S32); - break; - case PS_DATA_F32: - printf("Key Type: F32 Key Value: %15.3f ", metadataItem->data.F32); - break; - case PS_DATA_F64: - printf("Key Type: F64 Key Value: %15.3f ", metadataItem->data.F64); - break; - case PS_DATA_METADATA: - printf("Key Type: METADATA "); - break; - default: - printf("Key type: psPtr "); - } - if ( !strncmp(metadataItem->name, "psLib.time.Vector.S32", 256) ) { - printf("Key Values: "); - while ( (int)((psVector*)(metadataItem->data.V))->data.S32[i] != 0 ) { - printf("%d ", (int)((psVector*)(metadataItem->data.V))->data.S32[i] ); - i++; - } - printf("\n"); - } else if ( !strncmp(metadataItem->name, "psLib.time.tables.dir", 256) ) { - printf("Key Value: "); - printf("%s", (char*)metadataItem->data.V ); - printf("\n"); - } else if ( !strncmp(metadataItem->name, "psLib.TIME.Magazine", 256) ) { - printf("Key Value: "); - printf("%ld, ", (long)((psTime*)(metadataItem->data.V))->sec ); - printf("%u, ", ((psTime*)(metadataItem->data.V))->nsec ); - if( ((psTime*)(metadataItem->data.V))->leapsecond ) - printf("TRUE "); - else - printf("FALSE "); - if( ((psTime*)(metadataItem->data.V))->type == PS_TIME_UTC ) - printf("PS_TIME_UTC "); - else if( ((psTime*)(metadataItem->data.V))->type == PS_TIME_TAI ) - printf("PS_TIME_TAI "); - else if( ((psTime*)(metadataItem->data.V))->type == PS_TIME_UT1 ) - printf("PS_TIME_UT1 "); - else if( ((psTime*)(metadataItem->data.V))->type == PS_TIME_TT ) - printf("PS_TIME_TT "); - printf("\n"); - } else - printf("Key Comment: %s\n", metadataItem->comment); - - // if(metadataItem->data.V && metadataItem->type==PS_META_MULTI) { - // if(metadataItem->data.V) { - // printMetadataList(metadataItem->data.V, " "); - // } -} - -typedef xmlDocPtr psXMLDoc; -psS32 main( psS32 argc, char* argv[] ) -{ - psLogSetFormat("HLNM"); - psLogSetLevel(PS_LOG_INFO); - plan_tests(24); - - //Parses an XML file into memory. Stores as a psXMLDoc// - // testXMLInput00 - { - psMemId id = psMemGetId(); - //psXMLParseFile should return a psXMLDoc* of testFile1// - psXMLDoc *newXML = NULL; - newXML = psXMLParseFile(testFile1); - ok(newXML != NULL, "psXMLParseFile() returned non-NULL"); - psFree(newXML); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - //Parses an XML file from memory. Stores as a psXMLDoc// - // testXMLInput01 - { - psMemId id = psMemGetId(); - psXMLDoc *newXML = NULL; - newXML = psXMLParseFile(testFile1); - char buffer[2048]; - ok(psXMLDocToMem(newXML, buffer), "psXMLDocToMem() returned non-NULL"); - psXMLDoc *newDoc = NULL; - newDoc = psXMLParseMem(buffer, strlen(buffer) ); - ok(newDoc != NULL, "psXMLParseMem() returned non-NULL"); - psFree(newDoc); - psFree(newXML); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - //Parses an XML file from a file descriptor. Stores as a psXMLDoc// - // testXMLInput02 - { - psMemId id = psMemGetId(); - psXMLDoc *newXML = NULL; - newXML = psXMLParseFile(testFile1); - ok(newXML != NULL, "psXMLParseFile () returned non-NULL"); - int fd = creat("psTest5.xml", 0644); - ok(psXMLDocToFD(newXML, fd), "psXMLDocToFD() returned TRUE"); - - psXMLDoc *newDoc = NULL; - fd = open("psTest5.xml", O_RDWR, 0); - newDoc = psXMLParseFD(fd); - ok(newDoc != NULL, "psXMLParseFD () returned non-NULL"); - close(fd); - psFree(newXML); - psFree(newDoc); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - //Converts an existing psXMLDoc into psMetadata// - // testXMLConvert00 - { - psMemId id = psMemGetId(); - psXMLDoc *newXML = NULL; - newXML = psXMLParseFile(testFile1); - psMetadata *metaData = NULL; - metaData = psXMLDocToMetadata(newXML); - if (metaData == NULL) - { - ok(false, "psXMLDocToMetadata() returned non-NULL"); - } else - { - ok(true, "psXMLDocToMetadata() returned non-NULL"); - printMetadata(metaData); - } - psFree(newXML); - psFree(metaData); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // Converts existing psMetadata into a psXMLDoc// - // testXMLConvert01 - { - psMemId id = psMemGetId(); - psXMLDoc *newXML = NULL; - newXML = psXMLParseFile(testFile1); - psMetadata *metaData = NULL; - metaData = psXMLDocToMetadata(newXML); - ok(metaData != NULL, "psXMLDocToMetadata() returned non-NULL"); - psXMLDoc *XML2 = NULL; - XML2 = psMetadataToXMLDoc(metaData); - ok(psXMLDocToFile(XML2, "psTest2.xml"), "psMetadataToXMLDoc() returned TRUE"); - psFree(newXML); - psFree(XML2); - psFree(metaData); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - //Writes a psXMLDoc to File// - // testXMLOutput00 - { - psMemId id = psMemGetId(); - psXMLDoc *newXML = NULL; - newXML = psXMLParseFile(testFile1); - ok(psXMLDocToFile(newXML, "psTest.xml"), "psXMLParseFile() returned TRUE"); - psFree(newXML); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - //Writes a psXMLDoc to Memory// - // testXMLOutput01 - { - psMemId id = psMemGetId(); - psXMLDoc *newXML = NULL; - newXML = psXMLParseFile(testFile1); - char buffer[2048]; - FILE *file; - file = fopen("psTest3.xml", "w"); - ok(psXMLDocToMem(newXML, buffer), "fopen() successful"); - fprintf(file, "%s", buffer); - fclose(file); - psFree(newXML); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - //Writes a psXMLDoc to a file descriptor// - // testXMLOutput02 - { - psMemId id = psMemGetId(); - psXMLDoc *newXML = NULL; - newXML = psXMLParseFile(testFile1); - int fd = creat("psTest4.xml", 0666); - ok(!psXMLDocToFD(newXML, fd), "psXMLDocToFD() returned TRUE"); - close(fd); - psFree(newXML); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - - - // testXMLWrongInput - { - psMemId id = psMemGetId(); - psXMLDoc *newXML = NULL; - newXML = psXMLParseFile(testFile2); - ok(newXML != NULL, "psXMLParseFile() returned non-NULL"); - psMetadata *metaData = NULL; - metaData = psXMLDocToMetadata(newXML); - ok(metaData != NULL, "psXMLDocToMetadata() returned non-NULL"); - psFree(newXML); - psFree(metaData); - psXMLDoc *newXML2 = NULL; - psMetadata *metaData2 = NULL; - newXML2 = psXMLParseFile(testFile3); - ok(newXML2 != NULL, "psXMLParseFile() returned non-NULL"); - metaData2 = psXMLDocToMetadata(newXML2); - ok(metaData2 != NULL, "psXMLDocToMetadata() returned non-NULL"); - psFree(newXML2); - psFree(metaData2); - psXMLDoc *newXML3 = NULL; - psMetadata *metaData3 = NULL; - newXML3 = psXMLParseFile(testFile4); - ok(newXML3 != NULL, "psXMLParseFile() returned non-NULL"); - metaData3 = psXMLDocToMetadata(newXML3); - ok(metaData3 != NULL, "psXMLDocToMetadata() returned non-NULL"); - psFree(newXML3); - psFree(metaData3); - ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); - } - /* HERE - */ -} Index: trunk/psLib/test/xml/tap_psXML.c =================================================================== --- trunk/psLib/test/xml/tap_psXML.c (revision 11439) +++ trunk/psLib/test/xml/tap_psXML.c (revision 11439) @@ -0,0 +1,317 @@ +/** @file tst_psXML.c +* +* @brief Test driver for psXML functions +* +* This test driver contains the following tests for psXML: +* Test 1 - Parse an XML file +* Test 2 - Parse an XML memory block +* Test 3 - Parse an XML file descriptor +* Test 4 - Convert an XML doc to Metadata +* Test 5 - Convert Metadata to an XML doc +* Test 6 - Write an XML doc to file +* Test 7 - Write an XML doc to memory block +* Test 8 - Write an XML doc to file descriptor +* +* @author Dave Robbins, MHPCC +* +* XXXX: This doesn't even compile +* XXXX: There are no data tests, he simple prints data to STDOUT +* +* @version $Revision: 1.1 $ $Name: not supported by cvs2svn $ +* @date $Date: 2007-01-30 21:32:57 $ +* +* Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii +* +*/ +#include +#include +#include +#include "tap.h" +#include "pstap.h" + +//static void writeMetadata(psMetadata* metadata, char* indentStr); + +// XXX: What should SRCDIR be? +#define SRCDIR +const char testFile1[] = SRCDIR "/psTime.xml"; +const char testFile2[] = SRCDIR "/psTime2.xml"; +const char testFile3[] = SRCDIR "/psTime3.xml"; +const char testFile4[] = SRCDIR "/psTime4.xml"; +//static void printMetadata(psMetadata *in); +static void printMetadataItem(psMetadataItem *metadataItem, char *spaces); +static void printMetadata(psMetadata *metadata); +static void printMetadataList(psList *metadataItemList, char* spaces); +static void printMetadataTable(psHash *mdTable); + +static void printMetadata(psMetadata *metadata) +{ + printf("Contents of metadata list:\n"); + printMetadataList(metadata->list, " "); + printf("\nContents of metadata table:\n"); + printMetadataTable(metadata->hash); +} + +static void printMetadataList(psList *metadataItemList, char* spaces) +{ + psMetadataItem *entryChild = NULL; + + psListIterator* iter = psListIteratorAlloc(metadataItemList, PS_LIST_HEAD, true); + + while ( (entryChild=psListGetAndIncrement(iter)) != NULL) { + printMetadataItem(entryChild, spaces); + } + + psFree(iter); +} + +static void printMetadataTable(psHash *mdTable) +{ + psS32 i; + psHashBucket* ptr = NULL; + for(i=0; in; i++) { + ptr = mdTable->buckets[i]; + while (ptr != NULL) { + printMetadataItem(ptr->data, " "); + ptr = ptr->next; + } + } +} + +static void printMetadataItem(psMetadataItem *metadataItem, char *spaces) +{ + int i = 0; + printf("%sKey Name: %25s ", spaces, metadataItem->name); + // printf("Key mdType: %d ", (int)metadataItem->type); + // printf("Key mdType: 0x%08x ", metadataItem->type); + // if ( metadataItem->type == PS_DATA_S32 ) + // printf("Key mdType: S32 " ); + + switch (metadataItem->type) { + case PS_DATA_BOOL: + printf("Key Type: BOOL Key Value: %15d ", metadataItem->data.B); + break; + case PS_DATA_S32: + printf("Key Type: S32 Key Value: %15d ", metadataItem->data.S32); + break; + case PS_DATA_F32: + printf("Key Type: F32 Key Value: %15.3f ", metadataItem->data.F32); + break; + case PS_DATA_F64: + printf("Key Type: F64 Key Value: %15.3f ", metadataItem->data.F64); + break; + case PS_DATA_METADATA: + printf("Key Type: METADATA "); + break; + default: + printf("Key type: psPtr "); + } + if ( !strncmp(metadataItem->name, "psLib.time.Vector.S32", 256) ) { + printf("Key Values: "); + while ( (int)((psVector*)(metadataItem->data.V))->data.S32[i] != 0 ) { + printf("%d ", (int)((psVector*)(metadataItem->data.V))->data.S32[i] ); + i++; + } + printf("\n"); + } else if ( !strncmp(metadataItem->name, "psLib.time.tables.dir", 256) ) { + printf("Key Value: "); + printf("%s", (char*)metadataItem->data.V ); + printf("\n"); + } else if ( !strncmp(metadataItem->name, "psLib.TIME.Magazine", 256) ) { + printf("Key Value: "); + printf("%ld, ", (long)((psTime*)(metadataItem->data.V))->sec ); + printf("%u, ", ((psTime*)(metadataItem->data.V))->nsec ); + if( ((psTime*)(metadataItem->data.V))->leapsecond ) + printf("TRUE "); + else + printf("FALSE "); + if( ((psTime*)(metadataItem->data.V))->type == PS_TIME_UTC ) + printf("PS_TIME_UTC "); + else if( ((psTime*)(metadataItem->data.V))->type == PS_TIME_TAI ) + printf("PS_TIME_TAI "); + else if( ((psTime*)(metadataItem->data.V))->type == PS_TIME_UT1 ) + printf("PS_TIME_UT1 "); + else if( ((psTime*)(metadataItem->data.V))->type == PS_TIME_TT ) + printf("PS_TIME_TT "); + printf("\n"); + } else + printf("Key Comment: %s\n", metadataItem->comment); + + // if(metadataItem->data.V && metadataItem->type==PS_META_MULTI) { + // if(metadataItem->data.V) { + // printMetadataList(metadataItem->data.V, " "); + // } +} + +typedef xmlDocPtr psXMLDoc; +psS32 main( psS32 argc, char* argv[] ) +{ + psLogSetFormat("HLNM"); + psLogSetLevel(PS_LOG_INFO); + plan_tests(24); + + //Parses an XML file into memory. Stores as a psXMLDoc// + // testXMLInput00 + { + psMemId id = psMemGetId(); + //psXMLParseFile should return a psXMLDoc* of testFile1// + psXMLDoc *newXML = NULL; + newXML = psXMLParseFile(testFile1); + ok(newXML != NULL, "psXMLParseFile() returned non-NULL"); + psFree(newXML); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + //Parses an XML file from memory. Stores as a psXMLDoc// + // testXMLInput01 + { + psMemId id = psMemGetId(); + psXMLDoc *newXML = NULL; + newXML = psXMLParseFile(testFile1); + char buffer[2048]; + ok(psXMLDocToMem(newXML, buffer), "psXMLDocToMem() returned non-NULL"); + psXMLDoc *newDoc = NULL; + newDoc = psXMLParseMem(buffer, strlen(buffer) ); + ok(newDoc != NULL, "psXMLParseMem() returned non-NULL"); + psFree(newDoc); + psFree(newXML); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + //Parses an XML file from a file descriptor. Stores as a psXMLDoc// + // testXMLInput02 + { + psMemId id = psMemGetId(); + psXMLDoc *newXML = NULL; + newXML = psXMLParseFile(testFile1); + ok(newXML != NULL, "psXMLParseFile () returned non-NULL"); + int fd = creat("psTest5.xml", 0644); + ok(psXMLDocToFD(newXML, fd), "psXMLDocToFD() returned TRUE"); + + psXMLDoc *newDoc = NULL; + fd = open("psTest5.xml", O_RDWR, 0); + newDoc = psXMLParseFD(fd); + ok(newDoc != NULL, "psXMLParseFD () returned non-NULL"); + close(fd); + psFree(newXML); + psFree(newDoc); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + //Converts an existing psXMLDoc into psMetadata// + // testXMLConvert00 + { + psMemId id = psMemGetId(); + psXMLDoc *newXML = NULL; + newXML = psXMLParseFile(testFile1); + psMetadata *metaData = NULL; + metaData = psXMLDocToMetadata(newXML); + if (metaData == NULL) + { + ok(false, "psXMLDocToMetadata() returned non-NULL"); + } else + { + ok(true, "psXMLDocToMetadata() returned non-NULL"); + printMetadata(metaData); + } + psFree(newXML); + psFree(metaData); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // Converts existing psMetadata into a psXMLDoc// + // testXMLConvert01 + { + psMemId id = psMemGetId(); + psXMLDoc *newXML = NULL; + newXML = psXMLParseFile(testFile1); + psMetadata *metaData = NULL; + metaData = psXMLDocToMetadata(newXML); + ok(metaData != NULL, "psXMLDocToMetadata() returned non-NULL"); + psXMLDoc *XML2 = NULL; + XML2 = psMetadataToXMLDoc(metaData); + ok(psXMLDocToFile(XML2, "psTest2.xml"), "psMetadataToXMLDoc() returned TRUE"); + psFree(newXML); + psFree(XML2); + psFree(metaData); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + //Writes a psXMLDoc to File// + // testXMLOutput00 + { + psMemId id = psMemGetId(); + psXMLDoc *newXML = NULL; + newXML = psXMLParseFile(testFile1); + ok(psXMLDocToFile(newXML, "psTest.xml"), "psXMLParseFile() returned TRUE"); + psFree(newXML); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + //Writes a psXMLDoc to Memory// + // testXMLOutput01 + { + psMemId id = psMemGetId(); + psXMLDoc *newXML = NULL; + newXML = psXMLParseFile(testFile1); + char buffer[2048]; + FILE *file; + file = fopen("psTest3.xml", "w"); + ok(psXMLDocToMem(newXML, buffer), "fopen() successful"); + fprintf(file, "%s", buffer); + fclose(file); + psFree(newXML); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + //Writes a psXMLDoc to a file descriptor// + // testXMLOutput02 + { + psMemId id = psMemGetId(); + psXMLDoc *newXML = NULL; + newXML = psXMLParseFile(testFile1); + int fd = creat("psTest4.xml", 0666); + ok(!psXMLDocToFD(newXML, fd), "psXMLDocToFD() returned TRUE"); + close(fd); + psFree(newXML); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + + + // testXMLWrongInput + { + psMemId id = psMemGetId(); + psXMLDoc *newXML = NULL; + newXML = psXMLParseFile(testFile2); + ok(newXML != NULL, "psXMLParseFile() returned non-NULL"); + psMetadata *metaData = NULL; + metaData = psXMLDocToMetadata(newXML); + ok(metaData != NULL, "psXMLDocToMetadata() returned non-NULL"); + psFree(newXML); + psFree(metaData); + psXMLDoc *newXML2 = NULL; + psMetadata *metaData2 = NULL; + newXML2 = psXMLParseFile(testFile3); + ok(newXML2 != NULL, "psXMLParseFile() returned non-NULL"); + metaData2 = psXMLDocToMetadata(newXML2); + ok(metaData2 != NULL, "psXMLDocToMetadata() returned non-NULL"); + psFree(newXML2); + psFree(metaData2); + psXMLDoc *newXML3 = NULL; + psMetadata *metaData3 = NULL; + newXML3 = psXMLParseFile(testFile4); + ok(newXML3 != NULL, "psXMLParseFile() returned non-NULL"); + metaData3 = psXMLDocToMetadata(newXML3); + ok(metaData3 != NULL, "psXMLDocToMetadata() returned non-NULL"); + psFree(newXML3); + psFree(metaData3); + ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks"); + } + /* HERE + */ +}