! $Id$ ! ! Earth System Modeling Framework ! Copyright (c) 2002-2023, University Corporation for Atmospheric Research, ! Massachusetts Institute of Technology, Geophysical Fluid Dynamics ! Laboratory, University of Michigan, National Centers for Environmental ! Prediction, Los Alamos National Laboratory, Argonne National Laboratory, ! NASA Goddard Space Flight Center. ! Licensed under the University of Illinois-NCSA License. ! !============================================================================== ! program ESMF_ClockTest !------------------------------------------------------------------------------ ! #include "ESMF.h" !============================================================================== !BOP ! !PROGRAM: ESMF_ClockTest - Test Clock initialization and time-stepping ! ! !DESCRIPTION: ! ! The code in this file drives F90 Clock unit tests. ! The companion file ESMF\_Clock.F90 contains the definitions for the ! Clock methods. ! !EOP !----------------------------------------------------------------------------- ! !USES: use ESMF_TestMod ! test methods use ESMF implicit none !------------------------------------------------------------------------------ ! The following line turns the CVS identifier string into a printable variable. character(*), parameter :: version = & '$Id$' !------------------------------------------------------------------------------ ! cumulative result: count failures; no failures equals "all pass" integer :: result = 0 ! individual test result code integer :: rc ! individual test name character(ESMF_MAXSTR) :: name ! individual test failure message character(ESMF_MAXSTR) :: failMsg ! instantiate a clock type(ESMF_Clock) :: clock ! instantiate a calendar type(ESMF_Calendar) :: gregorianCalendar, julianDayCalendar, & no_leapCalendar, esmf_360dayCalendar, & noCalendar ! instantiate timestep, start times type(ESMF_TimeInterval) :: timeStep type(ESMF_Time) :: startTime logical :: isCreated #ifdef ESMF_TESTEXHAUSTIVE ! individual test result code integer :: totalDays, DD, MM, YY, H, M, days, hr, checkSec integer :: min, ms, testResults, julyr, julday, sec, secs type(ESMF_Direction_Flag) :: direction ! Random number real :: ranNum integer :: timevals(8) integer, allocatable :: seed(:) integer :: seed_size ! individual test failure message logical :: stepOnePass, stepTwoPass, runTheClock, bool, & clockStopped, testPass, clocksNotEqual, clocksEqual, & stopTimeEnabled ! to retrieve time in string format character(ESMF_MAXSTR) :: timeString ! instantiate a clock type(ESMF_Clock) :: topClock, clock_360day, clock_no_leap, & clock_gregorian, clock1, clock2, clock3, clock4 ! instantiate a calendar type(ESMF_CalKind_Flag) :: cal_kind ! instantiate timestep, start and stop times type(ESMF_Time) :: stopTime, stopTime2, stopTime3, stopTime4, syncTime, & previousTime, current_time, currentTime, startTime2 real(ESMF_KIND_R8) :: realSeconds integer :: timeStepCount integer :: datetime(8) integer(ESMF_KIND_I4) :: day integer(ESMF_KIND_I8) :: advanceCounts, nTimeSteps, & year_i8, YY_i8, second_i8 type(ESMF_TimeInterval) :: timeStep2, currentSimTime, previousSimTime, & timeDiff character(ESMF_MAXSTR) :: clockName #endif ! initialize ESMF framework call ESMF_TestStart(ESMF_SRCLINE, rc=rc) if (rc /= ESMF_SUCCESS) call ESMF_Finalize(endflag=ESMF_END_ABORT) ! set default calendar to Gregorian call ESMF_CalendarSetDefault(ESMF_CALKIND_GREGORIAN, rc=rc) ! initialize one calendar to be Gregorian type gregorianCalendar = ESMF_CalendarCreate(ESMF_CALKIND_GREGORIAN, & name="Gregorian", rc=rc) ! initialize secand calendar to be Julian type julianDayCalendar = ESMF_CalendarCreate(ESMF_CALKIND_JULIANDAY, & name="Julian", rc=rc) ! initialize third calendar to be No Leap type no_leapCalendar = ESMF_CalendarCreate(ESMF_CALKIND_NOLEAP, & name="NoLeap", rc=rc) ! initialize third calendar to be 360 day type esmf_360dayCalendar = ESMF_CalendarCreate(ESMF_CALKIND_360DAY, & name="360Day", rc=rc) ! initialize fourth calendar to be No calendar kind noCalendar = ESMF_CalendarCreate(ESMF_CALKIND_NOCALENDAR, & name="No Calendar", rc=rc) !------------------------------------------------------------------------------- ! The unit tests are divided into Sanity and Exhaustive. The Sanity tests are ! always run. When the environment variable, EXHAUSTIVE, is set to ON then ! the EXHAUSTIVE and sanity tests both run. If the EXHAUSTIVE variable is set ! to OFF, then only the sanity unit tests. ! Special strings (Non-exhaustive and exhaustive) have been ! added to allow a script to count the number and types of unit tests. !------------------------------------------------------------------------------- ! initialize clock time intervals and instants ! ---------------------------------------------------------------------------- !NEX_UTest ! Test Setting Time Step write(failMsg, *) " Did not return ESMF_SUCCESS" write(name, *) "Set Time Interval Initialization Test" call ESMF_TimeIntervalSet(timeStep, h=1, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !NEX_UTest ! Test Setting the Start Time write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Set Start Time Initialization Test" call ESMF_TimeSet(startTime, yy=2003, mm=3, dd=13, & h=18, m=45, s=27, & calkindflag=ESMF_CALKIND_GREGORIAN, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !NEX_UTest write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Clock Initialization Test" clock = ESMF_ClockCreate(timeStep, startTime, name="Clock 1", rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !NEX_UTest write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Clock Destroy Test" call ESMF_ClockDestroy(clock, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) !------------------------------------------------------------------------ !NEX_UTest write(name, *) "Testing Clock IsCreated for uncreated object" write(failMsg, *) "Did not return .false." isCreated = ESMF_ClockIsCreated(clock) call ESMF_Test((isCreated .eqv. .false.), name, failMsg, result, ESMF_SRCLINE) !------------------------------------------------------------------------ !------------------------------------------------------------------------ !NEX_UTest write(name, *) "Testing Clock IsCreated for uncreated object" write(failMsg, *) "Did not return ESMF_SUCCESS" isCreated = ESMF_ClockIsCreated(clock, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE) !------------------------------------------------------------------------ !------------------------------------------------------------------------ !NEX_UTest write(name, *) "Create test Clock for IsCreated" write(failMsg, *) "Did not return ESMF_SUCCESS" clock = ESMF_ClockCreate(timeStep, startTime, name="Clock 1", rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE) !------------------------------------------------------------------------ !------------------------------------------------------------------------ !NEX_UTest write(name, *) "Testing Clock IsCreated for created object" write(failMsg, *) "Did not return .true." isCreated = ESMF_ClockIsCreated(clock) call ESMF_Test((isCreated .eqv. .true.), name, failMsg, result, ESMF_SRCLINE) !------------------------------------------------------------------------ !------------------------------------------------------------------------ !NEX_UTest write(name, *) "Testing Clock IsCreated for created object" write(failMsg, *) "Did not return ESMF_SUCCESS" isCreated = ESMF_ClockIsCreated(clock, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE) !------------------------------------------------------------------------ !------------------------------------------------------------------------ !NEX_UTest write(name, *) "Destroy test Clock for IsCreated" write(failMsg, *) "Did not return ESMF_SUCCESS" call ESMF_ClockDestroy(clock, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE) !------------------------------------------------------------------------ !------------------------------------------------------------------------ !NEX_UTest write(name, *) "Testing Clock IsCreated for destroyed object" write(failMsg, *) "Did not return .false." isCreated = ESMF_ClockIsCreated(clock) call ESMF_Test((isCreated .eqv. .false.), name, failMsg, result, ESMF_SRCLINE) !------------------------------------------------------------------------ !------------------------------------------------------------------------ !NEX_UTest write(name, *) "Testing Clock IsCreated for destroyed object" write(failMsg, *) "Did not return ESMF_SUCCESS" isCreated = ESMF_ClockIsCreated(clock, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE) !------------------------------------------------------------------------ #ifdef ESMF_TESTEXHAUSTIVE ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Did not return ESMF_RC_OBJ_DELETED" write(name, *) "Destroyed Clock Destroy Test" call ESMF_ClockDestroy(clock, rc=rc) call ESMF_Test((rc.eq.ESMF_RC_OBJ_DELETED), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Did not return ESMF_RC_OBJ_NOT_CREATED" write(name, *) "Destroyed Clock Destroy Test" call ESMF_ClockDestroy(clock1, rc=rc) call ESMF_Test((rc.eq.ESMF_RC_OBJ_NOT_CREATED), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Did not return ESMF_RC_OBJ_DELETED" write(name, *) "Set destroyed Clock Name Test" call ESMF_ClockSet(clock, name="Clock 2", rc=rc) call ESMF_Test((rc.eq.ESMF_RC_OBJ_DELETED), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Did not return ESMF_RC_OBJ_NOT_CREATED" write(name, *) "Set uncreated Clock Name Test" call ESMF_ClockSet(clock1, name="Clock 2", rc=rc) call ESMF_Test((rc.eq.ESMF_RC_OBJ_NOT_CREATED), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Get previous time from deleted Clock Test" write(failMsg, *) " Did not return ESMF_RC_OBJ_DELETED" call ESMF_ClockGet(clock, prevTime=previousTime, rc=rc) call ESMF_Test((rc.eq.ESMF_RC_OBJ_DELETED), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Get previous time from uncreated Clock Test" write(failMsg, *) " Did not return ESMF_RC_OBJ_NOT_CREATED" call ESMF_ClockGet(clock1, prevTime=previousTime, rc=rc) call ESMF_Test((rc.eq.ESMF_RC_OBJ_NOT_CREATED), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Advance deleted CLock Test" write(failMsg, *) " Did not return ESMF_RC_OBJ_DELETED" call ESMF_ClockAdvance(clock, rc=rc) call ESMF_Test((rc.eq.ESMF_RC_OBJ_DELETED), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Advance uncreated CLock Test" write(failMsg, *) " Did not return ESMF_RC_OBJ_NOT_CREATED" call ESMF_ClockAdvance(clock1, rc=rc) call ESMF_Test((rc.eq.ESMF_RC_OBJ_NOT_CREATED), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Did not return ESMF_RC_OBJ_DELETED" write(name, *) "ClockIsStopTime on destroyed Clock Test" bool = ESMF_ClockIsStopTime(clock, rc=rc) call ESMF_Test((rc.eq.ESMF_RC_OBJ_DELETED), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Did not return ESMF_RC_OBJ_NOT_CREATED" write(name, *) "ClockIsStopTime on uncreated Clock Test" bool = ESMF_ClockIsStopTime(clock1, rc=rc) call ESMF_Test((rc.eq.ESMF_RC_OBJ_NOT_CREATED), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the year is set correctly write(name, *) "Get Start Time Year Test" call ESMF_TimeGet(startTime, yy=YY, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or Year not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(YY.eq.2003), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the month is set correctly write(name, *) "Get StartTime Month Test" call ESMF_TimeGet(startTime, mm=MM, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or Month not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(MM.eq.3), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the day is set correctly write(name, *) "Get StartTime Day Test" call ESMF_TimeGet(startTime, dd=DD, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or Day not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(DD.eq.13), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- ! hours, minutes, seconds within the day tests ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the hour is set correctly within the day write(name, *) "Get StartTime Hours Within the Day Test" call ESMF_TimeGet(startTime, dd=DD, h=H, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or day or hour not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(DD.eq.13).and.(H.eq.18), & name, failMsg, result, ESMF_SRCLINE) !print *, "hours = ", H ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the minutes is set correctly within the day write(name, *) "Get StartTime Minutes Within the Day Test" call ESMF_TimeGet(startTime, dd=DD, m=M, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or day or minutes not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(DD.eq.13).and.(M.eq.1125), & name, failMsg, result, ESMF_SRCLINE) ! Minutes = 18 X 60 + 45 = 1125 !print *, "minutes = ", M ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the seconds are set correctly within the day write(name, *) "Get StartTime seconds Within the Day Test" call ESMF_TimeGet(startTime, dd=DD, s=secs, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or day or seconds not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(DD.eq.13).and.(secs.eq.67527), & name, failMsg, result, ESMF_SRCLINE) ! seconds = 1125 X 60 + 27 = 67527 !print *, "seconds = ", secs ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the hours, minutes and seconds are set correctly within the day write(name, *) "Get StartTime in hours, minutes & seconds Within the Day Test" call ESMF_TimeGet(startTime, dd=DD, h=H, m=M, s=secs, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or day, hours, minutes or seconds not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(DD.eq.13).and.(secs.eq.27) & .and.(H.eq.18).and.(M.eq.45), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the hours and seconds are set correctly within the day write(name, *) "Get StartTime in hours, & seconds Within the Day Test" call ESMF_TimeGet(startTime, dd=DD, h=H, s=secs, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or day, hour or seconds not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(DD.eq.13).and.(secs.eq.2727) & .and.(H.eq.18), name, failMsg, result, ESMF_SRCLINE) ! Seconds = 60 X 45 + 27 = 2727 ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the minutes and seconds are set correctly within the day write(name, *) "Get StartTime in minutes, & seconds Within the Day Test" call ESMF_TimeGet(startTime, s=secs, m=M, dd=DD, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or day, minutes, or seconds not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(secs.eq.27) & .and.(M.eq.1125).and.(DD.eq.13), & name, failMsg, result, ESMF_SRCLINE) ! Minutes = 60 X 18 + 45 = 1125 ! ---------------------------------------------------------------------------- ! hours, minutes, seconds within the month tests ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the hour is set correctly within the month write(name, *) "Get StartTime Hours Within the Month Test" call ESMF_TimeGet(startTime, mm=MM, h=H, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or month or hour not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(MM.eq.3).and.(H.eq.306), & name, failMsg, result, ESMF_SRCLINE) ! Hours = 12 X 24 + 18 = 306 !print *, "hours = ", H ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the minutes is set correctly within the month write(name, *) "Get StartTime Minutes Within the Month Test" call ESMF_TimeGet(startTime, mm=MM, m=M, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or month or minutes not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(MM.eq.3).and.(M.eq.18405), & name, failMsg, result, ESMF_SRCLINE) ! Minutes = 12 X 1440 + 18 X 60 + 45 = 18405 !print *, "minutes = ", M ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the seconds are set correctly within the month write(name, *) "Get StartTime seconds Within the Month Test" call ESMF_TimeGet(startTime, mm=MM, s=secs, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or month or seconds not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(MM.eq.3).and.(secs.eq.1104327), & name, failMsg, result, ESMF_SRCLINE) ! seconds = 18405 X 60 + 27 = 1104327 !print *, "seconds = ", secs ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the hours, minutes and seconds are set correctly within the month write(name, *) "Get StartTime in hours, minutes & seconds Within the Month Test" call ESMF_TimeGet(startTime, mm=MM, h=H, m=M, s=secs, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or month, hours, minutes or seconds not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(MM.eq.3).and.(secs.eq.27) & .and.(H.eq.306).and.(M.eq.45), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the hours and seconds are set correctly within the month write(name, *) "Get StartTime in hours, & seconds Within the Month Test" call ESMF_TimeGet(startTime, mm=MM, h=H, s=secs, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or month, hour or seconds not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(MM.eq.3).and.(secs.eq.2727) & .and.(H.eq.306), name, failMsg, result, ESMF_SRCLINE) ! Seconds = 60 X 45 + 27 = 2727 ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the minutes and seconds are set correctly within the month write(name, *) "Get StartTime in minutes, & seconds Within the Month Test" call ESMF_TimeGet(startTime, s=secs, m=M, mm=MM, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or month, minutes, or seconds not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(secs.eq.27) & .and.(M.eq.18405).and.(MM.eq.3), & name, failMsg, result, ESMF_SRCLINE) ! Minutes = 12 X 1440 + 18 X 60 + 45 = 18405 ! ---------------------------------------------------------------------------- ! hours, minutes, seconds within the year tests ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the hour is set correctly within the year write(name, *) "Get StartTime Hours Within the Year Test" call ESMF_TimeGet(startTime, yy=YY, h=H, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or year or hour not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(YY.eq.2003).and.(H.eq.1722), & name, failMsg, result, ESMF_SRCLINE) ! Hours = (59+12) X 24 + 18 = 1722 !print *, "hours = ", H ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the minutes is set correctly within the year write(name, *) "Get StartTime Minutes Within the Year Test" call ESMF_TimeGet(startTime, yy=YY, m=M, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or year or minutes not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(YY.eq.2003).and.(M.eq.103365), & name, failMsg, result, ESMF_SRCLINE) ! Minutes = (59+12) X 1440 + 18 X 60 + 45 = 103365 !print *, "minutes = ", M ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the seconds are set correctly within the year write(name, *) "Get StartTime seconds Within the Year Test" call ESMF_TimeGet(startTime, yy=YY, s=secs, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or year or seconds not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(YY.eq.2003).and.(secs.eq.6201927), & name, failMsg, result, ESMF_SRCLINE) ! seconds = 103365 X 60 + 27 = 6201927 !print *, "seconds = ", secs ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the hours, minutes and seconds are set correctly within the year write(name, *) "Get StartTime in hours, minutes & seconds Within the Year Test" call ESMF_TimeGet(startTime, yy=YY, h=H, m=M, s=secs, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or year, hours, minutes or seconds not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(YY.eq.2003).and.(secs.eq.27) & .and.(H.eq.1722).and.(M.eq.45), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the hours and seconds are set correctly within the year write(name, *) "Get StartTime in hours, & seconds Within the Year Test" call ESMF_TimeGet(startTime, yy=YY, h=H, s=secs, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or year, hour or seconds not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(YY.eq.2003).and.(secs.eq.2727) & .and.(H.eq.1722), name, failMsg, result, ESMF_SRCLINE) ! Seconds = 60 X 45 + 27 = 2727 ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the minutes and seconds are set correctly within the year write(name, *) "Get StartTime in minutes, & seconds Within the Year Test" call ESMF_TimeGet(startTime, s=secs, m=M, yy=YY, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or year, minutes, or seconds not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(secs.eq.27) & .and.(M.eq.103365).and.(YY.eq.2003), & name, failMsg, result, ESMF_SRCLINE) ! Minutes = (59+12) X 1440 + 18 X 60 + 45 = 103365 ! ---------------------------------------------------------------------------- !EX_UTest ! Test fix for bug #1113438 "getting dayOfYear should impose day ! boundary for getting hrs" From Tom Henderson/WRF write(name, *) "Get current_time in dayOfYear, hours, minutes, seconds, & milliseconds Within the Year Test" call ESMF_TimeSet(current_time, YY=2000, MM=1, DD=24, & H=12, M=0, S=0, MS=0, rc=rc) call ESMF_TimeGet(current_time, YY=julyr, dayOfYear=julday, & H=hr, M=min, S=sec, MS=ms, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or year, dayOfYear, hours, minutes, seconds, milliseconds not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(ms.eq.0).and.(sec.eq.0) & .and.(min.eq.0).and.(hr.eq.12).and.(julday.eq.24) & .and.(julyr.eq.2000), & name, failMsg, result, ESMF_SRCLINE) !print *, "julyr,hr,min,sec,ms,julday = ", julyr,hr,min,sec,ms,julday ! ---------------------------------------------------------------------------- ! end of hours, minutes, seconds within the year tests ! ---------------------------------------------------------------------------- !EX_UTest ! Test Setting the Start Time day = 25 write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Set Start Time Initialization Test" call ESMF_TimeSet(startTime, yy=yy, mm=11, dd=day, & h=11, m=45, s=18, & calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the day is set correctly write(name, *) "Get StartTime Day Test" call ESMF_TimeGet(startTime, dd=day, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or Day not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(day.eq.25), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Test Setting the Start Time year_i8 = 30067 second_i8 = 51 write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Set Start Time Initialization Test" call ESMF_TimeSet(startTime, yy_i8=year_i8, mm=6, dd=25, & h=7, m=56, s_i8=second_i8, & calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the year is set correctly write(name, *) "Get Start Time Year Test" call ESMF_TimeGet(startTime, yy_i8=YY_i8, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or Year not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(YY_i8.eq.30067), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the month is set correctly write(name, *) "Get StartTime Month Test" call ESMF_TimeGet(startTime, mm=MM, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or Month not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(MM.eq.6), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the day of the month is set correctly write(name, *) "Get StartTime Day Test" call ESMF_TimeGet(startTime, dd=DD, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or Day not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(DD.eq.25), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the calendar is set correctly write(name, *) "Get Calendar Kind Test" call ESMF_CalendarGet(gregorianCalendar, calkindflag=cal_kind, rc=rc) write(failMsg, *) " Did not return ESMF_SUCCESS and/or calendar not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and. & (cal_kind.eq.ESMF_CALKIND_GREGORIAN), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! run this test only on platforms that support F95 initializers, otherwise ! may crash or produce FAIL commented out until after release. ! see bug #755424 ! TODO: test count will be "off-by-one" on platforms where this test ! doesn't run ! This code crashes, bug 797533 has been opened. ! Attempt to get un-initialized year from stop time write(name, *) "Get Uninitialized StopTime Year Test" call ESMF_TimeGet(stopTime, yy=YY, rc=rc) write(failMsg, *) " Returned ESMF_SUCCESS" call ESMF_Test((rc.eq.ESMF_RC_OBJ_INIT), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Set time to illegitimate month write(name, *) "Stop Time Initialization to illegitimate month (0) Test" write(failMsg, *) " Should not return ESMF_SUCCESS." call ESMF_TimeSet(stopTime, yy=2003, mm=0, dd=14, & calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMC_RC_ARG_OUTOFRANGE), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Set time to illegitimate month write(name, *) "Stop Time Initialization to illegitimate month (13) Test" write(failMsg, *) " Should not return ESMF_SUCCESS." call ESMF_TimeSet(stopTime, yy=2003, mm=13, dd=14, & calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMC_RC_ARG_OUTOFRANGE), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Set time to illegitimate day write(name, *) "Stop Time Initialization to Feb. 31st. Test" write(failMsg, *) " Should return ESMF_FAILURE." call ESMF_TimeSet(stopTime, yy=2003, mm=2, dd=31, & calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMC_RC_ARG_OUTOFRANGE), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Set time to lower bound of Fliegel algoritm write(name, *) "Test lower bound of Fliegel algorithm Test" write(failMsg, *) " Should return ESMF_SUCCESS." call ESMF_TimeSet(stopTime, yy=-4800, mm=3, dd=1, & calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Set time beyond lower bound of Fliegel algoritm write(name, *) "Test beyond lower bound of Fliegel algorithm Test" write(failMsg, *) " Should return ESMF_FAILURE." call ESMF_TimeSet(stopTime, yy=-4800, mm=2, dd=28, & calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMC_RC_ARG_OUTOFRANGE), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Stop Time Initialization Test" call ESMF_TimeSet(stopTime, yy=2003, mm=3, dd=14, & calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the year is set correctly write(name, *) "Get StopTime Year Test" call ESMF_TimeGet(stopTime, yy=YY, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or Year not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(YY.eq.2003), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the month is set correctly write(name, *) "Get StopTime Month Test" call ESMF_TimeGet(stopTime, mm=MM, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or Month not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(MM.eq.3), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- call ESMF_LogSet (flush=.true.) !EX_UTest ! Test fix for bug #755445 ! ClockPrint with an unallocated clock write(name, *) "Clock Print Test with unallocated clock" write(failMsg, *) "Did not return ESMF_RC_OBJ_DELETED" call ESMF_ClockPrint(clock, rc=rc) call ESMF_Test((rc.eq.ESMF_RC_OBJ_DELETED), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Test fix for bug 1649164. ! Initialize clock with uninitialized Start Time. write(name, *) "Clock Initialization Test with uninitialized startTime" write(failMsg, *) " Did not return ESMF_RC_OBJ_INIT" clock = ESMF_ClockCreate(timeStep, startTime2, & stopTime=stopTime, name="Clock 1", rc=rc) call ESMF_Test((rc.eq.ESMF_RC_OBJ_INIT), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EXxxx_UTest ! Destroy clock with uninitialized Start Time ! write(failMsg, *) " Did not return ESMF_RC_OBJ_NOT_CREATED" ! write(name, *) "Destroy uninitialized clock test" !call ESMF_LogSet (trace=.true.) ! call ESMF_ClockDestroy(clock, rc=rc) ! call ESMF_Test(rc == ESMF_RC_OBJ_NOT_CREATED, & ! name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Test Setting the Start Time write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Set Start Time Initialization Test" call ESMF_TimeSet(startTime, yy=2003, mm=3, dd=13, & h=18, m=45, s=27, & calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) !call ESMF_LogSet (trace=.false.) ! ---------------------------------------------------------------------------- !EX_UTest ! print out initialized variables ! Test that print subroutine returns ESMF_SUCESS write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Calendar Print Test" call ESMF_CalendarPrint(gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Time Interval Print Test" call ESMF_TimeIntervalPrint(timeStep, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Start Time Print Test" call ESMF_TimePrint(startTime, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Clock Initialization Test" clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="Clock 1", rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Clock Initialization Test" clock2 = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="Clock 1", rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Set Clock Name Test" call ESMF_ClockSet(clock2, name="Clock 2", rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Create Clock copy Test" clock1 = ESMF_ClockCreate(clock, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockAssignment(=)(clock,clock) write(failMsg, *) "Returned not equal" write(name, *) "Clock Assignment Test" clock4 = clock ! exercise default F90 Clock = assignment call ESMF_ClockGet(clock4, name=clockName, startTime=startTime2, & stopTime=stopTime2, timeStep=timeStep2, rc=rc) call ESMF_Test((clock==clock4 .and. clockName=="Clock 1" .and. & startTime2==startTime .and. stopTime2==stopTime .and. & timeStep2==timeStep), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(==)(clock,clock1) write(failMsg, *) "Returned not equal" write(name, *) "Clocks Equal Test" clocksEqual = (clock == clock1) ! exercise Clock == operator call ESMF_Test((clocksEqual), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(==)(clock,clock1) write(failMsg, *) "Returned equal" write(name, *) "Clocks Not Equal Test" clocksEqual = (clock == clock2) ! exercise Clock == operator call ESMF_Test((.not.clocksEqual), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(/=)(clock,clock1) write(failMsg, *) "Returned not equal" write(name, *) "Clocks Not Equal Test" clocksNotEqual = (clock /= clock2) ! exercise Clock /= operator call ESMF_Test((clocksNotEqual), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(/=)(clock,clock1) write(failMsg, *) "Returned not equal" write(name, *) "Clocks Equal Test" clocksNotEqual = (clock /= clock1) ! exercise Clock /= operator call ESMF_Test((.not.clocksNotEqual), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock1, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Stop Time Print Test" call ESMF_TimePrint(stopTime, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Clock Print Test" call ESMF_ClockPrint(clock, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Did not return ESMF_SUCCESS and/or bool not False" write(name, *) "ClockIsStopTime Test" bool = ESMF_ClockIsStopTime(clock, rc=rc) call ESMF_Test(((rc.eq.ESMF_SUCCESS) .and.(.not.bool)), & name, failMsg, result, ESMF_SRCLINE) !print *, "bool = ", bool ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Did not return ESMF_SUCCESS and advanceCount=247" write(name, *) "ClockSet(clock, advanceCount) Test" nTimeSteps = 247 call ESMF_ClockSet(clock, advanceCount=nTimeSteps, rc=rc) call ESMF_ClockGet(clock, advanceCount=advanceCounts, rc=rc) call ESMF_Test(((rc.eq.ESMF_SUCCESS) .and.(advanceCounts.eq.247)), & name, failMsg, result, ESMF_SRCLINE) !print *, "advanceCount = ", advanceCounts call ESMF_ClockDestroy(clock, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(==)(clock,clock1) write(failMsg, *) "Returned equal" write(name, *) "Deleted Clock Not Equal Created Clock Test 1" clocksEqual = (clock == clock2) ! exercise Clock == operator call ESMF_Test((.not.clocksEqual), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(==)(clock,clock1) write(failMsg, *) "Returned equal" write(name, *) "Deleted Clock Not Equal Uncreated Clock Test 1" clocksEqual = (clock == clock3) ! exercise Clock == operator call ESMF_Test((.not.clocksEqual), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(==)(clock,clock1) write(failMsg, *) "Returned equal" write(name, *) "Uncreated Clock Not Equal Created Clock Test 1" clocksEqual = (clock3 == clock2) ! exercise Clock == operator call ESMF_Test((.not.clocksEqual), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(==)(clock,clock1) write(failMsg, *) "Returned not equal" write(name, *) "Uncreated Clock Equal Uncreated Clock Test 1" clocksEqual = (clock3 == clock3) ! exercise Clock == operator call ESMF_Test((clocksEqual), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(==)(clock,clock1) write(failMsg, *) "Returned not equal" write(name, *) "Deleted Clock Equal Deleted Clock Test 1" clocksEqual = (clock == clock) ! exercise Clock == operator call ESMF_Test((clocksEqual), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(/=)(clock,clock1) write(failMsg, *) "Returned equal" write(name, *) "Deleted Clock Not Equal Created Clock Test 2" clocksNotEqual = (clock /= clock2) ! exercise Clock /= operator call ESMF_Test((clocksNotEqual), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(/=)(clock,clock1) write(failMsg, *) "Returned equal" write(name, *) "Deleted Clock Not Equal Uncreated Clock Test 2" clocksNotEqual = (clock /= clock3) ! exercise Clock /= operator call ESMF_Test((clocksNotEqual), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(/=)(clock,clock1) write(failMsg, *) "Returned equal" write(name, *) "Uncreated Clock Not Equal Created Clock Test 2" clocksNotEqual = (clock3 /= clock2) ! exercise Clock /= operator call ESMF_Test((clocksNotEqual), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(/=)(clock,clock1) write(failMsg, *) "Returned not equal" write(name, *) "Uncreated Clock Equal Uncreated Clock Test 2" clocksNotEqual = (clock3 /= clock3) ! exercise Clock /= operator call ESMF_Test((.not.clocksNotEqual), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_ClockOperator(/=)(clock,clock1) write(failMsg, *) "Returned not equal" write(name, *) "Deleted Clock Equal Deleted Clock Test 2" clocksNotEqual = (clock /= clock) ! exercise Clock /= operator call ESMF_Test((.not.clocksNotEqual), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Clock Initialization Test" clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="Clock 1", rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- if (rc.eq.ESMF_SUCCESS) then !EX_UTest ! time step from start time to stop time do while (.not.ESMF_ClockIsStopTime(clock, rc=rc)) call ESMF_ClockAdvance(clock, rc=rc) !call ESMF_ClockPrint(clock, options="currtime string", rc=rc) end do bool = ESMF_ClockIsStopTime(clock, rc=rc) !print *, "bool = ", bool write(failMsg, *) " Did not return ESMF_SUCCESS and/or bool not True" write(name, *) "Clock Advance Test" call ESMF_Test(((rc.eq.ESMF_SUCCESS).and.(bool)), & name, failMsg, result, ESMF_SRCLINE) end if ! ---------------------------------------------------------------------------- !EX_UTest ! Sync to real time test ! TODO: This test only will test for rc=ESMF_SUCCESS ! A test must be written that verifies that it works write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Clock Sync to Real Time Test" call ESMF_TimeSet(stopTime4, yy=100000, mm=1, dd=1, & calendar=gregorianCalendar, rc=rc) call ESMF_ClockSet(clock2, stopTime=stopTime4, rc=rc) call ESMF_ClockSyncToRealTime(clock2,rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Clock Validate write(failMsg, *) " Returned ESMF_FAILURE" write(name, *) "Clock Validate Test" call ESMF_ClockValidate(clock2,rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock2, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest call ESMF_ClockAdvance(clock, rc=rc) call ESMF_ClockAdvance(clock, rc=rc) call ESMF_ClockAdvance(clock, rc=rc) call ESMF_ClockAdvance(clock, rc=rc) !print *, "Print Clock after advancing 4 times" write(failMsg, *) " Returned ESMF_FAILURE and/or bool not True" write(name, *) "Clock Advanced beyond stopTime Test" !call ESMF_ClockPrint(clock, rc=rc) bool = ESMF_ClockIsStopTime(clock, rc=rc) call ESMF_Test(((rc.eq.ESMF_SUCCESS).and.(bool)), & name, failMsg, result, ESMF_SRCLINE) !print *, "bool = ", bool ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Get previous time and verify Test" call ESMF_ClockGet(clock, currTime=currentTime, rc=rc) call ESMF_ClockAdvance(clock, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or currTime != prevTime" call ESMF_ClockGet(clock, prevTime=previousTime, rc=rc) call ESMF_Test(((rc.eq.ESMF_SUCCESS).and.(currentTime.eq.previousTime)), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Get previous SimTime and verify Test" call ESMF_ClockGet(clock, currSimTime=currentSimTime, rc=rc) call ESMF_ClockAdvance(clock, rc=rc) write(failMsg, *) " Returned ESMF_FAILURE and/or currSimTime != prevTime" call ESMF_ClockGet(clock, prevSimTime=previousSimTime, rc=rc) call ESMF_Test(((rc.eq.ESMF_SUCCESS).and.(currentSimTime.eq.previousSimTime)), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Clock Initialization with stop time set before start time Test" call ESMF_TimeSet(stopTime, yy=2002, mm=3, dd=14, & calendar=gregorianCalendar, rc=rc) write(failMsg, *) "Should not return ESMF_SUCCESS because timestep is positive." clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="Clock 1", rc=rc) call ESMF_Test((rc.eq.ESMC_RC_VAL_OUTOFRANGE), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Clock Initialization with stop time & start time with different calendars Test" call ESMF_TimeSet(startTime, yy=2000, mm=3, dd=13, & calendar=julianDayCalendar, rc=rc) write(failMsg, *) "Should not return ESMF_SUCCESS." clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="Clock 1", rc=rc) call ESMF_Test((rc.eq.ESMC_RC_OBJ_BAD), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with Years = -1000 Test" call ESMF_TimeSet(startTime, yy=-1000, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with hour = zero Test" call ESMF_TimeSet(startTime, yy=-1000, h=0, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with hour = negative 3 Test" call ESMF_TimeSet(startTime, h=-3, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) !call ESMF_TimePrint(startTime, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with hour = 3 Test" call ESMF_TimeSet(startTime, h=3, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with hour = 25 Test" call ESMF_TimeSet(startTime, h=25, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with minutes = zero Test" call ESMF_TimeSet(startTime, m=0, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with minutes = negative 5 Test" call ESMF_TimeSet(startTime, m=-5, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with minutes = 5 Test" call ESMF_TimeSet(startTime, m=5, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with minutes = 65 Test" call ESMF_TimeSet(startTime, m=65, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with seconds = 0 Test" call ESMF_TimeSet(startTime, s=0, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with seconds = negative 8 Test" call ESMF_TimeSet(startTime, s=-8,calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with seconds = 8 with no calendar kind specified Test" call ESMF_TimeSet(startTime, s=8, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with seconds = 8 with calendar kind specified Test" call ESMF_TimeSet(startTime, s=8, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with seconds = 65 Test" call ESMF_TimeSet(startTime, s=65, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with milli-seconds = 0 Test" call ESMF_TimeSet(startTime, ms=0, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with milli-seconds = 84 Test" call ESMF_TimeSet(startTime, ms=84, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with milli-seconds = 101 Test" call ESMF_TimeSet(startTime, ms=101, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with micro-seconds = 0 Test" call ESMF_TimeSet(startTime, us=0, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with micro-seconds = 55 Test" call ESMF_TimeSet(startTime, us=55, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." write(name, *) "Time Initialization with micro-seconds = 101 Test" call ESMF_TimeSet(startTime, us=101, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(startTime, yy=100, mm=1, dd=1, & calendar=gregorianCalendar, rc=rc) write(name, *) "Start Time initialization with year = 100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(stopTime, yy=-100, mm=1, dd=1, & calendar=gregorianCalendar, rc=rc) write(name, *) "Stop Time initialization with year = -100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeIntervalSet(timeStep, h=-1, rc=rc) clock_gregorian = ESMF_ClockCreate(timeStep, startTime, & stopTime=stopTime, & name="Gregorian Clock", rc=rc) write(name, *) "Clock initialization with above settings Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- if (rc.eq.ESMF_SUCCESS) then totalDays=0 days=-1 call ESMF_TimeIntervalSet(timeStep, d=days, rc=rc) !call ESMF_TimePrint(startTime, rc=rc) !call ESMF_TimePrint(stopTime, rc=rc) ! time step from start time to stop time do while (.not.ESMF_ClockIsStopTime(clock_gregorian, rc=rc)) call ESMF_ClockAdvance(clock_gregorian, timeStep=timeStep, rc=rc) totalDays=totalDays+days end do end if ! ---------------------------------------------------------------------------- !EX_UTest !print *, " Total days = ", totalDays write(failMsg, *) "Results Total days = ", totalDays write(name, *) "Total days -73049 from +100 to -100 years in Gregorian Cal. Test" call ESMF_Test((totalDays.eq.-73049), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Total Counts 73049 from -100 to +100 years in Gregorian Cal. Test" call ESMF_ClockGet(clock_gregorian, advanceCount=advanceCounts, rc=rc) write(failMsg, *) "Results Total Counts = ", advanceCounts call ESMF_Test((advanceCounts.eq.73049), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock_gregorian, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeIntervalSet(timeStep, yy=10, rc=rc) write(name, *) "Time Step initialization with years = 10 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(startTime, yy=-100, mm=1, dd=1, & calendar=gregorianCalendar, rc=rc) write(name, *) "Start Time initialization with year = -100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(stopTime, yy=100, mm=1, dd=1, & calendar=gregorianCalendar, rc=rc) write(name, *) "Stop Time initialization with year = 100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." clock_gregorian = ESMF_ClockCreate(timeStep, startTime, & stopTime=stopTime, & name="Gregorian Clock", rc=rc) write(name, *) "Clock initialization with above settings Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- if (rc.eq.ESMF_SUCCESS) then call date_and_time(values=timevals) call random_seed (size=seed_size) allocate (seed(seed_size)) seed=timevals(8) call random_seed(put=seed) deallocate (seed) testResults = 0 do while (.not.ESMF_ClockIsStopTime(clock_gregorian, rc=rc)) call random_number(ranNum) days= int (ranNum*25) call random_number(ranNum) H= int (ranNum*100) call random_number(ranNum) MM= int (ranNum*100) call random_number(ranNum) secs= int (ranNum*100) call ESMF_TimeIntervalSet(timeStep, d=days, h=H, m=MM, s=secs, rc=rc) call ESMF_ClockAdvance(clock_gregorian, timeStep=timeStep, rc=rc) call ESMF_ClockGet(clock_gregorian, currTime=currentTime, rc=rc) call ESMF_ClockGet(clock_gregorian, prevTime=previousTime, rc=rc) timeDiff = currentTime - previousTime ! Note: this timeInterval comparison depends on ! ESMF_Initialize(defaultCalKind=ESMF_CALKIND_GREGORIAN) ! being set so the timeIntervals' (timeStep) magnitude can ! be determined. if((timeDiff.ne.timeStep).and.(testResults.eq.0)) then testResults=1 !call ESMF_TimeIntervalPrint(timeStep, rc=rc) !call ESMF_TimeIntervalPrint(timeDiff, rc=rc) !call ESMF_TimePrint(currentTime, rc=rc) !call ESMF_TimePrint(previousTime, rc=rc) ! Exit loop on first failure exit end if end do end if !EX_UTest write(failMsg, *) "Time comparison failed." write(name, *) "Current Time minus PreviousTime = timeStep for Gregorian Cal. Test" call ESMF_Test((testResults.eq.0), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock_gregorian, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(startTime, yy=-100, mm=1, dd=1, & calendar=no_leapCalendar, rc=rc) write(name, *) "Start Time initialization with year = -100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(stopTime, yy=100, mm=1, dd=1, & calendar=no_leapCalendar, rc=rc) write(name, *) "Stop Time initialization with year = 100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." clock_no_leap = ESMF_ClockCreate(timeStep, startTime, & stopTime=stopTime, & name="No Leap Clock", rc=rc) write(name, *) "Clock initialization with above settings Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- if (rc.eq.ESMF_SUCCESS) then totalDays=0 days=1 call ESMF_TimeIntervalSet(timeStep, d=days, rc=rc) !call ESMF_TimePrint(startTime, rc=rc) !call ESMF_TimePrint(stopTime, rc=rc) ! time step from start time to stop time do while (.not.ESMF_ClockIsStopTime(clock_no_leap, rc=rc)) call ESMF_ClockAdvance(clock_no_leap, timeStep=timeStep, rc=rc) totalDays=totalDays+days end do end if ! ---------------------------------------------------------------------------- !EX_UTest !print *, " Total days = ", totalDays write(failMsg, *) "Results Total days = ", totalDays write(name, *) "Total days 73000 from -100 to +100 years in No Leap Cal. Test" call ESMF_Test((totalDays.eq.73000), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Total Counts 73000 from -100 to +100 years in No Leap Cal. Test" call ESMF_ClockGet(clock_no_leap, advanceCount=advanceCounts, rc=rc) write(failMsg, *) "Results Total Counts = ", advanceCounts call ESMF_Test((advanceCounts.eq.73000), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock_no_leap, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest call ESMF_TimeSet(startTime, yy=100, mm=1, dd=1, & calendar=esmf_360dayCalendar, rc=rc) call ESMF_TimeSet(stopTime, yy=100, mm=1, dd=1, & calendar=esmf_360dayCalendar, rc=rc) write(failMsg, *) "Should not return ESMF_SUCCESS." clock_360day = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="360 Day Clock", rc=rc) write(name, *) "Clock initialization with Start Time equal to Stop Time Test" call ESMF_Test((rc.eq.ESMC_RC_VAL_WRONG), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock_360day, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeIntervalSet(timeStep, rc=rc) write(name, *) "Time Step initialization with nothing set Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should not return ESMF_SUCCESS." call ESMF_TimeSet(startTime, yy=-100, mm=1, dd=31, & calendar=esmf_360dayCalendar, rc=rc) write(name, *) "Start Time set to illegitimate day in 360 day Calendar Test" call ESMF_Test((rc.eq.ESMC_RC_ARG_OUTOFRANGE), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should not return ESMF_SUCCESS." call ESMF_TimeSet(startTime, yy=-100, mm=1, dd=380, & calendar=esmf_360dayCalendar, rc=rc) write(name, *) "Start Time set to illegitimate day in 360 day Calendar Test" call ESMF_Test((rc.eq.ESMC_RC_ARG_OUTOFRANGE), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Did not return ESMC_RC_VAL_WRONG." call ESMF_TimeSet(startTime, yy=100, mm=1, dd=1, h=0, m=-9, s=-5, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeSet(stopTime, yy=99, mm=12, dd=31, h=23, m=50, s=55, & calendar=gregorianCalendar, rc=rc) write(name, *) "Time setting equivalency Test" clock_gregorian = ESMF_ClockCreate(timeStep, startTime, & stopTime=stopTime, & name="Gregorian Clock", rc=rc) call ESMF_Test((rc.eq.ESMC_RC_VAL_WRONG), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock_gregorian, rc=rc) ! ---------------------------------------------------------------------------- ! TODO: uncomment when fixed !write(failMsg, *) "Should not return ESMF_SUCCESS." !call ESMF_TimeSyncToRealTime(syncTime, rc) !write(name, *) "Time Sync to Real Time Test" !call ESMF_Test((rc.ne.ESMF_SUCCESS), & ! name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Did not return ESMF_SUCCESS" write(name, *) "Sync Time Set Calendar Test" call ESMF_TimeSet(syncTime, calendar=gregorianCalendar, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." ! It is possible, but not probable, that a year boundary will be crossed ! between the next two calls, causing the test for year match below to ! fail. Keep these two calls adjacent to one another to ensure the ! lowest probability of failure. TODO: compare values call ESMF_TimeSyncToRealTime(syncTime, rc=rc) call date_and_time(values=datetime) write(name, *) "Time Sync to Real Time Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Verify the year is set correctly write(name, *) "Get Sync Time Year Test" call ESMF_TimeGet(syncTime, yy=YY, rc=rc) write(failMsg, *) " Did not return ESMF_SUCCESS and/or Year not correct value" call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(YY.eq.datetime(1)), & name, failMsg, result, ESMF_SRCLINE) !print *, " Sync Time year = ", YY !print *, " Get Sync Time rc = ", rc ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) " Did not return ESMF_SUCCESS" write(name, *) "Sync Time Print Test" call ESMF_TimePrint(syncTime, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(startTime, yy=-100, mm=1, dd=1, & calendar=gregorianCalendar, rc=rc) write(name, *) "Start Time initialization with year = -100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) !call ESMF_TimePrint(startTime, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(stopTime, yy=100, mm=1, dd=1, & calendar=gregorianCalendar, rc=rc) write(name, *) "Stop Time initialization with year = 100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) !call ESMF_TimePrint(stopTime, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest ! Test Setting Time Interval write(failMsg, *) " Did not return ESMF_SUCCESS" write(name, *) "Set Time Interval to 73049 days Test" call ESMF_TimeIntervalSet(timeStep, d=73049, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) !call ESMF_TimeIntervalPrint(timeStep, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest ! Test Incrementing Time by Time Interval ! Testing ESMF_TimeOperator(+)(time,timestep) write(failMsg, *) " startTime not equal to stopTime" write(name, *) "Incrementing starttime by 73049 days Test" startTime = startTime + timeStep ! exercise Time + operator call ESMF_Test((startTime.eq.stopTime), & name, failMsg, result, ESMF_SRCLINE) !call ESMF_TimePrint(startTime, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(startTime, yy=-100, mm=1, dd=1, & calendar=gregorianCalendar, rc=rc) write(name, *) "Start Time initialization with year = -100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) !call ESMF_TimePrint(startTime, rc=rc) ! ---------------------------------------------------------------------------- ! Test Decrementing Time by Time Interval ! Testing ESMF_TimeOperator(-)(time,timestep) !EX_UTest write(failMsg, *) " startTime not equal to stopTime" write(name, *) "Decrementing stoptime by 73049 days Test" stopTime = stopTime - timeStep ! exercise Time - operator call ESMF_Test((startTime.eq.stopTime), & name, failMsg, result, ESMF_SRCLINE) !call ESMF_TimePrint(stopTime, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(startTime, yy=-100, mm=1, dd=1, & calendar=gregorianCalendar, rc=rc) write(name, *) "Start Time initialization with year = -100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(startTime2, yy=-100, mm=1, dd=1, & calendar=gregorianCalendar, rc=rc) write(name, *) "Start Time initialization with year = -100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(==)(time,time1) write(failMsg, *) "startTime2 should be equal to startTime" write(name, *) "Verifying the EQ operator Test" call ESMF_Test((startTime2.eq.startTime), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time == operator ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(/=)(time,time1) write(failMsg, *) "startTime2 should be equal to startTime" write(name, *) "Verifying the NE operator Test" call ESMF_Test(.not.(startTime2.ne.startTime), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time /= operator ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(startTime2, yy=-100, mm=1, dd=1, s=-1, & calendar=gregorianCalendar, rc=rc) write(name, *) "Start Time initialization with year = -100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(==)(time,time1) write(failMsg, *) "startTime2 should not be equal to startTime" write(name, *) "Verifying the EQ operator Test" call ESMF_Test(.not.(startTime2.eq.startTime), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time == operator ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(/=)(time,time1) write(failMsg, *) "startTime2 should not be equal to startTime" write(name, *) "Verifying the NE operator Test" call ESMF_Test((startTime2.ne.startTime), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time /= operator ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(<)(time,time1) write(failMsg, *) "startTime2 should be less than startTime" write(name, *) "Verifying the LT operator Test" call ESMF_Test((startTime2.lt.startTime), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time < operator ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(<)(time,time1) write(failMsg, *) "startTime2 should be less than startTime" write(name, *) "Verifying the LT operator Test" call ESMF_Test(.not.(startTime.lt.startTime2), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time < operator ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(>)(time,time1) write(failMsg, *) "startTime should be greater than startTime2" write(name, *) "Verifying the GT operator Test" call ESMF_Test((startTime.gt.startTime2), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time > operator ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(>)(time,time1) write(failMsg, *) "startTime should less than startTime2" write(name, *) "Verifying the GT operator Test" call ESMF_Test(.not.(startTime2.gt.startTime), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time > operator ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(<=)(time,time1) write(failMsg, *) "startTime2 should be less than or equal to startTime" write(name, *) "Verifying the LE operator Test" call ESMF_Test((startTime2.le.startTime), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time <= operator ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(<=)(time,time1) write(failMsg, *) "startTime2 should be less than or equal to startTime" write(name, *) "Verifying the LE operator Test" call ESMF_Test(.not.(startTime.le.startTime2), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time <= operator ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(startTime2, yy=-100, mm=1, dd=1, & calendar=gregorianCalendar, rc=rc) write(name, *) "Start Time initialization with year = -100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(<=)(time,time1) write(failMsg, *) "startTime2 should be equal to startTime" write(name, *) "Verifying the LE operator Test" call ESMF_Test((startTime2.le.startTime), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time <= operator ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(>=)(time,time1) write(failMsg, *) "startTime should be greater than or equal to startTime2" write(name, *) "Verifying the GE operator Test" call ESMF_Test((startTime.ge.startTime2), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time >= operator ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(>=)(time,time1) write(failMsg, *) "startTime2 should be greater than or equal to startTime" write(name, *) "Verifying the GE operator Test" call ESMF_Test((startTime2.ge.startTime), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time >= operator ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(startTime2, yy=-100, mm=1, dd=1, & calendar=gregorianCalendar, rc=rc) write(name, *) "Start Time initialization with year = -100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Testing ESMF_TimeOperator(>=)(time,time1) write(failMsg, *) "startTime should equal startTime2" write(name, *) "Verifying the GE operator Test" call ESMF_Test((startTime2.ge.startTime), & name, failMsg, result, ESMF_SRCLINE) ! ^-- exercise Time >= operator ! ---------------------------------------------------------------------------- !EX_UTest ! Validate an uninitialized time write(failMsg, *) "Should not return ESMF_SUCCESS " write(name, *) "Validate an uninitialzed time Test" call ESMF_TimeValidate(stopTime3, rc=rc) call ESMF_Test((rc.eq.ESMF_RC_OBJ_INIT), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(stopTime3, yy=-100, mm=1, dd=1, & calendar=gregorianCalendar, rc=rc) write(name, *) "Stop Time initialization with year = -100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Validate an initialized time write(failMsg, *) "Should return ESMF_SUCCESS " write(name, *) "Validate an initialzed time Test" call ESMF_TimeValidate(stopTime3, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should not return ESMF_SUCCESS." call ESMF_TimeSet(stopTime3, yy=-4900, mm=2, dd=28, & calendar=gregorianCalendar, rc=rc) write(name, *) "Stop Time initialization with year = -4900 Test" !print *, " " call ESMF_Test((rc.eq.ESMC_RC_ARG_OUTOFRANGE), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Validate an initialized time write(failMsg, *) "Should return ESMF_SUCCESS " write(name, *) "Validate an initialzed time Test" call ESMF_TimeValidate(stopTime3, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeIntervalSet(timeStep, yy=10, rc=rc) write(name, *) "Time Step initialization with years = 10 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(startTime, yy=-100, & calendar=gregorianCalendar, rc=rc) write(name, *) "Start Time initialization with year = -100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) !print *, "startTime = " !call ESMF_TimePrint(startTime, options="string", rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." call ESMF_TimeSet(stopTime, yy=100, & calendar=gregorianCalendar, rc=rc) write(name, *) "Stop Time initialization with year = 100 Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) !print *, "stopTime = " !call ESMF_TimePrint(startTime, options="string", rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_SUCCESS." clock_gregorian = ESMF_ClockCreate(timeStep, startTime, & stopTime=stopTime, & name="Gregorian Clock", rc=rc) write(name, *) "Clock initialization with above settings Test" call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest write(failMsg, *) "Should return ESMF_ClockIsStopTime() false." bool = ESMF_ClockIsStopTime(clock_gregorian, rc=rc) write(name, *) "Check mm/dd defaults Test" call ESMF_Test(((rc.eq.ESMF_SUCCESS) .and.(.not.bool)), & name, failMsg, result, ESMF_SRCLINE) !print *, "bool = ", bool call ESMF_ClockDestroy(clock_gregorian, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Millisecond clock test" call ESMF_TimeSet(startTime, yy=2004, mm=9, dd=28, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeSet(stopTime, yy=2004, mm=9, dd=28, & h=0, m=1, calendar=gregorianCalendar, rc=rc) call ESMF_TimeIntervalSet(timeStep, ms=1, rc=rc) clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="Millisecond Clock", rc=rc) if (rc.eq.ESMF_SUCCESS) then ! time step from start time to stop time do while (.not.ESMF_ClockIsStopTime(clock, rc=rc)) call ESMF_ClockAdvance(clock, rc=rc) end do end if !call ESMF_ClockPrint(clock, rc=rc) !call ESMF_ClockPrint(clock, options="currtime string", rc=rc) !call ESMF_ClockPrint(clock, options="timestep", rc=rc) !call ESMF_ClockPrint(clock, options="timestep string", rc=rc) call ESMF_ClockGet(clock, advanceCount=advanceCounts, rc=rc) write(failMsg, *) "Millisecond clock advanced ", advanceCounts, & ", not 60,000 or not ESMF_SUCCESS." call ESMF_Test((advanceCounts.eq.60000.and.rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock, rc=rc) !print *, "Millisecond clock advanced ", advanceCounts, " times." ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Microsecond clock test" call ESMF_TimeSet(startTime, yy=2004, mm=9, dd=28, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeSet(stopTime, yy=2004, mm=9, dd=28, & s=1, calendar=gregorianCalendar, rc=rc) call ESMF_TimeIntervalSet(timeStep, us=100, rc=rc) clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="Microsecond Clock", rc=rc) if (rc.eq.ESMF_SUCCESS) then ! time step from start time to stop time do while (.not.ESMF_ClockIsStopTime(clock, rc=rc)) call ESMF_ClockAdvance(clock, rc=rc) end do end if !call ESMF_ClockPrint(clock, options="currtime string", rc=rc) !call ESMF_ClockPrint(clock, options="timestep", rc=rc) !call ESMF_ClockPrint(clock, options="timestep string", rc=rc) call ESMF_ClockGet(clock, advanceCount=advanceCounts, rc=rc) write(failMsg, *) "Microsecond clock advanced ", advanceCounts, & ", not 10,000 or not ESMF_SUCCESS." call ESMF_Test((advanceCounts.eq.10000.and.rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock, rc=rc) !print *, "Microsecond clock advanced ", advanceCounts, " times." ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Nanosecond clock test" call ESMF_TimeSet(startTime, yy=2004, mm=9, dd=28, ns=10000, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeSet(stopTime, yy=2004, mm=9, dd=28, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeIntervalSet(timeStep, ns=-1, rc=rc) clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="Nanosecond Clock", rc=rc) !call ESMF_ClockPrint(clock, options="currtime string", rc=rc) if (rc.eq.ESMF_SUCCESS) then ! time step from start time to stop time do while (.not.ESMF_ClockIsStopTime(clock, rc=rc)) call ESMF_ClockAdvance(clock, rc=rc) end do end if !call ESMF_ClockPrint(clock, options="currtime string", rc=rc) !call ESMF_ClockPrint(clock, options="timestep", rc=rc) !call ESMF_ClockPrint(clock, options="timestep string", rc=rc) call ESMF_ClockGet(clock, advanceCount=advanceCounts, rc=rc) write(failMsg, *) "Nanosecond clock advanced ", advanceCounts, & ", not 10,000 or not ESMF_SUCCESS." call ESMF_Test((advanceCounts.eq.10000.and.rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) !print *, "Nanosecond clock advanced ", advanceCounts, " times." ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Nanosecond time string test" call ESMF_ClockGet(clock, startTime=startTime, rc=rc) call ESMF_TimeGet(startTime, timeStringISOFrac=timeString, rc=rc) write(failMsg, *) "Nanosecond time string not 2004-09-28T00:00:00.000010000 or not ESMF_SUCCESS." call ESMF_Test((timeString=="2004-09-28T00:00:00.000010000" .and. & rc==ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE) !print *, "timeString = ", timeString !call ESMF_TimePrint(startTime) !call ESMF_TimePrint(startTime, options="string isofrac", rc=rc) call ESMF_ClockDestroy(clock, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Nanosecond time string test 2" call ESMF_TimeGet(startTime, timeString=timeString, rc=rc) write(failMsg, *) "Nanosecond time string not 2004-09-28T00:00:00:1/100000 or not ESMF_SUCCESS." !print *, " " call ESMF_Test((timeString=="2004-09-28T00:00:00:1/100000" .and. & rc==ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE) !call ESMF_TimePrint(startTime) !call ESMF_TimePrint(startTime, options="string", rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Nanosecond time interval string test" call ESMF_TimeIntervalGet(timeStep, timeStringISOFrac=timeString, rc=rc) write(failMsg, *) "Nanosecond time interval string not P0Y0M0DT0H0M-0.000000001S or not ESMF_SUCCESS." call ESMF_Test((timeString=="P0Y0M0DT0H0M-0.000000001S" .and. & rc==ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE) !print *, "timeString = ", timeString !call ESMF_TimeIntervalPrint(timeStep) !call ESMF_TimeIntervalPrint(timeStep, options="string isofrac", rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Nanosecond time interval string test 2" call ESMF_TimeIntervalGet(timeStep, timeString=timeString, rc=rc) write(failMsg, *) "Nanosecond time interval string not P0Y0M0DT0H0M0:-1/1000000000S or not ESMF_SUCCESS." call ESMF_Test((timeString=="P0Y0M0DT0H0M0:-1/1000000000S" .and. & rc==ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE) !call ESMF_TimeIntervalPrint(timeStep) !call ESMF_TimeIntervalPrint(timeStep, options="string", rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Rational fraction time step clock test" call ESMF_TimeSet(startTime, yy=2004, mm=9, dd=28, sN=1, sD=3, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeSet(stopTime, yy=2004, mm=9, dd=28, s=1, sN=2, sD=3, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeIntervalSet(timeStep, sN=1, sD=3, rc=rc) clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="1/3 second Clock", rc=rc) if (rc.eq.ESMF_SUCCESS) then ! time step from start time to stop time do while (.not.ESMF_ClockIsStopTime(clock, rc=rc)) call ESMF_ClockAdvance(clock, rc=rc) end do end if !call ESMF_ClockPrint(clock, options="currtime", rc=rc) !call ESMF_ClockPrint(clock, options="currtime string", rc=rc) !call ESMF_ClockPrint(clock, options="timestep", rc=rc) !call ESMF_ClockPrint(clock, options="timestep string", rc=rc) call ESMF_ClockGet(clock, advanceCount=advanceCounts, rc=rc) write(failMsg, *) "1/3 second clock advanced ", advanceCounts, & ", not 4 times, or not ESMF_SUCCESS." call ESMF_Test((advanceCounts.eq.4.and.rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock, rc=rc) !print *, "1/3 second clock advanced ", advanceCounts, " times." ! ---------------------------------------------------------------------------- !EX_UTest ! Run a clock to add 0.1 to itself 100,000 times. In normal double ! precision arithmetic, this produces 10000.0000000188, not exactly ! 10000.0000000000, due to the inherent error of representing 0.1 ! precisely in binary. Demonstrates the ESMF Time Manager's ability to ! represent and manipulate real numbers internally as integers without ! loss of precision. write(name, *) "Real time step clock test" call ESMF_TimeSet(startTime, s_r8=0.0d0, calendar=noCalendar, rc=rc) call ESMF_TimeIntervalSet(timeStep, s_r8=0.1d0, rc=rc) clock = ESMF_ClockCreate(timeStep, startTime, & runTimeStepCount=100000, name="0.1 second Clock", rc=rc) !call ESMF_ClockPrint(clock, options="currtime", rc=rc) !call ESMF_ClockPrint(clock, options="timestep", rc=rc) if (rc.eq.ESMF_SUCCESS) then ! Run the clock for 100,000 0.1 second time steps do while (.not.ESMF_ClockIsStopTime(clock, rc=rc)) call ESMF_ClockAdvance(clock, rc=rc) end do end if !call ESMF_ClockPrint(clock, options="currtime", rc=rc) call ESMF_ClockGet(clock, advanceCount=advanceCounts, rc=rc) call ESMF_ClockGet(clock, currTime=currentTime, rc=rc) call ESMF_TimeGet(currentTime, s_r8=realSeconds, rc=rc) write(failMsg, *) "advanceCount or ending currentTime incorrect or not ESMF_SUCCESS." call ESMF_Test((advanceCounts.eq.100000.and. & realSeconds.eq.10000.0 & ! exactly! .and.rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock, rc=rc) !print *, "0.1 second clock advanced ", advanceCounts, " times." !print *, "0.1 second clock end time = ", realSeconds, " seconds." ! ---------------------------------------------------------------------------- !EX_UTest ! From Shujia Zhou in Support #1091846, Bug #1099731 write(name, *) "ESMF_TimeGet() Seconds Beyond a Day Test" write(failMsg, *) " currentTime seconds incorrect or ESMF_FAILURE" call ESMF_TimeIntervalSet(timeStep, s=600, calendar=no_leapCalendar,rc=rc) call ESMF_TimeSet(startTime, s=0, calendar=no_leapCalendar, rc=rc) call ESMF_TimeSet(stopTime, s=180000, calendar=no_leapCalendar, rc=rc) topClock = ESMF_ClockCreate(timeStep, startTime, & stopTime=stopTime, name="Top Level Clock", rc=rc) checkSec = 0 testPass = .true. do while (.not. ESMF_ClockIsStopTime(topClock, rc=rc)) call ESMF_ClockGet(topClock, currTime=currentTime) call ESMF_TimeGet(currentTime, s=secs) if (secs .ne. checkSec) then testPass = .false. end if checkSec = checkSec + 600 call ESMF_ClockAdvance(topClock, rc=rc) end do call ESMF_Test(testPass.and.(rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! This checks Tom Henderson's WRF request that a clock be valid at ! the end of a timestep loop when currTime == stopTime. ! Bug #1101839, Support #1099854 write(failMsg, *) " Did not return ESMF_SUCCESS" write(name, *) "Clock Valid at end of Advance Loop Test" call ESMF_ClockValidate(topClock, rc=rc) call ESMF_Test((rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(topClock, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest ! Test fix for Support #1099584, Bug #1101904 "Disable stopTime to make ! clock run forever" requested by Tom Henderson/WRF write(name, *) "Clock stopTime disabled test" call ESMF_TimeSet(startTime, yy=2005, mm=2, dd=3, rc=rc) call ESMF_TimeSet(stopTime, yy=2005, mm=2, dd=4, rc=rc) call ESMF_TimeIntervalSet(timeStep, h=1, rc=rc) clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="Hourly Clock", rc=rc) testPass = .false. clockStopped = .false. if (rc.eq.ESMF_SUCCESS) then ! set clock to run "forever" call ESMF_ClockStopTimeDisable(clock, rc=rc) stopTimeEnabled = ESMF_ClockIsStopTimeEnabled(clock, rc=rc) ! time step from start time to one step beyond stop time do while (.not.clockStopped) call ESMF_ClockAdvance(clock, rc=rc) clockStopped = ESMF_ClockIsStopTime(clock, rc=rc) call ESMF_ClockGet(clock, currTime=currentTime, rc=rc) if (currentTime == (stopTime + timeStep)) then testPass = .true. clockStopped = .true. end if end do end if !call ESMF_ClockPrint(clock, options="currtime string", rc=rc) call ESMF_ClockGet(clock, advanceCount=advanceCounts, rc=rc) !print *, "Hourly clock advanced ", advanceCounts, " times." write(failMsg, *) "Disabled hourly clock advanced ", advanceCounts, & ", not 25 times, or not disabled, or not ESMF_SUCCESS." call ESMF_Test((testPass .and. .not.stopTimeEnabled .and. & advanceCounts.eq.25 .and. rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) ! ---------------------------------------------------------------------------- !EX_UTest ! Test fix for Support #1099584, Bug #1101904 "Disable stopTime to make ! clock run forever" requested by Tom Henderson/WRF write(name, *) "Clock stopTime re-enabled test" testPass = .true. clockStopped = .false. ! re-enable and reset clock stopTime to the next day call ESMF_TimeSet(stopTime, yy=2005, mm=2, dd=5, rc=rc) call ESMF_ClockStopTimeEnable(clock, stopTime=stopTime, rc=rc) stopTimeEnabled = ESMF_ClockIsStopTimeEnabled(clock, rc=rc) ! time step from current time to stop time do while (.not.clockStopped) call ESMF_ClockAdvance(clock, rc=rc) clockStopped = ESMF_ClockIsStopTime(clock, rc=rc) call ESMF_ClockGet(clock, currTime=currentTime, rc=rc) if (currentTime > stopTime) then testPass = .false. clockStopped = .true. end if end do !call ESMF_ClockPrint(clock, options="currtime string", rc=rc) call ESMF_ClockGet(clock, advanceCount=advanceCounts, rc=rc) !print *, "Hourly clock advanced ", advanceCounts, " times." write(failMsg, *) "Re-enabled hourly clock advanced ", advanceCounts, & ", not 48 times, or not enabled, or not ESMF_SUCCESS." call ESMF_Test((testPass .and. stopTimeEnabled .and. & advanceCounts.eq.48 .and. rc.eq.ESMF_SUCCESS), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Reverse day clock test 1" call ESMF_TimeSet(startTime, yy=2005, mm=5, dd=24, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeSet(stopTime, yy=2005, mm=6, dd=24, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeIntervalSet(timeStep, d=1, rc=rc) clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="Day Clock", rc=rc) stepOnePass = .false. stepTwoPass = .false. runTheClock = .true. do while (runTheClock) ! time step from start time to stop time do while (.not.ESMF_ClockIsDone(clock, rc=rc)) call ESMF_ClockAdvance(clock, rc=rc) end do call ESMF_ClockGet(clock, advanceCount=advanceCounts, & direction=direction, rc=rc) if (direction .eq. ESMF_DIRECTION_FORWARD) then !print *, "Reverse clock advanced ", advanceCounts, " times forward." if (advanceCounts .eq. 31 .and. rc .eq. ESMF_SUCCESS) then stepOnePass = .true. end if call ESMF_ClockSet(clock, direction=ESMF_DIRECTION_REVERSE, rc=rc) else !print *, "Reverse clock count is ", advanceCounts, "." if (advanceCounts .eq. 0 .and. rc .eq. ESMF_SUCCESS) then stepTwoPass = .true. end if runTheClock = .false. end if end do write(failMsg, *) "Reverse clock 1 failed." call ESMF_Test((stepOnePass .and. stepTwoPass), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Reverse day clock test 2" call ESMF_TimeSet(startTime, yy=2005, mm=5, dd=24, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeSet(stopTime, yy=2005, mm=6, dd=24, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeIntervalSet(timeStep, d=1, rc=rc) clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="Day Clock", rc=rc) stepOnePass = .false. stepTwoPass = .false. ! time step 2/3 of the way from start time to stop time and back again do while (.not.ESMF_ClockIsDone(clock, rc=rc)) call ESMF_ClockAdvance(clock, rc=rc) call ESMF_ClockGet(clock, advanceCount=advanceCounts, & direction=direction, rc=rc) ! print *, "Reverse clock advanceCount = ", advanceCounts if (direction .eq. ESMF_DIRECTION_FORWARD) then if (advanceCounts .eq. 20 .and. rc .eq. ESMF_SUCCESS) then !print *, "Reverse clock advanced ", advanceCounts, " times forward." stepOnePass = .true. call ESMF_ClockSet(clock, direction=ESMF_DIRECTION_REVERSE, rc=rc) end if else if (advanceCounts .eq. 0 .and. rc .eq. ESMF_SUCCESS) then !print *, "Reverse clock count is ", advanceCounts, "." stepTwoPass = .true. end if end if end do write(failMsg, *) "Reverse clock 2 failed." call ESMF_Test((stepOnePass .and. stepTwoPass), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Reverse day clock test 3" call ESMF_TimeSet(startTime, yy=2005, mm=5, dd=24, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeSet(stopTime, yy=2005, mm=6, dd=24, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeIntervalSet(timeStep, d=1, rc=rc) clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="Day Clock", rc=rc) stepOnePass = .false. stepTwoPass = .false. ! time step 2/3 of the way from start time to stop time, then back 1/3, ! and then forward to stopTime do while (.not.ESMF_ClockIsDone(clock, rc=rc)) call ESMF_ClockAdvance(clock, rc=rc) call ESMF_ClockGet(clock, advanceCount=advanceCounts, & direction=direction, rc=rc) !print *, "Reverse clock advanceCount = ", advanceCounts if (direction .eq. ESMF_DIRECTION_FORWARD) then if (.not.stepOnePass) then if (advanceCounts .eq. 20 .and. rc .eq. ESMF_SUCCESS) then !print *, "Reverse clock advanced ", advanceCounts, " times forward." stepOnePass = .true. call ESMF_ClockSet(clock, direction=ESMF_DIRECTION_REVERSE, rc=rc) end if end if else if (advanceCounts .eq. 10 .and. rc .eq. ESMF_SUCCESS) then !print *, "Reverse clock reversed to ", advanceCounts, "." call ESMF_ClockSet(clock, direction=ESMF_DIRECTION_FORWARD, rc=rc) stepTwoPass = .true. end if end if end do !print *, "Reverse clock ended at advanceCount ", advanceCounts write(failMsg, *) "Reverse clock 3 failed." call ESMF_Test((stepOnePass .and. stepTwoPass .and. & advanceCounts .eq. 31), & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Set runTimeStepCount test 1" call ESMF_TimeSet(startTime, yy=2006, mm=9, dd=8, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeSet(stopTime, yy=2006, mm=9, dd=12, & calendar=gregorianCalendar, rc=rc) call ESMF_TimeIntervalSet(timeStep, h=24, rc=rc) clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, & name="Day Clock", rc=rc) timeStepCount = 2 call ESMF_ClockSet(clock, runTimeStepCount=timeStepCount, rc=rc) do while (.not.ESMF_ClockIsDone(clock, rc=rc)) call ESMF_ClockAdvance(clock, rc=rc) end do call ESMF_ClockGet(clock, advanceCount=advanceCounts, rc=rc) !print *, "advanceCounts = ", advanceCounts write(failMsg, *) "runTimeStepCount test 1 failed." call ESMF_Test(advanceCounts.eq.2 .and. rc.eq.ESMF_SUCCESS, & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock, rc=rc) ! ---------------------------------------------------------------------------- !EX_UTest write(name, *) "Set runTimeStepCount test 2" timeStepCount = 3 clock = ESMF_ClockCreate(timeStep, startTime, & runTimeStepCount=timeStepCount, name="Day Clock", rc=rc) do while (.not.ESMF_ClockIsDone(clock, rc=rc)) call ESMF_ClockAdvance(clock, rc=rc) end do call ESMF_ClockGet(clock, advanceCount=advanceCounts, rc=rc) !print *, "advanceCounts = ", advanceCounts write(failMsg, *) "runTimeStepCount test 2 failed." call ESMF_Test(advanceCounts.eq.3 .and. rc.eq.ESMF_SUCCESS, & name, failMsg, result, ESMF_SRCLINE) call ESMF_ClockDestroy(clock, rc=rc) ! ---------------------------------------------------------------------------- #endif ! destroy calendars call ESMF_CalendarDestroy(gregorianCalendar, rc=rc) call ESMF_CalendarDestroy(julianDayCalendar, rc=rc) call ESMF_CalendarDestroy(no_leapCalendar, rc=rc) call ESMF_CalendarDestroy(esmf_360dayCalendar, rc=rc) call ESMF_CalendarDestroy(noCalendar, rc=rc) ! return number of failures to environment; 0 = success (all pass) ! return result ! TODO: no way to do this in F90 ? ! finalize ESMF framework call ESMF_TestEnd(ESMF_SRCLINE) end program ESMF_ClockTest