program ESMF_AlarmTest
!------------------------------------------------------------------------------
!
#include "ESMF.h"
!==============================================================================
!BOP
! !PROGRAM: ESMF_AlarmTest - Test Alarm functionalities
!
! !DESCRIPTION:
!
! The code in this file drives F90 Alarm unit tests.
!
!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) :: clock1
type(ESMF_Alarm) :: alarm1
! instantiate a calendar
type(ESMF_Calendar) :: gregorianCalendar, julianCalendar, &
no_leapCalendar, esmf_360dayCalendar
! instantiate timestep, start and stop times
type(ESMF_TimeInterval) :: timeStep
type(ESMF_Time) :: startTime, stopTime
type(ESMF_Time) :: alarmTime
logical :: isCreated
#ifdef ESMF_TESTEXHAUSTIVE
logical :: bool
! instantiate a clock
type(ESMF_Clock) :: clock, clock2, clock3, domainClock, CLOCK_ATM
logical :: alarmCountPass, isringing, sticky, enabled
integer(ESMF_KIND_I8) :: forwardCount
logical :: willRingNext, testPass, alarmsNotEqual, alarmsEqual
type(ESMF_Direction_Flag) :: reverseDirection, forwardDirection
type(ESMF_Alarm) :: alarm, alarm2, afterAlarm, beforeAlarm
type(ESMF_Alarm) :: alarmList(201), alarmListOne(1)
type(ESMF_Alarm) :: alarm6, alarm7, alarm8
type(ESMF_Alarm) :: alarm5(200), alarm3, alarm4
type(ESMF_Alarm) :: ALARM_HISTORY
integer(ESMF_KIND_I8) :: reverseCount, iteration
integer :: dd, nclock, ringCount, expectedCount, i, yy
integer :: mm, m, h, sstep, nstep, nring, alarmCount
! instantiate timestep, start and stop times
type(ESMF_TimeInterval) :: TIMEINTERVAL_HISTORY, alarmStep, alarmStep2
type(ESMF_TimeInterval) :: runDuration, ringDuration
type(ESMF_Time) :: currentTime, currTime, afterAlarmTime, beforeAlarmTime
type(ESMF_Time) :: alarmStopTime, nextTime, prevTime, currentTime2, time1
character(ESMF_MAXSTR) :: aName
#endif
! initialize ESMF framework
call ESMF_TestStart(ESMF_SRCLINE, rc=rc)
if (rc /= ESMF_SUCCESS) call ESMF_Finalize(endflag=ESMF_END_ABORT)
! initialize one calendar to be Gregorian type
gregorianCalendar = ESMF_CalendarCreate(ESMF_CALKIND_GREGORIAN, &
name="Gregorian", rc=rc)
! initialize secand calendar to be Julian type
julianCalendar = 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)
!-------------------------------------------------------------------------------
! 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, *) " Did not return ESMF_SUCCESS"
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)
! ----------------------------------------------------------------------------
!NEX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Stop Time Initialization Test"
call ESMF_TimeSet(stopTime, yy=2003, mm=3, dd=24, &
calendar=gregorianCalendar, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!NEX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Alarm Time Initialization Test"
call ESMF_TimeSet(alarmTime, yy=2003, mm=9, dd=15, &
calendar=gregorianCalendar, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!NEX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Clock Initialization Test"
clock1 = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 1", rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!NEX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Create Alarm Test"
alarm1 = ESMF_AlarmCreate(name="WAKEUP", clock=clock1, ringTime=alarmTime, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!NEX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Destroy Alarm Test"
call ESMF_AlarmDestroy(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
!------------------------------------------------------------------------
!NEX_UTest
write(name, *) "Testing Alarm IsCreated for uncreated object"
write(failMsg, *) "Did not return .false."
isCreated = ESMF_AlarmIsCreated(alarm1)
call ESMF_Test((isCreated .eqv. .false.), name, failMsg, result, ESMF_SRCLINE)
!------------------------------------------------------------------------
!------------------------------------------------------------------------
!NEX_UTest
write(name, *) "Testing Alarm IsCreated for uncreated object"
write(failMsg, *) "Did not return ESMF_SUCCESS"
isCreated = ESMF_AlarmIsCreated(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE)
!------------------------------------------------------------------------
!------------------------------------------------------------------------
!NEX_UTest
write(name, *) "Create test Alarm for IsCreated"
write(failMsg, *) "Did not return ESMF_SUCCESS"
alarm1 = ESMF_AlarmCreate(name="WAKEUP", clock=clock1, ringTime=alarmTime, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE)
!------------------------------------------------------------------------
!------------------------------------------------------------------------
!NEX_UTest
write(name, *) "Testing Alarm IsCreated for created object"
write(failMsg, *) "Did not return .true."
isCreated = ESMF_AlarmIsCreated(alarm1)
call ESMF_Test((isCreated .eqv. .true.), name, failMsg, result, ESMF_SRCLINE)
!------------------------------------------------------------------------
!------------------------------------------------------------------------
!NEX_UTest
write(name, *) "Testing Alarm IsCreated for created object"
write(failMsg, *) "Did not return ESMF_SUCCESS"
isCreated = ESMF_AlarmIsCreated(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE)
!------------------------------------------------------------------------
!------------------------------------------------------------------------
!NEX_UTest
write(name, *) "Destroy test Alarm for IsCreated"
write(failMsg, *) "Did not return ESMF_SUCCESS"
call ESMF_AlarmDestroy(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE)
!------------------------------------------------------------------------
!------------------------------------------------------------------------
!NEX_UTest
write(name, *) "Testing Alarm IsCreated for destroyed object"
write(failMsg, *) "Did not return .false."
isCreated = ESMF_AlarmIsCreated(alarm1)
call ESMF_Test((isCreated .eqv. .false.), name, failMsg, result, ESMF_SRCLINE)
!------------------------------------------------------------------------
!------------------------------------------------------------------------
!NEX_UTest
write(name, *) "Testing Alarm IsCreated for destroyed object"
write(failMsg, *) "Did not return ESMF_SUCCESS"
isCreated = ESMF_AlarmIsCreated(alarm1, 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_SUCCESS and alarmCount = 0"
write(name, *) "Get number of alarms after destroyed Alarm Test"
call ESMF_ClockGet(clock1, alarmCount=alarmCount, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS.and.alarmCount.eq.0), &
name, failMsg, result, ESMF_SRCLINE)
!print *, "alarmCount = ", alarmCount
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_FAILURE"
write(name, *) "Get a destroyed Alarm Test"
call ESMF_ClockGetAlarm(clock1, "WAKEUP", alarm=alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_FAILURE), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Advance clock after destroyed alarm test"
call ESMF_ClockAdvance(clock1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_RC_OBJ_DELETED"
write(name, *) "Destroy a destroyed Alarm Test"
call ESMF_AlarmDestroy(alarm1, 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, *) "Destroy a non-created Alarm Test"
call ESMF_AlarmDestroy(alarm6, 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, *) "Check if destroyed Alarm is sticky Test"
sticky = ESMF_AlarmIsSticky(alarm1, 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, *) "Check if non-created Alarm is sticky Test"
sticky = ESMF_AlarmIsSticky(alarm6, 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, *) "Validate destroyed Alarm Test"
call ESMF_AlarmValidate(alarm1, 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, *) "Validate non-created Alarm Test"
call ESMF_AlarmValidate(alarm6, 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, *) "Check if destroyed Alarm is enabled Test"
enabled = ESMF_AlarmIsEnabled(alarm1, 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, *) "Check if non-created Alarm is enabled Test"
enabled = ESMF_AlarmIsEnabled(alarm6, 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, *) "Check if destroyed Alarm is not ringing Test"
isringing = ESMF_AlarmIsRinging(alarm1, 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, *) "Check if non-created Alarm is not ringing Test"
isringing = ESMF_AlarmIsRinging(alarm6, 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, *) "Get name of destroyed Alarm Test"
call ESMF_AlarmGet(alarm1, name=aName, 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, *) "Get name of destroyed Alarm Test"
call ESMF_AlarmGet(alarm6, name=aName, 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 name of destroyed Alarm Test"
call ESMF_AlarmSet(alarm1, name="ALARM1", 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 name of non-created Alarm Test"
call ESMF_AlarmSet(alarm6, name="ALARM1", 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, *) "Turn on Ringing on destroyed Alarm "
call ESMF_AlarmRingerOn(alarm1, 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, *) "Turn on Ringing on non-created Alarm "
call ESMF_AlarmRingerOn(alarm6, 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, *) "Turn off Ringing on destroyed Alarm "
call ESMF_AlarmRingerOff(alarm1, 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, *) "Turn off Ringing on non-created Alarm "
call ESMF_AlarmRingerOff(alarm6, 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, *) "Enable destroyed Alarm Test"
call ESMF_AlarmEnable(alarm1, 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, *) "Enable non-create Alarm Test"
call ESMF_AlarmEnable(alarm6, 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, *) "Check if destroyed Alarm is enabled Test"
enabled = ESMF_AlarmIsEnabled(alarm1, 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, *) "Check if non-created Alarm is enabled Test"
enabled = ESMF_AlarmIsEnabled(alarm6, 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, *) "Disable destroyed Alarm Test"
call ESMF_AlarmDisable(alarm1, 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, *) "Disable non-created Alarm Test"
call ESMF_AlarmDisable(alarm6, rc=rc)
call ESMF_Test((rc.eq.ESMF_RC_OBJ_NOT_CREATED), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test if destroyed Alarm Previously ringing
write(failMsg, *) " Did not return ESMF_RC_OBJ_DELETED"
write(name, *) "Destroyed Alarm Was Previously ringing Test"
bool = ESMF_AlarmWasPrevRinging(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_RC_OBJ_DELETED), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test if non-created Alarm Previously ringing
write(failMsg, *) " Did not return ESMF_RC_OBJ_NOT_CREATED"
write(name, *) "Non-created Alarm Was Previously ringing Test"
bool = ESMF_AlarmWasPrevRinging(alarm6, 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, *) "Turn off Ringing on destroyed Alarm "
call ESMF_AlarmRingerOff(alarm1, 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, *) "Turn off Ringing on non-created Alarm "
call ESMF_AlarmRingerOff(alarm6, rc=rc)
call ESMF_Test((rc.eq.ESMF_RC_OBJ_NOT_CREATED), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test destroyed Alarm will ring next
write(failMsg, *) " Did not return ESMF_RC_OBJ_DELETED"
write(name, *) "Destroyed Alarm will ring next Test"
willRingNext = ESMF_AlarmWillRingNext(alarm1, timeStep=timeStep, rc=rc)
call ESMF_Test((rc.eq.ESMF_RC_OBJ_DELETED), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test non-created Alarm will ring next
write(failMsg, *) " Did not return ESMF_RC_OBJ_NOT_CREATED"
write(name, *) "Non-created Alarm will ring next Test"
willRingNext = ESMF_AlarmWillRingNext(alarm6, timeStep=timeStep, 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_SUCCESS"
write(name, *) "Create Alarm Test"
alarm1 = ESMF_AlarmCreate(name="WAKEUP1", clock=clock1, ringTime=alarmTime, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Create Alarm Test"
alarm3 = ESMF_AlarmCreate(name="WAKEUP3", clock=clock1, ringTime=alarmTime, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Create Alarm Copy Test"
alarm2 = ESMF_AlarmCreate(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Clock Get Alarm List Test 1 - optional args missing"
call ESMF_ClockGetAlarmList(clock1, ESMF_ALARMLIST_ALL, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Clock Get Alarm List Test 2 - only alarmList specified"
call ESMF_ClockGetAlarmList(clock1, ESMF_ALARMLIST_ALL, &
alarmList=alarmList, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS and alarmCount=3"
write(name, *) "Clock Get Alarm List Test 3 - only alarmCount specified"
call ESMF_ClockGetAlarmList(clock1, ESMF_ALARMLIST_ALL, &
alarmCount=alarmCount, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS.and.alarmCount.eq.3), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS and alarmCount=1"
write(name, *) "Clock Get Alarm List Test 4 - single-element length alarmList specified"
call ESMF_AlarmRingerOn(alarm1, rc=rc)
call ESMF_ClockGetAlarmList(clock1, ESMF_ALARMLIST_RINGING, &
alarmList=alarmListOne, &
alarmCount=alarmCount, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS.and.alarmCount.eq.1), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmRingerOff(alarm1, rc=rc)
!call ESMF_AlarmPrint(alarmListOne(1), options="name", rc=rc)
!print *, "alarmCount = ", alarmCount
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS and alarmCount = 3"
write(name, *) "Clock Get Alarm List Test 5"
call ESMF_ClockGetAlarmList(clock1, ESMF_ALARMLIST_ALL, &
alarmList=alarmList, alarmCount=alarmCount, &
rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS.and.alarmCount.eq.3), &
name, failMsg, result, ESMF_SRCLINE)
!call ESMF_AlarmPrint(alarmList(1), options="name", rc=rc)
!call ESMF_AlarmPrint(alarmList(2), options="name", rc=rc)
!call ESMF_AlarmPrint(alarmList(3), options="name", rc=rc)
!print *, "alarmCount = ", alarmCount
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmAssignment(=)(alarm,alarm)
write(failMsg, *) "Returned not equal"
write(name, *) "Alarm Assignment Test"
alarm8 = alarm1 ! exercise default F90 Alarm = assignment
call ESMF_AlarmGet(alarm8, name=aName, clock=clock3, &
ringTime=time1, rc=rc)
call ESMF_Test((alarm8==alarm1 .and. aName=="WAKEUP1" .and. &
clock3==clock1 .and. time1==alarmTime), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(==)(alarm1,alarm2)
write(failMsg, *) "Returned not equal"
write(name, *) "Alarms Equal Test"
alarmsEqual = (alarm1 == alarm2) ! exercise Alarm == operator
call ESMF_Test((alarmsEqual), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(==)(alarm1,alarm2)
write(failMsg, *) "Returned equal"
write(name, *) "Alarms Not Equal Test"
alarmsEqual = (alarm1 == alarm3) ! exercise Alarm == operator
call ESMF_Test((.not.alarmsEqual), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(/=)(alarm1,alarm2)
write(failMsg, *) "Returned not equal"
write(name, *) "Alarms Equal Test"
alarmsNotEqual = (alarm1 /= alarm2) ! exercise Alarm /= operator
call ESMF_Test((.not.alarmsNotEqual), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(alarm2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(/=)(alarm1,alarm2)
write(failMsg, *) "Returned equal"
write(name, *) "Alarms Not Equal Test"
alarmsNotEqual = (alarm1 /= alarm3) ! exercise Alarm /= operator
call ESMF_Test((alarmsNotEqual), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(alarm3, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(==)(alarm,alarm1)
write(failMsg, *) "Returned equal"
write(name, *) "Deleted Alarm Not Equal Created Alarm Test 1"
alarmsEqual = (alarm2 == alarm1) ! exercise Alarm == operator
call ESMF_Test((.not.alarmsEqual), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(==)(alarm,alarm1)
write(failMsg, *) "Returned equal"
write(name, *) "Deleted Alarm Not Equal Uncreated Alarm Test 1"
alarmsEqual = (alarm3 == alarm7) ! exercise Alarm == operator
call ESMF_Test((.not.alarmsEqual), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(==)(alarm,alarm1)
write(failMsg, *) "Returned equal"
write(name, *) "Uncreated Alarm Not Equal Created Alarm Test 1"
alarmsEqual = (alarm7 == alarm1) ! exercise Alarm == operator
call ESMF_Test((.not.alarmsEqual), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(==)(alarm,alarm1)
write(failMsg, *) "Returned not equal"
write(name, *) "Deleted Alarm Equal Deleted Alarm Test 1"
alarmsEqual = (alarm2 == alarm3) ! exercise Alarm == operator
call ESMF_Test((alarmsEqual), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(==)(alarm,alarm1)
write(failMsg, *) "Returned not equal"
write(name, *) "Uncreated Alarm Equal Uncreated Alarm Test 1"
alarmsEqual = (alarm7 == alarm7) ! exercise Alarm == operator
call ESMF_Test((alarmsEqual), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(/=)(alarm,alarm1)
write(failMsg, *) "Returned equal"
write(name, *) "Deleted Alarm Not Equal Created Alarm Test 2"
alarmsNotEqual = (alarm2 /= alarm1) ! exercise Alarm /= operator
call ESMF_Test((alarmsNotEqual), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(/=)(alarm,alarm1)
write(failMsg, *) "Returned equal"
write(name, *) "Deleted Alarm Not Equal Uncreated Alarm Test 2"
alarmsNotEqual = (alarm3 /= alarm7) ! exercise Alarm /= operator
call ESMF_Test((alarmsNotEqual), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(/=)(alarm,alarm1)
write(failMsg, *) "Returned equal"
write(name, *) "Uncreated Alarm Not Equal Created Alarm Test 2"
alarmsNotEqual = (alarm7 /= alarm1) ! exercise Alarm /= operator
call ESMF_Test((alarmsNotEqual), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(/=)(alarm,alarm1)
write(failMsg, *) "Returned not equal"
write(name, *) "Deleted Alarm Equal Deleted Alarm Test 2"
alarmsNotEqual = (alarm2 /= alarm3) ! exercise Alarm /= operator
call ESMF_Test((.not.alarmsNotEqual), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
! Testing ESMF_AlarmOperator(/=)(alarm,alarm1)
write(failMsg, *) "Returned equal"
write(name, *) "Uncreated Alarm Equal Uncreated Alarm Test 2"
alarmsNotEqual = (alarm7 /= alarm7) ! exercise Alarm /= operator
call ESMF_Test((.not.alarmsNotEqual), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Validate Alarm Test"
call ESMF_AlarmValidate(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS or returned not sticky"
write(name, *) "Check if Alarm is sticky Test"
sticky = ESMF_AlarmIsSticky(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(sticky), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS or returned not enabled"
write(name, *) "Check if Alarm is enabled Test"
enabled = ESMF_AlarmIsEnabled(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(enabled), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Set Alarm not sticky Test"
call ESMF_AlarmNotSticky(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS or name is not correct"
write(name, *) "Get Alarm name Test"
call ESMF_AlarmGet(alarm1, name=aName, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(aName.eq."WAKEUP1"), &
name, failMsg, result, ESMF_SRCLINE)
!print *, "Alarm name is ", aName
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS or name is not correct"
write(name, *) "Set Alarm name Test"
call ESMF_AlarmSet(alarm1, name="ALARM1", rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS or name is not correct"
write(name, *) "Get Alarm name Test"
call ESMF_AlarmGet(alarm1, name=aName, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(aName.eq."ALARM1"), &
name, failMsg, result, ESMF_SRCLINE)
!print *, "Alarm name is ", aName
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS or returned sticky"
write(name, *) "Check if Alarm is not sticky Test"
sticky = ESMF_AlarmIsSticky(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(.not.sticky), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Set Alarm sticky Test"
call ESMF_AlarmSticky(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS or returned not sticky"
write(name, *) "Check if Alarm is sticky Test"
sticky = ESMF_AlarmIsSticky(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(sticky), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS or is ringing"
write(name, *) "Check if Alarm is not ringing Test"
isringing = ESMF_AlarmIsRinging(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(.not.isringing), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Turn on Ringing Alarm "
call ESMF_AlarmRingerOn(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS or its not ringing"
write(name, *) "Check if Alarm is ringing Test"
isringing = ESMF_AlarmIsRinging(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(isringing), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Turn off Ringing Alarm "
call ESMF_AlarmRingerOff(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS or its ringing"
write(name, *) "Check if Alarm is not ringing Test"
isringing = ESMF_AlarmIsRinging(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(.not.isringing), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Enable Alarm Test"
call ESMF_AlarmEnable(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS or returned enabled"
write(name, *) "Check if Alarm is enabled Test"
enabled = ESMF_AlarmIsEnabled(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(enabled), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Alarm Print Test"
call ESMF_AlarmPrint(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Disable Alarm Test"
call ESMF_AlarmDisable(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS or returned enabled"
write(name, *) "Check if Alarm is disabled Test"
enabled = ESMF_AlarmIsEnabled(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(.not.enabled), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Destroy Alarm Test"
call ESMF_AlarmDestroy(alarm1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Destroy Clock Test"
call ESMF_ClockDestroy(clock1, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_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)
! ----------------------------------------------------------------------------
!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=1, m=45, s=27, &
calkindflag=ESMF_CALKIND_GREGORIAN, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
! Test Setting the Stop Time
write(failMsg, *) " Returned ESMF_FAILURE"
write(name, *) "Set Stop Time Initialization Test"
call ESMF_TimeSet(stopTime, 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)
! ----------------------------------------------------------------------------
!EX_UTest
! Test Setting the Alarm Time
write(failMsg, *) " Returned ESMF_FAILURE"
write(name, *) "Set Alarm Time Initialization Test"
call ESMF_TimeSet(alarmTime, yy=2003, mm=3, dd=13, h=5, &
calkindflag=ESMF_CALKIND_GREGORIAN, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
! Initialize clock
!EX_UTest
write(name, *) "Clock Initialization Test"
write(failMsg, *) " Did not return ESMF_SUCCESS"
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, *) " Did not return ESMF_SUCCESS"
write(name, *) "Sticky Alarm Time Initialization Test"
alarm = ESMF_AlarmCreate(name="alarm1", clock=clock, ringTime=alarmTime, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Get Alarm Test"
call ESMF_ClockGetAlarm(clock, alarmname="alarm1", alarm=alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm will ring next
call ESMF_ClockAdvance(clock, rc=rc)
call ESMF_ClockAdvance(clock, rc=rc)
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm will ring next Test"
willRingNext = ESMF_AlarmWillRingNext(alarm, timeStep=timeStep, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(.not.willRingNext), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Get Clock Next Time
write(failMsg, *) " Did not return ESMF_SUCCESS)"
write(name, *) "Get Clock Next Time Test"
call ESMF_ClockGetNextTime(clock, nextTime, timeStep=timeStep, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm will ring next
call ESMF_ClockAdvance(clock, rc=rc)
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm will ring next Test"
willRingNext = ESMF_AlarmWillRingNext(alarm, timeStep=timeStep, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(willRingNext), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Get Time from clock
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Get Clock Current Time Test"
call ESMF_ClockGet(clock, currTime=currentTime, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test that Clock Get Next Time Passed
!Testing ESMF_TimeOperator(==)(time1,time2)
write(failMsg, *) " Next Time not equal to current Time"
write(name, *) "Get Clock Next Time Test"
bool = (nextTime == currentTime) ! exercising Time == operator
call ESMF_Test((bool), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm ringing
call ESMF_ClockAdvance(clock, rc=rc)
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm is ringing Test"
bool = ESMF_AlarmIsRinging(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(bool), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm still ringing
call ESMF_ClockAdvance(clock, rc=rc)
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm is still ringing Test"
bool = ESMF_AlarmIsRinging(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(bool), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm Previously ringing
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm Was Previously ringing Test"
bool = ESMF_AlarmWasPrevRinging(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(bool), &
name, failMsg, result, ESMF_SRCLINE)
!print *, "bool is ", bool
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm Previously ringing
call ESMF_ClockAdvance(clock, rc=rc)
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm Was Previously ringing Test"
bool = ESMF_AlarmWasPrevRinging(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(bool), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm still ringing
call ESMF_ClockAdvance(clock, rc=rc)
call ESMF_ClockAdvance(clock, rc=rc)
call ESMF_ClockAdvance(clock, rc=rc)
call ESMF_ClockAdvance(clock, rc=rc)
call ESMF_ClockAdvance(clock, rc=rc)
call ESMF_ClockAdvance(clock, rc=rc)
call ESMF_ClockAdvance(clock, rc=rc)
call ESMF_ClockAdvance(clock, rc=rc)
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm is still ringing Test"
bool = ESMF_AlarmIsRinging(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(bool), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Turn off Ringing Alarm "
call ESMF_AlarmRingerOff(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not return ESMF_SUCCESS or its ringing"
write(name, *) "Check if Alarm is not ringing Test"
isringing = ESMF_AlarmIsRinging(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(.not.isringing), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm Previously ringing
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm Was Previously ringing Test"
bool = ESMF_AlarmWasPrevRinging(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(bool), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm Previously ringing
call ESMF_ClockAdvance(clock, rc=rc)
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm Was Previously ringing Test"
bool = ESMF_AlarmWasPrevRinging(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(bool), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm Previously ringing
call ESMF_ClockAdvance(clock, rc=rc)
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm Was Previously ringing Test"
bool = ESMF_AlarmWasPrevRinging(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(.not.bool), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy (alarm, rc=rc)
call ESMF_ClockDestroy (clock, rc=rc)
! ----------------------------------------------------------------------------
! Initialize clock
!EX_UTest
write(name, *) "Clock Initialization Test"
write(failMsg, *) " Did not return ESMF_SUCCESS"
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, *) " Did not return ESMF_SUCCESS"
write(name, *) "Non-Sticky Alarm Time Initialization Test"
alarm = ESMF_AlarmCreate(name="alarm1", clock=clock, &
ringTime=alarmTime, sticky=.FALSE., rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm will ring next
call ESMF_ClockAdvance(clock, rc=rc)
call ESMF_ClockAdvance(clock, rc=rc)
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm will ring next Test"
willRingNext = ESMF_AlarmWillRingNext(alarm, timeStep=timeStep, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(.not.willRingNext), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm will ring next
call ESMF_ClockAdvance(clock, rc=rc)
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm will ring next Test"
willRingNext = ESMF_AlarmWillRingNext(alarm, timeStep=timeStep, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(willRingNext), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm ringing
call ESMF_ClockAdvance(clock, rc=rc)
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm is ringing Test"
bool = ESMF_AlarmIsRinging(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(bool), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm still ringing
call ESMF_ClockAdvance(clock, rc=rc)
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm is still ringing Test"
bool = ESMF_AlarmIsRinging(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(.not.bool), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm Previously ringing
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm Was Previously ringing Test"
bool = ESMF_AlarmWasPrevRinging(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(bool), &
name, failMsg, result, ESMF_SRCLINE)
!print *, "bool is ", bool
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm Previously ringing
call ESMF_ClockAdvance(clock, rc=rc)
write(failMsg, *) " Did not return ESMF_SUCCESS or returned wrong state"
write(name, *) "Alarm Was Previously ringing Test"
bool = ESMF_AlarmWasPrevRinging(alarm, rc=rc)
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(.not.bool), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test destroying alarm
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Destroying alarm test"
call ESMF_AlarmDestroy (alarm, rc=rc)
call ESMF_Test(rc == ESMF_SUCCESS, name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test destroying clock after alarm
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Destroying clock after alarm test"
call ESMF_ClockDestroy (clock, rc=rc)
call ESMF_Test(rc == ESMF_SUCCESS, name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Non-Sticky Alarms 1
! from Chris Hill via support issue 988241, bug 996229
write(failMsg, *) " Did not return nstep=48, sstep=73, i=144, and ESMF_SUCCESS"
write(name, *) "Non-Sticky Alarm Test 1"
call ESMF_TimeIntervalSet(timeStep, s=100, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, s=150, rc=rc)
call ESMF_TimeSet(startTime, yy=1999, mm=12, dd=31, h=23, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2000, mm=1, dd=1, h=3, &
calendar=gregorianCalendar, rc=rc)
clock2=ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 2", rc=rc)
call ESMF_TimeSet(alarmTime, yy=2000, mm=1, dd=1, h=1, &
calendar=gregorianCalendar, rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, &
ringInterval=alarmStep, sticky=.false., rc=rc)
! number of clock time steps alarm rings for
nstep = 0
! starting time step number for first alarm ring
sstep = 0
! total clock time steps
i = 0
! run the clock
do while (.not. ESMF_ClockIsStopTime(clock2, rc=rc))
i = i + 1
call ESMF_ClockGetAlarmList(clock2, ESMF_ALARMLIST_RINGING, &
alarmList=alarmList, &
alarmCount=alarmCount, rc=rc)
if (alarmCount .gt. 0) then
if (sstep .eq. 0) sstep = i
nstep = nstep + 1
endif
call ESMF_ClockAdvance(clock2, rc=rc)
enddo
call ESMF_Test((rc.eq.ESMF_SUCCESS) &
.and.(nstep.eq.48).and.(sstep.eq.73).and.(i.eq.144), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Non-Sticky Alarms 2
! Test ringDuration and stopTime
write(failMsg, *) " Did not return nstep=12 and ESMF_SUCCESS"
write(name, *) "Non-Sticky Alarm Test 2"
call ESMF_TimeIntervalSet(timeStep, m=15, rc=rc)
call ESMF_TimeSet(startTime, yy=1999, mm=12, dd=31, h=23, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2000, mm=1, dd=1, h=23, &
calendar=gregorianCalendar, rc=rc)
clock2 = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 2", rc=rc)
call ESMF_TimeSet(alarmTime, yy=2000, mm=1, dd=1, h=1, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, h=2, rc=rc)
call ESMF_TimeIntervalSet(ringDuration, m=30, rc=rc)
call ESMF_TimeSet(alarmStopTime, yy=2000, mm=1, dd=1, h=13, &
calendar=gregorianCalendar, rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, &
ringInterval=alarmStep, &
ringDuration=ringDuration, &
stopTime=alarmStopTime, sticky=.false., rc=rc)
! number of clock time steps alarm rings for
nstep = 0
! run the clock
do while (.not. ESMF_ClockIsStopTime(clock2, rc=rc))
if (ESMF_AlarmIsRinging(alarm4)) then
nstep = nstep + 1
endif
call ESMF_ClockAdvance(clock2, rc=rc)
enddo
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(nstep.eq.12), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Non-Sticky Alarms 3
! Test ringTimeStepCount and stopTime
write(failMsg, *) " Did not return nstep=18 and ESMF_SUCCESS"
write(name, *) "Non-Sticky Alarm Test 3"
call ESMF_TimeIntervalSet(timeStep, m=15, rc=rc)
call ESMF_TimeSet(startTime, yy=1999, mm=12, dd=31, h=23, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2000, mm=1, dd=1, h=23, &
calendar=gregorianCalendar, rc=rc)
clock2=ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 2", rc=rc)
call ESMF_TimeSet(alarmTime, yy=2000, mm=1, dd=1, h=1, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, h=2, rc=rc)
call ESMF_TimeSet(alarmStopTime, yy=2000, mm=1, dd=1, h=13, &
calendar=gregorianCalendar, rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, &
ringInterval=alarmStep, &
ringTimeStepCount=3, &
stopTime=alarmStopTime, sticky=.false., rc=rc)
! number of clock time steps alarm rings for
nstep = 0
! run the clock
do while (.not. ESMF_ClockIsStopTime(clock2, rc=rc))
if (ESMF_AlarmIsRinging(alarm4)) then
nstep = nstep + 1
endif
call ESMF_ClockAdvance(clock2, rc=rc)
enddo
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(nstep.eq.18), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Non-Sticky Alarms 4
! Test ringTimeStepCount precedence over ringDuration
write(failMsg, *) " Did not return nstep=18 and ESMF_SUCCESS"
write(name, *) "Non-Sticky Alarm Test 4"
call ESMF_TimeIntervalSet(timeStep, m=15, rc=rc)
call ESMF_TimeSet(startTime, yy=1999, mm=12, dd=31, h=23, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2000, mm=1, dd=1, h=23, &
calendar=gregorianCalendar, rc=rc)
clock2=ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 2", rc=rc)
call ESMF_TimeSet(alarmTime, yy=2000, mm=1, dd=1, h=1, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, h=2, rc=rc)
call ESMF_TimeIntervalSet(ringDuration, m=30, rc=rc)
call ESMF_TimeSet(alarmStopTime, yy=2000, mm=1, dd=1, h=13, &
calendar=gregorianCalendar, rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, &
ringInterval=alarmStep, &
ringTimeStepCount=3, &
ringDuration=ringDuration, &
stopTime=alarmStopTime, sticky=.false., rc=rc)
! number of clock time steps alarm rings for
nstep = 0
! run the clock
do while (.not. ESMF_ClockIsStopTime(clock2, rc=rc))
if (ESMF_AlarmIsRinging(alarm4)) then
nstep = nstep + 1
endif
call ESMF_ClockAdvance(clock2, rc=rc)
enddo
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(nstep.eq.18), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Non-Sticky Alarms 5
! Test reverse non-sticky alarm
write(failMsg, *) "Did not return nstep=24, forwardCount=96, reverseCount=0, etc., and ESMF_SUCCESS"
write(name, *) "Non-Sticky Alarm Test 5"
call ESMF_TimeIntervalSet(timeStep, m=15, rc=rc)
call ESMF_TimeSet(startTime, yy=1999, mm=12, dd=31, h=23, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2000, mm=1, dd=1, h=23, &
calendar=gregorianCalendar, rc=rc)
clock2 = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 2", rc=rc)
call ESMF_TimeSet(alarmTime, yy=2000, mm=1, dd=1, h=1, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, h=2, rc=rc)
call ESMF_TimeIntervalSet(ringDuration, m=30, rc=rc)
call ESMF_TimeSet(alarmStopTime, yy=2000, mm=1, dd=1, h=13, &
calendar=gregorianCalendar, rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, &
ringInterval=alarmStep, &
ringDuration=ringDuration, &
stopTime=alarmStopTime, sticky=.false., rc=rc)
! number of clock time steps alarm rings for
nstep = 0
! number of times the clock has been run
nclock = 0
do while (nclock < 2)
! run the clock
do while (.not. ESMF_ClockIsDone(clock2, rc=rc))
!call ESMF_ClockGet(clock2, currTime=currentTime, rc=rc)
!call ESMF_TimeGet(currentTime, yy=yy, mm=mm, dd=dd, h=h, m=m, rc=rc)
!print *, mm, "/", dd, "/", yy, " ", h, ":", m
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_AlarmIsRinging(alarm4)) then
nstep = nstep + 1
!print *, "on"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
else
!print *, "off"
endif
!call ESMF_AlarmPrint(alarm4, options="ringtime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockAdvance(clock2, rc=rc)
enddo
if (nclock.eq.0) then
call ESMF_ClockGet(clock2, direction=forwardDirection, &
advanceCount=forwardCount, rc=rc)
!print *, "forwardCount = ", forwardCount
else
call ESMF_ClockGet(clock2, direction=reverseDirection, &
advanceCount=reverseCount, rc=rc)
!print *, "reverseCount = ", reverseCount
endif
call ESMF_ClockSet(clock2, direction=ESMF_DIRECTION_REVERSE, rc=rc)
nclock = nclock + 1
enddo
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(nstep.eq.24).and. &
(forwardCount.eq.96).and.(reverseCount.eq.0).and. &
(forwardDirection.eq.ESMF_DIRECTION_FORWARD).and. &
(reverseDirection.eq.ESMF_DIRECTION_REVERSE).and. &
ESMF_ClockIsReverse(clock2), &
name, failMsg, result, ESMF_SRCLINE)
!print *, "nstep = ", nstep, " nclock = ", nclock
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Non-Sticky Alarms 6
! Test reverse non-sticky alarm with negative timestep
write(failMsg, *) "Did not return nring=48, forwardCount=96, reverseCount=0, etc., and ESMF_SUCCESS"
write(name, *) "Non-Sticky Alarm Test 6"
call ESMF_TimeIntervalSet(timeStep, m=-15, rc=rc)
call ESMF_TimeSet(startTime, yy=2000, mm=1, dd=1, h=23, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=1999, mm=12, dd=31, h=23, &
calendar=gregorianCalendar, rc=rc)
clock2 = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 2", rc=rc)
call ESMF_TimeSet(alarmTime, yy=2000, mm=1, dd=1, h=23, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, h=-2, rc=rc)
call ESMF_TimeIntervalSet(ringDuration, m=-30, rc=rc)
call ESMF_TimeSet(alarmStopTime, yy=1999, mm=12, dd=31, h=21, &
calendar=gregorianCalendar, rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, &
ringInterval=alarmStep, &
ringDuration=ringDuration, &
stopTime=alarmStopTime, &
sticky=.false., rc=rc)
! number of clock time steps alarm rings for
nring = 0
! number of times the clock has been run
nclock = 0
do while (nclock < 2)
! run the clock
do while (.not. ESMF_ClockIsDone(clock2, rc=rc))
call ESMF_ClockGet(clock2, currTime=currentTime, rc=rc)
call ESMF_TimeGet(currentTime, yy=yy, mm=mm, dd=dd, h=h, m=m, rc=rc)
!print *, mm, "/", dd, "/", yy, " ", h, ":", m
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_AlarmIsRinging(alarm4)) then
nring = nring + 1
!print *, "ringing!"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
endif
!call ESMF_AlarmPrint(alarm4, options="ringbegin string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_AlarmPrint(alarm4, options="ringtime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockAdvance(clock2, rc=rc)
enddo
if (nclock.eq.0) then
call ESMF_ClockGet(clock2, direction=forwardDirection, &
advanceCount=forwardCount, rc=rc)
!print *, "forwardCount = ", forwardCount
else
call ESMF_ClockGet(clock2, direction=reverseDirection, &
advanceCount=reverseCount, rc=rc)
!print *, "reverseCount = ", reverseCount
endif
!print *, "Going in REVERSE ..."
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockSet(clock2, direction=ESMF_DIRECTION_REVERSE, rc=rc)
nclock = nclock + 1
enddo
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(nring.eq.48).and. &
(forwardCount.eq.96).and.(reverseCount.eq.0).and. &
(forwardDirection.eq.ESMF_DIRECTION_FORWARD).and. &
(reverseDirection.eq.ESMF_DIRECTION_REVERSE).and. &
ESMF_ClockIsReverse(clock2), &
name, failMsg, result, ESMF_SRCLINE)
!print *, "nring = ", nring, " nclock = ", nclock
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Sticky Alarms 1
! Test reverse sticky alarm
write(failMsg, *) " Did not return nstep=2 and ESMF_SUCCESS"
write(name, *) "Sticky Alarm Test 1"
call ESMF_TimeIntervalSet(timeStep, m=15, rc=rc)
call ESMF_TimeSet(startTime, yy=1999, mm=12, dd=31, h=23, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2000, mm=1, dd=1, h=23, &
calendar=gregorianCalendar, rc=rc)
clock2 = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 2", rc=rc)
call ESMF_TimeSet(alarmTime, yy=2000, mm=1, dd=1, h=1, &
calendar=gregorianCalendar, rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, rc=rc)
! number of clock time steps alarm rings for
nstep = 0
! number of times the clock has been run
nclock = 0
do while (nclock < 2)
! run the clock
do while (.not. ESMF_ClockIsDone(clock2, rc=rc))
call ESMF_ClockGet(clock2, currTime=currentTime, rc=rc)
call ESMF_TimeGet(currentTime, yy=yy, mm=mm, dd=dd, h=h, m=m, rc=rc)
!print *, mm, "/", dd, "/", yy, " ", h, ":", m
if (ESMF_AlarmIsRinging(alarm4)) then
nstep = nstep + 1
!print *, "on"
call ESMF_AlarmRingerOff(alarm4, rc=rc)
else
!print *, "off"
endif
call ESMF_ClockAdvance(clock2, rc=rc)
enddo
call ESMF_ClockSet(clock2, direction=ESMF_DIRECTION_REVERSE, rc=rc)
nclock = nclock + 1
enddo
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(nstep.eq.2), &
name, failMsg, result, ESMF_SRCLINE)
!print *, "nstep = ", nstep, " nclock = ", nclock
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Sticky Alarms 2
! Test reverse interval sticky alarm
write(failMsg, *) " Did not return nstep=23 and ESMF_SUCCESS"
write(name, *) "Sticky Alarm Test 2"
call ESMF_TimeIntervalSet(timeStep, m=15, rc=rc)
call ESMF_TimeSet(startTime, yy=1999, mm=12, dd=31, h=23, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2000, mm=1, dd=1, h=23, &
calendar=gregorianCalendar, rc=rc)
clock2 = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 2", rc=rc)
call ESMF_TimeSet(alarmTime, yy=2000, mm=1, dd=1, h=1, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, h=2, rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, &
ringInterval=alarmStep, rc=rc)
! number of clock time steps alarm rings for
nstep = 0
! number of times the clock has been run
nclock = 0
do while (nclock < 2)
! run the clock
do while (.not. ESMF_ClockIsDone(clock2, rc=rc))
call ESMF_ClockGet(clock2, currTime=currentTime, rc=rc)
call ESMF_TimeGet(currentTime, yy=yy, mm=mm, dd=dd, h=h, m=m, rc=rc)
!print *, mm, "/", dd, "/", yy, " ", h, ":", m
if (ESMF_AlarmIsRinging(alarm4)) then
nstep = nstep + 1
!print *, "on"
call ESMF_AlarmRingerOff(alarm4, rc=rc)
else
!print *, "off"
endif
call ESMF_ClockAdvance(clock2, rc=rc)
enddo
call ESMF_ClockSet(clock2, direction=ESMF_DIRECTION_REVERSE, rc=rc)
nclock = nclock + 1
enddo
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(nstep.eq.23), &
name, failMsg, result, ESMF_SRCLINE)
!print *, "nstep = ", nstep, " nclock = ", nclock
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Sticky Alarms 3
! Test reverse one-shot sticky alarms per WRF use case
! From Tom Henderson/WRF
write(name, *) "Sticky Alarm Test 3"
write(failMsg, *) " Alarms did not turn on/off at the correct time/iteration or did not return ESMF_SUCCESS"
call ESMF_TimeIntervalSet(timeStep, h=1, rc=rc)
call ESMF_TimeSet(startTime, yy=2005, mm=6, dd=15, h=1, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2005, mm=6, dd=15, h=5, &
calendar=gregorianCalendar, rc=rc)
domainClock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="WRF Clock", rc=rc)
call ESMF_TimeSet(beforeAlarmTime, yy=2005, mm=6, dd=15, h=2, &
calendar=gregorianCalendar, rc=rc)
beforeAlarm = ESMF_AlarmCreate(clock=domainClock, &
ringTime=beforeAlarmTime, rc=rc)
call ESMF_TimeSet(afterAlarmTime, yy=2005, mm=6, dd=15, h=3, &
calendar=gregorianCalendar, rc=rc)
afterAlarm = ESMF_AlarmCreate(clock=domainClock, &
ringTime=afterAlarmTime, rc=rc)
! any single failure will cause the whole test to fail
testPass = .true.
! track loop iterations
iteration = 0
call ESMF_ClockGet(domainClock, currTime=currentTime, rc=rc)
call ESMF_TimeGet(currentTime, yy=yy, mm=mm, dd=dd, h=h, rc=rc)
!print *, "Begin"
!print *, mm, "/", dd, "/", yy, " ", h, ": 0"
! run the clock forward
do while (.not. ESMF_ClockIsDone(domainClock, rc=rc))
iteration = iteration + 1
!print *, "Iteration = ", iteration
if (ESMF_AlarmIsRinging(beforeAlarm, rc=rc)) then
if (iteration .ne. 2 .or. h .ne. 2) then
testPass = .false.
endif
!print *, " beforeAlarm on"
call ESMF_AlarmRingerOff(beforeAlarm, rc=rc)
else
!print *, " beforeAlarm off"
endif
! would call WRF solver here, before clock advance
!print *, " Solve"
call ESMF_ClockAdvance(domainClock, rc=rc)
call ESMF_ClockGet(domainClock, currTime=currentTime, rc=rc)
call ESMF_TimeGet(currentTime, yy=yy, mm=mm, dd=dd, h=h, rc=rc)
!print *, " ClockAdvance()"
!print *, mm, "/", dd, "/", yy, " ", h, ": 0"
if (ESMF_AlarmIsRinging(afterAlarm, rc=rc)) then
if (iteration .ne. 2 .or. h .ne. 3) then
testPass = .false.
endif
!print *, " afterAlarm on"
call ESMF_AlarmRingerOff(afterAlarm, rc=rc)
else
!print *, " afterAlarm off"
endif
enddo
! run the clock backwards
call ESMF_ClockSet(domainClock, direction=ESMF_DIRECTION_REVERSE, rc=rc)
!print *
!print *, "domainClock set in reverse"
!print *
do while (.not. ESMF_ClockIsDone(domainClock, rc=rc))
!print *, "Iteration = ", iteration
if (ESMF_AlarmIsRinging(afterAlarm, rc=rc)) then
if (iteration .ne. 2 .or. h .ne. 3) then
testPass = .false.
endif
!print *, " afterAlarm on"
call ESMF_AlarmRingerOff(afterAlarm, rc=rc)
else
!print *, " afterAlarm off"
endif
! advance clock
call ESMF_ClockAdvance(domainClock, rc=rc)
call ESMF_ClockGet(domainClock, currTime=currentTime, rc=rc)
call ESMF_TimeGet(currentTime, yy=yy, mm=mm, dd=dd, h=h, rc=rc)
!print *, " ClockAdvance()"
!print *, mm, "/", dd, "/", yy, " ", h, ": 0"
! would call WRF solver here, after clock advance
!print *, " Solve"
if (ESMF_AlarmIsRinging(beforeAlarm, rc=rc)) then
if (iteration .ne. 2 .or. h .ne. 2) then
testPass = .false.
endif
!print *, " beforeAlarm on"
call ESMF_AlarmRingerOff(beforeAlarm, rc=rc)
else
!print *, " beforeAlarm off"
endif
iteration = iteration - 1
enddo
call ESMF_Test(testPass.and.(rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(afterAlarm, rc=rc)
call ESMF_AlarmDestroy(beforeAlarm, rc=rc)
call ESMF_ClockDestroy(domainClock, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Sticky Alarms 4
! Test reverse *interval* sticky alarms; variation on WRF use case above
write(name, *) "Sticky Alarm Test 4"
write(failMsg, *) " Alarms did not turn on/off at the correct time/iteration or did not return ESMF_SUCCESS"
call ESMF_TimeIntervalSet(timeStep, h=1, rc=rc)
call ESMF_TimeSet(startTime, yy=2005, mm=6, dd=15, h=1, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2005, mm=6, dd=15, h=10, &
calendar=gregorianCalendar, rc=rc)
domainClock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="WRF Clock", rc=rc)
call ESMF_TimeSet(beforeAlarmTime, yy=2005, mm=6, dd=15, h=2, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, h=3, rc=rc)
beforeAlarm = ESMF_AlarmCreate(clock=domainClock, &
ringTime=beforeAlarmTime, &
ringInterval=alarmStep, rc=rc)
call ESMF_TimeSet(afterAlarmTime, yy=2005, mm=6, dd=15, h=3, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet(alarmStep2, h=2, rc=rc)
afterAlarm = ESMF_AlarmCreate(clock=domainClock, &
ringTime=afterAlarmTime, &
ringInterval=alarmStep2, rc=rc)
! any single failure will cause the whole test to fail
testPass = .true.
! track loop iterations
iteration = 0
call ESMF_ClockGet(domainClock, currTime=currentTime, rc=rc)
call ESMF_TimeGet(currentTime, yy=yy, mm=mm, dd=dd, h=h, rc=rc)
!print *, "Begin"
!print *, mm, "/", dd, "/", yy, " ", h, ": 0"
! run the clock forward
do while (.not. ESMF_ClockIsDone(domainClock, rc=rc))
iteration = iteration + 1
!print *, "Iteration = ", iteration
if (ESMF_AlarmIsRinging(beforeAlarm, rc=rc)) then
if ((iteration .ne. 2 .or. h .ne. 2).and. &
(iteration .ne. 5 .or. h .ne. 5).and. &
(iteration .ne. 8 .or. h .ne. 8)) then
testPass = .false.
endif
!print *, " beforeAlarm on"
call ESMF_AlarmRingerOff(beforeAlarm, rc=rc)
else
!print *, " beforeAlarm off"
endif
! would call WRF solver here, before clock advance
!print *, " Solve"
call ESMF_ClockAdvance(domainClock, rc=rc)
call ESMF_ClockGet(domainClock, currTime=currentTime, rc=rc)
call ESMF_TimeGet(currentTime, yy=yy, mm=mm, dd=dd, h=h, rc=rc)
!print *, " ClockAdvance()"
!print *, mm, "/", dd, "/", yy, " ", h, ": 0"
if (ESMF_AlarmIsRinging(afterAlarm, rc=rc)) then
if ((iteration .ne. 2 .or. h .ne. 3).and. &
(iteration .ne. 4 .or. h .ne. 5).and. &
(iteration .ne. 6 .or. h .ne. 7).and. &
(iteration .ne. 8 .or. h .ne. 9)) then
testPass = .false.
endif
!print *, " afterAlarm on"
call ESMF_AlarmRingerOff(afterAlarm, rc=rc)
else
!print *, " afterAlarm off"
endif
enddo
! run the clock backwards
call ESMF_ClockSet(domainClock, direction=ESMF_DIRECTION_REVERSE, rc=rc)
!print *
!print *, "domainClock set in reverse"
!print *
do while (.not. ESMF_ClockIsDone(domainClock, rc=rc))
!print *, "Iteration = ", iteration
if (ESMF_AlarmIsRinging(afterAlarm, rc=rc)) then
if ((iteration .ne. 2 .or. h .ne. 3).and. &
(iteration .ne. 4 .or. h .ne. 5).and. &
(iteration .ne. 6 .or. h .ne. 7).and. &
(iteration .ne. 8 .or. h .ne. 9)) then
testPass = .false.
endif
!print *, " afterAlarm on"
call ESMF_AlarmRingerOff(afterAlarm, rc=rc)
else
!print *, " afterAlarm off"
endif
! advance clock
call ESMF_ClockAdvance(domainClock, rc=rc)
call ESMF_ClockGet(domainClock, currTime=currentTime, rc=rc)
call ESMF_TimeGet(currentTime, yy=yy, mm=mm, dd=dd, h=h, rc=rc)
!print *, " ClockAdvance()"
!print *, mm, "/", dd, "/", yy, " ", h, ": 0"
! would call WRF solver here, after clock advance
!print *, " Solve"
if (ESMF_AlarmIsRinging(beforeAlarm, rc=rc)) then
if ((iteration .ne. 2 .or. h .ne. 2).and. &
(iteration .ne. 5 .or. h .ne. 5).and. &
(iteration .ne. 8 .or. h .ne. 8)) then
testPass = .false.
endif
!print *, " beforeAlarm on"
call ESMF_AlarmRingerOff(beforeAlarm, rc=rc)
else
!print *, " beforeAlarm off"
endif
iteration = iteration - 1
enddo
call ESMF_Test(testPass.and.(rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(afterAlarm, rc=rc)
call ESMF_AlarmDestroy(beforeAlarm, rc=rc)
call ESMF_ClockDestroy(domainClock, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Sticky Alarms 5
! Test delay in checking for ringing sticky alarms,
! from James Geiger in #2825456, case #2 in his alarm_test.f90 reproducer
write(name, *) "Sticky Alarm Test 5"
write(failMsg, *) " Alarm did not ring at the correct times or did not return ESMF_SUCCESS"
call ESMF_TimeIntervalSet(timeStep, s=3600, rc=rc)
call ESMF_TimeSet(startTime, yy=2000, mm=1, dd=1, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2000, mm=1, dd=3, &
calendar=gregorianCalendar, rc=rc)
clock2 = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock", rc=rc)
call ESMF_TimeSet(alarmTime, yy=2000, mm=1, dd=1, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, h=3, rc=rc)
alarmTime = alarmTime + alarmStep
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, &
ringInterval=alarmStep, rc=rc)
testPass = .false.
iteration = 0
nring = 0
do while (.not.ESMF_ClockIsStopTime(clock2, rc=rc))
iteration = iteration + 1
!print *, "clock2 timestep ", iteration
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (iteration .eq. 10) then
! waiting period is over, clear any alarm which may have occurred
if (ESMF_AlarmIsRinging(alarm4, rc=rc)) then
call ESMF_AlarmRingerOff(alarm4, rc=rc)
endif
endif
call ESMF_ClockAdvance(clock2, rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_ClockPrint(clock2, options="currTime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (iteration .gt. 10) then
! process any alarm occuring after initial 10 hour waiting period
if (ESMF_AlarmIsRinging(alarm4, rc=rc)) then
nring = nring + 1
!print *, "alarm4 is ringing!"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmRingerOff(alarm4, rc=rc)
endif
endif
end do
! test in REVERSE mode (not from James)
call ESMF_ClockSet(clock2, direction=ESMF_DIRECTION_REVERSE, rc=rc)
do while (.not.ESMF_ClockIsDone(clock2, rc=rc))
iteration = iteration + 1
!print *, "clock2 timestep ", iteration
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockAdvance(clock2, rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_ClockPrint(clock2, options="currTime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_AlarmIsRinging(alarm4, rc=rc)) then
nring = nring + 1
!print *, "alarm4 is ringing!"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmRingerOff(alarm4, rc=rc)
endif
end do
! test double back in FORWARD mode (not from James)
call ESMF_ClockSet(clock2, direction=ESMF_DIRECTION_FORWARD, rc=rc)
do while (.not.ESMF_ClockIsDone(clock2, rc=rc))
iteration = iteration + 1
!print *, "clock2 timestep ", iteration
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockAdvance(clock2, rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_ClockPrint(clock2, options="currTime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_AlarmIsRinging(alarm4, rc=rc)) then
nring = nring + 1
!print *, "alarm4 is ringing!"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmRingerOff(alarm4, rc=rc)
endif
end do
!print *, "alarm4 rang ", nring, " times, clock stepped ", iteration, " times."
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (nring.eq.44 .and. iteration.eq.144) testPass = .true.
call ESMF_Test(testPass.and.(rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Sticky Alarms 6
! Test timeStep == ringInterval, from James Geiger in #2910203
write(name, *) "Sticky Alarm Test 6"
write(failMsg, *) " Alarm did not ring at the correct times or did not return ESMF_SUCCESS"
call ESMF_TimeIntervalSet(timeStep, s=900, rc=rc)
call ESMF_TimeSet(startTime, yy=2003, mm=9, dd=1, &
calendar=gregorianCalendar, rc=rc)
! dd=3, instead of original 30 in Jims report, to shorten test run time
call ESMF_TimeSet(stopTime, yy=2003, mm=9, dd=3, &
calendar=gregorianCalendar, rc=rc)
clock2 = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="The Clock", rc=rc)
call ESMF_TimeSet(alarmTime, yy=2003, mm=9, dd=1, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, s=900, rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, &
ringInterval=alarmStep, rc=rc)
testPass = .false.
iteration = 0
nring = 0
do while (.not.ESMF_ClockIsStopTime(clock2, rc=rc))
iteration = iteration + 1
!print *, "clock2 timestep ", iteration
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockAdvance(clock2, rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_ClockPrint(clock2, options="currTime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_AlarmIsRinging(alarm4, rc=rc)) then
nring = nring + 1
!print *, "alarm4 is ringing!"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmRingerOff(alarm4, rc=rc)
endif
end do
! test in REVERSE mode (not from James)
call ESMF_ClockSet(clock2, direction=ESMF_DIRECTION_REVERSE, rc=rc)
do while (.not.ESMF_ClockIsDone(clock2, rc=rc))
iteration = iteration + 1
!print *, "clock2 timestep ", iteration
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockAdvance(clock2, rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_ClockPrint(clock2, options="currTime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_AlarmIsRinging(alarm4, rc=rc)) then
nring = nring + 1
!print *, "alarm4 is ringing!"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmRingerOff(alarm4, rc=rc)
endif
end do
! test double back in FORWARD mode (not from James),
call ESMF_ClockSet(clock2, direction=ESMF_DIRECTION_FORWARD, rc=rc)
do while (.not.ESMF_ClockIsDone(clock2, rc=rc))
iteration = iteration + 1
!print *, "clock2 timestep ", iteration
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockAdvance(clock2, rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_ClockPrint(clock2, options="currTime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_AlarmIsRinging(alarm4, rc=rc)) then
nring = nring + 1
!print *, "alarm4 is ringing!"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmRingerOff(alarm4, rc=rc)
endif
end do
!print *, "alarm4 rang ", nring, " times, clock stepped ", iteration, " times."
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (nring.eq.576 .and. iteration.eq.576) testPass = .true.
call ESMF_Test(testPass.and.(rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Sticky Alarms 7
! Test timeStep > ringInterval, inspired by James Geiger in #2910203
write(name, *) "Sticky Alarm Test 7"
write(failMsg, *) " Alarm did not ring at the correct times or did not return ESMF_SUCCESS"
call ESMF_TimeIntervalSet(timeStep, s=1800, rc=rc)
call ESMF_TimeSet(startTime, yy=2003, mm=9, dd=1, &
calendar=gregorianCalendar, rc=rc)
! dd=3, instead of original 30 in Jims report, to save test run time
call ESMF_TimeSet(stopTime, yy=2003, mm=9, dd=3, &
calendar=gregorianCalendar, rc=rc)
clock2 = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="The Clock", rc=rc)
call ESMF_TimeSet(alarmTime, yy=2003, mm=9, dd=1, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, s=900, rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, &
ringInterval=alarmStep, rc=rc)
testPass = .false.
iteration = 0
nring = 0
do while (.not.ESMF_ClockIsStopTime(clock2, rc=rc))
iteration = iteration + 1
!print *, "clock2 timestep ", iteration
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockAdvance(clock2, rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_ClockPrint(clock2, options="currTime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_AlarmIsRinging(alarm4, rc=rc)) then
nring = nring + 1
!print *, "alarm4 is ringing!"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmRingerOff(alarm4, rc=rc)
endif
!call ESMF_AlarmPrint(alarm4, options="ringtime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
end do
!print *, "At end of 1st forward run, nring = ", nring
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
! TODO: test in REVERSE mode (not from James)
! currently doesn't ring in REVERSE
call ESMF_ClockSet(clock2, direction=ESMF_DIRECTION_REVERSE, rc=rc)
do while (.not.ESMF_ClockIsDone(clock2, rc=rc))
iteration = iteration + 1
!print *, "clock2 timestep ", iteration
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockAdvance(clock2, rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_ClockPrint(clock2, options="currTime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_AlarmIsRinging(alarm4, rc=rc)) then
nring = nring + 1
!print *, "alarm4 is ringing!"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmRingerOff(alarm4, rc=rc)
endif
!call ESMF_AlarmPrint(alarm4, options="ringtime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
end do
!print *, "At end of reverse run, nring = ", nring
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
! TODO: test double back in FORWARD mode (not from James)
! currently doesn't work until back into day 2
call ESMF_ClockSet(clock2, direction=ESMF_DIRECTION_FORWARD, rc=rc)
do while (.not.ESMF_ClockIsDone(clock2, rc=rc))
iteration = iteration + 1
!print *, "clock2 timestep ", iteration
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockAdvance(clock2, rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_ClockPrint(clock2, options="currTime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_AlarmIsRinging(alarm4, rc=rc)) then
nring = nring + 1
!print *, "alarm4 is ringing!"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmRingerOff(alarm4, rc=rc)
endif
!call ESMF_AlarmPrint(alarm4, options="ringtime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
end do
!print *, "At end of 2nd forward run, nring = ", nring
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!print *, "alarm4 rang ", nring, " times, clock stepped ", iteration, " times."
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (nring.eq.288 .and. iteration.eq.288) testPass = .true.
call ESMF_Test(testPass.and.(rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Fractional Time Alarms 1
write(failMsg, *) " Did not return nstep=8, and ESMF_SUCCESS"
write(name, *) "Fractional Time Alarm Test 1"
call ESMF_TimeIntervalSet(timeStep, ms=10, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, ms=100, rc=rc)
call ESMF_TimeSet(startTime, yy=1999, mm=12, dd=31, h=23, m=59, s=59, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2000, mm=1, dd=1, &
calendar=gregorianCalendar, rc=rc)
clock2=ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 2", rc=rc)
call ESMF_TimeSet(alarmTime, yy=1999, mm=12, dd=31, h=23, m=59, s=59, &
ms=200, calendar=gregorianCalendar, rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, &
ringInterval=alarmStep, rc=rc)
! number of clock time steps alarm rings for
nstep = 0
! run the clock
do while (.not. ESMF_ClockIsStopTime(clock2, rc=rc))
if (ESMF_AlarmIsRinging(alarm4)) then
nstep = nstep + 1
call ESMF_AlarmRingerOff(alarm4)
endif
call ESMF_ClockAdvance(clock2, rc=rc)
enddo
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(nstep.eq.8), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Fractional Time Alarms 2
write(failMsg, *) " Did not return nstep=4, and ESMF_SUCCESS"
write(name, *) "Fractional Time Alarm Test 2"
call ESMF_TimeIntervalSet(timeStep, sN=-22, sD=7, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, sN=-44, sD=7, rc=rc)
call ESMF_TimeSet(startTime, yy=2000, mm=1, dd=1, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=1999, mm=12, dd=31, h=23, m=59, s=28, &
sN=4, sD=7, calendar=gregorianCalendar, rc=rc)
clock2=ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 2", rc=rc)
call ESMF_TimeSet(alarmTime, yy=1999, mm=12, dd=31, h=23, m=59, s=53, &
sN=2, sD=7, calendar=gregorianCalendar, rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, &
ringInterval=alarmStep, rc=rc)
!print *, "stopTime = "
!call ESMF_TimePrint(stopTime)
!print *, "alarmTime = "
!call ESMF_TimePrint(alarmTime)
!print *, "timeStep = "
!call ESMF_TimeIntervalPrint(timeStep)
!print *, "alarmStep = "
!call ESMF_TimeIntervalPrint(alarmStep)
! number of clock time steps alarm rings for
nstep = 0
! run the clock
do while (.not. ESMF_ClockIsStopTime(clock2, rc=rc))
if (ESMF_AlarmIsRinging(alarm4)) then
nstep = nstep + 1
call ESMF_AlarmRingerOff(alarm4)
endif
call ESMF_ClockAdvance(clock2, rc=rc)
enddo
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(nstep.eq.4), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm ringTime = clock startTime => should ring immediately
! upon alarm creation.
write(failMsg, *) " Did not return alarm ringing and ESMF_SUCCESS"
write(name, *) "Test Alarm ringTime = Clock startTime"
call ESMF_TimeIntervalSet(timeStep, ms=10, rc=rc)
call ESMF_TimeSet(startTime, yy=1999, mm=12, dd=31, h=23, m=59, s=59, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2000, mm=1, dd=1, &
calendar=gregorianCalendar, rc=rc)
clock2=ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 2", rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=startTime, rc=rc)
bool = ESMF_AlarmIsRinging(alarm4)
call ESMF_Test((bool.and.rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm ringTime = clock startTime *and* ringInterval specified
! upon alarm creation => should ring immediately. Test 1
! From Tom Black in Support ticket 1989990.
write(failMsg, *) " Did not return alarm ringing and ESMF_SUCCESS"
write(name, *) "Alarm ringTime = Clock startTime with ringInterval, test 1"
call ESMF_TimeIntervalSet(timeStep, m=2, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, s=60, rc=rc)
call ESMF_TimeSet(startTime, yy=2007, mm=9, dd=18, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2007, mm=9, dd=19, &
calendar=gregorianCalendar, rc=rc)
clock2=ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 2", rc=rc)
alarm4 = ESMF_AlarmCreate(clock=clock2, ringTime=startTime, &
ringInterval=alarmStep, rc=rc)
call ESMF_AlarmGet(alarm4, ringTime=alarmTime, rc=rc)
bool = ESMF_AlarmIsRinging(alarm4)
call ESMF_Test(((alarmTime==startTime+alarmStep).and.bool.and. &
rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm ringTime = clock startTime *and* ringInterval specified
! upon alarm creation => should ring immediately. Test 2
! From Tom Black in Support ticket 1989990.
write(failMsg, *) " Did not return alarm ringing 21 times and ESMF_SUCCESS"
write(name, *) "Alarm ringTime = Clock startTime with ringInterval, test 2"
! any single failure will cause the whole test to fail
testPass = .true.
call ESMF_TimeIntervalSet(timeStep, s=60, rc=rc)
call ESMF_TimeIntervalSet(runDuration, s=3600, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, s=180, rc=rc)
call ESMF_TimeSet(startTime, yy=2007, mm=9, dd=18, &
calendar=gregorianCalendar, rc=rc)
clock2=ESMF_ClockCreate(timeStep, startTime, &
runDuration=runDuration, name="Clock 2", rc=rc)
! Tom Black's AlarmCreate() ...
alarm4=ESMF_AlarmCreate( &
name ='ALARM Recv from Parent' & !<-- Name of Alarm
,clock =clock2 & !<-- Each domain's ATM Driver Clock
,ringTime =startTime & !<-- First time the Alarm rings (ESMF)
,ringInterval =alarmStep & !<-- Recv from my parent at this
! frequency (ESMF)
,ringTimeStepCount=1 & !<-- The Alarm rings for this many
! timesteps
,sticky =.false. & !<-- Alarm does not ring until turned off
,rc =rc)
! run the clock
ringCount = 0
do while (.not. ESMF_ClockIsStopTime(clock2, rc=rc))
call ESMF_ClockGet(clock2, advanceCount=forwardCount, rc=rc)
!print *, "At clock timestep #", forwardCount
call ESMF_AlarmGet(alarm4, clock=clock1, rc=rc)
call ESMF_ClockGet(clock1, currTime=currentTime2, rc=rc)
!print *, "Alarm's clock's currTime ..."
!call ESMF_TimePrint(currentTime2, options="string", rc=rc)
if (clock2 /= clock1) then
testPass = .false.
!print *, "Alarm's clock and domain clock are *not* the same"
endif
call ESMF_ClockGet(clock2, currTime=currentTime, prevTime=prevTime, &
rc=rc)
!print *, "Clock's currTime and prevTime ..."
!call ESMF_TimePrint(currentTime, options="string", rc=rc)
!call ESMF_TimePrint(prevTime, options="string", rc=rc)
if (currentTime /= currentTime2) then
testPass = .false.
!print *, "Alarm's clock's currTime is *not* the same as the domain clock's currTime"
endif
call ESMF_AlarmGet(alarm4, ringTime=alarmTime, rc=rc)
!print *, "Alarm's ringTime ..."
!call ESMF_TimePrint(alarmTime, options="string", rc=rc)
if (ESMF_AlarmIsRinging(alarm=alarm4, rc=rc)) then
ringCount = ringCount + 1
!print *, " Alarm is ringing"
if (alarmTime /= currentTime+alarmStep) then
testPass = .false.
!print *, " Alarm ringTime *not* equal to clock currTime + alarmStep"
endif
endif
call ESMF_ClockAdvance(clock2, rc=rc)
enddo
call ESMF_ClockGet(clock2, advanceCount=forwardCount, rc=rc)
!print *, "End of clock run: At clock timestep #", forwardCount
if (ESMF_AlarmIsRinging(alarm=alarm4, rc=rc)) then
!print *, " Alarm is ringing"
ringCount = ringCount + 1
endif
! Alarm should have rung 21 times, including from timestep 0 (upon alarm
! creation) through timestep 60 (end of clock run) inclusive.
! Final ringTime should be one alarmStep past the clock end time.
call ESMF_AlarmGet(alarm4, ringTime=alarmTime, rc=rc)
call ESMF_Test(((alarmTime==startTime+runDuration+alarmStep).and. &
ringCount==21.and.testPass.and. &
rc.eq.ESMF_SUCCESS), name, failMsg, result, ESMF_SRCLINE)
!print *, "Alarm rang ", ringCount, " times."
!print *, "Alarm's final ringTime, after final clockAdvance() ..."
!call ESMF_TimePrint(alarmTime, options="string", rc=rc)
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm ringTime = clock startTime *and* ringInterval specified
! upon alarm creation => should ring immediately. Test 3, test REVERSE
! back to clock starttime. Robustness test for solution to
! Tom Black problem in Support ticket 1989990.
write(failMsg, *) " Did not return alarm ringing 41 times and ESMF_SUCCESS"
write(name, *) "Alarm ringTime = Clock startTime with ringInterval, test 3 (reverse)"
call ESMF_TimeIntervalSet(timeStep, s=60, rc=rc)
call ESMF_TimeIntervalSet(runDuration, s=3600, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, s=180, rc=rc)
call ESMF_TimeSet(startTime, yy=2007, mm=9, dd=18, &
calendar=gregorianCalendar, rc=rc)
clock2=ESMF_ClockCreate(timeStep, startTime, &
runDuration=runDuration, name="Clock 2", rc=rc)
! like Tom Black's AlarmCreate(), but sticky
alarm4=ESMF_AlarmCreate( &
name ='ALARM Recv from Parent' & !<-- Name of Alarm
,clock =clock2 & !<-- Each domain's ATM Driver Clock
,ringTime =startTime & !<-- First time the Alarm rings (ESMF)
,ringInterval =alarmStep & !<-- Recv from my parent at this
! frequency (ESMF)
,rc =rc)
! number of clock time steps alarm rings for
nring = 0
! number of times the clock has been run
nclock = 0
do while (nclock < 2)
! run the clock
do while (.not. ESMF_ClockIsDone(clock2, rc=rc))
if (ESMF_AlarmIsRinging(alarm4)) then
nring = nring + 1
!print *, "on"
call ESMF_AlarmRingerOff(alarm4, rc=rc)
else
!print *, "off"
endif
call ESMF_ClockAdvance(clock2, rc=rc)
enddo
if (nclock.eq.0) then
call ESMF_ClockGet(clock2, direction=forwardDirection, &
advanceCount=forwardCount, rc=rc)
!print *, "forwardCount = ", forwardCount
else
call ESMF_ClockGet(clock2, direction=reverseDirection, &
advanceCount=reverseCount, rc=rc)
!print *, "reverseCount = ", reverseCount
endif
call ESMF_ClockSet(clock2, direction=ESMF_DIRECTION_REVERSE, rc=rc)
nclock = nclock + 1
enddo
! count ring at the end point
if (ESMF_AlarmIsRinging(alarm4)) then
nring = nring + 1
!print *, "on"
call ESMF_AlarmRingerOff(alarm4, rc=rc)
else
!print *, "off"
endif
call ESMF_Test((rc.eq.ESMF_SUCCESS).and.(nring.eq.41).and. &
(forwardCount.eq.60).and.(reverseCount.eq.0).and. &
(forwardDirection.eq.ESMF_DIRECTION_FORWARD).and. &
(reverseDirection.eq.ESMF_DIRECTION_REVERSE).and. &
ESMF_ClockIsReverse(clock2), &
name, failMsg, result, ESMF_SRCLINE)
!print *, "nring = ", nring, " nclock = ", nclock
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm ringTime = clock startTime *and* ringInterval specified
! upon alarm creation *and* after clock restored from restart state --
! with 2 calls to ESMF_ClockSet() -- should ring immediately.
! This approach to restart will become obsolete with the implementation
! of WriteRestart()/ReadStart(), but it should remain technically valid,
! along with this unit test. From Ratko Vasic in ticket #2685243.
write(failMsg, *) " Did not return alarm ringing and ESMF_SUCCESS"
write(name, *) "Alarm ringTime = Clock startTime with ringInterval, after clock restore"
call ESMF_TimeIntervalSet(timeStep, m=3, rc=rc)
call ESMF_TimeIntervalSet(TIMEINTERVAL_HISTORY, h=3, rc=rc)
call ESMF_TimeSet(startTime, mm=9, dd=18, yy=2007, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, mm=9, dd=19, yy=2007, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(currTime, mm=9, dd=18, yy=2007, h=12, &
calendar=gregorianCalendar, rc=rc)
CLOCK_ATM=ESMF_ClockCreate( &
name ='CLOCK_ATM' & !<-- The ATM Clock's name
,timeStep =timeStep & !<-- The fundamental timestep in
! this component
,startTime =startTime & !<-- Start time of simulation
,stopTime =stopTime & !<-- Stop time of simulation
,rc =rc)
! 1st ClockSet() to reset currTime and advanceCount for restart
call ESMF_ClockSet( &
clock =CLOCK_ATM & !<-- The ATM Component's Clock
,currtime =currTime & !<-- Current time of simulation
,advanceCount=240_ESMF_KIND_I8 & !<-- Timestep at this current time
,rc =rc)
! 2nd ClockSet() with same values that CLOCK_ATM already has; should
! have no affect
call ESMF_ClockSet(clock =CLOCK_ATM &
,currtime =currTime &
,starttime=startTime &
,rc =rc)
!call ESMF_ClockPrint(CLOCK_ATM, rc=rc)
ALARM_HISTORY=ESMF_AlarmCreate( &
name ='ALARM_HISTORY' &
,clock =CLOCK_ATM & ! <-- ATM Clock
,ringTime =currTime & ! <-- Forecast/Restart start
! time (ESMF)
,ringInterval =TIMEINTERVAL_HISTORY & ! <-- Time interval between
,ringTimeStepCount=1 & ! <-- The Alarm rings for
! this many timesteps
,sticky =.false. & ! <-- Alarm does not ring
! until turned off
,rc =rc)
!call ESMF_AlarmPrint(ALARM_HISTORY, rc=rc)
call ESMF_AlarmGet(ALARM_HISTORY, ringTime=alarmTime, rc=rc)
bool = ESMF_AlarmIsRinging(ALARM_HISTORY)
call ESMF_Test(((alarmTime==currTime+TIMEINTERVAL_HISTORY).and.bool &
.and. rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy(ALARM_HISTORY, rc=rc)
call ESMF_ClockDestroy(CLOCK_ATM, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm list re-allocation within clock, part 1
write(failMsg, *) " Did not return ESMF_SUCCESS"
write(name, *) "Alarm list reallocation Test 1"
call ESMF_TimeIntervalSet(timeStep, ms=10, rc=rc)
call ESMF_TimeIntervalSet(alarmStep, ms=100, rc=rc)
call ESMF_TimeSet(startTime, yy=1999, mm=12, dd=31, h=23, m=59, s=59, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet(stopTime, yy=2000, mm=1, dd=1, &
calendar=gregorianCalendar, rc=rc)
clock2=ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="Clock 2", rc=rc)
call ESMF_TimeSet(alarmTime, yy=1999, mm=12, dd=31, h=23, m=59, s=59, &
ms=200, calendar=gregorianCalendar, rc=rc)
! fill up clock's alarmList
do i=1,200
alarm5(i) = ESMF_AlarmCreate(clock=clock2, ringTime=alarmTime, &
ringInterval=alarmStep, rc=rc)
enddo
! add one more alarm than there is space for (200), forcing a
! reallocation to 400 alarms
! also, set 201st alarm to be the first to ring upon the 1st timestep
call ESMF_TimeSet(alarmTime, yy=1999, mm=12, dd=31, h=23, m=59, s=59, &
ms=10, calendar=gregorianCalendar, rc=rc)
alarm4 = ESMF_AlarmCreate(name="201st Alarm", clock=clock2, &
ringTime=alarmTime, ringInterval=alarmStep, &
rc=rc)
! see if the 201st alarm was successfully added to the clock
call ESMF_Test((rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm list re-allocation within clock, part 2
write(failMsg, *) " Did not return 201 alarms and name '201st Alarm'"
write(name, *) "Alarm list reallocation Test 2"
call ESMF_ClockGetAlarmList(clock2, ESMF_ALARMLIST_ALL, &
alarmList=alarmList, &
alarmCount=alarmCount, rc=rc)
write(*,*) "rc=",rc
call ESMF_AlarmGet(alarmList(alarmCount), name=aName, rc=rc)
!print *, "alarmCount = ", alarmCount
!print *, "201st alarm name = ", aName
write(*,*) "rc=",rc
! see if we have 201 alarms and if the 201st alarm has the right name!
call ESMF_Test((alarmCount.eq.201).and.(aName.eq."201st Alarm") &
.and.(rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm list re-allocation within clock, part 3
write(failMsg, *) " Did not return 201st alarm ringing"
write(name, *) "Alarm list reallocation Test 3"
call ESMF_ClockAdvance(clock2, rc=rc)
call ESMF_ClockGetAlarmList(clock2, ESMF_ALARMLIST_RINGING, &
alarmList=alarmList, &
alarmCount=alarmCount, rc=rc)
! double check ringing with Alarm API call
isringing = ESMF_AlarmIsRinging(alarm4, rc=rc)
!print *, "alarmCount = ", alarmCount
call ESMF_AlarmGet(alarmList(alarmCount), name=aName, rc=rc)
!print *, "Ringing alarm name = ", trim(aName), ", is ringing = ", &
!isringing
! see if the 201st alarm is the only one ringing
call ESMF_Test(isringing.and.(alarmCount.eq.1) &
.and.(aName.eq."201st Alarm") &
.and.(rc.eq.ESMF_SUCCESS), &
name, failMsg, result, ESMF_SRCLINE)
! cleanup
do i=1,200
call ESMF_AlarmDestroy(alarm5(i), rc=rc)
enddo
call ESMF_AlarmDestroy(alarm4, rc=rc)
call ESMF_ClockDestroy(clock2, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
! Based on reproducer clocktester.F90 from Atanas. See bug #1531948.
write(failMsg, *) " Did not ring enough times during forward/backward march"
write(name, *) "Test ESMF_DIRECTION_FORWARD to a non-sticky alarm " // &
"point, ESMF_DIRECTION_REVERSE, ESMF_DIRECTION_FORWARD"
testPass = .true.
call ESMF_TimeSet (startTime, yy=2009, mm=1, dd=1, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeSet (stopTime, yy=2009, mm=1, dd=2, h=0, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet (timeStep, s=3600, rc=rc)
clock = ESMF_ClockCreate(timeStep, startTime, stopTime=stopTime, &
name="ApplClock", rc=rc)
if (rc /= ESMF_SUCCESS) testPass = .false.
call ESMF_TimeIntervalSet (alarmStep, s=7200, rc=rc)
!call ESMF_TimeIntervalSet(ringDuration, h=1, rc=rc)
!call ESMF_TimeSet(alarmStopTime, yy=2009, mm=1, dd=1, h=21, &
! calendar=gregorianCalendar, rc=rc)
alarm1 = ESMF_AlarmCreate (clock=clock, &
ringTime=startTime, ringInterval=alarmStep, &
! ringDuration=ringDuration, &
! stopTime=alarmStopTime, &
sticky=.false., name="testAlarm", rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
!call ESMF_AlarmPrint(alarm1, options="ringduration string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_AlarmPrint(alarm1, options="ringtimestepcount string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
alarmCount = 0
expectedCount = 22
do
!print *, "***********************Top of loop 1 **********************"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_ClockPrint(clock, options="currtime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_AlarmIsRinging(alarm1, rc=rc)) then
alarmCount = alarmCount + 1
!print *, "alarm1 is ringing"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_AlarmRingerOff(alarm1, rc=rc)
endif
!call ESMF_AlarmPrint(alarm1, options="ringbegin string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_AlarmPrint(alarm1, options="ringtime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_AlarmPrint(alarm1, options="ringend string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockAdvance(clock, rc=rc)
!call ESMF_AlarmPrint(alarm1, options="ringend string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_ClockIsStopTime(clock, rc=rc)) exit
enddo
!print *, "At end of 1st forward run, alarmCount = ", alarmCount
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockSet(clock, direction=ESMF_DIRECTION_REVERSE, rc=rc)
i=0
do
!print *, "***********************Top of loop 2 **********************"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_ClockPrint(clock, options="currtime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_AlarmIsRinging(alarm1, rc=rc)) then
alarmCount = alarmCount + 1
!print *, "alarm1 is ringing"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_AlarmRingerOff(alarm1, rc=rc)
endif
!call ESMF_AlarmPrint(alarm1, options="ringbegin string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_AlarmPrint(alarm1, options="ringtime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockAdvance(clock, rc=rc)
i = i+1
if (i == 5) exit
enddo
!print *, "At end of reverse run, alarmCount = ", alarmCount
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockSet(clock, direction=ESMF_DIRECTION_FORWARD, rc=rc)
i=0
do
!print *, "***********************Top of loop 3 **********************"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_ClockPrint(clock, options="currtime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
if (ESMF_AlarmIsRinging(alarm1, rc=rc)) then
alarmCount = alarmCount + 1
!print *, "alarm1 is ringing"
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_AlarmRingerOff(alarm1, rc=rc)
endif
!call ESMF_AlarmPrint(alarm1, options="ringbegin string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
!call ESMF_AlarmPrint(alarm1, options="ringtime string", rc=rc)
!call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_ClockAdvance(clock, rc=rc)
i = i+1
if (i == 15) exit
enddo
if (.not. testPass .or. alarmCount /= expectedCount) then
if (.not. testPass) print *, 'bad return codes discovered'
write (failMsg,*) trim (failMsg), ', alarmCount = ', alarmCount, ', expected = ', expectedCount
print *, 'The alarm ringTime may be stuck at:'
call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmPrint (alarm1, options="ringTime string", rc=rc)
call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
end if
call ESMF_Test (testPass .and. alarmCount == expectedCount, &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_UtilIOUnitFlush(ESMF_UtilIOStdout)
call ESMF_AlarmDestroy (alarm1, rc=rc)
call ESMF_ClockDestroy (clock, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm ringTime increment, first forwards a fixed number of
!timesteps, stopping at an alarm ringing time step.
!Using ESMF_DIRECTION_REVERSE, step backwards to some time prior to the
!clock's startTime. Then go ESMF_DIRECTION_FORWARD to one step past an
!alarm ringing time step, and then ESMF_DIRECTION_REVERSE once more.
! Count number of rings. See bug #1531948.
write(failMsg, *) " Did not ring enough times during forward/backward march"
write(name, *) "Test ESMF_DIRECTION_FORWARD to an alarm point, " // &
"ESMF_DIRECTION_REVERSE, ESMF_DIRECTION_FORWARD, " // &
"ESMF_DIRECTION_REVERSE"
testPass = .true.
call ESMF_TimeSet (startTime, yy=2008, mm=1, dd=23, h=0, &
calendar=gregorianCalendar, rc=rc)
!call ESMF_TimePrint (startTime, options="string isofrac", rc=rc)
call ESMF_TimeIntervalSet (timeStep, h=3, rc=rc)
clock = ESMF_ClockCreate(startTime = startTime, timeStep=timeStep, &
name="clock 1", rc=rc)
if (rc /= ESMF_SUCCESS) testPass = .false.
call ESMF_TimeSet (alarmTime, yy=2008, mm=1, dd=23, h=6, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet (alarmStep, h=6, rc=rc)
alarm1 = ESMF_AlarmCreate ( &
name="Alarm 1", clock=clock, &
ringTime=alarmTime, ringInterval=alarmStep, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
alarmCount = 0
expectedCount = 11
do, i=1,6
call ESMF_ClockAdvance (clock, rc=rc)
!call ESMF_ClockPrint (clock, options="currTime string", rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (ESMF_alarmIsRinging (alarm1)) then
alarmCount = alarmCount + 1
!print *, 'alarm IS ringing at forwards timestep', i
call ESMF_AlarmRingerOff (alarm1, rc=rc)
else
!print *, 'alarm not ringing at forwards timestep', i
end if
end do
!print *, 'SETTING CLOCK BACKWARDS'
call ESMF_ClockSet (clock, direction=ESMF_DIRECTION_REVERSE, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
do, i=5, -5, -1
call ESMF_ClockAdvance (clock, rc=rc)
!call ESMF_ClockPrint (clock, options="currTime string", rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (ESMF_alarmIsRinging (alarm1)) then
alarmCount = alarmCount + 1
!print *, 'alarm IS ringing at backwards timestep', i
call ESMF_AlarmRingerOff (alarm1, rc=rc)
!call ESMF_AlarmPrint(alarm1, options="ringTime string", rc=rc)
else
!print *, 'alarm not ringing at backwards timestep', i
!call ESMF_ClockPrint (clock, options="currTime string", rc=rc)
end if
end do
!print *, 'SETTING CLOCK FORWARDS'
call ESMF_ClockSet (clock, direction=ESMF_DIRECTION_FORWARD, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
do, i=-4,7
call ESMF_ClockAdvance (clock, rc=rc)
!call ESMF_ClockPrint (clock, options="currTime string", rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (ESMF_alarmIsRinging (alarm1)) then
alarmCount = alarmCount + 1
!print *, 'alarm IS ringing at forwards timestep', i
call ESMF_AlarmRingerOff (alarm1, rc=rc)
else
!print *, 'alarm not ringing at forwards timestep', i
end if
end do
!print *, 'SETTING CLOCK BACKWARDS'
call ESMF_ClockSet (clock, direction=ESMF_DIRECTION_REVERSE, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
do, i=6, -5, -1
call ESMF_ClockAdvance (clock, rc=rc)
!call ESMF_ClockPrint (clock, options="currTime string", rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (ESMF_alarmIsRinging (alarm1)) then
alarmCount = alarmCount + 1
!print *, 'alarm IS ringing at backwards timestep', i
call ESMF_AlarmRingerOff (alarm1, rc=rc)
!call ESMF_AlarmPrint(alarm1, options="ringTime string", rc=rc)
else
!print *, 'alarm not ringing at backwards timestep', i
!call ESMF_ClockPrint (clock, options="currTime string", rc=rc)
end if
end do
if (.not. testPass .or. alarmCount /= expectedCount) then
if (.not. testPass) print *, 'bad return codes discovered'
write (failMsg,*) trim (failMsg), ', alarmCount = ', alarmCount, ', expected = ', expectedCount
print *, 'The alarm ringTime may be stuck at:'
call ESMF_AlarmPrint (alarm1, options="ringTime string", rc=rc)
end if
call ESMF_Test (testPass .and. alarmCount == expectedCount, &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy (alarm1, rc=rc)
call ESMF_ClockDestroy (clock, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm ringTime increment, first forwards a fixed number of
!timesteps, stopping at an alarm ringing time step. Using a negative
!timestemp, step backwards to some time prior to the clock's startTime.
!Count number of rings. See bugs #1531948, #1457135.
write(failMsg, *) " Did not ring enough times during forward/backward march"
write(name, *) "Test forward to an alarm point, then step backward using a negative timeStep"
testPass = .true.
call ESMF_TimeSet (startTime, yy=2008, mm=1, dd=23, h=0, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet (timeStep, h=3, rc=rc)
clock = ESMF_ClockCreate(startTime = startTime, timeStep=timeStep, &
name="clock 1", rc=rc)
if (rc /= ESMF_SUCCESS) testPass = .false.
call ESMF_TimeSet (alarmTime, yy=2008, mm=1, dd=23, h=6, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet (alarmStep, h=6, rc=rc)
alarm1 = ESMF_AlarmCreate ( &
name="Alarm 1", clock=clock, &
ringTime=alarmTime, ringInterval=alarmStep, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
alarmCount = 0
expectedCount = 8
do, i=1,6
call ESMF_ClockAdvance (clock, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (ESMF_alarmIsRinging (alarm1)) then
alarmCount = alarmCount + 1
!print *, 'alarm IS ringing at forwards timestep', i
call ESMF_AlarmRingerOff (alarm1, rc=rc)
else
!print *, 'alarm not ringing at forwards timestep', i
end if
end do
!print *, 'SETTING CLOCK BACKWARDS WITH NEGATIVE TIMESTEP'
timeStep = -timeStep
call ESMF_ClockSet (clock, timeStep=timeStep, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
do, i=5, -5, -1
call ESMF_ClockAdvance (clock, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (ESMF_alarmIsRinging (alarm1)) then
alarmCount = alarmCount + 1
!print *, 'alarm IS ringing at backwards timestep', i, ', time:'
!call ESMF_ClockPrint (clock, options="currTime string")
call ESMF_AlarmRingerOff (alarm1, rc=rc)
else
!print *, 'alarm not ringing at backwards timestep', i
!call ESMF_ClockPrint (clock, options="currTime string")
end if
end do
if (.not. testPass .or. alarmCount /= expectedCount) then
if (.not. testPass) print *, 'bad return codes discovered'
write (failMsg,*) trim (failMsg), ', alarmCount = ', alarmCount, ', expected = ', expectedCount
print *, 'The alarm ringTime may be stuck at:'
call ESMF_AlarmPrint (alarm1, options="ringTime string", rc=rc)
end if
call ESMF_Test (testPass .and. alarmCount == expectedCount, &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy (alarm1, rc=rc)
call ESMF_ClockDestroy (clock, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm ringTime increment, first forwards a fixed number of
!timesteps, stopping at a non-alarm ringing time step. Using a negative
!timestemp, step backwards to some time prior to the clock's startTime.
!Count number of rings. See bugs #1531948, #1457135.
write(failMsg, *) " Did not ring enough times during forward/backward march"
write(name, *) "Test forward to a non-ringing step, then step backward using a negative timeStep"
testPass = .true.
call ESMF_TimeSet (startTime, yy=2008, mm=1, dd=23, h=0, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet (timeStep, h=3, rc=rc)
clock = ESMF_ClockCreate(startTime = startTime, timeStep=timeStep, &
name="clock 1", rc=rc)
if (rc /= ESMF_SUCCESS) testPass = .false.
call ESMF_TimeSet (alarmTime, yy=2008, mm=1, dd=23, h=6, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet (alarmStep, h=6, rc=rc)
alarm1 = ESMF_AlarmCreate ( &
name="Alarm 1", clock=clock, &
ringTime=alarmTime, ringInterval=alarmStep, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
alarmCount = 0
expectedCount = 9
do, i=1,7
call ESMF_ClockAdvance (clock, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (ESMF_alarmIsRinging (alarm1)) then
alarmCount = alarmCount + 1
!print *, 'alarm IS ringing at forwards timestep', i
call ESMF_AlarmRingerOff (alarm1, rc=rc)
else
!print *, 'alarm not ringing at forwards timestep', i
end if
end do
!print *, 'SETTING CLOCK BACKWARDS WITH NEGATIVE TIMESTEP'
timeStep = -timeStep
call ESMF_ClockSet (clock, timeStep=timeStep, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
do, i=6, -5, -1
call ESMF_ClockAdvance (clock, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (ESMF_alarmIsRinging (alarm1)) then
alarmCount = alarmCount + 1
!print *, 'alarm IS ringing at backwards timestep', i, ', time:'
!call ESMF_ClockPrint (clock, options="currTime string")
call ESMF_AlarmRingerOff (alarm1, rc=rc)
else
!print *, 'alarm not ringing at backwards timestep', i
!call ESMF_ClockPrint (clock, options="currTime string")
end if
end do
if (.not. testPass .or. alarmCount /= expectedCount) then
if (.not. testPass) print *, 'bad return codes discovered'
write (failMsg,*) trim (failMsg), ', alarmCount = ', alarmCount, ', expected = ', expectedCount
print *, 'The alarm ringTime may be stuck at:'
call ESMF_AlarmPrint (alarm1, options="ringTime string", rc=rc)
end if
call ESMF_Test (testPass .and. alarmCount == expectedCount, &
name, failMsg, result, ESMF_SRCLINE)
!
! ----------------------------------------------------------------------------
!EX_UTest
write(failMsg, *) " Did not show null clock in alarm"
write(name, *) "Test alarm after destroying its associated clock"
call ESMF_ClockDestroy (clock, rc=rc)
willRingNext = ESMF_AlarmWillRingNext(alarm1, rc=rc)
call ESMF_Test (rc==ESMC_RC_PTR_NULL .and. .not.willRingNext, &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy (alarm1, rc=rc)
! ----------------------------------------------------------------------------
!EX_UTest
!Test Alarm ringTime increment, arbitrarily forwards and backwards using
! positive and negative timesteps. Alarm ringTime and ringInterval are
! changed with each change in timestep direction. The extent of the run
! of each timestep value is different with each change in direction.
write(failMsg, *) " Did not ring enough times during arbitrary forward/backward march"
write(name, *) "Test arbitrary positive/negative timeStep runs with differing alarms"
testPass = .true.
alarmCountPass = .true.
call ESMF_TimeSet (startTime, yy=2008, mm=1, dd=23, h=0, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet (timeStep, h=1, rc=rc)
clock = ESMF_ClockCreate(startTime=startTime, timeStep=timeStep, &
name="clock 1", rc=rc)
if (rc /= ESMF_SUCCESS) testPass = .false.
call ESMF_TimeSet (alarmTime, yy=2008, mm=1, dd=23, h=2, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet (alarmStep, h=2, rc=rc)
alarm1 = ESMF_AlarmCreate ( &
name="Alarm 1", clock=clock, &
ringTime=alarmTime, ringInterval=alarmStep, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
alarmCount = 0
expectedCount = 15
do, i=1,7
call ESMF_ClockAdvance (clock, rc=rc)
!call ESMF_ClockPrint (clock, options="currTime string", rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (ESMF_alarmIsRinging (alarm1)) then
alarmCount = alarmCount + 1
!print *, 'alarm IS ringing at forwards timestep', i
call ESMF_AlarmRingerOff (alarm1, rc=rc)
else
!print *, 'alarm not ringing at forwards timestep', i
end if
end do
if (alarmCountPass .and. alarmCount /= 3) then
alarmCountPass = .false.
!print *, 'alarmCount = ', alarmCount, ' not 3 at 1st turnaround point'
end if
!print *, 'SETTING CLOCK BACKWARDS WITH NEW NEGATIVE TIMESTEP AND RINGINTERVAL'
timeStep = -2 * timeStep
alarmStep = -2 * alarmStep
call ESMF_ClockSet (clock, timeStep=timeStep, rc=rc)
call ESMF_AlarmSet (alarm1, ringInterval=alarmStep, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
do, i=6, -5, -1
call ESMF_ClockAdvance (clock, rc=rc)
!call ESMF_ClockPrint (clock, options="currTime string", rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (ESMF_alarmIsRinging (alarm1)) then
alarmCount = alarmCount + 1
!print *, 'alarm IS ringing at backwards timestep', i
call ESMF_AlarmRingerOff (alarm1, rc=rc)
else
!print *, 'alarm not ringing at backwards timestep', i
end if
end do
if (alarmCountPass .and. alarmCount /= 9) then
alarmCountPass = .false.
!print *, 'alarmCount = ', alarmCount, ' not 9 at 2nd turnaround point'
end if
!print *, 'SETTING CLOCK FORWARDS WITH NEW POSITIVE TIMESTEP, RINGINTERVAL, and RINGTIME'
call ESMF_TimeIntervalSet (timeStep, h=3, rc=rc)
call ESMF_TimeSet (alarmTime, yy=2008, mm=1, dd=22, h=11, &
calendar=gregorianCalendar, rc=rc)
call ESMF_TimeIntervalSet (alarmStep, h=6, rc=rc)
call ESMF_ClockSet (clock, timeStep=timeStep, rc=rc)
call ESMF_AlarmSet (alarm1, ringTime=alarmTime, ringInterval=alarmStep, &
rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
do, i=1,5
call ESMF_ClockAdvance (clock, rc=rc)
!call ESMF_ClockPrint (clock, options="currTime string", rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (ESMF_alarmIsRinging (alarm1)) then
alarmCount = alarmCount + 1
!print *, 'alarm IS ringing at forwards timestep', i
call ESMF_AlarmRingerOff (alarm1, rc=rc)
else
!print *, 'alarm not ringing at forwards timestep', i
end if
end do
if (alarmCountPass .and. alarmCount /= 11) then
alarmCountPass = .false.
!print *, 'alarmCount = ', alarmCount, ' not 11 at 3rd turnaround point'
end if
!print *, 'SETTING CLOCK BACKWARDS WITH NEW NEGATIVE TIMESTEP AND RINGTIME'
call ESMF_TimeIntervalSet (timeStep, h=-1, rc=rc)
call ESMF_TimeSet (alarmTime, yy=2008, mm=1, dd=22, h=21, &
calendar=gregorianCalendar, rc=rc)
call ESMF_ClockSet (clock, timeStep=timeStep, rc=rc)
call ESMF_AlarmSet (alarm1, ringTime=alarmTime, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
do, i=4,2,-1
call ESMF_ClockAdvance (clock, rc=rc)
!call ESMF_ClockPrint (clock, options="currTime string", rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (ESMF_alarmIsRinging (alarm1)) then
alarmCount = alarmCount + 1
!print *, 'alarm IS ringing at backwards timestep', i
call ESMF_AlarmRingerOff (alarm1, rc=rc)
else
!print *, 'alarm not ringing at backwards timestep', i
end if
end do
if (alarmCountPass .and. alarmCount /= 12) then
alarmCountPass = .false.
!print *, 'alarmCount = ', alarmCount, ' not 12 at 4th turnaround point'
end if
!print *, 'SETTING CLOCK FORWARDS WITH NEW POSITIVE TIMESTEP'
timeStep = -timeStep
call ESMF_ClockGet(clock, currTime=startTime, rc=rc)
call ESMF_ClockSet(clock, timeStep=timeStep, startTime=startTime, &
runTimeStepCount=15, rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
do while (.not. ESMF_ClockIsDone(clock, rc=rc))
call ESMF_ClockAdvance (clock, rc=rc)
!call ESMF_ClockPrint (clock, options="currTime string", rc=rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (ESMF_alarmIsRinging (alarm1)) then
alarmCount = alarmCount + 1
!print *, 'alarm IS ringing'
call ESMF_AlarmRingerOff (alarm1, rc=rc)
else
!print *, 'alarm not ringing'
end if
end do
if (alarmCountPass .and. alarmCount /= expectedCount) then
alarmCountPass = .false.
!print *, 'alarmCount = ', alarmCount, ', not ', expectedCount, ' at the end'
end if
if (.not. alarmCountPass) then
write(failMsg,*) trim(failMsg), ', alarmCount incorrect at one or more turnaround points'
!print *, 'Final alarmCount = ', alarmCount, ', expected = ', expectedCount
!print *, 'Final alarm ringTime:'
!call ESMF_AlarmPrint (alarm1, "ringTime string", rc=rc)
end if
if (.not. testPass) print *, 'bad return codes discovered'
call ESMF_Test (testPass .and. alarmCountPass, &
name, failMsg, result, ESMF_SRCLINE)
call ESMF_AlarmDestroy (alarm1, rc=rc)
call ESMF_ClockDestroy (clock, rc=rc)
! ----------------------------------------------------------------------------
#if 0
! The following tests are from Ben@NASA's support ticket 3614994
write(failMsg, *) " Alarms did not rewind correct number of times "
write(name, *) "Test multiple alarms rewind correct number of times "
rc = ESMF_SUCCESS
testPass = .true.
call Test_ReverseAlarms(testPass, rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (.not. testPass) print *, 'bad return codes discovered'
call ESMF_Test (testPass, name, failMsg, result, ESMF_SRCLINE)
! ----------------------------------------------------------------------------
write(failMsg, *) " Alarms hang... "
write(name, *) "Test multiple alarms replay without hanging "
rc = ESMF_SUCCESS
testPass = .true.
call Test_AlarmHang(testPass, rc)
if (testPass .and. rc /= ESMF_SUCCESS) testPass = .false.
if (.not. testPass) print *, 'bad return codes discovered'
call ESMF_Test (testPass, name, failMsg, result, ESMF_SRCLINE)
#endif
! ----------------------------------------------------------------------------
#endif
! destroy calendars
call ESMF_CalendarDestroy(esmf_360dayCalendar, rc=rc)
call ESMF_CalendarDestroy(no_leapCalendar, rc=rc)
call ESMF_CalendarDestroy(julianCalendar, rc=rc)
call ESMF_CalendarDestroy(gregorianCalendar, rc=rc)
! finalize ESMF framework
call ESMF_TestEnd(ESMF_SRCLINE)
#if 0
contains
subroutine test_reverseAlarms(testPass, rc)
implicit none
logical, intent(out) :: testPass
integer :: status,rc
type(ESMF_TimeInterval) :: dt
type(ESMF_Time) :: start_time, clock_start, clock_end
type(ESMF_Clock) :: clock
character(len=5) :: add_2nd
integer :: nargs
type(ESMF_TimeInterval) :: tint
type(ESMF_Alarm) :: esmfalarm, firstalarm
integer :: i,nstep
type(ESMF_Time) :: time
character(len=10) :: iam='test_clock'
logical :: esmf_ring
integer :: nalarms, n_rings=0
testPass = .false.
call ESMF_CalendarSetDefault ( ESMF_CALKIND_GREGORIAN, rc=status )
call verify_(status)
call ESMF_TimeSet(clock_start,yy=2000,mm=1,dd=1,h=21,m=0,s=0,rc=status)
call verify_(status)
call ESMF_TimeSet(clock_end,yy=2000,mm=12,dd=1,h=21,m=0,s=0,rc=status)
call verify_(status)
call ESMF_TimeSet(start_time,yy=2000,mm=10,dd=1,h=21,m=0,s=0,rc=status)
call verify_(status)
call ESMF_TimeIntervalSet(dt,S=900, sN=0, sD=1,rc=status)
call verify_(status)
clock= ESMF_ClockCreate(timeStep=dt,startTime=clock_start,stopTime=clock_end,rc=status)
call verify_(status)
call ESMF_ClockSet(clock,currTime=start_time,rc=status)
call verify_(status)
call ESMF_ClockGet(clock,currtime=start_time,rc=status)
if(status /= ESMF_SUCCESS) call ESMF_Finalize()
call ESMF_TimeIntervalSet(tint,h=2,rc=status)
if(status /= ESMF_SUCCESS) call ESMF_Finalize()
firstalarm = ESMF_AlarmCreate(clock=clock,ringInterval=tint,ringTime=start_time,sticky=.false.,name="alarm1",rc=status)
if(status /= ESMF_SUCCESS) call ESMF_Finalize()
nstep=47
call ESMF_ClockGet(clock,currtime=start_time,alarmCount=nalarms,rc=status)
!write(*,*) "alarms already in clock: ",nalarms
call verify_(status)
call ESMF_TimeIntervalSet(tint,h=1,rc=status)
call verify_(status)
esmfalarm = ESMF_AlarmCreate(clock=clock,ringInterval=tint,ringTime=start_time,sticky=.false.,name="alarm2",rc=status)
do i=1,nstep
call ESMF_ClockGet(clock,currTime=time)
esmf_ring = ESMF_AlarmIsRinging(esmfalarm,rc=status)
call verify_(status)
if ( esmf_ring) then
!write(*,*)'ringing'
!call ESMF_TimePrint(time,options='string')
end if
call ESMF_ClockAdvance(clock)
enddo
call ESMF_ClockSet(clock, direction=ESMF_DIRECTION_REVERSE, rc=status)
call verify_(status)
!write(*,*)"*************** start rewind *********************"
i = 0
do
i = i + 1
!write(*,*) 'Rewind step: ', i
call ESMF_ClockAdvance(clock,rc=status)
call verify_(status)
call ESMF_ClockGet(clock,currTime=time)
if (ESMF_AlarmIsRinging(esmfalarm)) then
!write(*,*)'rewinding one step ',ESMF_AlarmIsRinging(esmfalarm)
n_rings = n_rings + 1
!call ESMF_TimePrint(time,options='string')
end if
if (time == start_time) exit
enddo
call ESMF_ClockSet(clock, direction=ESMF_DIRECTION_FORWARD, rc=status)
call verify_(status)
!write(*,*)"*************** end rewind *********************"
do i=1,nstep*2
call ESMF_ClockGet(clock,currTime=time)
esmf_ring = ESMF_AlarmIsRinging(esmfalarm,rc=status)
call verify_(status)
if ( esmf_ring ) then
!write(*,*)'ringing'
!call ESMF_TimePrint(time,options='string')
end if
call ESMF_ClockAdvance(clock)
enddo
if(n_rings == 12) testPass = .true.
call ESMF_AlarmDestroy(esmfalarm, rc=status)
call verify_(status)
call ESMF_AlarmDestroy(firstalarm, rc=status)
call verify_(status)
call ESMF_ClockDestroy(clock, rc=status)
call verify_(status)
end subroutine Test_ReverseAlarms
subroutine Test_AlarmHang(testPass, rc)
logical, intent(out) :: testPass
integer :: status,rc
type(ESMF_TimeInterval) :: dt
type(ESMF_Time) :: start_time, clock_start, clock_end
type(ESMF_Clock) :: clock
character(len=5) :: add_2nd
integer :: nargs
integer :: i,nstep
type(ESMF_TimeInterval) :: tint
type(ESMF_Time) :: time
type(ESMF_Alarm) :: esmfalarm
type(ESMF_Alarm) :: testalarm
character(len=10) :: iam='test_clock'
logical :: esmf_ring
integer :: nalarms
testPass = .false.
call ESMF_CalendarSetDefault ( ESMF_CALKIND_GREGORIAN, rc=status )
call verify_(status)
call ESMF_TimeSet(clock_start,yy=2000,mm=1,dd=1,h=21,m=0,s=0,rc=status)
call verify_(status)
call ESMF_TimeSet(clock_end,yy=2000,mm=12,dd=1,h=21,m=0,s=0,rc=status)
call verify_(status)
call ESMF_TimeSet(start_time,yy=2000,mm=10,dd=1,h=21,m=0,s=0,rc=status)
call verify_(status)
call ESMF_TimeIntervalSet(dt,S=900, sN=0, sD=1,rc=status)
call verify_(status)
clock= ESMF_ClockCreate(timeStep=dt,startTime=clock_start,stopTime=clock_end,rc=status)
call verify_(status)
call ESMF_ClockSet(clock,currTime=start_time,rc=status)
call verify_(status)
nstep = 12
call ESMF_ClockGet(clock,currtime=start_time,alarmCount=nalarms,rc=status)
!write(*,*) "alarms already in clock: ",nalarms
call verify_(status)
call ESMF_TimeIntervalSet(tint,h=1,rc=status)
call verify_(status)
esmfalarm = ESMF_AlarmCreate(clock=clock,ringInterval=tint,ringTime=start_time,sticky=.false.,name="alarm2",rc=status)
!call ESMF_TimeIntervalSet(tint,h=3,rc=status)
!testalarm = ESMF_AlarmCreate(clock=clock,name="alarm3",ringInterval=tint, ringtime=start_time,sticky=.true.,rc=status)
testalarm = ESMF_AlarmCreate(clock=clock,name="alarm3",ringtime=start_time,sticky=.true.,rc=status)
call verify_(status)
call ESMF_AlarmRingerOff(testalarm,rc=status)
call verify_(status)
do i=1,nstep
call ESMF_AlarmRingerOn(testalarm,rc=status)
call verify_(status)
call ESMF_ClockGet(clock,currTime=time)
esmf_ring = ESMF_AlarmIsRinging(esmfalarm,rc=status)
call verify_(status)
if ( esmf_ring) then
!write(*,*)'ringing: esmfalarm'
call ESMF_TimePrint(time,options='string')
end if
call ESMF_ClockAdvance(clock)
enddo
call ESMF_ClockSet(clock, direction=ESMF_DIRECTION_REVERSE, rc=status)
call verify_(status)
call ESMF_AlarmRingerOff(testalarm,rc=status)
call verify_(status)
!write(*,*)"*************** start rewind *********************"
do
call ESMF_ClockAdvance(clock,rc=status)
call verify_(status)
call ESMF_ClockGet(clock,currTime=time)
if (ESMF_AlarmIsRinging(esmfalarm)) then
!write(*,*)'rewinding one step: esmfalarm ',ESMF_AlarmIsRinging(esmfalarm)
call ESMF_TimePrint(time,options='string')
end if
if (ESMF_AlarmIsRinging(esmfalarm)) then
write(*,*)'rewinding one step: testalarm ',ESMF_AlarmIsRinging(testalarm)
call ESMF_TimePrint(time,options='string')
end if
if (time == start_time) exit
enddo
call ESMF_ClockSet(clock, direction=ESMF_DIRECTION_FORWARD, rc=status)
call verify_(status)
!write(*,*)"*************** end rewind *********************"
do i=1,nstep*2
call ESMF_ClockGet(clock,currTime=time)
esmf_ring = ESMF_AlarmIsRinging(esmfalarm,rc=status)
call verify_(status)
if ( esmf_ring ) then
!write(*,*)'ringing: esmfalarm'
call ESMF_TimePrint(time,options='string')
end if
call ESMF_ClockAdvance(clock)
enddo
call ESMF_AlarmDestroy(esmfalarm, rc=status)
call verify_(status)
call ESMF_AlarmDestroy(testalarm, rc=status)
call verify_(status)
call ESMF_ClockDestroy(clock, rc=status)
call verify_(status)
testPass = .true.
end subroutine Test_AlarmHang
#endif
end program ESMF_AlarmTest