IPP Software Navigation Tools IPP Links Communication Pan-STARRS Links

Ignore:
Timestamp:
Jun 4, 2007, 10:25:32 AM (19 years ago)
Author:
gusciora
Message:

Improved test coverage.

Location:
trunk/psLib/test/astro
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/psLib/test/astro/tap_psTime_01.c

    r12607 r13614  
    2323 *  @author  Eric Van Alst, MHPCC
    2424 *
    25  *  @version $Revision: 1.5 $  $Name: not supported by cvs2svn $
    26  *  @date  $Date: 2007-03-27 22:52:02 $
     25 *  @version $Revision: 1.6 $  $Name: not supported by cvs2svn $
     26 *  @date  $Date: 2007-06-04 20:25:32 $
    2727 *
    2828 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    131131    psLogSetFormat("HLNM");
    132132    psLogSetLevel(PS_LOG_INFO);
    133     plan_tests(178);
     133    plan_tests(198);
    134134    // Initialize library internal structures
    135135    psLibInit("pslib.config");
    136136
    137137
    138     // Test psTimeAlloc()
     138    // Allocate new psTime with unallowed time type
     139    // Following should generate error message
     140    {
     141        psMemId id = psMemGetId();
     142        psTime *time = psTimeAlloc(-100);
     143        ok(time == NULL, "psTimeAlloc(-100) returned NULL");
     144        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     145    }
     146
     147
     148    // Test psTimeAlloc(TAI)
    139149    {
    140150        psMemId id = psMemGetId();
    … …  
    151161    }
    152162
    153     // Allocate new psTime with invalid time type
    154     // Following should generate error message
    155     {
    156         psMemId id = psMemGetId();
    157         psTime *time = psTimeAlloc(-100);
    158         ok(time == NULL, "psTimeAlloc(-100) returned NULL");
    159         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    160     }
     163
     164    // Test psTimeAlloc(UTC)
     165    {
     166        psMemId id = psMemGetId();
     167        psTime *time = psTimeAlloc(PS_TIME_UTC);
     168        ok(time != NULL, "psTimeAlloc() did not return NULL");
     169        skip_start(time == NULL, 4, "Skipping tests because psTimeAlloc() failed");
     170        ok(time->type == PS_TIME_UTC, "psTimeAlloc() correctly set psTime->type");
     171        ok(time->sec == 0, "psTimeAlloc() correctly set psTime->sec");
     172        ok(time->nsec == 0, "psTimeAlloc() correctly set psTime->nsec");
     173        ok(time->leapsecond == false, "psTimeAlloc() correctly set psTime->leapsecond");
     174        psFree(time);
     175        skip_end();
     176        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     177    }
     178
     179
     180    // Test psTimeAlloc(UT1)
     181    {
     182        psMemId id = psMemGetId();
     183        psTime *time = psTimeAlloc(PS_TIME_UT1);
     184        ok(time != NULL, "psTimeAlloc() did not return NULL");
     185        skip_start(time == NULL, 4, "Skipping tests because psTimeAlloc() failed");
     186        ok(time->type == PS_TIME_UT1, "psTimeAlloc() correctly set psTime->type");
     187        ok(time->sec == 0, "psTimeAlloc() correctly set psTime->sec");
     188        ok(time->nsec == 0, "psTimeAlloc() correctly set psTime->nsec");
     189        ok(time->leapsecond == false, "psTimeAlloc() correctly set psTime->leapsecond");
     190        psFree(time);
     191        skip_end();
     192        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     193    }
     194
     195
     196    // Test psTimeAlloc(TT)
     197    {
     198        psMemId id = psMemGetId();
     199        psTime *time = psTimeAlloc(PS_TIME_TT);
     200        ok(time != NULL, "psTimeAlloc() did not return NULL");
     201        skip_start(time == NULL, 4, "Skipping tests because psTimeAlloc() failed");
     202        ok(time->type == PS_TIME_TT, "psTimeAlloc() correctly set psTime->type");
     203        ok(time->sec == 0, "psTimeAlloc() correctly set psTime->sec");
     204        ok(time->nsec == 0, "psTimeAlloc() correctly set psTime->nsec");
     205        ok(time->leapsecond == false, "psTimeAlloc() correctly set psTime->leapsecond");
     206        psFree(time);
     207        skip_end();
     208        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     209    }
     210
    161211
    162212    // Test psTimeGetNow()
     213    // Attempt to get time with unallowed type
     214    // Following should generate an error message for unallowed time type
     215    {
     216        psMemId id = psMemGetId();
     217        psTime *timeNow = psTimeGetNow(-100);
     218        ok(timeNow == NULL, "psTimeGetNow(-100) returned NULL");
     219        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     220    }
     221
     222
     223    // Test psTimeGetNow(TAI)
    163224    {
    164225        psMemId id = psMemGetId();
    … …  
    167228        skip_start(time == NULL, 4, "Skipping tests because psTimeGetNow() failed");
    168229        ok(timeNow->type == PS_TIME_TAI, "psTimeGetNow() correctly set psTime->type");
     230        ok(timeNow->sec != 0, "psTimeAlloc() set psTime->sec to something");
     231        ok(timeNow->nsec != 0, "psTimeAlloc() set psTime->nsec to something");
    169232        psFree(timeNow);
    170233        skip_end();
    … …  
    172235    }
    173236
    174     // Attempt to get time with invalid type
    175     // Following should generate an error message for invalid time type
    176     {
    177         psMemId id = psMemGetId();
    178         psTime *timeNow = psTimeGetNow(-100);
    179         ok(timeNow == NULL, "psTimeGetNow(-100) returned NULL");
    180         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    181     }
    182237
    183238    // Test psTimeGetUT1Delta()
    … …  
    191246    }
    192247
    193     // Attempt to convert invalid time
     248    // Attempt to convert unallowed time
    194249    // Following should generate an error message for incorrect time
    195250    {
    … …  
    205260    }
    206261
    207     // Attempt to convert time with invalid bulletin
     262    // Attempt to convert time with unallowed bulletin
    208263    // Following should generate an error message for incorrect bulletin
    209264    {
    … …  
    360415        time->nsec = testTime1NanosecondsUTC;
    361416        psF64 mjd = psTimeToMJD(time);
    362 
    363417        is_double_tol(mjd, 53207.765929, ERROR_TOL, "psTimeToMJD() returned correct time after 1/1/1970 epoch");
    364 
    365         psFree(time);
    366         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    367     }
     418        psFree(time);
     419        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     420    }
     421
    368422
    369423    // psTimeToMJD()
    … …  
    375429        time->nsec = testTime4NanosecondsUTC;
    376430        psF64 mjd = psTimeToMJD(time);
    377 
    378431        is_double_tol(mjd, testTime4MJD, ERROR_TOL, "psTimeToMJD() returned correct time before 1/1/1970 epoch");
    379 
    380432        psFree(time);
    381433        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    390442        psMemId id = psMemGetId();
    391443        psF64 jd = psTimeToJD(NULL);
    392 
    393444        is_double(jd, NAN, "psTimeToJD(NULL) returned NULL");
    394445        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    395446    }
     447
    396448
    397449    // psTimeToJD()
    … …  
    406458        time->leapsecond = false;
    407459        psF64 jd = psTimeToJD(time);
    408        
    409460        is_double(jd, NAN, "psTimeToJD() returned NAN for incorrect time");
    410 
    411461        psFree(time);
    412462        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    422472        time->nsec = testTime1NanosecondsUTC;
    423473        psF64 jd = psTimeToJD(time);
    424 
    425474        is_double_tol(jd, 2453208.265929, ERROR_TOL, "psTimeToJD() returned the correct time after 1/1/1970 epoch");
    426 
    427475        psFree(time);
    428476        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    438486        time->nsec = testTime4NanosecondsUTC;
    439487        psF64 jd = psTimeToJD(time);
    440 
    441488        is_double_tol(jd, testTime4JD, ERROR_TOL, "psTimeToJD() returned the correct time before 1/1/1970 epoch");
    442 
    443489        psFree(time);
    444490        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    453499        psMemId id = psMemGetId();
    454500        char *timeStr = psTimeToISO(NULL);
    455 
    456501        ok(timeStr == NULL, "psTimeToISO(NULL) returned NULL");
    457 
    458502        psFree(timeStr);
    459503        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    460504    }
     505
    461506
    462507    // Test psTimeToISO()
    … …  
    471516        time->nsec = 2e9;
    472517        char *timeStr = psTimeToISO(time);
    473 
    474518        ok(timeStr == NULL, "psTimeToISO(time) returned NULL for incorrect time");
    475 
    476519        psFree(time);
    477520        psFree(timeStr);
    … …  
    490533        time->nsec = testTime5NanosecondsUTC;
    491534        char *timeStr = psTimeToISO(time);
    492 
    493535        ok(timeStr == NULL, "psTimeToISO(time) returned NULL for time prior to year 0000");
    494 
    495536        psFree(time);
    496537        psFree(timeStr);
    … …  
    527568        time->nsec = testTime1NanosecondsUTC;
    528569        char *timeStr = psTimeToISO(time);
    529 
    530570        is_str(timeStr, testTime1Str, "psTimeToISO(time) returned correct time (no leapsecond)");
    531 
    532571        psFree(timeStr);
    533572        psFree(time);
    … …  
    546585        time->leapsecond = true;
    547586        char *timeStr = psTimeToISO(time);
    548 
    549587        is_str(timeStr, testTime1StrLeap, "psTimeToISO(time) returned correct time (with leapsecond)");
    550 
    551588        psFree(timeStr);
    552589        psFree(time);
    … …  
    580617        time->nsec = 2e9;
    581618        struct timeval *timevalTime = psTimeToTimeval(time);
    582 
    583619        ok(timevalTime == NULL, "psTimeToTimeval() returned NULL for incorrect time");
    584 
    585620        psFree(time);
    586621        psFree(timevalTime);
    … …  
    599634        time->nsec = 0;
    600635        struct timeval *timevalTime = psTimeToTimeval(time);
    601 
    602636        ok(timevalTime == NULL, "psTimeToTimeval() returned NULL for incorrect time");
    603 
    604637        psFree(time);
    605638        psFree(timevalTime);
    … …  
    617650        time->nsec = testTime1NanosecondsUTC;
    618651        struct timeval *timevalTime = psTimeToTimeval(time);
    619 
    620652        is_long(timevalTime->tv_sec, testTime1TimevalSec, "psTimeToTimeval()->tv_sec");
    621653        is_long(timevalTime->tv_usec, testTime1TimevalUsec, "psTimeToTimeval()->tv_usec");
    622 
    623654        psFree(time);
    624655        psFree(timevalTime);
    … …  
    632663        psMemId id = psMemGetId();
    633664        psTime *time = psTimeFromMJD(testTime1MJDTAI);
    634 
    635665        ok(time->type == PS_TIME_TAI, "psTimeFromMJD() returned the correct type");
    636666        is_long(time->sec, testTime1SecondsTAI, "psTimeFromMJD()->sec");
    637 
    638667        psFree(time);
    639668        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    646675        psMemId id = psMemGetId();
    647676        psTime *time = psTimeFromMJD(testTime4MJD);
    648 
    649677        ok(time->type == PS_TIME_TAI, "psTimeFromMJD() returned the correct type");
    650678        is_long(time->sec, testTime4SecondsUTC, "psTimeFromMJD()->sec");
    651 
    652679        psFree(time);
    653680        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    660687        psMemId id = psMemGetId();
    661688        psTime *time = psTimeFromJD(testTime1JDTAI);
    662 
    663689        ok(time->type == PS_TIME_TAI, "psTimeFromJD() returned the correct type");
    664690        is_long(time->sec, testTime1SecondsTAI, "psTimeFromJD()->sec");
    665 
    666691        psFree(time);
    667692        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    843868
    844869    // psTimeConvert()
    845     // Attempt to convert to incorrect type
    846     // Following should generate an error message for incorrect type
     870    // Following should generate an error message for incorrect type output
     871    // Input psTime struct is PS_TIME_TAI
    847872    // XXX: We don't test whether the error message is generated
    848873    {
    … …  
    850875        psTime *time1 = psTimeAlloc(PS_TIME_TAI);
    851876        psTime *time2 = psTimeConvert(time1,-100);
    852 
    853877        ok(time2 == NULL, "psTimeConvert(time1, -100) returned NULL");
    854 
    855         psFree(time1);
     878        psFree(time1);
     879        psFree(time2);
     880        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     881    }
     882
     883
     884    // psTimeConvert()
     885    // Following should generate an error message for incorrect type output
     886    // Input psTime struct is PS_TIME_UTC
     887    // XXX: We don't test whether the error message is generated
     888    {
     889        psMemId id = psMemGetId();
     890        psTime *time1 = psTimeAlloc(PS_TIME_UTC);
     891        psTime *time2 = psTimeConvert(time1,-100);
     892        ok(time2 == NULL, "psTimeConvert(time1, -100) returned NULL");
     893        psFree(time1);
     894        psFree(time2);
    856895        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    857896    }
    … …  
    860899    // psTimeConvert()
    861900    // Following should generate an error message for incorrect type
    862     // XXX: We don't test whether the error message is generated
    863     {
    864         psMemId id = psMemGetId();
    865         psTime *time1 = psTimeAlloc(PS_TIME_TAI);
    866         time1->type = PS_TIME_UTC;
     901    // Input psTime struct is PS_TIME_TT
     902    // XXX: We don't test whether the error message is generated
     903    {
     904        psMemId id = psMemGetId();
     905        psTime *time1 = psTimeAlloc(PS_TIME_TT);
    867906        psTime *time2 = psTimeConvert(time1,-100);
    868 
    869907        ok(time2 == NULL, "psTimeConvert(time1, -100) returned NULL");
    870 
    871         psFree(time1);
    872         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    873     }
    874 
    875 
    876     // psTimeConvert()
    877     // Following should generate an error message for incorrect type
    878     // XXX: We don't test whether the error message is generated
    879     {
    880         psMemId id = psMemGetId();
    881         psTime *time1 = psTimeAlloc(PS_TIME_TAI);
    882         time1->type = PS_TIME_TT;
    883         psTime *time2 = psTimeConvert(time1,-100);
    884 
    885         ok(time2 == NULL, "psTimeConvert(time1, -100) returned NULL");
    886 
    887         psFree(time1);
    888         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    889     }
    890 
    891 
    892     // psTimeConvert()
    893     // Following should generate an error message for incorrect type
     908        psFree(time1);
     909        psFree(time2);
     910        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     911    }
     912
     913
     914    // psTimeConvert()
     915    // Following should generate an error message for incorrect type input
    894916    // XXX: We don't test whether the error message is generated
    895917    {
    … …  
    898920        time1->type = -100;
    899921        psTime *time2 = psTimeConvert(time1,PS_TIME_TAI);
    900 
    901922        ok(time2 == NULL, "psTimeConvert(time1, PS_TIME_TAI) returned NULL");
    902 
    903         psFree(time1);
     923        psFree(time1);
     924        psFree(time2);
    904925        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    905926    }
    … …  
    915936        time1->nsec = 2e9;
    916937        psTime *time2 = psTimeConvert(time1, PS_TIME_TAI);
    917 
    918938        ok(time2 == NULL, "psTimeConvert(time1, PS_TIME_TAI) returns NULL for incorrect psTime object");
    919 
    920         psFree(time1);
     939        psFree(time1);
     940        psFree(time2);
    921941        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    922942    }
    … …  
    932952        time1->type = PS_TIME_TAI;
    933953        time1->leapsecond = false;
    934 
    935954        psTime *time2 = psTimeConvert(time1, PS_TIME_TAI);
    936955        ok(time2 == time1, "psTimeConvert(time, ...) returns time for conversion to same type");

  • trunk/psLib/test/astro/tap_psTime_02.c

    r12607 r13614  
    1212 *  @author  Eric Van Alst, MHPCC
    1313 *
    14  *  @version $Revision: 1.4 $  $Name: not supported by cvs2svn $
    15  *  @date  $Date: 2007-03-27 22:52:02 $
     14 *  @version $Revision: 1.5 $  $Name: not supported by cvs2svn $
     15 *  @date  $Date: 2007-06-04 20:25:32 $
    1616 *
    1717 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    6464    {
    6565        psMemId id = psMemGetId();
    66 
    6766        psF64 lmst = psTimeToLMST(NULL, 0);
    68         is_double(lmst, NAN, "psTimeToLMST(time,0) returned NAN");
    69 
     67        is_double(lmst, NAN, "psTimeToLMST(NULL, 0) returned NAN");
    7068        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    7169    }
    … …  
    8078        time->nsec = testTime1NanosecondsUTC;
    8179        time->leapsecond = false;
    82 
    8380        psF64 lmst = psTimeToLMST(time, 0.0);
    8481        is_double_tol(lmst, testTime1LMST0, ERROR_TOL, "psTimeToLMST() returned the correct time");
    85 
    8682        psFree(time);
    8783        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    9086
    9187    // psTimeToLMST()
    92     // Attempt to get LMST with invalid input time UT1
     88    // Attempt to get LMST with unallowed input time UT1
    9389    // Following should generate error message for incorrect type
    9490    // XXX: We do not test the error generation
    … …  
    10096        time->leapsecond = false;
    10197        time->type = PS_TIME_UT1;
    102 
    10398        psF64 lmst = psTimeToLMST(time,0.0);
    10499        is_double(lmst, NAN, "psTimeToLMST() generated a NAN for incorrect type");
    105 
    106100        psFree(time);
    107101        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    115109    {
    116110        psMemId id = psMemGetId();
    117 
    118111        psS64 delta = psTimeLeapSecondDelta(NULL, NULL);
    119112        is_long(delta, 0, "psTimeLeapSecondDelta(NULL, NULL) returned 0");
    120 
    121         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    122     }
    123 
    124 
     113        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     114    }
     115
     116
     117    // psTimeLeapSecondDelta()
    125118    // Set test time 1
    126119    // Attempt to get delta with NULL time2 argument
    … …  
    133126        time1->nsec = testTime1NanosecondsUTC;
    134127        time1->leapsecond = false;
    135 
    136128        psS64 delta = psTimeLeapSecondDelta(time1, NULL);
    137129        is_long(delta, 0, "psTimeLeapSecondDelta(time1, NULL) returned 0");
    138 
    139         psFree(time1);
    140         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    141     }
    142 
    143 
    144     // Set test time 2 with invalid time
    145     // Attempt to get delta with invalid time2
    146     // Following should generate an error message for invalid time
     130        psFree(time1);
     131        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     132    }
     133
     134
     135    // psTimeLeapSecondDelta()
     136    // Set test time 2 with unallowed time
     137    // Attempt to get delta with unallowed time2
     138    // Following should generate an error message for unallowed time
    147139    // XXX: We do not test the error generation
    148140    {
    … …  
    156148        time2->nsec = 2e9;
    157149        time2->leapsecond = false;
    158 
    159150        psS64 delta = psTimeLeapSecondDelta(time1, time2);
    160151        is_long(delta, 0, "psTimeLeapSecondDelta(time1, time2) returned 0 with incorrect time2");
    161 
    162152        psFree(time1);
    163153        psFree(time2);
    … …  
    166156
    167157
     158    // psTimeLeapSecondDelta()
    168159    // Set test time 2 valid
    169     // Attempt to get delta with invalid time1
    170     // Following should generate an error message for invalid time
     160    // Attempt to get delta with unallowed time1
     161    // Following should generate an error message for unallowed time
    171162    // XXX: We do not test the error generation
    172163    {
    … …  
    181172        time1->sec = 0;
    182173        time1->nsec = 2e9;
    183 
    184174        psS64 delta = psTimeLeapSecondDelta(time1,time2);
    185175        is_long(delta, 0, "psTimeLeapSecondDelta(time1, time2) returned 0 with incorrect time1");
    186 
    187176        psFree(time1);
    188177        psFree(time2);
    … …  
    191180
    192181
     182    // psTimeLeapSecondDelta()
    193183    // Set test time 1 to greater time
    194184    {
    … …  
    202192        time2->sec = testTime2SecondsUTC;
    203193        time2->nsec = testTime2NanosecondsUTC;
    204 
    205194        psS64 delta = psTimeLeapSecondDelta(time1,time2);
    206195        is_long(delta, testTimeLeapSecondDelta1, "psTimeLeapSecondDelta() produced the correct result");
    207 
    208196        psFree(time1);
    209197        psFree(time2);
    … …  
    212200
    213201
     202    // psTimeLeapSecondDelta()
    214203    // Set test time 1 to lesser time
    215204    {
    … …  
    222211        time2->sec = testTime2SecondsUTC;
    223212        time2->nsec = testTime2NanosecondsUTC;
    224 
    225213        psS64 delta = psTimeLeapSecondDelta(time2, time1);
    226214        is_long(delta, testTimeLeapSecondDelta1, "psTimeLeapSecondDelta() produced the correct result");
    227 
    228215        psFree(time1);
    229216        psFree(time2);
    … …  
    232219
    233220
     221    // psTimeLeapSecondDelta()
    234222    // Attempt to get delta with times equal
    235223    {
    … …  
    239227        time1->nsec = testTime1NanosecondsUTC;
    240228        time1->leapsecond = false;
    241 
    242229        psS64 delta = psTimeLeapSecondDelta(time1,time1);
    243230        is_long(delta, 0, "psTimeLeapSecondDelta() produced the correct result");
    244 
    245231        psFree(time1);
    246232        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    254240    {
    255241        psMemId id = psMemGetId();
    256 
    257242        bool leapsecond = psTimeIsLeapSecond(NULL);
    258243        is_bool(leapsecond, false, "psTimeIsLeapSecond(NULL) returned correct value");
    259 
    260         ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    261     }
    262 
    263 
    264     // psTimeIsLeapSecond()
    265     // Set time
     244        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     245    }
     246
     247
     248    // psTimeIsLeapSecond()
    266249    // Attempt to determine if leap second with non-UTC time
    267     // Following should generate an error message for invalid type
     250    // Following should generate an error message for unallowed type
    268251    // XXX: We do not test the error generation
    269252    {
    … …  
    273256        time->nsec = testTime1NanosecondsUTC;
    274257        time->leapsecond = false;
    275 
    276258        bool leapsecond = psTimeIsLeapSecond(time);
    277259        is_bool(leapsecond, false, "psTimeIsLeapSecond() returned false with incorrect type");
    278 
    279260        psFree(time);
    280261        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    292273        time->leapsecond = false;
    293274        time->type = PS_TIME_UTC;
    294 
    295275        bool leapsecond = psTimeIsLeapSecond(time);
    296276        is_bool(leapsecond, false, "psTimeIsLeapSecond() returned false");
    297 
    298277        psFree(time);
    299278        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    309288        time->sec = testTime3SecondsUTC;
    310289        time->nsec = testTime3NanosecondsUTC;
    311 
    312290        bool leapsecond = psTimeIsLeapSecond(time);
    313291        is_bool(leapsecond, true, "psTimeIsLeapSecond() returned true");
    314 
    315292        psFree(time);
    316293        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    327304        time->nsec = testTime3NanosecondsUTC;
    328305        time->sec--;
    329 
    330306        bool leapsecond = psTimeIsLeapSecond(time);
    331307        is_bool(leapsecond, false, "psTimeIsLeapSecond() returned false");
    332 
    333308        psFree(time);
    334309        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    343318        time->sec = testTime3SecondsUTC;
    344319        time->nsec = testTime3NanosecondsUTC;
    345         time->sec ++;
    346 
     320        time->sec++;
    347321        bool leapsecond = psTimeIsLeapSecond(time);
    348322        is_bool(leapsecond, false, "psTimeIsLeapSecond() returned false");
    349 
    350323        psFree(time);
    351324        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    … …  
    354327
    355328    // psTimeFromTT()
    356     // Attempt to create psTime with invalid time
    357     // Following should generate an error message for invalid time
     329    // Attempt to create psTime with unallowed time
     330    // Following should generate an error message for unallowed time
    358331    // XXX: We do not test the error generation
    359332    {
    … …  
    389362
    390363    // psTimeFromUTC()
    391     // Attempt to create psTime with invalid time
    392     // Following should generate an error message for invalid time
     364    // Attempt to create psTime with unallowed time
     365    // Following should generate an error message for unallowed time
    393366    // XXX: We do not test the error generation
    394367    {

  • trunk/psLib/test/astro/tap_psTime_04.c

    r12415 r13614  
    1818 *  @author  David Robbins, MHPCC
    1919 *
    20  *  @version $Revision: 1.2 $  $Name: not supported by cvs2svn $
    21  *  @date  $Date: 2007-03-13 00:23:20 $
     20 *  @version $Revision: 1.3 $  $Name: not supported by cvs2svn $
     21 *  @date  $Date: 2007-06-04 20:25:32 $
    2222 *
    2323 *  Copyright 2004-2005 Maui High Performance Computing Center, University of Hawaii
    … …  
    3434    psLogSetFormat("HLNM");
    3535    psLogSetLevel(PS_LOG_INFO);
    36     plan_tests(16);
     36    plan_tests(19);
    3737
    3838
    … …  
    114114    }
    115115
     116
    116117    // testTideUT1Corr()
     118    // Verify NULL return with NULL input
     119    // XXX: Verify error
    117120    {
    118121        psMemId id = psMemGetId();
    119         psTime *tide = NULL;
     122        psTime *empty = psTime_TideUT1Corr(NULL);
     123        ok(empty == NULL, "psTime_TideUT1Corr() returned NULL for NULL input time");
     124        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     125        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     126    }
     127
     128
     129    // testTideUT1Corr()
     130    //
     131    {
     132        psMemId id = psMemGetId();
    120133        psTime *noTide = psTimeAlloc(PS_TIME_UTC);
    121134        noTide->sec = 1049160600;
    122135        noTide->nsec = 0;
    123136        noTide->leapsecond = false;
    124         // Following should generate error message
    125         // XXX: We do not test error generation here
    126         psTime *empty = empty = psTime_TideUT1Corr(tide);
    127         ok(empty == NULL, "psTime_TideUT1Corr() returned NULL for NULL input time");
    128 
    129         empty = psTime_TideUT1Corr(noTide);
     137        psTime *empty = psTime_TideUT1Corr(noTide);
    130138        is_long(empty->sec, 1049160599, "psTime_TideUT1Corr() returned correct ->sec");
    131139        is_long(empty->nsec, 656981971, "psTime_TideUT1Corr() returned correct ->nsec");
    132 
    133140        ok(p_psTimeFinalize(), "p_psTimeFinalize() successful");
    134 
    135141        psFree(empty);
    136142        psFree(noTide);
    137143        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
     144        ok(!psMemCheckLeaks (id, NULL, NULL, false), "no memory leaks");
    138145    }
    139146}
Note: See TracChangeset for help on using the changeset viewer.