IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Changeset 9805


Ignore:
Timestamp:
Oct 30, 2006, 7:06:19 PM (20 years ago)
Author:
drobbin
Message:

Added error check to psTimeCopy for proper time-type. only formatting in MetadataConfig. Updated all metadataConfig tests but still under construction. Added tests to Makefile and execute_tap

Location:
trunk/psLib
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/src/astro/psTime.c

    r9749 r9805  
    1010 *  @author Ross Harman, MHPCC
    1111 *
    12  *  @version $Revision: 1.99 $ $Name: not supported by cvs2svn $
    13  *  @date $Date: 2006-10-26 03:47:49 $
     12 *  @version $Revision: 1.100 $ $Name: not supported by cvs2svn $
     13 *  @date $Date: 2006-10-31 05:06:19 $
    1414 *
    1515 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    18651865    PS_ASSERT_PTR_NON_NULL(inTime, NULL);
    18661866    psTime *outTime = psTimeAlloc(inTime->type);
     1867    if (outTime == NULL) {
     1868        psError(PS_ERR_BAD_PARAMETER_TYPE, true,
     1869                "Invalid type specified in psTimeCopy.  %x", inTime->type);
     1870        return NULL;
     1871    }
    18671872    //    *outTime = *inTime;
    18681873    outTime->sec = inTime->sec;

  • trunk/psLib/src/types/psMetadataConfig.c

    r9799 r9805  
    1010*  @author Eric Van Alst, MHPCC
    1111*
    12 *  @version $Revision: 1.103 $ $Name: not supported by cvs2svn $
    13 *  @date $Date: 2006-10-31 03:40:01 $
     12*  @version $Revision: 1.104 $ $Name: not supported by cvs2svn $
     13*  @date $Date: 2006-10-31 05:06:19 $
    1414*
    1515*  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    2727#include "psMetadataConfig.h"
    2828#include "psAssert.h"
    29 //#include <sys/types.h>
    30 //#include <sys/stat.h>
    31 //#include <inttypes.h>
    32 //#include "psHash.h"
    33 //#include "psMetadata.h"
    34 //#include "psAbort.h"
    35 //#include "psType.h"
    36 
    37 //#include "psMemory.h"
    38 //#include "psError.h"
    39 //#include "psString.h"
    40 //#include "psList.h"
    41 //#include "psVector.h"
    4229
    4330

  • trunk/psLib/test/types/Makefile.am

    r9736 r9805  
    3131        tap_psLookupTable_all \
    3232        tap_psMetadataConfig_output \
    33         tap_psMetadataConfig_input
     33        tap_psMetadataConfig_input \
     34        tap_psMetadataConfig_format
    3435
    3536if BUILD_TESTS

  • trunk/psLib/test/types/execute_tap

    r9736 r9805  
    2020./tap_psMetadataConfig_output
    2121./tap_psMetadataConfig_input
     22./tap_psMetadataConfig_format

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

    r9750 r9805  
    2525int main(void)
    2626{
    27     plan_tests(10);
     27    plan_tests(22);
    2828
    2929    diag("Tests for psMetadataConfig Input Functions");
    … …  
    7373    //Return true for valid inputs
    7474    {
    75         skip_start(  !psMetadataConfigWrite(md, "mdcfg.wrt"), 2,
    76                      "Skipping 2 tests because psMetadataConfigWrite failed");
    77         out = psMetadataConfigRead(out, &nfail, "mdcfg.wrt", false);
    78         psMetadataItem *tempItem = psMetadataGet(out, PS_LIST_HEAD);
    79         ok( out != NULL && nfail == 0,
     75        out = psMetadataConfigRead(out, &nfail, "metaconf.in", false);
     76        //        psMetadataPrint(NULL, out, 2);
     77        psMetadataItem *tempItem = psMetadataGet(out, PS_LIST_HEAD);
     78        ok( out != NULL,
    8079            "psMetadataConfigRead:           return correct metadata for valid inputs.");
     80        if (nfail != 0)
     81            printf("\n nfail = %d   list->n = %ld\n", nfail, md->list->n);
    8182        skip_start(  tempItem == NULL, 1,
    8283                     "Skipping 1 tests because metadata container is empty!");
    83         ok_str( tempItem->name, "new_S32",
     84        ok_str( tempItem->name, "item1",
    8485                "psMetadataConfigRead:           return correct metadataItem from "
    8586                "returned metadata.");
    8687        skip_end();
    87         skip_end();
    8888    }
    8989
    … …  
    9191    {
    9292        psFree(out);
    93         remove
    94             ("mdcfg.wrt");
    9593        psFree(md);
    9694        checkMem();
    … …  
    103101    psMetadata *out = NULL;
    104102    unsigned int nfail = 0;
    105     char str1[30];
     103    char str1[70];
     104    char str2[70];
     105    char str3[70];
     106    char str4[70];
     107    char str5[70];
     108    char str6[70];
     109    char str7[70];
     110    char str8[70];
    106111    strcpy(str1, "-10.05    2        4");
    107     char str2[30];
    108     strcpy(str2, "\nnew S32       666\n");
     112    strcpy(str2, "new S32       666");
     113    strcpy(str3, "item4            F64       6.28");
     114    strcpy(str4, "item8            S8        3\nitem8            S8        5");
     115    strcpy(str5, "item1            BOOL      T");
     116    strcpy(str6, "item6            S16");
     117    strcpy(str7, "@vector6 U8 1 2 3 4 5   # I am a vector");
     118    strcpy(str8, "time01           TAI       1970-01-01T00:16:39Z  # I am time");
    109119
    110120    //Return NULL for NULL string input
    … …  
    114124            "psMetadataConfigParse:          return NULL for NULL string input.");
    115125    }
    116     //Return correct metadata for correct string input
    117     {
    118         psFree(out);
    119         out = NULL;
    120         out = psMetadataConfigParse(out, NULL, str2, false);
    121         psMetadataItem *tempItem = psMetadataGet(out, PS_LIST_HEAD);
    122         ok( out != NULL && tempItem != NULL,
    123             "psMetadataConfigParse:          return correct metadata for valid "
    124             "string input.");
    125     }
    126126    //Return empty metadata for incorrect string input
    127127    {
    … …  
    131131        psMetadataItem *tempItem = psMetadataGet(out, PS_LIST_HEAD);
    132132        ok( out != NULL && tempItem == NULL,
    133             "psMetadataConfigParse:          return correct metadata for valid "
     133            "psMetadataConfigParse:          return empty metadata for invalid "
    134134            "string input.");
    135135        if (tempItem != NULL)
    136136            printf("\n\n name=%s\n", tempItem->name);
    137137    }
    138 
    139 
    140     /*    FILE *openfile;
    141     openfile = fopen("mdcfg.prt", "w+");
    142     FILE *nofile = NULL;
    143     psMetadata *md = NULL;
    144     md = psMetadataAlloc();
    145 
    146     //psMetadataConfigParse(psMetadata* md,unsigned int *nFail,const char *str,bool overwrite)
    147 
    148     //Return false for NULL metadata input
    149     {
    150         ok( !psMetadataConfigPrint(openfile, NULL),
    151              "psMetadataConfigPrint:           return false for NULL metadata input.");
    152     }
    153     //Return false for empty metadata input
    154     {
    155         ok( !psMetadataConfigPrint(openfile, md),
    156              "psMetadataConfigPrint:           return false for empty metadata input.");
    157     }
    158     //Return false for NULL file input
    159     psMetadataAddS32(md, PS_LIST_HEAD, "new S32", 0, "", 666);
    160     {
    161         ok( !psMetadataConfigPrint(nofile, md),
    162              "psMetadataConfigPrint:           return false for NULL FILE* input.");
    163     }
    164     //Return false for read-only file input
    165     nofile = fopen("mdcfg.prt", "r");
    166     {
    167         ok( !psMetadataConfigPrint(nofile, md),
    168              "psMetadataConfigPrint:           return false for read-only FILE* input.");
    169     }
    170     //Return true for valid inputs
    171     {
    172         ok( psMetadataConfigPrint(openfile, md),
    173             "psMetadataConfigPrint:           return true for valid inputs.");
    174     }
    175 
    176     */
     138    //Return correct metadata for correct string input - S32
     139    {
     140        psFree(out);
     141        out = NULL;
     142        out = psMetadataConfigParse(out, NULL, str2, false);
     143        psMetadataItem *tempItem = psMetadataGet(out, PS_LIST_HEAD);
     144        ok( out != NULL && tempItem != NULL,
     145            "psMetadataConfigParse:          return correct metadata for valid "
     146            "string input. (S32)");
     147        skip_start(  tempItem == NULL, 2,
     148                     "Skipping 1 tests because metadata container is empty!");
     149        ok( tempItem->type == PS_TYPE_S32 && tempItem->data.S32 == 666,
     150            "psMetadataConfigParse:         return correct metadataItem data (S32)");
     151        ok_str( tempItem->name, "new",
     152                "psMetadataConfigParse:         return correct metadataItem name (S32)");
     153        skip_end();
     154    }
     155    //Return correct metadata for correct string input - F64
     156    {
     157        psFree(out);
     158        out = NULL;
     159        out = psMetadataConfigParse(out, NULL, str3, false);
     160        psMetadataItem *tempItem = psMetadataGet(out, PS_LIST_HEAD);
     161        ok( out != NULL && tempItem != NULL,
     162            "psMetadataConfigParse:         return correct metadata for valid "
     163            "string input. (F64)");
     164        skip_start(  tempItem == NULL, 2,
     165                     "Skipping 1 tests because metadata container is empty!");
     166        ok( tempItem->type == PS_DATA_F64,
     167            "psMetadataConfigParse:         return correct metadataItem data (F64) "
     168            "from outputted metadata.");
     169        ok_float(6.28, tempItem->data.F64,
     170                 "psMetadataConfigParse:         return correct metadataItem data (F64) "
     171                 "value.");
     172        ok_str( tempItem->name, "item4",
     173                "psMetadataConfigParse:         return correct metadataItem name (F64)");
     174        skip_end();
     175    }
     176    //Return correct metadata for string with duplicate entry - S8
     177    {
     178        psFree(out);
     179        out = NULL;
     180        out = psMetadataConfigParse(out, &nfail, str4, false);
     181        psMetadataItem *tempItem = psMetadataGet(out, PS_LIST_HEAD);
     182        ok( out != NULL && tempItem != NULL && out->list->n == 1  && nfail == 1,
     183            "psMetadataConfigParse:         return correct metadata for string "
     184            "with duplicate entry. (S8)");
     185        skip_start(  tempItem == NULL, 2,
     186                     "Skipping 1 tests because metadata container is empty!");
     187        ok( tempItem->type == PS_TYPE_S8 && tempItem->data.S8 == 3,
     188            "psMetadataConfigParse:         return correct metadataItem data (S8)");
     189        ok_str( tempItem->name, "item8",
     190                "psMetadataConfigParse:         return correct metadataItem name (S8)");
     191        skip_end();
     192    }
     193    //Return correct metadata for correct string input - Vector
     194    {
     195        psFree(out);
     196        out = NULL;
     197        out = psMetadataConfigParse(out, NULL, str7, false);
     198        psMetadataItem *tempItem = psMetadataGet(out, PS_LIST_HEAD);
     199        ok( out != NULL && tempItem != NULL,
     200            "psMetadataConfigParse:         return correct metadata for valid "
     201            "string input. (Vector)");
     202        skip_start(  tempItem == NULL, 2,
     203                     "Skipping 1 tests because metadata container is empty!");
     204        ok( tempItem->type == PS_DATA_VECTOR
     205            && ((psVector*)(tempItem->data.V))->data.U8[0] == 1,
     206            "psMetadataConfigParse:         return correct metadataItem data (Vector) ");
     207        ok_str( tempItem->name, "vector6",
     208                "psMetadataConfigParse:         return correct metadataItem name (Vector)");
     209        skip_end();
     210    }
     211
     212
    177213    //Check for Memory leaks
    178214    {

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

    r9750 r9805  
    1818static void testMetaConfigWrite(void);
    1919static void testMetaConfigPrint(void);
    20 
     20static psMetadata *setupMeta(void);
    2121
    2222int main(void)
    … …  
    3232}
    3333
     34static psMetadata *setupMeta(void)
     35{
     36    psMetadata *md = NULL;
     37    psVector *vec1 = NULL;
     38    psVector *vec2 = NULL;
     39    psVector *vec3 = NULL;
     40    psVector *vec4 = NULL;
     41    psVector *vec5 = NULL;
     42    psVector *vec6 = NULL;
     43    psVector *vec7 = NULL;
     44    psVector *vec8 = NULL;
     45    psVector *vec9 = NULL;
     46    psVector *vec10 = NULL;
     47    psMetadata *newMD = NULL;
     48    psTime *time1;
     49    psTime *time2;
     50    psTime *time3;
     51    psTime *time4;
     52    int i = 0;
     53    md = psMetadataAlloc();
     54    newMD = psMetadataAlloc();
     55    vec1 = psVectorAlloc(60, PS_DATA_S8);
     56    vec2 = psVectorAlloc(60, PS_DATA_S16);
     57    vec3 = psVectorAlloc(60, PS_DATA_S32);
     58    vec4 = psVectorAlloc(60, PS_DATA_S64);
     59    vec5 = psVectorAlloc(60, PS_DATA_U8);
     60    vec6 = psVectorAlloc(60, PS_DATA_U16);
     61    vec7 = psVectorAlloc(60, PS_DATA_U32);
     62    vec8 = psVectorAlloc(60, PS_DATA_U64);
     63    vec9 = psVectorAlloc(60, PS_DATA_F32);
     64    vec10 = psVectorAlloc(60, PS_DATA_F64);
     65    time1 = psTimeAlloc(PS_TIME_TAI);
     66    time2 = psTimeAlloc(PS_TIME_TT);
     67    time3 = psTimeAlloc(PS_TIME_UTC);
     68    time4 = psTimeAlloc(PS_TIME_UT1);
     69    for (i = 0; i < 5; i++) {
     70        vec1->data.S8[i] = i+1;
     71        vec2->data.S16[i] = i+1;
     72        vec3->data.S32[i] = i+1;
     73        vec4->data.S64[i] = i+1;
     74        vec5->data.U8[i] = i+1;
     75        vec6->data.U16[i] = i+1;
     76        vec7->data.U32[i] = i+1;
     77        vec8->data.U64[i] = i+1;
     78        vec9->data.F32[i] = i+1.0;
     79        vec10->data.F64[i] = i+1.0;
     80    }
     81    vec1->n = 5;
     82    vec2->n = 5;
     83    vec3->n = 5;
     84    vec4->n = 5;
     85    vec5->n = 5;
     86    vec6->n = 5;
     87    vec7->n = 5;
     88    vec8->n = 5;
     89    vec9->n = 5;
     90    vec10->n = 5;
     91    time1->sec = 1000;
     92    time1->nsec = 25;
     93    time1->leapsecond = true;
     94    psMetadataAddBool(md, PS_LIST_TAIL, "item1-1", 0, "I am a boolean", true);
     95    psMetadataAddBool(md, PS_LIST_TAIL, "item1-2", 0, "I am a boolean2", false);
     96    psMetadataAddS8(md, PS_LIST_TAIL, "item2-8", 0, "", 8);
     97    psMetadataAddS16(md, PS_LIST_TAIL, "item2-16", 0, "", 16);
     98    psMetadataAddS32(md, PS_LIST_TAIL, "item2-32", 0, "", 32);
     99    psMetadataAddS64(md, PS_LIST_TAIL, "item2-64", 0, "", 64);
     100    psMetadataAddU8(md, PS_LIST_TAIL, "item3-8", 0, "", 8);
     101    psMetadataAddU16(md, PS_LIST_TAIL, "item3-16", 0, "", 16);
     102    psMetadataAddU32(md, PS_LIST_TAIL, "item3-32", 0, "", 32);
     103    psMetadataAddU64(md, PS_LIST_TAIL, "item3-64", 0, "", 64);
     104    psMetadataAddF32(md, PS_LIST_TAIL, "item4", 0, NULL, 3.14);
     105    psMetadataAddF64(md, PS_LIST_TAIL, "item5", 0, "", 6.28);
     106    psMetadataAddStr(md, PS_LIST_TAIL, "item6", 0, "I am a string", "GNIRTS");
     107    psMetadataAddStr(md, PS_LIST_TAIL, "item6-2", 0, "", "");
     108    psMetadataAddVector(md, PS_LIST_TAIL, "vectorS8", 0, "I am a vector", vec1);
     109    psMetadataAddVector(md, PS_LIST_TAIL, "vectorS16", 0, "", vec2);
     110    psMetadataAddVector(md, PS_LIST_TAIL, "vectorS32", 0, "", vec3);
     111    psMetadataAddVector(md, PS_LIST_TAIL, "vectorS64", 0, "", vec4);
     112    psMetadataAddVector(md, PS_LIST_TAIL, "vectorU8", 0, "", vec5);
     113    psMetadataAddVector(md, PS_LIST_TAIL, "vectorU16", 0, "I am a vector", vec6);
     114    psMetadataAddVector(md, PS_LIST_TAIL, "vectorU32", 0, "", vec7);
     115    psMetadataAddVector(md, PS_LIST_TAIL, "vectorU64", 0, "", vec8);
     116    psMetadataAddVector(md, PS_LIST_TAIL, "vectorF32", 0, "", vec9);
     117    psMetadataAddVector(md, PS_LIST_TAIL, "vectorF64", 0, "", vec10);
     118    psMetadataAddTime(md, PS_LIST_TAIL, "time01", 0, "I am time1", time1);
     119    psMetadataAddTime(md, PS_LIST_TAIL, "time02", 0, "I am time2", time2);
     120    psMetadataAddTime(md, PS_LIST_TAIL, "time03", 0, "I am time3", time3);
     121    psMetadataAddTime(md, PS_LIST_TAIL, "time04", 0, "I am time4", time4);
     122
     123    psMetadataAddS32(newMD, PS_LIST_TAIL, "ITEM01", 0, NULL, 666);
     124    psMetadata *newestMD = NULL;
     125    newestMD = psMetadataAlloc();
     126    psMetadataAddVector(newestMD, PS_LIST_TAIL, "VECTORNEW", 0, "Newest VECTOR", vec1);
     127    psMetadataAddStr(newestMD, PS_LIST_TAIL, "cell", 0, "I am a p-Star", "pStArRs");
     128    psMetadataAddMetadata(newMD, PS_LIST_TAIL, "META_NEW", 0, "", newestMD);
     129    psMetadataAddF32(newMD, PS_LIST_TAIL, "ITEM02", 0, "I AM FLOAT", 666.6);
     130    psMetadataAddF64(newMD, PS_LIST_TAIL, "ITEM03", 0, "I AM DOUBLE", 666.666);
     131
     132    psMetadataAddMetadata(md, PS_LIST_TAIL, "metadata7", 0, "I am a metadata", newMD);
     133    psFree(time1);
     134    psFree(time2);
     135    psFree(time3);
     136    psFree(time4);
     137    psFree(newestMD);
     138    psFree(vec1);
     139    psFree(vec2);
     140    psFree(vec3);
     141    psFree(vec4);
     142    psFree(vec5);
     143    psFree(vec6);
     144    psFree(vec7);
     145    psFree(vec8);
     146    psFree(vec9);
     147    psFree(vec10);
     148    psFree(newMD);
     149    return md;
     150}
     151
    34152void testMetaConfigWrite(void)
    35153{
    … …  
    59177            "psMetadataConfigWrite:           return false for empty metadata input.");
    60178    }
    61     psMetadataAddS32(md, PS_LIST_HEAD, "new S32", 0, "", 666);
     179    //    psMetadataAddS32(md, PS_LIST_HEAD, "new S32", 0, "", 666);
     180    psFree(md);
     181    md = setupMeta();
    62182    //Return true for valid inputs
    63183    {
    … …  
    68188    //Check for Memory leaks
    69189    {
    70         remove
    71             ("mdcfg.wrt");
     190        //        remove("mdcfg.wrt");
    72191        psFree(md);
    73192        checkMem();

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

    r9736 r9805  
    2323int main(void)
    2424{
    25     plan_tests(35);
     25    plan_tests(36);
    2626
    2727    diag("psMetadataCopy and psMetadataItemCopy tests");
    … …  
    330330    //Time case - invalid time item
    331331    {
     332        psTime *t = psTimeAlloc(PS_TIME_TT);
     333        t->type += 1;
     334        psMetadataItem *itemTime2 = psMetadataItemAlloc("itemTime", PS_DATA_TIME, "", t);
     335        copy = psMetadataItemCopy(itemTime2);
     336        ok( copy != NULL && copy->data.V == NULL,
     337            "psMetadataItemCopy:  return non-NULL item for invalid input time item");
     338        psFree(t);
     339        psFree(copy);
     340        psFree(itemTime2);
     341    }
     342    //Time case - NULL time item
     343    {
    332344        psFree(itemTime->data.V);
    333345        itemTime->data.V = NULL;
    334346        copy = psMetadataItemCopy(itemTime);
    335         ok( copy == NULL, "psMetadataItemCopy:  return NULL for invalid time item");
     347        ok( copy != NULL && copy->data.V == NULL,
     348            "psMetadataItemCopy:  return non-NULL item for NULL input time item");
    336349        //        (itemTime->data.V) = psTimeAlloc(PS_TIME_TAI);
     350        psFree(copy);
    337351    }
    338352    //Metadata case
Note: See TracChangeset for help on using the changeset viewer.