! $Id$
!
! Earth System Modeling Framework
! Copyright (c) 2002-2023, University Corporation for Atmospheric Research,
! Massachusetts Institute of Technology, Geophysical Fluid Dynamics
! Laboratory, University of Michigan, National Centers for Environmental
! Prediction, Los Alamos National Laboratory, Argonne National Laboratory,
! NASA Goddard Space Flight Center.
! Licensed under the University of Illinois-NCSA License.
!
!==============================================================================
!
program ESMF_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
