IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Mar 22, 2005, 9:29:48 AM (21 years ago)
Author:
desonia
Message:

added test for psFitsReadTableColumnNum.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/dataIO/tst_psFits.c

    r3341 r3474  
    66*  @author Robert DeSonia, MHPCC
    77*
    8 *  @version $Revision: 1.20 $ $Name: not supported by cvs2svn $
    9 *  @date $Date: 2005-02-28 23:34:10 $
     8*  @version $Revision: 1.21 $ $Name: not supported by cvs2svn $
     9*  @date $Date: 2005-03-22 19:29:48 $
    1010*
    1111*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    4747static psS32 tst_psFitsReadHeaderSet( void );
    4848static psS32 tst_psFitsReadTable( void );
     49static psS32 tst_psFitsReadTableColumnNum(void);
    4950
    5051testDescription tests[] = {
    … …  
    5859                              {tst_psFitsReadHeaderSet,805, "psFitsReadHeaderSet", 0, false},
    5960                              {tst_psFitsReadTable,809, "psFitsReadTable", 0, false},
     61                              {tst_psFitsReadTableColumnNum,836, "psFitsReadTableColumnNum", 0, false},
     62                              {tst_psFitsReadTableColumn,837, "psFitsReadTableColumn", 0, false},
    6063                              {testImageRead,567, "psFitsReadImage", 0, false},
    6164                              {testImageWrite,569, "psFitsWriteImage", 0, false},
    … …  
    163166        psMetadataAdd(header,PS_LIST_TAIL, "MYINT",
    164167                      PS_META_S32,
    165                       "psS32 Item", (psS32)row);
     168                      "psS32 Item",
     169                      (psS32)row);
    166170
    167171        psMetadataAdd(header,PS_LIST_TAIL, "MYFLT",
    168172                      PS_META_F32,
    169                       "psF32 Item", (float)(1.0f/(float)(1+row)));
     173                      "psF32 Item",
     174                      (float)(1.0f/(float)(1+row)));
    170175
    171176        psMetadataAdd(header,PS_LIST_TAIL, "MYDBL",
    172177                      PS_META_F64,
    173                       "psF64 Item", (double)(1.0/(double)(1+row)));
     178                      "psF64 Item",
     179                      (double)(1.0/(double)(1+row)));
    174180
    175181        psMetadataAdd(header,PS_LIST_TAIL, "MYBOOL",
    … …  
    883889        return 30;
    884890    }
     891
     892    return 0;
     893}
     894
     895static psS32 tst_psFitsReadTableColumnNum( void )
     896{
     897    if (! makeTable()) {
     898        return 1;
     899    }
     900
     901    psFits* fits = psFitsAlloc(tableFilename);
     902
     903    if (fits == NULL) {
     904        psError(PS_ERR_UNKNOWN, false,
     905                "psFitsAlloc returned NULL on existing file.");
     906        return 1;
     907    }
     908
     909    psFitsMoveExtNum(fits,1,false);
     910
     911    // read the column data via number
     912    psVector* colData;
     913    psElemType type[4] = {PS_TYPE_S32, PS_TYPE_F32, PS_TYPE_F32, PS_TYPE_BOOL};
     914    psElemType altType[4] = {PS_TYPE_S64, PS_TYPE_F64, PS_TYPE_F64, PS_TYPE_BOOL};
     915    psF64 expectedValues[4][10] = {
     916                                      {0,1,2,3,4,5,6,7,8,9},
     917                                      {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},
     918                                      {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},
     919                                      {1.0,0.0,1.0,0.0,1.0,0.0,1.0,0.0,1.0,0.0}
     920                                  };
     921
     922    for (int col = 0; col < 4; col++) {
     923        colData = psFitsReadTableColumnNum(fits,col);
     924        if (colData == NULL) {
     925            psError(PS_ERR_UNKNOWN, false,
     926                    "psFitsReadTableColumnNum returned NULL for col=%d",
     927                    col);
     928            return 2;
     929        }
     930        if (colData->type.type != type[col] &&
     931                colData->type.type != altType[col]) {
     932            char* typeRead;
     933            char* typeExpected;
     934            PS_TYPE_NAME(typeRead, colData->type.type);
     935            PS_TYPE_NAME(typeExpected, type[col]);
     936
     937            psError(PS_ERR_UNKNOWN, false,
     938                    "psFitsReadTableColumnNum returned different type, %s vs %s, for col=%d",
     939                    typeRead, typeExpected, col);
     940            return 3;
     941        }
     942        if (colData->n != tableNumRows) {
     943            psError(PS_ERR_UNKNOWN, false,
     944                    "psFitsReadTableColumnNum returned different number of rows, %d vs %d, for col=%d",
     945                    colData->n, tableNumRows, col);
     946            return 4;
     947        }
     948        for (int row = 0; row < tableNumRows; row++) {
     949            if (abs(p_psVectorGetElementF64(colData,row) - expectedValues[col][row]) > FLT_EPSILON) {
     950                psError(PS_ERR_UNKNOWN, false,
     951                        "psFitsReadTableColumnNum returned unexpected values (%g vs %g) for col=%d",
     952                        p_psVectorGetElementF64(colData,row), expectedValues[col][row], col);
     953                return 5;
     954            }
     955        }
     956        psFree(colData);
     957    }
     958
     959    psWarning(__func__,"Following should be an error.");
     960    psErrorClear();
     961    psVector* data = psFitsReadTableColumnNum(NULL,0);
     962    psErr* err = psErrorLast();
     963    if (data != NULL) {
     964        psError(PS_ERR_UNKNOWN, false,
     965                "psFitsReadTableColumnNum did not return NULL with NULL psFits");
     966        return 6;
     967    }
     968    if (err->code != PS_ERR_BAD_PARAMETER_NULL) {
     969        psError(PS_ERR_UNKNOWN, false,
     970                "psFitsReadTableColumnNum did not error with NULL psFits");
     971        return 7;
     972    }
     973    psFree(err);
     974
     975    psWarning(__func__,"Following should be an error.");
     976    psErrorClear();
     977    data = psFitsReadTableColumnNum(fits,-1);
     978    err = psErrorLast();
     979    if (data != NULL) {
     980        psError(PS_ERR_UNKNOWN, false,
     981                "psFitsReadTableColumnNum did not return NULL with col=-1");
     982        return 8;
     983    }
     984    if (err->code != PS_ERR_IO) {
     985        psError(PS_ERR_UNKNOWN, false,
     986                "psFitsReadTableColumnNum did not error with col=-1");
     987        return 9;
     988    }
     989    psFree(err);
     990
     991    psWarning(__func__,"Following should be an error.");
     992    psErrorClear();
     993    data = psFitsReadTableColumnNum(fits,10);
     994    err = psErrorLast();
     995    if (data != NULL) {
     996        psError(PS_ERR_UNKNOWN, false,
     997                "psFitsReadTableColumnNum did not return NULL with col=10");
     998        return 10;
     999    }
     1000    if (err->code != PS_ERR_IO) {
     1001        psError(PS_ERR_UNKNOWN, false,
     1002                "psFitsReadTableColumnNum did not error with col=10");
     1003        return 11;
     1004    }
     1005    psFree(err);
     1006
     1007    psFree(fits);
     1008
     1009    return 0;
     1010}
     1011
     1012static psS32 tst_psFitsReadTableColumn( void )
     1013{
     1014    if (! makeTable()) {
     1015        return 1;
     1016    }
     1017
     1018    psFits* fits = psFitsAlloc(tableFilename);
     1019
     1020    if (fits == NULL) {
     1021        psError(PS_ERR_UNKNOWN, false,
     1022                "psFitsAlloc returned NULL on existing file.");
     1023        return 1;
     1024    }
     1025
     1026    psFitsMoveExtNum(fits,1,false);
     1027
     1028    // read the column data via number
     1029    psVector* colData;
     1030    psElemType type[4] = {PS_TYPE_S32, PS_TYPE_F32, PS_TYPE_F32, PS_TYPE_BOOL};
     1031    psElemType altType[4] = {PS_TYPE_S64, PS_TYPE_F64, PS_TYPE_F64, PS_TYPE_BOOL};
     1032    psF64 expectedValues[4][10] = {
     1033                                      {0,1,2,3,4,5,6,7,8,9},
     1034                                      {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},
     1035                                      {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},
     1036                                      {1.0,0.0,1.0,0.0,1.0,0.0,1.0,0.0,1.0,0.0}
     1037                                  };
     1038
     1039    for (int col = 0; col < 4; col++) {
     1040        colData = psFitsReadTableColumnNum(fits,col);
     1041        if (colData == NULL) {
     1042            psError(PS_ERR_UNKNOWN, false,
     1043                    "psFitsReadTableColumnNum returned NULL for col=%d",
     1044                    col);
     1045            return 2;
     1046        }
     1047        if (colData->type.type != type[col] &&
     1048                colData->type.type != altType[col]) {
     1049            char* typeRead;
     1050            char* typeExpected;
     1051            PS_TYPE_NAME(typeRead, colData->type.type);
     1052            PS_TYPE_NAME(typeExpected, type[col]);
     1053
     1054            psError(PS_ERR_UNKNOWN, false,
     1055                    "psFitsReadTableColumnNum returned different type, %s vs %s, for col=%d",
     1056                    typeRead, typeExpected, col);
     1057            return 3;
     1058        }
     1059        if (colData->n != tableNumRows) {
     1060            psError(PS_ERR_UNKNOWN, false,
     1061                    "psFitsReadTableColumnNum returned different number of rows, %d vs %d, for col=%d",
     1062                    colData->n, tableNumRows, col);
     1063            return 4;
     1064        }
     1065        for (int row = 0; row < tableNumRows; row++) {
     1066            if (abs(p_psVectorGetElementF64(colData,row) - expectedValues[col][row]) > FLT_EPSILON) {
     1067                psError(PS_ERR_UNKNOWN, false,
     1068                        "psFitsReadTableColumnNum returned unexpected values (%g vs %g) for col=%d",
     1069                        p_psVectorGetElementF64(colData,row), expectedValues[col][row], col);
     1070                return 5;
     1071            }
     1072        }
     1073        psFree(colData);
     1074    }
     1075
     1076    psWarning(__func__,"Following should be an error.");
     1077    psErrorClear();
     1078    psVector* data = psFitsReadTableColumnNum(NULL,0);
     1079    psErr* err = psErrorLast();
     1080    if (data != NULL) {
     1081        psError(PS_ERR_UNKNOWN, false,
     1082                "psFitsReadTableColumnNum did not return NULL with NULL psFits");
     1083        return 6;
     1084    }
     1085    if (err->code != PS_ERR_BAD_PARAMETER_NULL) {
     1086        psError(PS_ERR_UNKNOWN, false,
     1087                "psFitsReadTableColumnNum did not error with NULL psFits");
     1088        return 7;
     1089    }
     1090    psFree(err);
     1091
     1092    psWarning(__func__,"Following should be an error.");
     1093    psErrorClear();
     1094    data = psFitsReadTableColumnNum(fits,-1);
     1095    err = psErrorLast();
     1096    if (data != NULL) {
     1097        psError(PS_ERR_UNKNOWN, false,
     1098                "psFitsReadTableColumnNum did not return NULL with col=-1");
     1099        return 8;
     1100    }
     1101    if (err->code != PS_ERR_IO) {
     1102        psError(PS_ERR_UNKNOWN, false,
     1103                "psFitsReadTableColumnNum did not error with col=-1");
     1104        return 9;
     1105    }
     1106    psFree(err);
     1107
     1108    psWarning(__func__,"Following should be an error.");
     1109    psErrorClear();
     1110    data = psFitsReadTableColumnNum(fits,10);
     1111    err = psErrorLast();
     1112    if (data != NULL) {
     1113        psError(PS_ERR_UNKNOWN, false,
     1114                "psFitsReadTableColumnNum did not return NULL with col=10");
     1115        return 10;
     1116    }
     1117    if (err->code != PS_ERR_IO) {
     1118        psError(PS_ERR_UNKNOWN, false,
     1119                "psFitsReadTableColumnNum did not error with col=10");
     1120        return 11;
     1121    }
     1122    psFree(err);
     1123
     1124    psFree(fits);
    8851125
    8861126    return 0;
    … …  
    11291369    return 0;
    11301370}
     1371
Note: See TracChangeset for help on using the changeset viewer.